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