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