1	// SPDX-License-Identifier: GPL-2.0+
2	//
3	// soc-core.c -- ALSA SoC Audio Layer
4	//
5	// Copyright 2005 Wolfson Microelectronics PLC.
6	// Copyright 2005 Openedhand Ltd.
7	// Copyright (C) 2010 Slimlogic Ltd.
8	// Copyright (C) 2010 Texas Instruments Inc.
9	//
10	// Author: Liam Girdwood <lrg@slimlogic.co.uk>
11	// with code, comments and ideas from :-
12	// Richard Purdie <richard@openedhand.com>
13	//
14	// TODO:
15	// o Add hw rules to enforce rates, etc.
16	// o More testing with other codecs/machines.
17	// o Add more codecs and platforms to ensure good API coverage.
18	// o Support TDM on PCM and I2S
19
20	#include <linux/module.h>
21	#include <linux/moduleparam.h>
22	#include <linux/init.h>
23	#include <linux/delay.h>
24	#include <linux/pm.h>
25	#include <linux/bitops.h>
26	#include <linux/debugfs.h>
27	#include <linux/platform_device.h>
28	#include <linux/pinctrl/consumer.h>
29	#include <linux/ctype.h>
30	#include <linux/slab.h>
31	#include <linux/of.h>
32	#include <linux/of_graph.h>
33	#include <linux/dmi.h>
34	#include <linux/acpi.h>
35	#include <sound/core.h>
36	#include <sound/pcm.h>
37	#include <sound/pcm_params.h>
38	#include <sound/soc.h>
39	#include <sound/soc-dpcm.h>
40	#include <sound/soc-topology.h>
41	#include <sound/soc-link.h>
42	#include <sound/initval.h>
43
44	#define CREATE_TRACE_POINTS
45	#include <trace/events/asoc.h>
46
47	static DEFINE_MUTEX(client_mutex);
48	static LIST_HEAD(component_list);
49	static LIST_HEAD(unbind_card_list);
50
51	#define for_each_component(component) \
52	list_for_each_entry(component, &component_list, list)
53
54	/*
55	* This is used if driver don't need to have CPU/Codec/Platform
56	* dai_link. see soc.h
57	*/
58	struct snd_soc_dai_link_component null_dailink_component[0];
59	EXPORT_SYMBOL_GPL(null_dailink_component);
60
61	/*
62	* This is a timeout to do a DAPM powerdown after a stream is closed().
63	* It can be used to eliminate pops between different playback streams, e.g.
64	* between two audio tracks.
65	*/
66	static int pmdown_time = 5000;
67	module_param(pmdown_time, int, 0);
68	MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
69
70	static ssize_t pmdown_time_show(struct device *dev,
71	struct device_attribute *attr, char *buf)
72	{
73	struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
74
75	return sysfs_emit(buf, fmt: "%ld\n", rtd->pmdown_time);
76	}
77
78	static ssize_t pmdown_time_store(struct device *dev,
79	struct device_attribute *attr,
80	const char *buf, size_t count)
81	{
82	struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
83	int ret;
84
85	ret = kstrtol(s: buf, base: 10, res: &rtd->pmdown_time);
86	if (ret)
87	return ret;
88
89	return count;
90	}
91
92	static DEVICE_ATTR_RW(pmdown_time);
93
94	static struct attribute *soc_dev_attrs[] = {
95	&dev_attr_pmdown_time.attr,
96	NULL
97	};
98
99	static umode_t soc_dev_attr_is_visible(struct kobject *kobj,
100	struct attribute *attr, int idx)
101	{
102	struct device *dev = kobj_to_dev(kobj);
103	struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
104
105	if (!rtd)
106	return 0;
107
108	if (attr == &dev_attr_pmdown_time.attr)
109	return attr->mode; /* always visible */
110	return rtd->dai_link->num_codecs ? attr->mode : 0; /* enabled only with codec */
111	}
112
113	static const struct attribute_group soc_dapm_dev_group = {
114	.attrs = soc_dapm_dev_attrs,
115	.is_visible = soc_dev_attr_is_visible,
116	};
117
118	static const struct attribute_group soc_dev_group = {
119	.attrs = soc_dev_attrs,
120	.is_visible = soc_dev_attr_is_visible,
121	};
122
123	static const struct attribute_group *soc_dev_attr_groups[] = {
124	&soc_dapm_dev_group,
125	&soc_dev_group,
126	NULL
127	};
128
129	#ifdef CONFIG_DEBUG_FS
130	struct dentry *snd_soc_debugfs_root;
131	EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
132
133	static void soc_init_component_debugfs(struct snd_soc_component *component)
134	{
135	if (!component->card->debugfs_card_root)
136	return;
137
138	if (component->debugfs_prefix) {
139	char *name;
140
141	name = kasprintf(GFP_KERNEL, fmt: "%s:%s",
142	component->debugfs_prefix, component->name);
143	if (name) {
144	component->debugfs_root = debugfs_create_dir(name,
145	parent: component->card->debugfs_card_root);
146	kfree(objp: name);
147	}
148	} else {
149	component->debugfs_root = debugfs_create_dir(name: component->name,
150	parent: component->card->debugfs_card_root);
151	}
152
153	snd_soc_dapm_debugfs_init(dapm: snd_soc_component_get_dapm(component),
154	parent: component->debugfs_root);
155	}
156
157	static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
158	{
159	if (!component->debugfs_root)
160	return;
161	debugfs_remove_recursive(dentry: component->debugfs_root);
162	component->debugfs_root = NULL;
163	}
164
165	static int dai_list_show(struct seq_file *m, void *v)
166	{
167	struct snd_soc_component *component;
168	struct snd_soc_dai *dai;
169
170	mutex_lock(&client_mutex);
171
172	for_each_component(component)
173	for_each_component_dais(component, dai)
174	seq_printf(m, fmt: "%s\n", dai->name);
175
176	mutex_unlock(lock: &client_mutex);
177
178	return 0;
179	}
180	DEFINE_SHOW_ATTRIBUTE(dai_list);
181
182	static int component_list_show(struct seq_file *m, void *v)
183	{
184	struct snd_soc_component *component;
185
186	mutex_lock(&client_mutex);
187
188	for_each_component(component)
189	seq_printf(m, fmt: "%s\n", component->name);
190
191	mutex_unlock(lock: &client_mutex);
192
193	return 0;
194	}
195	DEFINE_SHOW_ATTRIBUTE(component_list);
196
197	static void soc_init_card_debugfs(struct snd_soc_card *card)
198	{
199	card->debugfs_card_root = debugfs_create_dir(name: card->name,
200	parent: snd_soc_debugfs_root);
201
202	debugfs_create_u32(name: "dapm_pop_time", mode: 0644, parent: card->debugfs_card_root,
203	value: &card->pop_time);
204
205	snd_soc_dapm_debugfs_init(dapm: &card->dapm, parent: card->debugfs_card_root);
206	}
207
208	static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
209	{
210	debugfs_remove_recursive(dentry: card->debugfs_card_root);
211	card->debugfs_card_root = NULL;
212	}
213
214	static void snd_soc_debugfs_init(void)
215	{
216	snd_soc_debugfs_root = debugfs_create_dir(name: "asoc", NULL);
217
218	debugfs_create_file(name: "dais", mode: 0444, parent: snd_soc_debugfs_root, NULL,
219	fops: &dai_list_fops);
220
221	debugfs_create_file(name: "components", mode: 0444, parent: snd_soc_debugfs_root, NULL,
222	fops: &component_list_fops);
223	}
224
225	static void snd_soc_debugfs_exit(void)
226	{
227	debugfs_remove_recursive(dentry: snd_soc_debugfs_root);
228	}
229
230	#else
231
232	static inline void soc_init_component_debugfs(struct snd_soc_component *component) { }
233	static inline void soc_cleanup_component_debugfs(struct snd_soc_component *component) { }
234	static inline void soc_init_card_debugfs(struct snd_soc_card *card) { }
235	static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card) { }
236	static inline void snd_soc_debugfs_init(void) { }
237	static inline void snd_soc_debugfs_exit(void) { }
238
239	#endif
240
241	static int snd_soc_is_match_dai_args(struct of_phandle_args *args1,
242	struct of_phandle_args *args2)
243	{
244	if (!args1 || !args2)
245	return 0;
246
247	if (args1->np != args2->np)
248	return 0;
249
250	for (int i = 0; i < args1->args_count; i++)
251	if (args1->args[i] != args2->args[i])
252	return 0;
253
254	return 1;
255	}
256
257	static inline int snd_soc_dlc_component_is_empty(struct snd_soc_dai_link_component *dlc)
258	{
259	return !(dlc->dai_args || dlc->name || dlc->of_node);
260	}
261
262	static inline int snd_soc_dlc_component_is_invalid(struct snd_soc_dai_link_component *dlc)
263	{
264	return (dlc->name && dlc->of_node);
265	}
266
267	static inline int snd_soc_dlc_dai_is_empty(struct snd_soc_dai_link_component *dlc)
268	{
269	return !(dlc->dai_args || dlc->dai_name);
270	}
271
272	static int snd_soc_is_matching_dai(const struct snd_soc_dai_link_component *dlc,
273	struct snd_soc_dai *dai)
274	{
275	if (!dlc)
276	return 0;
277
278	if (dlc->dai_args)
279	return snd_soc_is_match_dai_args(args1: dai->driver->dai_args, args2: dlc->dai_args);
280
281	if (!dlc->dai_name)
282	return 1;
283
284	/* see snd_soc_dai_name_get() */
285
286	if (strcmp(dlc->dai_name, dai->name) == 0)
287	return 1;
288
289	if (dai->driver->name &&
290	strcmp(dai->driver->name, dlc->dai_name) == 0)
291	return 1;
292
293	if (dai->component->name &&
294	strcmp(dlc->dai_name, dai->component->name) == 0)
295	return 1;
296
297	return 0;
298	}
299
300	const char *snd_soc_dai_name_get(struct snd_soc_dai *dai)
301	{
302	/* see snd_soc_is_matching_dai() */
303	if (dai->name)
304	return dai->name;
305
306	if (dai->driver->name)
307	return dai->driver->name;
308
309	if (dai->component->name)
310	return dai->component->name;
311
312	return NULL;
313	}
314	EXPORT_SYMBOL_GPL(snd_soc_dai_name_get);
315
316	static int snd_soc_rtd_add_component(struct snd_soc_pcm_runtime *rtd,
317	struct snd_soc_component *component)
318	{
319	struct snd_soc_component *comp;
320	int i;
321
322	for_each_rtd_components(rtd, i, comp) {
323	/* already connected */
324	if (comp == component)
325	return 0;
326	}
327
328	/* see for_each_rtd_components */
329	rtd->components[rtd->num_components] = component;
330	rtd->num_components++;
331
332	return 0;
333	}
334
335	struct snd_soc_component *snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
336	const char *driver_name)
337	{
338	struct snd_soc_component *component;
339	int i;
340
341	if (!driver_name)
342	return NULL;
343
344	/*
345	* NOTE
346	*
347	* snd_soc_rtdcom_lookup() will find component from rtd by using
348	* specified driver name.
349	* But, if many components which have same driver name are connected
350	* to 1 rtd, this function will return 1st found component.
351	*/
352	for_each_rtd_components(rtd, i, component) {
353	const char *component_name = component->driver->name;
354
355	if (!component_name)
356	continue;
357
358	if ((component_name == driver_name) ||
359	strcmp(component_name, driver_name) == 0)
360	return component;
361	}
362
363	return NULL;
364	}
365	EXPORT_SYMBOL_GPL(snd_soc_rtdcom_lookup);
366
367	struct snd_soc_component
368	*snd_soc_lookup_component_nolocked(struct device *dev, const char *driver_name)
369	{
370	struct snd_soc_component *component;
371	struct snd_soc_component *found_component;
372
373	found_component = NULL;
374	for_each_component(component) {
375	if ((dev == component->dev) &&
376	(!driver_name ||
377	(driver_name == component->driver->name) ||
378	(strcmp(component->driver->name, driver_name) == 0))) {
379	found_component = component;
380	break;
381	}
382	}
383
384	return found_component;
385	}
386	EXPORT_SYMBOL_GPL(snd_soc_lookup_component_nolocked);
387
388	struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
389	const char *driver_name)
390	{
391	struct snd_soc_component *component;
392
393	mutex_lock(&client_mutex);
394	component = snd_soc_lookup_component_nolocked(dev, driver_name);
395	mutex_unlock(lock: &client_mutex);
396
397	return component;
398	}
399	EXPORT_SYMBOL_GPL(snd_soc_lookup_component);
400
401	struct snd_soc_pcm_runtime
402	*snd_soc_get_pcm_runtime(struct snd_soc_card *card,
403	struct snd_soc_dai_link *dai_link)
404	{
405	struct snd_soc_pcm_runtime *rtd;
406
407	for_each_card_rtds(card, rtd) {
408	if (rtd->dai_link == dai_link)
409	return rtd;
410	}
411	dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link->name);
412	return NULL;
413	}
414	EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
415
416	/*
417	* Power down the audio subsystem pmdown_time msecs after close is called.
418	* This is to ensure there are no pops or clicks in between any music tracks
419	* due to DAPM power cycling.
420	*/
421	void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd)
422	{
423	struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
424	int playback = SNDRV_PCM_STREAM_PLAYBACK;
425
426	snd_soc_dpcm_mutex_lock(rtd);
427
428	dev_dbg(rtd->dev,
429	"ASoC: pop wq checking: %s status: %s waiting: %s\n",
430	codec_dai->driver->playback.stream_name,
431	snd_soc_dai_stream_active(codec_dai, playback) ?
432	"active" : "inactive",
433	rtd->pop_wait ? "yes" : "no");
434
435	/* are we waiting on this codec DAI stream */
436	if (rtd->pop_wait == 1) {
437	rtd->pop_wait = 0;
438	snd_soc_dapm_stream_event(rtd, stream: playback,
439	SND_SOC_DAPM_STREAM_STOP);
440	}
441
442	snd_soc_dpcm_mutex_unlock(rtd);
443	}
444	EXPORT_SYMBOL_GPL(snd_soc_close_delayed_work);
445
446	static void soc_release_rtd_dev(struct device *dev)
447	{
448	/* "dev" means "rtd->dev" */
449	kfree(objp: dev);
450	}
451
452	static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
453	{
454	if (!rtd)
455	return;
456
457	list_del(entry: &rtd->list);
458
459	if (delayed_work_pending(&rtd->delayed_work))
460	flush_delayed_work(dwork: &rtd->delayed_work);
461	snd_soc_pcm_component_free(rtd);
462
463	/*
464	* we don't need to call kfree() for rtd->dev
465	* see
466	* soc_release_rtd_dev()
467	*
468	* We don't need rtd->dev NULL check, because
469	* it is alloced *before* rtd.
470	* see
471	* soc_new_pcm_runtime()
472	*
473	* We don't need to mind freeing for rtd,
474	* because it was created from dev (= rtd->dev)
475	* see
476	* soc_new_pcm_runtime()
477	*
478	* rtd = devm_kzalloc(dev, ...);
479	* rtd->dev = dev
480	*/
481	device_unregister(dev: rtd->dev);
482	}
483
484	static void close_delayed_work(struct work_struct *work) {
485	struct snd_soc_pcm_runtime *rtd =
486	container_of(work, struct snd_soc_pcm_runtime,
487	delayed_work.work);
488
489	if (rtd->close_delayed_work_func)
490	rtd->close_delayed_work_func(rtd);
491	}
492
493	static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
494	struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
495	{
496	struct snd_soc_pcm_runtime *rtd;
497	struct snd_soc_component *component;
498	struct device *dev;
499	int ret;
500	int stream;
501
502	/*
503	* for rtd->dev
504	*/
505	dev = kzalloc(size: sizeof(struct device), GFP_KERNEL);
506	if (!dev)
507	return NULL;
508
509	dev->parent = card->dev;
510	dev->release = soc_release_rtd_dev;
511
512	dev_set_name(dev, name: "%s", dai_link->name);
513
514	ret = device_register(dev);
515	if (ret < 0) {
516	put_device(dev); /* soc_release_rtd_dev */
517	return NULL;
518	}
519
520	/*
521	* for rtd
522	*/
523	rtd = devm_kzalloc(dev,
524	size: sizeof(*rtd) +
525	sizeof(component) * (dai_link->num_cpus +
526	dai_link->num_codecs +
527	dai_link->num_platforms),
528	GFP_KERNEL);
529	if (!rtd) {
530	device_unregister(dev);
531	return NULL;
532	}
533
534	rtd->dev = dev;
535	INIT_LIST_HEAD(list: &rtd->list);
536	for_each_pcm_streams(stream) {
537	INIT_LIST_HEAD(list: &rtd->dpcm[stream].be_clients);
538	INIT_LIST_HEAD(list: &rtd->dpcm[stream].fe_clients);
539	}
540	dev_set_drvdata(dev, data: rtd);
541	INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
542
543	/*
544	* for rtd->dais
545	*/
546	rtd->dais = devm_kcalloc(dev, n: dai_link->num_cpus + dai_link->num_codecs,
547	size: sizeof(struct snd_soc_dai *),
548	GFP_KERNEL);
549	if (!rtd->dais)
550	goto free_rtd;
551
552	/*
553	* dais = [][][][][][][][][][][][][][][][][][]
554	* ^cpu_dais ^codec_dais
555	* |--- num_cpus ---|--- num_codecs --|
556	* see
557	* snd_soc_rtd_to_cpu()
558	* snd_soc_rtd_to_codec()
559	*/
560	rtd->card = card;
561	rtd->dai_link = dai_link;
562	rtd->num = card->num_rtd++;
563	rtd->pmdown_time = pmdown_time; /* default power off timeout */
564
565	/* see for_each_card_rtds */
566	list_add_tail(new: &rtd->list, head: &card->rtd_list);
567
568	ret = device_add_groups(dev, groups: soc_dev_attr_groups);
569	if (ret < 0)
570	goto free_rtd;
571
572	return rtd;
573
574	free_rtd:
575	soc_free_pcm_runtime(rtd);
576	return NULL;
577	}
578
579	static void snd_soc_flush_all_delayed_work(struct snd_soc_card *card)
580	{
581	struct snd_soc_pcm_runtime *rtd;
582
583	for_each_card_rtds(card, rtd)
584	flush_delayed_work(dwork: &rtd->delayed_work);
585	}
586
587	#ifdef CONFIG_PM_SLEEP
588	static void soc_playback_digital_mute(struct snd_soc_card *card, int mute)
589	{
590	struct snd_soc_pcm_runtime *rtd;
591	struct snd_soc_dai *dai;
592	int playback = SNDRV_PCM_STREAM_PLAYBACK;
593	int i;
594
595	for_each_card_rtds(card, rtd) {
596
597	if (rtd->dai_link->ignore_suspend)
598	continue;
599
600	for_each_rtd_dais(rtd, i, dai) {
601	if (snd_soc_dai_stream_active(dai, stream: playback))
602	snd_soc_dai_digital_mute(dai, mute, direction: playback);
603	}
604	}
605	}
606
607	static void soc_dapm_suspend_resume(struct snd_soc_card *card, int event)
608	{
609	struct snd_soc_pcm_runtime *rtd;
610	int stream;
611
612	for_each_card_rtds(card, rtd) {
613
614	if (rtd->dai_link->ignore_suspend)
615	continue;
616
617	for_each_pcm_streams(stream)
618	snd_soc_dapm_stream_event(rtd, stream, event);
619	}
620	}
621
622	/* powers down audio subsystem for suspend */
623	int snd_soc_suspend(struct device *dev)
624	{
625	struct snd_soc_card *card = dev_get_drvdata(dev);
626	struct snd_soc_component *component;
627	struct snd_soc_pcm_runtime *rtd;
628	int i;
629
630	/* If the card is not initialized yet there is nothing to do */
631	if (!snd_soc_card_is_instantiated(card))
632	return 0;
633
634	/*
635	* Due to the resume being scheduled into a workqueue we could
636	* suspend before that's finished - wait for it to complete.
637	*/
638	snd_power_wait(card: card->snd_card);
639
640	/* we're going to block userspace touching us until resume completes */
641	snd_power_change_state(card: card->snd_card, SNDRV_CTL_POWER_D3hot);
642
643	/* mute any active DACs */
644	soc_playback_digital_mute(card, mute: 1);
645
646	/* suspend all pcms */
647	for_each_card_rtds(card, rtd) {
648	if (rtd->dai_link->ignore_suspend)
649	continue;
650
651	snd_pcm_suspend_all(pcm: rtd->pcm);
652	}
653
654	snd_soc_card_suspend_pre(card);
655
656	/* close any waiting streams */
657	snd_soc_flush_all_delayed_work(card);
658
659	soc_dapm_suspend_resume(card, SND_SOC_DAPM_STREAM_SUSPEND);
660
661	/* Recheck all endpoints too, their state is affected by suspend */
662	dapm_mark_endpoints_dirty(card);
663	snd_soc_dapm_sync(dapm: &card->dapm);
664
665	/* suspend all COMPONENTs */
666	for_each_card_rtds(card, rtd) {
667
668	if (rtd->dai_link->ignore_suspend)
669	continue;
670
671	for_each_rtd_components(rtd, i, component) {
672	struct snd_soc_dapm_context *dapm =
673	snd_soc_component_get_dapm(component);
674
675	/*
676	* ignore if component was already suspended
677	*/
678	if (snd_soc_component_is_suspended(component))
679	continue;
680
681	/*
682	* If there are paths active then the COMPONENT will be
683	* held with bias _ON and should not be suspended.
684	*/
685	switch (snd_soc_dapm_get_bias_level(dapm)) {
686	case SND_SOC_BIAS_STANDBY:
687	/*
688	* If the COMPONENT is capable of idle
689	* bias off then being in STANDBY
690	* means it's doing something,
691	* otherwise fall through.
692	*/
693	if (dapm->idle_bias_off) {
694	dev_dbg(component->dev,
695	"ASoC: idle_bias_off CODEC on over suspend\n");
696	break;
697	}
698	fallthrough;
699
700	case SND_SOC_BIAS_OFF:
701	snd_soc_component_suspend(component);
702	if (component->regmap)
703	regcache_mark_dirty(map: component->regmap);
704	/* deactivate pins to sleep state */
705	pinctrl_pm_select_sleep_state(dev: component->dev);
706	break;
707	default:
708	dev_dbg(component->dev,
709	"ASoC: COMPONENT is on over suspend\n");
710	break;
711	}
712	}
713	}
714
715	snd_soc_card_suspend_post(card);
716
717	return 0;
718	}
719	EXPORT_SYMBOL_GPL(snd_soc_suspend);
720
721	/*
722	* deferred resume work, so resume can complete before we finished
723	* setting our codec back up, which can be very slow on I2C
724	*/
725	static void soc_resume_deferred(struct work_struct *work)
726	{
727	struct snd_soc_card *card =
728	container_of(work, struct snd_soc_card,
729	deferred_resume_work);
730	struct snd_soc_component *component;
731
732	/*
733	* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
734	* so userspace apps are blocked from touching us
735	*/
736
737	dev_dbg(card->dev, "ASoC: starting resume work\n");
738
739	/* Bring us up into D2 so that DAPM starts enabling things */
740	snd_power_change_state(card: card->snd_card, SNDRV_CTL_POWER_D2);
741
742	snd_soc_card_resume_pre(card);
743
744	for_each_card_components(card, component) {
745	if (snd_soc_component_is_suspended(component))
746	snd_soc_component_resume(component);
747	}
748
749	soc_dapm_suspend_resume(card, SND_SOC_DAPM_STREAM_RESUME);
750
751	/* unmute any active DACs */
752	soc_playback_digital_mute(card, mute: 0);
753
754	snd_soc_card_resume_post(card);
755
756	dev_dbg(card->dev, "ASoC: resume work completed\n");
757
758	/* Recheck all endpoints too, their state is affected by suspend */
759	dapm_mark_endpoints_dirty(card);
760	snd_soc_dapm_sync(dapm: &card->dapm);
761
762	/* userspace can access us now we are back as we were before */
763	snd_power_change_state(card: card->snd_card, SNDRV_CTL_POWER_D0);
764	}
765
766	/* powers up audio subsystem after a suspend */
767	int snd_soc_resume(struct device *dev)
768	{
769	struct snd_soc_card *card = dev_get_drvdata(dev);
770	struct snd_soc_component *component;
771
772	/* If the card is not initialized yet there is nothing to do */
773	if (!snd_soc_card_is_instantiated(card))
774	return 0;
775
776	/* activate pins from sleep state */
777	for_each_card_components(card, component)
778	if (snd_soc_component_active(component))
779	pinctrl_pm_select_default_state(dev: component->dev);
780
781	dev_dbg(dev, "ASoC: Scheduling resume work\n");
782	if (!schedule_work(work: &card->deferred_resume_work))
783	dev_err(dev, "ASoC: resume work item may be lost\n");
784
785	return 0;
786	}
787	EXPORT_SYMBOL_GPL(snd_soc_resume);
788
789	static void soc_resume_init(struct snd_soc_card *card)
790	{
791	/* deferred resume work */
792	INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
793	}
794	#else
795	#define snd_soc_suspend NULL
796	#define snd_soc_resume NULL
797	static inline void soc_resume_init(struct snd_soc_card *card) { }
798	#endif
799
800	static struct device_node
801	*soc_component_to_node(struct snd_soc_component *component)
802	{
803	struct device_node *of_node;
804
805	of_node = component->dev->of_node;
806	if (!of_node && component->dev->parent)
807	of_node = component->dev->parent->of_node;
808
809	return of_node;
810	}
811
812	struct of_phandle_args *snd_soc_copy_dai_args(struct device *dev, struct of_phandle_args *args)
813	{
814	struct of_phandle_args *ret = devm_kzalloc(dev, size: sizeof(*ret), GFP_KERNEL);
815
816	if (!ret)
817	return NULL;
818
819	*ret = *args;
820
821	return ret;
822	}
823	EXPORT_SYMBOL_GPL(snd_soc_copy_dai_args);
824
825	static int snd_soc_is_matching_component(
826	const struct snd_soc_dai_link_component *dlc,
827	struct snd_soc_component *component)
828	{
829	struct device_node *component_of_node;
830
831	if (!dlc)
832	return 0;
833
834	if (dlc->dai_args) {
835	struct snd_soc_dai *dai;
836
837	for_each_component_dais(component, dai)
838	if (snd_soc_is_matching_dai(dlc, dai))
839	return 1;
840	return 0;
841	}
842
843	component_of_node = soc_component_to_node(component);
844
845	if (dlc->of_node && component_of_node != dlc->of_node)
846	return 0;
847	if (dlc->name && strcmp(component->name, dlc->name))
848	return 0;
849
850	return 1;
851	}
852
853	static struct snd_soc_component *soc_find_component(
854	const struct snd_soc_dai_link_component *dlc)
855	{
856	struct snd_soc_component *component;
857
858	lockdep_assert_held(&client_mutex);
859
860	/*
861	* NOTE
862	*
863	* It returns *1st* found component, but some driver
864	* has few components by same of_node/name
865	* ex)
866	* CPU component and generic DMAEngine component
867	*/
868	for_each_component(component)
869	if (snd_soc_is_matching_component(dlc, component))
870	return component;
871
872	return NULL;
873	}
874
875	/**
876	* snd_soc_find_dai - Find a registered DAI
877	*
878	* @dlc: name of the DAI or the DAI driver and optional component info to match
879	*
880	* This function will search all registered components and their DAIs to
881	* find the DAI of the same name. The component's of_node and name
882	* should also match if being specified.
883	*
884	* Return: pointer of DAI, or NULL if not found.
885	*/
886	struct snd_soc_dai *snd_soc_find_dai(
887	const struct snd_soc_dai_link_component *dlc)
888	{
889	struct snd_soc_component *component;
890	struct snd_soc_dai *dai;
891
892	lockdep_assert_held(&client_mutex);
893
894	/* Find CPU DAI from registered DAIs */
895	for_each_component(component)
896	if (snd_soc_is_matching_component(dlc, component))
897	for_each_component_dais(component, dai)
898	if (snd_soc_is_matching_dai(dlc, dai))
899	return dai;
900
901	return NULL;
902	}
903	EXPORT_SYMBOL_GPL(snd_soc_find_dai);
904
905	struct snd_soc_dai *snd_soc_find_dai_with_mutex(
906	const struct snd_soc_dai_link_component *dlc)
907	{
908	struct snd_soc_dai *dai;
909
910	mutex_lock(&client_mutex);
911	dai = snd_soc_find_dai(dlc);
912	mutex_unlock(lock: &client_mutex);
913
914	return dai;
915	}
916	EXPORT_SYMBOL_GPL(snd_soc_find_dai_with_mutex);
917
918	static int soc_dai_link_sanity_check(struct snd_soc_card *card,
919	struct snd_soc_dai_link *link)
920	{
921	int i;
922	struct snd_soc_dai_link_component *dlc;
923
924	/* Codec check */
925	for_each_link_codecs(link, i, dlc) {
926	/*
927	* Codec must be specified by 1 of name or OF node,
928	* not both or neither.
929	*/
930	if (snd_soc_dlc_component_is_invalid(dlc))
931	goto component_invalid;
932
933	if (snd_soc_dlc_component_is_empty(dlc))
934	goto component_empty;
935
936	/* Codec DAI name must be specified */
937	if (snd_soc_dlc_dai_is_empty(dlc))
938	goto dai_empty;
939
940	/*
941	* Defer card registration if codec component is not added to
942	* component list.
943	*/
944	if (!soc_find_component(dlc))
945	goto component_not_found;
946	}
947
948	/* Platform check */
949	for_each_link_platforms(link, i, dlc) {
950	/*
951	* Platform may be specified by either name or OF node, but it
952	* can be left unspecified, then no components will be inserted
953	* in the rtdcom list
954	*/
955	if (snd_soc_dlc_component_is_invalid(dlc))
956	goto component_invalid;
957
958	if (snd_soc_dlc_component_is_empty(dlc))
959	goto component_empty;
960
961	/*
962	* Defer card registration if platform component is not added to
963	* component list.
964	*/
965	if (!soc_find_component(dlc))
966	goto component_not_found;
967	}
968
969	/* CPU check */
970	for_each_link_cpus(link, i, dlc) {
971	/*
972	* CPU device may be specified by either name or OF node, but
973	* can be left unspecified, and will be matched based on DAI
974	* name alone..
975	*/
976	if (snd_soc_dlc_component_is_invalid(dlc))
977	goto component_invalid;
978
979
980	if (snd_soc_dlc_component_is_empty(dlc)) {
981	/*
982	* At least one of CPU DAI name or CPU device name/node must be specified
983	*/
984	if (snd_soc_dlc_dai_is_empty(dlc))
985	goto component_dai_empty;
986	} else {
987	/*
988	* Defer card registration if Component is not added
989	*/
990	if (!soc_find_component(dlc))
991	goto component_not_found;
992	}
993	}
994
995	return 0;
996
997	component_invalid:
998	dev_err(card->dev, "ASoC: Both Component name/of_node are set for %s\n", link->name);
999	return -EINVAL;
1000
1001	component_empty:
1002	dev_err(card->dev, "ASoC: Neither Component name/of_node are set for %s\n", link->name);
1003	return -EINVAL;
1004
1005	component_not_found:
1006	dev_dbg(card->dev, "ASoC: Component %s not found for link %s\n", dlc->name, link->name);
1007	return -EPROBE_DEFER;
1008
1009	dai_empty:
1010	dev_err(card->dev, "ASoC: DAI name is not set for %s\n", link->name);
1011	return -EINVAL;
1012
1013	component_dai_empty:
1014	dev_err(card->dev, "ASoC: Neither DAI/Component name/of_node are set for %s\n", link->name);
1015	return -EINVAL;
1016	}
1017
1018	/**
1019	* snd_soc_remove_pcm_runtime - Remove a pcm_runtime from card
1020	* @card: The ASoC card to which the pcm_runtime has
1021	* @rtd: The pcm_runtime to remove
1022	*
1023	* This function removes a pcm_runtime from the ASoC card.
1024	*/
1025	void snd_soc_remove_pcm_runtime(struct snd_soc_card *card,
1026	struct snd_soc_pcm_runtime *rtd)
1027	{
1028	lockdep_assert_held(&client_mutex);
1029
1030	/*
1031	* Notify the machine driver for extra destruction
1032	*/
1033	snd_soc_card_remove_dai_link(card, dai_link: rtd->dai_link);
1034
1035	soc_free_pcm_runtime(rtd);
1036	}
1037	EXPORT_SYMBOL_GPL(snd_soc_remove_pcm_runtime);
1038
1039	/**
1040	* snd_soc_add_pcm_runtime - Add a pcm_runtime dynamically via dai_link
1041	* @card: The ASoC card to which the pcm_runtime is added
1042	* @dai_link: The DAI link to find pcm_runtime
1043	*
1044	* This function adds a pcm_runtime ASoC card by using dai_link.
1045	*
1046	* Note: Topology can use this API to add pcm_runtime when probing the
1047	* topology component. And machine drivers can still define static
1048	* DAI links in dai_link array.
1049	*/
1050	static int snd_soc_add_pcm_runtime(struct snd_soc_card *card,
1051	struct snd_soc_dai_link *dai_link)
1052	{
1053	struct snd_soc_pcm_runtime *rtd;
1054	struct snd_soc_dai_link_component *codec, *platform, *cpu;
1055	struct snd_soc_component *component;
1056	int i, ret;
1057
1058	lockdep_assert_held(&client_mutex);
1059
1060	/*
1061	* Notify the machine driver for extra initialization
1062	*/
1063	ret = snd_soc_card_add_dai_link(card, dai_link);
1064	if (ret < 0)
1065	return ret;
1066
1067	if (dai_link->ignore)
1068	return 0;
1069
1070	dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name);
1071
1072	ret = soc_dai_link_sanity_check(card, link: dai_link);
1073	if (ret < 0)
1074	return ret;
1075
1076	rtd = soc_new_pcm_runtime(card, dai_link);
1077	if (!rtd)
1078	return -ENOMEM;
1079
1080	for_each_link_cpus(dai_link, i, cpu) {
1081	snd_soc_rtd_to_cpu(rtd, i) = snd_soc_find_dai(cpu);
1082	if (!snd_soc_rtd_to_cpu(rtd, i)) {
1083	dev_info(card->dev, "ASoC: CPU DAI %s not registered\n",
1084	cpu->dai_name);
1085	goto _err_defer;
1086	}
1087	snd_soc_rtd_add_component(rtd, snd_soc_rtd_to_cpu(rtd, i)->component);
1088	}
1089
1090	/* Find CODEC from registered CODECs */
1091	for_each_link_codecs(dai_link, i, codec) {
1092	snd_soc_rtd_to_codec(rtd, i) = snd_soc_find_dai(codec);
1093	if (!snd_soc_rtd_to_codec(rtd, i)) {
1094	dev_info(card->dev, "ASoC: CODEC DAI %s not registered\n",
1095	codec->dai_name);
1096	goto _err_defer;
1097	}
1098
1099	snd_soc_rtd_add_component(rtd, snd_soc_rtd_to_codec(rtd, i)->component);
1100	}
1101
1102	/* Find PLATFORM from registered PLATFORMs */
1103	for_each_link_platforms(dai_link, i, platform) {
1104	for_each_component(component) {
1105	if (!snd_soc_is_matching_component(dlc: platform, component))
1106	continue;
1107
1108	snd_soc_rtd_add_component(rtd, component);
1109	}
1110	}
1111
1112	return 0;
1113
1114	_err_defer:
1115	snd_soc_remove_pcm_runtime(card, rtd);
1116	return -EPROBE_DEFER;
1117	}
1118
1119	int snd_soc_add_pcm_runtimes(struct snd_soc_card *card,
1120	struct snd_soc_dai_link *dai_link,
1121	int num_dai_link)
1122	{
1123	for (int i = 0; i < num_dai_link; i++) {
1124	int ret = snd_soc_add_pcm_runtime(card, dai_link: dai_link + i);
1125
1126	if (ret < 0)
1127	return ret;
1128	}
1129
1130	return 0;
1131	}
1132	EXPORT_SYMBOL_GPL(snd_soc_add_pcm_runtimes);
1133
1134	static void snd_soc_runtime_get_dai_fmt(struct snd_soc_pcm_runtime *rtd)
1135	{
1136	struct snd_soc_dai_link *dai_link = rtd->dai_link;
1137	struct snd_soc_dai *dai, *not_used;
1138	u64 pos, possible_fmt;
1139	unsigned int mask = 0, dai_fmt = 0;
1140	int i, j, priority, pri, until;
1141
1142	/*
1143	* Get selectable format from each DAIs.
1144	*
1145	****************************
1146	* NOTE
1147	* Using .auto_selectable_formats is not mandatory,
1148	* we can select format manually from Sound Card.
1149	* When use it, driver should list well tested format only.
1150	****************************
1151	*
1152	* ex)
1153	* auto_selectable_formats (= SND_SOC_POSSIBLE_xxx)
1154	* (A) (B) (C)
1155	* DAI0_: { 0x000F, 0x00F0, 0x0F00 };
1156	* DAI1 : { 0xF000, 0x0F00 };
1157	* (X) (Y)
1158	*
1159	* "until" will be 3 in this case (MAX array size from DAI0 and DAI1)
1160	* Here is dev_dbg() message and comments
1161	*
1162	* priority = 1
1163	* DAI0: (pri, fmt) = (1, 000000000000000F) // 1st check (A) DAI1 is not selected
1164	* DAI1: (pri, fmt) = (0, 0000000000000000) // Necessary Waste
1165	* DAI0: (pri, fmt) = (1, 000000000000000F) // 2nd check (A)
1166	* DAI1: (pri, fmt) = (1, 000000000000F000) // (X)
1167	* priority = 2
1168	* DAI0: (pri, fmt) = (2, 00000000000000FF) // 3rd check (A) + (B)
1169	* DAI1: (pri, fmt) = (1, 000000000000F000) // (X)
1170	* DAI0: (pri, fmt) = (2, 00000000000000FF) // 4th check (A) + (B)
1171	* DAI1: (pri, fmt) = (2, 000000000000FF00) // (X) + (Y)
1172	* priority = 3
1173	* DAI0: (pri, fmt) = (3, 0000000000000FFF) // 5th check (A) + (B) + (C)
1174	* DAI1: (pri, fmt) = (2, 000000000000FF00) // (X) + (Y)
1175	* found auto selected format: 0000000000000F00
1176	*/
1177	until = snd_soc_dai_get_fmt_max_priority(rtd);
1178	for (priority = 1; priority <= until; priority++) {
1179	for_each_rtd_dais(rtd, j, not_used) {
1180
1181	possible_fmt = ULLONG_MAX;
1182	for_each_rtd_dais(rtd, i, dai) {
1183	u64 fmt = 0;
1184
1185	pri = (j >= i) ? priority : priority - 1;
1186	fmt = snd_soc_dai_get_fmt(dai, priority: pri);
1187	possible_fmt &= fmt;
1188	}
1189	if (possible_fmt)
1190	goto found;
1191	}
1192	}
1193	/* Not Found */
1194	return;
1195	found:
1196	/*
1197	* convert POSSIBLE_DAIFMT to DAIFMT
1198	*
1199	* Some basic/default settings on each is defined as 0.
1200	* see
1201	* SND_SOC_DAIFMT_NB_NF
1202	* SND_SOC_DAIFMT_GATED
1203	*
1204	* SND_SOC_DAIFMT_xxx_MASK can't notice it if Sound Card specify
1205	* these value, and will be overwrite to auto selected value.
1206	*
1207	* To avoid such issue, loop from 63 to 0 here.
1208	* Small number of SND_SOC_POSSIBLE_xxx will be Hi priority.
1209	* Basic/Default settings of each part and aboves are defined
1210	* as Hi priority (= small number) of SND_SOC_POSSIBLE_xxx.
1211	*/
1212	for (i = 63; i >= 0; i--) {
1213	pos = 1ULL << i;
1214	switch (possible_fmt & pos) {
1215	/*
1216	* for format
1217	*/
1218	case SND_SOC_POSSIBLE_DAIFMT_I2S:
1219	case SND_SOC_POSSIBLE_DAIFMT_RIGHT_J:
1220	case SND_SOC_POSSIBLE_DAIFMT_LEFT_J:
1221	case SND_SOC_POSSIBLE_DAIFMT_DSP_A:
1222	case SND_SOC_POSSIBLE_DAIFMT_DSP_B:
1223	case SND_SOC_POSSIBLE_DAIFMT_AC97:
1224	case SND_SOC_POSSIBLE_DAIFMT_PDM:
1225	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_FORMAT_MASK) | i;
1226	break;
1227	/*
1228	* for clock
1229	*/
1230	case SND_SOC_POSSIBLE_DAIFMT_CONT:
1231	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_MASK) | SND_SOC_DAIFMT_CONT;
1232	break;
1233	case SND_SOC_POSSIBLE_DAIFMT_GATED:
1234	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_MASK) | SND_SOC_DAIFMT_GATED;
1235	break;
1236	/*
1237	* for clock invert
1238	*/
1239	case SND_SOC_POSSIBLE_DAIFMT_NB_NF:
1240	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_NB_NF;
1241	break;
1242	case SND_SOC_POSSIBLE_DAIFMT_NB_IF:
1243	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_NB_IF;
1244	break;
1245	case SND_SOC_POSSIBLE_DAIFMT_IB_NF:
1246	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_IB_NF;
1247	break;
1248	case SND_SOC_POSSIBLE_DAIFMT_IB_IF:
1249	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_IB_IF;
1250	break;
1251	/*
1252	* for clock provider / consumer
1253	*/
1254	case SND_SOC_POSSIBLE_DAIFMT_CBP_CFP:
1255	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBP_CFP;
1256	break;
1257	case SND_SOC_POSSIBLE_DAIFMT_CBC_CFP:
1258	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBC_CFP;
1259	break;
1260	case SND_SOC_POSSIBLE_DAIFMT_CBP_CFC:
1261	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBP_CFC;
1262	break;
1263	case SND_SOC_POSSIBLE_DAIFMT_CBC_CFC:
1264	dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBC_CFC;
1265	break;
1266	}
1267	}
1268
1269	/*
1270	* Some driver might have very complex limitation.
1271	* In such case, user want to auto-select non-limitation part,
1272	* and want to manually specify complex part.
1273	*
1274	* Or for example, if both CPU and Codec can be clock provider,
1275	* but because of its quality, user want to specify it manually.
1276	*
1277	* Use manually specified settings if sound card did.
1278	*/
1279	if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_FORMAT_MASK))
1280	mask |= SND_SOC_DAIFMT_FORMAT_MASK;
1281	if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_CLOCK_MASK))
1282	mask |= SND_SOC_DAIFMT_CLOCK_MASK;
1283	if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_INV_MASK))
1284	mask |= SND_SOC_DAIFMT_INV_MASK;
1285	if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK))
1286	mask |= SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;
1287
1288	dai_link->dai_fmt |= (dai_fmt & mask);
1289	}
1290
1291	/**
1292	* snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
1293	* @rtd: The runtime for which the DAI link format should be changed
1294	* @dai_fmt: The new DAI link format
1295	*
1296	* This function updates the DAI link format for all DAIs connected to the DAI
1297	* link for the specified runtime.
1298	*
1299	* Note: For setups with a static format set the dai_fmt field in the
1300	* corresponding snd_dai_link struct instead of using this function.
1301	*
1302	* Returns 0 on success, otherwise a negative error code.
1303	*/
1304	int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
1305	unsigned int dai_fmt)
1306	{
1307	struct snd_soc_dai *cpu_dai;
1308	struct snd_soc_dai *codec_dai;
1309	unsigned int i;
1310	int ret;
1311
1312	if (!dai_fmt)
1313	return 0;
1314
1315	for_each_rtd_codec_dais(rtd, i, codec_dai) {
1316	ret = snd_soc_dai_set_fmt(dai: codec_dai, fmt: dai_fmt);
1317	if (ret != 0 && ret != -ENOTSUPP)
1318	return ret;
1319	}
1320
1321	/* Flip the polarity for the "CPU" end of link */
1322	dai_fmt = snd_soc_daifmt_clock_provider_flipped(dai_fmt);
1323
1324	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1325	ret = snd_soc_dai_set_fmt(dai: cpu_dai, fmt: dai_fmt);
1326	if (ret != 0 && ret != -ENOTSUPP)
1327	return ret;
1328	}
1329
1330	return 0;
1331	}
1332	EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
1333
1334	static int soc_init_pcm_runtime(struct snd_soc_card *card,
1335	struct snd_soc_pcm_runtime *rtd)
1336	{
1337	struct snd_soc_dai_link *dai_link = rtd->dai_link;
1338	struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
1339	struct snd_soc_component *component;
1340	int ret, num, i;
1341
1342	/* do machine specific initialization */
1343	ret = snd_soc_link_init(rtd);
1344	if (ret < 0)
1345	return ret;
1346
1347	snd_soc_runtime_get_dai_fmt(rtd);
1348	ret = snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
1349	if (ret)
1350	goto err;
1351
1352	/* add DPCM sysfs entries */
1353	soc_dpcm_debugfs_add(rtd);
1354
1355	num = rtd->num;
1356
1357	/*
1358	* most drivers will register their PCMs using DAI link ordering but
1359	* topology based drivers can use the DAI link id field to set PCM
1360	* device number and then use rtd + a base offset of the BEs.
1361	*/
1362	for_each_rtd_components(rtd, i, component) {
1363	if (!component->driver->use_dai_pcm_id)
1364	continue;
1365
1366	if (rtd->dai_link->no_pcm)
1367	num += component->driver->be_pcm_base;
1368	else
1369	num = rtd->dai_link->id;
1370	}
1371
1372	/* create compress_device if possible */
1373	ret = snd_soc_dai_compress_new(dai: cpu_dai, rtd, num);
1374	if (ret != -ENOTSUPP)
1375	goto err;
1376
1377	/* create the pcm */
1378	ret = soc_new_pcm(rtd, num);
1379	if (ret < 0) {
1380	dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
1381	dai_link->stream_name, ret);
1382	goto err;
1383	}
1384
1385	ret = snd_soc_pcm_dai_new(rtd);
1386	if (ret < 0)
1387	goto err;
1388
1389	rtd->initialized = true;
1390
1391	return 0;
1392	err:
1393	snd_soc_link_exit(rtd);
1394	return ret;
1395	}
1396
1397	static void soc_set_name_prefix(struct snd_soc_card *card,
1398	struct snd_soc_component *component)
1399	{
1400	struct device_node *of_node = soc_component_to_node(component);
1401	const char *str;
1402	int ret, i;
1403
1404	for (i = 0; i < card->num_configs; i++) {
1405	struct snd_soc_codec_conf *map = &card->codec_conf[i];
1406
1407	if (snd_soc_is_matching_component(dlc: &map->dlc, component) &&
1408	map->name_prefix) {
1409	component->name_prefix = map->name_prefix;
1410	return;
1411	}
1412	}
1413
1414	/*
1415	* If there is no configuration table or no match in the table,
1416	* check if a prefix is provided in the node
1417	*/
1418	ret = of_property_read_string(np: of_node, propname: "sound-name-prefix", out_string: &str);
1419	if (ret < 0)
1420	return;
1421
1422	component->name_prefix = str;
1423	}
1424
1425	static void soc_remove_component(struct snd_soc_component *component,
1426	int probed)
1427	{
1428
1429	if (!component->card)
1430	return;
1431
1432	if (probed)
1433	snd_soc_component_remove(component);
1434
1435	list_del_init(entry: &component->card_list);
1436	snd_soc_dapm_free(dapm: snd_soc_component_get_dapm(component));
1437	soc_cleanup_component_debugfs(component);
1438	component->card = NULL;
1439	snd_soc_component_module_put_when_remove(component);
1440	}
1441
1442	static int soc_probe_component(struct snd_soc_card *card,
1443	struct snd_soc_component *component)
1444	{
1445	struct snd_soc_dapm_context *dapm =
1446	snd_soc_component_get_dapm(component);
1447	struct snd_soc_dai *dai;
1448	int probed = 0;
1449	int ret;
1450
1451	if (snd_soc_component_is_dummy(component))
1452	return 0;
1453
1454	if (component->card) {
1455	if (component->card != card) {
1456	dev_err(component->dev,
1457	"Trying to bind component \"%s\" to card \"%s\" but is already bound to card \"%s\"\n",
1458	component->name, card->name, component->card->name);
1459	return -ENODEV;
1460	}
1461	return 0;
1462	}
1463
1464	ret = snd_soc_component_module_get_when_probe(component);
1465	if (ret < 0)
1466	return ret;
1467
1468	component->card = card;
1469	soc_set_name_prefix(card, component);
1470
1471	soc_init_component_debugfs(component);
1472
1473	snd_soc_dapm_init(dapm, card, component);
1474
1475	ret = snd_soc_dapm_new_controls(dapm,
1476	widget: component->driver->dapm_widgets,
1477	num: component->driver->num_dapm_widgets);
1478
1479	if (ret != 0) {
1480	dev_err(component->dev,
1481	"Failed to create new controls %d\n", ret);
1482	goto err_probe;
1483	}
1484
1485	for_each_component_dais(component, dai) {
1486	ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
1487	if (ret != 0) {
1488	dev_err(component->dev,
1489	"Failed to create DAI widgets %d\n", ret);
1490	goto err_probe;
1491	}
1492	}
1493
1494	ret = snd_soc_component_probe(component);
1495	if (ret < 0)
1496	goto err_probe;
1497
1498	WARN(dapm->idle_bias_off &&
1499	dapm->bias_level != SND_SOC_BIAS_OFF,
1500	"codec %s can not start from non-off bias with idle_bias_off==1\n",
1501	component->name);
1502	probed = 1;
1503
1504	/*
1505	* machine specific init
1506	* see
1507	* snd_soc_component_set_aux()
1508	*/
1509	ret = snd_soc_component_init(component);
1510	if (ret < 0)
1511	goto err_probe;
1512
1513	ret = snd_soc_add_component_controls(component,
1514	controls: component->driver->controls,
1515	num_controls: component->driver->num_controls);
1516	if (ret < 0)
1517	goto err_probe;
1518
1519	ret = snd_soc_dapm_add_routes(dapm,
1520	route: component->driver->dapm_routes,
1521	num: component->driver->num_dapm_routes);
1522	if (ret < 0) {
1523	if (card->disable_route_checks) {
1524	dev_info(card->dev,
1525	"%s: disable_route_checks set, ignoring errors on add_routes\n",
1526	__func__);
1527	} else {
1528	dev_err(card->dev,
1529	"%s: snd_soc_dapm_add_routes failed: %d\n",
1530	__func__, ret);
1531	goto err_probe;
1532	}
1533	}
1534
1535	/* see for_each_card_components */
1536	list_add(new: &component->card_list, head: &card->component_dev_list);
1537
1538	err_probe:
1539	if (ret < 0)
1540	soc_remove_component(component, probed);
1541
1542	return ret;
1543	}
1544
1545	static void soc_remove_link_dais(struct snd_soc_card *card)
1546	{
1547	struct snd_soc_pcm_runtime *rtd;
1548	int order;
1549
1550	for_each_comp_order(order) {
1551	for_each_card_rtds(card, rtd) {
1552	/* remove all rtd connected DAIs in good order */
1553	snd_soc_pcm_dai_remove(rtd, order);
1554	}
1555	}
1556	}
1557
1558	static int soc_probe_link_dais(struct snd_soc_card *card)
1559	{
1560	struct snd_soc_pcm_runtime *rtd;
1561	int order, ret;
1562
1563	for_each_comp_order(order) {
1564	for_each_card_rtds(card, rtd) {
1565	/* probe all rtd connected DAIs in good order */
1566	ret = snd_soc_pcm_dai_probe(rtd, order);
1567	if (ret)
1568	return ret;
1569	}
1570	}
1571
1572	return 0;
1573	}
1574
1575	static void soc_remove_link_components(struct snd_soc_card *card)
1576	{
1577	struct snd_soc_component *component;
1578	struct snd_soc_pcm_runtime *rtd;
1579	int i, order;
1580
1581	for_each_comp_order(order) {
1582	for_each_card_rtds(card, rtd) {
1583	for_each_rtd_components(rtd, i, component) {
1584	if (component->driver->remove_order != order)
1585	continue;
1586
1587	soc_remove_component(component, probed: 1);
1588	}
1589	}
1590	}
1591	}
1592
1593	static int soc_probe_link_components(struct snd_soc_card *card)
1594	{
1595	struct snd_soc_component *component;
1596	struct snd_soc_pcm_runtime *rtd;
1597	int i, ret, order;
1598
1599	for_each_comp_order(order) {
1600	for_each_card_rtds(card, rtd) {
1601	for_each_rtd_components(rtd, i, component) {
1602	if (component->driver->probe_order != order)
1603	continue;
1604
1605	ret = soc_probe_component(card, component);
1606	if (ret < 0)
1607	return ret;
1608	}
1609	}
1610	}
1611
1612	return 0;
1613	}
1614
1615	static void soc_unbind_aux_dev(struct snd_soc_card *card)
1616	{
1617	struct snd_soc_component *component, *_component;
1618
1619	for_each_card_auxs_safe(card, component, _component) {
1620	/* for snd_soc_component_init() */
1621	snd_soc_component_set_aux(component, NULL);
1622	list_del(entry: &component->card_aux_list);
1623	}
1624	}
1625
1626	static int soc_bind_aux_dev(struct snd_soc_card *card)
1627	{
1628	struct snd_soc_component *component;
1629	struct snd_soc_aux_dev *aux;
1630	int i;
1631
1632	for_each_card_pre_auxs(card, i, aux) {
1633	/* codecs, usually analog devices */
1634	component = soc_find_component(dlc: &aux->dlc);
1635	if (!component)
1636	return -EPROBE_DEFER;
1637
1638	/* for snd_soc_component_init() */
1639	snd_soc_component_set_aux(component, aux);
1640	/* see for_each_card_auxs */
1641	list_add(new: &component->card_aux_list, head: &card->aux_comp_list);
1642	}
1643	return 0;
1644	}
1645
1646	static int soc_probe_aux_devices(struct snd_soc_card *card)
1647	{
1648	struct snd_soc_component *component;
1649	int order;
1650	int ret;
1651
1652	for_each_comp_order(order) {
1653	for_each_card_auxs(card, component) {
1654	if (component->driver->probe_order != order)
1655	continue;
1656
1657	ret = soc_probe_component(card, component);
1658	if (ret < 0)
1659	return ret;
1660	}
1661	}
1662
1663	return 0;
1664	}
1665
1666	static void soc_remove_aux_devices(struct snd_soc_card *card)
1667	{
1668	struct snd_soc_component *comp, *_comp;
1669	int order;
1670
1671	for_each_comp_order(order) {
1672	for_each_card_auxs_safe(card, comp, _comp) {
1673	if (comp->driver->remove_order == order)
1674	soc_remove_component(component: comp, probed: 1);
1675	}
1676	}
1677	}
1678
1679	#ifdef CONFIG_DMI
1680	/*
1681	* If a DMI filed contain strings in this blacklist (e.g.
1682	* "Type2 - Board Manufacturer" or "Type1 - TBD by OEM"), it will be taken
1683	* as invalid and dropped when setting the card long name from DMI info.
1684	*/
1685	static const char * const dmi_blacklist[] = {
1686	"To be filled by OEM",
1687	"TBD by OEM",
1688	"Default String",
1689	"Board Manufacturer",
1690	"Board Vendor Name",
1691	"Board Product Name",
1692	NULL, /* terminator */
1693	};
1694
1695	/*
1696	* Trim special characters, and replace '-' with '_' since '-' is used to
1697	* separate different DMI fields in the card long name. Only number and
1698	* alphabet characters and a few separator characters are kept.
1699	*/
1700	static void cleanup_dmi_name(char *name)
1701	{
1702	int i, j = 0;
1703
1704	for (i = 0; name[i]; i++) {
1705	if (isalnum(name[i]) || (name[i] == '.')
1706	|| (name[i] == '_'))
1707	name[j++] = name[i];
1708	else if (name[i] == '-')
1709	name[j++] = '_';
1710	}
1711
1712	name[j] = '\0';
1713	}
1714
1715	/*
1716	* Check if a DMI field is valid, i.e. not containing any string
1717	* in the black list.
1718	*/
1719	static int is_dmi_valid(const char *field)
1720	{
1721	int i = 0;
1722
1723	while (dmi_blacklist[i]) {
1724	if (strstr(field, dmi_blacklist[i]))
1725	return 0;
1726	i++;
1727	}
1728
1729	return 1;
1730	}
1731
1732	/*
1733	* Append a string to card->dmi_longname with character cleanups.
1734	*/
1735	static void append_dmi_string(struct snd_soc_card *card, const char *str)
1736	{
1737	char *dst = card->dmi_longname;
1738	size_t dst_len = sizeof(card->dmi_longname);
1739	size_t len;
1740
1741	len = strlen(dst);
1742	snprintf(buf: dst + len, size: dst_len - len, fmt: "-%s", str);
1743
1744	len++; /* skip the separator "-" */
1745	if (len < dst_len)
1746	cleanup_dmi_name(name: dst + len);
1747	}
1748
1749	/**
1750	* snd_soc_set_dmi_name() - Register DMI names to card
1751	* @card: The card to register DMI names
1752	* @flavour: The flavour "differentiator" for the card amongst its peers.
1753	*
1754	* An Intel machine driver may be used by many different devices but are
1755	* difficult for userspace to differentiate, since machine drivers ususally
1756	* use their own name as the card short name and leave the card long name
1757	* blank. To differentiate such devices and fix bugs due to lack of
1758	* device-specific configurations, this function allows DMI info to be used
1759	* as the sound card long name, in the format of
1760	* "vendor-product-version-board"
1761	* (Character '-' is used to separate different DMI fields here).
1762	* This will help the user space to load the device-specific Use Case Manager
1763	* (UCM) configurations for the card.
1764	*
1765	* Possible card long names may be:
1766	* DellInc.-XPS139343-01-0310JH
1767	* ASUSTeKCOMPUTERINC.-T100TA-1.0-T100TA
1768	* Circuitco-MinnowboardMaxD0PLATFORM-D0-MinnowBoardMAX
1769	*
1770	* This function also supports flavoring the card longname to provide
1771	* the extra differentiation, like "vendor-product-version-board-flavor".
1772	*
1773	* We only keep number and alphabet characters and a few separator characters
1774	* in the card long name since UCM in the user space uses the card long names
1775	* as card configuration directory names and AudoConf cannot support special
1776	* charactors like SPACE.
1777	*
1778	* Returns 0 on success, otherwise a negative error code.
1779	*/
1780	int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour)
1781	{
1782	const char *vendor, *product, *board;
1783
1784	if (card->long_name)
1785	return 0; /* long name already set by driver or from DMI */
1786
1787	if (!dmi_available)
1788	return 0;
1789
1790	/* make up dmi long name as: vendor-product-version-board */
1791	vendor = dmi_get_system_info(field: DMI_BOARD_VENDOR);
1792	if (!vendor || !is_dmi_valid(field: vendor)) {
1793	dev_warn(card->dev, "ASoC: no DMI vendor name!\n");
1794	return 0;
1795	}
1796
1797	snprintf(buf: card->dmi_longname, size: sizeof(card->dmi_longname), fmt: "%s", vendor);
1798	cleanup_dmi_name(name: card->dmi_longname);
1799
1800	product = dmi_get_system_info(field: DMI_PRODUCT_NAME);
1801	if (product && is_dmi_valid(field: product)) {
1802	const char *product_version = dmi_get_system_info(field: DMI_PRODUCT_VERSION);
1803
1804	append_dmi_string(card, str: product);
1805
1806	/*
1807	* some vendors like Lenovo may only put a self-explanatory
1808	* name in the product version field
1809	*/
1810	if (product_version && is_dmi_valid(field: product_version))
1811	append_dmi_string(card, str: product_version);
1812	}
1813
1814	board = dmi_get_system_info(field: DMI_BOARD_NAME);
1815	if (board && is_dmi_valid(field: board)) {
1816	if (!product || strcasecmp(s1: board, s2: product))
1817	append_dmi_string(card, str: board);
1818	} else if (!product) {
1819	/* fall back to using legacy name */
1820	dev_warn(card->dev, "ASoC: no DMI board/product name!\n");
1821	return 0;
1822	}
1823
1824	/* Add flavour to dmi long name */
1825	if (flavour)
1826	append_dmi_string(card, str: flavour);
1827
1828	/* set the card long name */
1829	card->long_name = card->dmi_longname;
1830
1831	return 0;
1832	}
1833	EXPORT_SYMBOL_GPL(snd_soc_set_dmi_name);
1834	#endif /* CONFIG_DMI */
1835
1836	static void soc_check_tplg_fes(struct snd_soc_card *card)
1837	{
1838	struct snd_soc_component *component;
1839	const struct snd_soc_component_driver *comp_drv;
1840	struct snd_soc_dai_link *dai_link;
1841	int i;
1842
1843	for_each_component(component) {
1844
1845	/* does this component override BEs ? */
1846	if (!component->driver->ignore_machine)
1847	continue;
1848
1849	/* for this machine ? */
1850	if (!strcmp(component->driver->ignore_machine,
1851	card->dev->driver->name))
1852	goto match;
1853	if (strcmp(component->driver->ignore_machine,
1854	dev_name(dev: card->dev)))
1855	continue;
1856	match:
1857	/* machine matches, so override the rtd data */
1858	for_each_card_prelinks(card, i, dai_link) {
1859
1860	/* ignore this FE */
1861	if (dai_link->dynamic) {
1862	dai_link->ignore = true;
1863	continue;
1864	}
1865
1866	dev_dbg(card->dev, "info: override BE DAI link %s\n",
1867	card->dai_link[i].name);
1868
1869	/* override platform component */
1870	if (!dai_link->platforms) {
1871	dev_err(card->dev, "init platform error");
1872	continue;
1873	}
1874
1875	if (component->dev->of_node)
1876	dai_link->platforms->of_node = component->dev->of_node;
1877	else
1878	dai_link->platforms->name = component->name;
1879
1880	/* convert non BE into BE */
1881	if (!dai_link->no_pcm) {
1882	dai_link->no_pcm = 1;
1883
1884	if (dai_link->dpcm_playback)
1885	dev_warn(card->dev,
1886	"invalid configuration, dailink %s has flags no_pcm=0 and dpcm_playback=1\n",
1887	dai_link->name);
1888	if (dai_link->dpcm_capture)
1889	dev_warn(card->dev,
1890	"invalid configuration, dailink %s has flags no_pcm=0 and dpcm_capture=1\n",
1891	dai_link->name);
1892
1893	/* convert normal link into DPCM one */
1894	if (!(dai_link->dpcm_playback ||
1895	dai_link->dpcm_capture)) {
1896	dai_link->dpcm_playback = !dai_link->capture_only;
1897	dai_link->dpcm_capture = !dai_link->playback_only;
1898	}
1899	}
1900
1901	/*
1902	* override any BE fixups
1903	* see
1904	* snd_soc_link_be_hw_params_fixup()
1905	*/
1906	dai_link->be_hw_params_fixup =
1907	component->driver->be_hw_params_fixup;
1908
1909	/*
1910	* most BE links don't set stream name, so set it to
1911	* dai link name if it's NULL to help bind widgets.
1912	*/
1913	if (!dai_link->stream_name)
1914	dai_link->stream_name = dai_link->name;
1915	}
1916
1917	/* Inform userspace we are using alternate topology */
1918	if (component->driver->topology_name_prefix) {
1919
1920	/* topology shortname created? */
1921	if (!card->topology_shortname_created) {
1922	comp_drv = component->driver;
1923
1924	snprintf(buf: card->topology_shortname, size: 32, fmt: "%s-%s",
1925	comp_drv->topology_name_prefix,
1926	card->name);
1927	card->topology_shortname_created = true;
1928	}
1929
1930	/* use topology shortname */
1931	card->name = card->topology_shortname;
1932	}
1933	}
1934	}
1935
1936	#define soc_setup_card_name(card, name, name1, name2) \
1937	__soc_setup_card_name(card, name, sizeof(name), name1, name2)
1938	static void __soc_setup_card_name(struct snd_soc_card *card,
1939	char *name, int len,
1940	const char *name1, const char *name2)
1941	{
1942	const char *src = name1 ? name1 : name2;
1943	int i;
1944
1945	snprintf(buf: name, size: len, fmt: "%s", src);
1946
1947	if (name != card->snd_card->driver)
1948	return;
1949
1950	/*
1951	* Name normalization (driver field)
1952	*
1953	* The driver name is somewhat special, as it's used as a key for
1954	* searches in the user-space.
1955	*
1956	* ex)
1957	* "abcd??efg" -> "abcd__efg"
1958	*/
1959	for (i = 0; i < len; i++) {
1960	switch (name[i]) {
1961	case '_':
1962	case '-':
1963	case '\0':
1964	break;
1965	default:
1966	if (!isalnum(name[i]))
1967	name[i] = '_';
1968	break;
1969	}
1970	}
1971
1972	/*
1973	* The driver field should contain a valid string from the user view.
1974	* The wrapping usually does not work so well here. Set a smaller string
1975	* in the specific ASoC driver.
1976	*/
1977	if (strlen(src) > len - 1)
1978	dev_err(card->dev, "ASoC: driver name too long '%s' -> '%s'\n", src, name);
1979	}
1980
1981	static void soc_cleanup_card_resources(struct snd_soc_card *card)
1982	{
1983	struct snd_soc_pcm_runtime *rtd, *n;
1984
1985	if (card->snd_card)
1986	snd_card_disconnect_sync(card: card->snd_card);
1987
1988	snd_soc_dapm_shutdown(card);
1989
1990	/* release machine specific resources */
1991	for_each_card_rtds(card, rtd)
1992	if (rtd->initialized)
1993	snd_soc_link_exit(rtd);
1994	/* remove and free each DAI */
1995	soc_remove_link_dais(card);
1996	soc_remove_link_components(card);
1997
1998	for_each_card_rtds_safe(card, rtd, n)
1999	snd_soc_remove_pcm_runtime(card, rtd);
2000
2001	/* remove auxiliary devices */
2002	soc_remove_aux_devices(card);
2003	soc_unbind_aux_dev(card);
2004
2005	snd_soc_dapm_free(dapm: &card->dapm);
2006	soc_cleanup_card_debugfs(card);
2007
2008	/* remove the card */
2009	snd_soc_card_remove(card);
2010
2011	if (card->snd_card) {
2012	snd_card_free(card: card->snd_card);
2013	card->snd_card = NULL;
2014	}
2015	}
2016
2017	static void snd_soc_unbind_card(struct snd_soc_card *card, bool unregister)
2018	{
2019	if (snd_soc_card_is_instantiated(card)) {
2020	card->instantiated = false;
2021	snd_soc_flush_all_delayed_work(card);
2022
2023	soc_cleanup_card_resources(card);
2024	if (!unregister)
2025	list_add(new: &card->list, head: &unbind_card_list);
2026	} else {
2027	if (unregister)
2028	list_del(entry: &card->list);
2029	}
2030	}
2031
2032	static int snd_soc_bind_card(struct snd_soc_card *card)
2033	{
2034	struct snd_soc_pcm_runtime *rtd;
2035	struct snd_soc_component *component;
2036	int ret;
2037
2038	mutex_lock(&client_mutex);
2039	snd_soc_card_mutex_lock_root(card);
2040
2041	snd_soc_dapm_init(dapm: &card->dapm, card, NULL);
2042
2043	/* check whether any platform is ignore machine FE and using topology */
2044	soc_check_tplg_fes(card);
2045
2046	/* bind aux_devs too */
2047	ret = soc_bind_aux_dev(card);
2048	if (ret < 0)
2049	goto probe_end;
2050
2051	/* add predefined DAI links to the list */
2052	card->num_rtd = 0;
2053	ret = snd_soc_add_pcm_runtimes(card, card->dai_link, card->num_links);
2054	if (ret < 0)
2055	goto probe_end;
2056
2057	/* card bind complete so register a sound card */
2058	ret = snd_card_new(parent: card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
2059	module: card->owner, extra_size: 0, card_ret: &card->snd_card);
2060	if (ret < 0) {
2061	dev_err(card->dev,
2062	"ASoC: can't create sound card for card %s: %d\n",
2063	card->name, ret);
2064	goto probe_end;
2065	}
2066
2067	soc_init_card_debugfs(card);
2068
2069	soc_resume_init(card);
2070
2071	ret = snd_soc_dapm_new_controls(dapm: &card->dapm, widget: card->dapm_widgets,
2072	num: card->num_dapm_widgets);
2073	if (ret < 0)
2074	goto probe_end;
2075
2076	ret = snd_soc_dapm_new_controls(dapm: &card->dapm, widget: card->of_dapm_widgets,
2077	num: card->num_of_dapm_widgets);
2078	if (ret < 0)
2079	goto probe_end;
2080
2081	/* initialise the sound card only once */
2082	ret = snd_soc_card_probe(card);
2083	if (ret < 0)
2084	goto probe_end;
2085
2086	/* probe all components used by DAI links on this card */
2087	ret = soc_probe_link_components(card);
2088	if (ret < 0) {
2089	if (ret != -EPROBE_DEFER) {
2090	dev_err(card->dev,
2091	"ASoC: failed to instantiate card %d\n", ret);
2092	}
2093	goto probe_end;
2094	}
2095
2096	/* probe auxiliary components */
2097	ret = soc_probe_aux_devices(card);
2098	if (ret < 0) {
2099	dev_err(card->dev,
2100	"ASoC: failed to probe aux component %d\n", ret);
2101	goto probe_end;
2102	}
2103
2104	/* probe all DAI links on this card */
2105	ret = soc_probe_link_dais(card);
2106	if (ret < 0) {
2107	dev_err(card->dev,
2108	"ASoC: failed to instantiate card %d\n", ret);
2109	goto probe_end;
2110	}
2111
2112	for_each_card_rtds(card, rtd) {
2113	ret = soc_init_pcm_runtime(card, rtd);
2114	if (ret < 0)
2115	goto probe_end;
2116	}
2117
2118	snd_soc_dapm_link_dai_widgets(card);
2119	snd_soc_dapm_connect_dai_link_widgets(card);
2120
2121	ret = snd_soc_add_card_controls(soc_card: card, controls: card->controls,
2122	num_controls: card->num_controls);
2123	if (ret < 0)
2124	goto probe_end;
2125
2126	ret = snd_soc_dapm_add_routes(dapm: &card->dapm, route: card->dapm_routes,
2127	num: card->num_dapm_routes);
2128	if (ret < 0) {
2129	if (card->disable_route_checks) {
2130	dev_info(card->dev,
2131	"%s: disable_route_checks set, ignoring errors on add_routes\n",
2132	__func__);
2133	} else {
2134	dev_err(card->dev,
2135	"%s: snd_soc_dapm_add_routes failed: %d\n",
2136	__func__, ret);
2137	goto probe_end;
2138	}
2139	}
2140
2141	ret = snd_soc_dapm_add_routes(dapm: &card->dapm, route: card->of_dapm_routes,
2142	num: card->num_of_dapm_routes);
2143	if (ret < 0)
2144	goto probe_end;
2145
2146	/* try to set some sane longname if DMI is available */
2147	snd_soc_set_dmi_name(card, NULL);
2148
2149	soc_setup_card_name(card, card->snd_card->shortname,
2150	card->name, NULL);
2151	soc_setup_card_name(card, card->snd_card->longname,
2152	card->long_name, card->name);
2153	soc_setup_card_name(card, card->snd_card->driver,
2154	card->driver_name, card->name);
2155
2156	if (card->components) {
2157	/* the current implementation of snd_component_add() accepts */
2158	/* multiple components in the string separated by space, */
2159	/* but the string collision (identical string) check might */
2160	/* not work correctly */
2161	ret = snd_component_add(card: card->snd_card, component: card->components);
2162	if (ret < 0) {
2163	dev_err(card->dev, "ASoC: %s snd_component_add() failed: %d\n",
2164	card->name, ret);
2165	goto probe_end;
2166	}
2167	}
2168
2169	ret = snd_soc_card_late_probe(card);
2170	if (ret < 0)
2171	goto probe_end;
2172
2173	snd_soc_dapm_new_widgets(card);
2174	snd_soc_card_fixup_controls(card);
2175
2176	ret = snd_card_register(card: card->snd_card);
2177	if (ret < 0) {
2178	dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
2179	ret);
2180	goto probe_end;
2181	}
2182
2183	card->instantiated = 1;
2184	dapm_mark_endpoints_dirty(card);
2185	snd_soc_dapm_sync(dapm: &card->dapm);
2186
2187	/* deactivate pins to sleep state */
2188	for_each_card_components(card, component)
2189	if (!snd_soc_component_active(component))
2190	pinctrl_pm_select_sleep_state(dev: component->dev);
2191
2192	probe_end:
2193	if (ret < 0)
2194	soc_cleanup_card_resources(card);
2195
2196	snd_soc_card_mutex_unlock(card);
2197	mutex_unlock(lock: &client_mutex);
2198
2199	return ret;
2200	}
2201
2202	/* probes a new socdev */
2203	static int soc_probe(struct platform_device *pdev)
2204	{
2205	struct snd_soc_card *card = platform_get_drvdata(pdev);
2206
2207	/*
2208	* no card, so machine driver should be registering card
2209	* we should not be here in that case so ret error
2210	*/
2211	if (!card)
2212	return -EINVAL;
2213
2214	dev_warn(&pdev->dev,
2215	"ASoC: machine %s should use snd_soc_register_card()\n",
2216	card->name);
2217
2218	/* Bodge while we unpick instantiation */
2219	card->dev = &pdev->dev;
2220
2221	return devm_snd_soc_register_card(dev: &pdev->dev, card);
2222	}
2223
2224	int snd_soc_poweroff(struct device *dev)
2225	{
2226	struct snd_soc_card *card = dev_get_drvdata(dev);
2227	struct snd_soc_component *component;
2228
2229	if (!snd_soc_card_is_instantiated(card))
2230	return 0;
2231
2232	/*
2233	* Flush out pmdown_time work - we actually do want to run it
2234	* now, we're shutting down so no imminent restart.
2235	*/
2236	snd_soc_flush_all_delayed_work(card);
2237
2238	snd_soc_dapm_shutdown(card);
2239
2240	/* deactivate pins to sleep state */
2241	for_each_card_components(card, component)
2242	pinctrl_pm_select_sleep_state(dev: component->dev);
2243
2244	return 0;
2245	}
2246	EXPORT_SYMBOL_GPL(snd_soc_poweroff);
2247
2248	const struct dev_pm_ops snd_soc_pm_ops = {
2249	.suspend = snd_soc_suspend,
2250	.resume = snd_soc_resume,
2251	.freeze = snd_soc_suspend,
2252	.thaw = snd_soc_resume,
2253	.poweroff = snd_soc_poweroff,
2254	.restore = snd_soc_resume,
2255	};
2256	EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
2257
2258	/* ASoC platform driver */
2259	static struct platform_driver soc_driver = {
2260	.driver = {
2261	.name = "soc-audio",
2262	.pm = &snd_soc_pm_ops,
2263	},
2264	.probe = soc_probe,
2265	};
2266
2267	/**
2268	* snd_soc_cnew - create new control
2269	* @_template: control template
2270	* @data: control private data
2271	* @long_name: control long name
2272	* @prefix: control name prefix
2273	*
2274	* Create a new mixer control from a template control.
2275	*
2276	* Returns 0 for success, else error.
2277	*/
2278	struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
2279	void *data, const char *long_name,
2280	const char *prefix)
2281	{
2282	struct snd_kcontrol_new template;
2283	struct snd_kcontrol *kcontrol;
2284	char *name = NULL;
2285
2286	memcpy(&template, _template, sizeof(template));
2287	template.index = 0;
2288
2289	if (!long_name)
2290	long_name = template.name;
2291
2292	if (prefix) {
2293	name = kasprintf(GFP_KERNEL, fmt: "%s %s", prefix, long_name);
2294	if (!name)
2295	return NULL;
2296
2297	template.name = name;
2298	} else {
2299	template.name = long_name;
2300	}
2301
2302	kcontrol = snd_ctl_new1(kcontrolnew: &template, private_data: data);
2303
2304	kfree(objp: name);
2305
2306	return kcontrol;
2307	}
2308	EXPORT_SYMBOL_GPL(snd_soc_cnew);
2309
2310	static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
2311	const struct snd_kcontrol_new *controls, int num_controls,
2312	const char *prefix, void *data)
2313	{
2314	int i;
2315
2316	for (i = 0; i < num_controls; i++) {
2317	const struct snd_kcontrol_new *control = &controls[i];
2318	int err = snd_ctl_add(card, kcontrol: snd_soc_cnew(control, data,
2319	control->name, prefix));
2320	if (err < 0) {
2321	dev_err(dev, "ASoC: Failed to add %s: %d\n",
2322	control->name, err);
2323	return err;
2324	}
2325	}
2326
2327	return 0;
2328	}
2329
2330	/**
2331	* snd_soc_add_component_controls - Add an array of controls to a component.
2332	*
2333	* @component: Component to add controls to
2334	* @controls: Array of controls to add
2335	* @num_controls: Number of elements in the array
2336	*
2337	* Return: 0 for success, else error.
2338	*/
2339	int snd_soc_add_component_controls(struct snd_soc_component *component,
2340	const struct snd_kcontrol_new *controls, unsigned int num_controls)
2341	{
2342	struct snd_card *card = component->card->snd_card;
2343
2344	return snd_soc_add_controls(card, dev: component->dev, controls,
2345	num_controls, prefix: component->name_prefix, data: component);
2346	}
2347	EXPORT_SYMBOL_GPL(snd_soc_add_component_controls);
2348
2349	/**
2350	* snd_soc_add_card_controls - add an array of controls to a SoC card.
2351	* Convenience function to add a list of controls.
2352	*
2353	* @soc_card: SoC card to add controls to
2354	* @controls: array of controls to add
2355	* @num_controls: number of elements in the array
2356	*
2357	* Return 0 for success, else error.
2358	*/
2359	int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
2360	const struct snd_kcontrol_new *controls, int num_controls)
2361	{
2362	struct snd_card *card = soc_card->snd_card;
2363
2364	return snd_soc_add_controls(card, dev: soc_card->dev, controls, num_controls,
2365	NULL, data: soc_card);
2366	}
2367	EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
2368
2369	/**
2370	* snd_soc_add_dai_controls - add an array of controls to a DAI.
2371	* Convienience function to add a list of controls.
2372	*
2373	* @dai: DAI to add controls to
2374	* @controls: array of controls to add
2375	* @num_controls: number of elements in the array
2376	*
2377	* Return 0 for success, else error.
2378	*/
2379	int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
2380	const struct snd_kcontrol_new *controls, int num_controls)
2381	{
2382	struct snd_card *card = dai->component->card->snd_card;
2383
2384	return snd_soc_add_controls(card, dev: dai->dev, controls, num_controls,
2385	NULL, data: dai);
2386	}
2387	EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
2388
2389	/**
2390	* snd_soc_register_card - Register a card with the ASoC core
2391	*
2392	* @card: Card to register
2393	*
2394	*/
2395	int snd_soc_register_card(struct snd_soc_card *card)
2396	{
2397	if (!card->name || !card->dev)
2398	return -EINVAL;
2399
2400	dev_set_drvdata(dev: card->dev, data: card);
2401
2402	INIT_LIST_HEAD(list: &card->widgets);
2403	INIT_LIST_HEAD(list: &card->paths);
2404	INIT_LIST_HEAD(list: &card->dapm_list);
2405	INIT_LIST_HEAD(list: &card->aux_comp_list);
2406	INIT_LIST_HEAD(list: &card->component_dev_list);
2407	INIT_LIST_HEAD(list: &card->list);
2408	INIT_LIST_HEAD(list: &card->rtd_list);
2409	INIT_LIST_HEAD(list: &card->dapm_dirty);
2410	INIT_LIST_HEAD(list: &card->dobj_list);
2411
2412	card->instantiated = 0;
2413	mutex_init(&card->mutex);
2414	mutex_init(&card->dapm_mutex);
2415	mutex_init(&card->pcm_mutex);
2416
2417	return snd_soc_bind_card(card);
2418	}
2419	EXPORT_SYMBOL_GPL(snd_soc_register_card);
2420
2421	/**
2422	* snd_soc_unregister_card - Unregister a card with the ASoC core
2423	*
2424	* @card: Card to unregister
2425	*
2426	*/
2427	void snd_soc_unregister_card(struct snd_soc_card *card)
2428	{
2429	mutex_lock(&client_mutex);
2430	snd_soc_unbind_card(card, unregister: true);
2431	mutex_unlock(lock: &client_mutex);
2432	dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
2433	}
2434	EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
2435
2436	/*
2437	* Simplify DAI link configuration by removing ".-1" from device names
2438	* and sanitizing names.
2439	*/
2440	static char *fmt_single_name(struct device *dev, int *id)
2441	{
2442	const char *devname = dev_name(dev);
2443	char *found, *name;
2444	unsigned int id1, id2;
2445
2446	if (devname == NULL)
2447	return NULL;
2448
2449	name = devm_kstrdup(dev, s: devname, GFP_KERNEL);
2450	if (!name)
2451	return NULL;
2452
2453	/* are we a "%s.%d" name (platform and SPI components) */
2454	found = strstr(name, dev->driver->name);
2455	if (found) {
2456	/* get ID */
2457	if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
2458
2459	/* discard ID from name if ID == -1 */
2460	if (*id == -1)
2461	found[strlen(dev->driver->name)] = '\0';
2462	}
2463
2464	/* I2C component devices are named "bus-addr" */
2465	} else if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
2466
2467	/* create unique ID number from I2C addr and bus */
2468	*id = ((id1 & 0xffff) << 16) + id2;
2469
2470	devm_kfree(dev, p: name);
2471
2472	/* sanitize component name for DAI link creation */
2473	name = devm_kasprintf(dev, GFP_KERNEL, fmt: "%s.%s", dev->driver->name, devname);
2474	} else {
2475	*id = 0;
2476	}
2477
2478	return name;
2479	}
2480
2481	/*
2482	* Simplify DAI link naming for single devices with multiple DAIs by removing
2483	* any ".-1" and using the DAI name (instead of device name).
2484	*/
2485	static inline char *fmt_multiple_name(struct device *dev,
2486	struct snd_soc_dai_driver *dai_drv)
2487	{
2488	if (dai_drv->name == NULL) {
2489	dev_err(dev,
2490	"ASoC: error - multiple DAI %s registered with no name\n",
2491	dev_name(dev));
2492	return NULL;
2493	}
2494
2495	return devm_kstrdup(dev, s: dai_drv->name, GFP_KERNEL);
2496	}
2497
2498	void snd_soc_unregister_dai(struct snd_soc_dai *dai)
2499	{
2500	dev_dbg(dai->dev, "ASoC: Unregistered DAI '%s'\n", dai->name);
2501	list_del(entry: &dai->list);
2502	}
2503	EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);
2504
2505	/**
2506	* snd_soc_register_dai - Register a DAI dynamically & create its widgets
2507	*
2508	* @component: The component the DAIs are registered for
2509	* @dai_drv: DAI driver to use for the DAI
2510	* @legacy_dai_naming: if %true, use legacy single-name format;
2511	* if %false, use multiple-name format;
2512	*
2513	* Topology can use this API to register DAIs when probing a component.
2514	* These DAIs's widgets will be freed in the card cleanup and the DAIs
2515	* will be freed in the component cleanup.
2516	*/
2517	struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component,
2518	struct snd_soc_dai_driver *dai_drv,
2519	bool legacy_dai_naming)
2520	{
2521	struct device *dev = component->dev;
2522	struct snd_soc_dai *dai;
2523
2524	lockdep_assert_held(&client_mutex);
2525
2526	dai = devm_kzalloc(dev, size: sizeof(*dai), GFP_KERNEL);
2527	if (dai == NULL)
2528	return NULL;
2529
2530	/*
2531	* Back in the old days when we still had component-less DAIs,
2532	* instead of having a static name, component-less DAIs would
2533	* inherit the name of the parent device so it is possible to
2534	* register multiple instances of the DAI. We still need to keep
2535	* the same naming style even though those DAIs are not
2536	* component-less anymore.
2537	*/
2538	if (legacy_dai_naming &&
2539	(dai_drv->id == 0 || dai_drv->name == NULL)) {
2540	dai->name = fmt_single_name(dev, id: &dai->id);
2541	} else {
2542	dai->name = fmt_multiple_name(dev, dai_drv);
2543	if (dai_drv->id)
2544	dai->id = dai_drv->id;
2545	else
2546	dai->id = component->num_dai;
2547	}
2548	if (!dai->name)
2549	return NULL;
2550
2551	dai->component = component;
2552	dai->dev = dev;
2553	dai->driver = dai_drv;
2554
2555	/* see for_each_component_dais */
2556	list_add_tail(new: &dai->list, head: &component->dai_list);
2557	component->num_dai++;
2558
2559	dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
2560	return dai;
2561	}
2562	EXPORT_SYMBOL_GPL(snd_soc_register_dai);
2563
2564	/**
2565	* snd_soc_unregister_dais - Unregister DAIs from the ASoC core
2566	*
2567	* @component: The component for which the DAIs should be unregistered
2568	*/
2569	static void snd_soc_unregister_dais(struct snd_soc_component *component)
2570	{
2571	struct snd_soc_dai *dai, *_dai;
2572
2573	for_each_component_dais_safe(component, dai, _dai)
2574	snd_soc_unregister_dai(dai);
2575	}
2576
2577	/**
2578	* snd_soc_register_dais - Register a DAI with the ASoC core
2579	*
2580	* @component: The component the DAIs are registered for
2581	* @dai_drv: DAI driver to use for the DAIs
2582	* @count: Number of DAIs
2583	*/
2584	static int snd_soc_register_dais(struct snd_soc_component *component,
2585	struct snd_soc_dai_driver *dai_drv,
2586	size_t count)
2587	{
2588	struct snd_soc_dai *dai;
2589	unsigned int i;
2590	int ret;
2591
2592	for (i = 0; i < count; i++) {
2593	dai = snd_soc_register_dai(component, dai_drv + i, count == 1 &&
2594	component->driver->legacy_dai_naming);
2595	if (dai == NULL) {
2596	ret = -ENOMEM;
2597	goto err;
2598	}
2599	}
2600
2601	return 0;
2602
2603	err:
2604	snd_soc_unregister_dais(component);
2605
2606	return ret;
2607	}
2608
2609	#define ENDIANNESS_MAP(name) \
2610	(SNDRV_PCM_FMTBIT_##name##LE | SNDRV_PCM_FMTBIT_##name##BE)
2611	static u64 endianness_format_map[] = {
2612	ENDIANNESS_MAP(S16_),
2613	ENDIANNESS_MAP(U16_),
2614	ENDIANNESS_MAP(S24_),
2615	ENDIANNESS_MAP(U24_),
2616	ENDIANNESS_MAP(S32_),
2617	ENDIANNESS_MAP(U32_),
2618	ENDIANNESS_MAP(S24_3),
2619	ENDIANNESS_MAP(U24_3),
2620	ENDIANNESS_MAP(S20_3),
2621	ENDIANNESS_MAP(U20_3),
2622	ENDIANNESS_MAP(S18_3),
2623	ENDIANNESS_MAP(U18_3),
2624	ENDIANNESS_MAP(FLOAT_),
2625	ENDIANNESS_MAP(FLOAT64_),
2626	ENDIANNESS_MAP(IEC958_SUBFRAME_),
2627	};
2628
2629	/*
2630	* Fix up the DAI formats for endianness: codecs don't actually see
2631	* the endianness of the data but we're using the CPU format
2632	* definitions which do need to include endianness so we ensure that
2633	* codec DAIs always have both big and little endian variants set.
2634	*/
2635	static void convert_endianness_formats(struct snd_soc_pcm_stream *stream)
2636	{
2637	int i;
2638
2639	for (i = 0; i < ARRAY_SIZE(endianness_format_map); i++)
2640	if (stream->formats & endianness_format_map[i])
2641	stream->formats |= endianness_format_map[i];
2642	}
2643
2644	static void snd_soc_try_rebind_card(void)
2645	{
2646	struct snd_soc_card *card, *c;
2647
2648	list_for_each_entry_safe(card, c, &unbind_card_list, list)
2649	if (!snd_soc_bind_card(card))
2650	list_del(entry: &card->list);
2651	}
2652
2653	static void snd_soc_del_component_unlocked(struct snd_soc_component *component)
2654	{
2655	struct snd_soc_card *card = component->card;
2656
2657	snd_soc_unregister_dais(component);
2658
2659	if (card)
2660	snd_soc_unbind_card(card, unregister: false);
2661
2662	list_del(entry: &component->list);
2663	}
2664
2665	int snd_soc_component_initialize(struct snd_soc_component *component,
2666	const struct snd_soc_component_driver *driver,
2667	struct device *dev)
2668	{
2669	INIT_LIST_HEAD(list: &component->dai_list);
2670	INIT_LIST_HEAD(list: &component->dobj_list);
2671	INIT_LIST_HEAD(list: &component->card_list);
2672	INIT_LIST_HEAD(list: &component->list);
2673	mutex_init(&component->io_mutex);
2674
2675	component->name = fmt_single_name(dev, id: &component->id);
2676	if (!component->name) {
2677	dev_err(dev, "ASoC: Failed to allocate name\n");
2678	return -ENOMEM;
2679	}
2680
2681	component->dev = dev;
2682	component->driver = driver;
2683
2684	#ifdef CONFIG_DEBUG_FS
2685	if (!component->debugfs_prefix)
2686	component->debugfs_prefix = driver->debugfs_prefix;
2687	#endif
2688
2689	return 0;
2690	}
2691	EXPORT_SYMBOL_GPL(snd_soc_component_initialize);
2692
2693	int snd_soc_add_component(struct snd_soc_component *component,
2694	struct snd_soc_dai_driver *dai_drv,
2695	int num_dai)
2696	{
2697	int ret;
2698	int i;
2699
2700	mutex_lock(&client_mutex);
2701
2702	if (component->driver->endianness) {
2703	for (i = 0; i < num_dai; i++) {
2704	convert_endianness_formats(stream: &dai_drv[i].playback);
2705	convert_endianness_formats(stream: &dai_drv[i].capture);
2706	}
2707	}
2708
2709	ret = snd_soc_register_dais(component, dai_drv, count: num_dai);
2710	if (ret < 0) {
2711	dev_err(component->dev, "ASoC: Failed to register DAIs: %d\n",
2712	ret);
2713	goto err_cleanup;
2714	}
2715
2716	if (!component->driver->write && !component->driver->read) {
2717	if (!component->regmap)
2718	component->regmap = dev_get_regmap(dev: component->dev,
2719	NULL);
2720	if (component->regmap)
2721	snd_soc_component_setup_regmap(component);
2722	}
2723
2724	/* see for_each_component */
2725	list_add(new: &component->list, head: &component_list);
2726
2727	err_cleanup:
2728	if (ret < 0)
2729	snd_soc_del_component_unlocked(component);
2730
2731	mutex_unlock(lock: &client_mutex);
2732
2733	if (ret == 0)
2734	snd_soc_try_rebind_card();
2735
2736	return ret;
2737	}
2738	EXPORT_SYMBOL_GPL(snd_soc_add_component);
2739
2740	int snd_soc_register_component(struct device *dev,
2741	const struct snd_soc_component_driver *component_driver,
2742	struct snd_soc_dai_driver *dai_drv,
2743	int num_dai)
2744	{
2745	struct snd_soc_component *component;
2746	int ret;
2747
2748	component = devm_kzalloc(dev, size: sizeof(*component), GFP_KERNEL);
2749	if (!component)
2750	return -ENOMEM;
2751
2752	ret = snd_soc_component_initialize(component, component_driver, dev);
2753	if (ret < 0)
2754	return ret;
2755
2756	return snd_soc_add_component(component, dai_drv, num_dai);
2757	}
2758	EXPORT_SYMBOL_GPL(snd_soc_register_component);
2759
2760	/**
2761	* snd_soc_unregister_component_by_driver - Unregister component using a given driver
2762	* from the ASoC core
2763	*
2764	* @dev: The device to unregister
2765	* @component_driver: The component driver to unregister
2766	*/
2767	void snd_soc_unregister_component_by_driver(struct device *dev,
2768	const struct snd_soc_component_driver *component_driver)
2769	{
2770	struct snd_soc_component *component;
2771
2772	if (!component_driver)
2773	return;
2774
2775	mutex_lock(&client_mutex);
2776	component = snd_soc_lookup_component_nolocked(dev, component_driver->name);
2777	if (!component)
2778	goto out;
2779
2780	snd_soc_del_component_unlocked(component);
2781
2782	out:
2783	mutex_unlock(lock: &client_mutex);
2784	}
2785	EXPORT_SYMBOL_GPL(snd_soc_unregister_component_by_driver);
2786
2787	/**
2788	* snd_soc_unregister_component - Unregister all related component
2789	* from the ASoC core
2790	*
2791	* @dev: The device to unregister
2792	*/
2793	void snd_soc_unregister_component(struct device *dev)
2794	{
2795	mutex_lock(&client_mutex);
2796	while (1) {
2797	struct snd_soc_component *component = snd_soc_lookup_component_nolocked(dev, NULL);
2798
2799	if (!component)
2800	break;
2801
2802	snd_soc_del_component_unlocked(component);
2803	}
2804	mutex_unlock(lock: &client_mutex);
2805	}
2806	EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
2807
2808	/* Retrieve a card's name from device tree */
2809	int snd_soc_of_parse_card_name(struct snd_soc_card *card,
2810	const char *propname)
2811	{
2812	struct device_node *np;
2813	int ret;
2814
2815	if (!card->dev) {
2816	pr_err("card->dev is not set before calling %s\n", __func__);
2817	return -EINVAL;
2818	}
2819
2820	np = card->dev->of_node;
2821
2822	ret = of_property_read_string_index(np, propname, index: 0, output: &card->name);
2823	/*
2824	* EINVAL means the property does not exist. This is fine providing
2825	* card->name was previously set, which is checked later in
2826	* snd_soc_register_card.
2827	*/
2828	if (ret < 0 && ret != -EINVAL) {
2829	dev_err(card->dev,
2830	"ASoC: Property '%s' could not be read: %d\n",
2831	propname, ret);
2832	return ret;
2833	}
2834
2835	return 0;
2836	}
2837	EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
2838
2839	static const struct snd_soc_dapm_widget simple_widgets[] = {
2840	SND_SOC_DAPM_MIC("Microphone", NULL),
2841	SND_SOC_DAPM_LINE("Line", NULL),
2842	SND_SOC_DAPM_HP("Headphone", NULL),
2843	SND_SOC_DAPM_SPK("Speaker", NULL),
2844	};
2845
2846	int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
2847	const char *propname)
2848	{
2849	struct device_node *np = card->dev->of_node;
2850	struct snd_soc_dapm_widget *widgets;
2851	const char *template, *wname;
2852	int i, j, num_widgets;
2853
2854	num_widgets = of_property_count_strings(np, propname);
2855	if (num_widgets < 0) {
2856	dev_err(card->dev,
2857	"ASoC: Property '%s' does not exist\n", propname);
2858	return -EINVAL;
2859	}
2860	if (!num_widgets) {
2861	dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
2862	propname);
2863	return -EINVAL;
2864	}
2865	if (num_widgets & 1) {
2866	dev_err(card->dev,
2867	"ASoC: Property '%s' length is not even\n", propname);
2868	return -EINVAL;
2869	}
2870
2871	num_widgets /= 2;
2872
2873	widgets = devm_kcalloc(dev: card->dev, n: num_widgets, size: sizeof(*widgets),
2874	GFP_KERNEL);
2875	if (!widgets) {
2876	dev_err(card->dev,
2877	"ASoC: Could not allocate memory for widgets\n");
2878	return -ENOMEM;
2879	}
2880
2881	for (i = 0; i < num_widgets; i++) {
2882	int ret = of_property_read_string_index(np, propname,
2883	index: 2 * i, output: &template);
2884	if (ret) {
2885	dev_err(card->dev,
2886	"ASoC: Property '%s' index %d read error:%d\n",
2887	propname, 2 * i, ret);
2888	return -EINVAL;
2889	}
2890
2891	for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) {
2892	if (!strncmp(template, simple_widgets[j].name,
2893	strlen(simple_widgets[j].name))) {
2894	widgets[i] = simple_widgets[j];
2895	break;
2896	}
2897	}
2898
2899	if (j >= ARRAY_SIZE(simple_widgets)) {
2900	dev_err(card->dev,
2901	"ASoC: DAPM widget '%s' is not supported\n",
2902	template);
2903	return -EINVAL;
2904	}
2905
2906	ret = of_property_read_string_index(np, propname,
2907	index: (2 * i) + 1,
2908	output: &wname);
2909	if (ret) {
2910	dev_err(card->dev,
2911	"ASoC: Property '%s' index %d read error:%d\n",
2912	propname, (2 * i) + 1, ret);
2913	return -EINVAL;
2914	}
2915
2916	widgets[i].name = wname;
2917	}
2918
2919	card->of_dapm_widgets = widgets;
2920	card->num_of_dapm_widgets = num_widgets;
2921
2922	return 0;
2923	}
2924	EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);
2925
2926	int snd_soc_of_parse_pin_switches(struct snd_soc_card *card, const char *prop)
2927	{
2928	const unsigned int nb_controls_max = 16;
2929	const char **strings, *control_name;
2930	struct snd_kcontrol_new *controls;
2931	struct device *dev = card->dev;
2932	unsigned int i, nb_controls;
2933	int ret;
2934
2935	if (!of_property_read_bool(np: dev->of_node, propname: prop))
2936	return 0;
2937
2938	strings = devm_kcalloc(dev, n: nb_controls_max,
2939	size: sizeof(*strings), GFP_KERNEL);
2940	if (!strings)
2941	return -ENOMEM;
2942
2943	ret = of_property_read_string_array(np: dev->of_node, propname: prop,
2944	out_strs: strings, sz: nb_controls_max);
2945	if (ret < 0)
2946	return ret;
2947
2948	nb_controls = (unsigned int)ret;
2949
2950	controls = devm_kcalloc(dev, n: nb_controls,
2951	size: sizeof(*controls), GFP_KERNEL);
2952	if (!controls)
2953	return -ENOMEM;
2954
2955	for (i = 0; i < nb_controls; i++) {
2956	control_name = devm_kasprintf(dev, GFP_KERNEL,
2957	fmt: "%s Switch", strings[i]);
2958	if (!control_name)
2959	return -ENOMEM;
2960
2961	controls[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2962	controls[i].name = control_name;
2963	controls[i].info = snd_soc_dapm_info_pin_switch;
2964	controls[i].get = snd_soc_dapm_get_pin_switch;
2965	controls[i].put = snd_soc_dapm_put_pin_switch;
2966	controls[i].private_value = (unsigned long)strings[i];
2967	}
2968
2969	card->controls = controls;
2970	card->num_controls = nb_controls;
2971
2972	return 0;
2973	}
2974	EXPORT_SYMBOL_GPL(snd_soc_of_parse_pin_switches);
2975
2976	int snd_soc_of_get_slot_mask(struct device_node *np,
2977	const char *prop_name,
2978	unsigned int *mask)
2979	{
2980	u32 val;
2981	const __be32 *of_slot_mask = of_get_property(node: np, name: prop_name, lenp: &val);
2982	int i;
2983
2984	if (!of_slot_mask)
2985	return 0;
2986	val /= sizeof(u32);
2987	for (i = 0; i < val; i++)
2988	if (be32_to_cpup(p: &of_slot_mask[i]))
2989	*mask |= (1 << i);
2990
2991	return val;
2992	}
2993	EXPORT_SYMBOL_GPL(snd_soc_of_get_slot_mask);
2994
2995	int snd_soc_of_parse_tdm_slot(struct device_node *np,
2996	unsigned int *tx_mask,
2997	unsigned int *rx_mask,
2998	unsigned int *slots,
2999	unsigned int *slot_width)
3000	{
3001	u32 val;
3002	int ret;
3003
3004	if (tx_mask)
3005	snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask);
3006	if (rx_mask)
3007	snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", rx_mask);
3008
3009	if (of_property_read_bool(np, propname: "dai-tdm-slot-num")) {
3010	ret = of_property_read_u32(np, propname: "dai-tdm-slot-num", out_value: &val);
3011	if (ret)
3012	return ret;
3013
3014	if (slots)
3015	*slots = val;
3016	}
3017
3018	if (of_property_read_bool(np, propname: "dai-tdm-slot-width")) {
3019	ret = of_property_read_u32(np, propname: "dai-tdm-slot-width", out_value: &val);
3020	if (ret)
3021	return ret;
3022
3023	if (slot_width)
3024	*slot_width = val;
3025	}
3026
3027	return 0;
3028	}
3029	EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot);
3030
3031	void snd_soc_dlc_use_cpu_as_platform(struct snd_soc_dai_link_component *platforms,
3032	struct snd_soc_dai_link_component *cpus)
3033	{
3034	platforms->of_node = cpus->of_node;
3035	platforms->dai_args = cpus->dai_args;
3036	}
3037	EXPORT_SYMBOL_GPL(snd_soc_dlc_use_cpu_as_platform);
3038
3039	void snd_soc_of_parse_node_prefix(struct device_node *np,
3040	struct snd_soc_codec_conf *codec_conf,
3041	struct device_node *of_node,
3042	const char *propname)
3043	{
3044	const char *str;
3045	int ret;
3046
3047	ret = of_property_read_string(np, propname, out_string: &str);
3048	if (ret < 0) {
3049	/* no prefix is not error */
3050	return;
3051	}
3052
3053	codec_conf->dlc.of_node = of_node;
3054	codec_conf->name_prefix = str;
3055	}
3056	EXPORT_SYMBOL_GPL(snd_soc_of_parse_node_prefix);
3057
3058	int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
3059	const char *propname)
3060	{
3061	struct device_node *np = card->dev->of_node;
3062	int num_routes;
3063	struct snd_soc_dapm_route *routes;
3064	int i;
3065
3066	num_routes = of_property_count_strings(np, propname);
3067	if (num_routes < 0 || num_routes & 1) {
3068	dev_err(card->dev,
3069	"ASoC: Property '%s' does not exist or its length is not even\n",
3070	propname);
3071	return -EINVAL;
3072	}
3073	num_routes /= 2;
3074
3075	routes = devm_kcalloc(dev: card->dev, n: num_routes, size: sizeof(*routes),
3076	GFP_KERNEL);
3077	if (!routes) {
3078	dev_err(card->dev,
3079	"ASoC: Could not allocate DAPM route table\n");
3080	return -ENOMEM;
3081	}
3082
3083	for (i = 0; i < num_routes; i++) {
3084	int ret = of_property_read_string_index(np, propname,
3085	index: 2 * i, output: &routes[i].sink);
3086	if (ret) {
3087	dev_err(card->dev,
3088	"ASoC: Property '%s' index %d could not be read: %d\n",
3089	propname, 2 * i, ret);
3090	return -EINVAL;
3091	}
3092	ret = of_property_read_string_index(np, propname,
3093	index: (2 * i) + 1, output: &routes[i].source);
3094	if (ret) {
3095	dev_err(card->dev,
3096	"ASoC: Property '%s' index %d could not be read: %d\n",
3097	propname, (2 * i) + 1, ret);
3098	return -EINVAL;
3099	}
3100	}
3101
3102	card->num_of_dapm_routes = num_routes;
3103	card->of_dapm_routes = routes;
3104
3105	return 0;
3106	}
3107	EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
3108
3109	int snd_soc_of_parse_aux_devs(struct snd_soc_card *card, const char *propname)
3110	{
3111	struct device_node *node = card->dev->of_node;
3112	struct snd_soc_aux_dev *aux;
3113	int num, i;
3114
3115	num = of_count_phandle_with_args(np: node, list_name: propname, NULL);
3116	if (num == -ENOENT) {
3117	return 0;
3118	} else if (num < 0) {
3119	dev_err(card->dev, "ASOC: Property '%s' could not be read: %d\n",
3120	propname, num);
3121	return num;
3122	}
3123
3124	aux = devm_kcalloc(dev: card->dev, n: num, size: sizeof(*aux), GFP_KERNEL);
3125	if (!aux)
3126	return -ENOMEM;
3127	card->aux_dev = aux;
3128	card->num_aux_devs = num;
3129
3130	for_each_card_pre_auxs(card, i, aux) {
3131	aux->dlc.of_node = of_parse_phandle(np: node, phandle_name: propname, index: i);
3132	if (!aux->dlc.of_node)
3133	return -EINVAL;
3134	}
3135
3136	return 0;
3137	}
3138	EXPORT_SYMBOL_GPL(snd_soc_of_parse_aux_devs);
3139
3140	unsigned int snd_soc_daifmt_clock_provider_flipped(unsigned int dai_fmt)
3141	{
3142	unsigned int inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;
3143
3144	switch (dai_fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
3145	case SND_SOC_DAIFMT_CBP_CFP:
3146	inv_dai_fmt |= SND_SOC_DAIFMT_CBC_CFC;
3147	break;
3148	case SND_SOC_DAIFMT_CBP_CFC:
3149	inv_dai_fmt |= SND_SOC_DAIFMT_CBC_CFP;
3150	break;
3151	case SND_SOC_DAIFMT_CBC_CFP:
3152	inv_dai_fmt |= SND_SOC_DAIFMT_CBP_CFC;
3153	break;
3154	case SND_SOC_DAIFMT_CBC_CFC:
3155	inv_dai_fmt |= SND_SOC_DAIFMT_CBP_CFP;
3156	break;
3157	}
3158
3159	return inv_dai_fmt;
3160	}
3161	EXPORT_SYMBOL_GPL(snd_soc_daifmt_clock_provider_flipped);
3162
3163	unsigned int snd_soc_daifmt_clock_provider_from_bitmap(unsigned int bit_frame)
3164	{
3165	/*
3166	* bit_frame is return value from
3167	* snd_soc_daifmt_parse_clock_provider_raw()
3168	*/
3169
3170	/* Codec base */
3171	switch (bit_frame) {
3172	case 0x11:
3173	return SND_SOC_DAIFMT_CBP_CFP;
3174	case 0x10:
3175	return SND_SOC_DAIFMT_CBP_CFC;
3176	case 0x01:
3177	return SND_SOC_DAIFMT_CBC_CFP;
3178	default:
3179	return SND_SOC_DAIFMT_CBC_CFC;
3180	}
3181
3182	return 0;
3183	}
3184	EXPORT_SYMBOL_GPL(snd_soc_daifmt_clock_provider_from_bitmap);
3185
3186	unsigned int snd_soc_daifmt_parse_format(struct device_node *np,
3187	const char *prefix)
3188	{
3189	int ret;
3190	char prop[128];
3191	unsigned int format = 0;
3192	int bit, frame;
3193	const char *str;
3194	struct {
3195	char *name;
3196	unsigned int val;
3197	} of_fmt_table[] = {
3198	{ "i2s", SND_SOC_DAIFMT_I2S },
3199	{ "right_j", SND_SOC_DAIFMT_RIGHT_J },
3200	{ "left_j", SND_SOC_DAIFMT_LEFT_J },
3201	{ "dsp_a", SND_SOC_DAIFMT_DSP_A },
3202	{ "dsp_b", SND_SOC_DAIFMT_DSP_B },
3203	{ "ac97", SND_SOC_DAIFMT_AC97 },
3204	{ "pdm", SND_SOC_DAIFMT_PDM},
3205	{ "msb", SND_SOC_DAIFMT_MSB },
3206	{ "lsb", SND_SOC_DAIFMT_LSB },
3207	};
3208
3209	if (!prefix)
3210	prefix = "";
3211
3212	/*
3213	* check "dai-format = xxx"
3214	* or "[prefix]format = xxx"
3215	* SND_SOC_DAIFMT_FORMAT_MASK area
3216	*/
3217	ret = of_property_read_string(np, propname: "dai-format", out_string: &str);
3218	if (ret < 0) {
3219	snprintf(buf: prop, size: sizeof(prop), fmt: "%sformat", prefix);
3220	ret = of_property_read_string(np, propname: prop, out_string: &str);
3221	}
3222	if (ret == 0) {
3223	int i;
3224
3225	for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) {
3226	if (strcmp(str, of_fmt_table[i].name) == 0) {
3227	format |= of_fmt_table[i].val;
3228	break;
3229	}
3230	}
3231	}
3232
3233	/*
3234	* check "[prefix]continuous-clock"
3235	* SND_SOC_DAIFMT_CLOCK_MASK area
3236	*/
3237	snprintf(buf: prop, size: sizeof(prop), fmt: "%scontinuous-clock", prefix);
3238	if (of_property_read_bool(np, propname: prop))
3239	format |= SND_SOC_DAIFMT_CONT;
3240	else
3241	format |= SND_SOC_DAIFMT_GATED;
3242
3243	/*
3244	* check "[prefix]bitclock-inversion"
3245	* check "[prefix]frame-inversion"
3246	* SND_SOC_DAIFMT_INV_MASK area
3247	*/
3248	snprintf(buf: prop, size: sizeof(prop), fmt: "%sbitclock-inversion", prefix);
3249	bit = !!of_get_property(node: np, name: prop, NULL);
3250
3251	snprintf(buf: prop, size: sizeof(prop), fmt: "%sframe-inversion", prefix);
3252	frame = !!of_get_property(node: np, name: prop, NULL);
3253
3254	switch ((bit << 4) + frame) {
3255	case 0x11:
3256	format |= SND_SOC_DAIFMT_IB_IF;
3257	break;
3258	case 0x10:
3259	format |= SND_SOC_DAIFMT_IB_NF;
3260	break;
3261	case 0x01:
3262	format |= SND_SOC_DAIFMT_NB_IF;
3263	break;
3264	default:
3265	/* SND_SOC_DAIFMT_NB_NF is default */
3266	break;
3267	}
3268
3269	return format;
3270	}
3271	EXPORT_SYMBOL_GPL(snd_soc_daifmt_parse_format);
3272
3273	unsigned int snd_soc_daifmt_parse_clock_provider_raw(struct device_node *np,
3274	const char *prefix,
3275	struct device_node **bitclkmaster,
3276	struct device_node **framemaster)
3277	{
3278	char prop[128];
3279	unsigned int bit, frame;
3280
3281	if (!prefix)
3282	prefix = "";
3283
3284	/*
3285	* check "[prefix]bitclock-master"
3286	* check "[prefix]frame-master"
3287	*/
3288	snprintf(buf: prop, size: sizeof(prop), fmt: "%sbitclock-master", prefix);
3289	bit = !!of_get_property(node: np, name: prop, NULL);
3290	if (bit && bitclkmaster)
3291	*bitclkmaster = of_parse_phandle(np, phandle_name: prop, index: 0);
3292
3293	snprintf(buf: prop, size: sizeof(prop), fmt: "%sframe-master", prefix);
3294	frame = !!of_get_property(node: np, name: prop, NULL);
3295	if (frame && framemaster)
3296	*framemaster = of_parse_phandle(np, phandle_name: prop, index: 0);
3297
3298	/*
3299	* return bitmap.
3300	* It will be parameter of
3301	* snd_soc_daifmt_clock_provider_from_bitmap()
3302	*/
3303	return (bit << 4) + frame;
3304	}
3305	EXPORT_SYMBOL_GPL(snd_soc_daifmt_parse_clock_provider_raw);
3306
3307	int snd_soc_get_stream_cpu(struct snd_soc_dai_link *dai_link, int stream)
3308	{
3309	/*
3310	* [Normal]
3311	*
3312	* Playback
3313	* CPU : SNDRV_PCM_STREAM_PLAYBACK
3314	* Codec: SNDRV_PCM_STREAM_PLAYBACK
3315	*
3316	* Capture
3317	* CPU : SNDRV_PCM_STREAM_CAPTURE
3318	* Codec: SNDRV_PCM_STREAM_CAPTURE
3319	*/
3320	if (!dai_link->c2c_params)
3321	return stream;
3322
3323	/*
3324	* [Codec2Codec]
3325	*
3326	* Playback
3327	* CPU : SNDRV_PCM_STREAM_CAPTURE
3328	* Codec: SNDRV_PCM_STREAM_PLAYBACK
3329	*
3330	* Capture
3331	* CPU : SNDRV_PCM_STREAM_PLAYBACK
3332	* Codec: SNDRV_PCM_STREAM_CAPTURE
3333	*/
3334	if (stream == SNDRV_PCM_STREAM_CAPTURE)
3335	return SNDRV_PCM_STREAM_PLAYBACK;
3336
3337	return SNDRV_PCM_STREAM_CAPTURE;
3338	}
3339	EXPORT_SYMBOL_GPL(snd_soc_get_stream_cpu);
3340
3341	int snd_soc_get_dai_id(struct device_node *ep)
3342	{
3343	struct snd_soc_component *component;
3344	struct snd_soc_dai_link_component dlc = {
3345	.of_node = of_graph_get_port_parent(node: ep),
3346	};
3347	int ret;
3348
3349
3350	/*
3351	* For example HDMI case, HDMI has video/sound port,
3352	* but ALSA SoC needs sound port number only.
3353	* Thus counting HDMI DT port/endpoint doesn't work.
3354	* Then, it should have .of_xlate_dai_id
3355	*/
3356	ret = -ENOTSUPP;
3357	mutex_lock(&client_mutex);
3358	component = soc_find_component(dlc: &dlc);
3359	if (component)
3360	ret = snd_soc_component_of_xlate_dai_id(component, ep);
3361	mutex_unlock(lock: &client_mutex);
3362
3363	of_node_put(node: dlc.of_node);
3364
3365	return ret;
3366	}
3367	EXPORT_SYMBOL_GPL(snd_soc_get_dai_id);
3368
3369	int snd_soc_get_dlc(const struct of_phandle_args *args, struct snd_soc_dai_link_component *dlc)
3370	{
3371	struct snd_soc_component *pos;
3372	int ret = -EPROBE_DEFER;
3373
3374	mutex_lock(&client_mutex);
3375	for_each_component(pos) {
3376	struct device_node *component_of_node = soc_component_to_node(component: pos);
3377
3378	if (component_of_node != args->np || !pos->num_dai)
3379	continue;
3380
3381	ret = snd_soc_component_of_xlate_dai_name(component: pos, args, dai_name: &dlc->dai_name);
3382	if (ret == -ENOTSUPP) {
3383	struct snd_soc_dai *dai;
3384	int id = -1;
3385
3386	switch (args->args_count) {
3387	case 0:
3388	id = 0; /* same as dai_drv[0] */
3389	break;
3390	case 1:
3391	id = args->args[0];
3392	break;
3393	default:
3394	/* not supported */
3395	break;
3396	}
3397
3398	if (id < 0 || id >= pos->num_dai) {
3399	ret = -EINVAL;
3400	continue;
3401	}
3402
3403	ret = 0;
3404
3405	/* find target DAI */
3406	for_each_component_dais(pos, dai) {
3407	if (id == 0)
3408	break;
3409	id--;
3410	}
3411
3412	dlc->dai_name = snd_soc_dai_name_get(dai);
3413	} else if (ret) {
3414	/*
3415	* if another error than ENOTSUPP is returned go on and
3416	* check if another component is provided with the same
3417	* node. This may happen if a device provides several
3418	* components
3419	*/
3420	continue;
3421	}
3422
3423	break;
3424	}
3425
3426	if (ret == 0)
3427	dlc->of_node = args->np;
3428
3429	mutex_unlock(lock: &client_mutex);
3430	return ret;
3431	}
3432	EXPORT_SYMBOL_GPL(snd_soc_get_dlc);
3433
3434	int snd_soc_of_get_dlc(struct device_node *of_node,
3435	struct of_phandle_args *args,
3436	struct snd_soc_dai_link_component *dlc,
3437	int index)
3438	{
3439	struct of_phandle_args __args;
3440	int ret;
3441
3442	if (!args)
3443	args = &__args;
3444
3445	ret = of_parse_phandle_with_args(np: of_node, list_name: "sound-dai",
3446	cells_name: "#sound-dai-cells", index, out_args: args);
3447	if (ret)
3448	return ret;
3449
3450	return snd_soc_get_dlc(args, dlc);
3451	}
3452	EXPORT_SYMBOL_GPL(snd_soc_of_get_dlc);
3453
3454	int snd_soc_get_dai_name(const struct of_phandle_args *args,
3455	const char **dai_name)
3456	{
3457	struct snd_soc_dai_link_component dlc;
3458	int ret = snd_soc_get_dlc(args, &dlc);
3459
3460	if (ret == 0)
3461	*dai_name = dlc.dai_name;
3462
3463	return ret;
3464	}
3465	EXPORT_SYMBOL_GPL(snd_soc_get_dai_name);
3466
3467	int snd_soc_of_get_dai_name(struct device_node *of_node,
3468	const char **dai_name, int index)
3469	{
3470	struct snd_soc_dai_link_component dlc;
3471	int ret = snd_soc_of_get_dlc(of_node, NULL, &dlc, index);
3472
3473	if (ret == 0)
3474	*dai_name = dlc.dai_name;
3475
3476	return ret;
3477	}
3478	EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);
3479
3480	struct snd_soc_dai *snd_soc_get_dai_via_args(struct of_phandle_args *dai_args)
3481	{
3482	struct snd_soc_dai *dai;
3483	struct snd_soc_component *component;
3484
3485	mutex_lock(&client_mutex);
3486	for_each_component(component) {
3487	for_each_component_dais(component, dai)
3488	if (snd_soc_is_match_dai_args(args1: dai->driver->dai_args, args2: dai_args))
3489	goto found;
3490	}
3491	dai = NULL;
3492	found:
3493	mutex_unlock(lock: &client_mutex);
3494	return dai;
3495	}
3496	EXPORT_SYMBOL_GPL(snd_soc_get_dai_via_args);
3497
3498	static void __snd_soc_of_put_component(struct snd_soc_dai_link_component *component)
3499	{
3500	if (component->of_node) {
3501	of_node_put(node: component->of_node);
3502	component->of_node = NULL;
3503	}
3504	}
3505
3506	static int __snd_soc_of_get_dai_link_component_alloc(
3507	struct device *dev, struct device_node *of_node,
3508	struct snd_soc_dai_link_component **ret_component,
3509	int *ret_num)
3510	{
3511	struct snd_soc_dai_link_component *component;
3512	int num;
3513
3514	/* Count the number of CPUs/CODECs */
3515	num = of_count_phandle_with_args(np: of_node, list_name: "sound-dai", cells_name: "#sound-dai-cells");
3516	if (num <= 0) {
3517	if (num == -ENOENT)
3518	dev_err(dev, "No 'sound-dai' property\n");
3519	else
3520	dev_err(dev, "Bad phandle in 'sound-dai'\n");
3521	return num;
3522	}
3523	component = devm_kcalloc(dev, n: num, size: sizeof(*component), GFP_KERNEL);
3524	if (!component)
3525	return -ENOMEM;
3526
3527	*ret_component = component;
3528	*ret_num = num;
3529
3530	return 0;
3531	}
3532
3533	/*
3534	* snd_soc_of_put_dai_link_codecs - Dereference device nodes in the codecs array
3535	* @dai_link: DAI link
3536	*
3537	* Dereference device nodes acquired by snd_soc_of_get_dai_link_codecs().
3538	*/
3539	void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link)
3540	{
3541	struct snd_soc_dai_link_component *component;
3542	int index;
3543
3544	for_each_link_codecs(dai_link, index, component)
3545	__snd_soc_of_put_component(component);
3546	}
3547	EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_codecs);
3548
3549	/*
3550	* snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree
3551	* @dev: Card device
3552	* @of_node: Device node
3553	* @dai_link: DAI link
3554	*
3555	* Builds an array of CODEC DAI components from the DAI link property
3556	* 'sound-dai'.
3557	* The array is set in the DAI link and the number of DAIs is set accordingly.
3558	* The device nodes in the array (of_node) must be dereferenced by calling
3559	* snd_soc_of_put_dai_link_codecs() on @dai_link.
3560	*
3561	* Returns 0 for success
3562	*/
3563	int snd_soc_of_get_dai_link_codecs(struct device *dev,
3564	struct device_node *of_node,
3565	struct snd_soc_dai_link *dai_link)
3566	{
3567	struct snd_soc_dai_link_component *component;
3568	int index, ret;
3569
3570	ret = __snd_soc_of_get_dai_link_component_alloc(dev, of_node,
3571	ret_component: &dai_link->codecs, ret_num: &dai_link->num_codecs);
3572	if (ret < 0)
3573	return ret;
3574
3575	/* Parse the list */
3576	for_each_link_codecs(dai_link, index, component) {
3577	ret = snd_soc_of_get_dlc(of_node, NULL, component, index);
3578	if (ret)
3579	goto err;
3580	}
3581	return 0;
3582	err:
3583	snd_soc_of_put_dai_link_codecs(dai_link);
3584	dai_link->codecs = NULL;
3585	dai_link->num_codecs = 0;
3586	return ret;
3587	}
3588	EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);
3589
3590	/*
3591	* snd_soc_of_put_dai_link_cpus - Dereference device nodes in the codecs array
3592	* @dai_link: DAI link
3593	*
3594	* Dereference device nodes acquired by snd_soc_of_get_dai_link_cpus().
3595	*/
3596	void snd_soc_of_put_dai_link_cpus(struct snd_soc_dai_link *dai_link)
3597	{
3598	struct snd_soc_dai_link_component *component;
3599	int index;
3600
3601	for_each_link_cpus(dai_link, index, component)
3602	__snd_soc_of_put_component(component);
3603	}
3604	EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_cpus);
3605
3606	/*
3607	* snd_soc_of_get_dai_link_cpus - Parse a list of CPU DAIs in the devicetree
3608	* @dev: Card device
3609	* @of_node: Device node
3610	* @dai_link: DAI link
3611	*
3612	* Is analogous to snd_soc_of_get_dai_link_codecs but parses a list of CPU DAIs
3613	* instead.
3614	*
3615	* Returns 0 for success
3616	*/
3617	int snd_soc_of_get_dai_link_cpus(struct device *dev,
3618	struct device_node *of_node,
3619	struct snd_soc_dai_link *dai_link)
3620	{
3621	struct snd_soc_dai_link_component *component;
3622	int index, ret;
3623
3624	/* Count the number of CPUs */
3625	ret = __snd_soc_of_get_dai_link_component_alloc(dev, of_node,
3626	ret_component: &dai_link->cpus, ret_num: &dai_link->num_cpus);
3627	if (ret < 0)
3628	return ret;
3629
3630	/* Parse the list */
3631	for_each_link_cpus(dai_link, index, component) {
3632	ret = snd_soc_of_get_dlc(of_node, NULL, component, index);
3633	if (ret)
3634	goto err;
3635	}
3636	return 0;
3637	err:
3638	snd_soc_of_put_dai_link_cpus(dai_link);
3639	dai_link->cpus = NULL;
3640	dai_link->num_cpus = 0;
3641	return ret;
3642	}
3643	EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_cpus);
3644
3645	static int __init snd_soc_init(void)
3646	{
3647	int ret;
3648
3649	snd_soc_debugfs_init();
3650	ret = snd_soc_util_init();
3651	if (ret)
3652	goto err_util_init;
3653
3654	ret = platform_driver_register(&soc_driver);
3655	if (ret)
3656	goto err_register;
3657	return 0;
3658
3659	err_register:
3660	snd_soc_util_exit();
3661	err_util_init:
3662	snd_soc_debugfs_exit();
3663	return ret;
3664	}
3665	module_init(snd_soc_init);
3666
3667	static void __exit snd_soc_exit(void)
3668	{
3669	snd_soc_util_exit();
3670	snd_soc_debugfs_exit();
3671
3672	platform_driver_unregister(&soc_driver);
3673	}
3674	module_exit(snd_soc_exit);
3675
3676	/* Module information */
3677	MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
3678	MODULE_DESCRIPTION("ALSA SoC Core");
3679	MODULE_LICENSE("GPL");
3680	MODULE_ALIAS("platform:soc-audio");
3681