2 * soc-core.c -- ALSA SoC Audio Layer
4 * Copyright 2005 Wolfson Microelectronics PLC.
5 * Copyright 2005 Openedhand Ltd.
6 * Copyright (C) 2010 Slimlogic Ltd.
7 * Copyright (C) 2010 Texas Instruments Inc.
9 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
10 * with code, comments and ideas from :-
11 * Richard Purdie <richard@openedhand.com>
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
19 * o Add hw rules to enforce rates, etc.
20 * o More testing with other codecs/machines.
21 * o Add more codecs and platforms to ensure good API coverage.
22 * o Support TDM on PCM and I2S
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/init.h>
28 #include <linux/delay.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>
37 #include <linux/gpio.h>
38 #include <linux/of_gpio.h>
39 #include <sound/ac97_codec.h>
40 #include <sound/core.h>
41 #include <sound/jack.h>
42 #include <sound/pcm.h>
43 #include <sound/pcm_params.h>
44 #include <sound/soc.h>
45 #include <sound/soc-dpcm.h>
46 #include <sound/initval.h>
48 #define CREATE_TRACE_POINTS
49 #include <trace/events/asoc.h>
53 #ifdef CONFIG_DEBUG_FS
54 struct dentry
*snd_soc_debugfs_root
;
55 EXPORT_SYMBOL_GPL(snd_soc_debugfs_root
);
58 static DEFINE_MUTEX(client_mutex
);
59 static LIST_HEAD(platform_list
);
60 static LIST_HEAD(codec_list
);
61 static LIST_HEAD(component_list
);
64 * This is a timeout to do a DAPM powerdown after a stream is closed().
65 * It can be used to eliminate pops between different playback streams, e.g.
66 * between two audio tracks.
68 static int pmdown_time
= 5000;
69 module_param(pmdown_time
, int, 0);
70 MODULE_PARM_DESC(pmdown_time
, "DAPM stream powerdown time (msecs)");
72 struct snd_ac97_reset_cfg
{
74 struct pinctrl_state
*pstate_reset
;
75 struct pinctrl_state
*pstate_warm_reset
;
76 struct pinctrl_state
*pstate_run
;
82 /* returns the minimum number of bytes needed to represent
83 * a particular given value */
84 static int min_bytes_needed(unsigned long val
)
89 for (i
= (sizeof val
* 8) - 1; i
>= 0; --i
, ++c
)
92 c
= (sizeof val
* 8) - c
;
100 /* fill buf which is 'len' bytes with a formatted
101 * string of the form 'reg: value\n' */
102 static int format_register_str(struct snd_soc_codec
*codec
,
103 unsigned int reg
, char *buf
, size_t len
)
105 int wordsize
= min_bytes_needed(codec
->driver
->reg_cache_size
) * 2;
106 int regsize
= codec
->driver
->reg_word_size
* 2;
108 char tmpbuf
[len
+ 1];
109 char regbuf
[regsize
+ 1];
111 /* since tmpbuf is allocated on the stack, warn the callers if they
112 * try to abuse this function */
115 /* +2 for ': ' and + 1 for '\n' */
116 if (wordsize
+ regsize
+ 2 + 1 != len
)
119 ret
= snd_soc_read(codec
, reg
);
121 memset(regbuf
, 'X', regsize
);
122 regbuf
[regsize
] = '\0';
124 snprintf(regbuf
, regsize
+ 1, "%.*x", regsize
, ret
);
127 /* prepare the buffer */
128 snprintf(tmpbuf
, len
+ 1, "%.*x: %s\n", wordsize
, reg
, regbuf
);
129 /* copy it back to the caller without the '\0' */
130 memcpy(buf
, tmpbuf
, len
);
135 /* codec register dump */
136 static ssize_t
soc_codec_reg_show(struct snd_soc_codec
*codec
, char *buf
,
137 size_t count
, loff_t pos
)
140 int wordsize
, regsize
;
145 wordsize
= min_bytes_needed(codec
->driver
->reg_cache_size
) * 2;
146 regsize
= codec
->driver
->reg_word_size
* 2;
148 len
= wordsize
+ regsize
+ 2 + 1;
150 if (!codec
->driver
->reg_cache_size
)
153 if (codec
->driver
->reg_cache_step
)
154 step
= codec
->driver
->reg_cache_step
;
156 for (i
= 0; i
< codec
->driver
->reg_cache_size
; i
+= step
) {
157 /* only support larger than PAGE_SIZE bytes debugfs
158 * entries for the default case */
160 if (total
+ len
>= count
- 1)
162 format_register_str(codec
, i
, buf
+ total
, len
);
168 total
= min(total
, count
- 1);
173 static ssize_t
codec_reg_show(struct device
*dev
,
174 struct device_attribute
*attr
, char *buf
)
176 struct snd_soc_pcm_runtime
*rtd
= dev_get_drvdata(dev
);
178 return soc_codec_reg_show(rtd
->codec
, buf
, PAGE_SIZE
, 0);
181 static DEVICE_ATTR(codec_reg
, 0444, codec_reg_show
, NULL
);
183 static ssize_t
pmdown_time_show(struct device
*dev
,
184 struct device_attribute
*attr
, char *buf
)
186 struct snd_soc_pcm_runtime
*rtd
= dev_get_drvdata(dev
);
188 return sprintf(buf
, "%ld\n", rtd
->pmdown_time
);
191 static ssize_t
pmdown_time_set(struct device
*dev
,
192 struct device_attribute
*attr
,
193 const char *buf
, size_t count
)
195 struct snd_soc_pcm_runtime
*rtd
= dev_get_drvdata(dev
);
198 ret
= kstrtol(buf
, 10, &rtd
->pmdown_time
);
205 static DEVICE_ATTR(pmdown_time
, 0644, pmdown_time_show
, pmdown_time_set
);
207 #ifdef CONFIG_DEBUG_FS
208 static ssize_t
codec_reg_read_file(struct file
*file
, char __user
*user_buf
,
209 size_t count
, loff_t
*ppos
)
212 struct snd_soc_codec
*codec
= file
->private_data
;
215 if (*ppos
< 0 || !count
)
218 buf
= kmalloc(count
, GFP_KERNEL
);
222 ret
= soc_codec_reg_show(codec
, buf
, count
, *ppos
);
224 if (copy_to_user(user_buf
, buf
, ret
)) {
235 static ssize_t
codec_reg_write_file(struct file
*file
,
236 const char __user
*user_buf
, size_t count
, loff_t
*ppos
)
241 unsigned long reg
, value
;
242 struct snd_soc_codec
*codec
= file
->private_data
;
245 buf_size
= min(count
, (sizeof(buf
)-1));
246 if (copy_from_user(buf
, user_buf
, buf_size
))
250 while (*start
== ' ')
252 reg
= simple_strtoul(start
, &start
, 16);
253 while (*start
== ' ')
255 ret
= kstrtoul(start
, 16, &value
);
259 /* Userspace has been fiddling around behind the kernel's back */
260 add_taint(TAINT_USER
, LOCKDEP_NOW_UNRELIABLE
);
262 snd_soc_write(codec
, reg
, value
);
266 static const struct file_operations codec_reg_fops
= {
268 .read
= codec_reg_read_file
,
269 .write
= codec_reg_write_file
,
270 .llseek
= default_llseek
,
273 static struct dentry
*soc_debugfs_create_dir(struct dentry
*parent
,
274 const char *fmt
, ...)
281 s
= kvasprintf(GFP_KERNEL
, fmt
, ap
);
287 de
= debugfs_create_dir(s
, parent
);
293 static void soc_init_codec_debugfs(struct snd_soc_codec
*codec
)
295 struct dentry
*debugfs_card_root
= codec
->card
->debugfs_card_root
;
297 codec
->debugfs_codec_root
= soc_debugfs_create_dir(debugfs_card_root
,
299 codec
->component
.name
);
300 if (!codec
->debugfs_codec_root
) {
302 "ASoC: Failed to create codec debugfs directory\n");
306 debugfs_create_bool("cache_sync", 0444, codec
->debugfs_codec_root
,
308 debugfs_create_bool("cache_only", 0444, codec
->debugfs_codec_root
,
311 codec
->debugfs_reg
= debugfs_create_file("codec_reg", 0644,
312 codec
->debugfs_codec_root
,
313 codec
, &codec_reg_fops
);
314 if (!codec
->debugfs_reg
)
316 "ASoC: Failed to create codec register debugfs file\n");
318 snd_soc_dapm_debugfs_init(&codec
->dapm
, codec
->debugfs_codec_root
);
321 static void soc_cleanup_codec_debugfs(struct snd_soc_codec
*codec
)
323 debugfs_remove_recursive(codec
->debugfs_codec_root
);
326 static void soc_init_platform_debugfs(struct snd_soc_platform
*platform
)
328 struct dentry
*debugfs_card_root
= platform
->card
->debugfs_card_root
;
330 platform
->debugfs_platform_root
= soc_debugfs_create_dir(debugfs_card_root
,
332 platform
->component
.name
);
333 if (!platform
->debugfs_platform_root
) {
334 dev_warn(platform
->dev
,
335 "ASoC: Failed to create platform debugfs directory\n");
339 snd_soc_dapm_debugfs_init(&platform
->component
.dapm
,
340 platform
->debugfs_platform_root
);
343 static void soc_cleanup_platform_debugfs(struct snd_soc_platform
*platform
)
345 debugfs_remove_recursive(platform
->debugfs_platform_root
);
348 static ssize_t
codec_list_read_file(struct file
*file
, char __user
*user_buf
,
349 size_t count
, loff_t
*ppos
)
351 char *buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
352 ssize_t len
, ret
= 0;
353 struct snd_soc_codec
*codec
;
358 list_for_each_entry(codec
, &codec_list
, list
) {
359 len
= snprintf(buf
+ ret
, PAGE_SIZE
- ret
, "%s\n",
360 codec
->component
.name
);
363 if (ret
> PAGE_SIZE
) {
370 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, ret
);
377 static const struct file_operations codec_list_fops
= {
378 .read
= codec_list_read_file
,
379 .llseek
= default_llseek
,/* read accesses f_pos */
382 static ssize_t
dai_list_read_file(struct file
*file
, char __user
*user_buf
,
383 size_t count
, loff_t
*ppos
)
385 char *buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
386 ssize_t len
, ret
= 0;
387 struct snd_soc_component
*component
;
388 struct snd_soc_dai
*dai
;
393 list_for_each_entry(component
, &component_list
, list
) {
394 list_for_each_entry(dai
, &component
->dai_list
, list
) {
395 len
= snprintf(buf
+ ret
, PAGE_SIZE
- ret
, "%s\n",
399 if (ret
> PAGE_SIZE
) {
406 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, ret
);
413 static const struct file_operations dai_list_fops
= {
414 .read
= dai_list_read_file
,
415 .llseek
= default_llseek
,/* read accesses f_pos */
418 static ssize_t
platform_list_read_file(struct file
*file
,
419 char __user
*user_buf
,
420 size_t count
, loff_t
*ppos
)
422 char *buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
423 ssize_t len
, ret
= 0;
424 struct snd_soc_platform
*platform
;
429 list_for_each_entry(platform
, &platform_list
, list
) {
430 len
= snprintf(buf
+ ret
, PAGE_SIZE
- ret
, "%s\n",
431 platform
->component
.name
);
434 if (ret
> PAGE_SIZE
) {
440 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, ret
);
447 static const struct file_operations platform_list_fops
= {
448 .read
= platform_list_read_file
,
449 .llseek
= default_llseek
,/* read accesses f_pos */
452 static void soc_init_card_debugfs(struct snd_soc_card
*card
)
454 card
->debugfs_card_root
= debugfs_create_dir(card
->name
,
455 snd_soc_debugfs_root
);
456 if (!card
->debugfs_card_root
) {
458 "ASoC: Failed to create card debugfs directory\n");
462 card
->debugfs_pop_time
= debugfs_create_u32("dapm_pop_time", 0644,
463 card
->debugfs_card_root
,
465 if (!card
->debugfs_pop_time
)
467 "ASoC: Failed to create pop time debugfs file\n");
470 static void soc_cleanup_card_debugfs(struct snd_soc_card
*card
)
472 debugfs_remove_recursive(card
->debugfs_card_root
);
477 static inline void soc_init_codec_debugfs(struct snd_soc_codec
*codec
)
481 static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec
*codec
)
485 static inline void soc_init_platform_debugfs(struct snd_soc_platform
*platform
)
489 static inline void soc_cleanup_platform_debugfs(struct snd_soc_platform
*platform
)
493 static inline void soc_init_card_debugfs(struct snd_soc_card
*card
)
497 static inline void soc_cleanup_card_debugfs(struct snd_soc_card
*card
)
502 struct snd_pcm_substream
*snd_soc_get_dai_substream(struct snd_soc_card
*card
,
503 const char *dai_link
, int stream
)
507 for (i
= 0; i
< card
->num_links
; i
++) {
508 if (card
->rtd
[i
].dai_link
->no_pcm
&&
509 !strcmp(card
->rtd
[i
].dai_link
->name
, dai_link
))
510 return card
->rtd
[i
].pcm
->streams
[stream
].substream
;
512 dev_dbg(card
->dev
, "ASoC: failed to find dai link %s\n", dai_link
);
515 EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream
);
517 struct snd_soc_pcm_runtime
*snd_soc_get_pcm_runtime(struct snd_soc_card
*card
,
518 const char *dai_link
)
522 for (i
= 0; i
< card
->num_links
; i
++) {
523 if (!strcmp(card
->rtd
[i
].dai_link
->name
, dai_link
))
524 return &card
->rtd
[i
];
526 dev_dbg(card
->dev
, "ASoC: failed to find rtd %s\n", dai_link
);
529 EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime
);
531 #ifdef CONFIG_SND_SOC_AC97_BUS
532 /* unregister ac97 codec */
533 static int soc_ac97_dev_unregister(struct snd_soc_codec
*codec
)
535 if (codec
->ac97
->dev
.bus
)
536 device_unregister(&codec
->ac97
->dev
);
540 /* stop no dev release warning */
541 static void soc_ac97_device_release(struct device
*dev
){}
543 /* register ac97 codec to bus */
544 static int soc_ac97_dev_register(struct snd_soc_codec
*codec
)
548 codec
->ac97
->dev
.bus
= &ac97_bus_type
;
549 codec
->ac97
->dev
.parent
= codec
->card
->dev
;
550 codec
->ac97
->dev
.release
= soc_ac97_device_release
;
552 dev_set_name(&codec
->ac97
->dev
, "%d-%d:%s",
553 codec
->card
->snd_card
->number
, 0, codec
->component
.name
);
554 err
= device_register(&codec
->ac97
->dev
);
556 dev_err(codec
->dev
, "ASoC: Can't register ac97 bus\n");
557 codec
->ac97
->dev
.bus
= NULL
;
564 static void codec2codec_close_delayed_work(struct work_struct
*work
)
566 /* Currently nothing to do for c2c links
567 * Since c2c links are internal nodes in the DAPM graph and
568 * don't interface with the outside world or application layer
569 * we don't have to do any special handling on close.
573 #ifdef CONFIG_PM_SLEEP
574 /* powers down audio subsystem for suspend */
575 int snd_soc_suspend(struct device
*dev
)
577 struct snd_soc_card
*card
= dev_get_drvdata(dev
);
578 struct snd_soc_codec
*codec
;
581 /* If the initialization of this soc device failed, there is no codec
582 * associated with it. Just bail out in this case.
584 if (list_empty(&card
->codec_dev_list
))
587 /* Due to the resume being scheduled into a workqueue we could
588 * suspend before that's finished - wait for it to complete.
590 snd_power_lock(card
->snd_card
);
591 snd_power_wait(card
->snd_card
, SNDRV_CTL_POWER_D0
);
592 snd_power_unlock(card
->snd_card
);
594 /* we're going to block userspace touching us until resume completes */
595 snd_power_change_state(card
->snd_card
, SNDRV_CTL_POWER_D3hot
);
597 /* mute any active DACs */
598 for (i
= 0; i
< card
->num_rtd
; i
++) {
600 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
603 for (j
= 0; j
< card
->rtd
[i
].num_codecs
; j
++) {
604 struct snd_soc_dai
*dai
= card
->rtd
[i
].codec_dais
[j
];
605 struct snd_soc_dai_driver
*drv
= dai
->driver
;
607 if (drv
->ops
->digital_mute
&& dai
->playback_active
)
608 drv
->ops
->digital_mute(dai
, 1);
612 /* suspend all pcms */
613 for (i
= 0; i
< card
->num_rtd
; i
++) {
614 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
617 snd_pcm_suspend_all(card
->rtd
[i
].pcm
);
620 if (card
->suspend_pre
)
621 card
->suspend_pre(card
);
623 for (i
= 0; i
< card
->num_rtd
; i
++) {
624 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
625 struct snd_soc_platform
*platform
= card
->rtd
[i
].platform
;
627 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
630 if (cpu_dai
->driver
->suspend
&& !cpu_dai
->driver
->ac97_control
)
631 cpu_dai
->driver
->suspend(cpu_dai
);
632 if (platform
->driver
->suspend
&& !platform
->suspended
) {
633 platform
->driver
->suspend(cpu_dai
);
634 platform
->suspended
= 1;
638 /* close any waiting streams and save state */
639 for (i
= 0; i
< card
->num_rtd
; i
++) {
640 struct snd_soc_dai
**codec_dais
= card
->rtd
[i
].codec_dais
;
641 flush_delayed_work(&card
->rtd
[i
].delayed_work
);
642 for (j
= 0; j
< card
->rtd
[i
].num_codecs
; j
++) {
643 codec_dais
[j
]->codec
->dapm
.suspend_bias_level
=
644 codec_dais
[j
]->codec
->dapm
.bias_level
;
648 for (i
= 0; i
< card
->num_rtd
; i
++) {
650 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
653 snd_soc_dapm_stream_event(&card
->rtd
[i
],
654 SNDRV_PCM_STREAM_PLAYBACK
,
655 SND_SOC_DAPM_STREAM_SUSPEND
);
657 snd_soc_dapm_stream_event(&card
->rtd
[i
],
658 SNDRV_PCM_STREAM_CAPTURE
,
659 SND_SOC_DAPM_STREAM_SUSPEND
);
662 /* Recheck all analogue paths too */
663 dapm_mark_io_dirty(&card
->dapm
);
664 snd_soc_dapm_sync(&card
->dapm
);
666 /* suspend all CODECs */
667 list_for_each_entry(codec
, &card
->codec_dev_list
, card_list
) {
668 /* If there are paths active then the CODEC will be held with
669 * bias _ON and should not be suspended. */
670 if (!codec
->suspended
&& codec
->driver
->suspend
) {
671 switch (codec
->dapm
.bias_level
) {
672 case SND_SOC_BIAS_STANDBY
:
674 * If the CODEC is capable of idle
675 * bias off then being in STANDBY
676 * means it's doing something,
677 * otherwise fall through.
679 if (codec
->dapm
.idle_bias_off
) {
681 "ASoC: idle_bias_off CODEC on over suspend\n");
684 case SND_SOC_BIAS_OFF
:
685 codec
->driver
->suspend(codec
);
686 codec
->suspended
= 1;
687 codec
->cache_sync
= 1;
688 if (codec
->component
.regmap
)
689 regcache_mark_dirty(codec
->component
.regmap
);
690 /* deactivate pins to sleep state */
691 pinctrl_pm_select_sleep_state(codec
->dev
);
695 "ASoC: CODEC is on over suspend\n");
701 for (i
= 0; i
< card
->num_rtd
; i
++) {
702 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
704 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
707 if (cpu_dai
->driver
->suspend
&& cpu_dai
->driver
->ac97_control
)
708 cpu_dai
->driver
->suspend(cpu_dai
);
710 /* deactivate pins to sleep state */
711 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
714 if (card
->suspend_post
)
715 card
->suspend_post(card
);
719 EXPORT_SYMBOL_GPL(snd_soc_suspend
);
721 /* deferred resume work, so resume can complete before we finished
722 * setting our codec back up, which can be very slow on I2C
724 static void soc_resume_deferred(struct work_struct
*work
)
726 struct snd_soc_card
*card
=
727 container_of(work
, struct snd_soc_card
, deferred_resume_work
);
728 struct snd_soc_codec
*codec
;
731 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
732 * so userspace apps are blocked from touching us
735 dev_dbg(card
->dev
, "ASoC: starting resume work\n");
737 /* Bring us up into D2 so that DAPM starts enabling things */
738 snd_power_change_state(card
->snd_card
, SNDRV_CTL_POWER_D2
);
740 if (card
->resume_pre
)
741 card
->resume_pre(card
);
743 /* resume AC97 DAIs */
744 for (i
= 0; i
< card
->num_rtd
; i
++) {
745 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
747 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
750 if (cpu_dai
->driver
->resume
&& cpu_dai
->driver
->ac97_control
)
751 cpu_dai
->driver
->resume(cpu_dai
);
754 list_for_each_entry(codec
, &card
->codec_dev_list
, card_list
) {
755 /* If the CODEC was idle over suspend then it will have been
756 * left with bias OFF or STANDBY and suspended so we must now
757 * resume. Otherwise the suspend was suppressed.
759 if (codec
->driver
->resume
&& codec
->suspended
) {
760 switch (codec
->dapm
.bias_level
) {
761 case SND_SOC_BIAS_STANDBY
:
762 case SND_SOC_BIAS_OFF
:
763 codec
->driver
->resume(codec
);
764 codec
->suspended
= 0;
768 "ASoC: CODEC was on over suspend\n");
774 for (i
= 0; i
< card
->num_rtd
; i
++) {
776 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
779 snd_soc_dapm_stream_event(&card
->rtd
[i
],
780 SNDRV_PCM_STREAM_PLAYBACK
,
781 SND_SOC_DAPM_STREAM_RESUME
);
783 snd_soc_dapm_stream_event(&card
->rtd
[i
],
784 SNDRV_PCM_STREAM_CAPTURE
,
785 SND_SOC_DAPM_STREAM_RESUME
);
788 /* unmute any active DACs */
789 for (i
= 0; i
< card
->num_rtd
; i
++) {
791 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
794 for (j
= 0; j
< card
->rtd
[i
].num_codecs
; j
++) {
795 struct snd_soc_dai
*dai
= card
->rtd
[i
].codec_dais
[j
];
796 struct snd_soc_dai_driver
*drv
= dai
->driver
;
798 if (drv
->ops
->digital_mute
&& dai
->playback_active
)
799 drv
->ops
->digital_mute(dai
, 0);
803 for (i
= 0; i
< card
->num_rtd
; i
++) {
804 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
805 struct snd_soc_platform
*platform
= card
->rtd
[i
].platform
;
807 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
810 if (cpu_dai
->driver
->resume
&& !cpu_dai
->driver
->ac97_control
)
811 cpu_dai
->driver
->resume(cpu_dai
);
812 if (platform
->driver
->resume
&& platform
->suspended
) {
813 platform
->driver
->resume(cpu_dai
);
814 platform
->suspended
= 0;
818 if (card
->resume_post
)
819 card
->resume_post(card
);
821 dev_dbg(card
->dev
, "ASoC: resume work completed\n");
823 /* userspace can access us now we are back as we were before */
824 snd_power_change_state(card
->snd_card
, SNDRV_CTL_POWER_D0
);
826 /* Recheck all analogue paths too */
827 dapm_mark_io_dirty(&card
->dapm
);
828 snd_soc_dapm_sync(&card
->dapm
);
831 /* powers up audio subsystem after a suspend */
832 int snd_soc_resume(struct device
*dev
)
834 struct snd_soc_card
*card
= dev_get_drvdata(dev
);
835 int i
, ac97_control
= 0;
837 /* If the initialization of this soc device failed, there is no codec
838 * associated with it. Just bail out in this case.
840 if (list_empty(&card
->codec_dev_list
))
843 /* activate pins from sleep state */
844 for (i
= 0; i
< card
->num_rtd
; i
++) {
845 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[i
];
846 struct snd_soc_dai
**codec_dais
= rtd
->codec_dais
;
847 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
851 pinctrl_pm_select_default_state(cpu_dai
->dev
);
853 for (j
= 0; j
< rtd
->num_codecs
; j
++) {
854 struct snd_soc_dai
*codec_dai
= codec_dais
[j
];
855 if (codec_dai
->active
)
856 pinctrl_pm_select_default_state(codec_dai
->dev
);
860 /* AC97 devices might have other drivers hanging off them so
861 * need to resume immediately. Other drivers don't have that
862 * problem and may take a substantial amount of time to resume
863 * due to I/O costs and anti-pop so handle them out of line.
865 for (i
= 0; i
< card
->num_rtd
; i
++) {
866 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
867 ac97_control
|= cpu_dai
->driver
->ac97_control
;
870 dev_dbg(dev
, "ASoC: Resuming AC97 immediately\n");
871 soc_resume_deferred(&card
->deferred_resume_work
);
873 dev_dbg(dev
, "ASoC: Scheduling resume work\n");
874 if (!schedule_work(&card
->deferred_resume_work
))
875 dev_err(dev
, "ASoC: resume work item may be lost\n");
880 EXPORT_SYMBOL_GPL(snd_soc_resume
);
882 #define snd_soc_suspend NULL
883 #define snd_soc_resume NULL
886 static const struct snd_soc_dai_ops null_dai_ops
= {
889 static struct snd_soc_codec
*soc_find_codec(
890 const struct device_node
*codec_of_node
,
891 const char *codec_name
)
893 struct snd_soc_codec
*codec
;
895 list_for_each_entry(codec
, &codec_list
, list
) {
897 if (codec
->dev
->of_node
!= codec_of_node
)
900 if (strcmp(codec
->component
.name
, codec_name
))
910 static struct snd_soc_dai
*soc_find_codec_dai(struct snd_soc_codec
*codec
,
911 const char *codec_dai_name
)
913 struct snd_soc_dai
*codec_dai
;
915 list_for_each_entry(codec_dai
, &codec
->component
.dai_list
, list
) {
916 if (!strcmp(codec_dai
->name
, codec_dai_name
)) {
924 static int soc_bind_dai_link(struct snd_soc_card
*card
, int num
)
926 struct snd_soc_dai_link
*dai_link
= &card
->dai_link
[num
];
927 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[num
];
928 struct snd_soc_component
*component
;
929 struct snd_soc_dai_link_component
*codecs
= dai_link
->codecs
;
930 struct snd_soc_dai
**codec_dais
= rtd
->codec_dais
;
931 struct snd_soc_platform
*platform
;
932 struct snd_soc_dai
*cpu_dai
;
933 const char *platform_name
;
936 dev_dbg(card
->dev
, "ASoC: binding %s at idx %d\n", dai_link
->name
, num
);
938 /* Find CPU DAI from registered DAIs*/
939 list_for_each_entry(component
, &component_list
, list
) {
940 if (dai_link
->cpu_of_node
&&
941 component
->dev
->of_node
!= dai_link
->cpu_of_node
)
943 if (dai_link
->cpu_name
&&
944 strcmp(dev_name(component
->dev
), dai_link
->cpu_name
))
946 list_for_each_entry(cpu_dai
, &component
->dai_list
, list
) {
947 if (dai_link
->cpu_dai_name
&&
948 strcmp(cpu_dai
->name
, dai_link
->cpu_dai_name
))
951 rtd
->cpu_dai
= cpu_dai
;
956 dev_err(card
->dev
, "ASoC: CPU DAI %s not registered\n",
957 dai_link
->cpu_dai_name
);
958 return -EPROBE_DEFER
;
961 rtd
->num_codecs
= dai_link
->num_codecs
;
963 /* Find CODEC from registered CODECs */
964 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
965 struct snd_soc_codec
*codec
;
966 codec
= soc_find_codec(codecs
[i
].of_node
, codecs
[i
].name
);
968 dev_err(card
->dev
, "ASoC: CODEC %s not registered\n",
970 return -EPROBE_DEFER
;
973 codec_dais
[i
] = soc_find_codec_dai(codec
, codecs
[i
].dai_name
);
974 if (!codec_dais
[i
]) {
975 dev_err(card
->dev
, "ASoC: CODEC DAI %s not registered\n",
977 return -EPROBE_DEFER
;
981 /* Single codec links expect codec and codec_dai in runtime data */
982 rtd
->codec_dai
= codec_dais
[0];
983 rtd
->codec
= rtd
->codec_dai
->codec
;
985 /* if there's no platform we match on the empty platform */
986 platform_name
= dai_link
->platform_name
;
987 if (!platform_name
&& !dai_link
->platform_of_node
)
988 platform_name
= "snd-soc-dummy";
990 /* find one from the set of registered platforms */
991 list_for_each_entry(platform
, &platform_list
, list
) {
992 if (dai_link
->platform_of_node
) {
993 if (platform
->dev
->of_node
!=
994 dai_link
->platform_of_node
)
997 if (strcmp(platform
->component
.name
, platform_name
))
1001 rtd
->platform
= platform
;
1003 if (!rtd
->platform
) {
1004 dev_err(card
->dev
, "ASoC: platform %s not registered\n",
1005 dai_link
->platform_name
);
1006 return -EPROBE_DEFER
;
1014 static int soc_remove_platform(struct snd_soc_platform
*platform
)
1018 if (platform
->driver
->remove
) {
1019 ret
= platform
->driver
->remove(platform
);
1021 dev_err(platform
->dev
, "ASoC: failed to remove %d\n",
1025 /* Make sure all DAPM widgets are freed */
1026 snd_soc_dapm_free(&platform
->component
.dapm
);
1028 soc_cleanup_platform_debugfs(platform
);
1029 platform
->probed
= 0;
1030 list_del(&platform
->card_list
);
1031 module_put(platform
->dev
->driver
->owner
);
1036 static void soc_remove_codec(struct snd_soc_codec
*codec
)
1040 if (codec
->driver
->remove
) {
1041 err
= codec
->driver
->remove(codec
);
1043 dev_err(codec
->dev
, "ASoC: failed to remove %d\n", err
);
1046 /* Make sure all DAPM widgets are freed */
1047 snd_soc_dapm_free(&codec
->dapm
);
1049 soc_cleanup_codec_debugfs(codec
);
1051 list_del(&codec
->card_list
);
1052 module_put(codec
->dev
->driver
->owner
);
1055 static void soc_remove_codec_dai(struct snd_soc_dai
*codec_dai
, int order
)
1059 if (codec_dai
&& codec_dai
->probed
&&
1060 codec_dai
->driver
->remove_order
== order
) {
1061 if (codec_dai
->driver
->remove
) {
1062 err
= codec_dai
->driver
->remove(codec_dai
);
1064 dev_err(codec_dai
->dev
,
1065 "ASoC: failed to remove %s: %d\n",
1066 codec_dai
->name
, err
);
1068 codec_dai
->probed
= 0;
1072 static void soc_remove_link_dais(struct snd_soc_card
*card
, int num
, int order
)
1074 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[num
];
1075 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1078 /* unregister the rtd device */
1079 if (rtd
->dev_registered
) {
1080 device_remove_file(rtd
->dev
, &dev_attr_pmdown_time
);
1081 device_remove_file(rtd
->dev
, &dev_attr_codec_reg
);
1082 device_unregister(rtd
->dev
);
1083 rtd
->dev_registered
= 0;
1086 /* remove the CODEC DAI */
1087 for (i
= 0; i
< rtd
->num_codecs
; i
++)
1088 soc_remove_codec_dai(rtd
->codec_dais
[i
], order
);
1090 /* remove the cpu_dai */
1091 if (cpu_dai
&& cpu_dai
->probed
&&
1092 cpu_dai
->driver
->remove_order
== order
) {
1093 if (cpu_dai
->driver
->remove
) {
1094 err
= cpu_dai
->driver
->remove(cpu_dai
);
1096 dev_err(cpu_dai
->dev
,
1097 "ASoC: failed to remove %s: %d\n",
1098 cpu_dai
->name
, err
);
1100 cpu_dai
->probed
= 0;
1101 if (!cpu_dai
->codec
)
1102 module_put(cpu_dai
->dev
->driver
->owner
);
1106 static void soc_remove_link_components(struct snd_soc_card
*card
, int num
,
1109 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[num
];
1110 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1111 struct snd_soc_platform
*platform
= rtd
->platform
;
1112 struct snd_soc_codec
*codec
;
1115 /* remove the platform */
1116 if (platform
&& platform
->probed
&&
1117 platform
->driver
->remove_order
== order
) {
1118 soc_remove_platform(platform
);
1121 /* remove the CODEC-side CODEC */
1122 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
1123 codec
= rtd
->codec_dais
[i
]->codec
;
1124 if (codec
&& codec
->probed
&&
1125 codec
->driver
->remove_order
== order
)
1126 soc_remove_codec(codec
);
1129 /* remove any CPU-side CODEC */
1131 codec
= cpu_dai
->codec
;
1132 if (codec
&& codec
->probed
&&
1133 codec
->driver
->remove_order
== order
)
1134 soc_remove_codec(codec
);
1138 static void soc_remove_dai_links(struct snd_soc_card
*card
)
1142 for (order
= SND_SOC_COMP_ORDER_FIRST
; order
<= SND_SOC_COMP_ORDER_LAST
;
1144 for (dai
= 0; dai
< card
->num_rtd
; dai
++)
1145 soc_remove_link_dais(card
, dai
, order
);
1148 for (order
= SND_SOC_COMP_ORDER_FIRST
; order
<= SND_SOC_COMP_ORDER_LAST
;
1150 for (dai
= 0; dai
< card
->num_rtd
; dai
++)
1151 soc_remove_link_components(card
, dai
, order
);
1157 static void soc_set_name_prefix(struct snd_soc_card
*card
,
1158 struct snd_soc_component
*component
)
1162 if (card
->codec_conf
== NULL
)
1165 for (i
= 0; i
< card
->num_configs
; i
++) {
1166 struct snd_soc_codec_conf
*map
= &card
->codec_conf
[i
];
1167 if (map
->of_node
&& component
->dev
->of_node
!= map
->of_node
)
1169 if (map
->dev_name
&& strcmp(component
->name
, map
->dev_name
))
1171 component
->name_prefix
= map
->name_prefix
;
1176 static int soc_probe_codec(struct snd_soc_card
*card
,
1177 struct snd_soc_codec
*codec
)
1180 const struct snd_soc_codec_driver
*driver
= codec
->driver
;
1181 struct snd_soc_dai
*dai
;
1184 codec
->dapm
.card
= card
;
1185 soc_set_name_prefix(card
, &codec
->component
);
1187 if (!try_module_get(codec
->dev
->driver
->owner
))
1190 soc_init_codec_debugfs(codec
);
1192 if (driver
->dapm_widgets
) {
1193 ret
= snd_soc_dapm_new_controls(&codec
->dapm
,
1194 driver
->dapm_widgets
,
1195 driver
->num_dapm_widgets
);
1199 "Failed to create new controls %d\n", ret
);
1204 /* Create DAPM widgets for each DAI stream */
1205 list_for_each_entry(dai
, &codec
->component
.dai_list
, list
) {
1206 ret
= snd_soc_dapm_new_dai_widgets(&codec
->dapm
, dai
);
1210 "Failed to create DAI widgets %d\n", ret
);
1215 codec
->dapm
.idle_bias_off
= driver
->idle_bias_off
;
1217 if (driver
->probe
) {
1218 ret
= driver
->probe(codec
);
1221 "ASoC: failed to probe CODEC %d\n", ret
);
1224 WARN(codec
->dapm
.idle_bias_off
&&
1225 codec
->dapm
.bias_level
!= SND_SOC_BIAS_OFF
,
1226 "codec %s can not start from non-off bias with idle_bias_off==1\n",
1227 codec
->component
.name
);
1230 if (driver
->controls
)
1231 snd_soc_add_codec_controls(codec
, driver
->controls
,
1232 driver
->num_controls
);
1233 if (driver
->dapm_routes
)
1234 snd_soc_dapm_add_routes(&codec
->dapm
, driver
->dapm_routes
,
1235 driver
->num_dapm_routes
);
1237 /* mark codec as probed and add to card codec list */
1239 list_add(&codec
->card_list
, &card
->codec_dev_list
);
1240 list_add(&codec
->dapm
.list
, &card
->dapm_list
);
1245 soc_cleanup_codec_debugfs(codec
);
1246 module_put(codec
->dev
->driver
->owner
);
1251 static int soc_probe_platform(struct snd_soc_card
*card
,
1252 struct snd_soc_platform
*platform
)
1255 const struct snd_soc_platform_driver
*driver
= platform
->driver
;
1256 struct snd_soc_component
*component
;
1257 struct snd_soc_dai
*dai
;
1259 platform
->card
= card
;
1260 platform
->component
.dapm
.card
= card
;
1262 if (!try_module_get(platform
->dev
->driver
->owner
))
1265 soc_init_platform_debugfs(platform
);
1267 if (driver
->dapm_widgets
)
1268 snd_soc_dapm_new_controls(&platform
->component
.dapm
,
1269 driver
->dapm_widgets
, driver
->num_dapm_widgets
);
1271 /* Create DAPM widgets for each DAI stream */
1272 list_for_each_entry(component
, &component_list
, list
) {
1273 if (component
->dev
!= platform
->dev
)
1275 list_for_each_entry(dai
, &component
->dai_list
, list
)
1276 snd_soc_dapm_new_dai_widgets(&platform
->component
.dapm
,
1280 platform
->component
.dapm
.idle_bias_off
= 1;
1282 if (driver
->probe
) {
1283 ret
= driver
->probe(platform
);
1285 dev_err(platform
->dev
,
1286 "ASoC: failed to probe platform %d\n", ret
);
1291 if (driver
->controls
)
1292 snd_soc_add_platform_controls(platform
, driver
->controls
,
1293 driver
->num_controls
);
1294 if (driver
->dapm_routes
)
1295 snd_soc_dapm_add_routes(&platform
->component
.dapm
,
1296 driver
->dapm_routes
, driver
->num_dapm_routes
);
1298 /* mark platform as probed and add to card platform list */
1299 platform
->probed
= 1;
1300 list_add(&platform
->card_list
, &card
->platform_dev_list
);
1301 list_add(&platform
->component
.dapm
.list
, &card
->dapm_list
);
1306 soc_cleanup_platform_debugfs(platform
);
1307 module_put(platform
->dev
->driver
->owner
);
1312 static void rtd_release(struct device
*dev
)
1317 static int soc_post_component_init(struct snd_soc_pcm_runtime
*rtd
,
1322 /* register the rtd device */
1323 rtd
->dev
= kzalloc(sizeof(struct device
), GFP_KERNEL
);
1326 device_initialize(rtd
->dev
);
1327 rtd
->dev
->parent
= rtd
->card
->dev
;
1328 rtd
->dev
->release
= rtd_release
;
1329 rtd
->dev
->init_name
= name
;
1330 dev_set_drvdata(rtd
->dev
, rtd
);
1331 mutex_init(&rtd
->pcm_mutex
);
1332 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_PLAYBACK
].be_clients
);
1333 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_CAPTURE
].be_clients
);
1334 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_PLAYBACK
].fe_clients
);
1335 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_CAPTURE
].fe_clients
);
1336 ret
= device_add(rtd
->dev
);
1338 /* calling put_device() here to free the rtd->dev */
1339 put_device(rtd
->dev
);
1340 dev_err(rtd
->card
->dev
,
1341 "ASoC: failed to register runtime device: %d\n", ret
);
1344 rtd
->dev_registered
= 1;
1346 /* add DAPM sysfs entries for this codec */
1347 ret
= snd_soc_dapm_sys_add(rtd
->dev
);
1350 "ASoC: failed to add codec dapm sysfs entries: %d\n", ret
);
1352 /* add codec sysfs entries */
1353 ret
= device_create_file(rtd
->dev
, &dev_attr_codec_reg
);
1356 "ASoC: failed to add codec sysfs files: %d\n", ret
);
1361 static int soc_probe_link_components(struct snd_soc_card
*card
, int num
,
1364 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[num
];
1365 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1366 struct snd_soc_platform
*platform
= rtd
->platform
;
1369 /* probe the CPU-side component, if it is a CODEC */
1370 if (cpu_dai
->codec
&&
1371 !cpu_dai
->codec
->probed
&&
1372 cpu_dai
->codec
->driver
->probe_order
== order
) {
1373 ret
= soc_probe_codec(card
, cpu_dai
->codec
);
1378 /* probe the CODEC-side components */
1379 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
1380 if (!rtd
->codec_dais
[i
]->codec
->probed
&&
1381 rtd
->codec_dais
[i
]->codec
->driver
->probe_order
== order
) {
1382 ret
= soc_probe_codec(card
, rtd
->codec_dais
[i
]->codec
);
1388 /* probe the platform */
1389 if (!platform
->probed
&&
1390 platform
->driver
->probe_order
== order
) {
1391 ret
= soc_probe_platform(card
, platform
);
1399 static int soc_probe_codec_dai(struct snd_soc_card
*card
,
1400 struct snd_soc_dai
*codec_dai
,
1405 if (!codec_dai
->probed
&& codec_dai
->driver
->probe_order
== order
) {
1406 if (codec_dai
->driver
->probe
) {
1407 ret
= codec_dai
->driver
->probe(codec_dai
);
1409 dev_err(codec_dai
->dev
,
1410 "ASoC: failed to probe CODEC DAI %s: %d\n",
1411 codec_dai
->name
, ret
);
1416 /* mark codec_dai as probed and add to card dai list */
1417 codec_dai
->probed
= 1;
1423 static int soc_link_dai_widgets(struct snd_soc_card
*card
,
1424 struct snd_soc_dai_link
*dai_link
,
1425 struct snd_soc_pcm_runtime
*rtd
)
1427 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1428 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
1429 struct snd_soc_dapm_widget
*play_w
, *capture_w
;
1432 if (rtd
->num_codecs
> 1)
1433 dev_warn(card
->dev
, "ASoC: Multiple codecs not supported yet\n");
1435 /* link the DAI widgets */
1436 play_w
= codec_dai
->playback_widget
;
1437 capture_w
= cpu_dai
->capture_widget
;
1438 if (play_w
&& capture_w
) {
1439 ret
= snd_soc_dapm_new_pcm(card
, dai_link
->params
,
1442 dev_err(card
->dev
, "ASoC: Can't link %s to %s: %d\n",
1443 play_w
->name
, capture_w
->name
, ret
);
1448 play_w
= cpu_dai
->playback_widget
;
1449 capture_w
= codec_dai
->capture_widget
;
1450 if (play_w
&& capture_w
) {
1451 ret
= snd_soc_dapm_new_pcm(card
, dai_link
->params
,
1454 dev_err(card
->dev
, "ASoC: Can't link %s to %s: %d\n",
1455 play_w
->name
, capture_w
->name
, ret
);
1463 static int soc_probe_link_dais(struct snd_soc_card
*card
, int num
, int order
)
1465 struct snd_soc_dai_link
*dai_link
= &card
->dai_link
[num
];
1466 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[num
];
1467 struct snd_soc_platform
*platform
= rtd
->platform
;
1468 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1471 dev_dbg(card
->dev
, "ASoC: probe %s dai link %d late %d\n",
1472 card
->name
, num
, order
);
1474 /* config components */
1475 cpu_dai
->platform
= platform
;
1476 cpu_dai
->card
= card
;
1477 for (i
= 0; i
< rtd
->num_codecs
; i
++)
1478 rtd
->codec_dais
[i
]->card
= card
;
1480 /* set default power off timeout */
1481 rtd
->pmdown_time
= pmdown_time
;
1483 /* probe the cpu_dai */
1484 if (!cpu_dai
->probed
&&
1485 cpu_dai
->driver
->probe_order
== order
) {
1486 if (!cpu_dai
->codec
) {
1487 if (!try_module_get(cpu_dai
->dev
->driver
->owner
))
1491 if (cpu_dai
->driver
->probe
) {
1492 ret
= cpu_dai
->driver
->probe(cpu_dai
);
1494 dev_err(cpu_dai
->dev
,
1495 "ASoC: failed to probe CPU DAI %s: %d\n",
1496 cpu_dai
->name
, ret
);
1497 module_put(cpu_dai
->dev
->driver
->owner
);
1501 cpu_dai
->probed
= 1;
1504 /* probe the CODEC DAI */
1505 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
1506 ret
= soc_probe_codec_dai(card
, rtd
->codec_dais
[i
], order
);
1511 /* complete DAI probe during last probe */
1512 if (order
!= SND_SOC_COMP_ORDER_LAST
)
1515 /* do machine specific initialization */
1516 if (dai_link
->init
) {
1517 ret
= dai_link
->init(rtd
);
1519 dev_err(card
->dev
, "ASoC: failed to init %s: %d\n",
1520 dai_link
->name
, ret
);
1525 ret
= soc_post_component_init(rtd
, dai_link
->name
);
1529 #ifdef CONFIG_DEBUG_FS
1530 /* add DPCM sysfs entries */
1531 if (dai_link
->dynamic
) {
1532 ret
= soc_dpcm_debugfs_add(rtd
);
1535 "ASoC: failed to add dpcm sysfs entries: %d\n",
1542 ret
= device_create_file(rtd
->dev
, &dev_attr_pmdown_time
);
1544 dev_warn(rtd
->dev
, "ASoC: failed to add pmdown_time sysfs: %d\n",
1547 if (cpu_dai
->driver
->compress_dai
) {
1548 /*create compress_device"*/
1549 ret
= soc_new_compress(rtd
, num
);
1551 dev_err(card
->dev
, "ASoC: can't create compress %s\n",
1552 dai_link
->stream_name
);
1557 if (!dai_link
->params
) {
1558 /* create the pcm */
1559 ret
= soc_new_pcm(rtd
, num
);
1561 dev_err(card
->dev
, "ASoC: can't create pcm %s :%d\n",
1562 dai_link
->stream_name
, ret
);
1566 INIT_DELAYED_WORK(&rtd
->delayed_work
,
1567 codec2codec_close_delayed_work
);
1569 /* link the DAI widgets */
1570 ret
= soc_link_dai_widgets(card
, dai_link
, rtd
);
1576 /* add platform data for AC97 devices */
1577 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
1578 if (rtd
->codec_dais
[i
]->driver
->ac97_control
)
1579 snd_ac97_dev_add_pdata(rtd
->codec_dais
[i
]->codec
->ac97
,
1580 rtd
->cpu_dai
->ac97_pdata
);
1586 #ifdef CONFIG_SND_SOC_AC97_BUS
1587 static int soc_register_ac97_codec(struct snd_soc_codec
*codec
,
1588 struct snd_soc_dai
*codec_dai
)
1592 /* Only instantiate AC97 if not already done by the adaptor
1593 * for the generic AC97 subsystem.
1595 if (codec_dai
->driver
->ac97_control
&& !codec
->ac97_registered
) {
1597 * It is possible that the AC97 device is already registered to
1598 * the device subsystem. This happens when the device is created
1599 * via snd_ac97_mixer(). Currently only SoC codec that does so
1600 * is the generic AC97 glue but others migh emerge.
1602 * In those cases we don't try to register the device again.
1604 if (!codec
->ac97_created
)
1607 ret
= soc_ac97_dev_register(codec
);
1610 "ASoC: AC97 device register failed: %d\n", ret
);
1614 codec
->ac97_registered
= 1;
1619 static void soc_unregister_ac97_codec(struct snd_soc_codec
*codec
)
1621 if (codec
->ac97_registered
) {
1622 soc_ac97_dev_unregister(codec
);
1623 codec
->ac97_registered
= 0;
1627 static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime
*rtd
)
1631 for (i
= 0; i
< rtd
->num_codecs
; i
++) {
1632 struct snd_soc_dai
*codec_dai
= rtd
->codec_dais
[i
];
1634 ret
= soc_register_ac97_codec(codec_dai
->codec
, codec_dai
);
1637 soc_unregister_ac97_codec(codec_dai
->codec
);
1645 static void soc_unregister_ac97_dai_link(struct snd_soc_pcm_runtime
*rtd
)
1649 for (i
= 0; i
< rtd
->num_codecs
; i
++)
1650 soc_unregister_ac97_codec(rtd
->codec_dais
[i
]->codec
);
1654 static int soc_bind_aux_dev(struct snd_soc_card
*card
, int num
)
1656 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd_aux
[num
];
1657 struct snd_soc_aux_dev
*aux_dev
= &card
->aux_dev
[num
];
1658 const char *codecname
= aux_dev
->codec_name
;
1660 rtd
->codec
= soc_find_codec(aux_dev
->codec_of_node
, codecname
);
1662 if (aux_dev
->codec_of_node
)
1663 codecname
= of_node_full_name(aux_dev
->codec_of_node
);
1665 dev_err(card
->dev
, "ASoC: %s not registered\n", codecname
);
1666 return -EPROBE_DEFER
;
1672 static int soc_probe_aux_dev(struct snd_soc_card
*card
, int num
)
1674 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd_aux
[num
];
1675 struct snd_soc_aux_dev
*aux_dev
= &card
->aux_dev
[num
];
1678 if (rtd
->codec
->probed
) {
1679 dev_err(rtd
->codec
->dev
, "ASoC: codec already probed\n");
1683 ret
= soc_probe_codec(card
, rtd
->codec
);
1687 /* do machine specific initialization */
1688 if (aux_dev
->init
) {
1689 ret
= aux_dev
->init(&rtd
->codec
->dapm
);
1691 dev_err(card
->dev
, "ASoC: failed to init %s: %d\n",
1692 aux_dev
->name
, ret
);
1697 return soc_post_component_init(rtd
, aux_dev
->name
);
1700 static void soc_remove_aux_dev(struct snd_soc_card
*card
, int num
)
1702 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd_aux
[num
];
1703 struct snd_soc_codec
*codec
= rtd
->codec
;
1705 /* unregister the rtd device */
1706 if (rtd
->dev_registered
) {
1707 device_remove_file(rtd
->dev
, &dev_attr_codec_reg
);
1708 device_unregister(rtd
->dev
);
1709 rtd
->dev_registered
= 0;
1712 if (codec
&& codec
->probed
)
1713 soc_remove_codec(codec
);
1716 static int snd_soc_init_codec_cache(struct snd_soc_codec
*codec
)
1720 if (codec
->cache_init
)
1723 ret
= snd_soc_cache_init(codec
);
1726 "ASoC: Failed to set cache compression type: %d\n",
1730 codec
->cache_init
= 1;
1734 static int snd_soc_instantiate_card(struct snd_soc_card
*card
)
1736 struct snd_soc_codec
*codec
;
1737 struct snd_soc_dai_link
*dai_link
;
1738 int ret
, i
, order
, dai_fmt
;
1740 mutex_lock_nested(&card
->mutex
, SND_SOC_CARD_CLASS_INIT
);
1743 for (i
= 0; i
< card
->num_links
; i
++) {
1744 ret
= soc_bind_dai_link(card
, i
);
1749 /* bind aux_devs too */
1750 for (i
= 0; i
< card
->num_aux_devs
; i
++) {
1751 ret
= soc_bind_aux_dev(card
, i
);
1756 /* initialize the register cache for each available codec */
1757 list_for_each_entry(codec
, &codec_list
, list
) {
1758 if (codec
->cache_init
)
1760 ret
= snd_soc_init_codec_cache(codec
);
1765 /* card bind complete so register a sound card */
1766 ret
= snd_card_new(card
->dev
, SNDRV_DEFAULT_IDX1
, SNDRV_DEFAULT_STR1
,
1767 card
->owner
, 0, &card
->snd_card
);
1770 "ASoC: can't create sound card for card %s: %d\n",
1775 card
->dapm
.bias_level
= SND_SOC_BIAS_OFF
;
1776 card
->dapm
.dev
= card
->dev
;
1777 card
->dapm
.card
= card
;
1778 list_add(&card
->dapm
.list
, &card
->dapm_list
);
1780 #ifdef CONFIG_DEBUG_FS
1781 snd_soc_dapm_debugfs_init(&card
->dapm
, card
->debugfs_card_root
);
1784 #ifdef CONFIG_PM_SLEEP
1785 /* deferred resume work */
1786 INIT_WORK(&card
->deferred_resume_work
, soc_resume_deferred
);
1789 if (card
->dapm_widgets
)
1790 snd_soc_dapm_new_controls(&card
->dapm
, card
->dapm_widgets
,
1791 card
->num_dapm_widgets
);
1793 /* initialise the sound card only once */
1795 ret
= card
->probe(card
);
1797 goto card_probe_error
;
1800 /* probe all components used by DAI links on this card */
1801 for (order
= SND_SOC_COMP_ORDER_FIRST
; order
<= SND_SOC_COMP_ORDER_LAST
;
1803 for (i
= 0; i
< card
->num_links
; i
++) {
1804 ret
= soc_probe_link_components(card
, i
, order
);
1807 "ASoC: failed to instantiate card %d\n",
1814 /* probe all DAI links on this card */
1815 for (order
= SND_SOC_COMP_ORDER_FIRST
; order
<= SND_SOC_COMP_ORDER_LAST
;
1817 for (i
= 0; i
< card
->num_links
; i
++) {
1818 ret
= soc_probe_link_dais(card
, i
, order
);
1821 "ASoC: failed to instantiate card %d\n",
1828 for (i
= 0; i
< card
->num_aux_devs
; i
++) {
1829 ret
= soc_probe_aux_dev(card
, i
);
1832 "ASoC: failed to add auxiliary devices %d\n",
1834 goto probe_aux_dev_err
;
1838 snd_soc_dapm_link_dai_widgets(card
);
1839 snd_soc_dapm_connect_dai_link_widgets(card
);
1842 snd_soc_add_card_controls(card
, card
->controls
, card
->num_controls
);
1844 if (card
->dapm_routes
)
1845 snd_soc_dapm_add_routes(&card
->dapm
, card
->dapm_routes
,
1846 card
->num_dapm_routes
);
1848 for (i
= 0; i
< card
->num_links
; i
++) {
1849 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[i
];
1850 dai_link
= &card
->dai_link
[i
];
1851 dai_fmt
= dai_link
->dai_fmt
;
1854 struct snd_soc_dai
**codec_dais
= rtd
->codec_dais
;
1857 for (j
= 0; j
< rtd
->num_codecs
; j
++) {
1858 struct snd_soc_dai
*codec_dai
= codec_dais
[j
];
1860 ret
= snd_soc_dai_set_fmt(codec_dai
, dai_fmt
);
1861 if (ret
!= 0 && ret
!= -ENOTSUPP
)
1862 dev_warn(codec_dai
->dev
,
1863 "ASoC: Failed to set DAI format: %d\n",
1868 /* If this is a regular CPU link there will be a platform */
1870 (dai_link
->platform_name
|| dai_link
->platform_of_node
)) {
1871 ret
= snd_soc_dai_set_fmt(card
->rtd
[i
].cpu_dai
,
1873 if (ret
!= 0 && ret
!= -ENOTSUPP
)
1874 dev_warn(card
->rtd
[i
].cpu_dai
->dev
,
1875 "ASoC: Failed to set DAI format: %d\n",
1877 } else if (dai_fmt
) {
1878 /* Flip the polarity for the "CPU" end */
1879 dai_fmt
&= ~SND_SOC_DAIFMT_MASTER_MASK
;
1880 switch (dai_link
->dai_fmt
&
1881 SND_SOC_DAIFMT_MASTER_MASK
) {
1882 case SND_SOC_DAIFMT_CBM_CFM
:
1883 dai_fmt
|= SND_SOC_DAIFMT_CBS_CFS
;
1885 case SND_SOC_DAIFMT_CBM_CFS
:
1886 dai_fmt
|= SND_SOC_DAIFMT_CBS_CFM
;
1888 case SND_SOC_DAIFMT_CBS_CFM
:
1889 dai_fmt
|= SND_SOC_DAIFMT_CBM_CFS
;
1891 case SND_SOC_DAIFMT_CBS_CFS
:
1892 dai_fmt
|= SND_SOC_DAIFMT_CBM_CFM
;
1896 ret
= snd_soc_dai_set_fmt(card
->rtd
[i
].cpu_dai
,
1898 if (ret
!= 0 && ret
!= -ENOTSUPP
)
1899 dev_warn(card
->rtd
[i
].cpu_dai
->dev
,
1900 "ASoC: Failed to set DAI format: %d\n",
1905 snprintf(card
->snd_card
->shortname
, sizeof(card
->snd_card
->shortname
),
1907 snprintf(card
->snd_card
->longname
, sizeof(card
->snd_card
->longname
),
1908 "%s", card
->long_name
? card
->long_name
: card
->name
);
1909 snprintf(card
->snd_card
->driver
, sizeof(card
->snd_card
->driver
),
1910 "%s", card
->driver_name
? card
->driver_name
: card
->name
);
1911 for (i
= 0; i
< ARRAY_SIZE(card
->snd_card
->driver
); i
++) {
1912 switch (card
->snd_card
->driver
[i
]) {
1918 if (!isalnum(card
->snd_card
->driver
[i
]))
1919 card
->snd_card
->driver
[i
] = '_';
1924 if (card
->late_probe
) {
1925 ret
= card
->late_probe(card
);
1927 dev_err(card
->dev
, "ASoC: %s late_probe() failed: %d\n",
1929 goto probe_aux_dev_err
;
1933 if (card
->fully_routed
)
1934 snd_soc_dapm_auto_nc_pins(card
);
1936 snd_soc_dapm_new_widgets(card
);
1938 ret
= snd_card_register(card
->snd_card
);
1940 dev_err(card
->dev
, "ASoC: failed to register soundcard %d\n",
1942 goto probe_aux_dev_err
;
1945 #ifdef CONFIG_SND_SOC_AC97_BUS
1946 /* register any AC97 codecs */
1947 for (i
= 0; i
< card
->num_rtd
; i
++) {
1948 ret
= soc_register_ac97_dai_link(&card
->rtd
[i
]);
1951 "ASoC: failed to register AC97: %d\n", ret
);
1953 soc_unregister_ac97_dai_link(&card
->rtd
[i
]);
1954 goto probe_aux_dev_err
;
1959 card
->instantiated
= 1;
1960 snd_soc_dapm_sync(&card
->dapm
);
1961 mutex_unlock(&card
->mutex
);
1966 for (i
= 0; i
< card
->num_aux_devs
; i
++)
1967 soc_remove_aux_dev(card
, i
);
1970 soc_remove_dai_links(card
);
1976 snd_card_free(card
->snd_card
);
1979 mutex_unlock(&card
->mutex
);
1984 /* probes a new socdev */
1985 static int soc_probe(struct platform_device
*pdev
)
1987 struct snd_soc_card
*card
= platform_get_drvdata(pdev
);
1990 * no card, so machine driver should be registering card
1991 * we should not be here in that case so ret error
1996 dev_warn(&pdev
->dev
,
1997 "ASoC: machine %s should use snd_soc_register_card()\n",
2000 /* Bodge while we unpick instantiation */
2001 card
->dev
= &pdev
->dev
;
2003 return snd_soc_register_card(card
);
2006 static int soc_cleanup_card_resources(struct snd_soc_card
*card
)
2010 /* make sure any delayed work runs */
2011 for (i
= 0; i
< card
->num_rtd
; i
++) {
2012 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[i
];
2013 flush_delayed_work(&rtd
->delayed_work
);
2016 /* remove auxiliary devices */
2017 for (i
= 0; i
< card
->num_aux_devs
; i
++)
2018 soc_remove_aux_dev(card
, i
);
2020 /* remove and free each DAI */
2021 soc_remove_dai_links(card
);
2023 soc_cleanup_card_debugfs(card
);
2025 /* remove the card */
2029 snd_soc_dapm_free(&card
->dapm
);
2031 snd_card_free(card
->snd_card
);
2036 /* removes a socdev */
2037 static int soc_remove(struct platform_device
*pdev
)
2039 struct snd_soc_card
*card
= platform_get_drvdata(pdev
);
2041 snd_soc_unregister_card(card
);
2045 int snd_soc_poweroff(struct device
*dev
)
2047 struct snd_soc_card
*card
= dev_get_drvdata(dev
);
2050 if (!card
->instantiated
)
2053 /* Flush out pmdown_time work - we actually do want to run it
2054 * now, we're shutting down so no imminent restart. */
2055 for (i
= 0; i
< card
->num_rtd
; i
++) {
2056 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[i
];
2057 flush_delayed_work(&rtd
->delayed_work
);
2060 snd_soc_dapm_shutdown(card
);
2062 /* deactivate pins to sleep state */
2063 for (i
= 0; i
< card
->num_rtd
; i
++) {
2064 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[i
];
2065 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
2068 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
2069 for (j
= 0; j
< rtd
->num_codecs
; j
++) {
2070 struct snd_soc_dai
*codec_dai
= rtd
->codec_dais
[j
];
2071 pinctrl_pm_select_sleep_state(codec_dai
->dev
);
2077 EXPORT_SYMBOL_GPL(snd_soc_poweroff
);
2079 const struct dev_pm_ops snd_soc_pm_ops
= {
2080 .suspend
= snd_soc_suspend
,
2081 .resume
= snd_soc_resume
,
2082 .freeze
= snd_soc_suspend
,
2083 .thaw
= snd_soc_resume
,
2084 .poweroff
= snd_soc_poweroff
,
2085 .restore
= snd_soc_resume
,
2087 EXPORT_SYMBOL_GPL(snd_soc_pm_ops
);
2089 /* ASoC platform driver */
2090 static struct platform_driver soc_driver
= {
2092 .name
= "soc-audio",
2093 .owner
= THIS_MODULE
,
2094 .pm
= &snd_soc_pm_ops
,
2097 .remove
= soc_remove
,
2101 * snd_soc_new_ac97_codec - initailise AC97 device
2102 * @codec: audio codec
2103 * @ops: AC97 bus operations
2104 * @num: AC97 codec number
2106 * Initialises AC97 codec resources for use by ad-hoc devices only.
2108 int snd_soc_new_ac97_codec(struct snd_soc_codec
*codec
,
2109 struct snd_ac97_bus_ops
*ops
, int num
)
2111 mutex_lock(&codec
->mutex
);
2113 codec
->ac97
= kzalloc(sizeof(struct snd_ac97
), GFP_KERNEL
);
2114 if (codec
->ac97
== NULL
) {
2115 mutex_unlock(&codec
->mutex
);
2119 codec
->ac97
->bus
= kzalloc(sizeof(struct snd_ac97_bus
), GFP_KERNEL
);
2120 if (codec
->ac97
->bus
== NULL
) {
2123 mutex_unlock(&codec
->mutex
);
2127 codec
->ac97
->bus
->ops
= ops
;
2128 codec
->ac97
->num
= num
;
2131 * Mark the AC97 device to be created by us. This way we ensure that the
2132 * device will be registered with the device subsystem later on.
2134 codec
->ac97_created
= 1;
2136 mutex_unlock(&codec
->mutex
);
2139 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec
);
2141 static struct snd_ac97_reset_cfg snd_ac97_rst_cfg
;
2143 static void snd_soc_ac97_warm_reset(struct snd_ac97
*ac97
)
2145 struct pinctrl
*pctl
= snd_ac97_rst_cfg
.pctl
;
2147 pinctrl_select_state(pctl
, snd_ac97_rst_cfg
.pstate_warm_reset
);
2149 gpio_direction_output(snd_ac97_rst_cfg
.gpio_sync
, 1);
2153 gpio_direction_output(snd_ac97_rst_cfg
.gpio_sync
, 0);
2155 pinctrl_select_state(pctl
, snd_ac97_rst_cfg
.pstate_run
);
2159 static void snd_soc_ac97_reset(struct snd_ac97
*ac97
)
2161 struct pinctrl
*pctl
= snd_ac97_rst_cfg
.pctl
;
2163 pinctrl_select_state(pctl
, snd_ac97_rst_cfg
.pstate_reset
);
2165 gpio_direction_output(snd_ac97_rst_cfg
.gpio_sync
, 0);
2166 gpio_direction_output(snd_ac97_rst_cfg
.gpio_sdata
, 0);
2167 gpio_direction_output(snd_ac97_rst_cfg
.gpio_reset
, 0);
2171 gpio_direction_output(snd_ac97_rst_cfg
.gpio_reset
, 1);
2173 pinctrl_select_state(pctl
, snd_ac97_rst_cfg
.pstate_run
);
2177 static int snd_soc_ac97_parse_pinctl(struct device
*dev
,
2178 struct snd_ac97_reset_cfg
*cfg
)
2181 struct pinctrl_state
*state
;
2185 p
= devm_pinctrl_get(dev
);
2187 dev_err(dev
, "Failed to get pinctrl\n");
2192 state
= pinctrl_lookup_state(p
, "ac97-reset");
2193 if (IS_ERR(state
)) {
2194 dev_err(dev
, "Can't find pinctrl state ac97-reset\n");
2195 return PTR_ERR(state
);
2197 cfg
->pstate_reset
= state
;
2199 state
= pinctrl_lookup_state(p
, "ac97-warm-reset");
2200 if (IS_ERR(state
)) {
2201 dev_err(dev
, "Can't find pinctrl state ac97-warm-reset\n");
2202 return PTR_ERR(state
);
2204 cfg
->pstate_warm_reset
= state
;
2206 state
= pinctrl_lookup_state(p
, "ac97-running");
2207 if (IS_ERR(state
)) {
2208 dev_err(dev
, "Can't find pinctrl state ac97-running\n");
2209 return PTR_ERR(state
);
2211 cfg
->pstate_run
= state
;
2213 gpio
= of_get_named_gpio(dev
->of_node
, "ac97-gpios", 0);
2215 dev_err(dev
, "Can't find ac97-sync gpio\n");
2218 ret
= devm_gpio_request(dev
, gpio
, "AC97 link sync");
2220 dev_err(dev
, "Failed requesting ac97-sync gpio\n");
2223 cfg
->gpio_sync
= gpio
;
2225 gpio
= of_get_named_gpio(dev
->of_node
, "ac97-gpios", 1);
2227 dev_err(dev
, "Can't find ac97-sdata gpio %d\n", gpio
);
2230 ret
= devm_gpio_request(dev
, gpio
, "AC97 link sdata");
2232 dev_err(dev
, "Failed requesting ac97-sdata gpio\n");
2235 cfg
->gpio_sdata
= gpio
;
2237 gpio
= of_get_named_gpio(dev
->of_node
, "ac97-gpios", 2);
2239 dev_err(dev
, "Can't find ac97-reset gpio\n");
2242 ret
= devm_gpio_request(dev
, gpio
, "AC97 link reset");
2244 dev_err(dev
, "Failed requesting ac97-reset gpio\n");
2247 cfg
->gpio_reset
= gpio
;
2252 struct snd_ac97_bus_ops
*soc_ac97_ops
;
2253 EXPORT_SYMBOL_GPL(soc_ac97_ops
);
2255 int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops
*ops
)
2257 if (ops
== soc_ac97_ops
)
2260 if (soc_ac97_ops
&& ops
)
2267 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops
);
2270 * snd_soc_set_ac97_ops_of_reset - Set ac97 ops with generic ac97 reset functions
2272 * This function sets the reset and warm_reset properties of ops and parses
2273 * the device node of pdev to get pinctrl states and gpio numbers to use.
2275 int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops
*ops
,
2276 struct platform_device
*pdev
)
2278 struct device
*dev
= &pdev
->dev
;
2279 struct snd_ac97_reset_cfg cfg
;
2282 ret
= snd_soc_ac97_parse_pinctl(dev
, &cfg
);
2286 ret
= snd_soc_set_ac97_ops(ops
);
2290 ops
->warm_reset
= snd_soc_ac97_warm_reset
;
2291 ops
->reset
= snd_soc_ac97_reset
;
2293 snd_ac97_rst_cfg
= cfg
;
2296 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops_of_reset
);
2299 * snd_soc_free_ac97_codec - free AC97 codec device
2300 * @codec: audio codec
2302 * Frees AC97 codec device resources.
2304 void snd_soc_free_ac97_codec(struct snd_soc_codec
*codec
)
2306 mutex_lock(&codec
->mutex
);
2307 #ifdef CONFIG_SND_SOC_AC97_BUS
2308 soc_unregister_ac97_codec(codec
);
2310 kfree(codec
->ac97
->bus
);
2313 codec
->ac97_created
= 0;
2314 mutex_unlock(&codec
->mutex
);
2316 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec
);
2319 * snd_soc_cnew - create new control
2320 * @_template: control template
2321 * @data: control private data
2322 * @long_name: control long name
2323 * @prefix: control name prefix
2325 * Create a new mixer control from a template control.
2327 * Returns 0 for success, else error.
2329 struct snd_kcontrol
*snd_soc_cnew(const struct snd_kcontrol_new
*_template
,
2330 void *data
, const char *long_name
,
2333 struct snd_kcontrol_new
template;
2334 struct snd_kcontrol
*kcontrol
;
2337 memcpy(&template, _template
, sizeof(template));
2341 long_name
= template.name
;
2344 name
= kasprintf(GFP_KERNEL
, "%s %s", prefix
, long_name
);
2348 template.name
= name
;
2350 template.name
= long_name
;
2353 kcontrol
= snd_ctl_new1(&template, data
);
2359 EXPORT_SYMBOL_GPL(snd_soc_cnew
);
2361 static int snd_soc_add_controls(struct snd_card
*card
, struct device
*dev
,
2362 const struct snd_kcontrol_new
*controls
, int num_controls
,
2363 const char *prefix
, void *data
)
2367 for (i
= 0; i
< num_controls
; i
++) {
2368 const struct snd_kcontrol_new
*control
= &controls
[i
];
2369 err
= snd_ctl_add(card
, snd_soc_cnew(control
, data
,
2370 control
->name
, prefix
));
2372 dev_err(dev
, "ASoC: Failed to add %s: %d\n",
2373 control
->name
, err
);
2381 struct snd_kcontrol
*snd_soc_card_get_kcontrol(struct snd_soc_card
*soc_card
,
2384 struct snd_card
*card
= soc_card
->snd_card
;
2385 struct snd_kcontrol
*kctl
;
2387 if (unlikely(!name
))
2390 list_for_each_entry(kctl
, &card
->controls
, list
)
2391 if (!strncmp(kctl
->id
.name
, name
, sizeof(kctl
->id
.name
)))
2395 EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol
);
2398 * snd_soc_add_codec_controls - add an array of controls to a codec.
2399 * Convenience function to add a list of controls. Many codecs were
2400 * duplicating this code.
2402 * @codec: codec to add controls to
2403 * @controls: array of controls to add
2404 * @num_controls: number of elements in the array
2406 * Return 0 for success, else error.
2408 int snd_soc_add_codec_controls(struct snd_soc_codec
*codec
,
2409 const struct snd_kcontrol_new
*controls
, int num_controls
)
2411 struct snd_card
*card
= codec
->card
->snd_card
;
2413 return snd_soc_add_controls(card
, codec
->dev
, controls
, num_controls
,
2414 codec
->component
.name_prefix
, &codec
->component
);
2416 EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls
);
2419 * snd_soc_add_platform_controls - add an array of controls to a platform.
2420 * Convenience function to add a list of controls.
2422 * @platform: platform to add controls to
2423 * @controls: array of controls to add
2424 * @num_controls: number of elements in the array
2426 * Return 0 for success, else error.
2428 int snd_soc_add_platform_controls(struct snd_soc_platform
*platform
,
2429 const struct snd_kcontrol_new
*controls
, int num_controls
)
2431 struct snd_card
*card
= platform
->card
->snd_card
;
2433 return snd_soc_add_controls(card
, platform
->dev
, controls
, num_controls
,
2434 NULL
, &platform
->component
);
2436 EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls
);
2439 * snd_soc_add_card_controls - add an array of controls to a SoC card.
2440 * Convenience function to add a list of controls.
2442 * @soc_card: SoC card to add controls to
2443 * @controls: array of controls to add
2444 * @num_controls: number of elements in the array
2446 * Return 0 for success, else error.
2448 int snd_soc_add_card_controls(struct snd_soc_card
*soc_card
,
2449 const struct snd_kcontrol_new
*controls
, int num_controls
)
2451 struct snd_card
*card
= soc_card
->snd_card
;
2453 return snd_soc_add_controls(card
, soc_card
->dev
, controls
, num_controls
,
2456 EXPORT_SYMBOL_GPL(snd_soc_add_card_controls
);
2459 * snd_soc_add_dai_controls - add an array of controls to a DAI.
2460 * Convienience function to add a list of controls.
2462 * @dai: DAI to add controls to
2463 * @controls: array of controls to add
2464 * @num_controls: number of elements in the array
2466 * Return 0 for success, else error.
2468 int snd_soc_add_dai_controls(struct snd_soc_dai
*dai
,
2469 const struct snd_kcontrol_new
*controls
, int num_controls
)
2471 struct snd_card
*card
= dai
->card
->snd_card
;
2473 return snd_soc_add_controls(card
, dai
->dev
, controls
, num_controls
,
2476 EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls
);
2479 * snd_soc_info_enum_double - enumerated double mixer info callback
2480 * @kcontrol: mixer control
2481 * @uinfo: control element information
2483 * Callback to provide information about a double enumerated
2486 * Returns 0 for success.
2488 int snd_soc_info_enum_double(struct snd_kcontrol
*kcontrol
,
2489 struct snd_ctl_elem_info
*uinfo
)
2491 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
2493 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
2494 uinfo
->count
= e
->shift_l
== e
->shift_r
? 1 : 2;
2495 uinfo
->value
.enumerated
.items
= e
->items
;
2497 if (uinfo
->value
.enumerated
.item
>= e
->items
)
2498 uinfo
->value
.enumerated
.item
= e
->items
- 1;
2499 strlcpy(uinfo
->value
.enumerated
.name
,
2500 e
->texts
[uinfo
->value
.enumerated
.item
],
2501 sizeof(uinfo
->value
.enumerated
.name
));
2504 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double
);
2507 * snd_soc_get_enum_double - enumerated double mixer get callback
2508 * @kcontrol: mixer control
2509 * @ucontrol: control element information
2511 * Callback to get the value of a double enumerated mixer.
2513 * Returns 0 for success.
2515 int snd_soc_get_enum_double(struct snd_kcontrol
*kcontrol
,
2516 struct snd_ctl_elem_value
*ucontrol
)
2518 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
2519 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
2520 unsigned int val
, item
;
2521 unsigned int reg_val
;
2524 ret
= snd_soc_component_read(component
, e
->reg
, ®_val
);
2527 val
= (reg_val
>> e
->shift_l
) & e
->mask
;
2528 item
= snd_soc_enum_val_to_item(e
, val
);
2529 ucontrol
->value
.enumerated
.item
[0] = item
;
2530 if (e
->shift_l
!= e
->shift_r
) {
2531 val
= (reg_val
>> e
->shift_l
) & e
->mask
;
2532 item
= snd_soc_enum_val_to_item(e
, val
);
2533 ucontrol
->value
.enumerated
.item
[1] = item
;
2538 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double
);
2541 * snd_soc_put_enum_double - enumerated double mixer put callback
2542 * @kcontrol: mixer control
2543 * @ucontrol: control element information
2545 * Callback to set the value of a double enumerated mixer.
2547 * Returns 0 for success.
2549 int snd_soc_put_enum_double(struct snd_kcontrol
*kcontrol
,
2550 struct snd_ctl_elem_value
*ucontrol
)
2552 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
2553 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
2554 unsigned int *item
= ucontrol
->value
.enumerated
.item
;
2558 if (item
[0] >= e
->items
)
2560 val
= snd_soc_enum_item_to_val(e
, item
[0]) << e
->shift_l
;
2561 mask
= e
->mask
<< e
->shift_l
;
2562 if (e
->shift_l
!= e
->shift_r
) {
2563 if (item
[1] >= e
->items
)
2565 val
|= snd_soc_enum_item_to_val(e
, item
[1]) << e
->shift_r
;
2566 mask
|= e
->mask
<< e
->shift_r
;
2569 return snd_soc_component_update_bits(component
, e
->reg
, mask
, val
);
2571 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double
);
2574 * snd_soc_read_signed - Read a codec register and interprete as signed value
2575 * @component: component
2576 * @reg: Register to read
2577 * @mask: Mask to use after shifting the register value
2578 * @shift: Right shift of register value
2579 * @sign_bit: Bit that describes if a number is negative or not.
2580 * @signed_val: Pointer to where the read value should be stored
2582 * This functions reads a codec register. The register value is shifted right
2583 * by 'shift' bits and masked with the given 'mask'. Afterwards it translates
2584 * the given registervalue into a signed integer if sign_bit is non-zero.
2586 * Returns 0 on sucess, otherwise an error value
2588 static int snd_soc_read_signed(struct snd_soc_component
*component
,
2589 unsigned int reg
, unsigned int mask
, unsigned int shift
,
2590 unsigned int sign_bit
, int *signed_val
)
2595 ret
= snd_soc_component_read(component
, reg
, &val
);
2599 val
= (val
>> shift
) & mask
;
2606 /* non-negative number */
2607 if (!(val
& BIT(sign_bit
))) {
2615 * The register most probably does not contain a full-sized int.
2616 * Instead we have an arbitrary number of bits in a signed
2617 * representation which has to be translated into a full-sized int.
2618 * This is done by filling up all bits above the sign-bit.
2620 ret
|= ~((int)(BIT(sign_bit
) - 1));
2628 * snd_soc_info_volsw - single mixer info callback
2629 * @kcontrol: mixer control
2630 * @uinfo: control element information
2632 * Callback to provide information about a single mixer control, or a double
2633 * mixer control that spans 2 registers.
2635 * Returns 0 for success.
2637 int snd_soc_info_volsw(struct snd_kcontrol
*kcontrol
,
2638 struct snd_ctl_elem_info
*uinfo
)
2640 struct soc_mixer_control
*mc
=
2641 (struct soc_mixer_control
*)kcontrol
->private_value
;
2644 if (!mc
->platform_max
)
2645 mc
->platform_max
= mc
->max
;
2646 platform_max
= mc
->platform_max
;
2648 if (platform_max
== 1 && !strstr(kcontrol
->id
.name
, " Volume"))
2649 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
2651 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2653 uinfo
->count
= snd_soc_volsw_is_stereo(mc
) ? 2 : 1;
2654 uinfo
->value
.integer
.min
= 0;
2655 uinfo
->value
.integer
.max
= platform_max
- mc
->min
;
2658 EXPORT_SYMBOL_GPL(snd_soc_info_volsw
);
2661 * snd_soc_get_volsw - single mixer get callback
2662 * @kcontrol: mixer control
2663 * @ucontrol: control element information
2665 * Callback to get the value of a single mixer control, or a double mixer
2666 * control that spans 2 registers.
2668 * Returns 0 for success.
2670 int snd_soc_get_volsw(struct snd_kcontrol
*kcontrol
,
2671 struct snd_ctl_elem_value
*ucontrol
)
2673 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
2674 struct soc_mixer_control
*mc
=
2675 (struct soc_mixer_control
*)kcontrol
->private_value
;
2676 unsigned int reg
= mc
->reg
;
2677 unsigned int reg2
= mc
->rreg
;
2678 unsigned int shift
= mc
->shift
;
2679 unsigned int rshift
= mc
->rshift
;
2682 int sign_bit
= mc
->sign_bit
;
2683 unsigned int mask
= (1 << fls(max
)) - 1;
2684 unsigned int invert
= mc
->invert
;
2689 mask
= BIT(sign_bit
+ 1) - 1;
2691 ret
= snd_soc_read_signed(component
, reg
, mask
, shift
, sign_bit
, &val
);
2695 ucontrol
->value
.integer
.value
[0] = val
- min
;
2697 ucontrol
->value
.integer
.value
[0] =
2698 max
- ucontrol
->value
.integer
.value
[0];
2700 if (snd_soc_volsw_is_stereo(mc
)) {
2702 ret
= snd_soc_read_signed(component
, reg
, mask
, rshift
,
2705 ret
= snd_soc_read_signed(component
, reg2
, mask
, shift
,
2710 ucontrol
->value
.integer
.value
[1] = val
- min
;
2712 ucontrol
->value
.integer
.value
[1] =
2713 max
- ucontrol
->value
.integer
.value
[1];
2718 EXPORT_SYMBOL_GPL(snd_soc_get_volsw
);
2721 * snd_soc_put_volsw - single mixer put callback
2722 * @kcontrol: mixer control
2723 * @ucontrol: control element information
2725 * Callback to set the value of a single mixer control, or a double mixer
2726 * control that spans 2 registers.
2728 * Returns 0 for success.
2730 int snd_soc_put_volsw(struct snd_kcontrol
*kcontrol
,
2731 struct snd_ctl_elem_value
*ucontrol
)
2733 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
2734 struct soc_mixer_control
*mc
=
2735 (struct soc_mixer_control
*)kcontrol
->private_value
;
2736 unsigned int reg
= mc
->reg
;
2737 unsigned int reg2
= mc
->rreg
;
2738 unsigned int shift
= mc
->shift
;
2739 unsigned int rshift
= mc
->rshift
;
2742 unsigned int sign_bit
= mc
->sign_bit
;
2743 unsigned int mask
= (1 << fls(max
)) - 1;
2744 unsigned int invert
= mc
->invert
;
2746 bool type_2r
= false;
2747 unsigned int val2
= 0;
2748 unsigned int val
, val_mask
;
2751 mask
= BIT(sign_bit
+ 1) - 1;
2753 val
= ((ucontrol
->value
.integer
.value
[0] + min
) & mask
);
2756 val_mask
= mask
<< shift
;
2758 if (snd_soc_volsw_is_stereo(mc
)) {
2759 val2
= ((ucontrol
->value
.integer
.value
[1] + min
) & mask
);
2763 val_mask
|= mask
<< rshift
;
2764 val
|= val2
<< rshift
;
2766 val2
= val2
<< shift
;
2770 err
= snd_soc_component_update_bits(component
, reg
, val_mask
, val
);
2775 err
= snd_soc_component_update_bits(component
, reg2
, val_mask
,
2780 EXPORT_SYMBOL_GPL(snd_soc_put_volsw
);
2783 * snd_soc_get_volsw_sx - single mixer get callback
2784 * @kcontrol: mixer control
2785 * @ucontrol: control element information
2787 * Callback to get the value of a single mixer control, or a double mixer
2788 * control that spans 2 registers.
2790 * Returns 0 for success.
2792 int snd_soc_get_volsw_sx(struct snd_kcontrol
*kcontrol
,
2793 struct snd_ctl_elem_value
*ucontrol
)
2795 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
2796 struct soc_mixer_control
*mc
=
2797 (struct soc_mixer_control
*)kcontrol
->private_value
;
2798 unsigned int reg
= mc
->reg
;
2799 unsigned int reg2
= mc
->rreg
;
2800 unsigned int shift
= mc
->shift
;
2801 unsigned int rshift
= mc
->rshift
;
2804 int mask
= (1 << (fls(min
+ max
) - 1)) - 1;
2808 ret
= snd_soc_component_read(component
, reg
, &val
);
2812 ucontrol
->value
.integer
.value
[0] = ((val
>> shift
) - min
) & mask
;
2814 if (snd_soc_volsw_is_stereo(mc
)) {
2815 ret
= snd_soc_component_read(component
, reg2
, &val
);
2819 val
= ((val
>> rshift
) - min
) & mask
;
2820 ucontrol
->value
.integer
.value
[1] = val
;
2825 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx
);
2828 * snd_soc_put_volsw_sx - double mixer set callback
2829 * @kcontrol: mixer control
2830 * @uinfo: control element information
2832 * Callback to set the value of a double mixer control that spans 2 registers.
2834 * Returns 0 for success.
2836 int snd_soc_put_volsw_sx(struct snd_kcontrol
*kcontrol
,
2837 struct snd_ctl_elem_value
*ucontrol
)
2839 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
2840 struct soc_mixer_control
*mc
=
2841 (struct soc_mixer_control
*)kcontrol
->private_value
;
2843 unsigned int reg
= mc
->reg
;
2844 unsigned int reg2
= mc
->rreg
;
2845 unsigned int shift
= mc
->shift
;
2846 unsigned int rshift
= mc
->rshift
;
2849 int mask
= (1 << (fls(min
+ max
) - 1)) - 1;
2851 unsigned int val
, val_mask
, val2
= 0;
2853 val_mask
= mask
<< shift
;
2854 val
= (ucontrol
->value
.integer
.value
[0] + min
) & mask
;
2857 err
= snd_soc_component_update_bits(component
, reg
, val_mask
, val
);
2861 if (snd_soc_volsw_is_stereo(mc
)) {
2862 val_mask
= mask
<< rshift
;
2863 val2
= (ucontrol
->value
.integer
.value
[1] + min
) & mask
;
2864 val2
= val2
<< rshift
;
2866 err
= snd_soc_component_update_bits(component
, reg2
, val_mask
,
2871 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx
);
2874 * snd_soc_info_volsw_s8 - signed mixer info callback
2875 * @kcontrol: mixer control
2876 * @uinfo: control element information
2878 * Callback to provide information about a signed mixer control.
2880 * Returns 0 for success.
2882 int snd_soc_info_volsw_s8(struct snd_kcontrol
*kcontrol
,
2883 struct snd_ctl_elem_info
*uinfo
)
2885 struct soc_mixer_control
*mc
=
2886 (struct soc_mixer_control
*)kcontrol
->private_value
;
2890 if (!mc
->platform_max
)
2891 mc
->platform_max
= mc
->max
;
2892 platform_max
= mc
->platform_max
;
2894 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2896 uinfo
->value
.integer
.min
= 0;
2897 uinfo
->value
.integer
.max
= platform_max
- min
;
2900 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8
);
2903 * snd_soc_get_volsw_s8 - signed mixer get callback
2904 * @kcontrol: mixer control
2905 * @ucontrol: control element information
2907 * Callback to get the value of a signed mixer control.
2909 * Returns 0 for success.
2911 int snd_soc_get_volsw_s8(struct snd_kcontrol
*kcontrol
,
2912 struct snd_ctl_elem_value
*ucontrol
)
2914 struct soc_mixer_control
*mc
=
2915 (struct soc_mixer_control
*)kcontrol
->private_value
;
2916 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
2917 unsigned int reg
= mc
->reg
;
2922 ret
= snd_soc_component_read(component
, reg
, &val
);
2926 ucontrol
->value
.integer
.value
[0] =
2927 ((signed char)(val
& 0xff))-min
;
2928 ucontrol
->value
.integer
.value
[1] =
2929 ((signed char)((val
>> 8) & 0xff))-min
;
2932 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8
);
2935 * snd_soc_put_volsw_sgn - signed mixer put callback
2936 * @kcontrol: mixer control
2937 * @ucontrol: control element information
2939 * Callback to set the value of a signed mixer control.
2941 * Returns 0 for success.
2943 int snd_soc_put_volsw_s8(struct snd_kcontrol
*kcontrol
,
2944 struct snd_ctl_elem_value
*ucontrol
)
2946 struct soc_mixer_control
*mc
=
2947 (struct soc_mixer_control
*)kcontrol
->private_value
;
2948 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
2949 unsigned int reg
= mc
->reg
;
2953 val
= (ucontrol
->value
.integer
.value
[0]+min
) & 0xff;
2954 val
|= ((ucontrol
->value
.integer
.value
[1]+min
) & 0xff) << 8;
2956 return snd_soc_component_update_bits(component
, reg
, 0xffff, val
);
2958 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8
);
2961 * snd_soc_info_volsw_range - single mixer info callback with range.
2962 * @kcontrol: mixer control
2963 * @uinfo: control element information
2965 * Callback to provide information, within a range, about a single
2968 * returns 0 for success.
2970 int snd_soc_info_volsw_range(struct snd_kcontrol
*kcontrol
,
2971 struct snd_ctl_elem_info
*uinfo
)
2973 struct soc_mixer_control
*mc
=
2974 (struct soc_mixer_control
*)kcontrol
->private_value
;
2978 if (!mc
->platform_max
)
2979 mc
->platform_max
= mc
->max
;
2980 platform_max
= mc
->platform_max
;
2982 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2983 uinfo
->count
= snd_soc_volsw_is_stereo(mc
) ? 2 : 1;
2984 uinfo
->value
.integer
.min
= 0;
2985 uinfo
->value
.integer
.max
= platform_max
- min
;
2989 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range
);
2992 * snd_soc_put_volsw_range - single mixer put value callback with range.
2993 * @kcontrol: mixer control
2994 * @ucontrol: control element information
2996 * Callback to set the value, within a range, for a single mixer control.
2998 * Returns 0 for success.
3000 int snd_soc_put_volsw_range(struct snd_kcontrol
*kcontrol
,
3001 struct snd_ctl_elem_value
*ucontrol
)
3003 struct soc_mixer_control
*mc
=
3004 (struct soc_mixer_control
*)kcontrol
->private_value
;
3005 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
3006 unsigned int reg
= mc
->reg
;
3007 unsigned int rreg
= mc
->rreg
;
3008 unsigned int shift
= mc
->shift
;
3011 unsigned int mask
= (1 << fls(max
)) - 1;
3012 unsigned int invert
= mc
->invert
;
3013 unsigned int val
, val_mask
;
3016 val
= ((ucontrol
->value
.integer
.value
[0] + min
) & mask
);
3019 val_mask
= mask
<< shift
;
3022 ret
= snd_soc_component_update_bits(component
, reg
, val_mask
, val
);
3026 if (snd_soc_volsw_is_stereo(mc
)) {
3027 val
= ((ucontrol
->value
.integer
.value
[1] + min
) & mask
);
3030 val_mask
= mask
<< shift
;
3033 ret
= snd_soc_component_update_bits(component
, rreg
, val_mask
,
3039 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range
);
3042 * snd_soc_get_volsw_range - single mixer get callback with range
3043 * @kcontrol: mixer control
3044 * @ucontrol: control element information
3046 * Callback to get the value, within a range, of a single mixer control.
3048 * Returns 0 for success.
3050 int snd_soc_get_volsw_range(struct snd_kcontrol
*kcontrol
,
3051 struct snd_ctl_elem_value
*ucontrol
)
3053 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
3054 struct soc_mixer_control
*mc
=
3055 (struct soc_mixer_control
*)kcontrol
->private_value
;
3056 unsigned int reg
= mc
->reg
;
3057 unsigned int rreg
= mc
->rreg
;
3058 unsigned int shift
= mc
->shift
;
3061 unsigned int mask
= (1 << fls(max
)) - 1;
3062 unsigned int invert
= mc
->invert
;
3066 ret
= snd_soc_component_read(component
, reg
, &val
);
3070 ucontrol
->value
.integer
.value
[0] = (val
>> shift
) & mask
;
3072 ucontrol
->value
.integer
.value
[0] =
3073 max
- ucontrol
->value
.integer
.value
[0];
3074 ucontrol
->value
.integer
.value
[0] =
3075 ucontrol
->value
.integer
.value
[0] - min
;
3077 if (snd_soc_volsw_is_stereo(mc
)) {
3078 ret
= snd_soc_component_read(component
, rreg
, &val
);
3082 ucontrol
->value
.integer
.value
[1] = (val
>> shift
) & mask
;
3084 ucontrol
->value
.integer
.value
[1] =
3085 max
- ucontrol
->value
.integer
.value
[1];
3086 ucontrol
->value
.integer
.value
[1] =
3087 ucontrol
->value
.integer
.value
[1] - min
;
3092 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range
);
3095 * snd_soc_limit_volume - Set new limit to an existing volume control.
3097 * @codec: where to look for the control
3098 * @name: Name of the control
3099 * @max: new maximum limit
3101 * Return 0 for success, else error.
3103 int snd_soc_limit_volume(struct snd_soc_codec
*codec
,
3104 const char *name
, int max
)
3106 struct snd_card
*card
= codec
->card
->snd_card
;
3107 struct snd_kcontrol
*kctl
;
3108 struct soc_mixer_control
*mc
;
3112 /* Sanity check for name and max */
3113 if (unlikely(!name
|| max
<= 0))
3116 list_for_each_entry(kctl
, &card
->controls
, list
) {
3117 if (!strncmp(kctl
->id
.name
, name
, sizeof(kctl
->id
.name
))) {
3123 mc
= (struct soc_mixer_control
*)kctl
->private_value
;
3124 if (max
<= mc
->max
) {
3125 mc
->platform_max
= max
;
3131 EXPORT_SYMBOL_GPL(snd_soc_limit_volume
);
3133 int snd_soc_bytes_info(struct snd_kcontrol
*kcontrol
,
3134 struct snd_ctl_elem_info
*uinfo
)
3136 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
3137 struct soc_bytes
*params
= (void *)kcontrol
->private_value
;
3139 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BYTES
;
3140 uinfo
->count
= params
->num_regs
* component
->val_bytes
;
3144 EXPORT_SYMBOL_GPL(snd_soc_bytes_info
);
3146 int snd_soc_bytes_get(struct snd_kcontrol
*kcontrol
,
3147 struct snd_ctl_elem_value
*ucontrol
)
3149 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
3150 struct soc_bytes
*params
= (void *)kcontrol
->private_value
;
3153 if (component
->regmap
)
3154 ret
= regmap_raw_read(component
->regmap
, params
->base
,
3155 ucontrol
->value
.bytes
.data
,
3156 params
->num_regs
* component
->val_bytes
);
3160 /* Hide any masked bytes to ensure consistent data reporting */
3161 if (ret
== 0 && params
->mask
) {
3162 switch (component
->val_bytes
) {
3164 ucontrol
->value
.bytes
.data
[0] &= ~params
->mask
;
3167 ((u16
*)(&ucontrol
->value
.bytes
.data
))[0]
3168 &= cpu_to_be16(~params
->mask
);
3171 ((u32
*)(&ucontrol
->value
.bytes
.data
))[0]
3172 &= cpu_to_be32(~params
->mask
);
3181 EXPORT_SYMBOL_GPL(snd_soc_bytes_get
);
3183 int snd_soc_bytes_put(struct snd_kcontrol
*kcontrol
,
3184 struct snd_ctl_elem_value
*ucontrol
)
3186 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
3187 struct soc_bytes
*params
= (void *)kcontrol
->private_value
;
3189 unsigned int val
, mask
;
3192 if (!component
->regmap
)
3195 len
= params
->num_regs
* component
->val_bytes
;
3197 data
= kmemdup(ucontrol
->value
.bytes
.data
, len
, GFP_KERNEL
| GFP_DMA
);
3202 * If we've got a mask then we need to preserve the register
3203 * bits. We shouldn't modify the incoming data so take a
3207 ret
= regmap_read(component
->regmap
, params
->base
, &val
);
3211 val
&= params
->mask
;
3213 switch (component
->val_bytes
) {
3215 ((u8
*)data
)[0] &= ~params
->mask
;
3216 ((u8
*)data
)[0] |= val
;
3219 mask
= ~params
->mask
;
3220 ret
= regmap_parse_val(component
->regmap
,
3225 ((u16
*)data
)[0] &= mask
;
3227 ret
= regmap_parse_val(component
->regmap
,
3232 ((u16
*)data
)[0] |= val
;
3235 mask
= ~params
->mask
;
3236 ret
= regmap_parse_val(component
->regmap
,
3241 ((u32
*)data
)[0] &= mask
;
3243 ret
= regmap_parse_val(component
->regmap
,
3248 ((u32
*)data
)[0] |= val
;
3256 ret
= regmap_raw_write(component
->regmap
, params
->base
,
3264 EXPORT_SYMBOL_GPL(snd_soc_bytes_put
);
3266 int snd_soc_bytes_info_ext(struct snd_kcontrol
*kcontrol
,
3267 struct snd_ctl_elem_info
*ucontrol
)
3269 struct soc_bytes_ext
*params
= (void *)kcontrol
->private_value
;
3271 ucontrol
->type
= SNDRV_CTL_ELEM_TYPE_BYTES
;
3272 ucontrol
->count
= params
->max
;
3276 EXPORT_SYMBOL_GPL(snd_soc_bytes_info_ext
);
3279 * snd_soc_info_xr_sx - signed multi register info callback
3280 * @kcontrol: mreg control
3281 * @uinfo: control element information
3283 * Callback to provide information of a control that can
3284 * span multiple codec registers which together
3285 * forms a single signed value in a MSB/LSB manner.
3287 * Returns 0 for success.
3289 int snd_soc_info_xr_sx(struct snd_kcontrol
*kcontrol
,
3290 struct snd_ctl_elem_info
*uinfo
)
3292 struct soc_mreg_control
*mc
=
3293 (struct soc_mreg_control
*)kcontrol
->private_value
;
3294 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
3296 uinfo
->value
.integer
.min
= mc
->min
;
3297 uinfo
->value
.integer
.max
= mc
->max
;
3301 EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx
);
3304 * snd_soc_get_xr_sx - signed multi register get callback
3305 * @kcontrol: mreg control
3306 * @ucontrol: control element information
3308 * Callback to get the value of a control that can span
3309 * multiple codec registers which together forms a single
3310 * signed value in a MSB/LSB manner. The control supports
3311 * specifying total no of bits used to allow for bitfields
3312 * across the multiple codec registers.
3314 * Returns 0 for success.
3316 int snd_soc_get_xr_sx(struct snd_kcontrol
*kcontrol
,
3317 struct snd_ctl_elem_value
*ucontrol
)
3319 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
3320 struct soc_mreg_control
*mc
=
3321 (struct soc_mreg_control
*)kcontrol
->private_value
;
3322 unsigned int regbase
= mc
->regbase
;
3323 unsigned int regcount
= mc
->regcount
;
3324 unsigned int regwshift
= component
->val_bytes
* BITS_PER_BYTE
;
3325 unsigned int regwmask
= (1<<regwshift
)-1;
3326 unsigned int invert
= mc
->invert
;
3327 unsigned long mask
= (1UL<<mc
->nbits
)-1;
3331 unsigned int regval
;
3335 for (i
= 0; i
< regcount
; i
++) {
3336 ret
= snd_soc_component_read(component
, regbase
+i
, ®val
);
3339 val
|= (regval
& regwmask
) << (regwshift
*(regcount
-i
-1));
3342 if (min
< 0 && val
> max
)
3346 ucontrol
->value
.integer
.value
[0] = val
;
3350 EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx
);
3353 * snd_soc_put_xr_sx - signed multi register get callback
3354 * @kcontrol: mreg control
3355 * @ucontrol: control element information
3357 * Callback to set the value of a control that can span
3358 * multiple codec registers which together forms a single
3359 * signed value in a MSB/LSB manner. The control supports
3360 * specifying total no of bits used to allow for bitfields
3361 * across the multiple codec registers.
3363 * Returns 0 for success.
3365 int snd_soc_put_xr_sx(struct snd_kcontrol
*kcontrol
,
3366 struct snd_ctl_elem_value
*ucontrol
)
3368 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
3369 struct soc_mreg_control
*mc
=
3370 (struct soc_mreg_control
*)kcontrol
->private_value
;
3371 unsigned int regbase
= mc
->regbase
;
3372 unsigned int regcount
= mc
->regcount
;
3373 unsigned int regwshift
= component
->val_bytes
* BITS_PER_BYTE
;
3374 unsigned int regwmask
= (1<<regwshift
)-1;
3375 unsigned int invert
= mc
->invert
;
3376 unsigned long mask
= (1UL<<mc
->nbits
)-1;
3378 long val
= ucontrol
->value
.integer
.value
[0];
3379 unsigned int i
, regval
, regmask
;
3385 for (i
= 0; i
< regcount
; i
++) {
3386 regval
= (val
>> (regwshift
*(regcount
-i
-1))) & regwmask
;
3387 regmask
= (mask
>> (regwshift
*(regcount
-i
-1))) & regwmask
;
3388 err
= snd_soc_component_update_bits(component
, regbase
+i
,
3396 EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx
);
3399 * snd_soc_get_strobe - strobe get callback
3400 * @kcontrol: mixer control
3401 * @ucontrol: control element information
3403 * Callback get the value of a strobe mixer control.
3405 * Returns 0 for success.
3407 int snd_soc_get_strobe(struct snd_kcontrol
*kcontrol
,
3408 struct snd_ctl_elem_value
*ucontrol
)
3410 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
3411 struct soc_mixer_control
*mc
=
3412 (struct soc_mixer_control
*)kcontrol
->private_value
;
3413 unsigned int reg
= mc
->reg
;
3414 unsigned int shift
= mc
->shift
;
3415 unsigned int mask
= 1 << shift
;
3416 unsigned int invert
= mc
->invert
!= 0;
3420 ret
= snd_soc_component_read(component
, reg
, &val
);
3426 if (shift
!= 0 && val
!= 0)
3428 ucontrol
->value
.enumerated
.item
[0] = val
^ invert
;
3432 EXPORT_SYMBOL_GPL(snd_soc_get_strobe
);
3435 * snd_soc_put_strobe - strobe put callback
3436 * @kcontrol: mixer control
3437 * @ucontrol: control element information
3439 * Callback strobe a register bit to high then low (or the inverse)
3440 * in one pass of a single mixer enum control.
3442 * Returns 1 for success.
3444 int snd_soc_put_strobe(struct snd_kcontrol
*kcontrol
,
3445 struct snd_ctl_elem_value
*ucontrol
)
3447 struct snd_soc_component
*component
= snd_kcontrol_chip(kcontrol
);
3448 struct soc_mixer_control
*mc
=
3449 (struct soc_mixer_control
*)kcontrol
->private_value
;
3450 unsigned int reg
= mc
->reg
;
3451 unsigned int shift
= mc
->shift
;
3452 unsigned int mask
= 1 << shift
;
3453 unsigned int invert
= mc
->invert
!= 0;
3454 unsigned int strobe
= ucontrol
->value
.enumerated
.item
[0] != 0;
3455 unsigned int val1
= (strobe
^ invert
) ? mask
: 0;
3456 unsigned int val2
= (strobe
^ invert
) ? 0 : mask
;
3459 err
= snd_soc_component_update_bits(component
, reg
, mask
, val1
);
3463 return snd_soc_component_update_bits(component
, reg
, mask
, val2
);
3465 EXPORT_SYMBOL_GPL(snd_soc_put_strobe
);
3468 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
3470 * @clk_id: DAI specific clock ID
3471 * @freq: new clock frequency in Hz
3472 * @dir: new clock direction - input/output.
3474 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
3476 int snd_soc_dai_set_sysclk(struct snd_soc_dai
*dai
, int clk_id
,
3477 unsigned int freq
, int dir
)
3479 if (dai
->driver
&& dai
->driver
->ops
->set_sysclk
)
3480 return dai
->driver
->ops
->set_sysclk(dai
, clk_id
, freq
, dir
);
3481 else if (dai
->codec
&& dai
->codec
->driver
->set_sysclk
)
3482 return dai
->codec
->driver
->set_sysclk(dai
->codec
, clk_id
, 0,
3487 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk
);
3490 * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
3492 * @clk_id: DAI specific clock ID
3493 * @source: Source for the clock
3494 * @freq: new clock frequency in Hz
3495 * @dir: new clock direction - input/output.
3497 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
3499 int snd_soc_codec_set_sysclk(struct snd_soc_codec
*codec
, int clk_id
,
3500 int source
, unsigned int freq
, int dir
)
3502 if (codec
->driver
->set_sysclk
)
3503 return codec
->driver
->set_sysclk(codec
, clk_id
, source
,
3508 EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk
);
3511 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
3513 * @div_id: DAI specific clock divider ID
3514 * @div: new clock divisor.
3516 * Configures the clock dividers. This is used to derive the best DAI bit and
3517 * frame clocks from the system or master clock. It's best to set the DAI bit
3518 * and frame clocks as low as possible to save system power.
3520 int snd_soc_dai_set_clkdiv(struct snd_soc_dai
*dai
,
3521 int div_id
, int div
)
3523 if (dai
->driver
&& dai
->driver
->ops
->set_clkdiv
)
3524 return dai
->driver
->ops
->set_clkdiv(dai
, div_id
, div
);
3528 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv
);
3531 * snd_soc_dai_set_pll - configure DAI PLL.
3533 * @pll_id: DAI specific PLL ID
3534 * @source: DAI specific source for the PLL
3535 * @freq_in: PLL input clock frequency in Hz
3536 * @freq_out: requested PLL output clock frequency in Hz
3538 * Configures and enables PLL to generate output clock based on input clock.
3540 int snd_soc_dai_set_pll(struct snd_soc_dai
*dai
, int pll_id
, int source
,
3541 unsigned int freq_in
, unsigned int freq_out
)
3543 if (dai
->driver
&& dai
->driver
->ops
->set_pll
)
3544 return dai
->driver
->ops
->set_pll(dai
, pll_id
, source
,
3546 else if (dai
->codec
&& dai
->codec
->driver
->set_pll
)
3547 return dai
->codec
->driver
->set_pll(dai
->codec
, pll_id
, source
,
3552 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll
);
3555 * snd_soc_codec_set_pll - configure codec PLL.
3557 * @pll_id: DAI specific PLL ID
3558 * @source: DAI specific source for the PLL
3559 * @freq_in: PLL input clock frequency in Hz
3560 * @freq_out: requested PLL output clock frequency in Hz
3562 * Configures and enables PLL to generate output clock based on input clock.
3564 int snd_soc_codec_set_pll(struct snd_soc_codec
*codec
, int pll_id
, int source
,
3565 unsigned int freq_in
, unsigned int freq_out
)
3567 if (codec
->driver
->set_pll
)
3568 return codec
->driver
->set_pll(codec
, pll_id
, source
,
3573 EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll
);
3576 * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
3578 * @ratio Ratio of BCLK to Sample rate.
3580 * Configures the DAI for a preset BCLK to sample rate ratio.
3582 int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai
*dai
, unsigned int ratio
)
3584 if (dai
->driver
&& dai
->driver
->ops
->set_bclk_ratio
)
3585 return dai
->driver
->ops
->set_bclk_ratio(dai
, ratio
);
3589 EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio
);
3592 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
3594 * @fmt: SND_SOC_DAIFMT_ format value.
3596 * Configures the DAI hardware format and clocking.
3598 int snd_soc_dai_set_fmt(struct snd_soc_dai
*dai
, unsigned int fmt
)
3600 if (dai
->driver
== NULL
)
3602 if (dai
->driver
->ops
->set_fmt
== NULL
)
3604 return dai
->driver
->ops
->set_fmt(dai
, fmt
);
3606 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt
);
3609 * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
3610 * @slots: Number of slots in use.
3611 * @tx_mask: bitmask representing active TX slots.
3612 * @rx_mask: bitmask representing active RX slots.
3614 * Generates the TDM tx and rx slot default masks for DAI.
3616 static int snd_soc_xlate_tdm_slot_mask(unsigned int slots
,
3617 unsigned int *tx_mask
,
3618 unsigned int *rx_mask
)
3620 if (*tx_mask
|| *rx_mask
)
3626 *tx_mask
= (1 << slots
) - 1;
3627 *rx_mask
= (1 << slots
) - 1;
3633 * snd_soc_dai_set_tdm_slot - configure DAI TDM.
3635 * @tx_mask: bitmask representing active TX slots.
3636 * @rx_mask: bitmask representing active RX slots.
3637 * @slots: Number of slots in use.
3638 * @slot_width: Width in bits for each slot.
3640 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
3643 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai
*dai
,
3644 unsigned int tx_mask
, unsigned int rx_mask
, int slots
, int slot_width
)
3646 if (dai
->driver
&& dai
->driver
->ops
->xlate_tdm_slot_mask
)
3647 dai
->driver
->ops
->xlate_tdm_slot_mask(slots
,
3648 &tx_mask
, &rx_mask
);
3650 snd_soc_xlate_tdm_slot_mask(slots
, &tx_mask
, &rx_mask
);
3652 dai
->tx_mask
= tx_mask
;
3653 dai
->rx_mask
= rx_mask
;
3655 if (dai
->driver
&& dai
->driver
->ops
->set_tdm_slot
)
3656 return dai
->driver
->ops
->set_tdm_slot(dai
, tx_mask
, rx_mask
,
3661 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot
);
3664 * snd_soc_dai_set_channel_map - configure DAI audio channel map
3666 * @tx_num: how many TX channels
3667 * @tx_slot: pointer to an array which imply the TX slot number channel
3669 * @rx_num: how many RX channels
3670 * @rx_slot: pointer to an array which imply the RX slot number channel
3673 * configure the relationship between channel number and TDM slot number.
3675 int snd_soc_dai_set_channel_map(struct snd_soc_dai
*dai
,
3676 unsigned int tx_num
, unsigned int *tx_slot
,
3677 unsigned int rx_num
, unsigned int *rx_slot
)
3679 if (dai
->driver
&& dai
->driver
->ops
->set_channel_map
)
3680 return dai
->driver
->ops
->set_channel_map(dai
, tx_num
, tx_slot
,
3685 EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map
);
3688 * snd_soc_dai_set_tristate - configure DAI system or master clock.
3690 * @tristate: tristate enable
3692 * Tristates the DAI so that others can use it.
3694 int snd_soc_dai_set_tristate(struct snd_soc_dai
*dai
, int tristate
)
3696 if (dai
->driver
&& dai
->driver
->ops
->set_tristate
)
3697 return dai
->driver
->ops
->set_tristate(dai
, tristate
);
3701 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate
);
3704 * snd_soc_dai_digital_mute - configure DAI system or master clock.
3706 * @mute: mute enable
3707 * @direction: stream to mute
3709 * Mutes the DAI DAC.
3711 int snd_soc_dai_digital_mute(struct snd_soc_dai
*dai
, int mute
,
3717 if (dai
->driver
->ops
->mute_stream
)
3718 return dai
->driver
->ops
->mute_stream(dai
, mute
, direction
);
3719 else if (direction
== SNDRV_PCM_STREAM_PLAYBACK
&&
3720 dai
->driver
->ops
->digital_mute
)
3721 return dai
->driver
->ops
->digital_mute(dai
, mute
);
3725 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute
);
3727 static int snd_soc_init_multicodec(struct snd_soc_card
*card
,
3728 struct snd_soc_dai_link
*dai_link
)
3730 /* Legacy codec/codec_dai link is a single entry in multicodec */
3731 if (dai_link
->codec_name
|| dai_link
->codec_of_node
||
3732 dai_link
->codec_dai_name
) {
3733 dai_link
->num_codecs
= 1;
3735 dai_link
->codecs
= devm_kzalloc(card
->dev
,
3736 sizeof(struct snd_soc_dai_link_component
),
3738 if (!dai_link
->codecs
)
3741 dai_link
->codecs
[0].name
= dai_link
->codec_name
;
3742 dai_link
->codecs
[0].of_node
= dai_link
->codec_of_node
;
3743 dai_link
->codecs
[0].dai_name
= dai_link
->codec_dai_name
;
3746 if (!dai_link
->codecs
) {
3747 dev_err(card
->dev
, "ASoC: DAI link has no CODECs\n");
3755 * snd_soc_register_card - Register a card with the ASoC core
3757 * @card: Card to register
3760 int snd_soc_register_card(struct snd_soc_card
*card
)
3764 if (!card
->name
|| !card
->dev
)
3767 for (i
= 0; i
< card
->num_links
; i
++) {
3768 struct snd_soc_dai_link
*link
= &card
->dai_link
[i
];
3770 ret
= snd_soc_init_multicodec(card
, link
);
3772 dev_err(card
->dev
, "ASoC: failed to init multicodec\n");
3776 for (j
= 0; j
< link
->num_codecs
; j
++) {
3778 * Codec must be specified by 1 of name or OF node,
3779 * not both or neither.
3781 if (!!link
->codecs
[j
].name
==
3782 !!link
->codecs
[j
].of_node
) {
3783 dev_err(card
->dev
, "ASoC: Neither/both codec name/of_node are set for %s\n",
3787 /* Codec DAI name must be specified */
3788 if (!link
->codecs
[j
].dai_name
) {
3789 dev_err(card
->dev
, "ASoC: codec_dai_name not set for %s\n",
3796 * Platform may be specified by either name or OF node, but
3797 * can be left unspecified, and a dummy platform will be used.
3799 if (link
->platform_name
&& link
->platform_of_node
) {
3801 "ASoC: Both platform name/of_node are set for %s\n",
3807 * CPU device may be specified by either name or OF node, but
3808 * can be left unspecified, and will be matched based on DAI
3811 if (link
->cpu_name
&& link
->cpu_of_node
) {
3813 "ASoC: Neither/both cpu name/of_node are set for %s\n",
3818 * At least one of CPU DAI name or CPU device name/node must be
3821 if (!link
->cpu_dai_name
&&
3822 !(link
->cpu_name
|| link
->cpu_of_node
)) {
3824 "ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
3830 dev_set_drvdata(card
->dev
, card
);
3832 snd_soc_initialize_card_lists(card
);
3834 soc_init_card_debugfs(card
);
3836 card
->rtd
= devm_kzalloc(card
->dev
,
3837 sizeof(struct snd_soc_pcm_runtime
) *
3838 (card
->num_links
+ card
->num_aux_devs
),
3840 if (card
->rtd
== NULL
)
3843 card
->rtd_aux
= &card
->rtd
[card
->num_links
];
3845 for (i
= 0; i
< card
->num_links
; i
++) {
3846 card
->rtd
[i
].card
= card
;
3847 card
->rtd
[i
].dai_link
= &card
->dai_link
[i
];
3848 card
->rtd
[i
].codec_dais
= devm_kzalloc(card
->dev
,
3849 sizeof(struct snd_soc_dai
*) *
3850 (card
->rtd
[i
].dai_link
->num_codecs
),
3852 if (card
->rtd
[i
].codec_dais
== NULL
)
3856 for (i
= 0; i
< card
->num_aux_devs
; i
++)
3857 card
->rtd_aux
[i
].card
= card
;
3859 INIT_LIST_HEAD(&card
->dapm_dirty
);
3860 card
->instantiated
= 0;
3861 mutex_init(&card
->mutex
);
3862 mutex_init(&card
->dapm_mutex
);
3864 ret
= snd_soc_instantiate_card(card
);
3866 soc_cleanup_card_debugfs(card
);
3868 /* deactivate pins to sleep state */
3869 for (i
= 0; i
< card
->num_rtd
; i
++) {
3870 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[i
];
3871 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
3874 for (j
= 0; j
< rtd
->num_codecs
; j
++) {
3875 struct snd_soc_dai
*codec_dai
= rtd
->codec_dais
[j
];
3876 if (!codec_dai
->active
)
3877 pinctrl_pm_select_sleep_state(codec_dai
->dev
);
3880 if (!cpu_dai
->active
)
3881 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
3886 EXPORT_SYMBOL_GPL(snd_soc_register_card
);
3889 * snd_soc_unregister_card - Unregister a card with the ASoC core
3891 * @card: Card to unregister
3894 int snd_soc_unregister_card(struct snd_soc_card
*card
)
3896 if (card
->instantiated
)
3897 soc_cleanup_card_resources(card
);
3898 dev_dbg(card
->dev
, "ASoC: Unregistered card '%s'\n", card
->name
);
3902 EXPORT_SYMBOL_GPL(snd_soc_unregister_card
);
3905 * Simplify DAI link configuration by removing ".-1" from device names
3906 * and sanitizing names.
3908 static char *fmt_single_name(struct device
*dev
, int *id
)
3910 char *found
, name
[NAME_SIZE
];
3913 if (dev_name(dev
) == NULL
)
3916 strlcpy(name
, dev_name(dev
), NAME_SIZE
);
3918 /* are we a "%s.%d" name (platform and SPI components) */
3919 found
= strstr(name
, dev
->driver
->name
);
3922 if (sscanf(&found
[strlen(dev
->driver
->name
)], ".%d", id
) == 1) {
3924 /* discard ID from name if ID == -1 */
3926 found
[strlen(dev
->driver
->name
)] = '\0';
3930 /* I2C component devices are named "bus-addr" */
3931 if (sscanf(name
, "%x-%x", &id1
, &id2
) == 2) {
3932 char tmp
[NAME_SIZE
];
3934 /* create unique ID number from I2C addr and bus */
3935 *id
= ((id1
& 0xffff) << 16) + id2
;
3937 /* sanitize component name for DAI link creation */
3938 snprintf(tmp
, NAME_SIZE
, "%s.%s", dev
->driver
->name
, name
);
3939 strlcpy(name
, tmp
, NAME_SIZE
);
3944 return kstrdup(name
, GFP_KERNEL
);
3948 * Simplify DAI link naming for single devices with multiple DAIs by removing
3949 * any ".-1" and using the DAI name (instead of device name).
3951 static inline char *fmt_multiple_name(struct device
*dev
,
3952 struct snd_soc_dai_driver
*dai_drv
)
3954 if (dai_drv
->name
== NULL
) {
3956 "ASoC: error - multiple DAI %s registered with no name\n",
3961 return kstrdup(dai_drv
->name
, GFP_KERNEL
);
3965 * snd_soc_unregister_dai - Unregister DAIs from the ASoC core
3967 * @component: The component for which the DAIs should be unregistered
3969 static void snd_soc_unregister_dais(struct snd_soc_component
*component
)
3971 struct snd_soc_dai
*dai
, *_dai
;
3973 list_for_each_entry_safe(dai
, _dai
, &component
->dai_list
, list
) {
3974 dev_dbg(component
->dev
, "ASoC: Unregistered DAI '%s'\n",
3976 list_del(&dai
->list
);
3983 * snd_soc_register_dais - Register a DAI with the ASoC core
3985 * @component: The component the DAIs are registered for
3986 * @dai_drv: DAI driver to use for the DAIs
3987 * @count: Number of DAIs
3988 * @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the
3991 static int snd_soc_register_dais(struct snd_soc_component
*component
,
3992 struct snd_soc_dai_driver
*dai_drv
, size_t count
,
3993 bool legacy_dai_naming
)
3995 struct device
*dev
= component
->dev
;
3996 struct snd_soc_dai
*dai
;
4000 dev_dbg(dev
, "ASoC: dai register %s #%Zu\n", dev_name(dev
), count
);
4002 component
->dai_drv
= dai_drv
;
4003 component
->num_dai
= count
;
4005 for (i
= 0; i
< count
; i
++) {
4007 dai
= kzalloc(sizeof(struct snd_soc_dai
), GFP_KERNEL
);
4014 * Back in the old days when we still had component-less DAIs,
4015 * instead of having a static name, component-less DAIs would
4016 * inherit the name of the parent device so it is possible to
4017 * register multiple instances of the DAI. We still need to keep
4018 * the same naming style even though those DAIs are not
4019 * component-less anymore.
4021 if (count
== 1 && legacy_dai_naming
) {
4022 dai
->name
= fmt_single_name(dev
, &dai
->id
);
4024 dai
->name
= fmt_multiple_name(dev
, &dai_drv
[i
]);
4026 dai
->id
= dai_drv
[i
].id
;
4030 if (dai
->name
== NULL
) {
4036 dai
->component
= component
;
4038 dai
->driver
= &dai_drv
[i
];
4039 if (!dai
->driver
->ops
)
4040 dai
->driver
->ops
= &null_dai_ops
;
4042 list_add(&dai
->list
, &component
->dai_list
);
4044 dev_dbg(dev
, "ASoC: Registered DAI '%s'\n", dai
->name
);
4050 snd_soc_unregister_dais(component
);
4055 static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context
*dapm
,
4056 enum snd_soc_dapm_type type
, int subseq
)
4058 struct snd_soc_component
*component
= dapm
->component
;
4060 component
->driver
->seq_notifier(component
, type
, subseq
);
4063 static int snd_soc_component_stream_event(struct snd_soc_dapm_context
*dapm
,
4066 struct snd_soc_component
*component
= dapm
->component
;
4068 return component
->driver
->stream_event(component
, event
);
4071 static int snd_soc_component_initialize(struct snd_soc_component
*component
,
4072 const struct snd_soc_component_driver
*driver
, struct device
*dev
)
4074 struct snd_soc_dapm_context
*dapm
;
4076 component
->name
= fmt_single_name(dev
, &component
->id
);
4077 if (!component
->name
) {
4078 dev_err(dev
, "ASoC: Failed to allocate name\n");
4082 component
->dev
= dev
;
4083 component
->driver
= driver
;
4085 if (!component
->dapm_ptr
)
4086 component
->dapm_ptr
= &component
->dapm
;
4088 dapm
= component
->dapm_ptr
;
4090 dapm
->component
= component
;
4091 dapm
->bias_level
= SND_SOC_BIAS_OFF
;
4092 if (driver
->seq_notifier
)
4093 dapm
->seq_notifier
= snd_soc_component_seq_notifier
;
4094 if (driver
->stream_event
)
4095 dapm
->stream_event
= snd_soc_component_stream_event
;
4097 INIT_LIST_HEAD(&component
->dai_list
);
4098 mutex_init(&component
->io_mutex
);
4103 static void snd_soc_component_add_unlocked(struct snd_soc_component
*component
)
4105 list_add(&component
->list
, &component_list
);
4108 static void snd_soc_component_add(struct snd_soc_component
*component
)
4110 mutex_lock(&client_mutex
);
4111 snd_soc_component_add_unlocked(component
);
4112 mutex_unlock(&client_mutex
);
4115 static void snd_soc_component_cleanup(struct snd_soc_component
*component
)
4117 snd_soc_unregister_dais(component
);
4118 kfree(component
->name
);
4121 static void snd_soc_component_del_unlocked(struct snd_soc_component
*component
)
4123 list_del(&component
->list
);
4126 static void snd_soc_component_del(struct snd_soc_component
*component
)
4128 mutex_lock(&client_mutex
);
4129 snd_soc_component_del_unlocked(component
);
4130 mutex_unlock(&client_mutex
);
4133 int snd_soc_register_component(struct device
*dev
,
4134 const struct snd_soc_component_driver
*cmpnt_drv
,
4135 struct snd_soc_dai_driver
*dai_drv
,
4138 struct snd_soc_component
*cmpnt
;
4141 cmpnt
= kzalloc(sizeof(*cmpnt
), GFP_KERNEL
);
4143 dev_err(dev
, "ASoC: Failed to allocate memory\n");
4147 ret
= snd_soc_component_initialize(cmpnt
, cmpnt_drv
, dev
);
4151 cmpnt
->ignore_pmdown_time
= true;
4152 cmpnt
->registered_as_component
= true;
4154 ret
= snd_soc_register_dais(cmpnt
, dai_drv
, num_dai
, true);
4156 dev_err(dev
, "ASoC: Failed to regster DAIs: %d\n", ret
);
4160 snd_soc_component_add(cmpnt
);
4165 snd_soc_component_cleanup(cmpnt
);
4170 EXPORT_SYMBOL_GPL(snd_soc_register_component
);
4173 * snd_soc_unregister_component - Unregister a component from the ASoC core
4176 void snd_soc_unregister_component(struct device
*dev
)
4178 struct snd_soc_component
*cmpnt
;
4180 list_for_each_entry(cmpnt
, &component_list
, list
) {
4181 if (dev
== cmpnt
->dev
&& cmpnt
->registered_as_component
)
4187 snd_soc_component_del(cmpnt
);
4188 snd_soc_component_cleanup(cmpnt
);
4191 EXPORT_SYMBOL_GPL(snd_soc_unregister_component
);
4193 static int snd_soc_platform_drv_write(struct snd_soc_component
*component
,
4194 unsigned int reg
, unsigned int val
)
4196 struct snd_soc_platform
*platform
= snd_soc_component_to_platform(component
);
4198 return platform
->driver
->write(platform
, reg
, val
);
4201 static int snd_soc_platform_drv_read(struct snd_soc_component
*component
,
4202 unsigned int reg
, unsigned int *val
)
4204 struct snd_soc_platform
*platform
= snd_soc_component_to_platform(component
);
4206 *val
= platform
->driver
->read(platform
, reg
);
4212 * snd_soc_add_platform - Add a platform to the ASoC core
4213 * @dev: The parent device for the platform
4214 * @platform: The platform to add
4215 * @platform_driver: The driver for the platform
4217 int snd_soc_add_platform(struct device
*dev
, struct snd_soc_platform
*platform
,
4218 const struct snd_soc_platform_driver
*platform_drv
)
4222 ret
= snd_soc_component_initialize(&platform
->component
,
4223 &platform_drv
->component_driver
, dev
);
4227 platform
->dev
= dev
;
4228 platform
->driver
= platform_drv
;
4229 if (platform_drv
->write
)
4230 platform
->component
.write
= snd_soc_platform_drv_write
;
4231 if (platform_drv
->read
)
4232 platform
->component
.read
= snd_soc_platform_drv_read
;
4234 mutex_lock(&client_mutex
);
4235 snd_soc_component_add_unlocked(&platform
->component
);
4236 list_add(&platform
->list
, &platform_list
);
4237 mutex_unlock(&client_mutex
);
4239 dev_dbg(dev
, "ASoC: Registered platform '%s'\n",
4240 platform
->component
.name
);
4244 EXPORT_SYMBOL_GPL(snd_soc_add_platform
);
4247 * snd_soc_register_platform - Register a platform with the ASoC core
4249 * @platform: platform to register
4251 int snd_soc_register_platform(struct device
*dev
,
4252 const struct snd_soc_platform_driver
*platform_drv
)
4254 struct snd_soc_platform
*platform
;
4257 dev_dbg(dev
, "ASoC: platform register %s\n", dev_name(dev
));
4259 platform
= kzalloc(sizeof(struct snd_soc_platform
), GFP_KERNEL
);
4260 if (platform
== NULL
)
4263 ret
= snd_soc_add_platform(dev
, platform
, platform_drv
);
4269 EXPORT_SYMBOL_GPL(snd_soc_register_platform
);
4272 * snd_soc_remove_platform - Remove a platform from the ASoC core
4273 * @platform: the platform to remove
4275 void snd_soc_remove_platform(struct snd_soc_platform
*platform
)
4278 mutex_lock(&client_mutex
);
4279 list_del(&platform
->list
);
4280 snd_soc_component_del_unlocked(&platform
->component
);
4281 mutex_unlock(&client_mutex
);
4283 snd_soc_component_cleanup(&platform
->component
);
4285 dev_dbg(platform
->dev
, "ASoC: Unregistered platform '%s'\n",
4286 platform
->component
.name
);
4288 EXPORT_SYMBOL_GPL(snd_soc_remove_platform
);
4290 struct snd_soc_platform
*snd_soc_lookup_platform(struct device
*dev
)
4292 struct snd_soc_platform
*platform
;
4294 list_for_each_entry(platform
, &platform_list
, list
) {
4295 if (dev
== platform
->dev
)
4301 EXPORT_SYMBOL_GPL(snd_soc_lookup_platform
);
4304 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
4306 * @platform: platform to unregister
4308 void snd_soc_unregister_platform(struct device
*dev
)
4310 struct snd_soc_platform
*platform
;
4312 platform
= snd_soc_lookup_platform(dev
);
4316 snd_soc_remove_platform(platform
);
4319 EXPORT_SYMBOL_GPL(snd_soc_unregister_platform
);
4321 static u64 codec_format_map
[] = {
4322 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
,
4323 SNDRV_PCM_FMTBIT_U16_LE
| SNDRV_PCM_FMTBIT_U16_BE
,
4324 SNDRV_PCM_FMTBIT_S24_LE
| SNDRV_PCM_FMTBIT_S24_BE
,
4325 SNDRV_PCM_FMTBIT_U24_LE
| SNDRV_PCM_FMTBIT_U24_BE
,
4326 SNDRV_PCM_FMTBIT_S32_LE
| SNDRV_PCM_FMTBIT_S32_BE
,
4327 SNDRV_PCM_FMTBIT_U32_LE
| SNDRV_PCM_FMTBIT_U32_BE
,
4328 SNDRV_PCM_FMTBIT_S24_3LE
| SNDRV_PCM_FMTBIT_U24_3BE
,
4329 SNDRV_PCM_FMTBIT_U24_3LE
| SNDRV_PCM_FMTBIT_U24_3BE
,
4330 SNDRV_PCM_FMTBIT_S20_3LE
| SNDRV_PCM_FMTBIT_S20_3BE
,
4331 SNDRV_PCM_FMTBIT_U20_3LE
| SNDRV_PCM_FMTBIT_U20_3BE
,
4332 SNDRV_PCM_FMTBIT_S18_3LE
| SNDRV_PCM_FMTBIT_S18_3BE
,
4333 SNDRV_PCM_FMTBIT_U18_3LE
| SNDRV_PCM_FMTBIT_U18_3BE
,
4334 SNDRV_PCM_FMTBIT_FLOAT_LE
| SNDRV_PCM_FMTBIT_FLOAT_BE
,
4335 SNDRV_PCM_FMTBIT_FLOAT64_LE
| SNDRV_PCM_FMTBIT_FLOAT64_BE
,
4336 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
4337 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
,
4340 /* Fix up the DAI formats for endianness: codecs don't actually see
4341 * the endianness of the data but we're using the CPU format
4342 * definitions which do need to include endianness so we ensure that
4343 * codec DAIs always have both big and little endian variants set.
4345 static void fixup_codec_formats(struct snd_soc_pcm_stream
*stream
)
4349 for (i
= 0; i
< ARRAY_SIZE(codec_format_map
); i
++)
4350 if (stream
->formats
& codec_format_map
[i
])
4351 stream
->formats
|= codec_format_map
[i
];
4354 static int snd_soc_codec_drv_write(struct snd_soc_component
*component
,
4355 unsigned int reg
, unsigned int val
)
4357 struct snd_soc_codec
*codec
= snd_soc_component_to_codec(component
);
4359 return codec
->driver
->write(codec
, reg
, val
);
4362 static int snd_soc_codec_drv_read(struct snd_soc_component
*component
,
4363 unsigned int reg
, unsigned int *val
)
4365 struct snd_soc_codec
*codec
= snd_soc_component_to_codec(component
);
4367 *val
= codec
->driver
->read(codec
, reg
);
4372 static int snd_soc_codec_set_bias_level(struct snd_soc_dapm_context
*dapm
,
4373 enum snd_soc_bias_level level
)
4375 struct snd_soc_codec
*codec
= snd_soc_dapm_to_codec(dapm
);
4377 return codec
->driver
->set_bias_level(codec
, level
);
4381 * snd_soc_register_codec - Register a codec with the ASoC core
4383 * @codec: codec to register
4385 int snd_soc_register_codec(struct device
*dev
,
4386 const struct snd_soc_codec_driver
*codec_drv
,
4387 struct snd_soc_dai_driver
*dai_drv
,
4390 struct snd_soc_codec
*codec
;
4391 struct snd_soc_dai
*dai
;
4392 struct regmap
*regmap
;
4395 dev_dbg(dev
, "codec register %s\n", dev_name(dev
));
4397 codec
= kzalloc(sizeof(struct snd_soc_codec
), GFP_KERNEL
);
4401 codec
->component
.dapm_ptr
= &codec
->dapm
;
4403 ret
= snd_soc_component_initialize(&codec
->component
,
4404 &codec_drv
->component_driver
, dev
);
4408 if (codec_drv
->write
)
4409 codec
->component
.write
= snd_soc_codec_drv_write
;
4410 if (codec_drv
->read
)
4411 codec
->component
.read
= snd_soc_codec_drv_read
;
4412 codec
->component
.ignore_pmdown_time
= codec_drv
->ignore_pmdown_time
;
4413 codec
->dapm
.codec
= codec
;
4414 if (codec_drv
->seq_notifier
)
4415 codec
->dapm
.seq_notifier
= codec_drv
->seq_notifier
;
4416 if (codec_drv
->set_bias_level
)
4417 codec
->dapm
.set_bias_level
= snd_soc_codec_set_bias_level
;
4419 codec
->driver
= codec_drv
;
4420 codec
->component
.val_bytes
= codec_drv
->reg_word_size
;
4421 mutex_init(&codec
->mutex
);
4423 if (!codec
->component
.write
) {
4424 if (codec_drv
->get_regmap
)
4425 regmap
= codec_drv
->get_regmap(dev
);
4427 regmap
= dev_get_regmap(dev
, NULL
);
4430 ret
= snd_soc_component_init_io(&codec
->component
,
4434 "Failed to set cache I/O:%d\n",
4441 for (i
= 0; i
< num_dai
; i
++) {
4442 fixup_codec_formats(&dai_drv
[i
].playback
);
4443 fixup_codec_formats(&dai_drv
[i
].capture
);
4446 ret
= snd_soc_register_dais(&codec
->component
, dai_drv
, num_dai
, false);
4448 dev_err(dev
, "ASoC: Failed to regster DAIs: %d\n", ret
);
4452 list_for_each_entry(dai
, &codec
->component
.dai_list
, list
)
4455 mutex_lock(&client_mutex
);
4456 snd_soc_component_add_unlocked(&codec
->component
);
4457 list_add(&codec
->list
, &codec_list
);
4458 mutex_unlock(&client_mutex
);
4460 dev_dbg(codec
->dev
, "ASoC: Registered codec '%s'\n",
4461 codec
->component
.name
);
4465 snd_soc_component_cleanup(&codec
->component
);
4470 EXPORT_SYMBOL_GPL(snd_soc_register_codec
);
4473 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
4475 * @codec: codec to unregister
4477 void snd_soc_unregister_codec(struct device
*dev
)
4479 struct snd_soc_codec
*codec
;
4481 list_for_each_entry(codec
, &codec_list
, list
) {
4482 if (dev
== codec
->dev
)
4489 mutex_lock(&client_mutex
);
4490 list_del(&codec
->list
);
4491 snd_soc_component_del_unlocked(&codec
->component
);
4492 mutex_unlock(&client_mutex
);
4494 dev_dbg(codec
->dev
, "ASoC: Unregistered codec '%s'\n",
4495 codec
->component
.name
);
4497 snd_soc_component_cleanup(&codec
->component
);
4498 snd_soc_cache_exit(codec
);
4501 EXPORT_SYMBOL_GPL(snd_soc_unregister_codec
);
4503 /* Retrieve a card's name from device tree */
4504 int snd_soc_of_parse_card_name(struct snd_soc_card
*card
,
4505 const char *propname
)
4507 struct device_node
*np
= card
->dev
->of_node
;
4510 ret
= of_property_read_string_index(np
, propname
, 0, &card
->name
);
4512 * EINVAL means the property does not exist. This is fine providing
4513 * card->name was previously set, which is checked later in
4514 * snd_soc_register_card.
4516 if (ret
< 0 && ret
!= -EINVAL
) {
4518 "ASoC: Property '%s' could not be read: %d\n",
4525 EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name
);
4527 static const struct snd_soc_dapm_widget simple_widgets
[] = {
4528 SND_SOC_DAPM_MIC("Microphone", NULL
),
4529 SND_SOC_DAPM_LINE("Line", NULL
),
4530 SND_SOC_DAPM_HP("Headphone", NULL
),
4531 SND_SOC_DAPM_SPK("Speaker", NULL
),
4534 int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card
*card
,
4535 const char *propname
)
4537 struct device_node
*np
= card
->dev
->of_node
;
4538 struct snd_soc_dapm_widget
*widgets
;
4539 const char *template, *wname
;
4540 int i
, j
, num_widgets
, ret
;
4542 num_widgets
= of_property_count_strings(np
, propname
);
4543 if (num_widgets
< 0) {
4545 "ASoC: Property '%s' does not exist\n", propname
);
4548 if (num_widgets
& 1) {
4550 "ASoC: Property '%s' length is not even\n", propname
);
4556 dev_err(card
->dev
, "ASoC: Property '%s's length is zero\n",
4561 widgets
= devm_kcalloc(card
->dev
, num_widgets
, sizeof(*widgets
),
4565 "ASoC: Could not allocate memory for widgets\n");
4569 for (i
= 0; i
< num_widgets
; i
++) {
4570 ret
= of_property_read_string_index(np
, propname
,
4574 "ASoC: Property '%s' index %d read error:%d\n",
4575 propname
, 2 * i
, ret
);
4579 for (j
= 0; j
< ARRAY_SIZE(simple_widgets
); j
++) {
4580 if (!strncmp(template, simple_widgets
[j
].name
,
4581 strlen(simple_widgets
[j
].name
))) {
4582 widgets
[i
] = simple_widgets
[j
];
4587 if (j
>= ARRAY_SIZE(simple_widgets
)) {
4589 "ASoC: DAPM widget '%s' is not supported\n",
4594 ret
= of_property_read_string_index(np
, propname
,
4599 "ASoC: Property '%s' index %d read error:%d\n",
4600 propname
, (2 * i
) + 1, ret
);
4604 widgets
[i
].name
= wname
;
4607 card
->dapm_widgets
= widgets
;
4608 card
->num_dapm_widgets
= num_widgets
;
4612 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets
);
4614 int snd_soc_of_parse_tdm_slot(struct device_node
*np
,
4615 unsigned int *slots
,
4616 unsigned int *slot_width
)
4621 if (of_property_read_bool(np
, "dai-tdm-slot-num")) {
4622 ret
= of_property_read_u32(np
, "dai-tdm-slot-num", &val
);
4630 if (of_property_read_bool(np
, "dai-tdm-slot-width")) {
4631 ret
= of_property_read_u32(np
, "dai-tdm-slot-width", &val
);
4641 EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot
);
4643 int snd_soc_of_parse_audio_routing(struct snd_soc_card
*card
,
4644 const char *propname
)
4646 struct device_node
*np
= card
->dev
->of_node
;
4648 struct snd_soc_dapm_route
*routes
;
4651 num_routes
= of_property_count_strings(np
, propname
);
4652 if (num_routes
< 0 || num_routes
& 1) {
4654 "ASoC: Property '%s' does not exist or its length is not even\n",
4660 dev_err(card
->dev
, "ASoC: Property '%s's length is zero\n",
4665 routes
= devm_kzalloc(card
->dev
, num_routes
* sizeof(*routes
),
4669 "ASoC: Could not allocate DAPM route table\n");
4673 for (i
= 0; i
< num_routes
; i
++) {
4674 ret
= of_property_read_string_index(np
, propname
,
4675 2 * i
, &routes
[i
].sink
);
4678 "ASoC: Property '%s' index %d could not be read: %d\n",
4679 propname
, 2 * i
, ret
);
4682 ret
= of_property_read_string_index(np
, propname
,
4683 (2 * i
) + 1, &routes
[i
].source
);
4686 "ASoC: Property '%s' index %d could not be read: %d\n",
4687 propname
, (2 * i
) + 1, ret
);
4692 card
->num_dapm_routes
= num_routes
;
4693 card
->dapm_routes
= routes
;
4697 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing
);
4699 unsigned int snd_soc_of_parse_daifmt(struct device_node
*np
,
4701 struct device_node
**bitclkmaster
,
4702 struct device_node
**framemaster
)
4706 unsigned int format
= 0;
4712 } of_fmt_table
[] = {
4713 { "i2s", SND_SOC_DAIFMT_I2S
},
4714 { "right_j", SND_SOC_DAIFMT_RIGHT_J
},
4715 { "left_j", SND_SOC_DAIFMT_LEFT_J
},
4716 { "dsp_a", SND_SOC_DAIFMT_DSP_A
},
4717 { "dsp_b", SND_SOC_DAIFMT_DSP_B
},
4718 { "ac97", SND_SOC_DAIFMT_AC97
},
4719 { "pdm", SND_SOC_DAIFMT_PDM
},
4720 { "msb", SND_SOC_DAIFMT_MSB
},
4721 { "lsb", SND_SOC_DAIFMT_LSB
},
4728 * check "[prefix]format = xxx"
4729 * SND_SOC_DAIFMT_FORMAT_MASK area
4731 snprintf(prop
, sizeof(prop
), "%sformat", prefix
);
4732 ret
= of_property_read_string(np
, prop
, &str
);
4734 for (i
= 0; i
< ARRAY_SIZE(of_fmt_table
); i
++) {
4735 if (strcmp(str
, of_fmt_table
[i
].name
) == 0) {
4736 format
|= of_fmt_table
[i
].val
;
4743 * check "[prefix]continuous-clock"
4744 * SND_SOC_DAIFMT_CLOCK_MASK area
4746 snprintf(prop
, sizeof(prop
), "%scontinuous-clock", prefix
);
4747 if (of_get_property(np
, prop
, NULL
))
4748 format
|= SND_SOC_DAIFMT_CONT
;
4750 format
|= SND_SOC_DAIFMT_GATED
;
4753 * check "[prefix]bitclock-inversion"
4754 * check "[prefix]frame-inversion"
4755 * SND_SOC_DAIFMT_INV_MASK area
4757 snprintf(prop
, sizeof(prop
), "%sbitclock-inversion", prefix
);
4758 bit
= !!of_get_property(np
, prop
, NULL
);
4760 snprintf(prop
, sizeof(prop
), "%sframe-inversion", prefix
);
4761 frame
= !!of_get_property(np
, prop
, NULL
);
4763 switch ((bit
<< 4) + frame
) {
4765 format
|= SND_SOC_DAIFMT_IB_IF
;
4768 format
|= SND_SOC_DAIFMT_IB_NF
;
4771 format
|= SND_SOC_DAIFMT_NB_IF
;
4774 /* SND_SOC_DAIFMT_NB_NF is default */
4779 * check "[prefix]bitclock-master"
4780 * check "[prefix]frame-master"
4781 * SND_SOC_DAIFMT_MASTER_MASK area
4783 snprintf(prop
, sizeof(prop
), "%sbitclock-master", prefix
);
4784 bit
= !!of_get_property(np
, prop
, NULL
);
4785 if (bit
&& bitclkmaster
)
4786 *bitclkmaster
= of_parse_phandle(np
, prop
, 0);
4788 snprintf(prop
, sizeof(prop
), "%sframe-master", prefix
);
4789 frame
= !!of_get_property(np
, prop
, NULL
);
4790 if (frame
&& framemaster
)
4791 *framemaster
= of_parse_phandle(np
, prop
, 0);
4793 switch ((bit
<< 4) + frame
) {
4795 format
|= SND_SOC_DAIFMT_CBM_CFM
;
4798 format
|= SND_SOC_DAIFMT_CBM_CFS
;
4801 format
|= SND_SOC_DAIFMT_CBS_CFM
;
4804 format
|= SND_SOC_DAIFMT_CBS_CFS
;
4810 EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt
);
4812 int snd_soc_of_get_dai_name(struct device_node
*of_node
,
4813 const char **dai_name
)
4815 struct snd_soc_component
*pos
;
4816 struct of_phandle_args args
;
4819 ret
= of_parse_phandle_with_args(of_node
, "sound-dai",
4820 "#sound-dai-cells", 0, &args
);
4824 ret
= -EPROBE_DEFER
;
4826 mutex_lock(&client_mutex
);
4827 list_for_each_entry(pos
, &component_list
, list
) {
4828 if (pos
->dev
->of_node
!= args
.np
)
4831 if (pos
->driver
->of_xlate_dai_name
) {
4832 ret
= pos
->driver
->of_xlate_dai_name(pos
, &args
, dai_name
);
4836 switch (args
.args_count
) {
4838 id
= 0; /* same as dai_drv[0] */
4848 if (id
< 0 || id
>= pos
->num_dai
) {
4855 *dai_name
= pos
->dai_drv
[id
].name
;
4857 *dai_name
= pos
->name
;
4862 mutex_unlock(&client_mutex
);
4864 of_node_put(args
.np
);
4868 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name
);
4870 static int __init
snd_soc_init(void)
4872 #ifdef CONFIG_DEBUG_FS
4873 snd_soc_debugfs_root
= debugfs_create_dir("asoc", NULL
);
4874 if (IS_ERR(snd_soc_debugfs_root
) || !snd_soc_debugfs_root
) {
4875 pr_warn("ASoC: Failed to create debugfs directory\n");
4876 snd_soc_debugfs_root
= NULL
;
4879 if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root
, NULL
,
4881 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
4883 if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root
, NULL
,
4885 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
4887 if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root
, NULL
,
4888 &platform_list_fops
))
4889 pr_warn("ASoC: Failed to create platform list debugfs file\n");
4892 snd_soc_util_init();
4894 return platform_driver_register(&soc_driver
);
4896 module_init(snd_soc_init
);
4898 static void __exit
snd_soc_exit(void)
4900 snd_soc_util_exit();
4902 #ifdef CONFIG_DEBUG_FS
4903 debugfs_remove_recursive(snd_soc_debugfs_root
);
4905 platform_driver_unregister(&soc_driver
);
4907 module_exit(snd_soc_exit
);
4909 /* Module information */
4910 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
4911 MODULE_DESCRIPTION("ALSA SoC Core");
4912 MODULE_LICENSE("GPL");
4913 MODULE_ALIAS("platform:soc-audio");