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