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