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(dai_list
);
60 static LIST_HEAD(platform_list
);
61 static LIST_HEAD(codec_list
);
62 static LIST_HEAD(component_list
);
65 * This is a timeout to do a DAPM powerdown after a stream is closed().
66 * It can be used to eliminate pops between different playback streams, e.g.
67 * between two audio tracks.
69 static int pmdown_time
= 5000;
70 module_param(pmdown_time
, int, 0);
71 MODULE_PARM_DESC(pmdown_time
, "DAPM stream powerdown time (msecs)");
73 struct snd_ac97_reset_cfg
{
75 struct pinctrl_state
*pstate_reset
;
76 struct pinctrl_state
*pstate_warm_reset
;
77 struct pinctrl_state
*pstate_run
;
83 /* returns the minimum number of bytes needed to represent
84 * a particular given value */
85 static int min_bytes_needed(unsigned long val
)
90 for (i
= (sizeof val
* 8) - 1; i
>= 0; --i
, ++c
)
93 c
= (sizeof val
* 8) - c
;
101 /* fill buf which is 'len' bytes with a formatted
102 * string of the form 'reg: value\n' */
103 static int format_register_str(struct snd_soc_codec
*codec
,
104 unsigned int reg
, char *buf
, size_t len
)
106 int wordsize
= min_bytes_needed(codec
->driver
->reg_cache_size
) * 2;
107 int regsize
= codec
->driver
->reg_word_size
* 2;
109 char tmpbuf
[len
+ 1];
110 char regbuf
[regsize
+ 1];
112 /* since tmpbuf is allocated on the stack, warn the callers if they
113 * try to abuse this function */
116 /* +2 for ': ' and + 1 for '\n' */
117 if (wordsize
+ regsize
+ 2 + 1 != len
)
120 ret
= snd_soc_read(codec
, reg
);
122 memset(regbuf
, 'X', regsize
);
123 regbuf
[regsize
] = '\0';
125 snprintf(regbuf
, regsize
+ 1, "%.*x", regsize
, ret
);
128 /* prepare the buffer */
129 snprintf(tmpbuf
, len
+ 1, "%.*x: %s\n", wordsize
, reg
, regbuf
);
130 /* copy it back to the caller without the '\0' */
131 memcpy(buf
, tmpbuf
, len
);
136 /* codec register dump */
137 static ssize_t
soc_codec_reg_show(struct snd_soc_codec
*codec
, char *buf
,
138 size_t count
, loff_t pos
)
141 int wordsize
, regsize
;
146 wordsize
= min_bytes_needed(codec
->driver
->reg_cache_size
) * 2;
147 regsize
= codec
->driver
->reg_word_size
* 2;
149 len
= wordsize
+ regsize
+ 2 + 1;
151 if (!codec
->driver
->reg_cache_size
)
154 if (codec
->driver
->reg_cache_step
)
155 step
= codec
->driver
->reg_cache_step
;
157 for (i
= 0; i
< codec
->driver
->reg_cache_size
; i
+= step
) {
158 if (!snd_soc_codec_readable_register(codec
, i
))
160 if (codec
->driver
->display_register
) {
161 count
+= codec
->driver
->display_register(codec
, buf
+ count
,
162 PAGE_SIZE
- count
, i
);
164 /* only support larger than PAGE_SIZE bytes debugfs
165 * entries for the default case */
167 if (total
+ len
>= count
- 1)
169 format_register_str(codec
, i
, buf
+ total
, len
);
176 total
= min(total
, count
- 1);
181 static ssize_t
codec_reg_show(struct device
*dev
,
182 struct device_attribute
*attr
, char *buf
)
184 struct snd_soc_pcm_runtime
*rtd
= dev_get_drvdata(dev
);
186 return soc_codec_reg_show(rtd
->codec
, buf
, PAGE_SIZE
, 0);
189 static DEVICE_ATTR(codec_reg
, 0444, codec_reg_show
, NULL
);
191 static ssize_t
pmdown_time_show(struct device
*dev
,
192 struct device_attribute
*attr
, char *buf
)
194 struct snd_soc_pcm_runtime
*rtd
= dev_get_drvdata(dev
);
196 return sprintf(buf
, "%ld\n", rtd
->pmdown_time
);
199 static ssize_t
pmdown_time_set(struct device
*dev
,
200 struct device_attribute
*attr
,
201 const char *buf
, size_t count
)
203 struct snd_soc_pcm_runtime
*rtd
= dev_get_drvdata(dev
);
206 ret
= kstrtol(buf
, 10, &rtd
->pmdown_time
);
213 static DEVICE_ATTR(pmdown_time
, 0644, pmdown_time_show
, pmdown_time_set
);
215 #ifdef CONFIG_DEBUG_FS
216 static ssize_t
codec_reg_read_file(struct file
*file
, char __user
*user_buf
,
217 size_t count
, loff_t
*ppos
)
220 struct snd_soc_codec
*codec
= file
->private_data
;
223 if (*ppos
< 0 || !count
)
226 buf
= kmalloc(count
, GFP_KERNEL
);
230 ret
= soc_codec_reg_show(codec
, buf
, count
, *ppos
);
232 if (copy_to_user(user_buf
, buf
, ret
)) {
243 static ssize_t
codec_reg_write_file(struct file
*file
,
244 const char __user
*user_buf
, size_t count
, loff_t
*ppos
)
249 unsigned long reg
, value
;
250 struct snd_soc_codec
*codec
= file
->private_data
;
253 buf_size
= min(count
, (sizeof(buf
)-1));
254 if (copy_from_user(buf
, user_buf
, buf_size
))
258 while (*start
== ' ')
260 reg
= simple_strtoul(start
, &start
, 16);
261 while (*start
== ' ')
263 ret
= kstrtoul(start
, 16, &value
);
267 /* Userspace has been fiddling around behind the kernel's back */
268 add_taint(TAINT_USER
, LOCKDEP_NOW_UNRELIABLE
);
270 snd_soc_write(codec
, reg
, value
);
274 static const struct file_operations codec_reg_fops
= {
276 .read
= codec_reg_read_file
,
277 .write
= codec_reg_write_file
,
278 .llseek
= default_llseek
,
281 static void soc_init_codec_debugfs(struct snd_soc_codec
*codec
)
283 struct dentry
*debugfs_card_root
= codec
->card
->debugfs_card_root
;
285 codec
->debugfs_codec_root
= debugfs_create_dir(codec
->name
,
287 if (!codec
->debugfs_codec_root
) {
289 "ASoC: Failed to create codec debugfs directory\n");
293 debugfs_create_bool("cache_sync", 0444, codec
->debugfs_codec_root
,
295 debugfs_create_bool("cache_only", 0444, codec
->debugfs_codec_root
,
298 codec
->debugfs_reg
= debugfs_create_file("codec_reg", 0644,
299 codec
->debugfs_codec_root
,
300 codec
, &codec_reg_fops
);
301 if (!codec
->debugfs_reg
)
303 "ASoC: Failed to create codec register debugfs file\n");
305 snd_soc_dapm_debugfs_init(&codec
->dapm
, codec
->debugfs_codec_root
);
308 static void soc_cleanup_codec_debugfs(struct snd_soc_codec
*codec
)
310 debugfs_remove_recursive(codec
->debugfs_codec_root
);
313 static void soc_init_platform_debugfs(struct snd_soc_platform
*platform
)
315 struct dentry
*debugfs_card_root
= platform
->card
->debugfs_card_root
;
317 platform
->debugfs_platform_root
= debugfs_create_dir(platform
->name
,
319 if (!platform
->debugfs_platform_root
) {
320 dev_warn(platform
->dev
,
321 "ASoC: Failed to create platform debugfs directory\n");
325 snd_soc_dapm_debugfs_init(&platform
->dapm
,
326 platform
->debugfs_platform_root
);
329 static void soc_cleanup_platform_debugfs(struct snd_soc_platform
*platform
)
331 debugfs_remove_recursive(platform
->debugfs_platform_root
);
334 static ssize_t
codec_list_read_file(struct file
*file
, char __user
*user_buf
,
335 size_t count
, loff_t
*ppos
)
337 char *buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
338 ssize_t len
, ret
= 0;
339 struct snd_soc_codec
*codec
;
344 list_for_each_entry(codec
, &codec_list
, list
) {
345 len
= snprintf(buf
+ ret
, PAGE_SIZE
- ret
, "%s\n",
349 if (ret
> PAGE_SIZE
) {
356 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, ret
);
363 static const struct file_operations codec_list_fops
= {
364 .read
= codec_list_read_file
,
365 .llseek
= default_llseek
,/* read accesses f_pos */
368 static ssize_t
dai_list_read_file(struct file
*file
, char __user
*user_buf
,
369 size_t count
, loff_t
*ppos
)
371 char *buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
372 ssize_t len
, ret
= 0;
373 struct snd_soc_dai
*dai
;
378 list_for_each_entry(dai
, &dai_list
, list
) {
379 len
= snprintf(buf
+ ret
, PAGE_SIZE
- ret
, "%s\n", dai
->name
);
382 if (ret
> PAGE_SIZE
) {
388 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, ret
);
395 static const struct file_operations dai_list_fops
= {
396 .read
= dai_list_read_file
,
397 .llseek
= default_llseek
,/* read accesses f_pos */
400 static ssize_t
platform_list_read_file(struct file
*file
,
401 char __user
*user_buf
,
402 size_t count
, loff_t
*ppos
)
404 char *buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
405 ssize_t len
, ret
= 0;
406 struct snd_soc_platform
*platform
;
411 list_for_each_entry(platform
, &platform_list
, list
) {
412 len
= snprintf(buf
+ ret
, PAGE_SIZE
- ret
, "%s\n",
416 if (ret
> PAGE_SIZE
) {
422 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, ret
);
429 static const struct file_operations platform_list_fops
= {
430 .read
= platform_list_read_file
,
431 .llseek
= default_llseek
,/* read accesses f_pos */
434 static void soc_init_card_debugfs(struct snd_soc_card
*card
)
436 card
->debugfs_card_root
= debugfs_create_dir(card
->name
,
437 snd_soc_debugfs_root
);
438 if (!card
->debugfs_card_root
) {
440 "ASoC: Failed to create card debugfs directory\n");
444 card
->debugfs_pop_time
= debugfs_create_u32("dapm_pop_time", 0644,
445 card
->debugfs_card_root
,
447 if (!card
->debugfs_pop_time
)
449 "ASoC: Failed to create pop time debugfs file\n");
452 static void soc_cleanup_card_debugfs(struct snd_soc_card
*card
)
454 debugfs_remove_recursive(card
->debugfs_card_root
);
459 static inline void soc_init_codec_debugfs(struct snd_soc_codec
*codec
)
463 static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec
*codec
)
467 static inline void soc_init_platform_debugfs(struct snd_soc_platform
*platform
)
471 static inline void soc_cleanup_platform_debugfs(struct snd_soc_platform
*platform
)
475 static inline void soc_init_card_debugfs(struct snd_soc_card
*card
)
479 static inline void soc_cleanup_card_debugfs(struct snd_soc_card
*card
)
484 struct snd_pcm_substream
*snd_soc_get_dai_substream(struct snd_soc_card
*card
,
485 const char *dai_link
, int stream
)
489 for (i
= 0; i
< card
->num_links
; i
++) {
490 if (card
->rtd
[i
].dai_link
->no_pcm
&&
491 !strcmp(card
->rtd
[i
].dai_link
->name
, dai_link
))
492 return card
->rtd
[i
].pcm
->streams
[stream
].substream
;
494 dev_dbg(card
->dev
, "ASoC: failed to find dai link %s\n", dai_link
);
497 EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream
);
499 struct snd_soc_pcm_runtime
*snd_soc_get_pcm_runtime(struct snd_soc_card
*card
,
500 const char *dai_link
)
504 for (i
= 0; i
< card
->num_links
; i
++) {
505 if (!strcmp(card
->rtd
[i
].dai_link
->name
, dai_link
))
506 return &card
->rtd
[i
];
508 dev_dbg(card
->dev
, "ASoC: failed to find rtd %s\n", dai_link
);
511 EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime
);
513 #ifdef CONFIG_SND_SOC_AC97_BUS
514 /* unregister ac97 codec */
515 static int soc_ac97_dev_unregister(struct snd_soc_codec
*codec
)
517 if (codec
->ac97
->dev
.bus
)
518 device_unregister(&codec
->ac97
->dev
);
522 /* stop no dev release warning */
523 static void soc_ac97_device_release(struct device
*dev
){}
525 /* register ac97 codec to bus */
526 static int soc_ac97_dev_register(struct snd_soc_codec
*codec
)
530 codec
->ac97
->dev
.bus
= &ac97_bus_type
;
531 codec
->ac97
->dev
.parent
= codec
->card
->dev
;
532 codec
->ac97
->dev
.release
= soc_ac97_device_release
;
534 dev_set_name(&codec
->ac97
->dev
, "%d-%d:%s",
535 codec
->card
->snd_card
->number
, 0, codec
->name
);
536 err
= device_register(&codec
->ac97
->dev
);
538 dev_err(codec
->dev
, "ASoC: Can't register ac97 bus\n");
539 codec
->ac97
->dev
.bus
= NULL
;
546 static void codec2codec_close_delayed_work(struct work_struct
*work
)
548 /* Currently nothing to do for c2c links
549 * Since c2c links are internal nodes in the DAPM graph and
550 * don't interface with the outside world or application layer
551 * we don't have to do any special handling on close.
555 #ifdef CONFIG_PM_SLEEP
556 /* powers down audio subsystem for suspend */
557 int snd_soc_suspend(struct device
*dev
)
559 struct snd_soc_card
*card
= dev_get_drvdata(dev
);
560 struct snd_soc_codec
*codec
;
563 /* If the initialization of this soc device failed, there is no codec
564 * associated with it. Just bail out in this case.
566 if (list_empty(&card
->codec_dev_list
))
569 /* Due to the resume being scheduled into a workqueue we could
570 * suspend before that's finished - wait for it to complete.
572 snd_power_lock(card
->snd_card
);
573 snd_power_wait(card
->snd_card
, SNDRV_CTL_POWER_D0
);
574 snd_power_unlock(card
->snd_card
);
576 /* we're going to block userspace touching us until resume completes */
577 snd_power_change_state(card
->snd_card
, SNDRV_CTL_POWER_D3hot
);
579 /* mute any active DACs */
580 for (i
= 0; i
< card
->num_rtd
; i
++) {
581 struct snd_soc_dai
*dai
= card
->rtd
[i
].codec_dai
;
582 struct snd_soc_dai_driver
*drv
= dai
->driver
;
584 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
587 if (drv
->ops
->digital_mute
&& dai
->playback_active
)
588 drv
->ops
->digital_mute(dai
, 1);
591 /* suspend all pcms */
592 for (i
= 0; i
< card
->num_rtd
; i
++) {
593 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
596 snd_pcm_suspend_all(card
->rtd
[i
].pcm
);
599 if (card
->suspend_pre
)
600 card
->suspend_pre(card
);
602 for (i
= 0; i
< card
->num_rtd
; i
++) {
603 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
604 struct snd_soc_platform
*platform
= card
->rtd
[i
].platform
;
606 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
609 if (cpu_dai
->driver
->suspend
&& !cpu_dai
->driver
->ac97_control
)
610 cpu_dai
->driver
->suspend(cpu_dai
);
611 if (platform
->driver
->suspend
&& !platform
->suspended
) {
612 platform
->driver
->suspend(cpu_dai
);
613 platform
->suspended
= 1;
617 /* close any waiting streams and save state */
618 for (i
= 0; i
< card
->num_rtd
; i
++) {
619 flush_delayed_work(&card
->rtd
[i
].delayed_work
);
620 card
->rtd
[i
].codec
->dapm
.suspend_bias_level
= card
->rtd
[i
].codec
->dapm
.bias_level
;
623 for (i
= 0; i
< card
->num_rtd
; i
++) {
625 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
628 snd_soc_dapm_stream_event(&card
->rtd
[i
],
629 SNDRV_PCM_STREAM_PLAYBACK
,
630 SND_SOC_DAPM_STREAM_SUSPEND
);
632 snd_soc_dapm_stream_event(&card
->rtd
[i
],
633 SNDRV_PCM_STREAM_CAPTURE
,
634 SND_SOC_DAPM_STREAM_SUSPEND
);
637 /* Recheck all analogue paths too */
638 dapm_mark_io_dirty(&card
->dapm
);
639 snd_soc_dapm_sync(&card
->dapm
);
641 /* suspend all CODECs */
642 list_for_each_entry(codec
, &card
->codec_dev_list
, card_list
) {
643 /* If there are paths active then the CODEC will be held with
644 * bias _ON and should not be suspended. */
645 if (!codec
->suspended
&& codec
->driver
->suspend
) {
646 switch (codec
->dapm
.bias_level
) {
647 case SND_SOC_BIAS_STANDBY
:
649 * If the CODEC is capable of idle
650 * bias off then being in STANDBY
651 * means it's doing something,
652 * otherwise fall through.
654 if (codec
->dapm
.idle_bias_off
) {
656 "ASoC: idle_bias_off CODEC on over suspend\n");
659 case SND_SOC_BIAS_OFF
:
660 codec
->driver
->suspend(codec
);
661 codec
->suspended
= 1;
662 codec
->cache_sync
= 1;
663 if (codec
->using_regmap
)
664 regcache_mark_dirty(codec
->control_data
);
665 /* deactivate pins to sleep state */
666 pinctrl_pm_select_sleep_state(codec
->dev
);
670 "ASoC: CODEC is on over suspend\n");
676 for (i
= 0; i
< card
->num_rtd
; i
++) {
677 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
679 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
682 if (cpu_dai
->driver
->suspend
&& cpu_dai
->driver
->ac97_control
)
683 cpu_dai
->driver
->suspend(cpu_dai
);
685 /* deactivate pins to sleep state */
686 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
689 if (card
->suspend_post
)
690 card
->suspend_post(card
);
694 EXPORT_SYMBOL_GPL(snd_soc_suspend
);
696 /* deferred resume work, so resume can complete before we finished
697 * setting our codec back up, which can be very slow on I2C
699 static void soc_resume_deferred(struct work_struct
*work
)
701 struct snd_soc_card
*card
=
702 container_of(work
, struct snd_soc_card
, deferred_resume_work
);
703 struct snd_soc_codec
*codec
;
706 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
707 * so userspace apps are blocked from touching us
710 dev_dbg(card
->dev
, "ASoC: starting resume work\n");
712 /* Bring us up into D2 so that DAPM starts enabling things */
713 snd_power_change_state(card
->snd_card
, SNDRV_CTL_POWER_D2
);
715 if (card
->resume_pre
)
716 card
->resume_pre(card
);
718 /* resume AC97 DAIs */
719 for (i
= 0; i
< card
->num_rtd
; i
++) {
720 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
722 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
725 if (cpu_dai
->driver
->resume
&& cpu_dai
->driver
->ac97_control
)
726 cpu_dai
->driver
->resume(cpu_dai
);
729 list_for_each_entry(codec
, &card
->codec_dev_list
, card_list
) {
730 /* If the CODEC was idle over suspend then it will have been
731 * left with bias OFF or STANDBY and suspended so we must now
732 * resume. Otherwise the suspend was suppressed.
734 if (codec
->driver
->resume
&& codec
->suspended
) {
735 switch (codec
->dapm
.bias_level
) {
736 case SND_SOC_BIAS_STANDBY
:
737 case SND_SOC_BIAS_OFF
:
738 codec
->driver
->resume(codec
);
739 codec
->suspended
= 0;
743 "ASoC: CODEC was on over suspend\n");
749 for (i
= 0; i
< card
->num_rtd
; i
++) {
751 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
754 snd_soc_dapm_stream_event(&card
->rtd
[i
],
755 SNDRV_PCM_STREAM_PLAYBACK
,
756 SND_SOC_DAPM_STREAM_RESUME
);
758 snd_soc_dapm_stream_event(&card
->rtd
[i
],
759 SNDRV_PCM_STREAM_CAPTURE
,
760 SND_SOC_DAPM_STREAM_RESUME
);
763 /* unmute any active DACs */
764 for (i
= 0; i
< card
->num_rtd
; i
++) {
765 struct snd_soc_dai
*dai
= card
->rtd
[i
].codec_dai
;
766 struct snd_soc_dai_driver
*drv
= dai
->driver
;
768 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
771 if (drv
->ops
->digital_mute
&& dai
->playback_active
)
772 drv
->ops
->digital_mute(dai
, 0);
775 for (i
= 0; i
< card
->num_rtd
; i
++) {
776 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
777 struct snd_soc_platform
*platform
= card
->rtd
[i
].platform
;
779 if (card
->rtd
[i
].dai_link
->ignore_suspend
)
782 if (cpu_dai
->driver
->resume
&& !cpu_dai
->driver
->ac97_control
)
783 cpu_dai
->driver
->resume(cpu_dai
);
784 if (platform
->driver
->resume
&& platform
->suspended
) {
785 platform
->driver
->resume(cpu_dai
);
786 platform
->suspended
= 0;
790 if (card
->resume_post
)
791 card
->resume_post(card
);
793 dev_dbg(card
->dev
, "ASoC: resume work completed\n");
795 /* userspace can access us now we are back as we were before */
796 snd_power_change_state(card
->snd_card
, SNDRV_CTL_POWER_D0
);
798 /* Recheck all analogue paths too */
799 dapm_mark_io_dirty(&card
->dapm
);
800 snd_soc_dapm_sync(&card
->dapm
);
803 /* powers up audio subsystem after a suspend */
804 int snd_soc_resume(struct device
*dev
)
806 struct snd_soc_card
*card
= dev_get_drvdata(dev
);
807 int i
, ac97_control
= 0;
809 /* If the initialization of this soc device failed, there is no codec
810 * associated with it. Just bail out in this case.
812 if (list_empty(&card
->codec_dev_list
))
815 /* activate pins from sleep state */
816 for (i
= 0; i
< card
->num_rtd
; i
++) {
817 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
818 struct snd_soc_dai
*codec_dai
= card
->rtd
[i
].codec_dai
;
820 pinctrl_pm_select_default_state(cpu_dai
->dev
);
821 if (codec_dai
->active
)
822 pinctrl_pm_select_default_state(codec_dai
->dev
);
825 /* AC97 devices might have other drivers hanging off them so
826 * need to resume immediately. Other drivers don't have that
827 * problem and may take a substantial amount of time to resume
828 * due to I/O costs and anti-pop so handle them out of line.
830 for (i
= 0; i
< card
->num_rtd
; i
++) {
831 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
832 ac97_control
|= cpu_dai
->driver
->ac97_control
;
835 dev_dbg(dev
, "ASoC: Resuming AC97 immediately\n");
836 soc_resume_deferred(&card
->deferred_resume_work
);
838 dev_dbg(dev
, "ASoC: Scheduling resume work\n");
839 if (!schedule_work(&card
->deferred_resume_work
))
840 dev_err(dev
, "ASoC: resume work item may be lost\n");
845 EXPORT_SYMBOL_GPL(snd_soc_resume
);
847 #define snd_soc_suspend NULL
848 #define snd_soc_resume NULL
851 static const struct snd_soc_dai_ops null_dai_ops
= {
854 static int soc_bind_dai_link(struct snd_soc_card
*card
, int num
)
856 struct snd_soc_dai_link
*dai_link
= &card
->dai_link
[num
];
857 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[num
];
858 struct snd_soc_codec
*codec
;
859 struct snd_soc_platform
*platform
;
860 struct snd_soc_dai
*codec_dai
, *cpu_dai
;
861 const char *platform_name
;
863 dev_dbg(card
->dev
, "ASoC: binding %s at idx %d\n", dai_link
->name
, num
);
865 /* Find CPU DAI from registered DAIs*/
866 list_for_each_entry(cpu_dai
, &dai_list
, list
) {
867 if (dai_link
->cpu_of_node
&&
868 (cpu_dai
->dev
->of_node
!= dai_link
->cpu_of_node
))
870 if (dai_link
->cpu_name
&&
871 strcmp(dev_name(cpu_dai
->dev
), dai_link
->cpu_name
))
873 if (dai_link
->cpu_dai_name
&&
874 strcmp(cpu_dai
->name
, dai_link
->cpu_dai_name
))
877 rtd
->cpu_dai
= cpu_dai
;
881 dev_err(card
->dev
, "ASoC: CPU DAI %s not registered\n",
882 dai_link
->cpu_dai_name
);
883 return -EPROBE_DEFER
;
886 /* Find CODEC from registered CODECs */
887 list_for_each_entry(codec
, &codec_list
, list
) {
888 if (dai_link
->codec_of_node
) {
889 if (codec
->dev
->of_node
!= dai_link
->codec_of_node
)
892 if (strcmp(codec
->name
, dai_link
->codec_name
))
899 * CODEC found, so find CODEC DAI from registered DAIs from
902 list_for_each_entry(codec_dai
, &dai_list
, list
) {
903 if (codec
->dev
== codec_dai
->dev
&&
904 !strcmp(codec_dai
->name
,
905 dai_link
->codec_dai_name
)) {
907 rtd
->codec_dai
= codec_dai
;
911 if (!rtd
->codec_dai
) {
912 dev_err(card
->dev
, "ASoC: CODEC DAI %s not registered\n",
913 dai_link
->codec_dai_name
);
914 return -EPROBE_DEFER
;
919 dev_err(card
->dev
, "ASoC: CODEC %s not registered\n",
920 dai_link
->codec_name
);
921 return -EPROBE_DEFER
;
924 /* if there's no platform we match on the empty platform */
925 platform_name
= dai_link
->platform_name
;
926 if (!platform_name
&& !dai_link
->platform_of_node
)
927 platform_name
= "snd-soc-dummy";
929 /* find one from the set of registered platforms */
930 list_for_each_entry(platform
, &platform_list
, list
) {
931 if (dai_link
->platform_of_node
) {
932 if (platform
->dev
->of_node
!=
933 dai_link
->platform_of_node
)
936 if (strcmp(platform
->name
, platform_name
))
940 rtd
->platform
= platform
;
942 if (!rtd
->platform
) {
943 dev_err(card
->dev
, "ASoC: platform %s not registered\n",
944 dai_link
->platform_name
);
945 return -EPROBE_DEFER
;
953 static int soc_remove_platform(struct snd_soc_platform
*platform
)
957 if (platform
->driver
->remove
) {
958 ret
= platform
->driver
->remove(platform
);
960 dev_err(platform
->dev
, "ASoC: failed to remove %d\n",
964 /* Make sure all DAPM widgets are freed */
965 snd_soc_dapm_free(&platform
->dapm
);
967 soc_cleanup_platform_debugfs(platform
);
968 platform
->probed
= 0;
969 list_del(&platform
->card_list
);
970 module_put(platform
->dev
->driver
->owner
);
975 static void soc_remove_codec(struct snd_soc_codec
*codec
)
979 if (codec
->driver
->remove
) {
980 err
= codec
->driver
->remove(codec
);
982 dev_err(codec
->dev
, "ASoC: failed to remove %d\n", err
);
985 /* Make sure all DAPM widgets are freed */
986 snd_soc_dapm_free(&codec
->dapm
);
988 soc_cleanup_codec_debugfs(codec
);
990 list_del(&codec
->card_list
);
991 module_put(codec
->dev
->driver
->owner
);
994 static void soc_remove_link_dais(struct snd_soc_card
*card
, int num
, int order
)
996 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[num
];
997 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
, *cpu_dai
= rtd
->cpu_dai
;
1000 /* unregister the rtd device */
1001 if (rtd
->dev_registered
) {
1002 device_remove_file(rtd
->dev
, &dev_attr_pmdown_time
);
1003 device_remove_file(rtd
->dev
, &dev_attr_codec_reg
);
1004 device_unregister(rtd
->dev
);
1005 rtd
->dev_registered
= 0;
1008 /* remove the CODEC DAI */
1009 if (codec_dai
&& codec_dai
->probed
&&
1010 codec_dai
->driver
->remove_order
== order
) {
1011 if (codec_dai
->driver
->remove
) {
1012 err
= codec_dai
->driver
->remove(codec_dai
);
1014 dev_err(codec_dai
->dev
,
1015 "ASoC: failed to remove %s: %d\n",
1016 codec_dai
->name
, err
);
1018 codec_dai
->probed
= 0;
1019 list_del(&codec_dai
->card_list
);
1022 /* remove the cpu_dai */
1023 if (cpu_dai
&& cpu_dai
->probed
&&
1024 cpu_dai
->driver
->remove_order
== order
) {
1025 if (cpu_dai
->driver
->remove
) {
1026 err
= cpu_dai
->driver
->remove(cpu_dai
);
1028 dev_err(cpu_dai
->dev
,
1029 "ASoC: failed to remove %s: %d\n",
1030 cpu_dai
->name
, err
);
1032 cpu_dai
->probed
= 0;
1033 list_del(&cpu_dai
->card_list
);
1035 if (!cpu_dai
->codec
) {
1036 snd_soc_dapm_free(&cpu_dai
->dapm
);
1037 module_put(cpu_dai
->dev
->driver
->owner
);
1042 static void soc_remove_link_components(struct snd_soc_card
*card
, int num
,
1045 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[num
];
1046 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1047 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
1048 struct snd_soc_platform
*platform
= rtd
->platform
;
1049 struct snd_soc_codec
*codec
;
1051 /* remove the platform */
1052 if (platform
&& platform
->probed
&&
1053 platform
->driver
->remove_order
== order
) {
1054 soc_remove_platform(platform
);
1057 /* remove the CODEC-side CODEC */
1059 codec
= codec_dai
->codec
;
1060 if (codec
&& codec
->probed
&&
1061 codec
->driver
->remove_order
== order
)
1062 soc_remove_codec(codec
);
1065 /* remove any CPU-side CODEC */
1067 codec
= cpu_dai
->codec
;
1068 if (codec
&& codec
->probed
&&
1069 codec
->driver
->remove_order
== order
)
1070 soc_remove_codec(codec
);
1074 static void soc_remove_dai_links(struct snd_soc_card
*card
)
1078 for (order
= SND_SOC_COMP_ORDER_FIRST
; order
<= SND_SOC_COMP_ORDER_LAST
;
1080 for (dai
= 0; dai
< card
->num_rtd
; dai
++)
1081 soc_remove_link_dais(card
, dai
, order
);
1084 for (order
= SND_SOC_COMP_ORDER_FIRST
; order
<= SND_SOC_COMP_ORDER_LAST
;
1086 for (dai
= 0; dai
< card
->num_rtd
; dai
++)
1087 soc_remove_link_components(card
, dai
, order
);
1093 static void soc_set_name_prefix(struct snd_soc_card
*card
,
1094 struct snd_soc_codec
*codec
)
1098 if (card
->codec_conf
== NULL
)
1101 for (i
= 0; i
< card
->num_configs
; i
++) {
1102 struct snd_soc_codec_conf
*map
= &card
->codec_conf
[i
];
1103 if (map
->dev_name
&& !strcmp(codec
->name
, map
->dev_name
)) {
1104 codec
->name_prefix
= map
->name_prefix
;
1110 static int soc_probe_codec(struct snd_soc_card
*card
,
1111 struct snd_soc_codec
*codec
)
1114 const struct snd_soc_codec_driver
*driver
= codec
->driver
;
1115 struct snd_soc_dai
*dai
;
1118 codec
->dapm
.card
= card
;
1119 soc_set_name_prefix(card
, codec
);
1121 if (!try_module_get(codec
->dev
->driver
->owner
))
1124 soc_init_codec_debugfs(codec
);
1126 if (driver
->dapm_widgets
)
1127 snd_soc_dapm_new_controls(&codec
->dapm
, driver
->dapm_widgets
,
1128 driver
->num_dapm_widgets
);
1130 /* Create DAPM widgets for each DAI stream */
1131 list_for_each_entry(dai
, &dai_list
, list
) {
1132 if (dai
->dev
!= codec
->dev
)
1135 snd_soc_dapm_new_dai_widgets(&codec
->dapm
, dai
);
1138 codec
->dapm
.idle_bias_off
= driver
->idle_bias_off
;
1140 if (driver
->probe
) {
1141 ret
= driver
->probe(codec
);
1144 "ASoC: failed to probe CODEC %d\n", ret
);
1147 WARN(codec
->dapm
.idle_bias_off
&&
1148 codec
->dapm
.bias_level
!= SND_SOC_BIAS_OFF
,
1149 "codec %s can not start from non-off bias with idle_bias_off==1\n",
1153 /* If the driver didn't set I/O up try regmap */
1154 if (!codec
->write
&& dev_get_regmap(codec
->dev
, NULL
))
1155 snd_soc_codec_set_cache_io(codec
, 0, 0, SND_SOC_REGMAP
);
1157 if (driver
->controls
)
1158 snd_soc_add_codec_controls(codec
, driver
->controls
,
1159 driver
->num_controls
);
1160 if (driver
->dapm_routes
)
1161 snd_soc_dapm_add_routes(&codec
->dapm
, driver
->dapm_routes
,
1162 driver
->num_dapm_routes
);
1164 /* mark codec as probed and add to card codec list */
1166 list_add(&codec
->card_list
, &card
->codec_dev_list
);
1167 list_add(&codec
->dapm
.list
, &card
->dapm_list
);
1172 soc_cleanup_codec_debugfs(codec
);
1173 module_put(codec
->dev
->driver
->owner
);
1178 static int soc_probe_platform(struct snd_soc_card
*card
,
1179 struct snd_soc_platform
*platform
)
1182 const struct snd_soc_platform_driver
*driver
= platform
->driver
;
1183 struct snd_soc_dai
*dai
;
1185 platform
->card
= card
;
1186 platform
->dapm
.card
= card
;
1188 if (!try_module_get(platform
->dev
->driver
->owner
))
1191 soc_init_platform_debugfs(platform
);
1193 if (driver
->dapm_widgets
)
1194 snd_soc_dapm_new_controls(&platform
->dapm
,
1195 driver
->dapm_widgets
, driver
->num_dapm_widgets
);
1197 /* Create DAPM widgets for each DAI stream */
1198 list_for_each_entry(dai
, &dai_list
, list
) {
1199 if (dai
->dev
!= platform
->dev
)
1202 snd_soc_dapm_new_dai_widgets(&platform
->dapm
, dai
);
1205 platform
->dapm
.idle_bias_off
= 1;
1207 if (driver
->probe
) {
1208 ret
= driver
->probe(platform
);
1210 dev_err(platform
->dev
,
1211 "ASoC: failed to probe platform %d\n", ret
);
1216 if (driver
->controls
)
1217 snd_soc_add_platform_controls(platform
, driver
->controls
,
1218 driver
->num_controls
);
1219 if (driver
->dapm_routes
)
1220 snd_soc_dapm_add_routes(&platform
->dapm
, driver
->dapm_routes
,
1221 driver
->num_dapm_routes
);
1223 /* mark platform as probed and add to card platform list */
1224 platform
->probed
= 1;
1225 list_add(&platform
->card_list
, &card
->platform_dev_list
);
1226 list_add(&platform
->dapm
.list
, &card
->dapm_list
);
1231 soc_cleanup_platform_debugfs(platform
);
1232 module_put(platform
->dev
->driver
->owner
);
1237 static void rtd_release(struct device
*dev
)
1242 static int soc_post_component_init(struct snd_soc_card
*card
,
1243 struct snd_soc_codec
*codec
,
1244 int num
, int dailess
)
1246 struct snd_soc_dai_link
*dai_link
= NULL
;
1247 struct snd_soc_aux_dev
*aux_dev
= NULL
;
1248 struct snd_soc_pcm_runtime
*rtd
;
1249 const char *temp
, *name
;
1253 dai_link
= &card
->dai_link
[num
];
1254 rtd
= &card
->rtd
[num
];
1255 name
= dai_link
->name
;
1257 aux_dev
= &card
->aux_dev
[num
];
1258 rtd
= &card
->rtd_aux
[num
];
1259 name
= aux_dev
->name
;
1263 /* machine controls, routes and widgets are not prefixed */
1264 temp
= codec
->name_prefix
;
1265 codec
->name_prefix
= NULL
;
1267 /* do machine specific initialization */
1268 if (!dailess
&& dai_link
->init
)
1269 ret
= dai_link
->init(rtd
);
1270 else if (dailess
&& aux_dev
->init
)
1271 ret
= aux_dev
->init(&codec
->dapm
);
1273 dev_err(card
->dev
, "ASoC: failed to init %s: %d\n", name
, ret
);
1276 codec
->name_prefix
= temp
;
1278 /* register the rtd device */
1281 rtd
->dev
= kzalloc(sizeof(struct device
), GFP_KERNEL
);
1284 device_initialize(rtd
->dev
);
1285 rtd
->dev
->parent
= card
->dev
;
1286 rtd
->dev
->release
= rtd_release
;
1287 rtd
->dev
->init_name
= name
;
1288 dev_set_drvdata(rtd
->dev
, rtd
);
1289 mutex_init(&rtd
->pcm_mutex
);
1290 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_PLAYBACK
].be_clients
);
1291 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_CAPTURE
].be_clients
);
1292 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_PLAYBACK
].fe_clients
);
1293 INIT_LIST_HEAD(&rtd
->dpcm
[SNDRV_PCM_STREAM_CAPTURE
].fe_clients
);
1294 ret
= device_add(rtd
->dev
);
1296 /* calling put_device() here to free the rtd->dev */
1297 put_device(rtd
->dev
);
1299 "ASoC: failed to register runtime device: %d\n", ret
);
1302 rtd
->dev_registered
= 1;
1304 /* add DAPM sysfs entries for this codec */
1305 ret
= snd_soc_dapm_sys_add(rtd
->dev
);
1308 "ASoC: failed to add codec dapm sysfs entries: %d\n", ret
);
1310 /* add codec sysfs entries */
1311 ret
= device_create_file(rtd
->dev
, &dev_attr_codec_reg
);
1314 "ASoC: failed to add codec sysfs files: %d\n", ret
);
1316 #ifdef CONFIG_DEBUG_FS
1317 /* add DPCM sysfs entries */
1318 if (!dailess
&& !dai_link
->dynamic
)
1321 ret
= soc_dpcm_debugfs_add(rtd
);
1323 dev_err(rtd
->dev
, "ASoC: failed to add dpcm sysfs entries: %d\n", ret
);
1330 static int soc_probe_link_components(struct snd_soc_card
*card
, int num
,
1333 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[num
];
1334 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1335 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
1336 struct snd_soc_platform
*platform
= rtd
->platform
;
1339 /* probe the CPU-side component, if it is a CODEC */
1340 if (cpu_dai
->codec
&&
1341 !cpu_dai
->codec
->probed
&&
1342 cpu_dai
->codec
->driver
->probe_order
== order
) {
1343 ret
= soc_probe_codec(card
, cpu_dai
->codec
);
1348 /* probe the CODEC-side component */
1349 if (!codec_dai
->codec
->probed
&&
1350 codec_dai
->codec
->driver
->probe_order
== order
) {
1351 ret
= soc_probe_codec(card
, codec_dai
->codec
);
1356 /* probe the platform */
1357 if (!platform
->probed
&&
1358 platform
->driver
->probe_order
== order
) {
1359 ret
= soc_probe_platform(card
, platform
);
1367 static int soc_probe_link_dais(struct snd_soc_card
*card
, int num
, int order
)
1369 struct snd_soc_dai_link
*dai_link
= &card
->dai_link
[num
];
1370 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[num
];
1371 struct snd_soc_codec
*codec
= rtd
->codec
;
1372 struct snd_soc_platform
*platform
= rtd
->platform
;
1373 struct snd_soc_dai
*codec_dai
= rtd
->codec_dai
;
1374 struct snd_soc_dai
*cpu_dai
= rtd
->cpu_dai
;
1375 struct snd_soc_dapm_widget
*play_w
, *capture_w
;
1378 dev_dbg(card
->dev
, "ASoC: probe %s dai link %d late %d\n",
1379 card
->name
, num
, order
);
1381 /* config components */
1382 cpu_dai
->platform
= platform
;
1383 codec_dai
->card
= card
;
1384 cpu_dai
->card
= card
;
1386 /* set default power off timeout */
1387 rtd
->pmdown_time
= pmdown_time
;
1389 /* probe the cpu_dai */
1390 if (!cpu_dai
->probed
&&
1391 cpu_dai
->driver
->probe_order
== order
) {
1392 if (!cpu_dai
->codec
) {
1393 cpu_dai
->dapm
.card
= card
;
1394 if (!try_module_get(cpu_dai
->dev
->driver
->owner
))
1397 list_add(&cpu_dai
->dapm
.list
, &card
->dapm_list
);
1400 if (cpu_dai
->driver
->probe
) {
1401 ret
= cpu_dai
->driver
->probe(cpu_dai
);
1403 dev_err(cpu_dai
->dev
,
1404 "ASoC: failed to probe CPU DAI %s: %d\n",
1405 cpu_dai
->name
, ret
);
1406 module_put(cpu_dai
->dev
->driver
->owner
);
1410 cpu_dai
->probed
= 1;
1411 /* mark cpu_dai as probed and add to card dai list */
1412 list_add(&cpu_dai
->card_list
, &card
->dai_dev_list
);
1415 /* probe the CODEC DAI */
1416 if (!codec_dai
->probed
&& codec_dai
->driver
->probe_order
== order
) {
1417 if (codec_dai
->driver
->probe
) {
1418 ret
= codec_dai
->driver
->probe(codec_dai
);
1420 dev_err(codec_dai
->dev
,
1421 "ASoC: failed to probe CODEC DAI %s: %d\n",
1422 codec_dai
->name
, ret
);
1427 /* mark codec_dai as probed and add to card dai list */
1428 codec_dai
->probed
= 1;
1429 list_add(&codec_dai
->card_list
, &card
->dai_dev_list
);
1432 /* complete DAI probe during last probe */
1433 if (order
!= SND_SOC_COMP_ORDER_LAST
)
1436 ret
= soc_post_component_init(card
, codec
, num
, 0);
1440 ret
= device_create_file(rtd
->dev
, &dev_attr_pmdown_time
);
1442 dev_warn(rtd
->dev
, "ASoC: failed to add pmdown_time sysfs: %d\n",
1445 if (cpu_dai
->driver
->compress_dai
) {
1446 /*create compress_device"*/
1447 ret
= soc_new_compress(rtd
, num
);
1449 dev_err(card
->dev
, "ASoC: can't create compress %s\n",
1450 dai_link
->stream_name
);
1455 if (!dai_link
->params
) {
1456 /* create the pcm */
1457 ret
= soc_new_pcm(rtd
, num
);
1459 dev_err(card
->dev
, "ASoC: can't create pcm %s :%d\n",
1460 dai_link
->stream_name
, ret
);
1464 INIT_DELAYED_WORK(&rtd
->delayed_work
,
1465 codec2codec_close_delayed_work
);
1467 /* link the DAI widgets */
1468 play_w
= codec_dai
->playback_widget
;
1469 capture_w
= cpu_dai
->capture_widget
;
1470 if (play_w
&& capture_w
) {
1471 ret
= snd_soc_dapm_new_pcm(card
, dai_link
->params
,
1474 dev_err(card
->dev
, "ASoC: Can't link %s to %s: %d\n",
1475 play_w
->name
, capture_w
->name
, ret
);
1480 play_w
= cpu_dai
->playback_widget
;
1481 capture_w
= codec_dai
->capture_widget
;
1482 if (play_w
&& capture_w
) {
1483 ret
= snd_soc_dapm_new_pcm(card
, dai_link
->params
,
1486 dev_err(card
->dev
, "ASoC: Can't link %s to %s: %d\n",
1487 play_w
->name
, capture_w
->name
, ret
);
1494 /* add platform data for AC97 devices */
1495 if (rtd
->codec_dai
->driver
->ac97_control
)
1496 snd_ac97_dev_add_pdata(codec
->ac97
, rtd
->cpu_dai
->ac97_pdata
);
1501 #ifdef CONFIG_SND_SOC_AC97_BUS
1502 static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime
*rtd
)
1506 /* Only instantiate AC97 if not already done by the adaptor
1507 * for the generic AC97 subsystem.
1509 if (rtd
->codec_dai
->driver
->ac97_control
&& !rtd
->codec
->ac97_registered
) {
1511 * It is possible that the AC97 device is already registered to
1512 * the device subsystem. This happens when the device is created
1513 * via snd_ac97_mixer(). Currently only SoC codec that does so
1514 * is the generic AC97 glue but others migh emerge.
1516 * In those cases we don't try to register the device again.
1518 if (!rtd
->codec
->ac97_created
)
1521 ret
= soc_ac97_dev_register(rtd
->codec
);
1523 dev_err(rtd
->codec
->dev
,
1524 "ASoC: AC97 device register failed: %d\n", ret
);
1528 rtd
->codec
->ac97_registered
= 1;
1533 static void soc_unregister_ac97_dai_link(struct snd_soc_codec
*codec
)
1535 if (codec
->ac97_registered
) {
1536 soc_ac97_dev_unregister(codec
);
1537 codec
->ac97_registered
= 0;
1542 static int soc_check_aux_dev(struct snd_soc_card
*card
, int num
)
1544 struct snd_soc_aux_dev
*aux_dev
= &card
->aux_dev
[num
];
1545 struct snd_soc_codec
*codec
;
1547 /* find CODEC from registered CODECs*/
1548 list_for_each_entry(codec
, &codec_list
, list
) {
1549 if (!strcmp(codec
->name
, aux_dev
->codec_name
))
1553 dev_err(card
->dev
, "ASoC: %s not registered\n", aux_dev
->codec_name
);
1555 return -EPROBE_DEFER
;
1558 static int soc_probe_aux_dev(struct snd_soc_card
*card
, int num
)
1560 struct snd_soc_aux_dev
*aux_dev
= &card
->aux_dev
[num
];
1561 struct snd_soc_codec
*codec
;
1564 /* find CODEC from registered CODECs*/
1565 list_for_each_entry(codec
, &codec_list
, list
) {
1566 if (!strcmp(codec
->name
, aux_dev
->codec_name
)) {
1567 if (codec
->probed
) {
1569 "ASoC: codec already probed");
1576 /* codec not found */
1577 dev_err(card
->dev
, "ASoC: codec %s not found", aux_dev
->codec_name
);
1578 return -EPROBE_DEFER
;
1581 ret
= soc_probe_codec(card
, codec
);
1585 ret
= soc_post_component_init(card
, codec
, num
, 1);
1591 static void soc_remove_aux_dev(struct snd_soc_card
*card
, int num
)
1593 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd_aux
[num
];
1594 struct snd_soc_codec
*codec
= rtd
->codec
;
1596 /* unregister the rtd device */
1597 if (rtd
->dev_registered
) {
1598 device_remove_file(rtd
->dev
, &dev_attr_codec_reg
);
1599 device_unregister(rtd
->dev
);
1600 rtd
->dev_registered
= 0;
1603 if (codec
&& codec
->probed
)
1604 soc_remove_codec(codec
);
1607 static int snd_soc_init_codec_cache(struct snd_soc_codec
*codec
)
1611 if (codec
->cache_init
)
1614 ret
= snd_soc_cache_init(codec
);
1617 "ASoC: Failed to set cache compression type: %d\n",
1621 codec
->cache_init
= 1;
1625 static int snd_soc_instantiate_card(struct snd_soc_card
*card
)
1627 struct snd_soc_codec
*codec
;
1628 struct snd_soc_dai_link
*dai_link
;
1629 int ret
, i
, order
, dai_fmt
;
1631 mutex_lock_nested(&card
->mutex
, SND_SOC_CARD_CLASS_INIT
);
1634 for (i
= 0; i
< card
->num_links
; i
++) {
1635 ret
= soc_bind_dai_link(card
, i
);
1640 /* check aux_devs too */
1641 for (i
= 0; i
< card
->num_aux_devs
; i
++) {
1642 ret
= soc_check_aux_dev(card
, i
);
1647 /* initialize the register cache for each available codec */
1648 list_for_each_entry(codec
, &codec_list
, list
) {
1649 if (codec
->cache_init
)
1651 ret
= snd_soc_init_codec_cache(codec
);
1656 /* card bind complete so register a sound card */
1657 ret
= snd_card_create(SNDRV_DEFAULT_IDX1
, SNDRV_DEFAULT_STR1
,
1658 card
->owner
, 0, &card
->snd_card
);
1661 "ASoC: can't create sound card for card %s: %d\n",
1665 card
->snd_card
->dev
= card
->dev
;
1667 card
->dapm
.bias_level
= SND_SOC_BIAS_OFF
;
1668 card
->dapm
.dev
= card
->dev
;
1669 card
->dapm
.card
= card
;
1670 list_add(&card
->dapm
.list
, &card
->dapm_list
);
1672 #ifdef CONFIG_DEBUG_FS
1673 snd_soc_dapm_debugfs_init(&card
->dapm
, card
->debugfs_card_root
);
1676 #ifdef CONFIG_PM_SLEEP
1677 /* deferred resume work */
1678 INIT_WORK(&card
->deferred_resume_work
, soc_resume_deferred
);
1681 if (card
->dapm_widgets
)
1682 snd_soc_dapm_new_controls(&card
->dapm
, card
->dapm_widgets
,
1683 card
->num_dapm_widgets
);
1685 /* initialise the sound card only once */
1687 ret
= card
->probe(card
);
1689 goto card_probe_error
;
1692 /* probe all components used by DAI links on this card */
1693 for (order
= SND_SOC_COMP_ORDER_FIRST
; order
<= SND_SOC_COMP_ORDER_LAST
;
1695 for (i
= 0; i
< card
->num_links
; i
++) {
1696 ret
= soc_probe_link_components(card
, i
, order
);
1699 "ASoC: failed to instantiate card %d\n",
1706 /* probe all DAI links on this card */
1707 for (order
= SND_SOC_COMP_ORDER_FIRST
; order
<= SND_SOC_COMP_ORDER_LAST
;
1709 for (i
= 0; i
< card
->num_links
; i
++) {
1710 ret
= soc_probe_link_dais(card
, i
, order
);
1713 "ASoC: failed to instantiate card %d\n",
1720 for (i
= 0; i
< card
->num_aux_devs
; i
++) {
1721 ret
= soc_probe_aux_dev(card
, i
);
1724 "ASoC: failed to add auxiliary devices %d\n",
1726 goto probe_aux_dev_err
;
1730 snd_soc_dapm_link_dai_widgets(card
);
1733 snd_soc_add_card_controls(card
, card
->controls
, card
->num_controls
);
1735 if (card
->dapm_routes
)
1736 snd_soc_dapm_add_routes(&card
->dapm
, card
->dapm_routes
,
1737 card
->num_dapm_routes
);
1739 for (i
= 0; i
< card
->num_links
; i
++) {
1740 dai_link
= &card
->dai_link
[i
];
1741 dai_fmt
= dai_link
->dai_fmt
;
1744 ret
= snd_soc_dai_set_fmt(card
->rtd
[i
].codec_dai
,
1746 if (ret
!= 0 && ret
!= -ENOTSUPP
)
1747 dev_warn(card
->rtd
[i
].codec_dai
->dev
,
1748 "ASoC: Failed to set DAI format: %d\n",
1752 /* If this is a regular CPU link there will be a platform */
1754 (dai_link
->platform_name
|| dai_link
->platform_of_node
)) {
1755 ret
= snd_soc_dai_set_fmt(card
->rtd
[i
].cpu_dai
,
1757 if (ret
!= 0 && ret
!= -ENOTSUPP
)
1758 dev_warn(card
->rtd
[i
].cpu_dai
->dev
,
1759 "ASoC: Failed to set DAI format: %d\n",
1761 } else if (dai_fmt
) {
1762 /* Flip the polarity for the "CPU" end */
1763 dai_fmt
&= ~SND_SOC_DAIFMT_MASTER_MASK
;
1764 switch (dai_link
->dai_fmt
&
1765 SND_SOC_DAIFMT_MASTER_MASK
) {
1766 case SND_SOC_DAIFMT_CBM_CFM
:
1767 dai_fmt
|= SND_SOC_DAIFMT_CBS_CFS
;
1769 case SND_SOC_DAIFMT_CBM_CFS
:
1770 dai_fmt
|= SND_SOC_DAIFMT_CBS_CFM
;
1772 case SND_SOC_DAIFMT_CBS_CFM
:
1773 dai_fmt
|= SND_SOC_DAIFMT_CBM_CFS
;
1775 case SND_SOC_DAIFMT_CBS_CFS
:
1776 dai_fmt
|= SND_SOC_DAIFMT_CBM_CFM
;
1780 ret
= snd_soc_dai_set_fmt(card
->rtd
[i
].cpu_dai
,
1782 if (ret
!= 0 && ret
!= -ENOTSUPP
)
1783 dev_warn(card
->rtd
[i
].cpu_dai
->dev
,
1784 "ASoC: Failed to set DAI format: %d\n",
1789 snprintf(card
->snd_card
->shortname
, sizeof(card
->snd_card
->shortname
),
1791 snprintf(card
->snd_card
->longname
, sizeof(card
->snd_card
->longname
),
1792 "%s", card
->long_name
? card
->long_name
: card
->name
);
1793 snprintf(card
->snd_card
->driver
, sizeof(card
->snd_card
->driver
),
1794 "%s", card
->driver_name
? card
->driver_name
: card
->name
);
1795 for (i
= 0; i
< ARRAY_SIZE(card
->snd_card
->driver
); i
++) {
1796 switch (card
->snd_card
->driver
[i
]) {
1802 if (!isalnum(card
->snd_card
->driver
[i
]))
1803 card
->snd_card
->driver
[i
] = '_';
1808 if (card
->late_probe
) {
1809 ret
= card
->late_probe(card
);
1811 dev_err(card
->dev
, "ASoC: %s late_probe() failed: %d\n",
1813 goto probe_aux_dev_err
;
1817 if (card
->fully_routed
)
1818 list_for_each_entry(codec
, &card
->codec_dev_list
, card_list
)
1819 snd_soc_dapm_auto_nc_codec_pins(codec
);
1821 snd_soc_dapm_new_widgets(card
);
1823 ret
= snd_card_register(card
->snd_card
);
1825 dev_err(card
->dev
, "ASoC: failed to register soundcard %d\n",
1827 goto probe_aux_dev_err
;
1830 #ifdef CONFIG_SND_SOC_AC97_BUS
1831 /* register any AC97 codecs */
1832 for (i
= 0; i
< card
->num_rtd
; i
++) {
1833 ret
= soc_register_ac97_dai_link(&card
->rtd
[i
]);
1836 "ASoC: failed to register AC97: %d\n", ret
);
1838 soc_unregister_ac97_dai_link(card
->rtd
[i
].codec
);
1839 goto probe_aux_dev_err
;
1844 card
->instantiated
= 1;
1845 snd_soc_dapm_sync(&card
->dapm
);
1846 mutex_unlock(&card
->mutex
);
1851 for (i
= 0; i
< card
->num_aux_devs
; i
++)
1852 soc_remove_aux_dev(card
, i
);
1855 soc_remove_dai_links(card
);
1861 snd_card_free(card
->snd_card
);
1864 mutex_unlock(&card
->mutex
);
1869 /* probes a new socdev */
1870 static int soc_probe(struct platform_device
*pdev
)
1872 struct snd_soc_card
*card
= platform_get_drvdata(pdev
);
1875 * no card, so machine driver should be registering card
1876 * we should not be here in that case so ret error
1881 dev_warn(&pdev
->dev
,
1882 "ASoC: machine %s should use snd_soc_register_card()\n",
1885 /* Bodge while we unpick instantiation */
1886 card
->dev
= &pdev
->dev
;
1888 return snd_soc_register_card(card
);
1891 static int soc_cleanup_card_resources(struct snd_soc_card
*card
)
1895 /* make sure any delayed work runs */
1896 for (i
= 0; i
< card
->num_rtd
; i
++) {
1897 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[i
];
1898 flush_delayed_work(&rtd
->delayed_work
);
1901 /* remove auxiliary devices */
1902 for (i
= 0; i
< card
->num_aux_devs
; i
++)
1903 soc_remove_aux_dev(card
, i
);
1905 /* remove and free each DAI */
1906 soc_remove_dai_links(card
);
1908 soc_cleanup_card_debugfs(card
);
1910 /* remove the card */
1914 snd_soc_dapm_free(&card
->dapm
);
1916 snd_card_free(card
->snd_card
);
1921 /* removes a socdev */
1922 static int soc_remove(struct platform_device
*pdev
)
1924 struct snd_soc_card
*card
= platform_get_drvdata(pdev
);
1926 snd_soc_unregister_card(card
);
1930 int snd_soc_poweroff(struct device
*dev
)
1932 struct snd_soc_card
*card
= dev_get_drvdata(dev
);
1935 if (!card
->instantiated
)
1938 /* Flush out pmdown_time work - we actually do want to run it
1939 * now, we're shutting down so no imminent restart. */
1940 for (i
= 0; i
< card
->num_rtd
; i
++) {
1941 struct snd_soc_pcm_runtime
*rtd
= &card
->rtd
[i
];
1942 flush_delayed_work(&rtd
->delayed_work
);
1945 snd_soc_dapm_shutdown(card
);
1947 /* deactivate pins to sleep state */
1948 for (i
= 0; i
< card
->num_rtd
; i
++) {
1949 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
1950 struct snd_soc_dai
*codec_dai
= card
->rtd
[i
].codec_dai
;
1951 pinctrl_pm_select_sleep_state(codec_dai
->dev
);
1952 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
1957 EXPORT_SYMBOL_GPL(snd_soc_poweroff
);
1959 const struct dev_pm_ops snd_soc_pm_ops
= {
1960 .suspend
= snd_soc_suspend
,
1961 .resume
= snd_soc_resume
,
1962 .freeze
= snd_soc_suspend
,
1963 .thaw
= snd_soc_resume
,
1964 .poweroff
= snd_soc_poweroff
,
1965 .restore
= snd_soc_resume
,
1967 EXPORT_SYMBOL_GPL(snd_soc_pm_ops
);
1969 /* ASoC platform driver */
1970 static struct platform_driver soc_driver
= {
1972 .name
= "soc-audio",
1973 .owner
= THIS_MODULE
,
1974 .pm
= &snd_soc_pm_ops
,
1977 .remove
= soc_remove
,
1981 * snd_soc_codec_volatile_register: Report if a register is volatile.
1983 * @codec: CODEC to query.
1984 * @reg: Register to query.
1986 * Boolean function indiciating if a CODEC register is volatile.
1988 int snd_soc_codec_volatile_register(struct snd_soc_codec
*codec
,
1991 if (codec
->volatile_register
)
1992 return codec
->volatile_register(codec
, reg
);
1996 EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register
);
1999 * snd_soc_codec_readable_register: Report if a register is readable.
2001 * @codec: CODEC to query.
2002 * @reg: Register to query.
2004 * Boolean function indicating if a CODEC register is readable.
2006 int snd_soc_codec_readable_register(struct snd_soc_codec
*codec
,
2009 if (codec
->readable_register
)
2010 return codec
->readable_register(codec
, reg
);
2014 EXPORT_SYMBOL_GPL(snd_soc_codec_readable_register
);
2017 * snd_soc_codec_writable_register: Report if a register is writable.
2019 * @codec: CODEC to query.
2020 * @reg: Register to query.
2022 * Boolean function indicating if a CODEC register is writable.
2024 int snd_soc_codec_writable_register(struct snd_soc_codec
*codec
,
2027 if (codec
->writable_register
)
2028 return codec
->writable_register(codec
, reg
);
2032 EXPORT_SYMBOL_GPL(snd_soc_codec_writable_register
);
2034 int snd_soc_platform_read(struct snd_soc_platform
*platform
,
2039 if (!platform
->driver
->read
) {
2040 dev_err(platform
->dev
, "ASoC: platform has no read back\n");
2044 ret
= platform
->driver
->read(platform
, reg
);
2045 dev_dbg(platform
->dev
, "read %x => %x\n", reg
, ret
);
2046 trace_snd_soc_preg_read(platform
, reg
, ret
);
2050 EXPORT_SYMBOL_GPL(snd_soc_platform_read
);
2052 int snd_soc_platform_write(struct snd_soc_platform
*platform
,
2053 unsigned int reg
, unsigned int val
)
2055 if (!platform
->driver
->write
) {
2056 dev_err(platform
->dev
, "ASoC: platform has no write back\n");
2060 dev_dbg(platform
->dev
, "write %x = %x\n", reg
, val
);
2061 trace_snd_soc_preg_write(platform
, reg
, val
);
2062 return platform
->driver
->write(platform
, reg
, val
);
2064 EXPORT_SYMBOL_GPL(snd_soc_platform_write
);
2067 * snd_soc_new_ac97_codec - initailise AC97 device
2068 * @codec: audio codec
2069 * @ops: AC97 bus operations
2070 * @num: AC97 codec number
2072 * Initialises AC97 codec resources for use by ad-hoc devices only.
2074 int snd_soc_new_ac97_codec(struct snd_soc_codec
*codec
,
2075 struct snd_ac97_bus_ops
*ops
, int num
)
2077 mutex_lock(&codec
->mutex
);
2079 codec
->ac97
= kzalloc(sizeof(struct snd_ac97
), GFP_KERNEL
);
2080 if (codec
->ac97
== NULL
) {
2081 mutex_unlock(&codec
->mutex
);
2085 codec
->ac97
->bus
= kzalloc(sizeof(struct snd_ac97_bus
), GFP_KERNEL
);
2086 if (codec
->ac97
->bus
== NULL
) {
2089 mutex_unlock(&codec
->mutex
);
2093 codec
->ac97
->bus
->ops
= ops
;
2094 codec
->ac97
->num
= num
;
2097 * Mark the AC97 device to be created by us. This way we ensure that the
2098 * device will be registered with the device subsystem later on.
2100 codec
->ac97_created
= 1;
2102 mutex_unlock(&codec
->mutex
);
2105 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec
);
2107 static struct snd_ac97_reset_cfg snd_ac97_rst_cfg
;
2109 static void snd_soc_ac97_warm_reset(struct snd_ac97
*ac97
)
2111 struct pinctrl
*pctl
= snd_ac97_rst_cfg
.pctl
;
2113 pinctrl_select_state(pctl
, snd_ac97_rst_cfg
.pstate_warm_reset
);
2115 gpio_direction_output(snd_ac97_rst_cfg
.gpio_sync
, 1);
2119 gpio_direction_output(snd_ac97_rst_cfg
.gpio_sync
, 0);
2121 pinctrl_select_state(pctl
, snd_ac97_rst_cfg
.pstate_run
);
2125 static void snd_soc_ac97_reset(struct snd_ac97
*ac97
)
2127 struct pinctrl
*pctl
= snd_ac97_rst_cfg
.pctl
;
2129 pinctrl_select_state(pctl
, snd_ac97_rst_cfg
.pstate_reset
);
2131 gpio_direction_output(snd_ac97_rst_cfg
.gpio_sync
, 0);
2132 gpio_direction_output(snd_ac97_rst_cfg
.gpio_sdata
, 0);
2133 gpio_direction_output(snd_ac97_rst_cfg
.gpio_reset
, 0);
2137 gpio_direction_output(snd_ac97_rst_cfg
.gpio_reset
, 1);
2139 pinctrl_select_state(pctl
, snd_ac97_rst_cfg
.pstate_run
);
2143 static int snd_soc_ac97_parse_pinctl(struct device
*dev
,
2144 struct snd_ac97_reset_cfg
*cfg
)
2147 struct pinctrl_state
*state
;
2151 p
= devm_pinctrl_get(dev
);
2153 dev_err(dev
, "Failed to get pinctrl\n");
2158 state
= pinctrl_lookup_state(p
, "ac97-reset");
2159 if (IS_ERR(state
)) {
2160 dev_err(dev
, "Can't find pinctrl state ac97-reset\n");
2161 return PTR_RET(state
);
2163 cfg
->pstate_reset
= state
;
2165 state
= pinctrl_lookup_state(p
, "ac97-warm-reset");
2166 if (IS_ERR(state
)) {
2167 dev_err(dev
, "Can't find pinctrl state ac97-warm-reset\n");
2168 return PTR_RET(state
);
2170 cfg
->pstate_warm_reset
= state
;
2172 state
= pinctrl_lookup_state(p
, "ac97-running");
2173 if (IS_ERR(state
)) {
2174 dev_err(dev
, "Can't find pinctrl state ac97-running\n");
2175 return PTR_RET(state
);
2177 cfg
->pstate_run
= state
;
2179 gpio
= of_get_named_gpio(dev
->of_node
, "ac97-gpios", 0);
2181 dev_err(dev
, "Can't find ac97-sync gpio\n");
2184 ret
= devm_gpio_request(dev
, gpio
, "AC97 link sync");
2186 dev_err(dev
, "Failed requesting ac97-sync gpio\n");
2189 cfg
->gpio_sync
= gpio
;
2191 gpio
= of_get_named_gpio(dev
->of_node
, "ac97-gpios", 1);
2193 dev_err(dev
, "Can't find ac97-sdata gpio %d\n", gpio
);
2196 ret
= devm_gpio_request(dev
, gpio
, "AC97 link sdata");
2198 dev_err(dev
, "Failed requesting ac97-sdata gpio\n");
2201 cfg
->gpio_sdata
= gpio
;
2203 gpio
= of_get_named_gpio(dev
->of_node
, "ac97-gpios", 2);
2205 dev_err(dev
, "Can't find ac97-reset gpio\n");
2208 ret
= devm_gpio_request(dev
, gpio
, "AC97 link reset");
2210 dev_err(dev
, "Failed requesting ac97-reset gpio\n");
2213 cfg
->gpio_reset
= gpio
;
2218 struct snd_ac97_bus_ops
*soc_ac97_ops
;
2219 EXPORT_SYMBOL_GPL(soc_ac97_ops
);
2221 int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops
*ops
)
2223 if (ops
== soc_ac97_ops
)
2226 if (soc_ac97_ops
&& ops
)
2233 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops
);
2236 * snd_soc_set_ac97_ops_of_reset - Set ac97 ops with generic ac97 reset functions
2238 * This function sets the reset and warm_reset properties of ops and parses
2239 * the device node of pdev to get pinctrl states and gpio numbers to use.
2241 int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops
*ops
,
2242 struct platform_device
*pdev
)
2244 struct device
*dev
= &pdev
->dev
;
2245 struct snd_ac97_reset_cfg cfg
;
2248 ret
= snd_soc_ac97_parse_pinctl(dev
, &cfg
);
2252 ret
= snd_soc_set_ac97_ops(ops
);
2256 ops
->warm_reset
= snd_soc_ac97_warm_reset
;
2257 ops
->reset
= snd_soc_ac97_reset
;
2259 snd_ac97_rst_cfg
= cfg
;
2262 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops_of_reset
);
2265 * snd_soc_free_ac97_codec - free AC97 codec device
2266 * @codec: audio codec
2268 * Frees AC97 codec device resources.
2270 void snd_soc_free_ac97_codec(struct snd_soc_codec
*codec
)
2272 mutex_lock(&codec
->mutex
);
2273 #ifdef CONFIG_SND_SOC_AC97_BUS
2274 soc_unregister_ac97_dai_link(codec
);
2276 kfree(codec
->ac97
->bus
);
2279 codec
->ac97_created
= 0;
2280 mutex_unlock(&codec
->mutex
);
2282 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec
);
2284 unsigned int snd_soc_read(struct snd_soc_codec
*codec
, unsigned int reg
)
2288 ret
= codec
->read(codec
, reg
);
2289 dev_dbg(codec
->dev
, "read %x => %x\n", reg
, ret
);
2290 trace_snd_soc_reg_read(codec
, reg
, ret
);
2294 EXPORT_SYMBOL_GPL(snd_soc_read
);
2296 unsigned int snd_soc_write(struct snd_soc_codec
*codec
,
2297 unsigned int reg
, unsigned int val
)
2299 dev_dbg(codec
->dev
, "write %x = %x\n", reg
, val
);
2300 trace_snd_soc_reg_write(codec
, reg
, val
);
2301 return codec
->write(codec
, reg
, val
);
2303 EXPORT_SYMBOL_GPL(snd_soc_write
);
2306 * snd_soc_update_bits - update codec register bits
2307 * @codec: audio codec
2308 * @reg: codec register
2309 * @mask: register mask
2312 * Writes new register value.
2314 * Returns 1 for change, 0 for no change, or negative error code.
2316 int snd_soc_update_bits(struct snd_soc_codec
*codec
, unsigned short reg
,
2317 unsigned int mask
, unsigned int value
)
2320 unsigned int old
, new;
2323 if (codec
->using_regmap
) {
2324 ret
= regmap_update_bits_check(codec
->control_data
, reg
,
2325 mask
, value
, &change
);
2327 ret
= snd_soc_read(codec
, reg
);
2332 new = (old
& ~mask
) | (value
& mask
);
2333 change
= old
!= new;
2335 ret
= snd_soc_write(codec
, reg
, new);
2343 EXPORT_SYMBOL_GPL(snd_soc_update_bits
);
2346 * snd_soc_update_bits_locked - update codec register bits
2347 * @codec: audio codec
2348 * @reg: codec register
2349 * @mask: register mask
2352 * Writes new register value, and takes the codec mutex.
2354 * Returns 1 for change else 0.
2356 int snd_soc_update_bits_locked(struct snd_soc_codec
*codec
,
2357 unsigned short reg
, unsigned int mask
,
2362 mutex_lock(&codec
->mutex
);
2363 change
= snd_soc_update_bits(codec
, reg
, mask
, value
);
2364 mutex_unlock(&codec
->mutex
);
2368 EXPORT_SYMBOL_GPL(snd_soc_update_bits_locked
);
2371 * snd_soc_test_bits - test register for change
2372 * @codec: audio codec
2373 * @reg: codec register
2374 * @mask: register mask
2377 * Tests a register with a new value and checks if the new value is
2378 * different from the old value.
2380 * Returns 1 for change else 0.
2382 int snd_soc_test_bits(struct snd_soc_codec
*codec
, unsigned short reg
,
2383 unsigned int mask
, unsigned int value
)
2386 unsigned int old
, new;
2388 old
= snd_soc_read(codec
, reg
);
2389 new = (old
& ~mask
) | value
;
2390 change
= old
!= new;
2394 EXPORT_SYMBOL_GPL(snd_soc_test_bits
);
2397 * snd_soc_cnew - create new control
2398 * @_template: control template
2399 * @data: control private data
2400 * @long_name: control long name
2401 * @prefix: control name prefix
2403 * Create a new mixer control from a template control.
2405 * Returns 0 for success, else error.
2407 struct snd_kcontrol
*snd_soc_cnew(const struct snd_kcontrol_new
*_template
,
2408 void *data
, const char *long_name
,
2411 struct snd_kcontrol_new
template;
2412 struct snd_kcontrol
*kcontrol
;
2415 memcpy(&template, _template
, sizeof(template));
2419 long_name
= template.name
;
2422 name
= kasprintf(GFP_KERNEL
, "%s %s", prefix
, long_name
);
2426 template.name
= name
;
2428 template.name
= long_name
;
2431 kcontrol
= snd_ctl_new1(&template, data
);
2437 EXPORT_SYMBOL_GPL(snd_soc_cnew
);
2439 static int snd_soc_add_controls(struct snd_card
*card
, struct device
*dev
,
2440 const struct snd_kcontrol_new
*controls
, int num_controls
,
2441 const char *prefix
, void *data
)
2445 for (i
= 0; i
< num_controls
; i
++) {
2446 const struct snd_kcontrol_new
*control
= &controls
[i
];
2447 err
= snd_ctl_add(card
, snd_soc_cnew(control
, data
,
2448 control
->name
, prefix
));
2450 dev_err(dev
, "ASoC: Failed to add %s: %d\n",
2451 control
->name
, err
);
2459 struct snd_kcontrol
*snd_soc_card_get_kcontrol(struct snd_soc_card
*soc_card
,
2462 struct snd_card
*card
= soc_card
->snd_card
;
2463 struct snd_kcontrol
*kctl
;
2465 if (unlikely(!name
))
2468 list_for_each_entry(kctl
, &card
->controls
, list
)
2469 if (!strncmp(kctl
->id
.name
, name
, sizeof(kctl
->id
.name
)))
2473 EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol
);
2476 * snd_soc_add_codec_controls - add an array of controls to a codec.
2477 * Convenience function to add a list of controls. Many codecs were
2478 * duplicating this code.
2480 * @codec: codec to add controls to
2481 * @controls: array of controls to add
2482 * @num_controls: number of elements in the array
2484 * Return 0 for success, else error.
2486 int snd_soc_add_codec_controls(struct snd_soc_codec
*codec
,
2487 const struct snd_kcontrol_new
*controls
, int num_controls
)
2489 struct snd_card
*card
= codec
->card
->snd_card
;
2491 return snd_soc_add_controls(card
, codec
->dev
, controls
, num_controls
,
2492 codec
->name_prefix
, codec
);
2494 EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls
);
2497 * snd_soc_add_platform_controls - add an array of controls to a platform.
2498 * Convenience function to add a list of controls.
2500 * @platform: platform to add controls to
2501 * @controls: array of controls to add
2502 * @num_controls: number of elements in the array
2504 * Return 0 for success, else error.
2506 int snd_soc_add_platform_controls(struct snd_soc_platform
*platform
,
2507 const struct snd_kcontrol_new
*controls
, int num_controls
)
2509 struct snd_card
*card
= platform
->card
->snd_card
;
2511 return snd_soc_add_controls(card
, platform
->dev
, controls
, num_controls
,
2514 EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls
);
2517 * snd_soc_add_card_controls - add an array of controls to a SoC card.
2518 * Convenience function to add a list of controls.
2520 * @soc_card: SoC card to add controls to
2521 * @controls: array of controls to add
2522 * @num_controls: number of elements in the array
2524 * Return 0 for success, else error.
2526 int snd_soc_add_card_controls(struct snd_soc_card
*soc_card
,
2527 const struct snd_kcontrol_new
*controls
, int num_controls
)
2529 struct snd_card
*card
= soc_card
->snd_card
;
2531 return snd_soc_add_controls(card
, soc_card
->dev
, controls
, num_controls
,
2534 EXPORT_SYMBOL_GPL(snd_soc_add_card_controls
);
2537 * snd_soc_add_dai_controls - add an array of controls to a DAI.
2538 * Convienience function to add a list of controls.
2540 * @dai: DAI to add controls to
2541 * @controls: array of controls to add
2542 * @num_controls: number of elements in the array
2544 * Return 0 for success, else error.
2546 int snd_soc_add_dai_controls(struct snd_soc_dai
*dai
,
2547 const struct snd_kcontrol_new
*controls
, int num_controls
)
2549 struct snd_card
*card
= dai
->card
->snd_card
;
2551 return snd_soc_add_controls(card
, dai
->dev
, controls
, num_controls
,
2554 EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls
);
2557 * snd_soc_info_enum_double - enumerated double mixer info callback
2558 * @kcontrol: mixer control
2559 * @uinfo: control element information
2561 * Callback to provide information about a double enumerated
2564 * Returns 0 for success.
2566 int snd_soc_info_enum_double(struct snd_kcontrol
*kcontrol
,
2567 struct snd_ctl_elem_info
*uinfo
)
2569 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
2571 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
2572 uinfo
->count
= e
->shift_l
== e
->shift_r
? 1 : 2;
2573 uinfo
->value
.enumerated
.items
= e
->max
;
2575 if (uinfo
->value
.enumerated
.item
> e
->max
- 1)
2576 uinfo
->value
.enumerated
.item
= e
->max
- 1;
2577 strlcpy(uinfo
->value
.enumerated
.name
,
2578 e
->texts
[uinfo
->value
.enumerated
.item
],
2579 sizeof(uinfo
->value
.enumerated
.name
));
2582 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double
);
2585 * snd_soc_get_enum_double - enumerated double mixer get callback
2586 * @kcontrol: mixer control
2587 * @ucontrol: control element information
2589 * Callback to get the value of a double enumerated mixer.
2591 * Returns 0 for success.
2593 int snd_soc_get_enum_double(struct snd_kcontrol
*kcontrol
,
2594 struct snd_ctl_elem_value
*ucontrol
)
2596 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2597 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
2600 val
= snd_soc_read(codec
, e
->reg
);
2601 ucontrol
->value
.enumerated
.item
[0]
2602 = (val
>> e
->shift_l
) & e
->mask
;
2603 if (e
->shift_l
!= e
->shift_r
)
2604 ucontrol
->value
.enumerated
.item
[1] =
2605 (val
>> e
->shift_r
) & e
->mask
;
2609 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double
);
2612 * snd_soc_put_enum_double - enumerated double mixer put callback
2613 * @kcontrol: mixer control
2614 * @ucontrol: control element information
2616 * Callback to set the value of a double enumerated mixer.
2618 * Returns 0 for success.
2620 int snd_soc_put_enum_double(struct snd_kcontrol
*kcontrol
,
2621 struct snd_ctl_elem_value
*ucontrol
)
2623 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2624 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
2628 if (ucontrol
->value
.enumerated
.item
[0] > e
->max
- 1)
2630 val
= ucontrol
->value
.enumerated
.item
[0] << e
->shift_l
;
2631 mask
= e
->mask
<< e
->shift_l
;
2632 if (e
->shift_l
!= e
->shift_r
) {
2633 if (ucontrol
->value
.enumerated
.item
[1] > e
->max
- 1)
2635 val
|= ucontrol
->value
.enumerated
.item
[1] << e
->shift_r
;
2636 mask
|= e
->mask
<< e
->shift_r
;
2639 return snd_soc_update_bits_locked(codec
, e
->reg
, mask
, val
);
2641 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double
);
2644 * snd_soc_get_value_enum_double - semi enumerated double mixer get callback
2645 * @kcontrol: mixer control
2646 * @ucontrol: control element information
2648 * Callback to get the value of a double semi enumerated mixer.
2650 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2651 * used for handling bitfield coded enumeration for example.
2653 * Returns 0 for success.
2655 int snd_soc_get_value_enum_double(struct snd_kcontrol
*kcontrol
,
2656 struct snd_ctl_elem_value
*ucontrol
)
2658 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2659 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
2660 unsigned int reg_val
, val
, mux
;
2662 reg_val
= snd_soc_read(codec
, e
->reg
);
2663 val
= (reg_val
>> e
->shift_l
) & e
->mask
;
2664 for (mux
= 0; mux
< e
->max
; mux
++) {
2665 if (val
== e
->values
[mux
])
2668 ucontrol
->value
.enumerated
.item
[0] = mux
;
2669 if (e
->shift_l
!= e
->shift_r
) {
2670 val
= (reg_val
>> e
->shift_r
) & e
->mask
;
2671 for (mux
= 0; mux
< e
->max
; mux
++) {
2672 if (val
== e
->values
[mux
])
2675 ucontrol
->value
.enumerated
.item
[1] = mux
;
2680 EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double
);
2683 * snd_soc_put_value_enum_double - semi enumerated double mixer put callback
2684 * @kcontrol: mixer control
2685 * @ucontrol: control element information
2687 * Callback to set the value of a double semi enumerated mixer.
2689 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2690 * used for handling bitfield coded enumeration for example.
2692 * Returns 0 for success.
2694 int snd_soc_put_value_enum_double(struct snd_kcontrol
*kcontrol
,
2695 struct snd_ctl_elem_value
*ucontrol
)
2697 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2698 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
2702 if (ucontrol
->value
.enumerated
.item
[0] > e
->max
- 1)
2704 val
= e
->values
[ucontrol
->value
.enumerated
.item
[0]] << e
->shift_l
;
2705 mask
= e
->mask
<< e
->shift_l
;
2706 if (e
->shift_l
!= e
->shift_r
) {
2707 if (ucontrol
->value
.enumerated
.item
[1] > e
->max
- 1)
2709 val
|= e
->values
[ucontrol
->value
.enumerated
.item
[1]] << e
->shift_r
;
2710 mask
|= e
->mask
<< e
->shift_r
;
2713 return snd_soc_update_bits_locked(codec
, e
->reg
, mask
, val
);
2715 EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double
);
2718 * snd_soc_info_volsw - single mixer info callback
2719 * @kcontrol: mixer control
2720 * @uinfo: control element information
2722 * Callback to provide information about a single mixer control, or a double
2723 * mixer control that spans 2 registers.
2725 * Returns 0 for success.
2727 int snd_soc_info_volsw(struct snd_kcontrol
*kcontrol
,
2728 struct snd_ctl_elem_info
*uinfo
)
2730 struct soc_mixer_control
*mc
=
2731 (struct soc_mixer_control
*)kcontrol
->private_value
;
2734 if (!mc
->platform_max
)
2735 mc
->platform_max
= mc
->max
;
2736 platform_max
= mc
->platform_max
;
2738 if (platform_max
== 1 && !strstr(kcontrol
->id
.name
, " Volume"))
2739 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
2741 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2743 uinfo
->count
= snd_soc_volsw_is_stereo(mc
) ? 2 : 1;
2744 uinfo
->value
.integer
.min
= 0;
2745 uinfo
->value
.integer
.max
= platform_max
;
2748 EXPORT_SYMBOL_GPL(snd_soc_info_volsw
);
2751 * snd_soc_get_volsw - single mixer get callback
2752 * @kcontrol: mixer control
2753 * @ucontrol: control element information
2755 * Callback to get the value of a single mixer control, or a double mixer
2756 * control that spans 2 registers.
2758 * Returns 0 for success.
2760 int snd_soc_get_volsw(struct snd_kcontrol
*kcontrol
,
2761 struct snd_ctl_elem_value
*ucontrol
)
2763 struct soc_mixer_control
*mc
=
2764 (struct soc_mixer_control
*)kcontrol
->private_value
;
2765 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2766 unsigned int reg
= mc
->reg
;
2767 unsigned int reg2
= mc
->rreg
;
2768 unsigned int shift
= mc
->shift
;
2769 unsigned int rshift
= mc
->rshift
;
2771 unsigned int mask
= (1 << fls(max
)) - 1;
2772 unsigned int invert
= mc
->invert
;
2774 ucontrol
->value
.integer
.value
[0] =
2775 (snd_soc_read(codec
, reg
) >> shift
) & mask
;
2777 ucontrol
->value
.integer
.value
[0] =
2778 max
- ucontrol
->value
.integer
.value
[0];
2780 if (snd_soc_volsw_is_stereo(mc
)) {
2782 ucontrol
->value
.integer
.value
[1] =
2783 (snd_soc_read(codec
, reg
) >> rshift
) & mask
;
2785 ucontrol
->value
.integer
.value
[1] =
2786 (snd_soc_read(codec
, reg2
) >> shift
) & mask
;
2788 ucontrol
->value
.integer
.value
[1] =
2789 max
- ucontrol
->value
.integer
.value
[1];
2794 EXPORT_SYMBOL_GPL(snd_soc_get_volsw
);
2797 * snd_soc_put_volsw - single mixer put callback
2798 * @kcontrol: mixer control
2799 * @ucontrol: control element information
2801 * Callback to set the value of a single mixer control, or a double mixer
2802 * control that spans 2 registers.
2804 * Returns 0 for success.
2806 int snd_soc_put_volsw(struct snd_kcontrol
*kcontrol
,
2807 struct snd_ctl_elem_value
*ucontrol
)
2809 struct soc_mixer_control
*mc
=
2810 (struct soc_mixer_control
*)kcontrol
->private_value
;
2811 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2812 unsigned int reg
= mc
->reg
;
2813 unsigned int reg2
= mc
->rreg
;
2814 unsigned int shift
= mc
->shift
;
2815 unsigned int rshift
= mc
->rshift
;
2817 unsigned int mask
= (1 << fls(max
)) - 1;
2818 unsigned int invert
= mc
->invert
;
2821 unsigned int val2
= 0;
2822 unsigned int val
, val_mask
;
2824 val
= (ucontrol
->value
.integer
.value
[0] & mask
);
2827 val_mask
= mask
<< shift
;
2829 if (snd_soc_volsw_is_stereo(mc
)) {
2830 val2
= (ucontrol
->value
.integer
.value
[1] & mask
);
2834 val_mask
|= mask
<< rshift
;
2835 val
|= val2
<< rshift
;
2837 val2
= val2
<< shift
;
2841 err
= snd_soc_update_bits_locked(codec
, reg
, val_mask
, val
);
2846 err
= snd_soc_update_bits_locked(codec
, reg2
, val_mask
, val2
);
2850 EXPORT_SYMBOL_GPL(snd_soc_put_volsw
);
2853 * snd_soc_get_volsw_sx - single mixer get callback
2854 * @kcontrol: mixer control
2855 * @ucontrol: control element information
2857 * Callback to get the value of a single mixer control, or a double mixer
2858 * control that spans 2 registers.
2860 * Returns 0 for success.
2862 int snd_soc_get_volsw_sx(struct snd_kcontrol
*kcontrol
,
2863 struct snd_ctl_elem_value
*ucontrol
)
2865 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2866 struct soc_mixer_control
*mc
=
2867 (struct soc_mixer_control
*)kcontrol
->private_value
;
2869 unsigned int reg
= mc
->reg
;
2870 unsigned int reg2
= mc
->rreg
;
2871 unsigned int shift
= mc
->shift
;
2872 unsigned int rshift
= mc
->rshift
;
2875 int mask
= (1 << (fls(min
+ max
) - 1)) - 1;
2877 ucontrol
->value
.integer
.value
[0] =
2878 ((snd_soc_read(codec
, reg
) >> shift
) - min
) & mask
;
2880 if (snd_soc_volsw_is_stereo(mc
))
2881 ucontrol
->value
.integer
.value
[1] =
2882 ((snd_soc_read(codec
, reg2
) >> rshift
) - min
) & mask
;
2886 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_sx
);
2889 * snd_soc_put_volsw_sx - double mixer set callback
2890 * @kcontrol: mixer control
2891 * @uinfo: control element information
2893 * Callback to set the value of a double mixer control that spans 2 registers.
2895 * Returns 0 for success.
2897 int snd_soc_put_volsw_sx(struct snd_kcontrol
*kcontrol
,
2898 struct snd_ctl_elem_value
*ucontrol
)
2900 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2901 struct soc_mixer_control
*mc
=
2902 (struct soc_mixer_control
*)kcontrol
->private_value
;
2904 unsigned int reg
= mc
->reg
;
2905 unsigned int reg2
= mc
->rreg
;
2906 unsigned int shift
= mc
->shift
;
2907 unsigned int rshift
= mc
->rshift
;
2910 int mask
= (1 << (fls(min
+ max
) - 1)) - 1;
2912 unsigned short val
, val_mask
, val2
= 0;
2914 val_mask
= mask
<< shift
;
2915 val
= (ucontrol
->value
.integer
.value
[0] + min
) & mask
;
2918 err
= snd_soc_update_bits_locked(codec
, reg
, val_mask
, val
);
2922 if (snd_soc_volsw_is_stereo(mc
)) {
2923 val_mask
= mask
<< rshift
;
2924 val2
= (ucontrol
->value
.integer
.value
[1] + min
) & mask
;
2925 val2
= val2
<< rshift
;
2927 if (snd_soc_update_bits_locked(codec
, reg2
, val_mask
, val2
))
2932 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_sx
);
2935 * snd_soc_info_volsw_s8 - signed mixer info callback
2936 * @kcontrol: mixer control
2937 * @uinfo: control element information
2939 * Callback to provide information about a signed mixer control.
2941 * Returns 0 for success.
2943 int snd_soc_info_volsw_s8(struct snd_kcontrol
*kcontrol
,
2944 struct snd_ctl_elem_info
*uinfo
)
2946 struct soc_mixer_control
*mc
=
2947 (struct soc_mixer_control
*)kcontrol
->private_value
;
2951 if (!mc
->platform_max
)
2952 mc
->platform_max
= mc
->max
;
2953 platform_max
= mc
->platform_max
;
2955 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2957 uinfo
->value
.integer
.min
= 0;
2958 uinfo
->value
.integer
.max
= platform_max
- min
;
2961 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8
);
2964 * snd_soc_get_volsw_s8 - signed mixer get callback
2965 * @kcontrol: mixer control
2966 * @ucontrol: control element information
2968 * Callback to get the value of a signed mixer control.
2970 * Returns 0 for success.
2972 int snd_soc_get_volsw_s8(struct snd_kcontrol
*kcontrol
,
2973 struct snd_ctl_elem_value
*ucontrol
)
2975 struct soc_mixer_control
*mc
=
2976 (struct soc_mixer_control
*)kcontrol
->private_value
;
2977 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2978 unsigned int reg
= mc
->reg
;
2980 int val
= snd_soc_read(codec
, reg
);
2982 ucontrol
->value
.integer
.value
[0] =
2983 ((signed char)(val
& 0xff))-min
;
2984 ucontrol
->value
.integer
.value
[1] =
2985 ((signed char)((val
>> 8) & 0xff))-min
;
2988 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8
);
2991 * snd_soc_put_volsw_sgn - signed mixer put callback
2992 * @kcontrol: mixer control
2993 * @ucontrol: control element information
2995 * Callback to set the value of a signed mixer control.
2997 * Returns 0 for success.
2999 int snd_soc_put_volsw_s8(struct snd_kcontrol
*kcontrol
,
3000 struct snd_ctl_elem_value
*ucontrol
)
3002 struct soc_mixer_control
*mc
=
3003 (struct soc_mixer_control
*)kcontrol
->private_value
;
3004 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3005 unsigned int reg
= mc
->reg
;
3009 val
= (ucontrol
->value
.integer
.value
[0]+min
) & 0xff;
3010 val
|= ((ucontrol
->value
.integer
.value
[1]+min
) & 0xff) << 8;
3012 return snd_soc_update_bits_locked(codec
, reg
, 0xffff, val
);
3014 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8
);
3017 * snd_soc_info_volsw_range - single mixer info callback with range.
3018 * @kcontrol: mixer control
3019 * @uinfo: control element information
3021 * Callback to provide information, within a range, about a single
3024 * returns 0 for success.
3026 int snd_soc_info_volsw_range(struct snd_kcontrol
*kcontrol
,
3027 struct snd_ctl_elem_info
*uinfo
)
3029 struct soc_mixer_control
*mc
=
3030 (struct soc_mixer_control
*)kcontrol
->private_value
;
3034 if (!mc
->platform_max
)
3035 mc
->platform_max
= mc
->max
;
3036 platform_max
= mc
->platform_max
;
3038 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
3039 uinfo
->count
= snd_soc_volsw_is_stereo(mc
) ? 2 : 1;
3040 uinfo
->value
.integer
.min
= 0;
3041 uinfo
->value
.integer
.max
= platform_max
- min
;
3045 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_range
);
3048 * snd_soc_put_volsw_range - single mixer put value callback with range.
3049 * @kcontrol: mixer control
3050 * @ucontrol: control element information
3052 * Callback to set the value, within a range, for a single mixer control.
3054 * Returns 0 for success.
3056 int snd_soc_put_volsw_range(struct snd_kcontrol
*kcontrol
,
3057 struct snd_ctl_elem_value
*ucontrol
)
3059 struct soc_mixer_control
*mc
=
3060 (struct soc_mixer_control
*)kcontrol
->private_value
;
3061 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3062 unsigned int reg
= mc
->reg
;
3063 unsigned int rreg
= mc
->rreg
;
3064 unsigned int shift
= mc
->shift
;
3067 unsigned int mask
= (1 << fls(max
)) - 1;
3068 unsigned int invert
= mc
->invert
;
3069 unsigned int val
, val_mask
;
3072 val
= ((ucontrol
->value
.integer
.value
[0] + min
) & mask
);
3075 val_mask
= mask
<< shift
;
3078 ret
= snd_soc_update_bits_locked(codec
, reg
, val_mask
, val
);
3082 if (snd_soc_volsw_is_stereo(mc
)) {
3083 val
= ((ucontrol
->value
.integer
.value
[1] + min
) & mask
);
3086 val_mask
= mask
<< shift
;
3089 ret
= snd_soc_update_bits_locked(codec
, rreg
, val_mask
, val
);
3094 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_range
);
3097 * snd_soc_get_volsw_range - single mixer get callback with range
3098 * @kcontrol: mixer control
3099 * @ucontrol: control element information
3101 * Callback to get the value, within a range, of a single mixer control.
3103 * Returns 0 for success.
3105 int snd_soc_get_volsw_range(struct snd_kcontrol
*kcontrol
,
3106 struct snd_ctl_elem_value
*ucontrol
)
3108 struct soc_mixer_control
*mc
=
3109 (struct soc_mixer_control
*)kcontrol
->private_value
;
3110 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3111 unsigned int reg
= mc
->reg
;
3112 unsigned int rreg
= mc
->rreg
;
3113 unsigned int shift
= mc
->shift
;
3116 unsigned int mask
= (1 << fls(max
)) - 1;
3117 unsigned int invert
= mc
->invert
;
3119 ucontrol
->value
.integer
.value
[0] =
3120 (snd_soc_read(codec
, reg
) >> shift
) & mask
;
3122 ucontrol
->value
.integer
.value
[0] =
3123 max
- ucontrol
->value
.integer
.value
[0];
3124 ucontrol
->value
.integer
.value
[0] =
3125 ucontrol
->value
.integer
.value
[0] - min
;
3127 if (snd_soc_volsw_is_stereo(mc
)) {
3128 ucontrol
->value
.integer
.value
[1] =
3129 (snd_soc_read(codec
, rreg
) >> shift
) & mask
;
3131 ucontrol
->value
.integer
.value
[1] =
3132 max
- ucontrol
->value
.integer
.value
[1];
3133 ucontrol
->value
.integer
.value
[1] =
3134 ucontrol
->value
.integer
.value
[1] - min
;
3139 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_range
);
3142 * snd_soc_limit_volume - Set new limit to an existing volume control.
3144 * @codec: where to look for the control
3145 * @name: Name of the control
3146 * @max: new maximum limit
3148 * Return 0 for success, else error.
3150 int snd_soc_limit_volume(struct snd_soc_codec
*codec
,
3151 const char *name
, int max
)
3153 struct snd_card
*card
= codec
->card
->snd_card
;
3154 struct snd_kcontrol
*kctl
;
3155 struct soc_mixer_control
*mc
;
3159 /* Sanity check for name and max */
3160 if (unlikely(!name
|| max
<= 0))
3163 list_for_each_entry(kctl
, &card
->controls
, list
) {
3164 if (!strncmp(kctl
->id
.name
, name
, sizeof(kctl
->id
.name
))) {
3170 mc
= (struct soc_mixer_control
*)kctl
->private_value
;
3171 if (max
<= mc
->max
) {
3172 mc
->platform_max
= max
;
3178 EXPORT_SYMBOL_GPL(snd_soc_limit_volume
);
3180 int snd_soc_bytes_info(struct snd_kcontrol
*kcontrol
,
3181 struct snd_ctl_elem_info
*uinfo
)
3183 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3184 struct soc_bytes
*params
= (void *)kcontrol
->private_value
;
3186 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BYTES
;
3187 uinfo
->count
= params
->num_regs
* codec
->val_bytes
;
3191 EXPORT_SYMBOL_GPL(snd_soc_bytes_info
);
3193 int snd_soc_bytes_get(struct snd_kcontrol
*kcontrol
,
3194 struct snd_ctl_elem_value
*ucontrol
)
3196 struct soc_bytes
*params
= (void *)kcontrol
->private_value
;
3197 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3200 if (codec
->using_regmap
)
3201 ret
= regmap_raw_read(codec
->control_data
, params
->base
,
3202 ucontrol
->value
.bytes
.data
,
3203 params
->num_regs
* codec
->val_bytes
);
3207 /* Hide any masked bytes to ensure consistent data reporting */
3208 if (ret
== 0 && params
->mask
) {
3209 switch (codec
->val_bytes
) {
3211 ucontrol
->value
.bytes
.data
[0] &= ~params
->mask
;
3214 ((u16
*)(&ucontrol
->value
.bytes
.data
))[0]
3215 &= cpu_to_be16(~params
->mask
);
3218 ((u32
*)(&ucontrol
->value
.bytes
.data
))[0]
3219 &= cpu_to_be32(~params
->mask
);
3228 EXPORT_SYMBOL_GPL(snd_soc_bytes_get
);
3230 int snd_soc_bytes_put(struct snd_kcontrol
*kcontrol
,
3231 struct snd_ctl_elem_value
*ucontrol
)
3233 struct soc_bytes
*params
= (void *)kcontrol
->private_value
;
3234 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3239 if (!codec
->using_regmap
)
3242 len
= params
->num_regs
* codec
->val_bytes
;
3244 data
= kmemdup(ucontrol
->value
.bytes
.data
, len
, GFP_KERNEL
| GFP_DMA
);
3249 * If we've got a mask then we need to preserve the register
3250 * bits. We shouldn't modify the incoming data so take a
3254 ret
= regmap_read(codec
->control_data
, params
->base
, &val
);
3258 val
&= params
->mask
;
3260 switch (codec
->val_bytes
) {
3262 ((u8
*)data
)[0] &= ~params
->mask
;
3263 ((u8
*)data
)[0] |= val
;
3266 ((u16
*)data
)[0] &= cpu_to_be16(~params
->mask
);
3267 ((u16
*)data
)[0] |= cpu_to_be16(val
);
3270 ((u32
*)data
)[0] &= cpu_to_be32(~params
->mask
);
3271 ((u32
*)data
)[0] |= cpu_to_be32(val
);
3279 ret
= regmap_raw_write(codec
->control_data
, params
->base
,
3287 EXPORT_SYMBOL_GPL(snd_soc_bytes_put
);
3290 * snd_soc_info_xr_sx - signed multi register info callback
3291 * @kcontrol: mreg control
3292 * @uinfo: control element information
3294 * Callback to provide information of a control that can
3295 * span multiple codec registers which together
3296 * forms a single signed value in a MSB/LSB manner.
3298 * Returns 0 for success.
3300 int snd_soc_info_xr_sx(struct snd_kcontrol
*kcontrol
,
3301 struct snd_ctl_elem_info
*uinfo
)
3303 struct soc_mreg_control
*mc
=
3304 (struct soc_mreg_control
*)kcontrol
->private_value
;
3305 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
3307 uinfo
->value
.integer
.min
= mc
->min
;
3308 uinfo
->value
.integer
.max
= mc
->max
;
3312 EXPORT_SYMBOL_GPL(snd_soc_info_xr_sx
);
3315 * snd_soc_get_xr_sx - signed multi register get callback
3316 * @kcontrol: mreg control
3317 * @ucontrol: control element information
3319 * Callback to get the value of a control that can span
3320 * multiple codec registers which together forms a single
3321 * signed value in a MSB/LSB manner. The control supports
3322 * specifying total no of bits used to allow for bitfields
3323 * across the multiple codec registers.
3325 * Returns 0 for success.
3327 int snd_soc_get_xr_sx(struct snd_kcontrol
*kcontrol
,
3328 struct snd_ctl_elem_value
*ucontrol
)
3330 struct soc_mreg_control
*mc
=
3331 (struct soc_mreg_control
*)kcontrol
->private_value
;
3332 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3333 unsigned int regbase
= mc
->regbase
;
3334 unsigned int regcount
= mc
->regcount
;
3335 unsigned int regwshift
= codec
->driver
->reg_word_size
* BITS_PER_BYTE
;
3336 unsigned int regwmask
= (1<<regwshift
)-1;
3337 unsigned int invert
= mc
->invert
;
3338 unsigned long mask
= (1UL<<mc
->nbits
)-1;
3342 unsigned long regval
;
3345 for (i
= 0; i
< regcount
; i
++) {
3346 regval
= snd_soc_read(codec
, regbase
+i
) & regwmask
;
3347 val
|= regval
<< (regwshift
*(regcount
-i
-1));
3350 if (min
< 0 && val
> max
)
3354 ucontrol
->value
.integer
.value
[0] = val
;
3358 EXPORT_SYMBOL_GPL(snd_soc_get_xr_sx
);
3361 * snd_soc_put_xr_sx - signed multi register get callback
3362 * @kcontrol: mreg control
3363 * @ucontrol: control element information
3365 * Callback to set the value of a control that can span
3366 * multiple codec registers which together forms a single
3367 * signed value in a MSB/LSB manner. The control supports
3368 * specifying total no of bits used to allow for bitfields
3369 * across the multiple codec registers.
3371 * Returns 0 for success.
3373 int snd_soc_put_xr_sx(struct snd_kcontrol
*kcontrol
,
3374 struct snd_ctl_elem_value
*ucontrol
)
3376 struct soc_mreg_control
*mc
=
3377 (struct soc_mreg_control
*)kcontrol
->private_value
;
3378 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3379 unsigned int regbase
= mc
->regbase
;
3380 unsigned int regcount
= mc
->regcount
;
3381 unsigned int regwshift
= codec
->driver
->reg_word_size
* BITS_PER_BYTE
;
3382 unsigned int regwmask
= (1<<regwshift
)-1;
3383 unsigned int invert
= mc
->invert
;
3384 unsigned long mask
= (1UL<<mc
->nbits
)-1;
3386 long val
= ucontrol
->value
.integer
.value
[0];
3387 unsigned int i
, regval
, regmask
;
3393 for (i
= 0; i
< regcount
; i
++) {
3394 regval
= (val
>> (regwshift
*(regcount
-i
-1))) & regwmask
;
3395 regmask
= (mask
>> (regwshift
*(regcount
-i
-1))) & regwmask
;
3396 err
= snd_soc_update_bits_locked(codec
, regbase
+i
,
3404 EXPORT_SYMBOL_GPL(snd_soc_put_xr_sx
);
3407 * snd_soc_get_strobe - strobe get callback
3408 * @kcontrol: mixer control
3409 * @ucontrol: control element information
3411 * Callback get the value of a strobe mixer control.
3413 * Returns 0 for success.
3415 int snd_soc_get_strobe(struct snd_kcontrol
*kcontrol
,
3416 struct snd_ctl_elem_value
*ucontrol
)
3418 struct soc_mixer_control
*mc
=
3419 (struct soc_mixer_control
*)kcontrol
->private_value
;
3420 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3421 unsigned int reg
= mc
->reg
;
3422 unsigned int shift
= mc
->shift
;
3423 unsigned int mask
= 1 << shift
;
3424 unsigned int invert
= mc
->invert
!= 0;
3425 unsigned int val
= snd_soc_read(codec
, reg
) & mask
;
3427 if (shift
!= 0 && val
!= 0)
3429 ucontrol
->value
.enumerated
.item
[0] = val
^ invert
;
3433 EXPORT_SYMBOL_GPL(snd_soc_get_strobe
);
3436 * snd_soc_put_strobe - strobe put callback
3437 * @kcontrol: mixer control
3438 * @ucontrol: control element information
3440 * Callback strobe a register bit to high then low (or the inverse)
3441 * in one pass of a single mixer enum control.
3443 * Returns 1 for success.
3445 int snd_soc_put_strobe(struct snd_kcontrol
*kcontrol
,
3446 struct snd_ctl_elem_value
*ucontrol
)
3448 struct soc_mixer_control
*mc
=
3449 (struct soc_mixer_control
*)kcontrol
->private_value
;
3450 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
3451 unsigned int reg
= mc
->reg
;
3452 unsigned int shift
= mc
->shift
;
3453 unsigned int mask
= 1 << shift
;
3454 unsigned int invert
= mc
->invert
!= 0;
3455 unsigned int strobe
= ucontrol
->value
.enumerated
.item
[0] != 0;
3456 unsigned int val1
= (strobe
^ invert
) ? mask
: 0;
3457 unsigned int val2
= (strobe
^ invert
) ? 0 : mask
;
3460 err
= snd_soc_update_bits_locked(codec
, reg
, mask
, val1
);
3464 err
= snd_soc_update_bits_locked(codec
, reg
, mask
, val2
);
3467 EXPORT_SYMBOL_GPL(snd_soc_put_strobe
);
3470 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
3472 * @clk_id: DAI specific clock ID
3473 * @freq: new clock frequency in Hz
3474 * @dir: new clock direction - input/output.
3476 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
3478 int snd_soc_dai_set_sysclk(struct snd_soc_dai
*dai
, int clk_id
,
3479 unsigned int freq
, int dir
)
3481 if (dai
->driver
&& dai
->driver
->ops
->set_sysclk
)
3482 return dai
->driver
->ops
->set_sysclk(dai
, clk_id
, freq
, dir
);
3483 else if (dai
->codec
&& dai
->codec
->driver
->set_sysclk
)
3484 return dai
->codec
->driver
->set_sysclk(dai
->codec
, clk_id
, 0,
3489 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk
);
3492 * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
3494 * @clk_id: DAI specific clock ID
3495 * @source: Source for the clock
3496 * @freq: new clock frequency in Hz
3497 * @dir: new clock direction - input/output.
3499 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
3501 int snd_soc_codec_set_sysclk(struct snd_soc_codec
*codec
, int clk_id
,
3502 int source
, unsigned int freq
, int dir
)
3504 if (codec
->driver
->set_sysclk
)
3505 return codec
->driver
->set_sysclk(codec
, clk_id
, source
,
3510 EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk
);
3513 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
3515 * @div_id: DAI specific clock divider ID
3516 * @div: new clock divisor.
3518 * Configures the clock dividers. This is used to derive the best DAI bit and
3519 * frame clocks from the system or master clock. It's best to set the DAI bit
3520 * and frame clocks as low as possible to save system power.
3522 int snd_soc_dai_set_clkdiv(struct snd_soc_dai
*dai
,
3523 int div_id
, int div
)
3525 if (dai
->driver
&& dai
->driver
->ops
->set_clkdiv
)
3526 return dai
->driver
->ops
->set_clkdiv(dai
, div_id
, div
);
3530 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv
);
3533 * snd_soc_dai_set_pll - configure DAI PLL.
3535 * @pll_id: DAI specific PLL ID
3536 * @source: DAI specific source for the PLL
3537 * @freq_in: PLL input clock frequency in Hz
3538 * @freq_out: requested PLL output clock frequency in Hz
3540 * Configures and enables PLL to generate output clock based on input clock.
3542 int snd_soc_dai_set_pll(struct snd_soc_dai
*dai
, int pll_id
, int source
,
3543 unsigned int freq_in
, unsigned int freq_out
)
3545 if (dai
->driver
&& dai
->driver
->ops
->set_pll
)
3546 return dai
->driver
->ops
->set_pll(dai
, pll_id
, source
,
3548 else if (dai
->codec
&& dai
->codec
->driver
->set_pll
)
3549 return dai
->codec
->driver
->set_pll(dai
->codec
, pll_id
, source
,
3554 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll
);
3557 * snd_soc_codec_set_pll - configure codec PLL.
3559 * @pll_id: DAI specific PLL ID
3560 * @source: DAI specific source for the PLL
3561 * @freq_in: PLL input clock frequency in Hz
3562 * @freq_out: requested PLL output clock frequency in Hz
3564 * Configures and enables PLL to generate output clock based on input clock.
3566 int snd_soc_codec_set_pll(struct snd_soc_codec
*codec
, int pll_id
, int source
,
3567 unsigned int freq_in
, unsigned int freq_out
)
3569 if (codec
->driver
->set_pll
)
3570 return codec
->driver
->set_pll(codec
, pll_id
, source
,
3575 EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll
);
3578 * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
3580 * @ratio Ratio of BCLK to Sample rate.
3582 * Configures the DAI for a preset BCLK to sample rate ratio.
3584 int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai
*dai
, unsigned int ratio
)
3586 if (dai
->driver
&& dai
->driver
->ops
->set_bclk_ratio
)
3587 return dai
->driver
->ops
->set_bclk_ratio(dai
, ratio
);
3591 EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio
);
3594 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
3596 * @fmt: SND_SOC_DAIFMT_ format value.
3598 * Configures the DAI hardware format and clocking.
3600 int snd_soc_dai_set_fmt(struct snd_soc_dai
*dai
, unsigned int fmt
)
3602 if (dai
->driver
== NULL
)
3604 if (dai
->driver
->ops
->set_fmt
== NULL
)
3606 return dai
->driver
->ops
->set_fmt(dai
, fmt
);
3608 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt
);
3611 * snd_soc_dai_set_tdm_slot - configure DAI TDM.
3613 * @tx_mask: bitmask representing active TX slots.
3614 * @rx_mask: bitmask representing active RX slots.
3615 * @slots: Number of slots in use.
3616 * @slot_width: Width in bits for each slot.
3618 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
3621 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai
*dai
,
3622 unsigned int tx_mask
, unsigned int rx_mask
, int slots
, int slot_width
)
3624 if (dai
->driver
&& dai
->driver
->ops
->set_tdm_slot
)
3625 return dai
->driver
->ops
->set_tdm_slot(dai
, tx_mask
, rx_mask
,
3630 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot
);
3633 * snd_soc_dai_set_channel_map - configure DAI audio channel map
3635 * @tx_num: how many TX channels
3636 * @tx_slot: pointer to an array which imply the TX slot number channel
3638 * @rx_num: how many RX channels
3639 * @rx_slot: pointer to an array which imply the RX slot number channel
3642 * configure the relationship between channel number and TDM slot number.
3644 int snd_soc_dai_set_channel_map(struct snd_soc_dai
*dai
,
3645 unsigned int tx_num
, unsigned int *tx_slot
,
3646 unsigned int rx_num
, unsigned int *rx_slot
)
3648 if (dai
->driver
&& dai
->driver
->ops
->set_channel_map
)
3649 return dai
->driver
->ops
->set_channel_map(dai
, tx_num
, tx_slot
,
3654 EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map
);
3657 * snd_soc_dai_set_tristate - configure DAI system or master clock.
3659 * @tristate: tristate enable
3661 * Tristates the DAI so that others can use it.
3663 int snd_soc_dai_set_tristate(struct snd_soc_dai
*dai
, int tristate
)
3665 if (dai
->driver
&& dai
->driver
->ops
->set_tristate
)
3666 return dai
->driver
->ops
->set_tristate(dai
, tristate
);
3670 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate
);
3673 * snd_soc_dai_digital_mute - configure DAI system or master clock.
3675 * @mute: mute enable
3676 * @direction: stream to mute
3678 * Mutes the DAI DAC.
3680 int snd_soc_dai_digital_mute(struct snd_soc_dai
*dai
, int mute
,
3686 if (dai
->driver
->ops
->mute_stream
)
3687 return dai
->driver
->ops
->mute_stream(dai
, mute
, direction
);
3688 else if (direction
== SNDRV_PCM_STREAM_PLAYBACK
&&
3689 dai
->driver
->ops
->digital_mute
)
3690 return dai
->driver
->ops
->digital_mute(dai
, mute
);
3694 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute
);
3697 * snd_soc_register_card - Register a card with the ASoC core
3699 * @card: Card to register
3702 int snd_soc_register_card(struct snd_soc_card
*card
)
3706 if (!card
->name
|| !card
->dev
)
3709 for (i
= 0; i
< card
->num_links
; i
++) {
3710 struct snd_soc_dai_link
*link
= &card
->dai_link
[i
];
3713 * Codec must be specified by 1 of name or OF node,
3714 * not both or neither.
3716 if (!!link
->codec_name
== !!link
->codec_of_node
) {
3718 "ASoC: Neither/both codec name/of_node are set for %s\n",
3722 /* Codec DAI name must be specified */
3723 if (!link
->codec_dai_name
) {
3725 "ASoC: codec_dai_name not set for %s\n",
3731 * Platform may be specified by either name or OF node, but
3732 * can be left unspecified, and a dummy platform will be used.
3734 if (link
->platform_name
&& link
->platform_of_node
) {
3736 "ASoC: Both platform name/of_node are set for %s\n",
3742 * CPU device may be specified by either name or OF node, but
3743 * can be left unspecified, and will be matched based on DAI
3746 if (link
->cpu_name
&& link
->cpu_of_node
) {
3748 "ASoC: Neither/both cpu name/of_node are set for %s\n",
3753 * At least one of CPU DAI name or CPU device name/node must be
3756 if (!link
->cpu_dai_name
&&
3757 !(link
->cpu_name
|| link
->cpu_of_node
)) {
3759 "ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
3765 dev_set_drvdata(card
->dev
, card
);
3767 snd_soc_initialize_card_lists(card
);
3769 soc_init_card_debugfs(card
);
3771 card
->rtd
= devm_kzalloc(card
->dev
,
3772 sizeof(struct snd_soc_pcm_runtime
) *
3773 (card
->num_links
+ card
->num_aux_devs
),
3775 if (card
->rtd
== NULL
)
3778 card
->rtd_aux
= &card
->rtd
[card
->num_links
];
3780 for (i
= 0; i
< card
->num_links
; i
++)
3781 card
->rtd
[i
].dai_link
= &card
->dai_link
[i
];
3783 INIT_LIST_HEAD(&card
->list
);
3784 INIT_LIST_HEAD(&card
->dapm_dirty
);
3785 card
->instantiated
= 0;
3786 mutex_init(&card
->mutex
);
3787 mutex_init(&card
->dapm_mutex
);
3789 ret
= snd_soc_instantiate_card(card
);
3791 soc_cleanup_card_debugfs(card
);
3793 /* deactivate pins to sleep state */
3794 for (i
= 0; i
< card
->num_rtd
; i
++) {
3795 struct snd_soc_dai
*cpu_dai
= card
->rtd
[i
].cpu_dai
;
3796 struct snd_soc_dai
*codec_dai
= card
->rtd
[i
].codec_dai
;
3797 if (!codec_dai
->active
)
3798 pinctrl_pm_select_sleep_state(codec_dai
->dev
);
3799 if (!cpu_dai
->active
)
3800 pinctrl_pm_select_sleep_state(cpu_dai
->dev
);
3805 EXPORT_SYMBOL_GPL(snd_soc_register_card
);
3808 * snd_soc_unregister_card - Unregister a card with the ASoC core
3810 * @card: Card to unregister
3813 int snd_soc_unregister_card(struct snd_soc_card
*card
)
3815 if (card
->instantiated
)
3816 soc_cleanup_card_resources(card
);
3817 dev_dbg(card
->dev
, "ASoC: Unregistered card '%s'\n", card
->name
);
3821 EXPORT_SYMBOL_GPL(snd_soc_unregister_card
);
3824 * Simplify DAI link configuration by removing ".-1" from device names
3825 * and sanitizing names.
3827 static char *fmt_single_name(struct device
*dev
, int *id
)
3829 char *found
, name
[NAME_SIZE
];
3832 if (dev_name(dev
) == NULL
)
3835 strlcpy(name
, dev_name(dev
), NAME_SIZE
);
3837 /* are we a "%s.%d" name (platform and SPI components) */
3838 found
= strstr(name
, dev
->driver
->name
);
3841 if (sscanf(&found
[strlen(dev
->driver
->name
)], ".%d", id
) == 1) {
3843 /* discard ID from name if ID == -1 */
3845 found
[strlen(dev
->driver
->name
)] = '\0';
3849 /* I2C component devices are named "bus-addr" */
3850 if (sscanf(name
, "%x-%x", &id1
, &id2
) == 2) {
3851 char tmp
[NAME_SIZE
];
3853 /* create unique ID number from I2C addr and bus */
3854 *id
= ((id1
& 0xffff) << 16) + id2
;
3856 /* sanitize component name for DAI link creation */
3857 snprintf(tmp
, NAME_SIZE
, "%s.%s", dev
->driver
->name
, name
);
3858 strlcpy(name
, tmp
, NAME_SIZE
);
3863 return kstrdup(name
, GFP_KERNEL
);
3867 * Simplify DAI link naming for single devices with multiple DAIs by removing
3868 * any ".-1" and using the DAI name (instead of device name).
3870 static inline char *fmt_multiple_name(struct device
*dev
,
3871 struct snd_soc_dai_driver
*dai_drv
)
3873 if (dai_drv
->name
== NULL
) {
3875 "ASoC: error - multiple DAI %s registered with no name\n",
3880 return kstrdup(dai_drv
->name
, GFP_KERNEL
);
3884 * snd_soc_register_dai - Register a DAI with the ASoC core
3886 * @dai: DAI to register
3888 static int snd_soc_register_dai(struct device
*dev
,
3889 struct snd_soc_dai_driver
*dai_drv
)
3891 struct snd_soc_codec
*codec
;
3892 struct snd_soc_dai
*dai
;
3894 dev_dbg(dev
, "ASoC: dai register %s\n", dev_name(dev
));
3896 dai
= kzalloc(sizeof(struct snd_soc_dai
), GFP_KERNEL
);
3900 /* create DAI component name */
3901 dai
->name
= fmt_single_name(dev
, &dai
->id
);
3902 if (dai
->name
== NULL
) {
3908 dai
->driver
= dai_drv
;
3909 dai
->dapm
.dev
= dev
;
3910 if (!dai
->driver
->ops
)
3911 dai
->driver
->ops
= &null_dai_ops
;
3913 mutex_lock(&client_mutex
);
3915 list_for_each_entry(codec
, &codec_list
, list
) {
3916 if (codec
->dev
== dev
) {
3917 dev_dbg(dev
, "ASoC: Mapped DAI %s to CODEC %s\n",
3918 dai
->name
, codec
->name
);
3925 dai
->dapm
.idle_bias_off
= 1;
3927 list_add(&dai
->list
, &dai_list
);
3929 mutex_unlock(&client_mutex
);
3931 dev_dbg(dev
, "ASoC: Registered DAI '%s'\n", dai
->name
);
3937 * snd_soc_unregister_dai - Unregister a DAI from the ASoC core
3939 * @dai: DAI to unregister
3941 static void snd_soc_unregister_dai(struct device
*dev
)
3943 struct snd_soc_dai
*dai
;
3945 list_for_each_entry(dai
, &dai_list
, list
) {
3946 if (dev
== dai
->dev
)
3952 mutex_lock(&client_mutex
);
3953 list_del(&dai
->list
);
3954 mutex_unlock(&client_mutex
);
3956 dev_dbg(dev
, "ASoC: Unregistered DAI '%s'\n", dai
->name
);
3962 * snd_soc_register_dais - Register multiple DAIs with the ASoC core
3964 * @dai: Array of DAIs to register
3965 * @count: Number of DAIs
3967 static int snd_soc_register_dais(struct device
*dev
,
3968 struct snd_soc_dai_driver
*dai_drv
, size_t count
)
3970 struct snd_soc_codec
*codec
;
3971 struct snd_soc_dai
*dai
;
3974 dev_dbg(dev
, "ASoC: dai register %s #%Zu\n", dev_name(dev
), count
);
3976 for (i
= 0; i
< count
; i
++) {
3978 dai
= kzalloc(sizeof(struct snd_soc_dai
), GFP_KERNEL
);
3984 /* create DAI component name */
3985 dai
->name
= fmt_multiple_name(dev
, &dai_drv
[i
]);
3986 if (dai
->name
== NULL
) {
3993 dai
->driver
= &dai_drv
[i
];
3994 if (dai
->driver
->id
)
3995 dai
->id
= dai
->driver
->id
;
3998 dai
->dapm
.dev
= dev
;
3999 if (!dai
->driver
->ops
)
4000 dai
->driver
->ops
= &null_dai_ops
;
4002 mutex_lock(&client_mutex
);
4004 list_for_each_entry(codec
, &codec_list
, list
) {
4005 if (codec
->dev
== dev
) {
4007 "ASoC: Mapped DAI %s to CODEC %s\n",
4008 dai
->name
, codec
->name
);
4015 dai
->dapm
.idle_bias_off
= 1;
4017 list_add(&dai
->list
, &dai_list
);
4019 mutex_unlock(&client_mutex
);
4021 dev_dbg(dai
->dev
, "ASoC: Registered DAI '%s'\n", dai
->name
);
4027 for (i
--; i
>= 0; i
--)
4028 snd_soc_unregister_dai(dev
);
4034 * snd_soc_unregister_dais - Unregister multiple DAIs from the ASoC core
4036 * @dai: Array of DAIs to unregister
4037 * @count: Number of DAIs
4039 static void snd_soc_unregister_dais(struct device
*dev
, size_t count
)
4043 for (i
= 0; i
< count
; i
++)
4044 snd_soc_unregister_dai(dev
);
4048 * snd_soc_register_component - Register a component with the ASoC core
4052 __snd_soc_register_component(struct device
*dev
,
4053 struct snd_soc_component
*cmpnt
,
4054 const struct snd_soc_component_driver
*cmpnt_drv
,
4055 struct snd_soc_dai_driver
*dai_drv
,
4056 int num_dai
, bool allow_single_dai
)
4060 dev_dbg(dev
, "component register %s\n", dev_name(dev
));
4063 dev_err(dev
, "ASoC: Failed to connecting component\n");
4067 cmpnt
->name
= fmt_single_name(dev
, &cmpnt
->id
);
4069 dev_err(dev
, "ASoC: Failed to simplifying name\n");
4074 cmpnt
->driver
= cmpnt_drv
;
4075 cmpnt
->dai_drv
= dai_drv
;
4076 cmpnt
->num_dai
= num_dai
;
4079 * snd_soc_register_dai() uses fmt_single_name(), and
4080 * snd_soc_register_dais() uses fmt_multiple_name()
4081 * for dai->name which is used for name based matching
4083 * this function is used from cpu/codec.
4084 * allow_single_dai flag can ignore "codec" driver reworking
4085 * since it had been used snd_soc_register_dais(),
4087 if ((1 == num_dai
) && allow_single_dai
)
4088 ret
= snd_soc_register_dai(dev
, dai_drv
);
4090 ret
= snd_soc_register_dais(dev
, dai_drv
, num_dai
);
4092 dev_err(dev
, "ASoC: Failed to regster DAIs: %d\n", ret
);
4093 goto error_component_name
;
4096 mutex_lock(&client_mutex
);
4097 list_add(&cmpnt
->list
, &component_list
);
4098 mutex_unlock(&client_mutex
);
4100 dev_dbg(cmpnt
->dev
, "ASoC: Registered component '%s'\n", cmpnt
->name
);
4104 error_component_name
:
4110 int snd_soc_register_component(struct device
*dev
,
4111 const struct snd_soc_component_driver
*cmpnt_drv
,
4112 struct snd_soc_dai_driver
*dai_drv
,
4115 struct snd_soc_component
*cmpnt
;
4117 cmpnt
= devm_kzalloc(dev
, sizeof(*cmpnt
), GFP_KERNEL
);
4119 dev_err(dev
, "ASoC: Failed to allocate memory\n");
4123 return __snd_soc_register_component(dev
, cmpnt
, cmpnt_drv
,
4124 dai_drv
, num_dai
, true);
4126 EXPORT_SYMBOL_GPL(snd_soc_register_component
);
4129 * snd_soc_unregister_component - Unregister a component from the ASoC core
4132 void snd_soc_unregister_component(struct device
*dev
)
4134 struct snd_soc_component
*cmpnt
;
4136 list_for_each_entry(cmpnt
, &component_list
, list
) {
4137 if (dev
== cmpnt
->dev
)
4143 snd_soc_unregister_dais(dev
, cmpnt
->num_dai
);
4145 mutex_lock(&client_mutex
);
4146 list_del(&cmpnt
->list
);
4147 mutex_unlock(&client_mutex
);
4149 dev_dbg(dev
, "ASoC: Unregistered component '%s'\n", cmpnt
->name
);
4152 EXPORT_SYMBOL_GPL(snd_soc_unregister_component
);
4155 * snd_soc_add_platform - Add a platform to the ASoC core
4156 * @dev: The parent device for the platform
4157 * @platform: The platform to add
4158 * @platform_driver: The driver for the platform
4160 int snd_soc_add_platform(struct device
*dev
, struct snd_soc_platform
*platform
,
4161 const struct snd_soc_platform_driver
*platform_drv
)
4163 /* create platform component name */
4164 platform
->name
= fmt_single_name(dev
, &platform
->id
);
4165 if (platform
->name
== NULL
)
4168 platform
->dev
= dev
;
4169 platform
->driver
= platform_drv
;
4170 platform
->dapm
.dev
= dev
;
4171 platform
->dapm
.platform
= platform
;
4172 platform
->dapm
.stream_event
= platform_drv
->stream_event
;
4173 mutex_init(&platform
->mutex
);
4175 mutex_lock(&client_mutex
);
4176 list_add(&platform
->list
, &platform_list
);
4177 mutex_unlock(&client_mutex
);
4179 dev_dbg(dev
, "ASoC: Registered platform '%s'\n", platform
->name
);
4183 EXPORT_SYMBOL_GPL(snd_soc_add_platform
);
4186 * snd_soc_register_platform - Register a platform with the ASoC core
4188 * @platform: platform to register
4190 int snd_soc_register_platform(struct device
*dev
,
4191 const struct snd_soc_platform_driver
*platform_drv
)
4193 struct snd_soc_platform
*platform
;
4196 dev_dbg(dev
, "ASoC: platform register %s\n", dev_name(dev
));
4198 platform
= kzalloc(sizeof(struct snd_soc_platform
), GFP_KERNEL
);
4199 if (platform
== NULL
)
4202 ret
= snd_soc_add_platform(dev
, platform
, platform_drv
);
4208 EXPORT_SYMBOL_GPL(snd_soc_register_platform
);
4211 * snd_soc_remove_platform - Remove a platform from the ASoC core
4212 * @platform: the platform to remove
4214 void snd_soc_remove_platform(struct snd_soc_platform
*platform
)
4216 mutex_lock(&client_mutex
);
4217 list_del(&platform
->list
);
4218 mutex_unlock(&client_mutex
);
4220 dev_dbg(platform
->dev
, "ASoC: Unregistered platform '%s'\n",
4222 kfree(platform
->name
);
4224 EXPORT_SYMBOL_GPL(snd_soc_remove_platform
);
4226 struct snd_soc_platform
*snd_soc_lookup_platform(struct device
*dev
)
4228 struct snd_soc_platform
*platform
;
4230 list_for_each_entry(platform
, &platform_list
, list
) {
4231 if (dev
== platform
->dev
)
4237 EXPORT_SYMBOL_GPL(snd_soc_lookup_platform
);
4240 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
4242 * @platform: platform to unregister
4244 void snd_soc_unregister_platform(struct device
*dev
)
4246 struct snd_soc_platform
*platform
;
4248 platform
= snd_soc_lookup_platform(dev
);
4252 snd_soc_remove_platform(platform
);
4255 EXPORT_SYMBOL_GPL(snd_soc_unregister_platform
);
4257 static u64 codec_format_map
[] = {
4258 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
,
4259 SNDRV_PCM_FMTBIT_U16_LE
| SNDRV_PCM_FMTBIT_U16_BE
,
4260 SNDRV_PCM_FMTBIT_S24_LE
| SNDRV_PCM_FMTBIT_S24_BE
,
4261 SNDRV_PCM_FMTBIT_U24_LE
| SNDRV_PCM_FMTBIT_U24_BE
,
4262 SNDRV_PCM_FMTBIT_S32_LE
| SNDRV_PCM_FMTBIT_S32_BE
,
4263 SNDRV_PCM_FMTBIT_U32_LE
| SNDRV_PCM_FMTBIT_U32_BE
,
4264 SNDRV_PCM_FMTBIT_S24_3LE
| SNDRV_PCM_FMTBIT_U24_3BE
,
4265 SNDRV_PCM_FMTBIT_U24_3LE
| SNDRV_PCM_FMTBIT_U24_3BE
,
4266 SNDRV_PCM_FMTBIT_S20_3LE
| SNDRV_PCM_FMTBIT_S20_3BE
,
4267 SNDRV_PCM_FMTBIT_U20_3LE
| SNDRV_PCM_FMTBIT_U20_3BE
,
4268 SNDRV_PCM_FMTBIT_S18_3LE
| SNDRV_PCM_FMTBIT_S18_3BE
,
4269 SNDRV_PCM_FMTBIT_U18_3LE
| SNDRV_PCM_FMTBIT_U18_3BE
,
4270 SNDRV_PCM_FMTBIT_FLOAT_LE
| SNDRV_PCM_FMTBIT_FLOAT_BE
,
4271 SNDRV_PCM_FMTBIT_FLOAT64_LE
| SNDRV_PCM_FMTBIT_FLOAT64_BE
,
4272 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
4273 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
,
4276 /* Fix up the DAI formats for endianness: codecs don't actually see
4277 * the endianness of the data but we're using the CPU format
4278 * definitions which do need to include endianness so we ensure that
4279 * codec DAIs always have both big and little endian variants set.
4281 static void fixup_codec_formats(struct snd_soc_pcm_stream
*stream
)
4285 for (i
= 0; i
< ARRAY_SIZE(codec_format_map
); i
++)
4286 if (stream
->formats
& codec_format_map
[i
])
4287 stream
->formats
|= codec_format_map
[i
];
4291 * snd_soc_register_codec - Register a codec with the ASoC core
4293 * @codec: codec to register
4295 int snd_soc_register_codec(struct device
*dev
,
4296 const struct snd_soc_codec_driver
*codec_drv
,
4297 struct snd_soc_dai_driver
*dai_drv
,
4300 struct snd_soc_codec
*codec
;
4303 dev_dbg(dev
, "codec register %s\n", dev_name(dev
));
4305 codec
= kzalloc(sizeof(struct snd_soc_codec
), GFP_KERNEL
);
4309 /* create CODEC component name */
4310 codec
->name
= fmt_single_name(dev
, &codec
->id
);
4311 if (codec
->name
== NULL
) {
4316 codec
->write
= codec_drv
->write
;
4317 codec
->read
= codec_drv
->read
;
4318 codec
->volatile_register
= codec_drv
->volatile_register
;
4319 codec
->readable_register
= codec_drv
->readable_register
;
4320 codec
->writable_register
= codec_drv
->writable_register
;
4321 codec
->ignore_pmdown_time
= codec_drv
->ignore_pmdown_time
;
4322 codec
->dapm
.bias_level
= SND_SOC_BIAS_OFF
;
4323 codec
->dapm
.dev
= dev
;
4324 codec
->dapm
.codec
= codec
;
4325 codec
->dapm
.seq_notifier
= codec_drv
->seq_notifier
;
4326 codec
->dapm
.stream_event
= codec_drv
->stream_event
;
4328 codec
->driver
= codec_drv
;
4329 codec
->num_dai
= num_dai
;
4330 mutex_init(&codec
->mutex
);
4332 for (i
= 0; i
< num_dai
; i
++) {
4333 fixup_codec_formats(&dai_drv
[i
].playback
);
4334 fixup_codec_formats(&dai_drv
[i
].capture
);
4337 mutex_lock(&client_mutex
);
4338 list_add(&codec
->list
, &codec_list
);
4339 mutex_unlock(&client_mutex
);
4341 /* register component */
4342 ret
= __snd_soc_register_component(dev
, &codec
->component
,
4343 &codec_drv
->component_driver
,
4344 dai_drv
, num_dai
, false);
4346 dev_err(codec
->dev
, "ASoC: Failed to regster component: %d\n", ret
);
4347 goto fail_codec_name
;
4350 dev_dbg(codec
->dev
, "ASoC: Registered codec '%s'\n", codec
->name
);
4354 mutex_lock(&client_mutex
);
4355 list_del(&codec
->list
);
4356 mutex_unlock(&client_mutex
);
4363 EXPORT_SYMBOL_GPL(snd_soc_register_codec
);
4366 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
4368 * @codec: codec to unregister
4370 void snd_soc_unregister_codec(struct device
*dev
)
4372 struct snd_soc_codec
*codec
;
4374 list_for_each_entry(codec
, &codec_list
, list
) {
4375 if (dev
== codec
->dev
)
4381 snd_soc_unregister_component(dev
);
4383 mutex_lock(&client_mutex
);
4384 list_del(&codec
->list
);
4385 mutex_unlock(&client_mutex
);
4387 dev_dbg(codec
->dev
, "ASoC: Unregistered codec '%s'\n", codec
->name
);
4389 snd_soc_cache_exit(codec
);
4393 EXPORT_SYMBOL_GPL(snd_soc_unregister_codec
);
4395 /* Retrieve a card's name from device tree */
4396 int snd_soc_of_parse_card_name(struct snd_soc_card
*card
,
4397 const char *propname
)
4399 struct device_node
*np
= card
->dev
->of_node
;
4402 ret
= of_property_read_string_index(np
, propname
, 0, &card
->name
);
4404 * EINVAL means the property does not exist. This is fine providing
4405 * card->name was previously set, which is checked later in
4406 * snd_soc_register_card.
4408 if (ret
< 0 && ret
!= -EINVAL
) {
4410 "ASoC: Property '%s' could not be read: %d\n",
4417 EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name
);
4419 int snd_soc_of_parse_audio_routing(struct snd_soc_card
*card
,
4420 const char *propname
)
4422 struct device_node
*np
= card
->dev
->of_node
;
4424 struct snd_soc_dapm_route
*routes
;
4427 num_routes
= of_property_count_strings(np
, propname
);
4428 if (num_routes
< 0 || num_routes
& 1) {
4430 "ASoC: Property '%s' does not exist or its length is not even\n",
4436 dev_err(card
->dev
, "ASoC: Property '%s's length is zero\n",
4441 routes
= devm_kzalloc(card
->dev
, num_routes
* sizeof(*routes
),
4445 "ASoC: Could not allocate DAPM route table\n");
4449 for (i
= 0; i
< num_routes
; i
++) {
4450 ret
= of_property_read_string_index(np
, propname
,
4451 2 * i
, &routes
[i
].sink
);
4454 "ASoC: Property '%s' index %d could not be read: %d\n",
4455 propname
, 2 * i
, ret
);
4458 ret
= of_property_read_string_index(np
, propname
,
4459 (2 * i
) + 1, &routes
[i
].source
);
4462 "ASoC: Property '%s' index %d could not be read: %d\n",
4463 propname
, (2 * i
) + 1, ret
);
4468 card
->num_dapm_routes
= num_routes
;
4469 card
->dapm_routes
= routes
;
4473 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing
);
4475 unsigned int snd_soc_of_parse_daifmt(struct device_node
*np
,
4480 unsigned int format
= 0;
4486 } of_fmt_table
[] = {
4487 { "i2s", SND_SOC_DAIFMT_I2S
},
4488 { "right_j", SND_SOC_DAIFMT_RIGHT_J
},
4489 { "left_j", SND_SOC_DAIFMT_LEFT_J
},
4490 { "dsp_a", SND_SOC_DAIFMT_DSP_A
},
4491 { "dsp_b", SND_SOC_DAIFMT_DSP_B
},
4492 { "ac97", SND_SOC_DAIFMT_AC97
},
4493 { "pdm", SND_SOC_DAIFMT_PDM
},
4494 { "msb", SND_SOC_DAIFMT_MSB
},
4495 { "lsb", SND_SOC_DAIFMT_LSB
},
4502 * check "[prefix]format = xxx"
4503 * SND_SOC_DAIFMT_FORMAT_MASK area
4505 snprintf(prop
, sizeof(prop
), "%sformat", prefix
);
4506 ret
= of_property_read_string(np
, prop
, &str
);
4508 for (i
= 0; i
< ARRAY_SIZE(of_fmt_table
); i
++) {
4509 if (strcmp(str
, of_fmt_table
[i
].name
) == 0) {
4510 format
|= of_fmt_table
[i
].val
;
4517 * check "[prefix]continuous-clock"
4518 * SND_SOC_DAIFMT_CLOCK_MASK area
4520 snprintf(prop
, sizeof(prop
), "%scontinuous-clock", prefix
);
4521 if (of_get_property(np
, prop
, NULL
))
4522 format
|= SND_SOC_DAIFMT_CONT
;
4524 format
|= SND_SOC_DAIFMT_GATED
;
4527 * check "[prefix]bitclock-inversion"
4528 * check "[prefix]frame-inversion"
4529 * SND_SOC_DAIFMT_INV_MASK area
4531 snprintf(prop
, sizeof(prop
), "%sbitclock-inversion", prefix
);
4532 bit
= !!of_get_property(np
, prop
, NULL
);
4534 snprintf(prop
, sizeof(prop
), "%sframe-inversion", prefix
);
4535 frame
= !!of_get_property(np
, prop
, NULL
);
4537 switch ((bit
<< 4) + frame
) {
4539 format
|= SND_SOC_DAIFMT_IB_IF
;
4542 format
|= SND_SOC_DAIFMT_IB_NF
;
4545 format
|= SND_SOC_DAIFMT_NB_IF
;
4548 /* SND_SOC_DAIFMT_NB_NF is default */
4553 * check "[prefix]bitclock-master"
4554 * check "[prefix]frame-master"
4555 * SND_SOC_DAIFMT_MASTER_MASK area
4557 snprintf(prop
, sizeof(prop
), "%sbitclock-master", prefix
);
4558 bit
= !!of_get_property(np
, prop
, NULL
);
4560 snprintf(prop
, sizeof(prop
), "%sframe-master", prefix
);
4561 frame
= !!of_get_property(np
, prop
, NULL
);
4563 switch ((bit
<< 4) + frame
) {
4565 format
|= SND_SOC_DAIFMT_CBM_CFM
;
4568 format
|= SND_SOC_DAIFMT_CBM_CFS
;
4571 format
|= SND_SOC_DAIFMT_CBS_CFM
;
4574 format
|= SND_SOC_DAIFMT_CBS_CFS
;
4580 EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt
);
4582 int snd_soc_of_get_dai_name(struct device_node
*of_node
,
4583 const char **dai_name
)
4585 struct snd_soc_component
*pos
;
4586 struct of_phandle_args args
;
4589 ret
= of_parse_phandle_with_args(of_node
, "sound-dai",
4590 "#sound-dai-cells", 0, &args
);
4594 ret
= -EPROBE_DEFER
;
4596 mutex_lock(&client_mutex
);
4597 list_for_each_entry(pos
, &component_list
, list
) {
4598 if (pos
->dev
->of_node
!= args
.np
)
4601 if (pos
->driver
->of_xlate_dai_name
) {
4602 ret
= pos
->driver
->of_xlate_dai_name(pos
, &args
, dai_name
);
4606 switch (args
.args_count
) {
4608 id
= 0; /* same as dai_drv[0] */
4618 if (id
< 0 || id
>= pos
->num_dai
) {
4621 *dai_name
= pos
->dai_drv
[id
].name
;
4628 mutex_unlock(&client_mutex
);
4630 of_node_put(args
.np
);
4634 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name
);
4636 static int __init
snd_soc_init(void)
4638 #ifdef CONFIG_DEBUG_FS
4639 snd_soc_debugfs_root
= debugfs_create_dir("asoc", NULL
);
4640 if (IS_ERR(snd_soc_debugfs_root
) || !snd_soc_debugfs_root
) {
4641 pr_warn("ASoC: Failed to create debugfs directory\n");
4642 snd_soc_debugfs_root
= NULL
;
4645 if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root
, NULL
,
4647 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
4649 if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root
, NULL
,
4651 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
4653 if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root
, NULL
,
4654 &platform_list_fops
))
4655 pr_warn("ASoC: Failed to create platform list debugfs file\n");
4658 snd_soc_util_init();
4660 return platform_driver_register(&soc_driver
);
4662 module_init(snd_soc_init
);
4664 static void __exit
snd_soc_exit(void)
4666 snd_soc_util_exit();
4668 #ifdef CONFIG_DEBUG_FS
4669 debugfs_remove_recursive(snd_soc_debugfs_root
);
4671 platform_driver_unregister(&soc_driver
);
4673 module_exit(snd_soc_exit
);
4675 /* Module information */
4676 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
4677 MODULE_DESCRIPTION("ALSA SoC Core");
4678 MODULE_LICENSE("GPL");
4679 MODULE_ALIAS("platform:soc-audio");