2 * soc-core.c -- ALSA SoC Audio Layer
4 * Copyright 2005 Wolfson Microelectronics PLC.
5 * Copyright 2005 Openedhand Ltd.
7 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
8 * with code, comments and ideas from :-
9 * Richard Purdie <richard@openedhand.com>
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
17 * o Add hw rules to enforce rates, etc.
18 * o More testing with other codecs/machines.
19 * o Add more codecs and platforms to ensure good API coverage.
20 * o Support TDM on PCM and I2S
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
28 #include <linux/bitops.h>
29 #include <linux/debugfs.h>
30 #include <linux/platform_device.h>
31 #include <linux/slab.h>
32 #include <sound/ac97_codec.h>
33 #include <sound/core.h>
34 #include <sound/pcm.h>
35 #include <sound/pcm_params.h>
36 #include <sound/soc.h>
37 #include <sound/soc-dapm.h>
38 #include <sound/initval.h>
40 static DEFINE_MUTEX(pcm_mutex
);
41 static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq
);
43 #ifdef CONFIG_DEBUG_FS
44 static struct dentry
*debugfs_root
;
47 static DEFINE_MUTEX(client_mutex
);
48 static LIST_HEAD(card_list
);
49 static LIST_HEAD(dai_list
);
50 static LIST_HEAD(platform_list
);
51 static LIST_HEAD(codec_list
);
53 static int snd_soc_register_card(struct snd_soc_card
*card
);
54 static int snd_soc_unregister_card(struct snd_soc_card
*card
);
57 * This is a timeout to do a DAPM powerdown after a stream is closed().
58 * It can be used to eliminate pops between different playback streams, e.g.
59 * between two audio tracks.
61 static int pmdown_time
= 5000;
62 module_param(pmdown_time
, int, 0);
63 MODULE_PARM_DESC(pmdown_time
, "DAPM stream powerdown time (msecs)");
66 * This function forces any delayed work to be queued and run.
68 static int run_delayed_work(struct delayed_work
*dwork
)
72 /* cancel any work waiting to be queued. */
73 ret
= cancel_delayed_work(dwork
);
75 /* if there was any work waiting then we run it now and
76 * wait for it's completion */
78 schedule_delayed_work(dwork
, 0);
79 flush_scheduled_work();
84 /* codec register dump */
85 static ssize_t
soc_codec_reg_show(struct snd_soc_codec
*codec
, char *buf
)
87 int i
, step
= 1, count
= 0;
89 if (!codec
->reg_cache_size
)
92 if (codec
->reg_cache_step
)
93 step
= codec
->reg_cache_step
;
95 count
+= sprintf(buf
, "%s registers\n", codec
->name
);
96 for (i
= 0; i
< codec
->reg_cache_size
; i
+= step
) {
97 if (codec
->readable_register
&& !codec
->readable_register(i
))
100 count
+= sprintf(buf
+ count
, "%2x: ", i
);
101 if (count
>= PAGE_SIZE
- 1)
104 if (codec
->display_register
)
105 count
+= codec
->display_register(codec
, buf
+ count
,
106 PAGE_SIZE
- count
, i
);
108 count
+= snprintf(buf
+ count
, PAGE_SIZE
- count
,
109 "%4x", codec
->read(codec
, i
));
111 if (count
>= PAGE_SIZE
- 1)
114 count
+= snprintf(buf
+ count
, PAGE_SIZE
- count
, "\n");
115 if (count
>= PAGE_SIZE
- 1)
119 /* Truncate count; min() would cause a warning */
120 if (count
>= PAGE_SIZE
)
121 count
= PAGE_SIZE
- 1;
125 static ssize_t
codec_reg_show(struct device
*dev
,
126 struct device_attribute
*attr
, char *buf
)
128 struct snd_soc_device
*devdata
= dev_get_drvdata(dev
);
129 return soc_codec_reg_show(devdata
->card
->codec
, buf
);
132 static DEVICE_ATTR(codec_reg
, 0444, codec_reg_show
, NULL
);
134 static ssize_t
pmdown_time_show(struct device
*dev
,
135 struct device_attribute
*attr
, char *buf
)
137 struct snd_soc_device
*socdev
= dev_get_drvdata(dev
);
138 struct snd_soc_card
*card
= socdev
->card
;
140 return sprintf(buf
, "%ld\n", card
->pmdown_time
);
143 static ssize_t
pmdown_time_set(struct device
*dev
,
144 struct device_attribute
*attr
,
145 const char *buf
, size_t count
)
147 struct snd_soc_device
*socdev
= dev_get_drvdata(dev
);
148 struct snd_soc_card
*card
= socdev
->card
;
150 strict_strtol(buf
, 10, &card
->pmdown_time
);
155 static DEVICE_ATTR(pmdown_time
, 0644, pmdown_time_show
, pmdown_time_set
);
157 #ifdef CONFIG_DEBUG_FS
158 static int codec_reg_open_file(struct inode
*inode
, struct file
*file
)
160 file
->private_data
= inode
->i_private
;
164 static ssize_t
codec_reg_read_file(struct file
*file
, char __user
*user_buf
,
165 size_t count
, loff_t
*ppos
)
168 struct snd_soc_codec
*codec
= file
->private_data
;
169 char *buf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
172 ret
= soc_codec_reg_show(codec
, buf
);
174 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, ret
);
179 static ssize_t
codec_reg_write_file(struct file
*file
,
180 const char __user
*user_buf
, size_t count
, loff_t
*ppos
)
185 unsigned long reg
, value
;
187 struct snd_soc_codec
*codec
= file
->private_data
;
189 buf_size
= min(count
, (sizeof(buf
)-1));
190 if (copy_from_user(buf
, user_buf
, buf_size
))
194 if (codec
->reg_cache_step
)
195 step
= codec
->reg_cache_step
;
197 while (*start
== ' ')
199 reg
= simple_strtoul(start
, &start
, 16);
200 if ((reg
>= codec
->reg_cache_size
) || (reg
% step
))
202 while (*start
== ' ')
204 if (strict_strtoul(start
, 16, &value
))
206 codec
->write(codec
, reg
, value
);
210 static const struct file_operations codec_reg_fops
= {
211 .open
= codec_reg_open_file
,
212 .read
= codec_reg_read_file
,
213 .write
= codec_reg_write_file
,
216 static void soc_init_codec_debugfs(struct snd_soc_codec
*codec
)
218 char codec_root
[128];
221 snprintf(codec_root
, sizeof(codec_root
),
222 "%s.%s", codec
->name
, dev_name(codec
->dev
));
224 snprintf(codec_root
, sizeof(codec_root
),
227 codec
->debugfs_codec_root
= debugfs_create_dir(codec_root
,
229 if (!codec
->debugfs_codec_root
) {
231 "ASoC: Failed to create codec debugfs directory\n");
235 codec
->debugfs_reg
= debugfs_create_file("codec_reg", 0644,
236 codec
->debugfs_codec_root
,
237 codec
, &codec_reg_fops
);
238 if (!codec
->debugfs_reg
)
240 "ASoC: Failed to create codec register debugfs file\n");
242 codec
->debugfs_pop_time
= debugfs_create_u32("dapm_pop_time", 0744,
243 codec
->debugfs_codec_root
,
245 if (!codec
->debugfs_pop_time
)
247 "Failed to create pop time debugfs file\n");
249 codec
->debugfs_dapm
= debugfs_create_dir("dapm",
250 codec
->debugfs_codec_root
);
251 if (!codec
->debugfs_dapm
)
253 "Failed to create DAPM debugfs directory\n");
255 snd_soc_dapm_debugfs_init(codec
);
258 static void soc_cleanup_codec_debugfs(struct snd_soc_codec
*codec
)
260 debugfs_remove_recursive(codec
->debugfs_codec_root
);
265 static inline void soc_init_codec_debugfs(struct snd_soc_codec
*codec
)
269 static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec
*codec
)
274 #ifdef CONFIG_SND_SOC_AC97_BUS
275 /* unregister ac97 codec */
276 static int soc_ac97_dev_unregister(struct snd_soc_codec
*codec
)
278 if (codec
->ac97
->dev
.bus
)
279 device_unregister(&codec
->ac97
->dev
);
283 /* stop no dev release warning */
284 static void soc_ac97_device_release(struct device
*dev
){}
286 /* register ac97 codec to bus */
287 static int soc_ac97_dev_register(struct snd_soc_codec
*codec
)
291 codec
->ac97
->dev
.bus
= &ac97_bus_type
;
292 codec
->ac97
->dev
.parent
= codec
->card
->dev
;
293 codec
->ac97
->dev
.release
= soc_ac97_device_release
;
295 dev_set_name(&codec
->ac97
->dev
, "%d-%d:%s",
296 codec
->card
->number
, 0, codec
->name
);
297 err
= device_register(&codec
->ac97
->dev
);
299 snd_printk(KERN_ERR
"Can't register ac97 bus\n");
300 codec
->ac97
->dev
.bus
= NULL
;
307 static int soc_pcm_apply_symmetry(struct snd_pcm_substream
*substream
)
309 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
310 struct snd_soc_device
*socdev
= rtd
->socdev
;
311 struct snd_soc_card
*card
= socdev
->card
;
312 struct snd_soc_dai_link
*machine
= rtd
->dai
;
313 struct snd_soc_dai
*cpu_dai
= machine
->cpu_dai
;
314 struct snd_soc_dai
*codec_dai
= machine
->codec_dai
;
317 if (codec_dai
->symmetric_rates
|| cpu_dai
->symmetric_rates
||
318 machine
->symmetric_rates
) {
319 dev_dbg(card
->dev
, "Symmetry forces %dHz rate\n",
322 ret
= snd_pcm_hw_constraint_minmax(substream
->runtime
,
323 SNDRV_PCM_HW_PARAM_RATE
,
328 "Unable to apply rate symmetry constraint: %d\n", ret
);
337 * Called by ALSA when a PCM substream is opened, the runtime->hw record is
338 * then initialized and any private data can be allocated. This also calls
339 * startup for the cpu DAI, platform, machine and codec DAI.
341 static int soc_pcm_open(struct snd_pcm_substream
*substream
)
343 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
344 struct snd_soc_device
*socdev
= rtd
->socdev
;
345 struct snd_soc_card
*card
= socdev
->card
;
346 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
347 struct snd_soc_dai_link
*machine
= rtd
->dai
;
348 struct snd_soc_platform
*platform
= card
->platform
;
349 struct snd_soc_dai
*cpu_dai
= machine
->cpu_dai
;
350 struct snd_soc_dai
*codec_dai
= machine
->codec_dai
;
353 mutex_lock(&pcm_mutex
);
355 /* startup the audio subsystem */
356 if (cpu_dai
->ops
->startup
) {
357 ret
= cpu_dai
->ops
->startup(substream
, cpu_dai
);
359 printk(KERN_ERR
"asoc: can't open interface %s\n",
365 if (platform
->pcm_ops
->open
) {
366 ret
= platform
->pcm_ops
->open(substream
);
368 printk(KERN_ERR
"asoc: can't open platform %s\n", platform
->name
);
373 if (codec_dai
->ops
->startup
) {
374 ret
= codec_dai
->ops
->startup(substream
, codec_dai
);
376 printk(KERN_ERR
"asoc: can't open codec %s\n",
382 if (machine
->ops
&& machine
->ops
->startup
) {
383 ret
= machine
->ops
->startup(substream
);
385 printk(KERN_ERR
"asoc: %s startup failed\n", machine
->name
);
390 /* Check that the codec and cpu DAI's are compatible */
391 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
392 runtime
->hw
.rate_min
=
393 max(codec_dai
->playback
.rate_min
,
394 cpu_dai
->playback
.rate_min
);
395 runtime
->hw
.rate_max
=
396 min(codec_dai
->playback
.rate_max
,
397 cpu_dai
->playback
.rate_max
);
398 runtime
->hw
.channels_min
=
399 max(codec_dai
->playback
.channels_min
,
400 cpu_dai
->playback
.channels_min
);
401 runtime
->hw
.channels_max
=
402 min(codec_dai
->playback
.channels_max
,
403 cpu_dai
->playback
.channels_max
);
404 runtime
->hw
.formats
=
405 codec_dai
->playback
.formats
& cpu_dai
->playback
.formats
;
407 codec_dai
->playback
.rates
& cpu_dai
->playback
.rates
;
409 runtime
->hw
.rate_min
=
410 max(codec_dai
->capture
.rate_min
,
411 cpu_dai
->capture
.rate_min
);
412 runtime
->hw
.rate_max
=
413 min(codec_dai
->capture
.rate_max
,
414 cpu_dai
->capture
.rate_max
);
415 runtime
->hw
.channels_min
=
416 max(codec_dai
->capture
.channels_min
,
417 cpu_dai
->capture
.channels_min
);
418 runtime
->hw
.channels_max
=
419 min(codec_dai
->capture
.channels_max
,
420 cpu_dai
->capture
.channels_max
);
421 runtime
->hw
.formats
=
422 codec_dai
->capture
.formats
& cpu_dai
->capture
.formats
;
424 codec_dai
->capture
.rates
& cpu_dai
->capture
.rates
;
427 snd_pcm_limit_hw_rates(runtime
);
428 if (!runtime
->hw
.rates
) {
429 printk(KERN_ERR
"asoc: %s <-> %s No matching rates\n",
430 codec_dai
->name
, cpu_dai
->name
);
433 if (!runtime
->hw
.formats
) {
434 printk(KERN_ERR
"asoc: %s <-> %s No matching formats\n",
435 codec_dai
->name
, cpu_dai
->name
);
438 if (!runtime
->hw
.channels_min
|| !runtime
->hw
.channels_max
) {
439 printk(KERN_ERR
"asoc: %s <-> %s No matching channels\n",
440 codec_dai
->name
, cpu_dai
->name
);
444 /* Symmetry only applies if we've already got an active stream. */
445 if (cpu_dai
->active
|| codec_dai
->active
) {
446 ret
= soc_pcm_apply_symmetry(substream
);
451 pr_debug("asoc: %s <-> %s info:\n", codec_dai
->name
, cpu_dai
->name
);
452 pr_debug("asoc: rate mask 0x%x\n", runtime
->hw
.rates
);
453 pr_debug("asoc: min ch %d max ch %d\n", runtime
->hw
.channels_min
,
454 runtime
->hw
.channels_max
);
455 pr_debug("asoc: min rate %d max rate %d\n", runtime
->hw
.rate_min
,
456 runtime
->hw
.rate_max
);
458 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
459 cpu_dai
->playback
.active
= codec_dai
->playback
.active
= 1;
461 cpu_dai
->capture
.active
= codec_dai
->capture
.active
= 1;
462 cpu_dai
->active
= codec_dai
->active
= 1;
463 cpu_dai
->runtime
= runtime
;
464 card
->codec
->active
++;
465 mutex_unlock(&pcm_mutex
);
469 if (machine
->ops
&& machine
->ops
->shutdown
)
470 machine
->ops
->shutdown(substream
);
473 if (codec_dai
->ops
->shutdown
)
474 codec_dai
->ops
->shutdown(substream
, codec_dai
);
477 if (platform
->pcm_ops
->close
)
478 platform
->pcm_ops
->close(substream
);
481 if (cpu_dai
->ops
->shutdown
)
482 cpu_dai
->ops
->shutdown(substream
, cpu_dai
);
484 mutex_unlock(&pcm_mutex
);
489 * Power down the audio subsystem pmdown_time msecs after close is called.
490 * This is to ensure there are no pops or clicks in between any music tracks
491 * due to DAPM power cycling.
493 static void close_delayed_work(struct work_struct
*work
)
495 struct snd_soc_card
*card
= container_of(work
, struct snd_soc_card
,
497 struct snd_soc_codec
*codec
= card
->codec
;
498 struct snd_soc_dai
*codec_dai
;
501 mutex_lock(&pcm_mutex
);
502 for (i
= 0; i
< codec
->num_dai
; i
++) {
503 codec_dai
= &codec
->dai
[i
];
505 pr_debug("pop wq checking: %s status: %s waiting: %s\n",
506 codec_dai
->playback
.stream_name
,
507 codec_dai
->playback
.active
? "active" : "inactive",
508 codec_dai
->pop_wait
? "yes" : "no");
510 /* are we waiting on this codec DAI stream */
511 if (codec_dai
->pop_wait
== 1) {
512 codec_dai
->pop_wait
= 0;
513 snd_soc_dapm_stream_event(codec
,
514 codec_dai
->playback
.stream_name
,
515 SND_SOC_DAPM_STREAM_STOP
);
518 mutex_unlock(&pcm_mutex
);
522 * Called by ALSA when a PCM substream is closed. Private data can be
523 * freed here. The cpu DAI, codec DAI, machine and platform are also
526 static int soc_codec_close(struct snd_pcm_substream
*substream
)
528 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
529 struct snd_soc_device
*socdev
= rtd
->socdev
;
530 struct snd_soc_card
*card
= socdev
->card
;
531 struct snd_soc_dai_link
*machine
= rtd
->dai
;
532 struct snd_soc_platform
*platform
= card
->platform
;
533 struct snd_soc_dai
*cpu_dai
= machine
->cpu_dai
;
534 struct snd_soc_dai
*codec_dai
= machine
->codec_dai
;
535 struct snd_soc_codec
*codec
= card
->codec
;
537 mutex_lock(&pcm_mutex
);
539 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
540 cpu_dai
->playback
.active
= codec_dai
->playback
.active
= 0;
542 cpu_dai
->capture
.active
= codec_dai
->capture
.active
= 0;
544 if (codec_dai
->playback
.active
== 0 &&
545 codec_dai
->capture
.active
== 0) {
546 cpu_dai
->active
= codec_dai
->active
= 0;
550 /* Muting the DAC suppresses artifacts caused during digital
551 * shutdown, for example from stopping clocks.
553 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
554 snd_soc_dai_digital_mute(codec_dai
, 1);
556 if (cpu_dai
->ops
->shutdown
)
557 cpu_dai
->ops
->shutdown(substream
, cpu_dai
);
559 if (codec_dai
->ops
->shutdown
)
560 codec_dai
->ops
->shutdown(substream
, codec_dai
);
562 if (machine
->ops
&& machine
->ops
->shutdown
)
563 machine
->ops
->shutdown(substream
);
565 if (platform
->pcm_ops
->close
)
566 platform
->pcm_ops
->close(substream
);
567 cpu_dai
->runtime
= NULL
;
569 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
570 /* start delayed pop wq here for playback streams */
571 codec_dai
->pop_wait
= 1;
572 schedule_delayed_work(&card
->delayed_work
,
573 msecs_to_jiffies(card
->pmdown_time
));
575 /* capture streams can be powered down now */
576 snd_soc_dapm_stream_event(codec
,
577 codec_dai
->capture
.stream_name
,
578 SND_SOC_DAPM_STREAM_STOP
);
581 mutex_unlock(&pcm_mutex
);
586 * Called by ALSA when the PCM substream is prepared, can set format, sample
587 * rate, etc. This function is non atomic and can be called multiple times,
588 * it can refer to the runtime info.
590 static int soc_pcm_prepare(struct snd_pcm_substream
*substream
)
592 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
593 struct snd_soc_device
*socdev
= rtd
->socdev
;
594 struct snd_soc_card
*card
= socdev
->card
;
595 struct snd_soc_dai_link
*machine
= rtd
->dai
;
596 struct snd_soc_platform
*platform
= card
->platform
;
597 struct snd_soc_dai
*cpu_dai
= machine
->cpu_dai
;
598 struct snd_soc_dai
*codec_dai
= machine
->codec_dai
;
599 struct snd_soc_codec
*codec
= card
->codec
;
602 mutex_lock(&pcm_mutex
);
604 if (machine
->ops
&& machine
->ops
->prepare
) {
605 ret
= machine
->ops
->prepare(substream
);
607 printk(KERN_ERR
"asoc: machine prepare error\n");
612 if (platform
->pcm_ops
->prepare
) {
613 ret
= platform
->pcm_ops
->prepare(substream
);
615 printk(KERN_ERR
"asoc: platform prepare error\n");
620 if (codec_dai
->ops
->prepare
) {
621 ret
= codec_dai
->ops
->prepare(substream
, codec_dai
);
623 printk(KERN_ERR
"asoc: codec DAI prepare error\n");
628 if (cpu_dai
->ops
->prepare
) {
629 ret
= cpu_dai
->ops
->prepare(substream
, cpu_dai
);
631 printk(KERN_ERR
"asoc: cpu DAI prepare error\n");
636 /* cancel any delayed stream shutdown that is pending */
637 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
&&
638 codec_dai
->pop_wait
) {
639 codec_dai
->pop_wait
= 0;
640 cancel_delayed_work(&card
->delayed_work
);
643 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
644 snd_soc_dapm_stream_event(codec
,
645 codec_dai
->playback
.stream_name
,
646 SND_SOC_DAPM_STREAM_START
);
648 snd_soc_dapm_stream_event(codec
,
649 codec_dai
->capture
.stream_name
,
650 SND_SOC_DAPM_STREAM_START
);
652 snd_soc_dai_digital_mute(codec_dai
, 0);
655 mutex_unlock(&pcm_mutex
);
660 * Called by ALSA when the hardware params are set by application. This
661 * function can also be called multiple times and can allocate buffers
662 * (using snd_pcm_lib_* ). It's non-atomic.
664 static int soc_pcm_hw_params(struct snd_pcm_substream
*substream
,
665 struct snd_pcm_hw_params
*params
)
667 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
668 struct snd_soc_device
*socdev
= rtd
->socdev
;
669 struct snd_soc_dai_link
*machine
= rtd
->dai
;
670 struct snd_soc_card
*card
= socdev
->card
;
671 struct snd_soc_platform
*platform
= card
->platform
;
672 struct snd_soc_dai
*cpu_dai
= machine
->cpu_dai
;
673 struct snd_soc_dai
*codec_dai
= machine
->codec_dai
;
676 mutex_lock(&pcm_mutex
);
678 if (machine
->ops
&& machine
->ops
->hw_params
) {
679 ret
= machine
->ops
->hw_params(substream
, params
);
681 printk(KERN_ERR
"asoc: machine hw_params failed\n");
686 if (codec_dai
->ops
->hw_params
) {
687 ret
= codec_dai
->ops
->hw_params(substream
, params
, codec_dai
);
689 printk(KERN_ERR
"asoc: can't set codec %s hw params\n",
695 if (cpu_dai
->ops
->hw_params
) {
696 ret
= cpu_dai
->ops
->hw_params(substream
, params
, cpu_dai
);
698 printk(KERN_ERR
"asoc: interface %s hw params failed\n",
704 if (platform
->pcm_ops
->hw_params
) {
705 ret
= platform
->pcm_ops
->hw_params(substream
, params
);
707 printk(KERN_ERR
"asoc: platform %s hw params failed\n",
713 machine
->rate
= params_rate(params
);
716 mutex_unlock(&pcm_mutex
);
720 if (cpu_dai
->ops
->hw_free
)
721 cpu_dai
->ops
->hw_free(substream
, cpu_dai
);
724 if (codec_dai
->ops
->hw_free
)
725 codec_dai
->ops
->hw_free(substream
, codec_dai
);
728 if (machine
->ops
&& machine
->ops
->hw_free
)
729 machine
->ops
->hw_free(substream
);
731 mutex_unlock(&pcm_mutex
);
736 * Free's resources allocated by hw_params, can be called multiple times
738 static int soc_pcm_hw_free(struct snd_pcm_substream
*substream
)
740 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
741 struct snd_soc_device
*socdev
= rtd
->socdev
;
742 struct snd_soc_dai_link
*machine
= rtd
->dai
;
743 struct snd_soc_card
*card
= socdev
->card
;
744 struct snd_soc_platform
*platform
= card
->platform
;
745 struct snd_soc_dai
*cpu_dai
= machine
->cpu_dai
;
746 struct snd_soc_dai
*codec_dai
= machine
->codec_dai
;
747 struct snd_soc_codec
*codec
= card
->codec
;
749 mutex_lock(&pcm_mutex
);
751 /* apply codec digital mute */
753 snd_soc_dai_digital_mute(codec_dai
, 1);
755 /* free any machine hw params */
756 if (machine
->ops
&& machine
->ops
->hw_free
)
757 machine
->ops
->hw_free(substream
);
759 /* free any DMA resources */
760 if (platform
->pcm_ops
->hw_free
)
761 platform
->pcm_ops
->hw_free(substream
);
763 /* now free hw params for the DAI's */
764 if (codec_dai
->ops
->hw_free
)
765 codec_dai
->ops
->hw_free(substream
, codec_dai
);
767 if (cpu_dai
->ops
->hw_free
)
768 cpu_dai
->ops
->hw_free(substream
, cpu_dai
);
770 mutex_unlock(&pcm_mutex
);
774 static int soc_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
776 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
777 struct snd_soc_device
*socdev
= rtd
->socdev
;
778 struct snd_soc_card
*card
= socdev
->card
;
779 struct snd_soc_dai_link
*machine
= rtd
->dai
;
780 struct snd_soc_platform
*platform
= card
->platform
;
781 struct snd_soc_dai
*cpu_dai
= machine
->cpu_dai
;
782 struct snd_soc_dai
*codec_dai
= machine
->codec_dai
;
785 if (codec_dai
->ops
->trigger
) {
786 ret
= codec_dai
->ops
->trigger(substream
, cmd
, codec_dai
);
791 if (platform
->pcm_ops
->trigger
) {
792 ret
= platform
->pcm_ops
->trigger(substream
, cmd
);
797 if (cpu_dai
->ops
->trigger
) {
798 ret
= cpu_dai
->ops
->trigger(substream
, cmd
, cpu_dai
);
805 /* ASoC PCM operations */
806 static struct snd_pcm_ops soc_pcm_ops
= {
807 .open
= soc_pcm_open
,
808 .close
= soc_codec_close
,
809 .hw_params
= soc_pcm_hw_params
,
810 .hw_free
= soc_pcm_hw_free
,
811 .prepare
= soc_pcm_prepare
,
812 .trigger
= soc_pcm_trigger
,
816 /* powers down audio subsystem for suspend */
817 static int soc_suspend(struct device
*dev
)
819 struct platform_device
*pdev
= to_platform_device(dev
);
820 struct snd_soc_device
*socdev
= platform_get_drvdata(pdev
);
821 struct snd_soc_card
*card
= socdev
->card
;
822 struct snd_soc_platform
*platform
= card
->platform
;
823 struct snd_soc_codec_device
*codec_dev
= socdev
->codec_dev
;
824 struct snd_soc_codec
*codec
= card
->codec
;
827 /* If the initialization of this soc device failed, there is no codec
828 * associated with it. Just bail out in this case.
833 /* Due to the resume being scheduled into a workqueue we could
834 * suspend before that's finished - wait for it to complete.
836 snd_power_lock(codec
->card
);
837 snd_power_wait(codec
->card
, SNDRV_CTL_POWER_D0
);
838 snd_power_unlock(codec
->card
);
840 /* we're going to block userspace touching us until resume completes */
841 snd_power_change_state(codec
->card
, SNDRV_CTL_POWER_D3hot
);
843 /* mute any active DAC's */
844 for (i
= 0; i
< card
->num_links
; i
++) {
845 struct snd_soc_dai
*dai
= card
->dai_link
[i
].codec_dai
;
846 if (dai
->ops
->digital_mute
&& dai
->playback
.active
)
847 dai
->ops
->digital_mute(dai
, 1);
850 /* suspend all pcms */
851 for (i
= 0; i
< card
->num_links
; i
++)
852 snd_pcm_suspend_all(card
->dai_link
[i
].pcm
);
854 if (card
->suspend_pre
)
855 card
->suspend_pre(pdev
, PMSG_SUSPEND
);
857 for (i
= 0; i
< card
->num_links
; i
++) {
858 struct snd_soc_dai
*cpu_dai
= card
->dai_link
[i
].cpu_dai
;
859 if (cpu_dai
->suspend
&& !cpu_dai
->ac97_control
)
860 cpu_dai
->suspend(cpu_dai
);
861 if (platform
->suspend
)
862 platform
->suspend(cpu_dai
);
865 /* close any waiting streams and save state */
866 run_delayed_work(&card
->delayed_work
);
867 codec
->suspend_bias_level
= codec
->bias_level
;
869 for (i
= 0; i
< codec
->num_dai
; i
++) {
870 char *stream
= codec
->dai
[i
].playback
.stream_name
;
872 snd_soc_dapm_stream_event(codec
, stream
,
873 SND_SOC_DAPM_STREAM_SUSPEND
);
874 stream
= codec
->dai
[i
].capture
.stream_name
;
876 snd_soc_dapm_stream_event(codec
, stream
,
877 SND_SOC_DAPM_STREAM_SUSPEND
);
880 if (codec_dev
->suspend
)
881 codec_dev
->suspend(pdev
, PMSG_SUSPEND
);
883 for (i
= 0; i
< card
->num_links
; i
++) {
884 struct snd_soc_dai
*cpu_dai
= card
->dai_link
[i
].cpu_dai
;
885 if (cpu_dai
->suspend
&& cpu_dai
->ac97_control
)
886 cpu_dai
->suspend(cpu_dai
);
889 if (card
->suspend_post
)
890 card
->suspend_post(pdev
, PMSG_SUSPEND
);
895 /* deferred resume work, so resume can complete before we finished
896 * setting our codec back up, which can be very slow on I2C
898 static void soc_resume_deferred(struct work_struct
*work
)
900 struct snd_soc_card
*card
= container_of(work
,
902 deferred_resume_work
);
903 struct snd_soc_device
*socdev
= card
->socdev
;
904 struct snd_soc_platform
*platform
= card
->platform
;
905 struct snd_soc_codec_device
*codec_dev
= socdev
->codec_dev
;
906 struct snd_soc_codec
*codec
= card
->codec
;
907 struct platform_device
*pdev
= to_platform_device(socdev
->dev
);
910 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
911 * so userspace apps are blocked from touching us
914 dev_dbg(socdev
->dev
, "starting resume work\n");
916 if (card
->resume_pre
)
917 card
->resume_pre(pdev
);
919 for (i
= 0; i
< card
->num_links
; i
++) {
920 struct snd_soc_dai
*cpu_dai
= card
->dai_link
[i
].cpu_dai
;
921 if (cpu_dai
->resume
&& cpu_dai
->ac97_control
)
922 cpu_dai
->resume(cpu_dai
);
925 if (codec_dev
->resume
)
926 codec_dev
->resume(pdev
);
928 for (i
= 0; i
< codec
->num_dai
; i
++) {
929 char *stream
= codec
->dai
[i
].playback
.stream_name
;
931 snd_soc_dapm_stream_event(codec
, stream
,
932 SND_SOC_DAPM_STREAM_RESUME
);
933 stream
= codec
->dai
[i
].capture
.stream_name
;
935 snd_soc_dapm_stream_event(codec
, stream
,
936 SND_SOC_DAPM_STREAM_RESUME
);
939 /* unmute any active DACs */
940 for (i
= 0; i
< card
->num_links
; i
++) {
941 struct snd_soc_dai
*dai
= card
->dai_link
[i
].codec_dai
;
942 if (dai
->ops
->digital_mute
&& dai
->playback
.active
)
943 dai
->ops
->digital_mute(dai
, 0);
946 for (i
= 0; i
< card
->num_links
; i
++) {
947 struct snd_soc_dai
*cpu_dai
= card
->dai_link
[i
].cpu_dai
;
948 if (cpu_dai
->resume
&& !cpu_dai
->ac97_control
)
949 cpu_dai
->resume(cpu_dai
);
950 if (platform
->resume
)
951 platform
->resume(cpu_dai
);
954 if (card
->resume_post
)
955 card
->resume_post(pdev
);
957 dev_dbg(socdev
->dev
, "resume work completed\n");
959 /* userspace can access us now we are back as we were before */
960 snd_power_change_state(codec
->card
, SNDRV_CTL_POWER_D0
);
963 /* powers up audio subsystem after a suspend */
964 static int soc_resume(struct device
*dev
)
966 struct platform_device
*pdev
= to_platform_device(dev
);
967 struct snd_soc_device
*socdev
= platform_get_drvdata(pdev
);
968 struct snd_soc_card
*card
= socdev
->card
;
969 struct snd_soc_dai
*cpu_dai
= card
->dai_link
[0].cpu_dai
;
971 /* If the initialization of this soc device failed, there is no codec
972 * associated with it. Just bail out in this case.
977 /* AC97 devices might have other drivers hanging off them so
978 * need to resume immediately. Other drivers don't have that
979 * problem and may take a substantial amount of time to resume
980 * due to I/O costs and anti-pop so handle them out of line.
982 if (cpu_dai
->ac97_control
) {
983 dev_dbg(socdev
->dev
, "Resuming AC97 immediately\n");
984 soc_resume_deferred(&card
->deferred_resume_work
);
986 dev_dbg(socdev
->dev
, "Scheduling resume work\n");
987 if (!schedule_work(&card
->deferred_resume_work
))
988 dev_err(socdev
->dev
, "resume work item may be lost\n");
994 #define soc_suspend NULL
995 #define soc_resume NULL
998 static struct snd_soc_dai_ops null_dai_ops
= {
1001 static void snd_soc_instantiate_card(struct snd_soc_card
*card
)
1003 struct platform_device
*pdev
= container_of(card
->dev
,
1004 struct platform_device
,
1006 struct snd_soc_codec_device
*codec_dev
= card
->socdev
->codec_dev
;
1007 struct snd_soc_codec
*codec
;
1008 struct snd_soc_platform
*platform
;
1009 struct snd_soc_dai
*dai
;
1010 int i
, found
, ret
, ac97
;
1012 if (card
->instantiated
)
1016 list_for_each_entry(platform
, &platform_list
, list
)
1017 if (card
->platform
== platform
) {
1022 dev_dbg(card
->dev
, "Platform %s not registered\n",
1023 card
->platform
->name
);
1028 for (i
= 0; i
< card
->num_links
; i
++) {
1030 list_for_each_entry(dai
, &dai_list
, list
)
1031 if (card
->dai_link
[i
].cpu_dai
== dai
) {
1036 dev_dbg(card
->dev
, "DAI %s not registered\n",
1037 card
->dai_link
[i
].cpu_dai
->name
);
1041 if (card
->dai_link
[i
].cpu_dai
->ac97_control
)
1045 for (i
= 0; i
< card
->num_links
; i
++) {
1046 if (!card
->dai_link
[i
].codec_dai
->ops
)
1047 card
->dai_link
[i
].codec_dai
->ops
= &null_dai_ops
;
1050 /* If we have AC97 in the system then don't wait for the
1051 * codec. This will need revisiting if we have to handle
1052 * systems with mixed AC97 and non-AC97 parts. Only check for
1053 * DAIs currently; we can't do this per link since some AC97
1054 * codecs have non-AC97 DAIs.
1057 for (i
= 0; i
< card
->num_links
; i
++) {
1059 list_for_each_entry(dai
, &dai_list
, list
)
1060 if (card
->dai_link
[i
].codec_dai
== dai
) {
1065 dev_dbg(card
->dev
, "DAI %s not registered\n",
1066 card
->dai_link
[i
].codec_dai
->name
);
1071 /* Note that we do not current check for codec components */
1073 dev_dbg(card
->dev
, "All components present, instantiating\n");
1075 /* Found everything, bring it up */
1076 card
->pmdown_time
= pmdown_time
;
1079 ret
= card
->probe(pdev
);
1084 for (i
= 0; i
< card
->num_links
; i
++) {
1085 struct snd_soc_dai
*cpu_dai
= card
->dai_link
[i
].cpu_dai
;
1086 if (cpu_dai
->probe
) {
1087 ret
= cpu_dai
->probe(pdev
, cpu_dai
);
1093 if (codec_dev
->probe
) {
1094 ret
= codec_dev
->probe(pdev
);
1098 codec
= card
->codec
;
1100 if (platform
->probe
) {
1101 ret
= platform
->probe(pdev
);
1106 /* DAPM stream work */
1107 INIT_DELAYED_WORK(&card
->delayed_work
, close_delayed_work
);
1109 /* deferred resume work */
1110 INIT_WORK(&card
->deferred_resume_work
, soc_resume_deferred
);
1113 for (i
= 0; i
< card
->num_links
; i
++) {
1114 if (card
->dai_link
[i
].init
) {
1115 ret
= card
->dai_link
[i
].init(codec
);
1117 printk(KERN_ERR
"asoc: failed to init %s\n",
1118 card
->dai_link
[i
].stream_name
);
1122 if (card
->dai_link
[i
].codec_dai
->ac97_control
)
1126 snprintf(codec
->card
->shortname
, sizeof(codec
->card
->shortname
),
1128 snprintf(codec
->card
->longname
, sizeof(codec
->card
->longname
),
1129 "%s (%s)", card
->name
, codec
->name
);
1131 /* Make sure all DAPM widgets are instantiated */
1132 snd_soc_dapm_new_widgets(codec
);
1134 ret
= snd_card_register(codec
->card
);
1136 printk(KERN_ERR
"asoc: failed to register soundcard for %s\n",
1141 mutex_lock(&codec
->mutex
);
1142 #ifdef CONFIG_SND_SOC_AC97_BUS
1143 /* Only instantiate AC97 if not already done by the adaptor
1144 * for the generic AC97 subsystem.
1146 if (ac97
&& strcmp(codec
->name
, "AC97") != 0) {
1147 ret
= soc_ac97_dev_register(codec
);
1149 printk(KERN_ERR
"asoc: AC97 device register failed\n");
1150 snd_card_free(codec
->card
);
1151 mutex_unlock(&codec
->mutex
);
1157 ret
= snd_soc_dapm_sys_add(card
->socdev
->dev
);
1159 printk(KERN_WARNING
"asoc: failed to add dapm sysfs entries\n");
1161 ret
= device_create_file(card
->socdev
->dev
, &dev_attr_pmdown_time
);
1163 printk(KERN_WARNING
"asoc: failed to add pmdown_time sysfs\n");
1165 ret
= device_create_file(card
->socdev
->dev
, &dev_attr_codec_reg
);
1167 printk(KERN_WARNING
"asoc: failed to add codec sysfs files\n");
1169 soc_init_codec_debugfs(codec
);
1170 mutex_unlock(&codec
->mutex
);
1172 card
->instantiated
= 1;
1177 if (platform
->remove
)
1178 platform
->remove(pdev
);
1181 if (codec_dev
->remove
)
1182 codec_dev
->remove(pdev
);
1185 for (i
--; i
>= 0; i
--) {
1186 struct snd_soc_dai
*cpu_dai
= card
->dai_link
[i
].cpu_dai
;
1187 if (cpu_dai
->remove
)
1188 cpu_dai
->remove(pdev
, cpu_dai
);
1196 * Attempt to initialise any uninitalised cards. Must be called with
1199 static void snd_soc_instantiate_cards(void)
1201 struct snd_soc_card
*card
;
1202 list_for_each_entry(card
, &card_list
, list
)
1203 snd_soc_instantiate_card(card
);
1206 /* probes a new socdev */
1207 static int soc_probe(struct platform_device
*pdev
)
1210 struct snd_soc_device
*socdev
= platform_get_drvdata(pdev
);
1211 struct snd_soc_card
*card
= socdev
->card
;
1213 /* Bodge while we push things out of socdev */
1214 card
->socdev
= socdev
;
1216 /* Bodge while we unpick instantiation */
1217 card
->dev
= &pdev
->dev
;
1218 ret
= snd_soc_register_card(card
);
1220 dev_err(&pdev
->dev
, "Failed to register card\n");
1227 /* removes a socdev */
1228 static int soc_remove(struct platform_device
*pdev
)
1231 struct snd_soc_device
*socdev
= platform_get_drvdata(pdev
);
1232 struct snd_soc_card
*card
= socdev
->card
;
1233 struct snd_soc_platform
*platform
= card
->platform
;
1234 struct snd_soc_codec_device
*codec_dev
= socdev
->codec_dev
;
1236 if (!card
->instantiated
)
1239 run_delayed_work(&card
->delayed_work
);
1241 if (platform
->remove
)
1242 platform
->remove(pdev
);
1244 if (codec_dev
->remove
)
1245 codec_dev
->remove(pdev
);
1247 for (i
= 0; i
< card
->num_links
; i
++) {
1248 struct snd_soc_dai
*cpu_dai
= card
->dai_link
[i
].cpu_dai
;
1249 if (cpu_dai
->remove
)
1250 cpu_dai
->remove(pdev
, cpu_dai
);
1256 snd_soc_unregister_card(card
);
1261 static int soc_poweroff(struct device
*dev
)
1263 struct platform_device
*pdev
= to_platform_device(dev
);
1264 struct snd_soc_device
*socdev
= platform_get_drvdata(pdev
);
1265 struct snd_soc_card
*card
= socdev
->card
;
1267 if (!card
->instantiated
)
1270 /* Flush out pmdown_time work - we actually do want to run it
1271 * now, we're shutting down so no imminent restart. */
1272 run_delayed_work(&card
->delayed_work
);
1274 snd_soc_dapm_shutdown(socdev
);
1279 static const struct dev_pm_ops soc_pm_ops
= {
1280 .suspend
= soc_suspend
,
1281 .resume
= soc_resume
,
1282 .poweroff
= soc_poweroff
,
1285 /* ASoC platform driver */
1286 static struct platform_driver soc_driver
= {
1288 .name
= "soc-audio",
1289 .owner
= THIS_MODULE
,
1293 .remove
= soc_remove
,
1296 /* create a new pcm */
1297 static int soc_new_pcm(struct snd_soc_device
*socdev
,
1298 struct snd_soc_dai_link
*dai_link
, int num
)
1300 struct snd_soc_card
*card
= socdev
->card
;
1301 struct snd_soc_codec
*codec
= card
->codec
;
1302 struct snd_soc_platform
*platform
= card
->platform
;
1303 struct snd_soc_dai
*codec_dai
= dai_link
->codec_dai
;
1304 struct snd_soc_dai
*cpu_dai
= dai_link
->cpu_dai
;
1305 struct snd_soc_pcm_runtime
*rtd
;
1306 struct snd_pcm
*pcm
;
1308 int ret
= 0, playback
= 0, capture
= 0;
1310 rtd
= kzalloc(sizeof(struct snd_soc_pcm_runtime
), GFP_KERNEL
);
1314 rtd
->dai
= dai_link
;
1315 rtd
->socdev
= socdev
;
1316 codec_dai
->codec
= card
->codec
;
1318 /* check client and interface hw capabilities */
1319 snprintf(new_name
, sizeof(new_name
), "%s %s-%d",
1320 dai_link
->stream_name
, codec_dai
->name
, num
);
1322 if (codec_dai
->playback
.channels_min
)
1324 if (codec_dai
->capture
.channels_min
)
1327 ret
= snd_pcm_new(codec
->card
, new_name
, codec
->pcm_devs
++, playback
,
1330 printk(KERN_ERR
"asoc: can't create pcm for codec %s\n",
1336 dai_link
->pcm
= pcm
;
1337 pcm
->private_data
= rtd
;
1338 soc_pcm_ops
.mmap
= platform
->pcm_ops
->mmap
;
1339 soc_pcm_ops
.pointer
= platform
->pcm_ops
->pointer
;
1340 soc_pcm_ops
.ioctl
= platform
->pcm_ops
->ioctl
;
1341 soc_pcm_ops
.copy
= platform
->pcm_ops
->copy
;
1342 soc_pcm_ops
.silence
= platform
->pcm_ops
->silence
;
1343 soc_pcm_ops
.ack
= platform
->pcm_ops
->ack
;
1344 soc_pcm_ops
.page
= platform
->pcm_ops
->page
;
1347 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &soc_pcm_ops
);
1350 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &soc_pcm_ops
);
1352 ret
= platform
->pcm_new(codec
->card
, codec_dai
, pcm
);
1354 printk(KERN_ERR
"asoc: platform pcm constructor failed\n");
1359 pcm
->private_free
= platform
->pcm_free
;
1360 printk(KERN_INFO
"asoc: %s <-> %s mapping ok\n", codec_dai
->name
,
1366 * snd_soc_codec_volatile_register: Report if a register is volatile.
1368 * @codec: CODEC to query.
1369 * @reg: Register to query.
1371 * Boolean function indiciating if a CODEC register is volatile.
1373 int snd_soc_codec_volatile_register(struct snd_soc_codec
*codec
, int reg
)
1375 if (codec
->volatile_register
)
1376 return codec
->volatile_register(reg
);
1380 EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register
);
1383 * snd_soc_new_ac97_codec - initailise AC97 device
1384 * @codec: audio codec
1385 * @ops: AC97 bus operations
1386 * @num: AC97 codec number
1388 * Initialises AC97 codec resources for use by ad-hoc devices only.
1390 int snd_soc_new_ac97_codec(struct snd_soc_codec
*codec
,
1391 struct snd_ac97_bus_ops
*ops
, int num
)
1393 mutex_lock(&codec
->mutex
);
1395 codec
->ac97
= kzalloc(sizeof(struct snd_ac97
), GFP_KERNEL
);
1396 if (codec
->ac97
== NULL
) {
1397 mutex_unlock(&codec
->mutex
);
1401 codec
->ac97
->bus
= kzalloc(sizeof(struct snd_ac97_bus
), GFP_KERNEL
);
1402 if (codec
->ac97
->bus
== NULL
) {
1405 mutex_unlock(&codec
->mutex
);
1409 codec
->ac97
->bus
->ops
= ops
;
1410 codec
->ac97
->num
= num
;
1411 codec
->dev
= &codec
->ac97
->dev
;
1412 mutex_unlock(&codec
->mutex
);
1415 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec
);
1418 * snd_soc_free_ac97_codec - free AC97 codec device
1419 * @codec: audio codec
1421 * Frees AC97 codec device resources.
1423 void snd_soc_free_ac97_codec(struct snd_soc_codec
*codec
)
1425 mutex_lock(&codec
->mutex
);
1426 kfree(codec
->ac97
->bus
);
1429 mutex_unlock(&codec
->mutex
);
1431 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec
);
1434 * snd_soc_update_bits - update codec register bits
1435 * @codec: audio codec
1436 * @reg: codec register
1437 * @mask: register mask
1440 * Writes new register value.
1442 * Returns 1 for change else 0.
1444 int snd_soc_update_bits(struct snd_soc_codec
*codec
, unsigned short reg
,
1445 unsigned int mask
, unsigned int value
)
1448 unsigned int old
, new;
1450 old
= snd_soc_read(codec
, reg
);
1451 new = (old
& ~mask
) | value
;
1452 change
= old
!= new;
1454 snd_soc_write(codec
, reg
, new);
1458 EXPORT_SYMBOL_GPL(snd_soc_update_bits
);
1461 * snd_soc_update_bits_locked - update codec register bits
1462 * @codec: audio codec
1463 * @reg: codec register
1464 * @mask: register mask
1467 * Writes new register value, and takes the codec mutex.
1469 * Returns 1 for change else 0.
1471 int snd_soc_update_bits_locked(struct snd_soc_codec
*codec
,
1472 unsigned short reg
, unsigned int mask
,
1477 mutex_lock(&codec
->mutex
);
1478 change
= snd_soc_update_bits(codec
, reg
, mask
, value
);
1479 mutex_unlock(&codec
->mutex
);
1483 EXPORT_SYMBOL_GPL(snd_soc_update_bits_locked
);
1486 * snd_soc_test_bits - test register for change
1487 * @codec: audio codec
1488 * @reg: codec register
1489 * @mask: register mask
1492 * Tests a register with a new value and checks if the new value is
1493 * different from the old value.
1495 * Returns 1 for change else 0.
1497 int snd_soc_test_bits(struct snd_soc_codec
*codec
, unsigned short reg
,
1498 unsigned int mask
, unsigned int value
)
1501 unsigned int old
, new;
1503 old
= snd_soc_read(codec
, reg
);
1504 new = (old
& ~mask
) | value
;
1505 change
= old
!= new;
1509 EXPORT_SYMBOL_GPL(snd_soc_test_bits
);
1512 * snd_soc_new_pcms - create new sound card and pcms
1513 * @socdev: the SoC audio device
1514 * @idx: ALSA card index
1515 * @xid: card identification
1517 * Create a new sound card based upon the codec and interface pcms.
1519 * Returns 0 for success, else error.
1521 int snd_soc_new_pcms(struct snd_soc_device
*socdev
, int idx
, const char *xid
)
1523 struct snd_soc_card
*card
= socdev
->card
;
1524 struct snd_soc_codec
*codec
= card
->codec
;
1527 mutex_lock(&codec
->mutex
);
1529 /* register a sound card */
1530 ret
= snd_card_create(idx
, xid
, codec
->owner
, 0, &codec
->card
);
1532 printk(KERN_ERR
"asoc: can't create sound card for codec %s\n",
1534 mutex_unlock(&codec
->mutex
);
1538 codec
->socdev
= socdev
;
1539 codec
->card
->dev
= socdev
->dev
;
1540 codec
->card
->private_data
= codec
;
1541 strncpy(codec
->card
->driver
, codec
->name
, sizeof(codec
->card
->driver
));
1543 /* create the pcms */
1544 for (i
= 0; i
< card
->num_links
; i
++) {
1545 ret
= soc_new_pcm(socdev
, &card
->dai_link
[i
], i
);
1547 printk(KERN_ERR
"asoc: can't create pcm %s\n",
1548 card
->dai_link
[i
].stream_name
);
1549 mutex_unlock(&codec
->mutex
);
1552 /* Check for codec->ac97 to handle the ac97.c fun */
1553 if (card
->dai_link
[i
].codec_dai
->ac97_control
&& codec
->ac97
) {
1554 snd_ac97_dev_add_pdata(codec
->ac97
,
1555 card
->dai_link
[i
].cpu_dai
->ac97_pdata
);
1559 mutex_unlock(&codec
->mutex
);
1562 EXPORT_SYMBOL_GPL(snd_soc_new_pcms
);
1565 * snd_soc_free_pcms - free sound card and pcms
1566 * @socdev: the SoC audio device
1568 * Frees sound card and pcms associated with the socdev.
1569 * Also unregister the codec if it is an AC97 device.
1571 void snd_soc_free_pcms(struct snd_soc_device
*socdev
)
1573 struct snd_soc_codec
*codec
= socdev
->card
->codec
;
1574 #ifdef CONFIG_SND_SOC_AC97_BUS
1575 struct snd_soc_dai
*codec_dai
;
1579 mutex_lock(&codec
->mutex
);
1580 soc_cleanup_codec_debugfs(codec
);
1581 #ifdef CONFIG_SND_SOC_AC97_BUS
1582 for (i
= 0; i
< codec
->num_dai
; i
++) {
1583 codec_dai
= &codec
->dai
[i
];
1584 if (codec_dai
->ac97_control
&& codec
->ac97
&&
1585 strcmp(codec
->name
, "AC97") != 0) {
1586 soc_ac97_dev_unregister(codec
);
1594 snd_card_free(codec
->card
);
1595 device_remove_file(socdev
->dev
, &dev_attr_codec_reg
);
1596 mutex_unlock(&codec
->mutex
);
1598 EXPORT_SYMBOL_GPL(snd_soc_free_pcms
);
1601 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
1602 * @substream: the pcm substream
1603 * @hw: the hardware parameters
1605 * Sets the substream runtime hardware parameters.
1607 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream
*substream
,
1608 const struct snd_pcm_hardware
*hw
)
1610 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1611 runtime
->hw
.info
= hw
->info
;
1612 runtime
->hw
.formats
= hw
->formats
;
1613 runtime
->hw
.period_bytes_min
= hw
->period_bytes_min
;
1614 runtime
->hw
.period_bytes_max
= hw
->period_bytes_max
;
1615 runtime
->hw
.periods_min
= hw
->periods_min
;
1616 runtime
->hw
.periods_max
= hw
->periods_max
;
1617 runtime
->hw
.buffer_bytes_max
= hw
->buffer_bytes_max
;
1618 runtime
->hw
.fifo_size
= hw
->fifo_size
;
1621 EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams
);
1624 * snd_soc_cnew - create new control
1625 * @_template: control template
1626 * @data: control private data
1627 * @long_name: control long name
1629 * Create a new mixer control from a template control.
1631 * Returns 0 for success, else error.
1633 struct snd_kcontrol
*snd_soc_cnew(const struct snd_kcontrol_new
*_template
,
1634 void *data
, char *long_name
)
1636 struct snd_kcontrol_new
template;
1638 memcpy(&template, _template
, sizeof(template));
1640 template.name
= long_name
;
1643 return snd_ctl_new1(&template, data
);
1645 EXPORT_SYMBOL_GPL(snd_soc_cnew
);
1648 * snd_soc_add_controls - add an array of controls to a codec.
1649 * Convienience function to add a list of controls. Many codecs were
1650 * duplicating this code.
1652 * @codec: codec to add controls to
1653 * @controls: array of controls to add
1654 * @num_controls: number of elements in the array
1656 * Return 0 for success, else error.
1658 int snd_soc_add_controls(struct snd_soc_codec
*codec
,
1659 const struct snd_kcontrol_new
*controls
, int num_controls
)
1661 struct snd_card
*card
= codec
->card
;
1664 for (i
= 0; i
< num_controls
; i
++) {
1665 const struct snd_kcontrol_new
*control
= &controls
[i
];
1666 err
= snd_ctl_add(card
, snd_soc_cnew(control
, codec
, NULL
));
1668 dev_err(codec
->dev
, "%s: Failed to add %s\n",
1669 codec
->name
, control
->name
);
1676 EXPORT_SYMBOL_GPL(snd_soc_add_controls
);
1679 * snd_soc_info_enum_double - enumerated double mixer info callback
1680 * @kcontrol: mixer control
1681 * @uinfo: control element information
1683 * Callback to provide information about a double enumerated
1686 * Returns 0 for success.
1688 int snd_soc_info_enum_double(struct snd_kcontrol
*kcontrol
,
1689 struct snd_ctl_elem_info
*uinfo
)
1691 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
1693 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
1694 uinfo
->count
= e
->shift_l
== e
->shift_r
? 1 : 2;
1695 uinfo
->value
.enumerated
.items
= e
->max
;
1697 if (uinfo
->value
.enumerated
.item
> e
->max
- 1)
1698 uinfo
->value
.enumerated
.item
= e
->max
- 1;
1699 strcpy(uinfo
->value
.enumerated
.name
,
1700 e
->texts
[uinfo
->value
.enumerated
.item
]);
1703 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double
);
1706 * snd_soc_get_enum_double - enumerated double mixer get callback
1707 * @kcontrol: mixer control
1708 * @ucontrol: control element information
1710 * Callback to get the value of a double enumerated mixer.
1712 * Returns 0 for success.
1714 int snd_soc_get_enum_double(struct snd_kcontrol
*kcontrol
,
1715 struct snd_ctl_elem_value
*ucontrol
)
1717 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1718 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
1719 unsigned int val
, bitmask
;
1721 for (bitmask
= 1; bitmask
< e
->max
; bitmask
<<= 1)
1723 val
= snd_soc_read(codec
, e
->reg
);
1724 ucontrol
->value
.enumerated
.item
[0]
1725 = (val
>> e
->shift_l
) & (bitmask
- 1);
1726 if (e
->shift_l
!= e
->shift_r
)
1727 ucontrol
->value
.enumerated
.item
[1] =
1728 (val
>> e
->shift_r
) & (bitmask
- 1);
1732 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double
);
1735 * snd_soc_put_enum_double - enumerated double mixer put callback
1736 * @kcontrol: mixer control
1737 * @ucontrol: control element information
1739 * Callback to set the value of a double enumerated mixer.
1741 * Returns 0 for success.
1743 int snd_soc_put_enum_double(struct snd_kcontrol
*kcontrol
,
1744 struct snd_ctl_elem_value
*ucontrol
)
1746 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1747 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
1749 unsigned int mask
, bitmask
;
1751 for (bitmask
= 1; bitmask
< e
->max
; bitmask
<<= 1)
1753 if (ucontrol
->value
.enumerated
.item
[0] > e
->max
- 1)
1755 val
= ucontrol
->value
.enumerated
.item
[0] << e
->shift_l
;
1756 mask
= (bitmask
- 1) << e
->shift_l
;
1757 if (e
->shift_l
!= e
->shift_r
) {
1758 if (ucontrol
->value
.enumerated
.item
[1] > e
->max
- 1)
1760 val
|= ucontrol
->value
.enumerated
.item
[1] << e
->shift_r
;
1761 mask
|= (bitmask
- 1) << e
->shift_r
;
1764 return snd_soc_update_bits_locked(codec
, e
->reg
, mask
, val
);
1766 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double
);
1769 * snd_soc_get_value_enum_double - semi enumerated double mixer get callback
1770 * @kcontrol: mixer control
1771 * @ucontrol: control element information
1773 * Callback to get the value of a double semi enumerated mixer.
1775 * Semi enumerated mixer: the enumerated items are referred as values. Can be
1776 * used for handling bitfield coded enumeration for example.
1778 * Returns 0 for success.
1780 int snd_soc_get_value_enum_double(struct snd_kcontrol
*kcontrol
,
1781 struct snd_ctl_elem_value
*ucontrol
)
1783 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1784 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
1785 unsigned int reg_val
, val
, mux
;
1787 reg_val
= snd_soc_read(codec
, e
->reg
);
1788 val
= (reg_val
>> e
->shift_l
) & e
->mask
;
1789 for (mux
= 0; mux
< e
->max
; mux
++) {
1790 if (val
== e
->values
[mux
])
1793 ucontrol
->value
.enumerated
.item
[0] = mux
;
1794 if (e
->shift_l
!= e
->shift_r
) {
1795 val
= (reg_val
>> e
->shift_r
) & e
->mask
;
1796 for (mux
= 0; mux
< e
->max
; mux
++) {
1797 if (val
== e
->values
[mux
])
1800 ucontrol
->value
.enumerated
.item
[1] = mux
;
1805 EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double
);
1808 * snd_soc_put_value_enum_double - semi enumerated double mixer put callback
1809 * @kcontrol: mixer control
1810 * @ucontrol: control element information
1812 * Callback to set the value of a double semi enumerated mixer.
1814 * Semi enumerated mixer: the enumerated items are referred as values. Can be
1815 * used for handling bitfield coded enumeration for example.
1817 * Returns 0 for success.
1819 int snd_soc_put_value_enum_double(struct snd_kcontrol
*kcontrol
,
1820 struct snd_ctl_elem_value
*ucontrol
)
1822 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1823 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
1827 if (ucontrol
->value
.enumerated
.item
[0] > e
->max
- 1)
1829 val
= e
->values
[ucontrol
->value
.enumerated
.item
[0]] << e
->shift_l
;
1830 mask
= e
->mask
<< e
->shift_l
;
1831 if (e
->shift_l
!= e
->shift_r
) {
1832 if (ucontrol
->value
.enumerated
.item
[1] > e
->max
- 1)
1834 val
|= e
->values
[ucontrol
->value
.enumerated
.item
[1]] << e
->shift_r
;
1835 mask
|= e
->mask
<< e
->shift_r
;
1838 return snd_soc_update_bits_locked(codec
, e
->reg
, mask
, val
);
1840 EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double
);
1843 * snd_soc_info_enum_ext - external enumerated single mixer info callback
1844 * @kcontrol: mixer control
1845 * @uinfo: control element information
1847 * Callback to provide information about an external enumerated
1850 * Returns 0 for success.
1852 int snd_soc_info_enum_ext(struct snd_kcontrol
*kcontrol
,
1853 struct snd_ctl_elem_info
*uinfo
)
1855 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
1857 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
1859 uinfo
->value
.enumerated
.items
= e
->max
;
1861 if (uinfo
->value
.enumerated
.item
> e
->max
- 1)
1862 uinfo
->value
.enumerated
.item
= e
->max
- 1;
1863 strcpy(uinfo
->value
.enumerated
.name
,
1864 e
->texts
[uinfo
->value
.enumerated
.item
]);
1867 EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext
);
1870 * snd_soc_info_volsw_ext - external single mixer info callback
1871 * @kcontrol: mixer control
1872 * @uinfo: control element information
1874 * Callback to provide information about a single external mixer control.
1876 * Returns 0 for success.
1878 int snd_soc_info_volsw_ext(struct snd_kcontrol
*kcontrol
,
1879 struct snd_ctl_elem_info
*uinfo
)
1881 int max
= kcontrol
->private_value
;
1883 if (max
== 1 && !strstr(kcontrol
->id
.name
, " Volume"))
1884 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1886 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1889 uinfo
->value
.integer
.min
= 0;
1890 uinfo
->value
.integer
.max
= max
;
1893 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext
);
1896 * snd_soc_info_volsw - single mixer info callback
1897 * @kcontrol: mixer control
1898 * @uinfo: control element information
1900 * Callback to provide information about a single mixer control.
1902 * Returns 0 for success.
1904 int snd_soc_info_volsw(struct snd_kcontrol
*kcontrol
,
1905 struct snd_ctl_elem_info
*uinfo
)
1907 struct soc_mixer_control
*mc
=
1908 (struct soc_mixer_control
*)kcontrol
->private_value
;
1910 unsigned int shift
= mc
->shift
;
1911 unsigned int rshift
= mc
->rshift
;
1913 if (max
== 1 && !strstr(kcontrol
->id
.name
, " Volume"))
1914 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1916 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1918 uinfo
->count
= shift
== rshift
? 1 : 2;
1919 uinfo
->value
.integer
.min
= 0;
1920 uinfo
->value
.integer
.max
= max
;
1923 EXPORT_SYMBOL_GPL(snd_soc_info_volsw
);
1926 * snd_soc_get_volsw - single mixer get callback
1927 * @kcontrol: mixer control
1928 * @ucontrol: control element information
1930 * Callback to get the value of a single mixer control.
1932 * Returns 0 for success.
1934 int snd_soc_get_volsw(struct snd_kcontrol
*kcontrol
,
1935 struct snd_ctl_elem_value
*ucontrol
)
1937 struct soc_mixer_control
*mc
=
1938 (struct soc_mixer_control
*)kcontrol
->private_value
;
1939 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1940 unsigned int reg
= mc
->reg
;
1941 unsigned int shift
= mc
->shift
;
1942 unsigned int rshift
= mc
->rshift
;
1944 unsigned int mask
= (1 << fls(max
)) - 1;
1945 unsigned int invert
= mc
->invert
;
1947 ucontrol
->value
.integer
.value
[0] =
1948 (snd_soc_read(codec
, reg
) >> shift
) & mask
;
1949 if (shift
!= rshift
)
1950 ucontrol
->value
.integer
.value
[1] =
1951 (snd_soc_read(codec
, reg
) >> rshift
) & mask
;
1953 ucontrol
->value
.integer
.value
[0] =
1954 max
- ucontrol
->value
.integer
.value
[0];
1955 if (shift
!= rshift
)
1956 ucontrol
->value
.integer
.value
[1] =
1957 max
- ucontrol
->value
.integer
.value
[1];
1962 EXPORT_SYMBOL_GPL(snd_soc_get_volsw
);
1965 * snd_soc_put_volsw - single mixer put callback
1966 * @kcontrol: mixer control
1967 * @ucontrol: control element information
1969 * Callback to set the value of a single mixer control.
1971 * Returns 0 for success.
1973 int snd_soc_put_volsw(struct snd_kcontrol
*kcontrol
,
1974 struct snd_ctl_elem_value
*ucontrol
)
1976 struct soc_mixer_control
*mc
=
1977 (struct soc_mixer_control
*)kcontrol
->private_value
;
1978 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
1979 unsigned int reg
= mc
->reg
;
1980 unsigned int shift
= mc
->shift
;
1981 unsigned int rshift
= mc
->rshift
;
1983 unsigned int mask
= (1 << fls(max
)) - 1;
1984 unsigned int invert
= mc
->invert
;
1985 unsigned int val
, val2
, val_mask
;
1987 val
= (ucontrol
->value
.integer
.value
[0] & mask
);
1990 val_mask
= mask
<< shift
;
1992 if (shift
!= rshift
) {
1993 val2
= (ucontrol
->value
.integer
.value
[1] & mask
);
1996 val_mask
|= mask
<< rshift
;
1997 val
|= val2
<< rshift
;
1999 return snd_soc_update_bits_locked(codec
, reg
, val_mask
, val
);
2001 EXPORT_SYMBOL_GPL(snd_soc_put_volsw
);
2004 * snd_soc_info_volsw_2r - double mixer info callback
2005 * @kcontrol: mixer control
2006 * @uinfo: control element information
2008 * Callback to provide information about a double mixer control that
2009 * spans 2 codec registers.
2011 * Returns 0 for success.
2013 int snd_soc_info_volsw_2r(struct snd_kcontrol
*kcontrol
,
2014 struct snd_ctl_elem_info
*uinfo
)
2016 struct soc_mixer_control
*mc
=
2017 (struct soc_mixer_control
*)kcontrol
->private_value
;
2020 if (max
== 1 && !strstr(kcontrol
->id
.name
, " Volume"))
2021 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
2023 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2026 uinfo
->value
.integer
.min
= 0;
2027 uinfo
->value
.integer
.max
= max
;
2030 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r
);
2033 * snd_soc_get_volsw_2r - double mixer get callback
2034 * @kcontrol: mixer control
2035 * @ucontrol: control element information
2037 * Callback to get the value of a double mixer control that spans 2 registers.
2039 * Returns 0 for success.
2041 int snd_soc_get_volsw_2r(struct snd_kcontrol
*kcontrol
,
2042 struct snd_ctl_elem_value
*ucontrol
)
2044 struct soc_mixer_control
*mc
=
2045 (struct soc_mixer_control
*)kcontrol
->private_value
;
2046 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2047 unsigned int reg
= mc
->reg
;
2048 unsigned int reg2
= mc
->rreg
;
2049 unsigned int shift
= mc
->shift
;
2051 unsigned int mask
= (1 << fls(max
)) - 1;
2052 unsigned int invert
= mc
->invert
;
2054 ucontrol
->value
.integer
.value
[0] =
2055 (snd_soc_read(codec
, reg
) >> shift
) & mask
;
2056 ucontrol
->value
.integer
.value
[1] =
2057 (snd_soc_read(codec
, reg2
) >> shift
) & mask
;
2059 ucontrol
->value
.integer
.value
[0] =
2060 max
- ucontrol
->value
.integer
.value
[0];
2061 ucontrol
->value
.integer
.value
[1] =
2062 max
- ucontrol
->value
.integer
.value
[1];
2067 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r
);
2070 * snd_soc_put_volsw_2r - double mixer set callback
2071 * @kcontrol: mixer control
2072 * @ucontrol: control element information
2074 * Callback to set the value of a double mixer control that spans 2 registers.
2076 * Returns 0 for success.
2078 int snd_soc_put_volsw_2r(struct snd_kcontrol
*kcontrol
,
2079 struct snd_ctl_elem_value
*ucontrol
)
2081 struct soc_mixer_control
*mc
=
2082 (struct soc_mixer_control
*)kcontrol
->private_value
;
2083 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2084 unsigned int reg
= mc
->reg
;
2085 unsigned int reg2
= mc
->rreg
;
2086 unsigned int shift
= mc
->shift
;
2088 unsigned int mask
= (1 << fls(max
)) - 1;
2089 unsigned int invert
= mc
->invert
;
2091 unsigned int val
, val2
, val_mask
;
2093 val_mask
= mask
<< shift
;
2094 val
= (ucontrol
->value
.integer
.value
[0] & mask
);
2095 val2
= (ucontrol
->value
.integer
.value
[1] & mask
);
2103 val2
= val2
<< shift
;
2105 err
= snd_soc_update_bits_locked(codec
, reg
, val_mask
, val
);
2109 err
= snd_soc_update_bits_locked(codec
, reg2
, val_mask
, val2
);
2112 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r
);
2115 * snd_soc_info_volsw_s8 - signed mixer info callback
2116 * @kcontrol: mixer control
2117 * @uinfo: control element information
2119 * Callback to provide information about a signed mixer control.
2121 * Returns 0 for success.
2123 int snd_soc_info_volsw_s8(struct snd_kcontrol
*kcontrol
,
2124 struct snd_ctl_elem_info
*uinfo
)
2126 struct soc_mixer_control
*mc
=
2127 (struct soc_mixer_control
*)kcontrol
->private_value
;
2131 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
2133 uinfo
->value
.integer
.min
= 0;
2134 uinfo
->value
.integer
.max
= max
-min
;
2137 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8
);
2140 * snd_soc_get_volsw_s8 - signed mixer get callback
2141 * @kcontrol: mixer control
2142 * @ucontrol: control element information
2144 * Callback to get the value of a signed mixer control.
2146 * Returns 0 for success.
2148 int snd_soc_get_volsw_s8(struct snd_kcontrol
*kcontrol
,
2149 struct snd_ctl_elem_value
*ucontrol
)
2151 struct soc_mixer_control
*mc
=
2152 (struct soc_mixer_control
*)kcontrol
->private_value
;
2153 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2154 unsigned int reg
= mc
->reg
;
2156 int val
= snd_soc_read(codec
, reg
);
2158 ucontrol
->value
.integer
.value
[0] =
2159 ((signed char)(val
& 0xff))-min
;
2160 ucontrol
->value
.integer
.value
[1] =
2161 ((signed char)((val
>> 8) & 0xff))-min
;
2164 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8
);
2167 * snd_soc_put_volsw_sgn - signed mixer put callback
2168 * @kcontrol: mixer control
2169 * @ucontrol: control element information
2171 * Callback to set the value of a signed mixer control.
2173 * Returns 0 for success.
2175 int snd_soc_put_volsw_s8(struct snd_kcontrol
*kcontrol
,
2176 struct snd_ctl_elem_value
*ucontrol
)
2178 struct soc_mixer_control
*mc
=
2179 (struct soc_mixer_control
*)kcontrol
->private_value
;
2180 struct snd_soc_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2181 unsigned int reg
= mc
->reg
;
2185 val
= (ucontrol
->value
.integer
.value
[0]+min
) & 0xff;
2186 val
|= ((ucontrol
->value
.integer
.value
[1]+min
) & 0xff) << 8;
2188 return snd_soc_update_bits_locked(codec
, reg
, 0xffff, val
);
2190 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8
);
2193 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2195 * @clk_id: DAI specific clock ID
2196 * @freq: new clock frequency in Hz
2197 * @dir: new clock direction - input/output.
2199 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2201 int snd_soc_dai_set_sysclk(struct snd_soc_dai
*dai
, int clk_id
,
2202 unsigned int freq
, int dir
)
2204 if (dai
->ops
&& dai
->ops
->set_sysclk
)
2205 return dai
->ops
->set_sysclk(dai
, clk_id
, freq
, dir
);
2209 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk
);
2212 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2214 * @div_id: DAI specific clock divider ID
2215 * @div: new clock divisor.
2217 * Configures the clock dividers. This is used to derive the best DAI bit and
2218 * frame clocks from the system or master clock. It's best to set the DAI bit
2219 * and frame clocks as low as possible to save system power.
2221 int snd_soc_dai_set_clkdiv(struct snd_soc_dai
*dai
,
2222 int div_id
, int div
)
2224 if (dai
->ops
&& dai
->ops
->set_clkdiv
)
2225 return dai
->ops
->set_clkdiv(dai
, div_id
, div
);
2229 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv
);
2232 * snd_soc_dai_set_pll - configure DAI PLL.
2234 * @pll_id: DAI specific PLL ID
2235 * @source: DAI specific source for the PLL
2236 * @freq_in: PLL input clock frequency in Hz
2237 * @freq_out: requested PLL output clock frequency in Hz
2239 * Configures and enables PLL to generate output clock based on input clock.
2241 int snd_soc_dai_set_pll(struct snd_soc_dai
*dai
, int pll_id
, int source
,
2242 unsigned int freq_in
, unsigned int freq_out
)
2244 if (dai
->ops
&& dai
->ops
->set_pll
)
2245 return dai
->ops
->set_pll(dai
, pll_id
, source
,
2250 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll
);
2253 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
2255 * @fmt: SND_SOC_DAIFMT_ format value.
2257 * Configures the DAI hardware format and clocking.
2259 int snd_soc_dai_set_fmt(struct snd_soc_dai
*dai
, unsigned int fmt
)
2261 if (dai
->ops
&& dai
->ops
->set_fmt
)
2262 return dai
->ops
->set_fmt(dai
, fmt
);
2266 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt
);
2269 * snd_soc_dai_set_tdm_slot - configure DAI TDM.
2271 * @tx_mask: bitmask representing active TX slots.
2272 * @rx_mask: bitmask representing active RX slots.
2273 * @slots: Number of slots in use.
2274 * @slot_width: Width in bits for each slot.
2276 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
2279 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai
*dai
,
2280 unsigned int tx_mask
, unsigned int rx_mask
, int slots
, int slot_width
)
2282 if (dai
->ops
&& dai
->ops
->set_tdm_slot
)
2283 return dai
->ops
->set_tdm_slot(dai
, tx_mask
, rx_mask
,
2288 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot
);
2291 * snd_soc_dai_set_channel_map - configure DAI audio channel map
2293 * @tx_num: how many TX channels
2294 * @tx_slot: pointer to an array which imply the TX slot number channel
2296 * @rx_num: how many RX channels
2297 * @rx_slot: pointer to an array which imply the RX slot number channel
2300 * configure the relationship between channel number and TDM slot number.
2302 int snd_soc_dai_set_channel_map(struct snd_soc_dai
*dai
,
2303 unsigned int tx_num
, unsigned int *tx_slot
,
2304 unsigned int rx_num
, unsigned int *rx_slot
)
2306 if (dai
->ops
&& dai
->ops
->set_channel_map
)
2307 return dai
->ops
->set_channel_map(dai
, tx_num
, tx_slot
,
2312 EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map
);
2315 * snd_soc_dai_set_tristate - configure DAI system or master clock.
2317 * @tristate: tristate enable
2319 * Tristates the DAI so that others can use it.
2321 int snd_soc_dai_set_tristate(struct snd_soc_dai
*dai
, int tristate
)
2323 if (dai
->ops
&& dai
->ops
->set_tristate
)
2324 return dai
->ops
->set_tristate(dai
, tristate
);
2328 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate
);
2331 * snd_soc_dai_digital_mute - configure DAI system or master clock.
2333 * @mute: mute enable
2335 * Mutes the DAI DAC.
2337 int snd_soc_dai_digital_mute(struct snd_soc_dai
*dai
, int mute
)
2339 if (dai
->ops
&& dai
->ops
->digital_mute
)
2340 return dai
->ops
->digital_mute(dai
, mute
);
2344 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute
);
2347 * snd_soc_register_card - Register a card with the ASoC core
2349 * @card: Card to register
2351 * Note that currently this is an internal only function: it will be
2352 * exposed to machine drivers after further backporting of ASoC v2
2353 * registration APIs.
2355 static int snd_soc_register_card(struct snd_soc_card
*card
)
2357 if (!card
->name
|| !card
->dev
)
2360 INIT_LIST_HEAD(&card
->list
);
2361 card
->instantiated
= 0;
2363 mutex_lock(&client_mutex
);
2364 list_add(&card
->list
, &card_list
);
2365 snd_soc_instantiate_cards();
2366 mutex_unlock(&client_mutex
);
2368 dev_dbg(card
->dev
, "Registered card '%s'\n", card
->name
);
2374 * snd_soc_unregister_card - Unregister a card with the ASoC core
2376 * @card: Card to unregister
2378 * Note that currently this is an internal only function: it will be
2379 * exposed to machine drivers after further backporting of ASoC v2
2380 * registration APIs.
2382 static int snd_soc_unregister_card(struct snd_soc_card
*card
)
2384 mutex_lock(&client_mutex
);
2385 list_del(&card
->list
);
2386 mutex_unlock(&client_mutex
);
2388 dev_dbg(card
->dev
, "Unregistered card '%s'\n", card
->name
);
2394 * snd_soc_register_dai - Register a DAI with the ASoC core
2396 * @dai: DAI to register
2398 int snd_soc_register_dai(struct snd_soc_dai
*dai
)
2403 /* The device should become mandatory over time */
2405 printk(KERN_WARNING
"No device for DAI %s\n", dai
->name
);
2408 dai
->ops
= &null_dai_ops
;
2410 INIT_LIST_HEAD(&dai
->list
);
2412 mutex_lock(&client_mutex
);
2413 list_add(&dai
->list
, &dai_list
);
2414 snd_soc_instantiate_cards();
2415 mutex_unlock(&client_mutex
);
2417 pr_debug("Registered DAI '%s'\n", dai
->name
);
2421 EXPORT_SYMBOL_GPL(snd_soc_register_dai
);
2424 * snd_soc_unregister_dai - Unregister a DAI from the ASoC core
2426 * @dai: DAI to unregister
2428 void snd_soc_unregister_dai(struct snd_soc_dai
*dai
)
2430 mutex_lock(&client_mutex
);
2431 list_del(&dai
->list
);
2432 mutex_unlock(&client_mutex
);
2434 pr_debug("Unregistered DAI '%s'\n", dai
->name
);
2436 EXPORT_SYMBOL_GPL(snd_soc_unregister_dai
);
2439 * snd_soc_register_dais - Register multiple DAIs with the ASoC core
2441 * @dai: Array of DAIs to register
2442 * @count: Number of DAIs
2444 int snd_soc_register_dais(struct snd_soc_dai
*dai
, size_t count
)
2448 for (i
= 0; i
< count
; i
++) {
2449 ret
= snd_soc_register_dai(&dai
[i
]);
2457 for (i
--; i
>= 0; i
--)
2458 snd_soc_unregister_dai(&dai
[i
]);
2462 EXPORT_SYMBOL_GPL(snd_soc_register_dais
);
2465 * snd_soc_unregister_dais - Unregister multiple DAIs from the ASoC core
2467 * @dai: Array of DAIs to unregister
2468 * @count: Number of DAIs
2470 void snd_soc_unregister_dais(struct snd_soc_dai
*dai
, size_t count
)
2474 for (i
= 0; i
< count
; i
++)
2475 snd_soc_unregister_dai(&dai
[i
]);
2477 EXPORT_SYMBOL_GPL(snd_soc_unregister_dais
);
2480 * snd_soc_register_platform - Register a platform with the ASoC core
2482 * @platform: platform to register
2484 int snd_soc_register_platform(struct snd_soc_platform
*platform
)
2486 if (!platform
->name
)
2489 INIT_LIST_HEAD(&platform
->list
);
2491 mutex_lock(&client_mutex
);
2492 list_add(&platform
->list
, &platform_list
);
2493 snd_soc_instantiate_cards();
2494 mutex_unlock(&client_mutex
);
2496 pr_debug("Registered platform '%s'\n", platform
->name
);
2500 EXPORT_SYMBOL_GPL(snd_soc_register_platform
);
2503 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
2505 * @platform: platform to unregister
2507 void snd_soc_unregister_platform(struct snd_soc_platform
*platform
)
2509 mutex_lock(&client_mutex
);
2510 list_del(&platform
->list
);
2511 mutex_unlock(&client_mutex
);
2513 pr_debug("Unregistered platform '%s'\n", platform
->name
);
2515 EXPORT_SYMBOL_GPL(snd_soc_unregister_platform
);
2517 static u64 codec_format_map
[] = {
2518 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S16_BE
,
2519 SNDRV_PCM_FMTBIT_U16_LE
| SNDRV_PCM_FMTBIT_U16_BE
,
2520 SNDRV_PCM_FMTBIT_S24_LE
| SNDRV_PCM_FMTBIT_S24_BE
,
2521 SNDRV_PCM_FMTBIT_U24_LE
| SNDRV_PCM_FMTBIT_U24_BE
,
2522 SNDRV_PCM_FMTBIT_S32_LE
| SNDRV_PCM_FMTBIT_S32_BE
,
2523 SNDRV_PCM_FMTBIT_U32_LE
| SNDRV_PCM_FMTBIT_U32_BE
,
2524 SNDRV_PCM_FMTBIT_S24_3LE
| SNDRV_PCM_FMTBIT_U24_3BE
,
2525 SNDRV_PCM_FMTBIT_U24_3LE
| SNDRV_PCM_FMTBIT_U24_3BE
,
2526 SNDRV_PCM_FMTBIT_S20_3LE
| SNDRV_PCM_FMTBIT_S20_3BE
,
2527 SNDRV_PCM_FMTBIT_U20_3LE
| SNDRV_PCM_FMTBIT_U20_3BE
,
2528 SNDRV_PCM_FMTBIT_S18_3LE
| SNDRV_PCM_FMTBIT_S18_3BE
,
2529 SNDRV_PCM_FMTBIT_U18_3LE
| SNDRV_PCM_FMTBIT_U18_3BE
,
2530 SNDRV_PCM_FMTBIT_FLOAT_LE
| SNDRV_PCM_FMTBIT_FLOAT_BE
,
2531 SNDRV_PCM_FMTBIT_FLOAT64_LE
| SNDRV_PCM_FMTBIT_FLOAT64_BE
,
2532 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
2533 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
,
2536 /* Fix up the DAI formats for endianness: codecs don't actually see
2537 * the endianness of the data but we're using the CPU format
2538 * definitions which do need to include endianness so we ensure that
2539 * codec DAIs always have both big and little endian variants set.
2541 static void fixup_codec_formats(struct snd_soc_pcm_stream
*stream
)
2545 for (i
= 0; i
< ARRAY_SIZE(codec_format_map
); i
++)
2546 if (stream
->formats
& codec_format_map
[i
])
2547 stream
->formats
|= codec_format_map
[i
];
2551 * snd_soc_register_codec - Register a codec with the ASoC core
2553 * @codec: codec to register
2555 int snd_soc_register_codec(struct snd_soc_codec
*codec
)
2562 /* The device should become mandatory over time */
2564 printk(KERN_WARNING
"No device for codec %s\n", codec
->name
);
2566 INIT_LIST_HEAD(&codec
->list
);
2568 for (i
= 0; i
< codec
->num_dai
; i
++) {
2569 fixup_codec_formats(&codec
->dai
[i
].playback
);
2570 fixup_codec_formats(&codec
->dai
[i
].capture
);
2573 mutex_lock(&client_mutex
);
2574 list_add(&codec
->list
, &codec_list
);
2575 snd_soc_instantiate_cards();
2576 mutex_unlock(&client_mutex
);
2578 pr_debug("Registered codec '%s'\n", codec
->name
);
2582 EXPORT_SYMBOL_GPL(snd_soc_register_codec
);
2585 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
2587 * @codec: codec to unregister
2589 void snd_soc_unregister_codec(struct snd_soc_codec
*codec
)
2591 mutex_lock(&client_mutex
);
2592 list_del(&codec
->list
);
2593 mutex_unlock(&client_mutex
);
2595 pr_debug("Unregistered codec '%s'\n", codec
->name
);
2597 EXPORT_SYMBOL_GPL(snd_soc_unregister_codec
);
2599 static int __init
snd_soc_init(void)
2601 #ifdef CONFIG_DEBUG_FS
2602 debugfs_root
= debugfs_create_dir("asoc", NULL
);
2603 if (IS_ERR(debugfs_root
) || !debugfs_root
) {
2605 "ASoC: Failed to create debugfs directory\n");
2606 debugfs_root
= NULL
;
2610 return platform_driver_register(&soc_driver
);
2613 static void __exit
snd_soc_exit(void)
2615 #ifdef CONFIG_DEBUG_FS
2616 debugfs_remove_recursive(debugfs_root
);
2618 platform_driver_unregister(&soc_driver
);
2621 module_init(snd_soc_init
);
2622 module_exit(snd_soc_exit
);
2624 /* Module information */
2625 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
2626 MODULE_DESCRIPTION("ALSA SoC Core");
2627 MODULE_LICENSE("GPL");
2628 MODULE_ALIAS("platform:soc-audio");