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