1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <linux/module.h>
26#include <linux/moduleparam.h>
27#include <linux/init.h>
28#include <linux/delay.h>
29#include <linux/pm.h>
30#include <linux/bitops.h>
31#include <linux/debugfs.h>
32#include <linux/platform_device.h>
33#include <linux/pinctrl/consumer.h>
34#include <linux/ctype.h>
35#include <linux/slab.h>
36#include <linux/of.h>
37#include <linux/of_graph.h>
38#include <linux/dmi.h>
39#include <sound/core.h>
40#include <sound/jack.h>
41#include <sound/pcm.h>
42#include <sound/pcm_params.h>
43#include <sound/soc.h>
44#include <sound/soc-dpcm.h>
45#include <sound/soc-topology.h>
46#include <sound/initval.h>
47
48#define CREATE_TRACE_POINTS
49#include <trace/events/asoc.h>
50
51#define NAME_SIZE 32
52
53#ifdef CONFIG_DEBUG_FS
54struct dentry *snd_soc_debugfs_root;
55EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
56#endif
57
58static DEFINE_MUTEX(client_mutex);
59static LIST_HEAD(platform_list);
60static LIST_HEAD(codec_list);
61static LIST_HEAD(component_list);
62
63
64
65
66
67
68static int pmdown_time = 5000;
69module_param(pmdown_time, int, 0);
70MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
71
72
73
74
75
76static const char * const dmi_blacklist[] = {
77 "To be filled by OEM",
78 "TBD by OEM",
79 "Default String",
80 "Board Manufacturer",
81 "Board Vendor Name",
82 "Board Product Name",
83 NULL,
84};
85
86
87
88static int min_bytes_needed(unsigned long val)
89{
90 int c = 0;
91 int i;
92
93 for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
94 if (val & (1UL << i))
95 break;
96 c = (sizeof val * 8) - c;
97 if (!c || (c % 8))
98 c = (c + 8) / 8;
99 else
100 c /= 8;
101 return c;
102}
103
104
105
106static int format_register_str(struct snd_soc_codec *codec,
107 unsigned int reg, char *buf, size_t len)
108{
109 int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
110 int regsize = codec->driver->reg_word_size * 2;
111 int ret;
112
113
114 if (wordsize + regsize + 2 + 1 != len)
115 return -EINVAL;
116
117 sprintf(buf, "%.*x: ", wordsize, reg);
118 buf += wordsize + 2;
119
120 ret = snd_soc_read(codec, reg);
121 if (ret < 0)
122 memset(buf, 'X', regsize);
123 else
124 sprintf(buf, "%.*x", regsize, ret);
125 buf[regsize] = '\n';
126
127 return 0;
128}
129
130
131static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
132 size_t count, loff_t pos)
133{
134 int i, step = 1;
135 int wordsize, regsize;
136 int len;
137 size_t total = 0;
138 loff_t p = 0;
139
140 wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
141 regsize = codec->driver->reg_word_size * 2;
142
143 len = wordsize + regsize + 2 + 1;
144
145 if (!codec->driver->reg_cache_size)
146 return 0;
147
148 if (codec->driver->reg_cache_step)
149 step = codec->driver->reg_cache_step;
150
151 for (i = 0; i < codec->driver->reg_cache_size; i += step) {
152
153
154 if (p >= pos) {
155 if (total + len >= count - 1)
156 break;
157 format_register_str(codec, i, buf + total, len);
158 total += len;
159 }
160 p += len;
161 }
162
163 total = min(total, count - 1);
164
165 return total;
166}
167
168static ssize_t codec_reg_show(struct device *dev,
169 struct device_attribute *attr, char *buf)
170{
171 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
172
173 return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
174}
175
176static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
177
178static ssize_t pmdown_time_show(struct device *dev,
179 struct device_attribute *attr, char *buf)
180{
181 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
182
183 return sprintf(buf, "%ld\n", rtd->pmdown_time);
184}
185
186static ssize_t pmdown_time_set(struct device *dev,
187 struct device_attribute *attr,
188 const char *buf, size_t count)
189{
190 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
191 int ret;
192
193 ret = kstrtol(buf, 10, &rtd->pmdown_time);
194 if (ret)
195 return ret;
196
197 return count;
198}
199
200static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
201
202static struct attribute *soc_dev_attrs[] = {
203 &dev_attr_codec_reg.attr,
204 &dev_attr_pmdown_time.attr,
205 NULL
206};
207
208static umode_t soc_dev_attr_is_visible(struct kobject *kobj,
209 struct attribute *attr, int idx)
210{
211 struct device *dev = kobj_to_dev(kobj);
212 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
213
214 if (attr == &dev_attr_pmdown_time.attr)
215 return attr->mode;
216 return rtd->codec ? attr->mode : 0;
217}
218
219static const struct attribute_group soc_dapm_dev_group = {
220 .attrs = soc_dapm_dev_attrs,
221 .is_visible = soc_dev_attr_is_visible,
222};
223
224static const struct attribute_group soc_dev_roup = {
225 .attrs = soc_dev_attrs,
226 .is_visible = soc_dev_attr_is_visible,
227};
228
229static const struct attribute_group *soc_dev_attr_groups[] = {
230 &soc_dapm_dev_group,
231 &soc_dev_roup,
232 NULL
233};
234
235#ifdef CONFIG_DEBUG_FS
236static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
237 size_t count, loff_t *ppos)
238{
239 ssize_t ret;
240 struct snd_soc_codec *codec = file->private_data;
241 char *buf;
242
243 if (*ppos < 0 || !count)
244 return -EINVAL;
245
246 buf = kmalloc(count, GFP_KERNEL);
247 if (!buf)
248 return -ENOMEM;
249
250 ret = soc_codec_reg_show(codec, buf, count, *ppos);
251 if (ret >= 0) {
252 if (copy_to_user(user_buf, buf, ret)) {
253 kfree(buf);
254 return -EFAULT;
255 }
256 *ppos += ret;
257 }
258
259 kfree(buf);
260 return ret;
261}
262
263static ssize_t codec_reg_write_file(struct file *file,
264 const char __user *user_buf, size_t count, loff_t *ppos)
265{
266 char buf[32];
267 size_t buf_size;
268 char *start = buf;
269 unsigned long reg, value;
270 struct snd_soc_codec *codec = file->private_data;
271 int ret;
272
273 buf_size = min(count, (sizeof(buf)-1));
274 if (copy_from_user(buf, user_buf, buf_size))
275 return -EFAULT;
276 buf[buf_size] = 0;
277
278 while (*start == ' ')
279 start++;
280 reg = simple_strtoul(start, &start, 16);
281 while (*start == ' ')
282 start++;
283 ret = kstrtoul(start, 16, &value);
284 if (ret)
285 return ret;
286
287
288 add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
289
290 snd_soc_write(codec, reg, value);
291 return buf_size;
292}
293
294static const struct file_operations codec_reg_fops = {
295 .open = simple_open,
296 .read = codec_reg_read_file,
297 .write = codec_reg_write_file,
298 .llseek = default_llseek,
299};
300
301static void soc_init_component_debugfs(struct snd_soc_component *component)
302{
303 if (!component->card->debugfs_card_root)
304 return;
305
306 if (component->debugfs_prefix) {
307 char *name;
308
309 name = kasprintf(GFP_KERNEL, "%s:%s",
310 component->debugfs_prefix, component->name);
311 if (name) {
312 component->debugfs_root = debugfs_create_dir(name,
313 component->card->debugfs_card_root);
314 kfree(name);
315 }
316 } else {
317 component->debugfs_root = debugfs_create_dir(component->name,
318 component->card->debugfs_card_root);
319 }
320
321 if (!component->debugfs_root) {
322 dev_warn(component->dev,
323 "ASoC: Failed to create component debugfs directory\n");
324 return;
325 }
326
327 snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),
328 component->debugfs_root);
329
330 if (component->init_debugfs)
331 component->init_debugfs(component);
332}
333
334static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
335{
336 debugfs_remove_recursive(component->debugfs_root);
337}
338
339static void soc_init_codec_debugfs(struct snd_soc_component *component)
340{
341 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
342
343 codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
344 codec->component.debugfs_root,
345 codec, &codec_reg_fops);
346 if (!codec->debugfs_reg)
347 dev_warn(codec->dev,
348 "ASoC: Failed to create codec register debugfs file\n");
349}
350
351static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
352 size_t count, loff_t *ppos)
353{
354 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
355 ssize_t len, ret = 0;
356 struct snd_soc_codec *codec;
357
358 if (!buf)
359 return -ENOMEM;
360
361 mutex_lock(&client_mutex);
362
363 list_for_each_entry(codec, &codec_list, list) {
364 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
365 codec->component.name);
366 if (len >= 0)
367 ret += len;
368 if (ret > PAGE_SIZE) {
369 ret = PAGE_SIZE;
370 break;
371 }
372 }
373
374 mutex_unlock(&client_mutex);
375
376 if (ret >= 0)
377 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
378
379 kfree(buf);
380
381 return ret;
382}
383
384static const struct file_operations codec_list_fops = {
385 .read = codec_list_read_file,
386 .llseek = default_llseek,
387};
388
389static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
390 size_t count, loff_t *ppos)
391{
392 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
393 ssize_t len, ret = 0;
394 struct snd_soc_component *component;
395 struct snd_soc_dai *dai;
396
397 if (!buf)
398 return -ENOMEM;
399
400 mutex_lock(&client_mutex);
401
402 list_for_each_entry(component, &component_list, list) {
403 list_for_each_entry(dai, &component->dai_list, list) {
404 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
405 dai->name);
406 if (len >= 0)
407 ret += len;
408 if (ret > PAGE_SIZE) {
409 ret = PAGE_SIZE;
410 break;
411 }
412 }
413 }
414
415 mutex_unlock(&client_mutex);
416
417 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
418
419 kfree(buf);
420
421 return ret;
422}
423
424static const struct file_operations dai_list_fops = {
425 .read = dai_list_read_file,
426 .llseek = default_llseek,
427};
428
429static ssize_t platform_list_read_file(struct file *file,
430 char __user *user_buf,
431 size_t count, loff_t *ppos)
432{
433 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
434 ssize_t len, ret = 0;
435 struct snd_soc_platform *platform;
436
437 if (!buf)
438 return -ENOMEM;
439
440 mutex_lock(&client_mutex);
441
442 list_for_each_entry(platform, &platform_list, list) {
443 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
444 platform->component.name);
445 if (len >= 0)
446 ret += len;
447 if (ret > PAGE_SIZE) {
448 ret = PAGE_SIZE;
449 break;
450 }
451 }
452
453 mutex_unlock(&client_mutex);
454
455 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
456
457 kfree(buf);
458
459 return ret;
460}
461
462static const struct file_operations platform_list_fops = {
463 .read = platform_list_read_file,
464 .llseek = default_llseek,
465};
466
467static void soc_init_card_debugfs(struct snd_soc_card *card)
468{
469 if (!snd_soc_debugfs_root)
470 return;
471
472 card->debugfs_card_root = debugfs_create_dir(card->name,
473 snd_soc_debugfs_root);
474 if (!card->debugfs_card_root) {
475 dev_warn(card->dev,
476 "ASoC: Failed to create card debugfs directory\n");
477 return;
478 }
479
480 card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
481 card->debugfs_card_root,
482 &card->pop_time);
483 if (!card->debugfs_pop_time)
484 dev_warn(card->dev,
485 "ASoC: Failed to create pop time debugfs file\n");
486}
487
488static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
489{
490 debugfs_remove_recursive(card->debugfs_card_root);
491}
492
493
494static void snd_soc_debugfs_init(void)
495{
496 snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
497 if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
498 pr_warn("ASoC: Failed to create debugfs directory\n");
499 snd_soc_debugfs_root = NULL;
500 return;
501 }
502
503 if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
504 &codec_list_fops))
505 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
506
507 if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
508 &dai_list_fops))
509 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
510
511 if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
512 &platform_list_fops))
513 pr_warn("ASoC: Failed to create platform list debugfs file\n");
514}
515
516static void snd_soc_debugfs_exit(void)
517{
518 debugfs_remove_recursive(snd_soc_debugfs_root);
519}
520
521#else
522
523#define soc_init_codec_debugfs NULL
524
525static inline void soc_init_component_debugfs(
526 struct snd_soc_component *component)
527{
528}
529
530static inline void soc_cleanup_component_debugfs(
531 struct snd_soc_component *component)
532{
533}
534
535static inline void soc_init_card_debugfs(struct snd_soc_card *card)
536{
537}
538
539static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
540{
541}
542
543static inline void snd_soc_debugfs_init(void)
544{
545}
546
547static inline void snd_soc_debugfs_exit(void)
548{
549}
550
551#endif
552
553struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
554 const char *dai_link, int stream)
555{
556 struct snd_soc_pcm_runtime *rtd;
557
558 list_for_each_entry(rtd, &card->rtd_list, list) {
559 if (rtd->dai_link->no_pcm &&
560 !strcmp(rtd->dai_link->name, dai_link))
561 return rtd->pcm->streams[stream].substream;
562 }
563 dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link);
564 return NULL;
565}
566EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
567
568static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
569 struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
570{
571 struct snd_soc_pcm_runtime *rtd;
572
573 rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
574 if (!rtd)
575 return NULL;
576
577 rtd->card = card;
578 rtd->dai_link = dai_link;
579 rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) *
580 dai_link->num_codecs,
581 GFP_KERNEL);
582 if (!rtd->codec_dais) {
583 kfree(rtd);
584 return NULL;
585 }
586
587 return rtd;
588}
589
590static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
591{
592 if (rtd && rtd->codec_dais)
593 kfree(rtd->codec_dais);
594 kfree(rtd);
595}
596
597static void soc_add_pcm_runtime(struct snd_soc_card *card,
598 struct snd_soc_pcm_runtime *rtd)
599{
600 list_add_tail(&rtd->list, &card->rtd_list);
601 rtd->num = card->num_rtd;
602 card->num_rtd++;
603}
604
605static void soc_remove_pcm_runtimes(struct snd_soc_card *card)
606{
607 struct snd_soc_pcm_runtime *rtd, *_rtd;
608
609 list_for_each_entry_safe(rtd, _rtd, &card->rtd_list, list) {
610 list_del(&rtd->list);
611 soc_free_pcm_runtime(rtd);
612 }
613
614 card->num_rtd = 0;
615}
616
617struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
618 const char *dai_link)
619{
620 struct snd_soc_pcm_runtime *rtd;
621
622 list_for_each_entry(rtd, &card->rtd_list, list) {
623 if (!strcmp(rtd->dai_link->name, dai_link))
624 return rtd;
625 }
626 dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
627 return NULL;
628}
629EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
630
631static void codec2codec_close_delayed_work(struct work_struct *work)
632{
633
634
635
636
637
638}
639
640#ifdef CONFIG_PM_SLEEP
641
642int snd_soc_suspend(struct device *dev)
643{
644 struct snd_soc_card *card = dev_get_drvdata(dev);
645 struct snd_soc_component *component;
646 struct snd_soc_pcm_runtime *rtd;
647 int i;
648
649
650 if (!card->instantiated)
651 return 0;
652
653
654
655
656 snd_power_lock(card->snd_card);
657 snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
658 snd_power_unlock(card->snd_card);
659
660
661 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
662
663
664 list_for_each_entry(rtd, &card->rtd_list, list) {
665
666 if (rtd->dai_link->ignore_suspend)
667 continue;
668
669 for (i = 0; i < rtd->num_codecs; i++) {
670 struct snd_soc_dai *dai = rtd->codec_dais[i];
671 struct snd_soc_dai_driver *drv = dai->driver;
672
673 if (drv->ops->digital_mute && dai->playback_active)
674 drv->ops->digital_mute(dai, 1);
675 }
676 }
677
678
679 list_for_each_entry(rtd, &card->rtd_list, list) {
680 if (rtd->dai_link->ignore_suspend)
681 continue;
682
683 snd_pcm_suspend_all(rtd->pcm);
684 }
685
686 if (card->suspend_pre)
687 card->suspend_pre(card);
688
689 list_for_each_entry(rtd, &card->rtd_list, list) {
690 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
691
692 if (rtd->dai_link->ignore_suspend)
693 continue;
694
695 if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
696 cpu_dai->driver->suspend(cpu_dai);
697 }
698
699
700 list_for_each_entry(rtd, &card->rtd_list, list)
701 flush_delayed_work(&rtd->delayed_work);
702
703 list_for_each_entry(rtd, &card->rtd_list, list) {
704
705 if (rtd->dai_link->ignore_suspend)
706 continue;
707
708 snd_soc_dapm_stream_event(rtd,
709 SNDRV_PCM_STREAM_PLAYBACK,
710 SND_SOC_DAPM_STREAM_SUSPEND);
711
712 snd_soc_dapm_stream_event(rtd,
713 SNDRV_PCM_STREAM_CAPTURE,
714 SND_SOC_DAPM_STREAM_SUSPEND);
715 }
716
717
718 dapm_mark_endpoints_dirty(card);
719 snd_soc_dapm_sync(&card->dapm);
720
721
722 list_for_each_entry(component, &card->component_dev_list, card_list) {
723 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
724
725
726
727 if (!component->suspended) {
728 switch (snd_soc_dapm_get_bias_level(dapm)) {
729 case SND_SOC_BIAS_STANDBY:
730
731
732
733
734
735
736 if (dapm->idle_bias_off) {
737 dev_dbg(component->dev,
738 "ASoC: idle_bias_off CODEC on over suspend\n");
739 break;
740 }
741
742 case SND_SOC_BIAS_OFF:
743 if (component->suspend)
744 component->suspend(component);
745 component->suspended = 1;
746 if (component->regmap)
747 regcache_mark_dirty(component->regmap);
748
749 pinctrl_pm_select_sleep_state(component->dev);
750 break;
751 default:
752 dev_dbg(component->dev,
753 "ASoC: COMPONENT is on over suspend\n");
754 break;
755 }
756 }
757 }
758
759 list_for_each_entry(rtd, &card->rtd_list, list) {
760 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
761
762 if (rtd->dai_link->ignore_suspend)
763 continue;
764
765 if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)
766 cpu_dai->driver->suspend(cpu_dai);
767
768
769 pinctrl_pm_select_sleep_state(cpu_dai->dev);
770 }
771
772 if (card->suspend_post)
773 card->suspend_post(card);
774
775 return 0;
776}
777EXPORT_SYMBOL_GPL(snd_soc_suspend);
778
779
780
781
782static void soc_resume_deferred(struct work_struct *work)
783{
784 struct snd_soc_card *card =
785 container_of(work, struct snd_soc_card, deferred_resume_work);
786 struct snd_soc_pcm_runtime *rtd;
787 struct snd_soc_component *component;
788 int i;
789
790
791
792
793
794 dev_dbg(card->dev, "ASoC: starting resume work\n");
795
796
797 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
798
799 if (card->resume_pre)
800 card->resume_pre(card);
801
802
803 list_for_each_entry(rtd, &card->rtd_list, list) {
804 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
805
806 if (rtd->dai_link->ignore_suspend)
807 continue;
808
809 if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)
810 cpu_dai->driver->resume(cpu_dai);
811 }
812
813 list_for_each_entry(component, &card->component_dev_list, card_list) {
814 if (component->suspended) {
815 if (component->resume)
816 component->resume(component);
817 component->suspended = 0;
818 }
819 }
820
821 list_for_each_entry(rtd, &card->rtd_list, list) {
822
823 if (rtd->dai_link->ignore_suspend)
824 continue;
825
826 snd_soc_dapm_stream_event(rtd,
827 SNDRV_PCM_STREAM_PLAYBACK,
828 SND_SOC_DAPM_STREAM_RESUME);
829
830 snd_soc_dapm_stream_event(rtd,
831 SNDRV_PCM_STREAM_CAPTURE,
832 SND_SOC_DAPM_STREAM_RESUME);
833 }
834
835
836 list_for_each_entry(rtd, &card->rtd_list, list) {
837
838 if (rtd->dai_link->ignore_suspend)
839 continue;
840
841 for (i = 0; i < rtd->num_codecs; i++) {
842 struct snd_soc_dai *dai = rtd->codec_dais[i];
843 struct snd_soc_dai_driver *drv = dai->driver;
844
845 if (drv->ops->digital_mute && dai->playback_active)
846 drv->ops->digital_mute(dai, 0);
847 }
848 }
849
850 list_for_each_entry(rtd, &card->rtd_list, list) {
851 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
852
853 if (rtd->dai_link->ignore_suspend)
854 continue;
855
856 if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
857 cpu_dai->driver->resume(cpu_dai);
858 }
859
860 if (card->resume_post)
861 card->resume_post(card);
862
863 dev_dbg(card->dev, "ASoC: resume work completed\n");
864
865
866 dapm_mark_endpoints_dirty(card);
867 snd_soc_dapm_sync(&card->dapm);
868
869
870 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
871}
872
873
874int snd_soc_resume(struct device *dev)
875{
876 struct snd_soc_card *card = dev_get_drvdata(dev);
877 bool bus_control = false;
878 struct snd_soc_pcm_runtime *rtd;
879
880
881 if (!card->instantiated)
882 return 0;
883
884
885 list_for_each_entry(rtd, &card->rtd_list, list) {
886 struct snd_soc_dai **codec_dais = rtd->codec_dais;
887 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
888 int j;
889
890 if (cpu_dai->active)
891 pinctrl_pm_select_default_state(cpu_dai->dev);
892
893 for (j = 0; j < rtd->num_codecs; j++) {
894 struct snd_soc_dai *codec_dai = codec_dais[j];
895 if (codec_dai->active)
896 pinctrl_pm_select_default_state(codec_dai->dev);
897 }
898 }
899
900
901
902
903
904
905
906 list_for_each_entry(rtd, &card->rtd_list, list) {
907 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
908 bus_control |= cpu_dai->driver->bus_control;
909 }
910 if (bus_control) {
911 dev_dbg(dev, "ASoC: Resuming control bus master immediately\n");
912 soc_resume_deferred(&card->deferred_resume_work);
913 } else {
914 dev_dbg(dev, "ASoC: Scheduling resume work\n");
915 if (!schedule_work(&card->deferred_resume_work))
916 dev_err(dev, "ASoC: resume work item may be lost\n");
917 }
918
919 return 0;
920}
921EXPORT_SYMBOL_GPL(snd_soc_resume);
922#else
923#define snd_soc_suspend NULL
924#define snd_soc_resume NULL
925#endif
926
927static const struct snd_soc_dai_ops null_dai_ops = {
928};
929
930static struct snd_soc_component *soc_find_component(
931 const struct device_node *of_node, const char *name)
932{
933 struct snd_soc_component *component;
934
935 lockdep_assert_held(&client_mutex);
936
937 list_for_each_entry(component, &component_list, list) {
938 if (of_node) {
939 if (component->dev->of_node == of_node)
940 return component;
941 } else if (strcmp(component->name, name) == 0) {
942 return component;
943 }
944 }
945
946 return NULL;
947}
948
949
950
951
952
953
954
955
956
957
958
959
960struct snd_soc_dai *snd_soc_find_dai(
961 const struct snd_soc_dai_link_component *dlc)
962{
963 struct snd_soc_component *component;
964 struct snd_soc_dai *dai;
965 struct device_node *component_of_node;
966
967 lockdep_assert_held(&client_mutex);
968
969
970 list_for_each_entry(component, &component_list, list) {
971 component_of_node = component->dev->of_node;
972 if (!component_of_node && component->dev->parent)
973 component_of_node = component->dev->parent->of_node;
974
975 if (dlc->of_node && component_of_node != dlc->of_node)
976 continue;
977 if (dlc->name && strcmp(component->name, dlc->name))
978 continue;
979 list_for_each_entry(dai, &component->dai_list, list) {
980 if (dlc->dai_name && strcmp(dai->name, dlc->dai_name))
981 continue;
982
983 return dai;
984 }
985 }
986
987 return NULL;
988}
989EXPORT_SYMBOL_GPL(snd_soc_find_dai);
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
1008 int id, const char *name,
1009 const char *stream_name)
1010{
1011 struct snd_soc_dai_link *link, *_link;
1012
1013 lockdep_assert_held(&client_mutex);
1014
1015 list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1016 if (link->id != id)
1017 continue;
1018
1019 if (name && (!link->name || strcmp(name, link->name)))
1020 continue;
1021
1022 if (stream_name && (!link->stream_name
1023 || strcmp(stream_name, link->stream_name)))
1024 continue;
1025
1026 return link;
1027 }
1028
1029 return NULL;
1030}
1031EXPORT_SYMBOL_GPL(snd_soc_find_dai_link);
1032
1033static bool soc_is_dai_link_bound(struct snd_soc_card *card,
1034 struct snd_soc_dai_link *dai_link)
1035{
1036 struct snd_soc_pcm_runtime *rtd;
1037
1038 list_for_each_entry(rtd, &card->rtd_list, list) {
1039 if (rtd->dai_link == dai_link)
1040 return true;
1041 }
1042
1043 return false;
1044}
1045
1046static int soc_bind_dai_link(struct snd_soc_card *card,
1047 struct snd_soc_dai_link *dai_link)
1048{
1049 struct snd_soc_pcm_runtime *rtd;
1050 struct snd_soc_dai_link_component *codecs = dai_link->codecs;
1051 struct snd_soc_dai_link_component cpu_dai_component;
1052 struct snd_soc_dai **codec_dais;
1053 struct snd_soc_platform *platform;
1054 struct device_node *platform_of_node;
1055 const char *platform_name;
1056 int i;
1057
1058 dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name);
1059
1060 if (soc_is_dai_link_bound(card, dai_link)) {
1061 dev_dbg(card->dev, "ASoC: dai link %s already bound\n",
1062 dai_link->name);
1063 return 0;
1064 }
1065
1066 rtd = soc_new_pcm_runtime(card, dai_link);
1067 if (!rtd)
1068 return -ENOMEM;
1069
1070 cpu_dai_component.name = dai_link->cpu_name;
1071 cpu_dai_component.of_node = dai_link->cpu_of_node;
1072 cpu_dai_component.dai_name = dai_link->cpu_dai_name;
1073 rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);
1074 if (!rtd->cpu_dai) {
1075 dev_err(card->dev, "ASoC: CPU DAI %s not registered\n",
1076 dai_link->cpu_dai_name);
1077 goto _err_defer;
1078 }
1079
1080 rtd->num_codecs = dai_link->num_codecs;
1081
1082
1083 codec_dais = rtd->codec_dais;
1084 for (i = 0; i < rtd->num_codecs; i++) {
1085 codec_dais[i] = snd_soc_find_dai(&codecs[i]);
1086 if (!codec_dais[i]) {
1087 dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
1088 codecs[i].dai_name);
1089 goto _err_defer;
1090 }
1091 }
1092
1093
1094 rtd->codec_dai = codec_dais[0];
1095 rtd->codec = rtd->codec_dai->codec;
1096
1097
1098 platform_name = dai_link->platform_name;
1099 if (!platform_name && !dai_link->platform_of_node)
1100 platform_name = "snd-soc-dummy";
1101
1102
1103 list_for_each_entry(platform, &platform_list, list) {
1104 platform_of_node = platform->dev->of_node;
1105 if (!platform_of_node && platform->dev->parent->of_node)
1106 platform_of_node = platform->dev->parent->of_node;
1107
1108 if (dai_link->platform_of_node) {
1109 if (platform_of_node != dai_link->platform_of_node)
1110 continue;
1111 } else {
1112 if (strcmp(platform->component.name, platform_name))
1113 continue;
1114 }
1115
1116 rtd->platform = platform;
1117 }
1118 if (!rtd->platform) {
1119 dev_err(card->dev, "ASoC: platform %s not registered\n",
1120 dai_link->platform_name);
1121 goto _err_defer;
1122 }
1123
1124 soc_add_pcm_runtime(card, rtd);
1125 return 0;
1126
1127_err_defer:
1128 soc_free_pcm_runtime(rtd);
1129 return -EPROBE_DEFER;
1130}
1131
1132static void soc_remove_component(struct snd_soc_component *component)
1133{
1134 if (!component->card)
1135 return;
1136
1137 list_del(&component->card_list);
1138
1139 if (component->remove)
1140 component->remove(component);
1141
1142 snd_soc_dapm_free(snd_soc_component_get_dapm(component));
1143
1144 soc_cleanup_component_debugfs(component);
1145 component->card = NULL;
1146 module_put(component->dev->driver->owner);
1147}
1148
1149static void soc_remove_dai(struct snd_soc_dai *dai, int order)
1150{
1151 int err;
1152
1153 if (dai && dai->probed &&
1154 dai->driver->remove_order == order) {
1155 if (dai->driver->remove) {
1156 err = dai->driver->remove(dai);
1157 if (err < 0)
1158 dev_err(dai->dev,
1159 "ASoC: failed to remove %s: %d\n",
1160 dai->name, err);
1161 }
1162 dai->probed = 0;
1163 }
1164}
1165
1166static void soc_remove_link_dais(struct snd_soc_card *card,
1167 struct snd_soc_pcm_runtime *rtd, int order)
1168{
1169 int i;
1170
1171
1172 if (rtd->dev_registered) {
1173 device_unregister(rtd->dev);
1174 rtd->dev_registered = 0;
1175 }
1176
1177
1178 for (i = 0; i < rtd->num_codecs; i++)
1179 soc_remove_dai(rtd->codec_dais[i], order);
1180
1181 soc_remove_dai(rtd->cpu_dai, order);
1182}
1183
1184static void soc_remove_link_components(struct snd_soc_card *card,
1185 struct snd_soc_pcm_runtime *rtd, int order)
1186{
1187 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1188 struct snd_soc_platform *platform = rtd->platform;
1189 struct snd_soc_component *component;
1190 int i;
1191
1192
1193 if (platform && platform->component.driver->remove_order == order)
1194 soc_remove_component(&platform->component);
1195
1196
1197 for (i = 0; i < rtd->num_codecs; i++) {
1198 component = rtd->codec_dais[i]->component;
1199 if (component->driver->remove_order == order)
1200 soc_remove_component(component);
1201 }
1202
1203
1204 if (cpu_dai) {
1205 if (cpu_dai->component->driver->remove_order == order)
1206 soc_remove_component(cpu_dai->component);
1207 }
1208}
1209
1210static void soc_remove_dai_links(struct snd_soc_card *card)
1211{
1212 int order;
1213 struct snd_soc_pcm_runtime *rtd;
1214 struct snd_soc_dai_link *link, *_link;
1215
1216 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1217 order++) {
1218 list_for_each_entry(rtd, &card->rtd_list, list)
1219 soc_remove_link_dais(card, rtd, order);
1220 }
1221
1222 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1223 order++) {
1224 list_for_each_entry(rtd, &card->rtd_list, list)
1225 soc_remove_link_components(card, rtd, order);
1226 }
1227
1228 list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1229 if (link->dobj.type == SND_SOC_DOBJ_DAI_LINK)
1230 dev_warn(card->dev, "Topology forgot to remove link %s?\n",
1231 link->name);
1232
1233 list_del(&link->list);
1234 card->num_dai_links--;
1235 }
1236}
1237
1238static int snd_soc_init_multicodec(struct snd_soc_card *card,
1239 struct snd_soc_dai_link *dai_link)
1240{
1241
1242 if (dai_link->codec_name || dai_link->codec_of_node ||
1243 dai_link->codec_dai_name) {
1244 dai_link->num_codecs = 1;
1245
1246 dai_link->codecs = devm_kzalloc(card->dev,
1247 sizeof(struct snd_soc_dai_link_component),
1248 GFP_KERNEL);
1249 if (!dai_link->codecs)
1250 return -ENOMEM;
1251
1252 dai_link->codecs[0].name = dai_link->codec_name;
1253 dai_link->codecs[0].of_node = dai_link->codec_of_node;
1254 dai_link->codecs[0].dai_name = dai_link->codec_dai_name;
1255 }
1256
1257 if (!dai_link->codecs) {
1258 dev_err(card->dev, "ASoC: DAI link has no CODECs\n");
1259 return -EINVAL;
1260 }
1261
1262 return 0;
1263}
1264
1265static int soc_init_dai_link(struct snd_soc_card *card,
1266 struct snd_soc_dai_link *link)
1267{
1268 int i, ret;
1269
1270 ret = snd_soc_init_multicodec(card, link);
1271 if (ret) {
1272 dev_err(card->dev, "ASoC: failed to init multicodec\n");
1273 return ret;
1274 }
1275
1276 for (i = 0; i < link->num_codecs; i++) {
1277
1278
1279
1280
1281 if (!!link->codecs[i].name ==
1282 !!link->codecs[i].of_node) {
1283 dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",
1284 link->name);
1285 return -EINVAL;
1286 }
1287
1288 if (!link->codecs[i].dai_name) {
1289 dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",
1290 link->name);
1291 return -EINVAL;
1292 }
1293 }
1294
1295
1296
1297
1298
1299 if (link->platform_name && link->platform_of_node) {
1300 dev_err(card->dev,
1301 "ASoC: Both platform name/of_node are set for %s\n",
1302 link->name);
1303 return -EINVAL;
1304 }
1305
1306
1307
1308
1309
1310
1311 if (link->cpu_name && link->cpu_of_node) {
1312 dev_err(card->dev,
1313 "ASoC: Neither/both cpu name/of_node are set for %s\n",
1314 link->name);
1315 return -EINVAL;
1316 }
1317
1318
1319
1320
1321 if (!link->cpu_dai_name &&
1322 !(link->cpu_name || link->cpu_of_node)) {
1323 dev_err(card->dev,
1324 "ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
1325 link->name);
1326 return -EINVAL;
1327 }
1328
1329 return 0;
1330}
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343int snd_soc_add_dai_link(struct snd_soc_card *card,
1344 struct snd_soc_dai_link *dai_link)
1345{
1346 if (dai_link->dobj.type
1347 && dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
1348 dev_err(card->dev, "Invalid dai link type %d\n",
1349 dai_link->dobj.type);
1350 return -EINVAL;
1351 }
1352
1353 lockdep_assert_held(&client_mutex);
1354
1355
1356
1357 if (dai_link->dobj.type && card->add_dai_link)
1358 card->add_dai_link(card, dai_link);
1359
1360 list_add_tail(&dai_link->list, &card->dai_link_list);
1361 card->num_dai_links++;
1362
1363 return 0;
1364}
1365EXPORT_SYMBOL_GPL(snd_soc_add_dai_link);
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377void snd_soc_remove_dai_link(struct snd_soc_card *card,
1378 struct snd_soc_dai_link *dai_link)
1379{
1380 struct snd_soc_dai_link *link, *_link;
1381
1382 if (dai_link->dobj.type
1383 && dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
1384 dev_err(card->dev, "Invalid dai link type %d\n",
1385 dai_link->dobj.type);
1386 return;
1387 }
1388
1389 lockdep_assert_held(&client_mutex);
1390
1391
1392
1393 if (dai_link->dobj.type && card->remove_dai_link)
1394 card->remove_dai_link(card, dai_link);
1395
1396 list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1397 if (link == dai_link) {
1398 list_del(&link->list);
1399 card->num_dai_links--;
1400 return;
1401 }
1402 }
1403}
1404EXPORT_SYMBOL_GPL(snd_soc_remove_dai_link);
1405
1406static void soc_set_name_prefix(struct snd_soc_card *card,
1407 struct snd_soc_component *component)
1408{
1409 int i;
1410
1411 if (card->codec_conf == NULL)
1412 return;
1413
1414 for (i = 0; i < card->num_configs; i++) {
1415 struct snd_soc_codec_conf *map = &card->codec_conf[i];
1416 if (map->of_node && component->dev->of_node != map->of_node)
1417 continue;
1418 if (map->dev_name && strcmp(component->name, map->dev_name))
1419 continue;
1420 component->name_prefix = map->name_prefix;
1421 break;
1422 }
1423}
1424
1425static int soc_probe_component(struct snd_soc_card *card,
1426 struct snd_soc_component *component)
1427{
1428 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
1429 struct snd_soc_dai *dai;
1430 int ret;
1431
1432 if (!strcmp(component->name, "snd-soc-dummy"))
1433 return 0;
1434
1435 if (component->card) {
1436 if (component->card != card) {
1437 dev_err(component->dev,
1438 "Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",
1439 card->name, component->card->name);
1440 return -ENODEV;
1441 }
1442 return 0;
1443 }
1444
1445 if (!try_module_get(component->dev->driver->owner))
1446 return -ENODEV;
1447
1448 component->card = card;
1449 dapm->card = card;
1450 soc_set_name_prefix(card, component);
1451
1452 soc_init_component_debugfs(component);
1453
1454 if (component->dapm_widgets) {
1455 ret = snd_soc_dapm_new_controls(dapm, component->dapm_widgets,
1456 component->num_dapm_widgets);
1457
1458 if (ret != 0) {
1459 dev_err(component->dev,
1460 "Failed to create new controls %d\n", ret);
1461 goto err_probe;
1462 }
1463 }
1464
1465 list_for_each_entry(dai, &component->dai_list, list) {
1466 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
1467 if (ret != 0) {
1468 dev_err(component->dev,
1469 "Failed to create DAI widgets %d\n", ret);
1470 goto err_probe;
1471 }
1472 }
1473
1474 if (component->probe) {
1475 ret = component->probe(component);
1476 if (ret < 0) {
1477 dev_err(component->dev,
1478 "ASoC: failed to probe component %d\n", ret);
1479 goto err_probe;
1480 }
1481
1482 WARN(dapm->idle_bias_off &&
1483 dapm->bias_level != SND_SOC_BIAS_OFF,
1484 "codec %s can not start from non-off bias with idle_bias_off==1\n",
1485 component->name);
1486 }
1487
1488
1489 if (component->init) {
1490 ret = component->init(component);
1491 if (ret < 0) {
1492 dev_err(component->dev,
1493 "Failed to do machine specific init %d\n", ret);
1494 goto err_probe;
1495 }
1496 }
1497
1498 if (component->controls)
1499 snd_soc_add_component_controls(component, component->controls,
1500 component->num_controls);
1501 if (component->dapm_routes)
1502 snd_soc_dapm_add_routes(dapm, component->dapm_routes,
1503 component->num_dapm_routes);
1504
1505 list_add(&dapm->list, &card->dapm_list);
1506 list_add(&component->card_list, &card->component_dev_list);
1507
1508 return 0;
1509
1510err_probe:
1511 soc_cleanup_component_debugfs(component);
1512 component->card = NULL;
1513 module_put(component->dev->driver->owner);
1514
1515 return ret;
1516}
1517
1518static void rtd_release(struct device *dev)
1519{
1520 kfree(dev);
1521}
1522
1523static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
1524 const char *name)
1525{
1526 int ret = 0;
1527
1528
1529 rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1530 if (!rtd->dev)
1531 return -ENOMEM;
1532 device_initialize(rtd->dev);
1533 rtd->dev->parent = rtd->card->dev;
1534 rtd->dev->release = rtd_release;
1535 rtd->dev->groups = soc_dev_attr_groups;
1536 dev_set_name(rtd->dev, "%s", name);
1537 dev_set_drvdata(rtd->dev, rtd);
1538 mutex_init(&rtd->pcm_mutex);
1539 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
1540 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
1541 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
1542 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
1543 ret = device_add(rtd->dev);
1544 if (ret < 0) {
1545
1546 put_device(rtd->dev);
1547 dev_err(rtd->card->dev,
1548 "ASoC: failed to register runtime device: %d\n", ret);
1549 return ret;
1550 }
1551 rtd->dev_registered = 1;
1552 return 0;
1553}
1554
1555static int soc_probe_link_components(struct snd_soc_card *card,
1556 struct snd_soc_pcm_runtime *rtd,
1557 int order)
1558{
1559 struct snd_soc_platform *platform = rtd->platform;
1560 struct snd_soc_component *component;
1561 int i, ret;
1562
1563
1564 component = rtd->cpu_dai->component;
1565 if (component->driver->probe_order == order) {
1566 ret = soc_probe_component(card, component);
1567 if (ret < 0)
1568 return ret;
1569 }
1570
1571
1572 for (i = 0; i < rtd->num_codecs; i++) {
1573 component = rtd->codec_dais[i]->component;
1574 if (component->driver->probe_order == order) {
1575 ret = soc_probe_component(card, component);
1576 if (ret < 0)
1577 return ret;
1578 }
1579 }
1580
1581
1582 if (platform->component.driver->probe_order == order) {
1583 ret = soc_probe_component(card, &platform->component);
1584 if (ret < 0)
1585 return ret;
1586 }
1587
1588 return 0;
1589}
1590
1591static int soc_probe_dai(struct snd_soc_dai *dai, int order)
1592{
1593 int ret;
1594
1595 if (!dai->probed && dai->driver->probe_order == order) {
1596 if (dai->driver->probe) {
1597 ret = dai->driver->probe(dai);
1598 if (ret < 0) {
1599 dev_err(dai->dev,
1600 "ASoC: failed to probe DAI %s: %d\n",
1601 dai->name, ret);
1602 return ret;
1603 }
1604 }
1605
1606 dai->probed = 1;
1607 }
1608
1609 return 0;
1610}
1611
1612static int soc_link_dai_pcm_new(struct snd_soc_dai **dais, int num_dais,
1613 struct snd_soc_pcm_runtime *rtd)
1614{
1615 int i, ret = 0;
1616
1617 for (i = 0; i < num_dais; ++i) {
1618 struct snd_soc_dai_driver *drv = dais[i]->driver;
1619
1620 if (!rtd->dai_link->no_pcm && drv->pcm_new)
1621 ret = drv->pcm_new(rtd, dais[i]);
1622 if (ret < 0) {
1623 dev_err(dais[i]->dev,
1624 "ASoC: Failed to bind %s with pcm device\n",
1625 dais[i]->name);
1626 return ret;
1627 }
1628 }
1629
1630 return 0;
1631}
1632
1633static int soc_link_dai_widgets(struct snd_soc_card *card,
1634 struct snd_soc_dai_link *dai_link,
1635 struct snd_soc_pcm_runtime *rtd)
1636{
1637 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1638 struct snd_soc_dai *codec_dai = rtd->codec_dai;
1639 struct snd_soc_dapm_widget *sink, *source;
1640 int ret;
1641
1642 if (rtd->num_codecs > 1)
1643 dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");
1644
1645
1646 sink = codec_dai->playback_widget;
1647 source = cpu_dai->capture_widget;
1648 if (sink && source) {
1649 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
1650 dai_link->num_params,
1651 source, sink);
1652 if (ret != 0) {
1653 dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1654 sink->name, source->name, ret);
1655 return ret;
1656 }
1657 }
1658
1659 sink = cpu_dai->playback_widget;
1660 source = codec_dai->capture_widget;
1661 if (sink && source) {
1662 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
1663 dai_link->num_params,
1664 source, sink);
1665 if (ret != 0) {
1666 dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1667 sink->name, source->name, ret);
1668 return ret;
1669 }
1670 }
1671
1672 return 0;
1673}
1674
1675static int soc_probe_link_dais(struct snd_soc_card *card,
1676 struct snd_soc_pcm_runtime *rtd, int order)
1677{
1678 struct snd_soc_dai_link *dai_link = rtd->dai_link;
1679 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1680 int i, ret;
1681
1682 dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
1683 card->name, rtd->num, order);
1684
1685
1686 rtd->pmdown_time = pmdown_time;
1687
1688 ret = soc_probe_dai(cpu_dai, order);
1689 if (ret)
1690 return ret;
1691
1692
1693 for (i = 0; i < rtd->num_codecs; i++) {
1694 ret = soc_probe_dai(rtd->codec_dais[i], order);
1695 if (ret)
1696 return ret;
1697 }
1698
1699
1700 if (order != SND_SOC_COMP_ORDER_LAST)
1701 return 0;
1702
1703
1704 if (dai_link->init) {
1705 ret = dai_link->init(rtd);
1706 if (ret < 0) {
1707 dev_err(card->dev, "ASoC: failed to init %s: %d\n",
1708 dai_link->name, ret);
1709 return ret;
1710 }
1711 }
1712
1713 if (dai_link->dai_fmt)
1714 snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
1715
1716 ret = soc_post_component_init(rtd, dai_link->name);
1717 if (ret)
1718 return ret;
1719
1720#ifdef CONFIG_DEBUG_FS
1721
1722 if (dai_link->dynamic)
1723 soc_dpcm_debugfs_add(rtd);
1724#endif
1725
1726 if (cpu_dai->driver->compress_new) {
1727
1728 ret = cpu_dai->driver->compress_new(rtd, rtd->num);
1729 if (ret < 0) {
1730 dev_err(card->dev, "ASoC: can't create compress %s\n",
1731 dai_link->stream_name);
1732 return ret;
1733 }
1734 } else {
1735
1736 if (!dai_link->params) {
1737
1738 ret = soc_new_pcm(rtd, rtd->num);
1739 if (ret < 0) {
1740 dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
1741 dai_link->stream_name, ret);
1742 return ret;
1743 }
1744 ret = soc_link_dai_pcm_new(&cpu_dai, 1, rtd);
1745 if (ret < 0)
1746 return ret;
1747 ret = soc_link_dai_pcm_new(rtd->codec_dais,
1748 rtd->num_codecs, rtd);
1749 if (ret < 0)
1750 return ret;
1751 } else {
1752 INIT_DELAYED_WORK(&rtd->delayed_work,
1753 codec2codec_close_delayed_work);
1754
1755
1756 ret = soc_link_dai_widgets(card, dai_link, rtd);
1757 if (ret)
1758 return ret;
1759 }
1760 }
1761
1762 return 0;
1763}
1764
1765static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
1766{
1767 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
1768 struct snd_soc_component *component;
1769 const char *name;
1770 struct device_node *codec_of_node;
1771
1772 if (aux_dev->codec_of_node || aux_dev->codec_name) {
1773
1774 name = aux_dev->codec_name;
1775 codec_of_node = aux_dev->codec_of_node;
1776 component = soc_find_component(codec_of_node, name);
1777 if (!component) {
1778 if (codec_of_node)
1779 name = of_node_full_name(codec_of_node);
1780 goto err_defer;
1781 }
1782 } else if (aux_dev->name) {
1783
1784 name = aux_dev->name;
1785 component = soc_find_component(NULL, name);
1786 if (!component)
1787 goto err_defer;
1788 } else {
1789 dev_err(card->dev, "ASoC: Invalid auxiliary device\n");
1790 return -EINVAL;
1791 }
1792
1793 component->init = aux_dev->init;
1794 list_add(&component->card_aux_list, &card->aux_comp_list);
1795
1796 return 0;
1797
1798err_defer:
1799 dev_err(card->dev, "ASoC: %s not registered\n", name);
1800 return -EPROBE_DEFER;
1801}
1802
1803static int soc_probe_aux_devices(struct snd_soc_card *card)
1804{
1805 struct snd_soc_component *comp;
1806 int order;
1807 int ret;
1808
1809 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1810 order++) {
1811 list_for_each_entry(comp, &card->aux_comp_list, card_aux_list) {
1812 if (comp->driver->probe_order == order) {
1813 ret = soc_probe_component(card, comp);
1814 if (ret < 0) {
1815 dev_err(card->dev,
1816 "ASoC: failed to probe aux component %s %d\n",
1817 comp->name, ret);
1818 return ret;
1819 }
1820 }
1821 }
1822 }
1823
1824 return 0;
1825}
1826
1827static void soc_remove_aux_devices(struct snd_soc_card *card)
1828{
1829 struct snd_soc_component *comp, *_comp;
1830 int order;
1831
1832 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1833 order++) {
1834 list_for_each_entry_safe(comp, _comp,
1835 &card->aux_comp_list, card_aux_list) {
1836
1837 if (comp->driver->remove_order == order) {
1838 soc_remove_component(comp);
1839
1840 list_del(&comp->card_aux_list);
1841 }
1842 }
1843 }
1844}
1845
1846static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
1847{
1848 int ret;
1849
1850 if (codec->cache_init)
1851 return 0;
1852
1853 ret = snd_soc_cache_init(codec);
1854 if (ret < 0) {
1855 dev_err(codec->dev,
1856 "ASoC: Failed to set cache compression type: %d\n",
1857 ret);
1858 return ret;
1859 }
1860 codec->cache_init = 1;
1861 return 0;
1862}
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
1878 unsigned int dai_fmt)
1879{
1880 struct snd_soc_dai **codec_dais = rtd->codec_dais;
1881 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1882 unsigned int i;
1883 int ret;
1884
1885 for (i = 0; i < rtd->num_codecs; i++) {
1886 struct snd_soc_dai *codec_dai = codec_dais[i];
1887
1888 ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
1889 if (ret != 0 && ret != -ENOTSUPP) {
1890 dev_warn(codec_dai->dev,
1891 "ASoC: Failed to set DAI format: %d\n", ret);
1892 return ret;
1893 }
1894 }
1895
1896
1897 if (cpu_dai->codec) {
1898 unsigned int inv_dai_fmt;
1899
1900 inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_MASTER_MASK;
1901 switch (dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1902 case SND_SOC_DAIFMT_CBM_CFM:
1903 inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
1904 break;
1905 case SND_SOC_DAIFMT_CBM_CFS:
1906 inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
1907 break;
1908 case SND_SOC_DAIFMT_CBS_CFM:
1909 inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
1910 break;
1911 case SND_SOC_DAIFMT_CBS_CFS:
1912 inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
1913 break;
1914 }
1915
1916 dai_fmt = inv_dai_fmt;
1917 }
1918
1919 ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt);
1920 if (ret != 0 && ret != -ENOTSUPP) {
1921 dev_warn(cpu_dai->dev,
1922 "ASoC: Failed to set DAI format: %d\n", ret);
1923 return ret;
1924 }
1925
1926 return 0;
1927}
1928EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
1929
1930
1931#ifdef CONFIG_DMI
1932
1933
1934
1935
1936static void cleanup_dmi_name(char *name)
1937{
1938 int i, j = 0;
1939
1940 for (i = 0; name[i]; i++) {
1941 if (isalnum(name[i]) || (name[i] == '.')
1942 || (name[i] == '_'))
1943 name[j++] = name[i];
1944 else if (name[i] == '-')
1945 name[j++] = '_';
1946 }
1947
1948 name[j] = '\0';
1949}
1950
1951
1952
1953
1954static int is_dmi_valid(const char *field)
1955{
1956 int i = 0;
1957
1958 while (dmi_blacklist[i]) {
1959 if (strstr(field, dmi_blacklist[i]))
1960 return 0;
1961 i++;
1962 }
1963
1964 return 1;
1965}
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour)
1999{
2000 const char *vendor, *product, *product_version, *board;
2001 size_t longname_buf_size = sizeof(card->snd_card->longname);
2002 size_t len;
2003
2004 if (card->long_name)
2005 return 0;
2006
2007
2008 vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
2009 if (!vendor || !is_dmi_valid(vendor)) {
2010 dev_warn(card->dev, "ASoC: no DMI vendor name!\n");
2011 return 0;
2012 }
2013
2014
2015 snprintf(card->dmi_longname, sizeof(card->snd_card->longname),
2016 "%s", vendor);
2017 cleanup_dmi_name(card->dmi_longname);
2018
2019 product = dmi_get_system_info(DMI_PRODUCT_NAME);
2020 if (product && is_dmi_valid(product)) {
2021 len = strlen(card->dmi_longname);
2022 snprintf(card->dmi_longname + len,
2023 longname_buf_size - len,
2024 "-%s", product);
2025
2026 len++;
2027 if (len < longname_buf_size)
2028 cleanup_dmi_name(card->dmi_longname + len);
2029
2030
2031
2032
2033 product_version = dmi_get_system_info(DMI_PRODUCT_VERSION);
2034 if (product_version && is_dmi_valid(product_version)) {
2035 len = strlen(card->dmi_longname);
2036 snprintf(card->dmi_longname + len,
2037 longname_buf_size - len,
2038 "-%s", product_version);
2039
2040 len++;
2041 if (len < longname_buf_size)
2042 cleanup_dmi_name(card->dmi_longname + len);
2043 }
2044 }
2045
2046 board = dmi_get_system_info(DMI_BOARD_NAME);
2047 if (board && is_dmi_valid(board)) {
2048 len = strlen(card->dmi_longname);
2049 snprintf(card->dmi_longname + len,
2050 longname_buf_size - len,
2051 "-%s", board);
2052
2053 len++;
2054 if (len < longname_buf_size)
2055 cleanup_dmi_name(card->dmi_longname + len);
2056 } else if (!product) {
2057
2058 dev_warn(card->dev, "ASoC: no DMI board/product name!\n");
2059 return 0;
2060 }
2061
2062
2063 if (flavour) {
2064 len = strlen(card->dmi_longname);
2065 snprintf(card->dmi_longname + len,
2066 longname_buf_size - len,
2067 "-%s", flavour);
2068
2069 len++;
2070 if (len < longname_buf_size)
2071 cleanup_dmi_name(card->dmi_longname + len);
2072 }
2073
2074
2075 card->long_name = card->dmi_longname;
2076
2077 return 0;
2078}
2079EXPORT_SYMBOL_GPL(snd_soc_set_dmi_name);
2080#endif
2081
2082static int snd_soc_instantiate_card(struct snd_soc_card *card)
2083{
2084 struct snd_soc_codec *codec;
2085 struct snd_soc_pcm_runtime *rtd;
2086 struct snd_soc_dai_link *dai_link;
2087 int ret, i, order;
2088
2089 mutex_lock(&client_mutex);
2090 mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
2091
2092
2093 for (i = 0; i < card->num_links; i++) {
2094 ret = soc_bind_dai_link(card, &card->dai_link[i]);
2095 if (ret != 0)
2096 goto base_error;
2097 }
2098
2099
2100 for (i = 0; i < card->num_aux_devs; i++) {
2101 ret = soc_bind_aux_dev(card, i);
2102 if (ret != 0)
2103 goto base_error;
2104 }
2105
2106
2107 for (i = 0; i < card->num_links; i++)
2108 snd_soc_add_dai_link(card, card->dai_link+i);
2109
2110
2111 list_for_each_entry(codec, &codec_list, list) {
2112 if (codec->cache_init)
2113 continue;
2114 ret = snd_soc_init_codec_cache(codec);
2115 if (ret < 0)
2116 goto base_error;
2117 }
2118
2119
2120 ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
2121 card->owner, 0, &card->snd_card);
2122 if (ret < 0) {
2123 dev_err(card->dev,
2124 "ASoC: can't create sound card for card %s: %d\n",
2125 card->name, ret);
2126 goto base_error;
2127 }
2128
2129 soc_init_card_debugfs(card);
2130
2131 card->dapm.bias_level = SND_SOC_BIAS_OFF;
2132 card->dapm.dev = card->dev;
2133 card->dapm.card = card;
2134 list_add(&card->dapm.list, &card->dapm_list);
2135
2136#ifdef CONFIG_DEBUG_FS
2137 snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
2138#endif
2139
2140#ifdef CONFIG_PM_SLEEP
2141
2142 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
2143#endif
2144
2145 if (card->dapm_widgets)
2146 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
2147 card->num_dapm_widgets);
2148
2149 if (card->of_dapm_widgets)
2150 snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,
2151 card->num_of_dapm_widgets);
2152
2153
2154 if (card->probe) {
2155 ret = card->probe(card);
2156 if (ret < 0)
2157 goto card_probe_error;
2158 }
2159
2160
2161 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
2162 order++) {
2163 list_for_each_entry(rtd, &card->rtd_list, list) {
2164 ret = soc_probe_link_components(card, rtd, order);
2165 if (ret < 0) {
2166 dev_err(card->dev,
2167 "ASoC: failed to instantiate card %d\n",
2168 ret);
2169 goto probe_dai_err;
2170 }
2171 }
2172 }
2173
2174
2175 ret = soc_probe_aux_devices(card);
2176 if (ret < 0)
2177 goto probe_dai_err;
2178
2179
2180
2181
2182 list_for_each_entry(dai_link, &card->dai_link_list, list) {
2183 if (soc_is_dai_link_bound(card, dai_link))
2184 continue;
2185
2186 ret = soc_init_dai_link(card, dai_link);
2187 if (ret)
2188 goto probe_dai_err;
2189 ret = soc_bind_dai_link(card, dai_link);
2190 if (ret)
2191 goto probe_dai_err;
2192 }
2193
2194
2195 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
2196 order++) {
2197 list_for_each_entry(rtd, &card->rtd_list, list) {
2198 ret = soc_probe_link_dais(card, rtd, order);
2199 if (ret < 0) {
2200 dev_err(card->dev,
2201 "ASoC: failed to instantiate card %d\n",
2202 ret);
2203 goto probe_dai_err;
2204 }
2205 }
2206 }
2207
2208 snd_soc_dapm_link_dai_widgets(card);
2209 snd_soc_dapm_connect_dai_link_widgets(card);
2210
2211 if (card->controls)
2212 snd_soc_add_card_controls(card, card->controls, card->num_controls);
2213
2214 if (card->dapm_routes)
2215 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
2216 card->num_dapm_routes);
2217
2218 if (card->of_dapm_routes)
2219 snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
2220 card->num_of_dapm_routes);
2221
2222
2223 snd_soc_set_dmi_name(card, NULL);
2224
2225 snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
2226 "%s", card->name);
2227 snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
2228 "%s", card->long_name ? card->long_name : card->name);
2229 snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
2230 "%s", card->driver_name ? card->driver_name : card->name);
2231 for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
2232 switch (card->snd_card->driver[i]) {
2233 case '_':
2234 case '-':
2235 case '\0':
2236 break;
2237 default:
2238 if (!isalnum(card->snd_card->driver[i]))
2239 card->snd_card->driver[i] = '_';
2240 break;
2241 }
2242 }
2243
2244 if (card->late_probe) {
2245 ret = card->late_probe(card);
2246 if (ret < 0) {
2247 dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
2248 card->name, ret);
2249 goto probe_aux_dev_err;
2250 }
2251 }
2252
2253 snd_soc_dapm_new_widgets(card);
2254
2255 ret = snd_card_register(card->snd_card);
2256 if (ret < 0) {
2257 dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
2258 ret);
2259 goto probe_aux_dev_err;
2260 }
2261
2262 card->instantiated = 1;
2263 snd_soc_dapm_sync(&card->dapm);
2264 mutex_unlock(&card->mutex);
2265 mutex_unlock(&client_mutex);
2266
2267 return 0;
2268
2269probe_aux_dev_err:
2270 soc_remove_aux_devices(card);
2271
2272probe_dai_err:
2273 soc_remove_dai_links(card);
2274
2275card_probe_error:
2276 if (card->remove)
2277 card->remove(card);
2278
2279 snd_soc_dapm_free(&card->dapm);
2280 soc_cleanup_card_debugfs(card);
2281 snd_card_free(card->snd_card);
2282
2283base_error:
2284 soc_remove_pcm_runtimes(card);
2285 mutex_unlock(&card->mutex);
2286 mutex_unlock(&client_mutex);
2287
2288 return ret;
2289}
2290
2291
2292static int soc_probe(struct platform_device *pdev)
2293{
2294 struct snd_soc_card *card = platform_get_drvdata(pdev);
2295
2296
2297
2298
2299
2300 if (!card)
2301 return -EINVAL;
2302
2303 dev_warn(&pdev->dev,
2304 "ASoC: machine %s should use snd_soc_register_card()\n",
2305 card->name);
2306
2307
2308 card->dev = &pdev->dev;
2309
2310 return snd_soc_register_card(card);
2311}
2312
2313static int soc_cleanup_card_resources(struct snd_soc_card *card)
2314{
2315 struct snd_soc_pcm_runtime *rtd;
2316
2317
2318 list_for_each_entry(rtd, &card->rtd_list, list)
2319 flush_delayed_work(&rtd->delayed_work);
2320
2321
2322 snd_card_free(card->snd_card);
2323
2324
2325 soc_remove_dai_links(card);
2326 soc_remove_pcm_runtimes(card);
2327
2328
2329 soc_remove_aux_devices(card);
2330
2331 snd_soc_dapm_free(&card->dapm);
2332 soc_cleanup_card_debugfs(card);
2333
2334
2335 if (card->remove)
2336 card->remove(card);
2337
2338 return 0;
2339}
2340
2341
2342static int soc_remove(struct platform_device *pdev)
2343{
2344 struct snd_soc_card *card = platform_get_drvdata(pdev);
2345
2346 snd_soc_unregister_card(card);
2347 return 0;
2348}
2349
2350int snd_soc_poweroff(struct device *dev)
2351{
2352 struct snd_soc_card *card = dev_get_drvdata(dev);
2353 struct snd_soc_pcm_runtime *rtd;
2354
2355 if (!card->instantiated)
2356 return 0;
2357
2358
2359
2360 list_for_each_entry(rtd, &card->rtd_list, list)
2361 flush_delayed_work(&rtd->delayed_work);
2362
2363 snd_soc_dapm_shutdown(card);
2364
2365
2366 list_for_each_entry(rtd, &card->rtd_list, list) {
2367 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2368 int i;
2369
2370 pinctrl_pm_select_sleep_state(cpu_dai->dev);
2371 for (i = 0; i < rtd->num_codecs; i++) {
2372 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
2373 pinctrl_pm_select_sleep_state(codec_dai->dev);
2374 }
2375 }
2376
2377 return 0;
2378}
2379EXPORT_SYMBOL_GPL(snd_soc_poweroff);
2380
2381const struct dev_pm_ops snd_soc_pm_ops = {
2382 .suspend = snd_soc_suspend,
2383 .resume = snd_soc_resume,
2384 .freeze = snd_soc_suspend,
2385 .thaw = snd_soc_resume,
2386 .poweroff = snd_soc_poweroff,
2387 .restore = snd_soc_resume,
2388};
2389EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
2390
2391
2392static struct platform_driver soc_driver = {
2393 .driver = {
2394 .name = "soc-audio",
2395 .pm = &snd_soc_pm_ops,
2396 },
2397 .probe = soc_probe,
2398 .remove = soc_remove,
2399};
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
2413 void *data, const char *long_name,
2414 const char *prefix)
2415{
2416 struct snd_kcontrol_new template;
2417 struct snd_kcontrol *kcontrol;
2418 char *name = NULL;
2419
2420 memcpy(&template, _template, sizeof(template));
2421 template.index = 0;
2422
2423 if (!long_name)
2424 long_name = template.name;
2425
2426 if (prefix) {
2427 name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
2428 if (!name)
2429 return NULL;
2430
2431 template.name = name;
2432 } else {
2433 template.name = long_name;
2434 }
2435
2436 kcontrol = snd_ctl_new1(&template, data);
2437
2438 kfree(name);
2439
2440 return kcontrol;
2441}
2442EXPORT_SYMBOL_GPL(snd_soc_cnew);
2443
2444static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
2445 const struct snd_kcontrol_new *controls, int num_controls,
2446 const char *prefix, void *data)
2447{
2448 int err, i;
2449
2450 for (i = 0; i < num_controls; i++) {
2451 const struct snd_kcontrol_new *control = &controls[i];
2452 err = snd_ctl_add(card, snd_soc_cnew(control, data,
2453 control->name, prefix));
2454 if (err < 0) {
2455 dev_err(dev, "ASoC: Failed to add %s: %d\n",
2456 control->name, err);
2457 return err;
2458 }
2459 }
2460
2461 return 0;
2462}
2463
2464struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
2465 const char *name)
2466{
2467 struct snd_card *card = soc_card->snd_card;
2468 struct snd_kcontrol *kctl;
2469
2470 if (unlikely(!name))
2471 return NULL;
2472
2473 list_for_each_entry(kctl, &card->controls, list)
2474 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))
2475 return kctl;
2476 return NULL;
2477}
2478EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489int snd_soc_add_component_controls(struct snd_soc_component *component,
2490 const struct snd_kcontrol_new *controls, unsigned int num_controls)
2491{
2492 struct snd_card *card = component->card->snd_card;
2493
2494 return snd_soc_add_controls(card, component->dev, controls,
2495 num_controls, component->name_prefix, component);
2496}
2497EXPORT_SYMBOL_GPL(snd_soc_add_component_controls);
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
2511 const struct snd_kcontrol_new *controls, unsigned int num_controls)
2512{
2513 return snd_soc_add_component_controls(&codec->component, controls,
2514 num_controls);
2515}
2516EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
2529 const struct snd_kcontrol_new *controls, unsigned int num_controls)
2530{
2531 return snd_soc_add_component_controls(&platform->component, controls,
2532 num_controls);
2533}
2534EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
2547 const struct snd_kcontrol_new *controls, int num_controls)
2548{
2549 struct snd_card *card = soc_card->snd_card;
2550
2551 return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
2552 NULL, soc_card);
2553}
2554EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
2567 const struct snd_kcontrol_new *controls, int num_controls)
2568{
2569 struct snd_card *card = dai->component->card->snd_card;
2570
2571 return snd_soc_add_controls(card, dai->dev, controls, num_controls,
2572 NULL, dai);
2573}
2574EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2586 unsigned int freq, int dir)
2587{
2588 if (dai->driver && dai->driver->ops->set_sysclk)
2589 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
2590 else if (dai->codec && dai->codec->driver->set_sysclk)
2591 return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
2592 freq, dir);
2593 else
2594 return -ENOTSUPP;
2595}
2596EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
2609 int source, unsigned int freq, int dir)
2610{
2611 if (codec->driver->set_sysclk)
2612 return codec->driver->set_sysclk(codec, clk_id, source,
2613 freq, dir);
2614 else
2615 return -ENOTSUPP;
2616}
2617EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2630 int div_id, int div)
2631{
2632 if (dai->driver && dai->driver->ops->set_clkdiv)
2633 return dai->driver->ops->set_clkdiv(dai, div_id, div);
2634 else
2635 return -EINVAL;
2636}
2637EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2650 unsigned int freq_in, unsigned int freq_out)
2651{
2652 if (dai->driver && dai->driver->ops->set_pll)
2653 return dai->driver->ops->set_pll(dai, pll_id, source,
2654 freq_in, freq_out);
2655 else if (dai->codec && dai->codec->driver->set_pll)
2656 return dai->codec->driver->set_pll(dai->codec, pll_id, source,
2657 freq_in, freq_out);
2658 else
2659 return -EINVAL;
2660}
2661EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
2674 unsigned int freq_in, unsigned int freq_out)
2675{
2676 if (codec->driver->set_pll)
2677 return codec->driver->set_pll(codec, pll_id, source,
2678 freq_in, freq_out);
2679 else
2680 return -EINVAL;
2681}
2682EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
2683
2684
2685
2686
2687
2688
2689
2690
2691int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
2692{
2693 if (dai->driver && dai->driver->ops->set_bclk_ratio)
2694 return dai->driver->ops->set_bclk_ratio(dai, ratio);
2695 else
2696 return -EINVAL;
2697}
2698EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
2699
2700
2701
2702
2703
2704
2705
2706
2707int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2708{
2709 if (dai->driver == NULL)
2710 return -EINVAL;
2711 if (dai->driver->ops->set_fmt == NULL)
2712 return -ENOTSUPP;
2713 return dai->driver->ops->set_fmt(dai, fmt);
2714}
2715EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
2726 unsigned int *tx_mask,
2727 unsigned int *rx_mask)
2728{
2729 if (*tx_mask || *rx_mask)
2730 return 0;
2731
2732 if (!slots)
2733 return -EINVAL;
2734
2735 *tx_mask = (1 << slots) - 1;
2736 *rx_mask = (1 << slots) - 1;
2737
2738 return 0;
2739}
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
2765 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
2766{
2767 if (dai->driver && dai->driver->ops->xlate_tdm_slot_mask)
2768 dai->driver->ops->xlate_tdm_slot_mask(slots,
2769 &tx_mask, &rx_mask);
2770 else
2771 snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
2772
2773 dai->tx_mask = tx_mask;
2774 dai->rx_mask = rx_mask;
2775
2776 if (dai->driver && dai->driver->ops->set_tdm_slot)
2777 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
2778 slots, slot_width);
2779 else
2780 return -ENOTSUPP;
2781}
2782EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
2797 unsigned int tx_num, unsigned int *tx_slot,
2798 unsigned int rx_num, unsigned int *rx_slot)
2799{
2800 if (dai->driver && dai->driver->ops->set_channel_map)
2801 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
2802 rx_num, rx_slot);
2803 else
2804 return -EINVAL;
2805}
2806EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
2807
2808
2809
2810
2811
2812
2813
2814
2815int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
2816{
2817 if (dai->driver && dai->driver->ops->set_tristate)
2818 return dai->driver->ops->set_tristate(dai, tristate);
2819 else
2820 return -EINVAL;
2821}
2822EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
2833 int direction)
2834{
2835 if (!dai->driver)
2836 return -ENOTSUPP;
2837
2838 if (dai->driver->ops->mute_stream)
2839 return dai->driver->ops->mute_stream(dai, mute, direction);
2840 else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
2841 dai->driver->ops->digital_mute)
2842 return dai->driver->ops->digital_mute(dai, mute);
2843 else
2844 return -ENOTSUPP;
2845}
2846EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
2847
2848
2849
2850
2851
2852
2853
2854int snd_soc_register_card(struct snd_soc_card *card)
2855{
2856 int i, ret;
2857 struct snd_soc_pcm_runtime *rtd;
2858
2859 if (!card->name || !card->dev)
2860 return -EINVAL;
2861
2862 for (i = 0; i < card->num_links; i++) {
2863 struct snd_soc_dai_link *link = &card->dai_link[i];
2864
2865 ret = soc_init_dai_link(card, link);
2866 if (ret) {
2867 dev_err(card->dev, "ASoC: failed to init link %s\n",
2868 link->name);
2869 return ret;
2870 }
2871 }
2872
2873 dev_set_drvdata(card->dev, card);
2874
2875 snd_soc_initialize_card_lists(card);
2876
2877 INIT_LIST_HEAD(&card->dai_link_list);
2878 card->num_dai_links = 0;
2879
2880 INIT_LIST_HEAD(&card->rtd_list);
2881 card->num_rtd = 0;
2882
2883 INIT_LIST_HEAD(&card->dapm_dirty);
2884 INIT_LIST_HEAD(&card->dobj_list);
2885 card->instantiated = 0;
2886 mutex_init(&card->mutex);
2887 mutex_init(&card->dapm_mutex);
2888
2889 ret = snd_soc_instantiate_card(card);
2890 if (ret != 0)
2891 return ret;
2892
2893
2894 list_for_each_entry(rtd, &card->rtd_list, list) {
2895 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2896 int j;
2897
2898 for (j = 0; j < rtd->num_codecs; j++) {
2899 struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
2900 if (!codec_dai->active)
2901 pinctrl_pm_select_sleep_state(codec_dai->dev);
2902 }
2903
2904 if (!cpu_dai->active)
2905 pinctrl_pm_select_sleep_state(cpu_dai->dev);
2906 }
2907
2908 return ret;
2909}
2910EXPORT_SYMBOL_GPL(snd_soc_register_card);
2911
2912
2913
2914
2915
2916
2917
2918int snd_soc_unregister_card(struct snd_soc_card *card)
2919{
2920 if (card->instantiated) {
2921 card->instantiated = false;
2922 snd_soc_dapm_shutdown(card);
2923 soc_cleanup_card_resources(card);
2924 dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
2925 }
2926
2927 return 0;
2928}
2929EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
2930
2931
2932
2933
2934
2935static char *fmt_single_name(struct device *dev, int *id)
2936{
2937 char *found, name[NAME_SIZE];
2938 int id1, id2;
2939
2940 if (dev_name(dev) == NULL)
2941 return NULL;
2942
2943 strlcpy(name, dev_name(dev), NAME_SIZE);
2944
2945
2946 found = strstr(name, dev->driver->name);
2947 if (found) {
2948
2949 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
2950
2951
2952 if (*id == -1)
2953 found[strlen(dev->driver->name)] = '\0';
2954 }
2955
2956 } else {
2957
2958 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
2959 char tmp[NAME_SIZE];
2960
2961
2962 *id = ((id1 & 0xffff) << 16) + id2;
2963
2964
2965 snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
2966 strlcpy(name, tmp, NAME_SIZE);
2967 } else
2968 *id = 0;
2969 }
2970
2971 return kstrdup(name, GFP_KERNEL);
2972}
2973
2974
2975
2976
2977
2978static inline char *fmt_multiple_name(struct device *dev,
2979 struct snd_soc_dai_driver *dai_drv)
2980{
2981 if (dai_drv->name == NULL) {
2982 dev_err(dev,
2983 "ASoC: error - multiple DAI %s registered with no name\n",
2984 dev_name(dev));
2985 return NULL;
2986 }
2987
2988 return kstrdup(dai_drv->name, GFP_KERNEL);
2989}
2990
2991
2992
2993
2994
2995
2996static void snd_soc_unregister_dais(struct snd_soc_component *component)
2997{
2998 struct snd_soc_dai *dai, *_dai;
2999
3000 list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
3001 dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
3002 dai->name);
3003 list_del(&dai->list);
3004 kfree(dai->name);
3005 kfree(dai);
3006 }
3007}
3008
3009
3010static struct snd_soc_dai *soc_add_dai(struct snd_soc_component *component,
3011 struct snd_soc_dai_driver *dai_drv,
3012 bool legacy_dai_naming)
3013{
3014 struct device *dev = component->dev;
3015 struct snd_soc_dai *dai;
3016
3017 dev_dbg(dev, "ASoC: dynamically register DAI %s\n", dev_name(dev));
3018
3019 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3020 if (dai == NULL)
3021 return NULL;
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031 if (legacy_dai_naming &&
3032 (dai_drv->id == 0 || dai_drv->name == NULL)) {
3033 dai->name = fmt_single_name(dev, &dai->id);
3034 } else {
3035 dai->name = fmt_multiple_name(dev, dai_drv);
3036 if (dai_drv->id)
3037 dai->id = dai_drv->id;
3038 else
3039 dai->id = component->num_dai;
3040 }
3041 if (dai->name == NULL) {
3042 kfree(dai);
3043 return NULL;
3044 }
3045
3046 dai->component = component;
3047 dai->dev = dev;
3048 dai->driver = dai_drv;
3049 if (!dai->driver->ops)
3050 dai->driver->ops = &null_dai_ops;
3051
3052 list_add(&dai->list, &component->dai_list);
3053 component->num_dai++;
3054
3055 dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
3056 return dai;
3057}
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068static int snd_soc_register_dais(struct snd_soc_component *component,
3069 struct snd_soc_dai_driver *dai_drv, size_t count,
3070 bool legacy_dai_naming)
3071{
3072 struct device *dev = component->dev;
3073 struct snd_soc_dai *dai;
3074 unsigned int i;
3075 int ret;
3076
3077 dev_dbg(dev, "ASoC: dai register %s #%zu\n", dev_name(dev), count);
3078
3079 component->dai_drv = dai_drv;
3080
3081 for (i = 0; i < count; i++) {
3082
3083 dai = soc_add_dai(component, dai_drv + i,
3084 count == 1 && legacy_dai_naming);
3085 if (dai == NULL) {
3086 ret = -ENOMEM;
3087 goto err;
3088 }
3089 }
3090
3091 return 0;
3092
3093err:
3094 snd_soc_unregister_dais(component);
3095
3096 return ret;
3097}
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109int snd_soc_register_dai(struct snd_soc_component *component,
3110 struct snd_soc_dai_driver *dai_drv)
3111{
3112 struct snd_soc_dapm_context *dapm =
3113 snd_soc_component_get_dapm(component);
3114 struct snd_soc_dai *dai;
3115 int ret;
3116
3117 if (dai_drv->dobj.type != SND_SOC_DOBJ_PCM) {
3118 dev_err(component->dev, "Invalid dai type %d\n",
3119 dai_drv->dobj.type);
3120 return -EINVAL;
3121 }
3122
3123 lockdep_assert_held(&client_mutex);
3124 dai = soc_add_dai(component, dai_drv, false);
3125 if (!dai)
3126 return -ENOMEM;
3127
3128
3129
3130
3131 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
3132 if (ret != 0) {
3133 dev_err(component->dev,
3134 "Failed to create DAI widgets %d\n", ret);
3135 }
3136
3137 return ret;
3138}
3139EXPORT_SYMBOL_GPL(snd_soc_register_dai);
3140
3141static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,
3142 enum snd_soc_dapm_type type, int subseq)
3143{
3144 struct snd_soc_component *component = dapm->component;
3145
3146 component->driver->seq_notifier(component, type, subseq);
3147}
3148
3149static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
3150 int event)
3151{
3152 struct snd_soc_component *component = dapm->component;
3153
3154 return component->driver->stream_event(component, event);
3155}
3156
3157static int snd_soc_component_initialize(struct snd_soc_component *component,
3158 const struct snd_soc_component_driver *driver, struct device *dev)
3159{
3160 struct snd_soc_dapm_context *dapm;
3161
3162 component->name = fmt_single_name(dev, &component->id);
3163 if (!component->name) {
3164 dev_err(dev, "ASoC: Failed to allocate name\n");
3165 return -ENOMEM;
3166 }
3167
3168 component->dev = dev;
3169 component->driver = driver;
3170 component->probe = component->driver->probe;
3171 component->remove = component->driver->remove;
3172 component->suspend = component->driver->suspend;
3173 component->resume = component->driver->resume;
3174
3175 dapm = &component->dapm;
3176 dapm->dev = dev;
3177 dapm->component = component;
3178 dapm->bias_level = SND_SOC_BIAS_OFF;
3179 dapm->idle_bias_off = true;
3180 if (driver->seq_notifier)
3181 dapm->seq_notifier = snd_soc_component_seq_notifier;
3182 if (driver->stream_event)
3183 dapm->stream_event = snd_soc_component_stream_event;
3184
3185 component->controls = driver->controls;
3186 component->num_controls = driver->num_controls;
3187 component->dapm_widgets = driver->dapm_widgets;
3188 component->num_dapm_widgets = driver->num_dapm_widgets;
3189 component->dapm_routes = driver->dapm_routes;
3190 component->num_dapm_routes = driver->num_dapm_routes;
3191
3192 INIT_LIST_HEAD(&component->dai_list);
3193 mutex_init(&component->io_mutex);
3194
3195 return 0;
3196}
3197
3198static void snd_soc_component_setup_regmap(struct snd_soc_component *component)
3199{
3200 int val_bytes = regmap_get_val_bytes(component->regmap);
3201
3202
3203 if (val_bytes > 0)
3204 component->val_bytes = val_bytes;
3205}
3206
3207#ifdef CONFIG_REGMAP
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219void snd_soc_component_init_regmap(struct snd_soc_component *component,
3220 struct regmap *regmap)
3221{
3222 component->regmap = regmap;
3223 snd_soc_component_setup_regmap(component);
3224}
3225EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap);
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237void snd_soc_component_exit_regmap(struct snd_soc_component *component)
3238{
3239 regmap_exit(component->regmap);
3240 component->regmap = NULL;
3241}
3242EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap);
3243
3244#endif
3245
3246static void snd_soc_component_add_unlocked(struct snd_soc_component *component)
3247{
3248 if (!component->write && !component->read) {
3249 if (!component->regmap)
3250 component->regmap = dev_get_regmap(component->dev, NULL);
3251 if (component->regmap)
3252 snd_soc_component_setup_regmap(component);
3253 }
3254
3255 list_add(&component->list, &component_list);
3256 INIT_LIST_HEAD(&component->dobj_list);
3257}
3258
3259static void snd_soc_component_add(struct snd_soc_component *component)
3260{
3261 mutex_lock(&client_mutex);
3262 snd_soc_component_add_unlocked(component);
3263 mutex_unlock(&client_mutex);
3264}
3265
3266static void snd_soc_component_cleanup(struct snd_soc_component *component)
3267{
3268 snd_soc_unregister_dais(component);
3269 kfree(component->name);
3270}
3271
3272static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
3273{
3274 struct snd_soc_card *card = component->card;
3275
3276 if (card)
3277 snd_soc_unregister_card(card);
3278
3279 list_del(&component->list);
3280}
3281
3282int snd_soc_register_component(struct device *dev,
3283 const struct snd_soc_component_driver *cmpnt_drv,
3284 struct snd_soc_dai_driver *dai_drv,
3285 int num_dai)
3286{
3287 struct snd_soc_component *cmpnt;
3288 int ret;
3289
3290 cmpnt = kzalloc(sizeof(*cmpnt), GFP_KERNEL);
3291 if (!cmpnt) {
3292 dev_err(dev, "ASoC: Failed to allocate memory\n");
3293 return -ENOMEM;
3294 }
3295
3296 ret = snd_soc_component_initialize(cmpnt, cmpnt_drv, dev);
3297 if (ret)
3298 goto err_free;
3299
3300 cmpnt->ignore_pmdown_time = true;
3301 cmpnt->registered_as_component = true;
3302
3303 ret = snd_soc_register_dais(cmpnt, dai_drv, num_dai, true);
3304 if (ret < 0) {
3305 dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
3306 goto err_cleanup;
3307 }
3308
3309 snd_soc_component_add(cmpnt);
3310
3311 return 0;
3312
3313err_cleanup:
3314 snd_soc_component_cleanup(cmpnt);
3315err_free:
3316 kfree(cmpnt);
3317 return ret;
3318}
3319EXPORT_SYMBOL_GPL(snd_soc_register_component);
3320
3321
3322
3323
3324
3325
3326void snd_soc_unregister_component(struct device *dev)
3327{
3328 struct snd_soc_component *cmpnt;
3329
3330 mutex_lock(&client_mutex);
3331 list_for_each_entry(cmpnt, &component_list, list) {
3332 if (dev == cmpnt->dev && cmpnt->registered_as_component)
3333 goto found;
3334 }
3335 mutex_unlock(&client_mutex);
3336 return;
3337
3338found:
3339 snd_soc_tplg_component_remove(cmpnt, SND_SOC_TPLG_INDEX_ALL);
3340 snd_soc_component_del_unlocked(cmpnt);
3341 mutex_unlock(&client_mutex);
3342 snd_soc_component_cleanup(cmpnt);
3343 kfree(cmpnt);
3344}
3345EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
3346
3347static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
3348{
3349 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
3350
3351 return platform->driver->probe(platform);
3352}
3353
3354static void snd_soc_platform_drv_remove(struct snd_soc_component *component)
3355{
3356 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
3357
3358 platform->driver->remove(platform);
3359}
3360
3361
3362
3363
3364
3365
3366
3367int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
3368 const struct snd_soc_platform_driver *platform_drv)
3369{
3370 int ret;
3371
3372 ret = snd_soc_component_initialize(&platform->component,
3373 &platform_drv->component_driver, dev);
3374 if (ret)
3375 return ret;
3376
3377 platform->dev = dev;
3378 platform->driver = platform_drv;
3379
3380 if (platform_drv->probe)
3381 platform->component.probe = snd_soc_platform_drv_probe;
3382 if (platform_drv->remove)
3383 platform->component.remove = snd_soc_platform_drv_remove;
3384
3385#ifdef CONFIG_DEBUG_FS
3386 platform->component.debugfs_prefix = "platform";
3387#endif
3388
3389 mutex_lock(&client_mutex);
3390 snd_soc_component_add_unlocked(&platform->component);
3391 list_add(&platform->list, &platform_list);
3392 mutex_unlock(&client_mutex);
3393
3394 dev_dbg(dev, "ASoC: Registered platform '%s'\n",
3395 platform->component.name);
3396
3397 return 0;
3398}
3399EXPORT_SYMBOL_GPL(snd_soc_add_platform);
3400
3401
3402
3403
3404
3405
3406
3407int snd_soc_register_platform(struct device *dev,
3408 const struct snd_soc_platform_driver *platform_drv)
3409{
3410 struct snd_soc_platform *platform;
3411 int ret;
3412
3413 dev_dbg(dev, "ASoC: platform register %s\n", dev_name(dev));
3414
3415 platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
3416 if (platform == NULL)
3417 return -ENOMEM;
3418
3419 ret = snd_soc_add_platform(dev, platform, platform_drv);
3420 if (ret)
3421 kfree(platform);
3422
3423 return ret;
3424}
3425EXPORT_SYMBOL_GPL(snd_soc_register_platform);
3426
3427
3428
3429
3430
3431void snd_soc_remove_platform(struct snd_soc_platform *platform)
3432{
3433
3434 mutex_lock(&client_mutex);
3435 list_del(&platform->list);
3436 snd_soc_component_del_unlocked(&platform->component);
3437 mutex_unlock(&client_mutex);
3438
3439 dev_dbg(platform->dev, "ASoC: Unregistered platform '%s'\n",
3440 platform->component.name);
3441
3442 snd_soc_component_cleanup(&platform->component);
3443}
3444EXPORT_SYMBOL_GPL(snd_soc_remove_platform);
3445
3446struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev)
3447{
3448 struct snd_soc_platform *platform;
3449
3450 mutex_lock(&client_mutex);
3451 list_for_each_entry(platform, &platform_list, list) {
3452 if (dev == platform->dev) {
3453 mutex_unlock(&client_mutex);
3454 return platform;
3455 }
3456 }
3457 mutex_unlock(&client_mutex);
3458
3459 return NULL;
3460}
3461EXPORT_SYMBOL_GPL(snd_soc_lookup_platform);
3462
3463
3464
3465
3466
3467
3468void snd_soc_unregister_platform(struct device *dev)
3469{
3470 struct snd_soc_platform *platform;
3471
3472 platform = snd_soc_lookup_platform(dev);
3473 if (!platform)
3474 return;
3475
3476 snd_soc_remove_platform(platform);
3477 kfree(platform);
3478}
3479EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
3480
3481static u64 codec_format_map[] = {
3482 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
3483 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
3484 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
3485 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
3486 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
3487 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
3488 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3489 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3490 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
3491 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
3492 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
3493 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
3494 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
3495 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
3496 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
3497 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
3498};
3499
3500
3501
3502
3503
3504
3505static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
3506{
3507 int i;
3508
3509 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
3510 if (stream->formats & codec_format_map[i])
3511 stream->formats |= codec_format_map[i];
3512}
3513
3514static int snd_soc_codec_drv_probe(struct snd_soc_component *component)
3515{
3516 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3517
3518 return codec->driver->probe(codec);
3519}
3520
3521static void snd_soc_codec_drv_remove(struct snd_soc_component *component)
3522{
3523 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3524
3525 codec->driver->remove(codec);
3526}
3527
3528static int snd_soc_codec_drv_suspend(struct snd_soc_component *component)
3529{
3530 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3531
3532 return codec->driver->suspend(codec);
3533}
3534
3535static int snd_soc_codec_drv_resume(struct snd_soc_component *component)
3536{
3537 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3538
3539 return codec->driver->resume(codec);
3540}
3541
3542static int snd_soc_codec_drv_write(struct snd_soc_component *component,
3543 unsigned int reg, unsigned int val)
3544{
3545 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3546
3547 return codec->driver->write(codec, reg, val);
3548}
3549
3550static int snd_soc_codec_drv_read(struct snd_soc_component *component,
3551 unsigned int reg, unsigned int *val)
3552{
3553 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3554
3555 *val = codec->driver->read(codec, reg);
3556
3557 return 0;
3558}
3559
3560static int snd_soc_codec_set_bias_level(struct snd_soc_dapm_context *dapm,
3561 enum snd_soc_bias_level level)
3562{
3563 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
3564
3565 return codec->driver->set_bias_level(codec, level);
3566}
3567
3568
3569
3570
3571
3572
3573
3574
3575
3576int snd_soc_register_codec(struct device *dev,
3577 const struct snd_soc_codec_driver *codec_drv,
3578 struct snd_soc_dai_driver *dai_drv,
3579 int num_dai)
3580{
3581 struct snd_soc_dapm_context *dapm;
3582 struct snd_soc_codec *codec;
3583 struct snd_soc_dai *dai;
3584 int ret, i;
3585
3586 dev_dbg(dev, "codec register %s\n", dev_name(dev));
3587
3588 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
3589 if (codec == NULL)
3590 return -ENOMEM;
3591
3592 codec->component.codec = codec;
3593
3594 ret = snd_soc_component_initialize(&codec->component,
3595 &codec_drv->component_driver, dev);
3596 if (ret)
3597 goto err_free;
3598
3599 if (codec_drv->probe)
3600 codec->component.probe = snd_soc_codec_drv_probe;
3601 if (codec_drv->remove)
3602 codec->component.remove = snd_soc_codec_drv_remove;
3603 if (codec_drv->suspend)
3604 codec->component.suspend = snd_soc_codec_drv_suspend;
3605 if (codec_drv->resume)
3606 codec->component.resume = snd_soc_codec_drv_resume;
3607 if (codec_drv->write)
3608 codec->component.write = snd_soc_codec_drv_write;
3609 if (codec_drv->read)
3610 codec->component.read = snd_soc_codec_drv_read;
3611 codec->component.ignore_pmdown_time = codec_drv->ignore_pmdown_time;
3612
3613 dapm = snd_soc_codec_get_dapm(codec);
3614 dapm->idle_bias_off = codec_drv->idle_bias_off;
3615 dapm->suspend_bias_off = codec_drv->suspend_bias_off;
3616 if (codec_drv->seq_notifier)
3617 dapm->seq_notifier = codec_drv->seq_notifier;
3618 if (codec_drv->set_bias_level)
3619 dapm->set_bias_level = snd_soc_codec_set_bias_level;
3620 codec->dev = dev;
3621 codec->driver = codec_drv;
3622 codec->component.val_bytes = codec_drv->reg_word_size;
3623
3624#ifdef CONFIG_DEBUG_FS
3625 codec->component.init_debugfs = soc_init_codec_debugfs;
3626 codec->component.debugfs_prefix = "codec";
3627#endif
3628
3629 if (codec_drv->get_regmap)
3630 codec->component.regmap = codec_drv->get_regmap(dev);
3631
3632 for (i = 0; i < num_dai; i++) {
3633 fixup_codec_formats(&dai_drv[i].playback);
3634 fixup_codec_formats(&dai_drv[i].capture);
3635 }
3636
3637 ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);
3638 if (ret < 0) {
3639 dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
3640 goto err_cleanup;
3641 }
3642
3643 list_for_each_entry(dai, &codec->component.dai_list, list)
3644 dai->codec = codec;
3645
3646 mutex_lock(&client_mutex);
3647 snd_soc_component_add_unlocked(&codec->component);
3648 list_add(&codec->list, &codec_list);
3649 mutex_unlock(&client_mutex);
3650
3651 dev_dbg(codec->dev, "ASoC: Registered codec '%s'\n",
3652 codec->component.name);
3653 return 0;
3654
3655err_cleanup:
3656 snd_soc_component_cleanup(&codec->component);
3657err_free:
3658 kfree(codec);
3659 return ret;
3660}
3661EXPORT_SYMBOL_GPL(snd_soc_register_codec);
3662
3663
3664
3665
3666
3667
3668void snd_soc_unregister_codec(struct device *dev)
3669{
3670 struct snd_soc_codec *codec;
3671
3672 mutex_lock(&client_mutex);
3673 list_for_each_entry(codec, &codec_list, list) {
3674 if (dev == codec->dev)
3675 goto found;
3676 }
3677 mutex_unlock(&client_mutex);
3678 return;
3679
3680found:
3681 list_del(&codec->list);
3682 snd_soc_component_del_unlocked(&codec->component);
3683 mutex_unlock(&client_mutex);
3684
3685 dev_dbg(codec->dev, "ASoC: Unregistered codec '%s'\n",
3686 codec->component.name);
3687
3688 snd_soc_component_cleanup(&codec->component);
3689 snd_soc_cache_exit(codec);
3690 kfree(codec);
3691}
3692EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
3693
3694
3695int snd_soc_of_parse_card_name(struct snd_soc_card *card,
3696 const char *propname)
3697{
3698 struct device_node *np;
3699 int ret;
3700
3701 if (!card->dev) {
3702 pr_err("card->dev is not set before calling %s\n", __func__);
3703 return -EINVAL;
3704 }
3705
3706 np = card->dev->of_node;
3707
3708 ret = of_property_read_string_index(np, propname, 0, &card->name);
3709
3710
3711
3712
3713
3714 if (ret < 0 && ret != -EINVAL) {
3715 dev_err(card->dev,
3716 "ASoC: Property '%s' could not be read: %d\n",
3717 propname, ret);
3718 return ret;
3719 }
3720
3721 return 0;
3722}
3723EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
3724
3725static const struct snd_soc_dapm_widget simple_widgets[] = {
3726 SND_SOC_DAPM_MIC("Microphone", NULL),
3727 SND_SOC_DAPM_LINE("Line", NULL),
3728 SND_SOC_DAPM_HP("Headphone", NULL),
3729 SND_SOC_DAPM_SPK("Speaker", NULL),
3730};
3731
3732int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
3733 const char *propname)
3734{
3735 struct device_node *np = card->dev->of_node;
3736 struct snd_soc_dapm_widget *widgets;
3737 const char *template, *wname;
3738 int i, j, num_widgets, ret;
3739
3740 num_widgets = of_property_count_strings(np, propname);
3741 if (num_widgets < 0) {
3742 dev_err(card->dev,
3743 "ASoC: Property '%s' does not exist\n", propname);
3744 return -EINVAL;
3745 }
3746 if (num_widgets & 1) {
3747 dev_err(card->dev,
3748 "ASoC: Property '%s' length is not even\n", propname);
3749 return -EINVAL;
3750 }
3751
3752 num_widgets /= 2;
3753 if (!num_widgets) {
3754 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
3755 propname);
3756 return -EINVAL;
3757 }
3758
3759 widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets),
3760 GFP_KERNEL);
3761 if (!widgets) {
3762 dev_err(card->dev,
3763 "ASoC: Could not allocate memory for widgets\n");
3764 return -ENOMEM;
3765 }
3766
3767 for (i = 0; i < num_widgets; i++) {
3768 ret = of_property_read_string_index(np, propname,
3769 2 * i, &template);
3770 if (ret) {
3771 dev_err(card->dev,
3772 "ASoC: Property '%s' index %d read error:%d\n",
3773 propname, 2 * i, ret);
3774 return -EINVAL;
3775 }
3776
3777 for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) {
3778 if (!strncmp(template, simple_widgets[j].name,
3779 strlen(simple_widgets[j].name))) {
3780 widgets[i] = simple_widgets[j];
3781 break;
3782 }
3783 }
3784
3785 if (j >= ARRAY_SIZE(simple_widgets)) {
3786 dev_err(card->dev,
3787 "ASoC: DAPM widget '%s' is not supported\n",
3788 template);
3789 return -EINVAL;
3790 }
3791
3792 ret = of_property_read_string_index(np, propname,
3793 (2 * i) + 1,
3794 &wname);
3795 if (ret) {
3796 dev_err(card->dev,
3797 "ASoC: Property '%s' index %d read error:%d\n",
3798 propname, (2 * i) + 1, ret);
3799 return -EINVAL;
3800 }
3801
3802 widgets[i].name = wname;
3803 }
3804
3805 card->of_dapm_widgets = widgets;
3806 card->num_of_dapm_widgets = num_widgets;
3807
3808 return 0;
3809}
3810EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);
3811
3812static int snd_soc_of_get_slot_mask(struct device_node *np,
3813 const char *prop_name,
3814 unsigned int *mask)
3815{
3816 u32 val;
3817 const __be32 *of_slot_mask = of_get_property(np, prop_name, &val);
3818 int i;
3819
3820 if (!of_slot_mask)
3821 return 0;
3822 val /= sizeof(u32);
3823 for (i = 0; i < val; i++)
3824 if (be32_to_cpup(&of_slot_mask[i]))
3825 *mask |= (1 << i);
3826
3827 return val;
3828}
3829
3830int snd_soc_of_parse_tdm_slot(struct device_node *np,
3831 unsigned int *tx_mask,
3832 unsigned int *rx_mask,
3833 unsigned int *slots,
3834 unsigned int *slot_width)
3835{
3836 u32 val;
3837 int ret;
3838
3839 if (tx_mask)
3840 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask);
3841 if (rx_mask)
3842 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", rx_mask);
3843
3844 if (of_property_read_bool(np, "dai-tdm-slot-num")) {
3845 ret = of_property_read_u32(np, "dai-tdm-slot-num", &val);
3846 if (ret)
3847 return ret;
3848
3849 if (slots)
3850 *slots = val;
3851 }
3852
3853 if (of_property_read_bool(np, "dai-tdm-slot-width")) {
3854 ret = of_property_read_u32(np, "dai-tdm-slot-width", &val);
3855 if (ret)
3856 return ret;
3857
3858 if (slot_width)
3859 *slot_width = val;
3860 }
3861
3862 return 0;
3863}
3864EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot);
3865
3866void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
3867 struct snd_soc_codec_conf *codec_conf,
3868 struct device_node *of_node,
3869 const char *propname)
3870{
3871 struct device_node *np = card->dev->of_node;
3872 const char *str;
3873 int ret;
3874
3875 ret = of_property_read_string(np, propname, &str);
3876 if (ret < 0) {
3877
3878 return;
3879 }
3880
3881 codec_conf->of_node = of_node;
3882 codec_conf->name_prefix = str;
3883}
3884EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_prefix);
3885
3886int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
3887 const char *propname)
3888{
3889 struct device_node *np = card->dev->of_node;
3890 int num_routes;
3891 struct snd_soc_dapm_route *routes;
3892 int i, ret;
3893
3894 num_routes = of_property_count_strings(np, propname);
3895 if (num_routes < 0 || num_routes & 1) {
3896 dev_err(card->dev,
3897 "ASoC: Property '%s' does not exist or its length is not even\n",
3898 propname);
3899 return -EINVAL;
3900 }
3901 num_routes /= 2;
3902 if (!num_routes) {
3903 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
3904 propname);
3905 return -EINVAL;
3906 }
3907
3908 routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
3909 GFP_KERNEL);
3910 if (!routes) {
3911 dev_err(card->dev,
3912 "ASoC: Could not allocate DAPM route table\n");
3913 return -EINVAL;
3914 }
3915
3916 for (i = 0; i < num_routes; i++) {
3917 ret = of_property_read_string_index(np, propname,
3918 2 * i, &routes[i].sink);
3919 if (ret) {
3920 dev_err(card->dev,
3921 "ASoC: Property '%s' index %d could not be read: %d\n",
3922 propname, 2 * i, ret);
3923 return -EINVAL;
3924 }
3925 ret = of_property_read_string_index(np, propname,
3926 (2 * i) + 1, &routes[i].source);
3927 if (ret) {
3928 dev_err(card->dev,
3929 "ASoC: Property '%s' index %d could not be read: %d\n",
3930 propname, (2 * i) + 1, ret);
3931 return -EINVAL;
3932 }
3933 }
3934
3935 card->num_of_dapm_routes = num_routes;
3936 card->of_dapm_routes = routes;
3937
3938 return 0;
3939}
3940EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
3941
3942unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
3943 const char *prefix,
3944 struct device_node **bitclkmaster,
3945 struct device_node **framemaster)
3946{
3947 int ret, i;
3948 char prop[128];
3949 unsigned int format = 0;
3950 int bit, frame;
3951 const char *str;
3952 struct {
3953 char *name;
3954 unsigned int val;
3955 } of_fmt_table[] = {
3956 { "i2s", SND_SOC_DAIFMT_I2S },
3957 { "right_j", SND_SOC_DAIFMT_RIGHT_J },
3958 { "left_j", SND_SOC_DAIFMT_LEFT_J },
3959 { "dsp_a", SND_SOC_DAIFMT_DSP_A },
3960 { "dsp_b", SND_SOC_DAIFMT_DSP_B },
3961 { "ac97", SND_SOC_DAIFMT_AC97 },
3962 { "pdm", SND_SOC_DAIFMT_PDM},
3963 { "msb", SND_SOC_DAIFMT_MSB },
3964 { "lsb", SND_SOC_DAIFMT_LSB },
3965 };
3966
3967 if (!prefix)
3968 prefix = "";
3969
3970
3971
3972
3973
3974
3975 ret = of_property_read_string(np, "dai-format", &str);
3976 if (ret < 0) {
3977 snprintf(prop, sizeof(prop), "%sformat", prefix);
3978 ret = of_property_read_string(np, prop, &str);
3979 }
3980 if (ret == 0) {
3981 for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) {
3982 if (strcmp(str, of_fmt_table[i].name) == 0) {
3983 format |= of_fmt_table[i].val;
3984 break;
3985 }
3986 }
3987 }
3988
3989
3990
3991
3992
3993 snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);
3994 if (of_property_read_bool(np, prop))
3995 format |= SND_SOC_DAIFMT_CONT;
3996 else
3997 format |= SND_SOC_DAIFMT_GATED;
3998
3999
4000
4001
4002
4003
4004 snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix);
4005 bit = !!of_get_property(np, prop, NULL);
4006
4007 snprintf(prop, sizeof(prop), "%sframe-inversion", prefix);
4008 frame = !!of_get_property(np, prop, NULL);
4009
4010 switch ((bit << 4) + frame) {
4011 case 0x11:
4012 format |= SND_SOC_DAIFMT_IB_IF;
4013 break;
4014 case 0x10:
4015 format |= SND_SOC_DAIFMT_IB_NF;
4016 break;
4017 case 0x01:
4018 format |= SND_SOC_DAIFMT_NB_IF;
4019 break;
4020 default:
4021
4022 break;
4023 }
4024
4025
4026
4027
4028
4029
4030 snprintf(prop, sizeof(prop), "%sbitclock-master", prefix);
4031 bit = !!of_get_property(np, prop, NULL);
4032 if (bit && bitclkmaster)
4033 *bitclkmaster = of_parse_phandle(np, prop, 0);
4034
4035 snprintf(prop, sizeof(prop), "%sframe-master", prefix);
4036 frame = !!of_get_property(np, prop, NULL);
4037 if (frame && framemaster)
4038 *framemaster = of_parse_phandle(np, prop, 0);
4039
4040 switch ((bit << 4) + frame) {
4041 case 0x11:
4042 format |= SND_SOC_DAIFMT_CBM_CFM;
4043 break;
4044 case 0x10:
4045 format |= SND_SOC_DAIFMT_CBM_CFS;
4046 break;
4047 case 0x01:
4048 format |= SND_SOC_DAIFMT_CBS_CFM;
4049 break;
4050 default:
4051 format |= SND_SOC_DAIFMT_CBS_CFS;
4052 break;
4053 }
4054
4055 return format;
4056}
4057EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt);
4058
4059int snd_soc_get_dai_id(struct device_node *ep)
4060{
4061 struct snd_soc_component *pos;
4062 struct device_node *node;
4063 int ret;
4064
4065 node = of_graph_get_port_parent(ep);
4066
4067
4068
4069
4070
4071
4072
4073 ret = -ENOTSUPP;
4074 mutex_lock(&client_mutex);
4075 list_for_each_entry(pos, &component_list, list) {
4076 struct device_node *component_of_node = pos->dev->of_node;
4077
4078 if (!component_of_node && pos->dev->parent)
4079 component_of_node = pos->dev->parent->of_node;
4080
4081 if (component_of_node != node)
4082 continue;
4083
4084 if (pos->driver->of_xlate_dai_id)
4085 ret = pos->driver->of_xlate_dai_id(pos, ep);
4086
4087 break;
4088 }
4089 mutex_unlock(&client_mutex);
4090
4091 of_node_put(node);
4092
4093 return ret;
4094}
4095EXPORT_SYMBOL_GPL(snd_soc_get_dai_id);
4096
4097int snd_soc_get_dai_name(struct of_phandle_args *args,
4098 const char **dai_name)
4099{
4100 struct snd_soc_component *pos;
4101 struct device_node *component_of_node;
4102 int ret = -EPROBE_DEFER;
4103
4104 mutex_lock(&client_mutex);
4105 list_for_each_entry(pos, &component_list, list) {
4106 component_of_node = pos->dev->of_node;
4107 if (!component_of_node && pos->dev->parent)
4108 component_of_node = pos->dev->parent->of_node;
4109
4110 if (component_of_node != args->np)
4111 continue;
4112
4113 if (pos->driver->of_xlate_dai_name) {
4114 ret = pos->driver->of_xlate_dai_name(pos,
4115 args,
4116 dai_name);
4117 } else {
4118 int id = -1;
4119
4120 switch (args->args_count) {
4121 case 0:
4122 id = 0;
4123 break;
4124 case 1:
4125 id = args->args[0];
4126 break;
4127 default:
4128
4129 break;
4130 }
4131
4132 if (id < 0 || id >= pos->num_dai) {
4133 ret = -EINVAL;
4134 continue;
4135 }
4136
4137 ret = 0;
4138
4139 *dai_name = pos->dai_drv[id].name;
4140 if (!*dai_name)
4141 *dai_name = pos->name;
4142 }
4143
4144 break;
4145 }
4146 mutex_unlock(&client_mutex);
4147 return ret;
4148}
4149EXPORT_SYMBOL_GPL(snd_soc_get_dai_name);
4150
4151int snd_soc_of_get_dai_name(struct device_node *of_node,
4152 const char **dai_name)
4153{
4154 struct of_phandle_args args;
4155 int ret;
4156
4157 ret = of_parse_phandle_with_args(of_node, "sound-dai",
4158 "#sound-dai-cells", 0, &args);
4159 if (ret)
4160 return ret;
4161
4162 ret = snd_soc_get_dai_name(&args, dai_name);
4163
4164 of_node_put(args.np);
4165
4166 return ret;
4167}
4168EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);
4169
4170
4171
4172
4173
4174
4175
4176
4177
4178
4179
4180
4181
4182
4183int snd_soc_of_get_dai_link_codecs(struct device *dev,
4184 struct device_node *of_node,
4185 struct snd_soc_dai_link *dai_link)
4186{
4187 struct of_phandle_args args;
4188 struct snd_soc_dai_link_component *component;
4189 char *name;
4190 int index, num_codecs, ret;
4191
4192
4193 name = "sound-dai";
4194 num_codecs = of_count_phandle_with_args(of_node, name,
4195 "#sound-dai-cells");
4196 if (num_codecs <= 0) {
4197 if (num_codecs == -ENOENT)
4198 dev_err(dev, "No 'sound-dai' property\n");
4199 else
4200 dev_err(dev, "Bad phandle in 'sound-dai'\n");
4201 return num_codecs;
4202 }
4203 component = devm_kzalloc(dev,
4204 sizeof *component * num_codecs,
4205 GFP_KERNEL);
4206 if (!component)
4207 return -ENOMEM;
4208 dai_link->codecs = component;
4209 dai_link->num_codecs = num_codecs;
4210
4211
4212 for (index = 0, component = dai_link->codecs;
4213 index < dai_link->num_codecs;
4214 index++, component++) {
4215 ret = of_parse_phandle_with_args(of_node, name,
4216 "#sound-dai-cells",
4217 index, &args);
4218 if (ret)
4219 goto err;
4220 component->of_node = args.np;
4221 ret = snd_soc_get_dai_name(&args, &component->dai_name);
4222 if (ret < 0)
4223 goto err;
4224 }
4225 return 0;
4226err:
4227 for (index = 0, component = dai_link->codecs;
4228 index < dai_link->num_codecs;
4229 index++, component++) {
4230 if (!component->of_node)
4231 break;
4232 of_node_put(component->of_node);
4233 component->of_node = NULL;
4234 }
4235 dai_link->codecs = NULL;
4236 dai_link->num_codecs = 0;
4237 return ret;
4238}
4239EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);
4240
4241static int __init snd_soc_init(void)
4242{
4243 snd_soc_debugfs_init();
4244 snd_soc_util_init();
4245
4246 return platform_driver_register(&soc_driver);
4247}
4248module_init(snd_soc_init);
4249
4250static void __exit snd_soc_exit(void)
4251{
4252 snd_soc_util_exit();
4253 snd_soc_debugfs_exit();
4254
4255 platform_driver_unregister(&soc_driver);
4256}
4257module_exit(snd_soc_exit);
4258
4259
4260MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
4261MODULE_DESCRIPTION("ALSA SoC Core");
4262MODULE_LICENSE("GPL");
4263MODULE_ALIAS("platform:soc-audio");
4264