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