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/slab.h>
34 #include <sound/ac97_codec.h>
35 #include <sound/core.h>
36 #include <sound/pcm.h>
37 #include <sound/pcm_params.h>
38 #include <sound/soc.h>
39 #include <sound/initval.h>
41 #define CREATE_TRACE_POINTS
42 #include <trace/events/asoc.h>
46 static DEFINE_MUTEX(pcm_mutex);
47 static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
49 #ifdef CONFIG_DEBUG_FS
50 static struct dentry *debugfs_root;
53 static DEFINE_MUTEX(client_mutex);
54 static LIST_HEAD(card_list);
55 static LIST_HEAD(dai_list);
56 static LIST_HEAD(platform_list);
57 static LIST_HEAD(codec_list);
59 static int snd_soc_register_card(struct snd_soc_card *card);
60 static int snd_soc_unregister_card(struct snd_soc_card *card);
61 static int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
64 * This is a timeout to do a DAPM powerdown after a stream is closed().
65 * It can be used to eliminate pops between different playback streams, e.g.
66 * between two audio tracks.
68 static int pmdown_time = 5000;
69 module_param(pmdown_time, int, 0);
70 MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
73 * This function forces any delayed work to be queued and run.
75 static int run_delayed_work(struct delayed_work *dwork)
79 /* cancel any work waiting to be queued. */
80 ret = cancel_delayed_work(dwork);
82 /* if there was any work waiting then we run it now and
83 * wait for it's completion */
85 schedule_delayed_work(dwork, 0);
86 flush_scheduled_work();
91 /* codec register dump */
92 static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf)
94 int ret, i, step = 1, count = 0;
96 if (!codec->driver->reg_cache_size)
99 if (codec->driver->reg_cache_step)
100 step = codec->driver->reg_cache_step;
102 count += sprintf(buf, "%s registers\n", codec->name);
103 for (i = 0; i < codec->driver->reg_cache_size; i += step) {
104 if (codec->driver->readable_register && !codec->driver->readable_register(i))
107 count += sprintf(buf + count, "%2x: ", i);
108 if (count >= PAGE_SIZE - 1)
111 if (codec->driver->display_register) {
112 count += codec->driver->display_register(codec, buf + count,
113 PAGE_SIZE - count, i);
115 /* If the read fails it's almost certainly due to
116 * the register being volatile and the device being
119 ret = codec->driver->read(codec, i);
121 count += snprintf(buf + count,
125 count += snprintf(buf + count,
127 "<no data: %d>", ret);
130 if (count >= PAGE_SIZE - 1)
133 count += snprintf(buf + count, PAGE_SIZE - count, "\n");
134 if (count >= PAGE_SIZE - 1)
138 /* Truncate count; min() would cause a warning */
139 if (count >= PAGE_SIZE)
140 count = PAGE_SIZE - 1;
144 static ssize_t codec_reg_show(struct device *dev,
145 struct device_attribute *attr, char *buf)
147 struct snd_soc_pcm_runtime *rtd =
148 container_of(dev, struct snd_soc_pcm_runtime, dev);
150 return soc_codec_reg_show(rtd->codec, buf);
153 static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
155 static ssize_t pmdown_time_show(struct device *dev,
156 struct device_attribute *attr, char *buf)
158 struct snd_soc_pcm_runtime *rtd =
159 container_of(dev, struct snd_soc_pcm_runtime, dev);
161 return sprintf(buf, "%ld\n", rtd->pmdown_time);
164 static ssize_t pmdown_time_set(struct device *dev,
165 struct device_attribute *attr,
166 const char *buf, size_t count)
168 struct snd_soc_pcm_runtime *rtd =
169 container_of(dev, struct snd_soc_pcm_runtime, dev);
172 ret = strict_strtol(buf, 10, &rtd->pmdown_time);
179 static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
181 #ifdef CONFIG_DEBUG_FS
182 static int codec_reg_open_file(struct inode *inode, struct file *file)
184 file->private_data = inode->i_private;
188 static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
189 size_t count, loff_t *ppos)
192 struct snd_soc_codec *codec = file->private_data;
193 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
196 ret = soc_codec_reg_show(codec, buf);
198 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
203 static ssize_t codec_reg_write_file(struct file *file,
204 const char __user *user_buf, size_t count, loff_t *ppos)
209 unsigned long reg, value;
211 struct snd_soc_codec *codec = file->private_data;
213 buf_size = min(count, (sizeof(buf)-1));
214 if (copy_from_user(buf, user_buf, buf_size))
218 if (codec->driver->reg_cache_step)
219 step = codec->driver->reg_cache_step;
221 while (*start == ' ')
223 reg = simple_strtoul(start, &start, 16);
224 if ((reg >= codec->driver->reg_cache_size) || (reg % step))
226 while (*start == ' ')
228 if (strict_strtoul(start, 16, &value))
230 codec->driver->write(codec, reg, value);
234 static const struct file_operations codec_reg_fops = {
235 .open = codec_reg_open_file,
236 .read = codec_reg_read_file,
237 .write = codec_reg_write_file,
238 .llseek = default_llseek,
241 static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
243 struct dentry *debugfs_card_root = codec->card->debugfs_card_root;
245 codec->debugfs_codec_root = debugfs_create_dir(codec->name,
247 if (!codec->debugfs_codec_root) {
249 "ASoC: Failed to create codec debugfs directory\n");
253 codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
254 codec->debugfs_codec_root,
255 codec, &codec_reg_fops);
256 if (!codec->debugfs_reg)
258 "ASoC: Failed to create codec register debugfs file\n");
260 codec->dapm.debugfs_dapm = debugfs_create_dir("dapm",
261 codec->debugfs_codec_root);
262 if (!codec->dapm.debugfs_dapm)
264 "Failed to create DAPM debugfs directory\n");
266 snd_soc_dapm_debugfs_init(&codec->dapm);
269 static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
271 debugfs_remove_recursive(codec->debugfs_codec_root);
274 static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
275 size_t count, loff_t *ppos)
277 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
278 ssize_t len, ret = 0;
279 struct snd_soc_codec *codec;
284 list_for_each_entry(codec, &codec_list, list) {
285 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
289 if (ret > PAGE_SIZE) {
296 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
303 static const struct file_operations codec_list_fops = {
304 .read = codec_list_read_file,
305 .llseek = default_llseek,/* read accesses f_pos */
308 static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
309 size_t count, loff_t *ppos)
311 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
312 ssize_t len, ret = 0;
313 struct snd_soc_dai *dai;
318 list_for_each_entry(dai, &dai_list, list) {
319 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", dai->name);
322 if (ret > PAGE_SIZE) {
328 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
335 static const struct file_operations dai_list_fops = {
336 .read = dai_list_read_file,
337 .llseek = default_llseek,/* read accesses f_pos */
340 static ssize_t platform_list_read_file(struct file *file,
341 char __user *user_buf,
342 size_t count, loff_t *ppos)
344 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
345 ssize_t len, ret = 0;
346 struct snd_soc_platform *platform;
351 list_for_each_entry(platform, &platform_list, list) {
352 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
356 if (ret > PAGE_SIZE) {
362 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
369 static const struct file_operations platform_list_fops = {
370 .read = platform_list_read_file,
371 .llseek = default_llseek,/* read accesses f_pos */
374 static void soc_init_card_debugfs(struct snd_soc_card *card)
376 card->debugfs_card_root = debugfs_create_dir(card->name,
378 if (!card->debugfs_card_root) {
380 "ASoC: Failed to create codec debugfs directory\n");
384 card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
385 card->debugfs_card_root,
387 if (!card->debugfs_pop_time)
389 "Failed to create pop time debugfs file\n");
392 static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
394 debugfs_remove_recursive(card->debugfs_card_root);
399 static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
403 static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
407 static inline void soc_init_card_debugfs(struct snd_soc_card *card)
411 static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
416 #ifdef CONFIG_SND_SOC_AC97_BUS
417 /* unregister ac97 codec */
418 static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
420 if (codec->ac97->dev.bus)
421 device_unregister(&codec->ac97->dev);
425 /* stop no dev release warning */
426 static void soc_ac97_device_release(struct device *dev){}
428 /* register ac97 codec to bus */
429 static int soc_ac97_dev_register(struct snd_soc_codec *codec)
433 codec->ac97->dev.bus = &ac97_bus_type;
434 codec->ac97->dev.parent = codec->card->dev;
435 codec->ac97->dev.release = soc_ac97_device_release;
437 dev_set_name(&codec->ac97->dev, "%d-%d:%s",
438 codec->card->snd_card->number, 0, codec->name);
439 err = device_register(&codec->ac97->dev);
441 snd_printk(KERN_ERR "Can't register ac97 bus\n");
442 codec->ac97->dev.bus = NULL;
449 static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream)
451 struct snd_soc_pcm_runtime *rtd = substream->private_data;
452 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
453 struct snd_soc_dai *codec_dai = rtd->codec_dai;
456 if (codec_dai->driver->symmetric_rates || cpu_dai->driver->symmetric_rates ||
457 rtd->dai_link->symmetric_rates) {
458 dev_dbg(&rtd->dev, "Symmetry forces %dHz rate\n",
461 ret = snd_pcm_hw_constraint_minmax(substream->runtime,
462 SNDRV_PCM_HW_PARAM_RATE,
467 "Unable to apply rate symmetry constraint: %d\n", ret);
476 * Called by ALSA when a PCM substream is opened, the runtime->hw record is
477 * then initialized and any private data can be allocated. This also calls
478 * startup for the cpu DAI, platform, machine and codec DAI.
480 static int soc_pcm_open(struct snd_pcm_substream *substream)
482 struct snd_soc_pcm_runtime *rtd = substream->private_data;
483 struct snd_pcm_runtime *runtime = substream->runtime;
484 struct snd_soc_platform *platform = rtd->platform;
485 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
486 struct snd_soc_dai *codec_dai = rtd->codec_dai;
487 struct snd_soc_dai_driver *cpu_dai_drv = cpu_dai->driver;
488 struct snd_soc_dai_driver *codec_dai_drv = codec_dai->driver;
491 mutex_lock(&pcm_mutex);
493 /* startup the audio subsystem */
494 if (cpu_dai->driver->ops->startup) {
495 ret = cpu_dai->driver->ops->startup(substream, cpu_dai);
497 printk(KERN_ERR "asoc: can't open interface %s\n",
503 if (platform->driver->ops->open) {
504 ret = platform->driver->ops->open(substream);
506 printk(KERN_ERR "asoc: can't open platform %s\n", platform->name);
511 if (codec_dai->driver->ops->startup) {
512 ret = codec_dai->driver->ops->startup(substream, codec_dai);
514 printk(KERN_ERR "asoc: can't open codec %s\n",
520 if (rtd->dai_link->ops && rtd->dai_link->ops->startup) {
521 ret = rtd->dai_link->ops->startup(substream);
523 printk(KERN_ERR "asoc: %s startup failed\n", rtd->dai_link->name);
528 /* Check that the codec and cpu DAIs are compatible */
529 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
530 runtime->hw.rate_min =
531 max(codec_dai_drv->playback.rate_min,
532 cpu_dai_drv->playback.rate_min);
533 runtime->hw.rate_max =
534 min(codec_dai_drv->playback.rate_max,
535 cpu_dai_drv->playback.rate_max);
536 runtime->hw.channels_min =
537 max(codec_dai_drv->playback.channels_min,
538 cpu_dai_drv->playback.channels_min);
539 runtime->hw.channels_max =
540 min(codec_dai_drv->playback.channels_max,
541 cpu_dai_drv->playback.channels_max);
542 runtime->hw.formats =
543 codec_dai_drv->playback.formats & cpu_dai_drv->playback.formats;
545 codec_dai_drv->playback.rates & cpu_dai_drv->playback.rates;
546 if (codec_dai_drv->playback.rates
547 & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
548 runtime->hw.rates |= cpu_dai_drv->playback.rates;
549 if (cpu_dai_drv->playback.rates
550 & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
551 runtime->hw.rates |= codec_dai_drv->playback.rates;
553 runtime->hw.rate_min =
554 max(codec_dai_drv->capture.rate_min,
555 cpu_dai_drv->capture.rate_min);
556 runtime->hw.rate_max =
557 min(codec_dai_drv->capture.rate_max,
558 cpu_dai_drv->capture.rate_max);
559 runtime->hw.channels_min =
560 max(codec_dai_drv->capture.channels_min,
561 cpu_dai_drv->capture.channels_min);
562 runtime->hw.channels_max =
563 min(codec_dai_drv->capture.channels_max,
564 cpu_dai_drv->capture.channels_max);
565 runtime->hw.formats =
566 codec_dai_drv->capture.formats & cpu_dai_drv->capture.formats;
568 codec_dai_drv->capture.rates & cpu_dai_drv->capture.rates;
569 if (codec_dai_drv->capture.rates
570 & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
571 runtime->hw.rates |= cpu_dai_drv->capture.rates;
572 if (cpu_dai_drv->capture.rates
573 & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
574 runtime->hw.rates |= codec_dai_drv->capture.rates;
577 snd_pcm_limit_hw_rates(runtime);
578 if (!runtime->hw.rates) {
579 printk(KERN_ERR "asoc: %s <-> %s No matching rates\n",
580 codec_dai->name, cpu_dai->name);
583 if (!runtime->hw.formats) {
584 printk(KERN_ERR "asoc: %s <-> %s No matching formats\n",
585 codec_dai->name, cpu_dai->name);
588 if (!runtime->hw.channels_min || !runtime->hw.channels_max) {
589 printk(KERN_ERR "asoc: %s <-> %s No matching channels\n",
590 codec_dai->name, cpu_dai->name);
594 /* Symmetry only applies if we've already got an active stream. */
595 if (cpu_dai->active || codec_dai->active) {
596 ret = soc_pcm_apply_symmetry(substream);
601 pr_debug("asoc: %s <-> %s info:\n",
602 codec_dai->name, cpu_dai->name);
603 pr_debug("asoc: rate mask 0x%x\n", runtime->hw.rates);
604 pr_debug("asoc: min ch %d max ch %d\n", runtime->hw.channels_min,
605 runtime->hw.channels_max);
606 pr_debug("asoc: min rate %d max rate %d\n", runtime->hw.rate_min,
607 runtime->hw.rate_max);
609 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
610 cpu_dai->playback_active++;
611 codec_dai->playback_active++;
613 cpu_dai->capture_active++;
614 codec_dai->capture_active++;
618 rtd->codec->active++;
619 mutex_unlock(&pcm_mutex);
623 if (rtd->dai_link->ops && rtd->dai_link->ops->shutdown)
624 rtd->dai_link->ops->shutdown(substream);
627 if (codec_dai->driver->ops->shutdown)
628 codec_dai->driver->ops->shutdown(substream, codec_dai);
631 if (platform->driver->ops->close)
632 platform->driver->ops->close(substream);
635 if (cpu_dai->driver->ops->shutdown)
636 cpu_dai->driver->ops->shutdown(substream, cpu_dai);
638 mutex_unlock(&pcm_mutex);
643 * Power down the audio subsystem pmdown_time msecs after close is called.
644 * This is to ensure there are no pops or clicks in between any music tracks
645 * due to DAPM power cycling.
647 static void close_delayed_work(struct work_struct *work)
649 struct snd_soc_pcm_runtime *rtd =
650 container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
651 struct snd_soc_dai *codec_dai = rtd->codec_dai;
653 mutex_lock(&pcm_mutex);
655 pr_debug("pop wq checking: %s status: %s waiting: %s\n",
656 codec_dai->driver->playback.stream_name,
657 codec_dai->playback_active ? "active" : "inactive",
658 codec_dai->pop_wait ? "yes" : "no");
660 /* are we waiting on this codec DAI stream */
661 if (codec_dai->pop_wait == 1) {
662 codec_dai->pop_wait = 0;
663 snd_soc_dapm_stream_event(rtd,
664 codec_dai->driver->playback.stream_name,
665 SND_SOC_DAPM_STREAM_STOP);
668 mutex_unlock(&pcm_mutex);
672 * Called by ALSA when a PCM substream is closed. Private data can be
673 * freed here. The cpu DAI, codec DAI, machine and platform are also
676 static int soc_codec_close(struct snd_pcm_substream *substream)
678 struct snd_soc_pcm_runtime *rtd = substream->private_data;
679 struct snd_soc_platform *platform = rtd->platform;
680 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
681 struct snd_soc_dai *codec_dai = rtd->codec_dai;
682 struct snd_soc_codec *codec = rtd->codec;
684 mutex_lock(&pcm_mutex);
686 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
687 cpu_dai->playback_active--;
688 codec_dai->playback_active--;
690 cpu_dai->capture_active--;
691 codec_dai->capture_active--;
698 /* Muting the DAC suppresses artifacts caused during digital
699 * shutdown, for example from stopping clocks.
701 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
702 snd_soc_dai_digital_mute(codec_dai, 1);
704 if (cpu_dai->driver->ops->shutdown)
705 cpu_dai->driver->ops->shutdown(substream, cpu_dai);
707 if (codec_dai->driver->ops->shutdown)
708 codec_dai->driver->ops->shutdown(substream, codec_dai);
710 if (rtd->dai_link->ops && rtd->dai_link->ops->shutdown)
711 rtd->dai_link->ops->shutdown(substream);
713 if (platform->driver->ops->close)
714 platform->driver->ops->close(substream);
715 cpu_dai->runtime = NULL;
717 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
718 /* start delayed pop wq here for playback streams */
719 codec_dai->pop_wait = 1;
720 schedule_delayed_work(&rtd->delayed_work,
721 msecs_to_jiffies(rtd->pmdown_time));
723 /* capture streams can be powered down now */
724 snd_soc_dapm_stream_event(rtd,
725 codec_dai->driver->capture.stream_name,
726 SND_SOC_DAPM_STREAM_STOP);
729 mutex_unlock(&pcm_mutex);
734 * Called by ALSA when the PCM substream is prepared, can set format, sample
735 * rate, etc. This function is non atomic and can be called multiple times,
736 * it can refer to the runtime info.
738 static int soc_pcm_prepare(struct snd_pcm_substream *substream)
740 struct snd_soc_pcm_runtime *rtd = substream->private_data;
741 struct snd_soc_platform *platform = rtd->platform;
742 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
743 struct snd_soc_dai *codec_dai = rtd->codec_dai;
746 mutex_lock(&pcm_mutex);
748 if (rtd->dai_link->ops && rtd->dai_link->ops->prepare) {
749 ret = rtd->dai_link->ops->prepare(substream);
751 printk(KERN_ERR "asoc: machine prepare error\n");
756 if (platform->driver->ops->prepare) {
757 ret = platform->driver->ops->prepare(substream);
759 printk(KERN_ERR "asoc: platform prepare error\n");
764 if (codec_dai->driver->ops->prepare) {
765 ret = codec_dai->driver->ops->prepare(substream, codec_dai);
767 printk(KERN_ERR "asoc: codec DAI prepare error\n");
772 if (cpu_dai->driver->ops->prepare) {
773 ret = cpu_dai->driver->ops->prepare(substream, cpu_dai);
775 printk(KERN_ERR "asoc: cpu DAI prepare error\n");
780 /* cancel any delayed stream shutdown that is pending */
781 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
782 codec_dai->pop_wait) {
783 codec_dai->pop_wait = 0;
784 cancel_delayed_work(&rtd->delayed_work);
787 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
788 snd_soc_dapm_stream_event(rtd,
789 codec_dai->driver->playback.stream_name,
790 SND_SOC_DAPM_STREAM_START);
792 snd_soc_dapm_stream_event(rtd,
793 codec_dai->driver->capture.stream_name,
794 SND_SOC_DAPM_STREAM_START);
796 snd_soc_dai_digital_mute(codec_dai, 0);
799 mutex_unlock(&pcm_mutex);
804 * Called by ALSA when the hardware params are set by application. This
805 * function can also be called multiple times and can allocate buffers
806 * (using snd_pcm_lib_* ). It's non-atomic.
808 static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
809 struct snd_pcm_hw_params *params)
811 struct snd_soc_pcm_runtime *rtd = substream->private_data;
812 struct snd_soc_platform *platform = rtd->platform;
813 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
814 struct snd_soc_dai *codec_dai = rtd->codec_dai;
817 mutex_lock(&pcm_mutex);
819 if (rtd->dai_link->ops && rtd->dai_link->ops->hw_params) {
820 ret = rtd->dai_link->ops->hw_params(substream, params);
822 printk(KERN_ERR "asoc: machine hw_params failed\n");
827 if (codec_dai->driver->ops->hw_params) {
828 ret = codec_dai->driver->ops->hw_params(substream, params, codec_dai);
830 printk(KERN_ERR "asoc: can't set codec %s hw params\n",
836 if (cpu_dai->driver->ops->hw_params) {
837 ret = cpu_dai->driver->ops->hw_params(substream, params, cpu_dai);
839 printk(KERN_ERR "asoc: interface %s hw params failed\n",
845 if (platform->driver->ops->hw_params) {
846 ret = platform->driver->ops->hw_params(substream, params);
848 printk(KERN_ERR "asoc: platform %s hw params failed\n",
854 rtd->rate = params_rate(params);
857 mutex_unlock(&pcm_mutex);
861 if (cpu_dai->driver->ops->hw_free)
862 cpu_dai->driver->ops->hw_free(substream, cpu_dai);
865 if (codec_dai->driver->ops->hw_free)
866 codec_dai->driver->ops->hw_free(substream, codec_dai);
869 if (rtd->dai_link->ops && rtd->dai_link->ops->hw_free)
870 rtd->dai_link->ops->hw_free(substream);
872 mutex_unlock(&pcm_mutex);
877 * Frees resources allocated by hw_params, can be called multiple times
879 static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
881 struct snd_soc_pcm_runtime *rtd = substream->private_data;
882 struct snd_soc_platform *platform = rtd->platform;
883 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
884 struct snd_soc_dai *codec_dai = rtd->codec_dai;
885 struct snd_soc_codec *codec = rtd->codec;
887 mutex_lock(&pcm_mutex);
889 /* apply codec digital mute */
891 snd_soc_dai_digital_mute(codec_dai, 1);
893 /* free any machine hw params */
894 if (rtd->dai_link->ops && rtd->dai_link->ops->hw_free)
895 rtd->dai_link->ops->hw_free(substream);
897 /* free any DMA resources */
898 if (platform->driver->ops->hw_free)
899 platform->driver->ops->hw_free(substream);
901 /* now free hw params for the DAIs */
902 if (codec_dai->driver->ops->hw_free)
903 codec_dai->driver->ops->hw_free(substream, codec_dai);
905 if (cpu_dai->driver->ops->hw_free)
906 cpu_dai->driver->ops->hw_free(substream, cpu_dai);
908 mutex_unlock(&pcm_mutex);
912 static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
914 struct snd_soc_pcm_runtime *rtd = substream->private_data;
915 struct snd_soc_platform *platform = rtd->platform;
916 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
917 struct snd_soc_dai *codec_dai = rtd->codec_dai;
920 if (codec_dai->driver->ops->trigger) {
921 ret = codec_dai->driver->ops->trigger(substream, cmd, codec_dai);
926 if (platform->driver->ops->trigger) {
927 ret = platform->driver->ops->trigger(substream, cmd);
932 if (cpu_dai->driver->ops->trigger) {
933 ret = cpu_dai->driver->ops->trigger(substream, cmd, cpu_dai);
941 * soc level wrapper for pointer callback
942 * If cpu_dai, codec_dai, platform driver has the delay callback, than
943 * the runtime->delay will be updated accordingly.
945 static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
947 struct snd_soc_pcm_runtime *rtd = substream->private_data;
948 struct snd_soc_platform *platform = rtd->platform;
949 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
950 struct snd_soc_dai *codec_dai = rtd->codec_dai;
951 struct snd_pcm_runtime *runtime = substream->runtime;
952 snd_pcm_uframes_t offset = 0;
953 snd_pcm_sframes_t delay = 0;
955 if (platform->driver->ops->pointer)
956 offset = platform->driver->ops->pointer(substream);
958 if (cpu_dai->driver->ops->delay)
959 delay += cpu_dai->driver->ops->delay(substream, cpu_dai);
961 if (codec_dai->driver->ops->delay)
962 delay += codec_dai->driver->ops->delay(substream, codec_dai);
964 if (platform->driver->delay)
965 delay += platform->driver->delay(substream, codec_dai);
967 runtime->delay = delay;
972 /* ASoC PCM operations */
973 static struct snd_pcm_ops soc_pcm_ops = {
974 .open = soc_pcm_open,
975 .close = soc_codec_close,
976 .hw_params = soc_pcm_hw_params,
977 .hw_free = soc_pcm_hw_free,
978 .prepare = soc_pcm_prepare,
979 .trigger = soc_pcm_trigger,
980 .pointer = soc_pcm_pointer,
984 /* powers down audio subsystem for suspend */
985 static int soc_suspend(struct device *dev)
987 struct platform_device *pdev = to_platform_device(dev);
988 struct snd_soc_card *card = platform_get_drvdata(pdev);
989 struct snd_soc_codec *codec;
992 /* If the initialization of this soc device failed, there is no codec
993 * associated with it. Just bail out in this case.
995 if (list_empty(&card->codec_dev_list))
998 /* Due to the resume being scheduled into a workqueue we could
999 * suspend before that's finished - wait for it to complete.
1001 snd_power_lock(card->snd_card);
1002 snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
1003 snd_power_unlock(card->snd_card);
1005 /* we're going to block userspace touching us until resume completes */
1006 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
1008 /* mute any active DACs */
1009 for (i = 0; i < card->num_rtd; i++) {
1010 struct snd_soc_dai *dai = card->rtd[i].codec_dai;
1011 struct snd_soc_dai_driver *drv = dai->driver;
1013 if (card->rtd[i].dai_link->ignore_suspend)
1016 if (drv->ops->digital_mute && dai->playback_active)
1017 drv->ops->digital_mute(dai, 1);
1020 /* suspend all pcms */
1021 for (i = 0; i < card->num_rtd; i++) {
1022 if (card->rtd[i].dai_link->ignore_suspend)
1025 snd_pcm_suspend_all(card->rtd[i].pcm);
1028 if (card->suspend_pre)
1029 card->suspend_pre(pdev, PMSG_SUSPEND);
1031 for (i = 0; i < card->num_rtd; i++) {
1032 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1033 struct snd_soc_platform *platform = card->rtd[i].platform;
1035 if (card->rtd[i].dai_link->ignore_suspend)
1038 if (cpu_dai->driver->suspend && !cpu_dai->driver->ac97_control)
1039 cpu_dai->driver->suspend(cpu_dai);
1040 if (platform->driver->suspend && !platform->suspended) {
1041 platform->driver->suspend(cpu_dai);
1042 platform->suspended = 1;
1046 /* close any waiting streams and save state */
1047 for (i = 0; i < card->num_rtd; i++) {
1048 run_delayed_work(&card->rtd[i].delayed_work);
1049 card->rtd[i].codec->dapm.suspend_bias_level = card->rtd[i].codec->dapm.bias_level;
1052 for (i = 0; i < card->num_rtd; i++) {
1053 struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;
1055 if (card->rtd[i].dai_link->ignore_suspend)
1058 if (driver->playback.stream_name != NULL)
1059 snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,
1060 SND_SOC_DAPM_STREAM_SUSPEND);
1062 if (driver->capture.stream_name != NULL)
1063 snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,
1064 SND_SOC_DAPM_STREAM_SUSPEND);
1067 /* suspend all CODECs */
1068 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
1069 /* If there are paths active then the CODEC will be held with
1070 * bias _ON and should not be suspended. */
1071 if (!codec->suspended && codec->driver->suspend) {
1072 switch (codec->dapm.bias_level) {
1073 case SND_SOC_BIAS_STANDBY:
1074 case SND_SOC_BIAS_OFF:
1075 codec->driver->suspend(codec, PMSG_SUSPEND);
1076 codec->suspended = 1;
1079 dev_dbg(codec->dev, "CODEC is on over suspend\n");
1085 for (i = 0; i < card->num_rtd; i++) {
1086 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1088 if (card->rtd[i].dai_link->ignore_suspend)
1091 if (cpu_dai->driver->suspend && cpu_dai->driver->ac97_control)
1092 cpu_dai->driver->suspend(cpu_dai);
1095 if (card->suspend_post)
1096 card->suspend_post(pdev, PMSG_SUSPEND);
1101 /* deferred resume work, so resume can complete before we finished
1102 * setting our codec back up, which can be very slow on I2C
1104 static void soc_resume_deferred(struct work_struct *work)
1106 struct snd_soc_card *card =
1107 container_of(work, struct snd_soc_card, deferred_resume_work);
1108 struct platform_device *pdev = to_platform_device(card->dev);
1109 struct snd_soc_codec *codec;
1112 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
1113 * so userspace apps are blocked from touching us
1116 dev_dbg(card->dev, "starting resume work\n");
1118 /* Bring us up into D2 so that DAPM starts enabling things */
1119 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
1121 if (card->resume_pre)
1122 card->resume_pre(pdev);
1124 /* resume AC97 DAIs */
1125 for (i = 0; i < card->num_rtd; i++) {
1126 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1128 if (card->rtd[i].dai_link->ignore_suspend)
1131 if (cpu_dai->driver->resume && cpu_dai->driver->ac97_control)
1132 cpu_dai->driver->resume(cpu_dai);
1135 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
1136 /* If the CODEC was idle over suspend then it will have been
1137 * left with bias OFF or STANDBY and suspended so we must now
1138 * resume. Otherwise the suspend was suppressed.
1140 if (codec->driver->resume && codec->suspended) {
1141 switch (codec->dapm.bias_level) {
1142 case SND_SOC_BIAS_STANDBY:
1143 case SND_SOC_BIAS_OFF:
1144 codec->driver->resume(codec);
1145 codec->suspended = 0;
1148 dev_dbg(codec->dev, "CODEC was on over suspend\n");
1154 for (i = 0; i < card->num_rtd; i++) {
1155 struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;
1157 if (card->rtd[i].dai_link->ignore_suspend)
1160 if (driver->playback.stream_name != NULL)
1161 snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,
1162 SND_SOC_DAPM_STREAM_RESUME);
1164 if (driver->capture.stream_name != NULL)
1165 snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,
1166 SND_SOC_DAPM_STREAM_RESUME);
1169 /* unmute any active DACs */
1170 for (i = 0; i < card->num_rtd; i++) {
1171 struct snd_soc_dai *dai = card->rtd[i].codec_dai;
1172 struct snd_soc_dai_driver *drv = dai->driver;
1174 if (card->rtd[i].dai_link->ignore_suspend)
1177 if (drv->ops->digital_mute && dai->playback_active)
1178 drv->ops->digital_mute(dai, 0);
1181 for (i = 0; i < card->num_rtd; i++) {
1182 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1183 struct snd_soc_platform *platform = card->rtd[i].platform;
1185 if (card->rtd[i].dai_link->ignore_suspend)
1188 if (cpu_dai->driver->resume && !cpu_dai->driver->ac97_control)
1189 cpu_dai->driver->resume(cpu_dai);
1190 if (platform->driver->resume && platform->suspended) {
1191 platform->driver->resume(cpu_dai);
1192 platform->suspended = 0;
1196 if (card->resume_post)
1197 card->resume_post(pdev);
1199 dev_dbg(card->dev, "resume work completed\n");
1201 /* userspace can access us now we are back as we were before */
1202 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
1205 /* powers up audio subsystem after a suspend */
1206 static int soc_resume(struct device *dev)
1208 struct platform_device *pdev = to_platform_device(dev);
1209 struct snd_soc_card *card = platform_get_drvdata(pdev);
1212 /* AC97 devices might have other drivers hanging off them so
1213 * need to resume immediately. Other drivers don't have that
1214 * problem and may take a substantial amount of time to resume
1215 * due to I/O costs and anti-pop so handle them out of line.
1217 for (i = 0; i < card->num_rtd; i++) {
1218 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1219 if (cpu_dai->driver->ac97_control) {
1220 dev_dbg(dev, "Resuming AC97 immediately\n");
1221 soc_resume_deferred(&card->deferred_resume_work);
1223 dev_dbg(dev, "Scheduling resume work\n");
1224 if (!schedule_work(&card->deferred_resume_work))
1225 dev_err(dev, "resume work item may be lost\n");
1232 #define soc_suspend NULL
1233 #define soc_resume NULL
1236 static struct snd_soc_dai_ops null_dai_ops = {
1239 static int soc_bind_dai_link(struct snd_soc_card *card, int num)
1241 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1242 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1243 struct snd_soc_codec *codec;
1244 struct snd_soc_platform *platform;
1245 struct snd_soc_dai *codec_dai, *cpu_dai;
1249 dev_dbg(card->dev, "binding %s at idx %d\n", dai_link->name, num);
1251 /* do we already have the CPU DAI for this link ? */
1255 /* no, then find CPU DAI from registered DAIs*/
1256 list_for_each_entry(cpu_dai, &dai_list, list) {
1257 if (!strcmp(cpu_dai->name, dai_link->cpu_dai_name)) {
1259 if (!try_module_get(cpu_dai->dev->driver->owner))
1262 rtd->cpu_dai = cpu_dai;
1266 dev_dbg(card->dev, "CPU DAI %s not registered\n",
1267 dai_link->cpu_dai_name);
1270 /* do we already have the CODEC for this link ? */
1275 /* no, then find CODEC from registered CODECs*/
1276 list_for_each_entry(codec, &codec_list, list) {
1277 if (!strcmp(codec->name, dai_link->codec_name)) {
1280 if (!try_module_get(codec->dev->driver->owner))
1283 /* CODEC found, so find CODEC DAI from registered DAIs from this CODEC*/
1284 list_for_each_entry(codec_dai, &dai_list, list) {
1285 if (codec->dev == codec_dai->dev &&
1286 !strcmp(codec_dai->name, dai_link->codec_dai_name)) {
1287 rtd->codec_dai = codec_dai;
1291 dev_dbg(card->dev, "CODEC DAI %s not registered\n",
1292 dai_link->codec_dai_name);
1297 dev_dbg(card->dev, "CODEC %s not registered\n",
1298 dai_link->codec_name);
1301 /* do we already have the CODEC DAI for this link ? */
1302 if (rtd->platform) {
1305 /* no, then find CPU DAI from registered DAIs*/
1306 list_for_each_entry(platform, &platform_list, list) {
1307 if (!strcmp(platform->name, dai_link->platform_name)) {
1309 if (!try_module_get(platform->dev->driver->owner))
1312 rtd->platform = platform;
1317 dev_dbg(card->dev, "platform %s not registered\n",
1318 dai_link->platform_name);
1322 /* mark rtd as complete if we found all 4 of our client devices */
1323 if (rtd->codec && rtd->codec_dai && rtd->platform && rtd->cpu_dai) {
1330 static void soc_remove_dai_link(struct snd_soc_card *card, int num)
1332 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1333 struct snd_soc_codec *codec = rtd->codec;
1334 struct snd_soc_platform *platform = rtd->platform;
1335 struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
1338 /* unregister the rtd device */
1339 if (rtd->dev_registered) {
1340 device_remove_file(&rtd->dev, &dev_attr_pmdown_time);
1341 device_unregister(&rtd->dev);
1342 rtd->dev_registered = 0;
1345 /* remove the CODEC DAI */
1346 if (codec_dai && codec_dai->probed) {
1347 if (codec_dai->driver->remove) {
1348 err = codec_dai->driver->remove(codec_dai);
1350 printk(KERN_ERR "asoc: failed to remove %s\n", codec_dai->name);
1352 codec_dai->probed = 0;
1353 list_del(&codec_dai->card_list);
1356 /* remove the platform */
1357 if (platform && platform->probed) {
1358 if (platform->driver->remove) {
1359 err = platform->driver->remove(platform);
1361 printk(KERN_ERR "asoc: failed to remove %s\n", platform->name);
1363 platform->probed = 0;
1364 list_del(&platform->card_list);
1365 module_put(platform->dev->driver->owner);
1368 /* remove the CODEC */
1369 if (codec && codec->probed) {
1370 if (codec->driver->remove) {
1371 err = codec->driver->remove(codec);
1373 printk(KERN_ERR "asoc: failed to remove %s\n", codec->name);
1376 /* Make sure all DAPM widgets are freed */
1377 snd_soc_dapm_free(&codec->dapm);
1379 soc_cleanup_codec_debugfs(codec);
1380 device_remove_file(&rtd->dev, &dev_attr_codec_reg);
1382 list_del(&codec->card_list);
1383 module_put(codec->dev->driver->owner);
1386 /* remove the cpu_dai */
1387 if (cpu_dai && cpu_dai->probed) {
1388 if (cpu_dai->driver->remove) {
1389 err = cpu_dai->driver->remove(cpu_dai);
1391 printk(KERN_ERR "asoc: failed to remove %s\n", cpu_dai->name);
1393 cpu_dai->probed = 0;
1394 list_del(&cpu_dai->card_list);
1395 module_put(cpu_dai->dev->driver->owner);
1399 static void soc_set_name_prefix(struct snd_soc_card *card,
1400 struct snd_soc_codec *codec)
1404 if (card->codec_conf == NULL)
1407 for (i = 0; i < card->num_configs; i++) {
1408 struct snd_soc_codec_conf *map = &card->codec_conf[i];
1409 if (map->dev_name && !strcmp(codec->name, map->dev_name)) {
1410 codec->name_prefix = map->name_prefix;
1416 static void rtd_release(struct device *dev) {}
1418 static int soc_probe_dai_link(struct snd_soc_card *card, int num)
1420 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1421 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1422 struct snd_soc_codec *codec = rtd->codec;
1423 struct snd_soc_platform *platform = rtd->platform;
1424 struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
1428 dev_dbg(card->dev, "probe %s dai link %d\n", card->name, num);
1430 /* config components */
1431 codec_dai->codec = codec;
1433 cpu_dai->platform = platform;
1435 rtd->dev.parent = card->dev;
1436 codec_dai->card = card;
1437 cpu_dai->card = card;
1439 /* set default power off timeout */
1440 rtd->pmdown_time = pmdown_time;
1442 /* probe the cpu_dai */
1443 if (!cpu_dai->probed) {
1444 if (cpu_dai->driver->probe) {
1445 ret = cpu_dai->driver->probe(cpu_dai);
1447 printk(KERN_ERR "asoc: failed to probe CPU DAI %s\n",
1452 cpu_dai->probed = 1;
1453 /* mark cpu_dai as probed and add to card cpu_dai list */
1454 list_add(&cpu_dai->card_list, &card->dai_dev_list);
1457 /* probe the CODEC */
1458 if (!codec->probed) {
1459 codec->dapm.card = card;
1460 soc_set_name_prefix(card, codec);
1461 if (codec->driver->probe) {
1462 ret = codec->driver->probe(codec);
1464 printk(KERN_ERR "asoc: failed to probe CODEC %s\n",
1470 soc_init_codec_debugfs(codec);
1472 /* mark codec as probed and add to card codec list */
1474 list_add(&codec->card_list, &card->codec_dev_list);
1477 /* probe the platform */
1478 if (!platform->probed) {
1479 if (platform->driver->probe) {
1480 ret = platform->driver->probe(platform);
1482 printk(KERN_ERR "asoc: failed to probe platform %s\n",
1487 /* mark platform as probed and add to card platform list */
1488 platform->probed = 1;
1489 list_add(&platform->card_list, &card->platform_dev_list);
1492 /* probe the CODEC DAI */
1493 if (!codec_dai->probed) {
1494 if (codec_dai->driver->probe) {
1495 ret = codec_dai->driver->probe(codec_dai);
1497 printk(KERN_ERR "asoc: failed to probe CODEC DAI %s\n",
1503 /* mark cpu_dai as probed and add to card cpu_dai list */
1504 codec_dai->probed = 1;
1505 list_add(&codec_dai->card_list, &card->dai_dev_list);
1508 /* DAPM dai link stream work */
1509 INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
1511 /* now that all clients have probed, initialise the DAI link */
1512 if (dai_link->init) {
1513 /* machine controls, routes and widgets are not prefixed */
1514 temp = rtd->codec->name_prefix;
1515 rtd->codec->name_prefix = NULL;
1516 ret = dai_link->init(rtd);
1518 printk(KERN_ERR "asoc: failed to init %s\n", dai_link->stream_name);
1521 rtd->codec->name_prefix = temp;
1524 /* Make sure all DAPM widgets are instantiated */
1525 snd_soc_dapm_new_widgets(&codec->dapm);
1526 snd_soc_dapm_sync(&codec->dapm);
1528 /* register the rtd device */
1529 rtd->dev.release = rtd_release;
1530 rtd->dev.init_name = dai_link->name;
1531 ret = device_register(&rtd->dev);
1533 printk(KERN_ERR "asoc: failed to register DAI runtime device %d\n", ret);
1537 rtd->dev_registered = 1;
1538 ret = device_create_file(&rtd->dev, &dev_attr_pmdown_time);
1540 printk(KERN_WARNING "asoc: failed to add pmdown_time sysfs\n");
1542 /* add DAPM sysfs entries for this codec */
1543 ret = snd_soc_dapm_sys_add(&rtd->dev);
1545 printk(KERN_WARNING "asoc: failed to add codec dapm sysfs entries\n");
1547 /* add codec sysfs entries */
1548 ret = device_create_file(&rtd->dev, &dev_attr_codec_reg);
1550 printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");
1552 /* create the pcm */
1553 ret = soc_new_pcm(rtd, num);
1555 printk(KERN_ERR "asoc: can't create pcm %s\n", dai_link->stream_name);
1559 /* add platform data for AC97 devices */
1560 if (rtd->codec_dai->driver->ac97_control)
1561 snd_ac97_dev_add_pdata(codec->ac97, rtd->cpu_dai->ac97_pdata);
1566 #ifdef CONFIG_SND_SOC_AC97_BUS
1567 static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime *rtd)
1571 /* Only instantiate AC97 if not already done by the adaptor
1572 * for the generic AC97 subsystem.
1574 if (rtd->codec_dai->driver->ac97_control && !rtd->codec->ac97_registered) {
1576 * It is possible that the AC97 device is already registered to
1577 * the device subsystem. This happens when the device is created
1578 * via snd_ac97_mixer(). Currently only SoC codec that does so
1579 * is the generic AC97 glue but others migh emerge.
1581 * In those cases we don't try to register the device again.
1583 if (!rtd->codec->ac97_created)
1586 ret = soc_ac97_dev_register(rtd->codec);
1588 printk(KERN_ERR "asoc: AC97 device register failed\n");
1592 rtd->codec->ac97_registered = 1;
1597 static void soc_unregister_ac97_dai_link(struct snd_soc_codec *codec)
1599 if (codec->ac97_registered) {
1600 soc_ac97_dev_unregister(codec);
1601 codec->ac97_registered = 0;
1606 static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
1608 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
1609 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
1610 struct snd_soc_codec *codec;
1614 /* find CODEC from registered CODECs*/
1615 list_for_each_entry(codec, &codec_list, list) {
1616 if (!strcmp(codec->name, aux_dev->codec_name)) {
1617 if (codec->probed) {
1619 "asoc: codec already probed");
1626 /* codec not found */
1627 dev_err(card->dev, "asoc: codec %s not found", aux_dev->codec_name);
1631 if (!try_module_get(codec->dev->driver->owner))
1635 codec->dapm.card = card;
1637 soc_set_name_prefix(card, codec);
1638 if (codec->driver->probe) {
1639 ret = codec->driver->probe(codec);
1641 dev_err(codec->dev, "asoc: failed to probe CODEC");
1646 soc_init_codec_debugfs(codec);
1648 /* mark codec as probed and add to card codec list */
1650 list_add(&codec->card_list, &card->codec_dev_list);
1652 /* now that all clients have probed, initialise the DAI link */
1653 if (aux_dev->init) {
1654 /* machine controls, routes and widgets are not prefixed */
1655 temp = codec->name_prefix;
1656 codec->name_prefix = NULL;
1657 ret = aux_dev->init(&codec->dapm);
1660 "asoc: failed to init %s\n", aux_dev->name);
1663 codec->name_prefix = temp;
1666 /* Make sure all DAPM widgets are instantiated */
1667 snd_soc_dapm_new_widgets(&codec->dapm);
1668 snd_soc_dapm_sync(&codec->dapm);
1670 /* register the rtd device */
1673 rtd->dev.parent = card->dev;
1674 rtd->dev.release = rtd_release;
1675 rtd->dev.init_name = aux_dev->name;
1676 ret = device_register(&rtd->dev);
1679 "asoc: failed to register aux runtime device %d\n",
1683 rtd->dev_registered = 1;
1685 /* add DAPM sysfs entries for this codec */
1686 ret = snd_soc_dapm_sys_add(&rtd->dev);
1689 "asoc: failed to add codec dapm sysfs entries\n");
1691 /* add codec sysfs entries */
1692 ret = device_create_file(&rtd->dev, &dev_attr_codec_reg);
1694 dev_err(codec->dev, "asoc: failed to add codec sysfs files\n");
1700 static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
1702 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
1703 struct snd_soc_codec *codec = rtd->codec;
1706 /* unregister the rtd device */
1707 if (rtd->dev_registered) {
1708 device_unregister(&rtd->dev);
1709 rtd->dev_registered = 0;
1712 /* remove the CODEC */
1713 if (codec && codec->probed) {
1714 if (codec->driver->remove) {
1715 err = codec->driver->remove(codec);
1718 "asoc: failed to remove %s\n",
1722 /* Make sure all DAPM widgets are freed */
1723 snd_soc_dapm_free(&codec->dapm);
1725 soc_cleanup_codec_debugfs(codec);
1726 device_remove_file(&rtd->dev, &dev_attr_codec_reg);
1728 list_del(&codec->card_list);
1729 module_put(codec->dev->driver->owner);
1733 static int snd_soc_init_codec_cache(struct snd_soc_codec *codec,
1734 enum snd_soc_compress_type compress_type)
1738 if (codec->cache_init)
1741 /* override the compress_type if necessary */
1742 if (compress_type && codec->compress_type != compress_type)
1743 codec->compress_type = compress_type;
1744 dev_dbg(codec->dev, "Cache compress_type for %s is %d\n",
1745 codec->name, codec->compress_type);
1746 ret = snd_soc_cache_init(codec);
1748 dev_err(codec->dev, "Failed to set cache compression type: %d\n",
1752 codec->cache_init = 1;
1757 static void snd_soc_instantiate_card(struct snd_soc_card *card)
1759 struct platform_device *pdev = to_platform_device(card->dev);
1760 struct snd_soc_codec *codec;
1761 struct snd_soc_codec_conf *codec_conf;
1762 enum snd_soc_compress_type compress_type;
1765 mutex_lock(&card->mutex);
1767 if (card->instantiated) {
1768 mutex_unlock(&card->mutex);
1773 for (i = 0; i < card->num_links; i++)
1774 soc_bind_dai_link(card, i);
1776 /* bind completed ? */
1777 if (card->num_rtd != card->num_links) {
1778 mutex_unlock(&card->mutex);
1782 /* initialize the register cache for each available codec */
1783 list_for_each_entry(codec, &codec_list, list) {
1784 if (codec->cache_init)
1786 /* check to see if we need to override the compress_type */
1787 for (i = 0; i < card->num_configs; ++i) {
1788 codec_conf = &card->codec_conf[i];
1789 if (!strcmp(codec->name, codec_conf->dev_name)) {
1790 compress_type = codec_conf->compress_type;
1791 if (compress_type && compress_type
1792 != codec->compress_type)
1796 if (i == card->num_configs) {
1797 /* no need to override the compress_type so
1798 * go ahead and do the standard thing */
1799 ret = snd_soc_init_codec_cache(codec, 0);
1801 mutex_unlock(&card->mutex);
1806 /* override the compress_type with the one supplied in
1807 * the machine driver */
1808 ret = snd_soc_init_codec_cache(codec, compress_type);
1810 mutex_unlock(&card->mutex);
1815 /* card bind complete so register a sound card */
1816 ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
1817 card->owner, 0, &card->snd_card);
1819 printk(KERN_ERR "asoc: can't create sound card for card %s\n",
1821 mutex_unlock(&card->mutex);
1824 card->snd_card->dev = card->dev;
1827 /* deferred resume work */
1828 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
1831 /* initialise the sound card only once */
1833 ret = card->probe(pdev);
1835 goto card_probe_error;
1838 for (i = 0; i < card->num_links; i++) {
1839 ret = soc_probe_dai_link(card, i);
1841 pr_err("asoc: failed to instantiate card %s: %d\n",
1847 for (i = 0; i < card->num_aux_devs; i++) {
1848 ret = soc_probe_aux_dev(card, i);
1850 pr_err("asoc: failed to add auxiliary devices %s: %d\n",
1852 goto probe_aux_dev_err;
1856 snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
1858 snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
1861 ret = snd_card_register(card->snd_card);
1863 printk(KERN_ERR "asoc: failed to register soundcard for %s\n", card->name);
1867 #ifdef CONFIG_SND_SOC_AC97_BUS
1868 /* register any AC97 codecs */
1869 for (i = 0; i < card->num_rtd; i++) {
1870 ret = soc_register_ac97_dai_link(&card->rtd[i]);
1872 printk(KERN_ERR "asoc: failed to register AC97 %s\n", card->name);
1878 card->instantiated = 1;
1879 mutex_unlock(&card->mutex);
1883 for (i = 0; i < card->num_aux_devs; i++)
1884 soc_remove_aux_dev(card, i);
1887 for (i = 0; i < card->num_links; i++)
1888 soc_remove_dai_link(card, i);
1894 snd_card_free(card->snd_card);
1896 mutex_unlock(&card->mutex);
1900 * Attempt to initialise any uninitialised cards. Must be called with
1903 static void snd_soc_instantiate_cards(void)
1905 struct snd_soc_card *card;
1906 list_for_each_entry(card, &card_list, list)
1907 snd_soc_instantiate_card(card);
1910 /* probes a new socdev */
1911 static int soc_probe(struct platform_device *pdev)
1913 struct snd_soc_card *card = platform_get_drvdata(pdev);
1916 /* Bodge while we unpick instantiation */
1917 card->dev = &pdev->dev;
1918 INIT_LIST_HEAD(&card->dai_dev_list);
1919 INIT_LIST_HEAD(&card->codec_dev_list);
1920 INIT_LIST_HEAD(&card->platform_dev_list);
1922 soc_init_card_debugfs(card);
1924 ret = snd_soc_register_card(card);
1926 dev_err(&pdev->dev, "Failed to register card\n");
1933 /* removes a socdev */
1934 static int soc_remove(struct platform_device *pdev)
1936 struct snd_soc_card *card = platform_get_drvdata(pdev);
1939 if (card->instantiated) {
1941 /* make sure any delayed work runs */
1942 for (i = 0; i < card->num_rtd; i++) {
1943 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1944 run_delayed_work(&rtd->delayed_work);
1947 /* remove auxiliary devices */
1948 for (i = 0; i < card->num_aux_devs; i++)
1949 soc_remove_aux_dev(card, i);
1951 /* remove and free each DAI */
1952 for (i = 0; i < card->num_rtd; i++)
1953 soc_remove_dai_link(card, i);
1955 soc_cleanup_card_debugfs(card);
1957 /* remove the card */
1962 snd_card_free(card->snd_card);
1964 snd_soc_unregister_card(card);
1968 static int soc_poweroff(struct device *dev)
1970 struct platform_device *pdev = to_platform_device(dev);
1971 struct snd_soc_card *card = platform_get_drvdata(pdev);
1974 if (!card->instantiated)
1977 /* Flush out pmdown_time work - we actually do want to run it
1978 * now, we're shutting down so no imminent restart. */
1979 for (i = 0; i < card->num_rtd; i++) {
1980 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1981 run_delayed_work(&rtd->delayed_work);
1984 snd_soc_dapm_shutdown(card);
1989 static const struct dev_pm_ops soc_pm_ops = {
1990 .suspend = soc_suspend,
1991 .resume = soc_resume,
1992 .poweroff = soc_poweroff,
1995 /* ASoC platform driver */
1996 static struct platform_driver soc_driver = {
1998 .name = "soc-audio",
1999 .owner = THIS_MODULE,
2003 .remove = soc_remove,
2006 /* create a new pcm */
2007 static int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
2009 struct snd_soc_codec *codec = rtd->codec;
2010 struct snd_soc_platform *platform = rtd->platform;
2011 struct snd_soc_dai *codec_dai = rtd->codec_dai;
2012 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2013 struct snd_pcm *pcm;
2015 int ret = 0, playback = 0, capture = 0;
2017 /* check client and interface hw capabilities */
2018 snprintf(new_name, sizeof(new_name), "%s %s-%d",
2019 rtd->dai_link->stream_name, codec_dai->name, num);
2021 if (codec_dai->driver->playback.channels_min)
2023 if (codec_dai->driver->capture.channels_min)
2026 dev_dbg(rtd->card->dev, "registered pcm #%d %s\n",num,new_name);
2027 ret = snd_pcm_new(rtd->card->snd_card, new_name,
2028 num, playback, capture, &pcm);
2030 printk(KERN_ERR "asoc: can't create pcm for codec %s\n", codec->name);
2035 pcm->private_data = rtd;
2036 soc_pcm_ops.mmap = platform->driver->ops->mmap;
2037 soc_pcm_ops.pointer = platform->driver->ops->pointer;
2038 soc_pcm_ops.ioctl = platform->driver->ops->ioctl;
2039 soc_pcm_ops.copy = platform->driver->ops->copy;
2040 soc_pcm_ops.silence = platform->driver->ops->silence;
2041 soc_pcm_ops.ack = platform->driver->ops->ack;
2042 soc_pcm_ops.page = platform->driver->ops->page;
2045 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops);
2048 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops);
2050 ret = platform->driver->pcm_new(rtd->card->snd_card, codec_dai, pcm);
2052 printk(KERN_ERR "asoc: platform pcm constructor failed\n");
2056 pcm->private_free = platform->driver->pcm_free;
2057 printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name,
2063 * snd_soc_codec_volatile_register: Report if a register is volatile.
2065 * @codec: CODEC to query.
2066 * @reg: Register to query.
2068 * Boolean function indiciating if a CODEC register is volatile.
2070 int snd_soc_codec_volatile_register(struct snd_soc_codec *codec, int reg)
2072 if (codec->driver->volatile_register)
2073 return codec->driver->volatile_register(reg);
2077 EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register);
2080 * snd_soc_new_ac97_codec - initailise AC97 device
2081 * @codec: audio codec
2082 * @ops: AC97 bus operations
2083 * @num: AC97 codec number
2085 * Initialises AC97 codec resources for use by ad-hoc devices only.
2087 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
2088 struct snd_ac97_bus_ops *ops, int num)
2090 mutex_lock(&codec->mutex);
2092 codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
2093 if (codec->ac97 == NULL) {
2094 mutex_unlock(&codec->mutex);
2098 codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
2099 if (codec->ac97->bus == NULL) {
2102 mutex_unlock(&codec->mutex);
2106 codec->ac97->bus->ops = ops;
2107 codec->ac97->num = num;
2110 * Mark the AC97 device to be created by us. This way we ensure that the
2111 * device will be registered with the device subsystem later on.
2113 codec->ac97_created = 1;
2115 mutex_unlock(&codec->mutex);
2118 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
2121 * snd_soc_free_ac97_codec - free AC97 codec device
2122 * @codec: audio codec
2124 * Frees AC97 codec device resources.
2126 void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
2128 mutex_lock(&codec->mutex);
2129 #ifdef CONFIG_SND_SOC_AC97_BUS
2130 soc_unregister_ac97_dai_link(codec);
2132 kfree(codec->ac97->bus);
2135 codec->ac97_created = 0;
2136 mutex_unlock(&codec->mutex);
2138 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
2140 unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg)
2144 ret = codec->read(codec, reg);
2145 dev_dbg(codec->dev, "read %x => %x\n", reg, ret);
2146 trace_snd_soc_reg_read(codec, reg, ret);
2150 EXPORT_SYMBOL_GPL(snd_soc_read);
2152 unsigned int snd_soc_write(struct snd_soc_codec *codec,
2153 unsigned int reg, unsigned int val)
2155 dev_dbg(codec->dev, "write %x = %x\n", reg, val);
2156 trace_snd_soc_reg_write(codec, reg, val);
2157 return codec->write(codec, reg, val);
2159 EXPORT_SYMBOL_GPL(snd_soc_write);
2162 * snd_soc_update_bits - update codec register bits
2163 * @codec: audio codec
2164 * @reg: codec register
2165 * @mask: register mask
2168 * Writes new register value.
2170 * Returns 1 for change else 0.
2172 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
2173 unsigned int mask, unsigned int value)
2176 unsigned int old, new;
2178 old = snd_soc_read(codec, reg);
2179 new = (old & ~mask) | value;
2180 change = old != new;
2182 snd_soc_write(codec, reg, new);
2186 EXPORT_SYMBOL_GPL(snd_soc_update_bits);
2189 * snd_soc_update_bits_locked - update codec register bits
2190 * @codec: audio codec
2191 * @reg: codec register
2192 * @mask: register mask
2195 * Writes new register value, and takes the codec mutex.
2197 * Returns 1 for change else 0.
2199 int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
2200 unsigned short reg, unsigned int mask,
2205 mutex_lock(&codec->mutex);
2206 change = snd_soc_update_bits(codec, reg, mask, value);
2207 mutex_unlock(&codec->mutex);
2211 EXPORT_SYMBOL_GPL(snd_soc_update_bits_locked);
2214 * snd_soc_test_bits - test register for change
2215 * @codec: audio codec
2216 * @reg: codec register
2217 * @mask: register mask
2220 * Tests a register with a new value and checks if the new value is
2221 * different from the old value.
2223 * Returns 1 for change else 0.
2225 int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
2226 unsigned int mask, unsigned int value)
2229 unsigned int old, new;
2231 old = snd_soc_read(codec, reg);
2232 new = (old & ~mask) | value;
2233 change = old != new;
2237 EXPORT_SYMBOL_GPL(snd_soc_test_bits);
2240 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
2241 * @substream: the pcm substream
2242 * @hw: the hardware parameters
2244 * Sets the substream runtime hardware parameters.
2246 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
2247 const struct snd_pcm_hardware *hw)
2249 struct snd_pcm_runtime *runtime = substream->runtime;
2250 runtime->hw.info = hw->info;
2251 runtime->hw.formats = hw->formats;
2252 runtime->hw.period_bytes_min = hw->period_bytes_min;
2253 runtime->hw.period_bytes_max = hw->period_bytes_max;
2254 runtime->hw.periods_min = hw->periods_min;
2255 runtime->hw.periods_max = hw->periods_max;
2256 runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
2257 runtime->hw.fifo_size = hw->fifo_size;
2260 EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
2263 * snd_soc_cnew - create new control
2264 * @_template: control template
2265 * @data: control private data
2266 * @long_name: control long name
2268 * Create a new mixer control from a template control.
2270 * Returns 0 for success, else error.
2272 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
2273 void *data, char *long_name)
2275 struct snd_kcontrol_new template;
2277 memcpy(&template, _template, sizeof(template));
2279 template.name = long_name;
2282 return snd_ctl_new1(&template, data);
2284 EXPORT_SYMBOL_GPL(snd_soc_cnew);
2287 * snd_soc_add_controls - add an array of controls to a codec.
2288 * Convienience function to add a list of controls. Many codecs were
2289 * duplicating this code.
2291 * @codec: codec to add controls to
2292 * @controls: array of controls to add
2293 * @num_controls: number of elements in the array
2295 * Return 0 for success, else error.
2297 int snd_soc_add_controls(struct snd_soc_codec *codec,
2298 const struct snd_kcontrol_new *controls, int num_controls)
2300 struct snd_card *card = codec->card->snd_card;
2301 char prefixed_name[44], *name;
2304 for (i = 0; i < num_controls; i++) {
2305 const struct snd_kcontrol_new *control = &controls[i];
2306 if (codec->name_prefix) {
2307 snprintf(prefixed_name, sizeof(prefixed_name), "%s %s",
2308 codec->name_prefix, control->name);
2309 name = prefixed_name;
2311 name = control->name;
2313 err = snd_ctl_add(card, snd_soc_cnew(control, codec, name));
2315 dev_err(codec->dev, "%s: Failed to add %s: %d\n",
2316 codec->name, name, err);
2323 EXPORT_SYMBOL_GPL(snd_soc_add_controls);
2326 * snd_soc_info_enum_double - enumerated double mixer info callback
2327 * @kcontrol: mixer control
2328 * @uinfo: control element information
2330 * Callback to provide information about a double enumerated
2333 * Returns 0 for success.
2335 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
2336 struct snd_ctl_elem_info *uinfo)
2338 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2340 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2341 uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
2342 uinfo->value.enumerated.items = e->max;
2344 if (uinfo->value.enumerated.item > e->max - 1)
2345 uinfo->value.enumerated.item = e->max - 1;
2346 strcpy(uinfo->value.enumerated.name,
2347 e->texts[uinfo->value.enumerated.item]);
2350 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
2353 * snd_soc_get_enum_double - enumerated double mixer get callback
2354 * @kcontrol: mixer control
2355 * @ucontrol: control element information
2357 * Callback to get the value of a double enumerated mixer.
2359 * Returns 0 for success.
2361 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
2362 struct snd_ctl_elem_value *ucontrol)
2364 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2365 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2366 unsigned int val, bitmask;
2368 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
2370 val = snd_soc_read(codec, e->reg);
2371 ucontrol->value.enumerated.item[0]
2372 = (val >> e->shift_l) & (bitmask - 1);
2373 if (e->shift_l != e->shift_r)
2374 ucontrol->value.enumerated.item[1] =
2375 (val >> e->shift_r) & (bitmask - 1);
2379 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
2382 * snd_soc_put_enum_double - enumerated double mixer put callback
2383 * @kcontrol: mixer control
2384 * @ucontrol: control element information
2386 * Callback to set the value of a double enumerated mixer.
2388 * Returns 0 for success.
2390 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
2391 struct snd_ctl_elem_value *ucontrol)
2393 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2394 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2396 unsigned int mask, bitmask;
2398 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
2400 if (ucontrol->value.enumerated.item[0] > e->max - 1)
2402 val = ucontrol->value.enumerated.item[0] << e->shift_l;
2403 mask = (bitmask - 1) << e->shift_l;
2404 if (e->shift_l != e->shift_r) {
2405 if (ucontrol->value.enumerated.item[1] > e->max - 1)
2407 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
2408 mask |= (bitmask - 1) << e->shift_r;
2411 return snd_soc_update_bits_locked(codec, e->reg, mask, val);
2413 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
2416 * snd_soc_get_value_enum_double - semi enumerated double mixer get callback
2417 * @kcontrol: mixer control
2418 * @ucontrol: control element information
2420 * Callback to get the value of a double semi enumerated mixer.
2422 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2423 * used for handling bitfield coded enumeration for example.
2425 * Returns 0 for success.
2427 int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
2428 struct snd_ctl_elem_value *ucontrol)
2430 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2431 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2432 unsigned int reg_val, val, mux;
2434 reg_val = snd_soc_read(codec, e->reg);
2435 val = (reg_val >> e->shift_l) & e->mask;
2436 for (mux = 0; mux < e->max; mux++) {
2437 if (val == e->values[mux])
2440 ucontrol->value.enumerated.item[0] = mux;
2441 if (e->shift_l != e->shift_r) {
2442 val = (reg_val >> e->shift_r) & e->mask;
2443 for (mux = 0; mux < e->max; mux++) {
2444 if (val == e->values[mux])
2447 ucontrol->value.enumerated.item[1] = mux;
2452 EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double);
2455 * snd_soc_put_value_enum_double - semi enumerated double mixer put callback
2456 * @kcontrol: mixer control
2457 * @ucontrol: control element information
2459 * Callback to set the value of a double semi enumerated mixer.
2461 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2462 * used for handling bitfield coded enumeration for example.
2464 * Returns 0 for success.
2466 int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
2467 struct snd_ctl_elem_value *ucontrol)
2469 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2470 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2474 if (ucontrol->value.enumerated.item[0] > e->max - 1)
2476 val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
2477 mask = e->mask << e->shift_l;
2478 if (e->shift_l != e->shift_r) {
2479 if (ucontrol->value.enumerated.item[1] > e->max - 1)
2481 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
2482 mask |= e->mask << e->shift_r;
2485 return snd_soc_update_bits_locked(codec, e->reg, mask, val);
2487 EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double);
2490 * snd_soc_info_enum_ext - external enumerated single mixer info callback
2491 * @kcontrol: mixer control
2492 * @uinfo: control element information
2494 * Callback to provide information about an external enumerated
2497 * Returns 0 for success.
2499 int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
2500 struct snd_ctl_elem_info *uinfo)
2502 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2504 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2506 uinfo->value.enumerated.items = e->max;
2508 if (uinfo->value.enumerated.item > e->max - 1)
2509 uinfo->value.enumerated.item = e->max - 1;
2510 strcpy(uinfo->value.enumerated.name,
2511 e->texts[uinfo->value.enumerated.item]);
2514 EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
2517 * snd_soc_info_volsw_ext - external single mixer info callback
2518 * @kcontrol: mixer control
2519 * @uinfo: control element information
2521 * Callback to provide information about a single external mixer control.
2523 * Returns 0 for success.
2525 int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
2526 struct snd_ctl_elem_info *uinfo)
2528 int max = kcontrol->private_value;
2530 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
2531 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2533 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2536 uinfo->value.integer.min = 0;
2537 uinfo->value.integer.max = max;
2540 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
2543 * snd_soc_info_volsw - single mixer info callback
2544 * @kcontrol: mixer control
2545 * @uinfo: control element information
2547 * Callback to provide information about a single mixer control.
2549 * Returns 0 for success.
2551 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
2552 struct snd_ctl_elem_info *uinfo)
2554 struct soc_mixer_control *mc =
2555 (struct soc_mixer_control *)kcontrol->private_value;
2557 unsigned int shift = mc->shift;
2558 unsigned int rshift = mc->rshift;
2560 if (!mc->platform_max)
2561 mc->platform_max = mc->max;
2562 platform_max = mc->platform_max;
2564 if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
2565 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2567 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2569 uinfo->count = shift == rshift ? 1 : 2;
2570 uinfo->value.integer.min = 0;
2571 uinfo->value.integer.max = platform_max;
2574 EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
2577 * snd_soc_get_volsw - single mixer get callback
2578 * @kcontrol: mixer control
2579 * @ucontrol: control element information
2581 * Callback to get the value of a single mixer control.
2583 * Returns 0 for success.
2585 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
2586 struct snd_ctl_elem_value *ucontrol)
2588 struct soc_mixer_control *mc =
2589 (struct soc_mixer_control *)kcontrol->private_value;
2590 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2591 unsigned int reg = mc->reg;
2592 unsigned int shift = mc->shift;
2593 unsigned int rshift = mc->rshift;
2595 unsigned int mask = (1 << fls(max)) - 1;
2596 unsigned int invert = mc->invert;
2598 ucontrol->value.integer.value[0] =
2599 (snd_soc_read(codec, reg) >> shift) & mask;
2600 if (shift != rshift)
2601 ucontrol->value.integer.value[1] =
2602 (snd_soc_read(codec, reg) >> rshift) & mask;
2604 ucontrol->value.integer.value[0] =
2605 max - ucontrol->value.integer.value[0];
2606 if (shift != rshift)
2607 ucontrol->value.integer.value[1] =
2608 max - ucontrol->value.integer.value[1];
2613 EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
2616 * snd_soc_put_volsw - single mixer put callback
2617 * @kcontrol: mixer control
2618 * @ucontrol: control element information
2620 * Callback to set the value of a single mixer control.
2622 * Returns 0 for success.
2624 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
2625 struct snd_ctl_elem_value *ucontrol)
2627 struct soc_mixer_control *mc =
2628 (struct soc_mixer_control *)kcontrol->private_value;
2629 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2630 unsigned int reg = mc->reg;
2631 unsigned int shift = mc->shift;
2632 unsigned int rshift = mc->rshift;
2634 unsigned int mask = (1 << fls(max)) - 1;
2635 unsigned int invert = mc->invert;
2636 unsigned int val, val2, val_mask;
2638 val = (ucontrol->value.integer.value[0] & mask);
2641 val_mask = mask << shift;
2643 if (shift != rshift) {
2644 val2 = (ucontrol->value.integer.value[1] & mask);
2647 val_mask |= mask << rshift;
2648 val |= val2 << rshift;
2650 return snd_soc_update_bits_locked(codec, reg, val_mask, val);
2652 EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
2655 * snd_soc_info_volsw_2r - double mixer info callback
2656 * @kcontrol: mixer control
2657 * @uinfo: control element information
2659 * Callback to provide information about a double mixer control that
2660 * spans 2 codec registers.
2662 * Returns 0 for success.
2664 int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
2665 struct snd_ctl_elem_info *uinfo)
2667 struct soc_mixer_control *mc =
2668 (struct soc_mixer_control *)kcontrol->private_value;
2671 if (!mc->platform_max)
2672 mc->platform_max = mc->max;
2673 platform_max = mc->platform_max;
2675 if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
2676 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2678 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2681 uinfo->value.integer.min = 0;
2682 uinfo->value.integer.max = platform_max;
2685 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
2688 * snd_soc_get_volsw_2r - double mixer get callback
2689 * @kcontrol: mixer control
2690 * @ucontrol: control element information
2692 * Callback to get the value of a double mixer control that spans 2 registers.
2694 * Returns 0 for success.
2696 int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
2697 struct snd_ctl_elem_value *ucontrol)
2699 struct soc_mixer_control *mc =
2700 (struct soc_mixer_control *)kcontrol->private_value;
2701 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2702 unsigned int reg = mc->reg;
2703 unsigned int reg2 = mc->rreg;
2704 unsigned int shift = mc->shift;
2706 unsigned int mask = (1 << fls(max)) - 1;
2707 unsigned int invert = mc->invert;
2709 ucontrol->value.integer.value[0] =
2710 (snd_soc_read(codec, reg) >> shift) & mask;
2711 ucontrol->value.integer.value[1] =
2712 (snd_soc_read(codec, reg2) >> shift) & mask;
2714 ucontrol->value.integer.value[0] =
2715 max - ucontrol->value.integer.value[0];
2716 ucontrol->value.integer.value[1] =
2717 max - ucontrol->value.integer.value[1];
2722 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r);
2725 * snd_soc_put_volsw_2r - double mixer set callback
2726 * @kcontrol: mixer control
2727 * @ucontrol: control element information
2729 * Callback to set the value of a double mixer control that spans 2 registers.
2731 * Returns 0 for success.
2733 int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
2734 struct snd_ctl_elem_value *ucontrol)
2736 struct soc_mixer_control *mc =
2737 (struct soc_mixer_control *)kcontrol->private_value;
2738 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2739 unsigned int reg = mc->reg;
2740 unsigned int reg2 = mc->rreg;
2741 unsigned int shift = mc->shift;
2743 unsigned int mask = (1 << fls(max)) - 1;
2744 unsigned int invert = mc->invert;
2746 unsigned int val, val2, val_mask;
2748 val_mask = mask << shift;
2749 val = (ucontrol->value.integer.value[0] & mask);
2750 val2 = (ucontrol->value.integer.value[1] & mask);
2758 val2 = val2 << shift;
2760 err = snd_soc_update_bits_locked(codec, reg, val_mask, val);
2764 err = snd_soc_update_bits_locked(codec, reg2, val_mask, val2);
2767 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
2770 * snd_soc_info_volsw_s8 - signed mixer info callback
2771 * @kcontrol: mixer control
2772 * @uinfo: control element information
2774 * Callback to provide information about a signed mixer control.
2776 * Returns 0 for success.
2778 int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
2779 struct snd_ctl_elem_info *uinfo)
2781 struct soc_mixer_control *mc =
2782 (struct soc_mixer_control *)kcontrol->private_value;
2786 if (!mc->platform_max)
2787 mc->platform_max = mc->max;
2788 platform_max = mc->platform_max;
2790 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2792 uinfo->value.integer.min = 0;
2793 uinfo->value.integer.max = platform_max - min;
2796 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
2799 * snd_soc_get_volsw_s8 - signed mixer get callback
2800 * @kcontrol: mixer control
2801 * @ucontrol: control element information
2803 * Callback to get the value of a signed mixer control.
2805 * Returns 0 for success.
2807 int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
2808 struct snd_ctl_elem_value *ucontrol)
2810 struct soc_mixer_control *mc =
2811 (struct soc_mixer_control *)kcontrol->private_value;
2812 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2813 unsigned int reg = mc->reg;
2815 int val = snd_soc_read(codec, reg);
2817 ucontrol->value.integer.value[0] =
2818 ((signed char)(val & 0xff))-min;
2819 ucontrol->value.integer.value[1] =
2820 ((signed char)((val >> 8) & 0xff))-min;
2823 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
2826 * snd_soc_put_volsw_sgn - signed mixer put callback
2827 * @kcontrol: mixer control
2828 * @ucontrol: control element information
2830 * Callback to set the value of a signed mixer control.
2832 * Returns 0 for success.
2834 int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
2835 struct snd_ctl_elem_value *ucontrol)
2837 struct soc_mixer_control *mc =
2838 (struct soc_mixer_control *)kcontrol->private_value;
2839 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2840 unsigned int reg = mc->reg;
2844 val = (ucontrol->value.integer.value[0]+min) & 0xff;
2845 val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
2847 return snd_soc_update_bits_locked(codec, reg, 0xffff, val);
2849 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
2852 * snd_soc_limit_volume - Set new limit to an existing volume control.
2854 * @codec: where to look for the control
2855 * @name: Name of the control
2856 * @max: new maximum limit
2858 * Return 0 for success, else error.
2860 int snd_soc_limit_volume(struct snd_soc_codec *codec,
2861 const char *name, int max)
2863 struct snd_card *card = codec->card->snd_card;
2864 struct snd_kcontrol *kctl;
2865 struct soc_mixer_control *mc;
2869 /* Sanity check for name and max */
2870 if (unlikely(!name || max <= 0))
2873 list_for_each_entry(kctl, &card->controls, list) {
2874 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
2880 mc = (struct soc_mixer_control *)kctl->private_value;
2881 if (max <= mc->max) {
2882 mc->platform_max = max;
2888 EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
2891 * snd_soc_info_volsw_2r_sx - double with tlv and variable data size
2892 * mixer info callback
2893 * @kcontrol: mixer control
2894 * @uinfo: control element information
2896 * Returns 0 for success.
2898 int snd_soc_info_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2899 struct snd_ctl_elem_info *uinfo)
2901 struct soc_mixer_control *mc =
2902 (struct soc_mixer_control *)kcontrol->private_value;
2906 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2908 uinfo->value.integer.min = 0;
2909 uinfo->value.integer.max = max-min;
2913 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r_sx);
2916 * snd_soc_get_volsw_2r_sx - double with tlv and variable data size
2917 * mixer get callback
2918 * @kcontrol: mixer control
2919 * @uinfo: control element information
2921 * Returns 0 for success.
2923 int snd_soc_get_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2924 struct snd_ctl_elem_value *ucontrol)
2926 struct soc_mixer_control *mc =
2927 (struct soc_mixer_control *)kcontrol->private_value;
2928 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2929 unsigned int mask = (1<<mc->shift)-1;
2931 int val = snd_soc_read(codec, mc->reg) & mask;
2932 int valr = snd_soc_read(codec, mc->rreg) & mask;
2934 ucontrol->value.integer.value[0] = ((val & 0xff)-min) & mask;
2935 ucontrol->value.integer.value[1] = ((valr & 0xff)-min) & mask;
2938 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r_sx);
2941 * snd_soc_put_volsw_2r_sx - double with tlv and variable data size
2942 * mixer put callback
2943 * @kcontrol: mixer control
2944 * @uinfo: control element information
2946 * Returns 0 for success.
2948 int snd_soc_put_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2949 struct snd_ctl_elem_value *ucontrol)
2951 struct soc_mixer_control *mc =
2952 (struct soc_mixer_control *)kcontrol->private_value;
2953 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2954 unsigned int mask = (1<<mc->shift)-1;
2957 unsigned int val, valr, oval, ovalr;
2959 val = ((ucontrol->value.integer.value[0]+min) & 0xff);
2961 valr = ((ucontrol->value.integer.value[1]+min) & 0xff);
2964 oval = snd_soc_read(codec, mc->reg) & mask;
2965 ovalr = snd_soc_read(codec, mc->rreg) & mask;
2969 ret = snd_soc_write(codec, mc->reg, val);
2973 if (ovalr != valr) {
2974 ret = snd_soc_write(codec, mc->rreg, valr);
2981 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r_sx);
2984 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2986 * @clk_id: DAI specific clock ID
2987 * @freq: new clock frequency in Hz
2988 * @dir: new clock direction - input/output.
2990 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2992 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2993 unsigned int freq, int dir)
2995 if (dai->driver && dai->driver->ops->set_sysclk)
2996 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
3000 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
3003 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
3005 * @div_id: DAI specific clock divider ID
3006 * @div: new clock divisor.
3008 * Configures the clock dividers. This is used to derive the best DAI bit and
3009 * frame clocks from the system or master clock. It's best to set the DAI bit
3010 * and frame clocks as low as possible to save system power.
3012 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
3013 int div_id, int div)
3015 if (dai->driver && dai->driver->ops->set_clkdiv)
3016 return dai->driver->ops->set_clkdiv(dai, div_id, div);
3020 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
3023 * snd_soc_dai_set_pll - configure DAI PLL.
3025 * @pll_id: DAI specific PLL ID
3026 * @source: DAI specific source for the PLL
3027 * @freq_in: PLL input clock frequency in Hz
3028 * @freq_out: requested PLL output clock frequency in Hz
3030 * Configures and enables PLL to generate output clock based on input clock.
3032 int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
3033 unsigned int freq_in, unsigned int freq_out)
3035 if (dai->driver && dai->driver->ops->set_pll)
3036 return dai->driver->ops->set_pll(dai, pll_id, source,
3041 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
3044 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
3046 * @fmt: SND_SOC_DAIFMT_ format value.
3048 * Configures the DAI hardware format and clocking.
3050 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
3052 if (dai->driver && dai->driver->ops->set_fmt)
3053 return dai->driver->ops->set_fmt(dai, fmt);
3057 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
3060 * snd_soc_dai_set_tdm_slot - configure DAI TDM.
3062 * @tx_mask: bitmask representing active TX slots.
3063 * @rx_mask: bitmask representing active RX slots.
3064 * @slots: Number of slots in use.
3065 * @slot_width: Width in bits for each slot.
3067 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
3070 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
3071 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
3073 if (dai->driver && dai->driver->ops->set_tdm_slot)
3074 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
3079 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
3082 * snd_soc_dai_set_channel_map - configure DAI audio channel map
3084 * @tx_num: how many TX channels
3085 * @tx_slot: pointer to an array which imply the TX slot number channel
3087 * @rx_num: how many RX channels
3088 * @rx_slot: pointer to an array which imply the RX slot number channel
3091 * configure the relationship between channel number and TDM slot number.
3093 int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
3094 unsigned int tx_num, unsigned int *tx_slot,
3095 unsigned int rx_num, unsigned int *rx_slot)
3097 if (dai->driver && dai->driver->ops->set_channel_map)
3098 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
3103 EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
3106 * snd_soc_dai_set_tristate - configure DAI system or master clock.
3108 * @tristate: tristate enable
3110 * Tristates the DAI so that others can use it.
3112 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
3114 if (dai->driver && dai->driver->ops->set_tristate)
3115 return dai->driver->ops->set_tristate(dai, tristate);
3119 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
3122 * snd_soc_dai_digital_mute - configure DAI system or master clock.
3124 * @mute: mute enable
3126 * Mutes the DAI DAC.
3128 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
3130 if (dai->driver && dai->driver->ops->digital_mute)
3131 return dai->driver->ops->digital_mute(dai, mute);
3135 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
3138 * snd_soc_register_card - Register a card with the ASoC core
3140 * @card: Card to register
3142 * Note that currently this is an internal only function: it will be
3143 * exposed to machine drivers after further backporting of ASoC v2
3144 * registration APIs.
3146 static int snd_soc_register_card(struct snd_soc_card *card)
3150 if (!card->name || !card->dev)
3153 card->rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime) *
3154 (card->num_links + card->num_aux_devs),
3156 if (card->rtd == NULL)
3158 card->rtd_aux = &card->rtd[card->num_links];
3160 for (i = 0; i < card->num_links; i++)
3161 card->rtd[i].dai_link = &card->dai_link[i];
3163 INIT_LIST_HEAD(&card->list);
3164 card->instantiated = 0;
3165 mutex_init(&card->mutex);
3167 mutex_lock(&client_mutex);
3168 list_add(&card->list, &card_list);
3169 snd_soc_instantiate_cards();
3170 mutex_unlock(&client_mutex);
3172 dev_dbg(card->dev, "Registered card '%s'\n", card->name);
3178 * snd_soc_unregister_card - Unregister a card with the ASoC core
3180 * @card: Card to unregister
3182 * Note that currently this is an internal only function: it will be
3183 * exposed to machine drivers after further backporting of ASoC v2
3184 * registration APIs.
3186 static int snd_soc_unregister_card(struct snd_soc_card *card)
3188 mutex_lock(&client_mutex);
3189 list_del(&card->list);
3190 mutex_unlock(&client_mutex);
3191 dev_dbg(card->dev, "Unregistered card '%s'\n", card->name);
3197 * Simplify DAI link configuration by removing ".-1" from device names
3198 * and sanitizing names.
3200 static inline char *fmt_single_name(struct device *dev, int *id)
3202 char *found, name[NAME_SIZE];
3205 if (dev_name(dev) == NULL)
3208 strncpy(name, dev_name(dev), NAME_SIZE);
3210 /* are we a "%s.%d" name (platform and SPI components) */
3211 found = strstr(name, dev->driver->name);
3214 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
3216 /* discard ID from name if ID == -1 */
3218 found[strlen(dev->driver->name)] = '\0';
3222 /* I2C component devices are named "bus-addr" */
3223 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
3224 char tmp[NAME_SIZE];
3226 /* create unique ID number from I2C addr and bus */
3227 *id = ((id1 & 0xffff) << 16) + id2;
3229 /* sanitize component name for DAI link creation */
3230 snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
3231 strncpy(name, tmp, NAME_SIZE);
3236 return kstrdup(name, GFP_KERNEL);
3240 * Simplify DAI link naming for single devices with multiple DAIs by removing
3241 * any ".-1" and using the DAI name (instead of device name).
3243 static inline char *fmt_multiple_name(struct device *dev,
3244 struct snd_soc_dai_driver *dai_drv)
3246 if (dai_drv->name == NULL) {
3247 printk(KERN_ERR "asoc: error - multiple DAI %s registered with no name\n",
3252 return kstrdup(dai_drv->name, GFP_KERNEL);
3256 * snd_soc_register_dai - Register a DAI with the ASoC core
3258 * @dai: DAI to register
3260 int snd_soc_register_dai(struct device *dev,
3261 struct snd_soc_dai_driver *dai_drv)
3263 struct snd_soc_dai *dai;
3265 dev_dbg(dev, "dai register %s\n", dev_name(dev));
3267 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3271 /* create DAI component name */
3272 dai->name = fmt_single_name(dev, &dai->id);
3273 if (dai->name == NULL) {
3279 dai->driver = dai_drv;
3280 if (!dai->driver->ops)
3281 dai->driver->ops = &null_dai_ops;
3283 mutex_lock(&client_mutex);
3284 list_add(&dai->list, &dai_list);
3285 snd_soc_instantiate_cards();
3286 mutex_unlock(&client_mutex);
3288 pr_debug("Registered DAI '%s'\n", dai->name);
3292 EXPORT_SYMBOL_GPL(snd_soc_register_dai);
3295 * snd_soc_unregister_dai - Unregister a DAI from the ASoC core
3297 * @dai: DAI to unregister
3299 void snd_soc_unregister_dai(struct device *dev)
3301 struct snd_soc_dai *dai;
3303 list_for_each_entry(dai, &dai_list, list) {
3304 if (dev == dai->dev)
3310 mutex_lock(&client_mutex);
3311 list_del(&dai->list);
3312 mutex_unlock(&client_mutex);
3314 pr_debug("Unregistered DAI '%s'\n", dai->name);
3318 EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);
3321 * snd_soc_register_dais - Register multiple DAIs with the ASoC core
3323 * @dai: Array of DAIs to register
3324 * @count: Number of DAIs
3326 int snd_soc_register_dais(struct device *dev,
3327 struct snd_soc_dai_driver *dai_drv, size_t count)
3329 struct snd_soc_dai *dai;
3332 dev_dbg(dev, "dai register %s #%Zu\n", dev_name(dev), count);
3334 for (i = 0; i < count; i++) {
3336 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3342 /* create DAI component name */
3343 dai->name = fmt_multiple_name(dev, &dai_drv[i]);
3344 if (dai->name == NULL) {
3351 dai->driver = &dai_drv[i];
3352 if (dai->driver->id)
3353 dai->id = dai->driver->id;
3356 if (!dai->driver->ops)
3357 dai->driver->ops = &null_dai_ops;
3359 mutex_lock(&client_mutex);
3360 list_add(&dai->list, &dai_list);
3361 mutex_unlock(&client_mutex);
3363 pr_debug("Registered DAI '%s'\n", dai->name);
3366 snd_soc_instantiate_cards();
3370 for (i--; i >= 0; i--)
3371 snd_soc_unregister_dai(dev);
3375 EXPORT_SYMBOL_GPL(snd_soc_register_dais);
3378 * snd_soc_unregister_dais - Unregister multiple DAIs from the ASoC core
3380 * @dai: Array of DAIs to unregister
3381 * @count: Number of DAIs
3383 void snd_soc_unregister_dais(struct device *dev, size_t count)
3387 for (i = 0; i < count; i++)
3388 snd_soc_unregister_dai(dev);
3390 EXPORT_SYMBOL_GPL(snd_soc_unregister_dais);
3393 * snd_soc_register_platform - Register a platform with the ASoC core
3395 * @platform: platform to register
3397 int snd_soc_register_platform(struct device *dev,
3398 struct snd_soc_platform_driver *platform_drv)
3400 struct snd_soc_platform *platform;
3402 dev_dbg(dev, "platform register %s\n", dev_name(dev));
3404 platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
3405 if (platform == NULL)
3408 /* create platform component name */
3409 platform->name = fmt_single_name(dev, &platform->id);
3410 if (platform->name == NULL) {
3415 platform->dev = dev;
3416 platform->driver = platform_drv;
3418 mutex_lock(&client_mutex);
3419 list_add(&platform->list, &platform_list);
3420 snd_soc_instantiate_cards();
3421 mutex_unlock(&client_mutex);
3423 pr_debug("Registered platform '%s'\n", platform->name);
3427 EXPORT_SYMBOL_GPL(snd_soc_register_platform);
3430 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
3432 * @platform: platform to unregister
3434 void snd_soc_unregister_platform(struct device *dev)
3436 struct snd_soc_platform *platform;
3438 list_for_each_entry(platform, &platform_list, list) {
3439 if (dev == platform->dev)
3445 mutex_lock(&client_mutex);
3446 list_del(&platform->list);
3447 mutex_unlock(&client_mutex);
3449 pr_debug("Unregistered platform '%s'\n", platform->name);
3450 kfree(platform->name);
3453 EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
3455 static u64 codec_format_map[] = {
3456 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
3457 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
3458 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
3459 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
3460 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
3461 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
3462 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3463 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3464 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
3465 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
3466 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
3467 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
3468 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
3469 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
3470 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
3471 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
3474 /* Fix up the DAI formats for endianness: codecs don't actually see
3475 * the endianness of the data but we're using the CPU format
3476 * definitions which do need to include endianness so we ensure that
3477 * codec DAIs always have both big and little endian variants set.
3479 static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
3483 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
3484 if (stream->formats & codec_format_map[i])
3485 stream->formats |= codec_format_map[i];
3489 * snd_soc_register_codec - Register a codec with the ASoC core
3491 * @codec: codec to register
3493 int snd_soc_register_codec(struct device *dev,
3494 struct snd_soc_codec_driver *codec_drv,
3495 struct snd_soc_dai_driver *dai_drv, int num_dai)
3498 struct snd_soc_codec *codec;
3501 dev_dbg(dev, "codec register %s\n", dev_name(dev));
3503 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
3507 /* create CODEC component name */
3508 codec->name = fmt_single_name(dev, &codec->id);
3509 if (codec->name == NULL) {
3514 if (codec_drv->compress_type)
3515 codec->compress_type = codec_drv->compress_type;
3517 codec->compress_type = SND_SOC_FLAT_COMPRESSION;
3519 INIT_LIST_HEAD(&codec->dapm.widgets);
3520 INIT_LIST_HEAD(&codec->dapm.paths);
3521 codec->write = codec_drv->write;
3522 codec->read = codec_drv->read;
3523 codec->dapm.bias_level = SND_SOC_BIAS_OFF;
3524 codec->dapm.dev = dev;
3525 codec->dapm.codec = codec;
3527 codec->driver = codec_drv;
3528 codec->num_dai = num_dai;
3529 mutex_init(&codec->mutex);
3531 /* allocate CODEC register cache */
3532 if (codec_drv->reg_cache_size && codec_drv->reg_word_size) {
3533 reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
3534 /* it is necessary to make a copy of the default register cache
3535 * because in the case of using a compression type that requires
3536 * the default register cache to be marked as __devinitconst the
3537 * kernel might have freed the array by the time we initialize
3540 codec->reg_def_copy = kmemdup(codec_drv->reg_cache_default,
3541 reg_size, GFP_KERNEL);
3542 if (!codec->reg_def_copy) {
3548 for (i = 0; i < num_dai; i++) {
3549 fixup_codec_formats(&dai_drv[i].playback);
3550 fixup_codec_formats(&dai_drv[i].capture);
3553 /* register any DAIs */
3555 ret = snd_soc_register_dais(dev, dai_drv, num_dai);
3560 mutex_lock(&client_mutex);
3561 list_add(&codec->list, &codec_list);
3562 snd_soc_instantiate_cards();
3563 mutex_unlock(&client_mutex);
3565 pr_debug("Registered codec '%s'\n", codec->name);
3569 kfree(codec->reg_def_copy);
3570 codec->reg_def_copy = NULL;
3575 EXPORT_SYMBOL_GPL(snd_soc_register_codec);
3578 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
3580 * @codec: codec to unregister
3582 void snd_soc_unregister_codec(struct device *dev)
3584 struct snd_soc_codec *codec;
3587 list_for_each_entry(codec, &codec_list, list) {
3588 if (dev == codec->dev)
3595 for (i = 0; i < codec->num_dai; i++)
3596 snd_soc_unregister_dai(dev);
3598 mutex_lock(&client_mutex);
3599 list_del(&codec->list);
3600 mutex_unlock(&client_mutex);
3602 pr_debug("Unregistered codec '%s'\n", codec->name);
3604 snd_soc_cache_exit(codec);
3605 kfree(codec->reg_def_copy);
3609 EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
3611 static int __init snd_soc_init(void)
3613 #ifdef CONFIG_DEBUG_FS
3614 debugfs_root = debugfs_create_dir("asoc", NULL);
3615 if (IS_ERR(debugfs_root) || !debugfs_root) {
3617 "ASoC: Failed to create debugfs directory\n");
3618 debugfs_root = NULL;
3621 if (!debugfs_create_file("codecs", 0444, debugfs_root, NULL,
3623 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
3625 if (!debugfs_create_file("dais", 0444, debugfs_root, NULL,
3627 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
3629 if (!debugfs_create_file("platforms", 0444, debugfs_root, NULL,
3630 &platform_list_fops))
3631 pr_warn("ASoC: Failed to create platform list debugfs file\n");
3634 return platform_driver_register(&soc_driver);
3636 module_init(snd_soc_init);
3638 static void __exit snd_soc_exit(void)
3640 #ifdef CONFIG_DEBUG_FS
3641 debugfs_remove_recursive(debugfs_root);
3643 platform_driver_unregister(&soc_driver);
3645 module_exit(snd_soc_exit);
3647 /* Module information */
3648 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
3649 MODULE_DESCRIPTION("ALSA SoC Core");
3650 MODULE_LICENSE("GPL");
3651 MODULE_ALIAS("platform:soc-audio");