2 * soc-core.c -- ALSA SoC Audio Layer
4 * Copyright 2005 Wolfson Microelectronics PLC.
5 * Copyright 2005 Openedhand Ltd.
7 * Author: Liam Girdwood
8 * liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com
9 * with code, comments and ideas from :-
10 * Richard Purdie <richard@openedhand.com>
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
18 * o Add hw rules to enforce rates, etc.
19 * o More testing with other codecs/machines.
20 * o Add more codecs and platforms to ensure good API coverage.
21 * o Support TDM on PCM and I2S
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/init.h>
27 #include <linux/delay.h>
29 #include <linux/bitops.h>
30 #include <linux/platform_device.h>
31 #include <sound/core.h>
32 #include <sound/pcm.h>
33 #include <sound/pcm_params.h>
34 #include <sound/soc.h>
35 #include <sound/soc-dapm.h>
36 #include <sound/initval.h>
41 #define dbg(format, arg...) printk(format, ## arg)
43 #define dbg(format, arg...)
46 static DEFINE_MUTEX(pcm_mutex);
47 static DEFINE_MUTEX(io_mutex);
48 static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
51 * This is a timeout to do a DAPM powerdown after a stream is closed().
52 * It can be used to eliminate pops between different playback streams, e.g.
53 * between two audio tracks.
55 static int pmdown_time = 5000;
56 module_param(pmdown_time, int, 0);
57 MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
60 * This function forces any delayed work to be queued and run.
62 static int run_delayed_work(struct delayed_work *dwork)
66 /* cancel any work waiting to be queued. */
67 ret = cancel_delayed_work(dwork);
69 /* if there was any work waiting then we run it now and
70 * wait for it's completion */
72 schedule_delayed_work(dwork, 0);
73 flush_scheduled_work();
78 #ifdef CONFIG_SND_SOC_AC97_BUS
79 /* unregister ac97 codec */
80 static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
82 if (codec->ac97->dev.bus)
83 device_unregister(&codec->ac97->dev);
87 /* stop no dev release warning */
88 static void soc_ac97_device_release(struct device *dev){}
90 /* register ac97 codec to bus */
91 static int soc_ac97_dev_register(struct snd_soc_codec *codec)
95 codec->ac97->dev.bus = &ac97_bus_type;
96 codec->ac97->dev.parent = NULL;
97 codec->ac97->dev.release = soc_ac97_device_release;
99 snprintf(codec->ac97->dev.bus_id, BUS_ID_SIZE, "%d-%d:%s",
100 codec->card->number, 0, codec->name);
101 err = device_register(&codec->ac97->dev);
103 snd_printk(KERN_ERR "Can't register ac97 bus\n");
104 codec->ac97->dev.bus = NULL;
111 static inline const char *get_dai_name(int type)
114 case SND_SOC_DAI_AC97_BUS:
115 case SND_SOC_DAI_AC97:
117 case SND_SOC_DAI_I2S:
119 case SND_SOC_DAI_PCM:
126 * Called by ALSA when a PCM substream is opened, the runtime->hw record is
127 * then initialized and any private data can be allocated. This also calls
128 * startup for the cpu DAI, platform, machine and codec DAI.
130 static int soc_pcm_open(struct snd_pcm_substream *substream)
132 struct snd_soc_pcm_runtime *rtd = substream->private_data;
133 struct snd_soc_device *socdev = rtd->socdev;
134 struct snd_pcm_runtime *runtime = substream->runtime;
135 struct snd_soc_dai_link *machine = rtd->dai;
136 struct snd_soc_platform *platform = socdev->platform;
137 struct snd_soc_cpu_dai *cpu_dai = machine->cpu_dai;
138 struct snd_soc_codec_dai *codec_dai = machine->codec_dai;
141 mutex_lock(&pcm_mutex);
143 /* startup the audio subsystem */
144 if (cpu_dai->ops.startup) {
145 ret = cpu_dai->ops.startup(substream);
147 printk(KERN_ERR "asoc: can't open interface %s\n",
153 if (platform->pcm_ops->open) {
154 ret = platform->pcm_ops->open(substream);
156 printk(KERN_ERR "asoc: can't open platform %s\n", platform->name);
161 if (codec_dai->ops.startup) {
162 ret = codec_dai->ops.startup(substream);
164 printk(KERN_ERR "asoc: can't open codec %s\n",
170 if (machine->ops && machine->ops->startup) {
171 ret = machine->ops->startup(substream);
173 printk(KERN_ERR "asoc: %s startup failed\n", machine->name);
178 /* Check that the codec and cpu DAI's are compatible */
179 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
180 runtime->hw.rate_min =
181 max(codec_dai->playback.rate_min,
182 cpu_dai->playback.rate_min);
183 runtime->hw.rate_max =
184 min(codec_dai->playback.rate_max,
185 cpu_dai->playback.rate_max);
186 runtime->hw.channels_min =
187 max(codec_dai->playback.channels_min,
188 cpu_dai->playback.channels_min);
189 runtime->hw.channels_max =
190 min(codec_dai->playback.channels_max,
191 cpu_dai->playback.channels_max);
192 runtime->hw.formats =
193 codec_dai->playback.formats & cpu_dai->playback.formats;
195 codec_dai->playback.rates & cpu_dai->playback.rates;
197 runtime->hw.rate_min =
198 max(codec_dai->capture.rate_min,
199 cpu_dai->capture.rate_min);
200 runtime->hw.rate_max =
201 min(codec_dai->capture.rate_max,
202 cpu_dai->capture.rate_max);
203 runtime->hw.channels_min =
204 max(codec_dai->capture.channels_min,
205 cpu_dai->capture.channels_min);
206 runtime->hw.channels_max =
207 min(codec_dai->capture.channels_max,
208 cpu_dai->capture.channels_max);
209 runtime->hw.formats =
210 codec_dai->capture.formats & cpu_dai->capture.formats;
212 codec_dai->capture.rates & cpu_dai->capture.rates;
215 snd_pcm_limit_hw_rates(runtime);
216 if (!runtime->hw.rates) {
217 printk(KERN_ERR "asoc: %s <-> %s No matching rates\n",
218 codec_dai->name, cpu_dai->name);
221 if (!runtime->hw.formats) {
222 printk(KERN_ERR "asoc: %s <-> %s No matching formats\n",
223 codec_dai->name, cpu_dai->name);
226 if (!runtime->hw.channels_min || !runtime->hw.channels_max) {
227 printk(KERN_ERR "asoc: %s <-> %s No matching channels\n",
228 codec_dai->name, cpu_dai->name);
232 dbg("asoc: %s <-> %s info:\n", codec_dai->name, cpu_dai->name);
233 dbg("asoc: rate mask 0x%x\n", runtime->hw.rates);
234 dbg("asoc: min ch %d max ch %d\n", runtime->hw.channels_min,
235 runtime->hw.channels_max);
236 dbg("asoc: min rate %d max rate %d\n", runtime->hw.rate_min,
237 runtime->hw.rate_max);
239 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
240 cpu_dai->playback.active = codec_dai->playback.active = 1;
242 cpu_dai->capture.active = codec_dai->capture.active = 1;
243 cpu_dai->active = codec_dai->active = 1;
244 cpu_dai->runtime = runtime;
245 socdev->codec->active++;
246 mutex_unlock(&pcm_mutex);
250 if (machine->ops && machine->ops->shutdown)
251 machine->ops->shutdown(substream);
254 if (platform->pcm_ops->close)
255 platform->pcm_ops->close(substream);
258 if (cpu_dai->ops.shutdown)
259 cpu_dai->ops.shutdown(substream);
261 mutex_unlock(&pcm_mutex);
266 * Power down the audio subsystem pmdown_time msecs after close is called.
267 * This is to ensure there are no pops or clicks in between any music tracks
268 * due to DAPM power cycling.
270 static void close_delayed_work(struct work_struct *work)
272 struct snd_soc_device *socdev =
273 container_of(work, struct snd_soc_device, delayed_work.work);
274 struct snd_soc_codec *codec = socdev->codec;
275 struct snd_soc_codec_dai *codec_dai;
278 mutex_lock(&pcm_mutex);
279 for (i = 0; i < codec->num_dai; i++) {
280 codec_dai = &codec->dai[i];
282 dbg("pop wq checking: %s status: %s waiting: %s\n",
283 codec_dai->playback.stream_name,
284 codec_dai->playback.active ? "active" : "inactive",
285 codec_dai->pop_wait ? "yes" : "no");
287 /* are we waiting on this codec DAI stream */
288 if (codec_dai->pop_wait == 1) {
290 /* Reduce power if no longer active */
291 if (codec->active == 0) {
292 dbg("pop wq D1 %s %s\n", codec->name,
293 codec_dai->playback.stream_name);
294 snd_soc_dapm_set_bias_level(socdev,
295 SND_SOC_BIAS_PREPARE);
298 codec_dai->pop_wait = 0;
299 snd_soc_dapm_stream_event(codec,
300 codec_dai->playback.stream_name,
301 SND_SOC_DAPM_STREAM_STOP);
303 /* Fall into standby if no longer active */
304 if (codec->active == 0) {
305 dbg("pop wq D3 %s %s\n", codec->name,
306 codec_dai->playback.stream_name);
307 snd_soc_dapm_set_bias_level(socdev,
308 SND_SOC_BIAS_STANDBY);
312 mutex_unlock(&pcm_mutex);
316 * Called by ALSA when a PCM substream is closed. Private data can be
317 * freed here. The cpu DAI, codec DAI, machine and platform are also
320 static int soc_codec_close(struct snd_pcm_substream *substream)
322 struct snd_soc_pcm_runtime *rtd = substream->private_data;
323 struct snd_soc_device *socdev = rtd->socdev;
324 struct snd_soc_dai_link *machine = rtd->dai;
325 struct snd_soc_platform *platform = socdev->platform;
326 struct snd_soc_cpu_dai *cpu_dai = machine->cpu_dai;
327 struct snd_soc_codec_dai *codec_dai = machine->codec_dai;
328 struct snd_soc_codec *codec = socdev->codec;
330 mutex_lock(&pcm_mutex);
332 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
333 cpu_dai->playback.active = codec_dai->playback.active = 0;
335 cpu_dai->capture.active = codec_dai->capture.active = 0;
337 if (codec_dai->playback.active == 0 &&
338 codec_dai->capture.active == 0) {
339 cpu_dai->active = codec_dai->active = 0;
343 if (cpu_dai->ops.shutdown)
344 cpu_dai->ops.shutdown(substream);
346 if (codec_dai->ops.shutdown)
347 codec_dai->ops.shutdown(substream);
349 if (machine->ops && machine->ops->shutdown)
350 machine->ops->shutdown(substream);
352 if (platform->pcm_ops->close)
353 platform->pcm_ops->close(substream);
354 cpu_dai->runtime = NULL;
356 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
357 /* start delayed pop wq here for playback streams */
358 codec_dai->pop_wait = 1;
359 schedule_delayed_work(&socdev->delayed_work,
360 msecs_to_jiffies(pmdown_time));
362 /* capture streams can be powered down now */
363 snd_soc_dapm_stream_event(codec,
364 codec_dai->capture.stream_name,
365 SND_SOC_DAPM_STREAM_STOP);
367 if (codec->active == 0 && codec_dai->pop_wait == 0)
368 snd_soc_dapm_set_bias_level(socdev,
369 SND_SOC_BIAS_STANDBY);
372 mutex_unlock(&pcm_mutex);
377 * Called by ALSA when the PCM substream is prepared, can set format, sample
378 * rate, etc. This function is non atomic and can be called multiple times,
379 * it can refer to the runtime info.
381 static int soc_pcm_prepare(struct snd_pcm_substream *substream)
383 struct snd_soc_pcm_runtime *rtd = substream->private_data;
384 struct snd_soc_device *socdev = rtd->socdev;
385 struct snd_soc_dai_link *machine = rtd->dai;
386 struct snd_soc_platform *platform = socdev->platform;
387 struct snd_soc_cpu_dai *cpu_dai = machine->cpu_dai;
388 struct snd_soc_codec_dai *codec_dai = machine->codec_dai;
389 struct snd_soc_codec *codec = socdev->codec;
392 mutex_lock(&pcm_mutex);
394 if (machine->ops && machine->ops->prepare) {
395 ret = machine->ops->prepare(substream);
397 printk(KERN_ERR "asoc: machine prepare error\n");
402 if (platform->pcm_ops->prepare) {
403 ret = platform->pcm_ops->prepare(substream);
405 printk(KERN_ERR "asoc: platform prepare error\n");
410 if (codec_dai->ops.prepare) {
411 ret = codec_dai->ops.prepare(substream);
413 printk(KERN_ERR "asoc: codec DAI prepare error\n");
418 if (cpu_dai->ops.prepare) {
419 ret = cpu_dai->ops.prepare(substream);
421 printk(KERN_ERR "asoc: cpu DAI prepare error\n");
426 /* we only want to start a DAPM playback stream if we are not waiting
427 * on an existing one stopping */
428 if (codec_dai->pop_wait) {
429 /* we are waiting for the delayed work to start */
430 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
431 snd_soc_dapm_stream_event(socdev->codec,
432 codec_dai->capture.stream_name,
433 SND_SOC_DAPM_STREAM_START);
435 codec_dai->pop_wait = 0;
436 cancel_delayed_work(&socdev->delayed_work);
437 if (codec_dai->dai_ops.digital_mute)
438 codec_dai->dai_ops.digital_mute(codec_dai, 0);
441 /* no delayed work - do we need to power up codec */
442 if (codec->bias_level != SND_SOC_BIAS_ON) {
444 snd_soc_dapm_set_bias_level(socdev,
445 SND_SOC_BIAS_PREPARE);
447 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
448 snd_soc_dapm_stream_event(codec,
449 codec_dai->playback.stream_name,
450 SND_SOC_DAPM_STREAM_START);
452 snd_soc_dapm_stream_event(codec,
453 codec_dai->capture.stream_name,
454 SND_SOC_DAPM_STREAM_START);
456 snd_soc_dapm_set_bias_level(socdev, SND_SOC_BIAS_ON);
457 if (codec_dai->dai_ops.digital_mute)
458 codec_dai->dai_ops.digital_mute(codec_dai, 0);
461 /* codec already powered - power on widgets */
462 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
463 snd_soc_dapm_stream_event(codec,
464 codec_dai->playback.stream_name,
465 SND_SOC_DAPM_STREAM_START);
467 snd_soc_dapm_stream_event(codec,
468 codec_dai->capture.stream_name,
469 SND_SOC_DAPM_STREAM_START);
470 if (codec_dai->dai_ops.digital_mute)
471 codec_dai->dai_ops.digital_mute(codec_dai, 0);
476 mutex_unlock(&pcm_mutex);
481 * Called by ALSA when the hardware params are set by application. This
482 * function can also be called multiple times and can allocate buffers
483 * (using snd_pcm_lib_* ). It's non-atomic.
485 static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
486 struct snd_pcm_hw_params *params)
488 struct snd_soc_pcm_runtime *rtd = substream->private_data;
489 struct snd_soc_device *socdev = rtd->socdev;
490 struct snd_soc_dai_link *machine = rtd->dai;
491 struct snd_soc_platform *platform = socdev->platform;
492 struct snd_soc_cpu_dai *cpu_dai = machine->cpu_dai;
493 struct snd_soc_codec_dai *codec_dai = machine->codec_dai;
496 mutex_lock(&pcm_mutex);
498 if (machine->ops && machine->ops->hw_params) {
499 ret = machine->ops->hw_params(substream, params);
501 printk(KERN_ERR "asoc: machine hw_params failed\n");
506 if (codec_dai->ops.hw_params) {
507 ret = codec_dai->ops.hw_params(substream, params);
509 printk(KERN_ERR "asoc: can't set codec %s hw params\n",
515 if (cpu_dai->ops.hw_params) {
516 ret = cpu_dai->ops.hw_params(substream, params);
518 printk(KERN_ERR "asoc: interface %s hw params failed\n",
524 if (platform->pcm_ops->hw_params) {
525 ret = platform->pcm_ops->hw_params(substream, params);
527 printk(KERN_ERR "asoc: platform %s hw params failed\n",
534 mutex_unlock(&pcm_mutex);
538 if (cpu_dai->ops.hw_free)
539 cpu_dai->ops.hw_free(substream);
542 if (codec_dai->ops.hw_free)
543 codec_dai->ops.hw_free(substream);
546 if (machine->ops && machine->ops->hw_free)
547 machine->ops->hw_free(substream);
549 mutex_unlock(&pcm_mutex);
554 * Free's resources allocated by hw_params, can be called multiple times
556 static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
558 struct snd_soc_pcm_runtime *rtd = substream->private_data;
559 struct snd_soc_device *socdev = rtd->socdev;
560 struct snd_soc_dai_link *machine = rtd->dai;
561 struct snd_soc_platform *platform = socdev->platform;
562 struct snd_soc_cpu_dai *cpu_dai = machine->cpu_dai;
563 struct snd_soc_codec_dai *codec_dai = machine->codec_dai;
564 struct snd_soc_codec *codec = socdev->codec;
566 mutex_lock(&pcm_mutex);
568 /* apply codec digital mute */
569 if (!codec->active && codec_dai->dai_ops.digital_mute)
570 codec_dai->dai_ops.digital_mute(codec_dai, 1);
572 /* free any machine hw params */
573 if (machine->ops && machine->ops->hw_free)
574 machine->ops->hw_free(substream);
576 /* free any DMA resources */
577 if (platform->pcm_ops->hw_free)
578 platform->pcm_ops->hw_free(substream);
580 /* now free hw params for the DAI's */
581 if (codec_dai->ops.hw_free)
582 codec_dai->ops.hw_free(substream);
584 if (cpu_dai->ops.hw_free)
585 cpu_dai->ops.hw_free(substream);
587 mutex_unlock(&pcm_mutex);
591 static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
593 struct snd_soc_pcm_runtime *rtd = substream->private_data;
594 struct snd_soc_device *socdev = rtd->socdev;
595 struct snd_soc_dai_link *machine = rtd->dai;
596 struct snd_soc_platform *platform = socdev->platform;
597 struct snd_soc_cpu_dai *cpu_dai = machine->cpu_dai;
598 struct snd_soc_codec_dai *codec_dai = machine->codec_dai;
601 if (codec_dai->ops.trigger) {
602 ret = codec_dai->ops.trigger(substream, cmd);
607 if (platform->pcm_ops->trigger) {
608 ret = platform->pcm_ops->trigger(substream, cmd);
613 if (cpu_dai->ops.trigger) {
614 ret = cpu_dai->ops.trigger(substream, cmd);
621 /* ASoC PCM operations */
622 static struct snd_pcm_ops soc_pcm_ops = {
623 .open = soc_pcm_open,
624 .close = soc_codec_close,
625 .hw_params = soc_pcm_hw_params,
626 .hw_free = soc_pcm_hw_free,
627 .prepare = soc_pcm_prepare,
628 .trigger = soc_pcm_trigger,
632 /* powers down audio subsystem for suspend */
633 static int soc_suspend(struct platform_device *pdev, pm_message_t state)
635 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
636 struct snd_soc_machine *machine = socdev->machine;
637 struct snd_soc_platform *platform = socdev->platform;
638 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
639 struct snd_soc_codec *codec = socdev->codec;
642 /* Due to the resume being scheduled into a workqueue we could
643 * suspend before that's finished - wait for it to complete.
645 snd_power_lock(codec->card);
646 snd_power_wait(codec->card, SNDRV_CTL_POWER_D0);
647 snd_power_unlock(codec->card);
649 /* we're going to block userspace touching us until resume completes */
650 snd_power_change_state(codec->card, SNDRV_CTL_POWER_D3hot);
652 /* mute any active DAC's */
653 for (i = 0; i < machine->num_links; i++) {
654 struct snd_soc_codec_dai *dai = machine->dai_link[i].codec_dai;
655 if (dai->dai_ops.digital_mute && dai->playback.active)
656 dai->dai_ops.digital_mute(dai, 1);
659 /* suspend all pcms */
660 for (i = 0; i < machine->num_links; i++)
661 snd_pcm_suspend_all(machine->dai_link[i].pcm);
663 if (machine->suspend_pre)
664 machine->suspend_pre(pdev, state);
666 for (i = 0; i < machine->num_links; i++) {
667 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
668 if (cpu_dai->suspend && cpu_dai->type != SND_SOC_DAI_AC97)
669 cpu_dai->suspend(pdev, cpu_dai);
670 if (platform->suspend)
671 platform->suspend(pdev, cpu_dai);
674 /* close any waiting streams and save state */
675 run_delayed_work(&socdev->delayed_work);
676 codec->suspend_bias_level = codec->bias_level;
678 for (i = 0; i < codec->num_dai; i++) {
679 char *stream = codec->dai[i].playback.stream_name;
681 snd_soc_dapm_stream_event(codec, stream,
682 SND_SOC_DAPM_STREAM_SUSPEND);
683 stream = codec->dai[i].capture.stream_name;
685 snd_soc_dapm_stream_event(codec, stream,
686 SND_SOC_DAPM_STREAM_SUSPEND);
689 if (codec_dev->suspend)
690 codec_dev->suspend(pdev, state);
692 for (i = 0; i < machine->num_links; i++) {
693 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
694 if (cpu_dai->suspend && cpu_dai->type == SND_SOC_DAI_AC97)
695 cpu_dai->suspend(pdev, cpu_dai);
698 if (machine->suspend_post)
699 machine->suspend_post(pdev, state);
704 /* deferred resume work, so resume can complete before we finished
705 * setting our codec back up, which can be very slow on I2C
707 static void soc_resume_deferred(struct work_struct *work)
709 struct snd_soc_device *socdev = container_of(work,
710 struct snd_soc_device,
711 deferred_resume_work);
712 struct snd_soc_machine *machine = socdev->machine;
713 struct snd_soc_platform *platform = socdev->platform;
714 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
715 struct snd_soc_codec *codec = socdev->codec;
716 struct platform_device *pdev = to_platform_device(socdev->dev);
719 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
720 * so userspace apps are blocked from touching us
723 dev_info(socdev->dev, "starting resume work\n");
725 if (machine->resume_pre)
726 machine->resume_pre(pdev);
728 for (i = 0; i < machine->num_links; i++) {
729 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
730 if (cpu_dai->resume && cpu_dai->type == SND_SOC_DAI_AC97)
731 cpu_dai->resume(pdev, cpu_dai);
734 if (codec_dev->resume)
735 codec_dev->resume(pdev);
737 for (i = 0; i < codec->num_dai; i++) {
738 char *stream = codec->dai[i].playback.stream_name;
740 snd_soc_dapm_stream_event(codec, stream,
741 SND_SOC_DAPM_STREAM_RESUME);
742 stream = codec->dai[i].capture.stream_name;
744 snd_soc_dapm_stream_event(codec, stream,
745 SND_SOC_DAPM_STREAM_RESUME);
748 /* unmute any active DACs */
749 for (i = 0; i < machine->num_links; i++) {
750 struct snd_soc_codec_dai *dai = machine->dai_link[i].codec_dai;
751 if (dai->dai_ops.digital_mute && dai->playback.active)
752 dai->dai_ops.digital_mute(dai, 0);
755 for (i = 0; i < machine->num_links; i++) {
756 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
757 if (cpu_dai->resume && cpu_dai->type != SND_SOC_DAI_AC97)
758 cpu_dai->resume(pdev, cpu_dai);
759 if (platform->resume)
760 platform->resume(pdev, cpu_dai);
763 if (machine->resume_post)
764 machine->resume_post(pdev);
766 dev_info(socdev->dev, "resume work completed\n");
768 /* userspace can access us now we are back as we were before */
769 snd_power_change_state(codec->card, SNDRV_CTL_POWER_D0);
772 /* powers up audio subsystem after a suspend */
773 static int soc_resume(struct platform_device *pdev)
775 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
777 dev_info(socdev->dev, "scheduling resume work\n");
779 if (!schedule_work(&socdev->deferred_resume_work))
780 dev_err(socdev->dev, "work item may be lost\n");
786 #define soc_suspend NULL
787 #define soc_resume NULL
790 /* probes a new socdev */
791 static int soc_probe(struct platform_device *pdev)
794 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
795 struct snd_soc_machine *machine = socdev->machine;
796 struct snd_soc_platform *platform = socdev->platform;
797 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
799 if (machine->probe) {
800 ret = machine->probe(pdev);
805 for (i = 0; i < machine->num_links; i++) {
806 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
807 if (cpu_dai->probe) {
808 ret = cpu_dai->probe(pdev, cpu_dai);
814 if (codec_dev->probe) {
815 ret = codec_dev->probe(pdev);
820 if (platform->probe) {
821 ret = platform->probe(pdev);
826 /* DAPM stream work */
827 INIT_DELAYED_WORK(&socdev->delayed_work, close_delayed_work);
828 /* deferred resume work */
829 INIT_WORK(&socdev->deferred_resume_work, soc_resume_deferred);
834 if (codec_dev->remove)
835 codec_dev->remove(pdev);
838 for (i--; i >= 0; i--) {
839 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
841 cpu_dai->remove(pdev, cpu_dai);
845 machine->remove(pdev);
850 /* removes a socdev */
851 static int soc_remove(struct platform_device *pdev)
854 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
855 struct snd_soc_machine *machine = socdev->machine;
856 struct snd_soc_platform *platform = socdev->platform;
857 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
859 run_delayed_work(&socdev->delayed_work);
861 if (platform->remove)
862 platform->remove(pdev);
864 if (codec_dev->remove)
865 codec_dev->remove(pdev);
867 for (i = 0; i < machine->num_links; i++) {
868 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
870 cpu_dai->remove(pdev, cpu_dai);
874 machine->remove(pdev);
879 /* ASoC platform driver */
880 static struct platform_driver soc_driver = {
883 .owner = THIS_MODULE,
886 .remove = soc_remove,
887 .suspend = soc_suspend,
888 .resume = soc_resume,
891 /* create a new pcm */
892 static int soc_new_pcm(struct snd_soc_device *socdev,
893 struct snd_soc_dai_link *dai_link, int num)
895 struct snd_soc_codec *codec = socdev->codec;
896 struct snd_soc_codec_dai *codec_dai = dai_link->codec_dai;
897 struct snd_soc_cpu_dai *cpu_dai = dai_link->cpu_dai;
898 struct snd_soc_pcm_runtime *rtd;
901 int ret = 0, playback = 0, capture = 0;
903 rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
908 rtd->socdev = socdev;
909 codec_dai->codec = socdev->codec;
911 /* check client and interface hw capabilities */
912 sprintf(new_name, "%s %s-%s-%d", dai_link->stream_name, codec_dai->name,
913 get_dai_name(cpu_dai->type), num);
915 if (codec_dai->playback.channels_min)
917 if (codec_dai->capture.channels_min)
920 ret = snd_pcm_new(codec->card, new_name, codec->pcm_devs++, playback,
923 printk(KERN_ERR "asoc: can't create pcm for codec %s\n",
930 pcm->private_data = rtd;
931 soc_pcm_ops.mmap = socdev->platform->pcm_ops->mmap;
932 soc_pcm_ops.pointer = socdev->platform->pcm_ops->pointer;
933 soc_pcm_ops.ioctl = socdev->platform->pcm_ops->ioctl;
934 soc_pcm_ops.copy = socdev->platform->pcm_ops->copy;
935 soc_pcm_ops.silence = socdev->platform->pcm_ops->silence;
936 soc_pcm_ops.ack = socdev->platform->pcm_ops->ack;
937 soc_pcm_ops.page = socdev->platform->pcm_ops->page;
940 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops);
943 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops);
945 ret = socdev->platform->pcm_new(codec->card, codec_dai, pcm);
947 printk(KERN_ERR "asoc: platform pcm constructor failed\n");
952 pcm->private_free = socdev->platform->pcm_free;
953 printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name,
958 /* codec register dump */
959 static ssize_t codec_reg_show(struct device *dev,
960 struct device_attribute *attr, char *buf)
962 struct snd_soc_device *devdata = dev_get_drvdata(dev);
963 struct snd_soc_codec *codec = devdata->codec;
964 int i, step = 1, count = 0;
966 if (!codec->reg_cache_size)
969 if (codec->reg_cache_step)
970 step = codec->reg_cache_step;
972 count += sprintf(buf, "%s registers\n", codec->name);
973 for (i = 0; i < codec->reg_cache_size; i += step)
974 count += sprintf(buf + count, "%2x: %4x\n", i,
975 codec->read(codec, i));
979 static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
982 * snd_soc_new_ac97_codec - initailise AC97 device
983 * @codec: audio codec
984 * @ops: AC97 bus operations
985 * @num: AC97 codec number
987 * Initialises AC97 codec resources for use by ad-hoc devices only.
989 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
990 struct snd_ac97_bus_ops *ops, int num)
992 mutex_lock(&codec->mutex);
994 codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
995 if (codec->ac97 == NULL) {
996 mutex_unlock(&codec->mutex);
1000 codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
1001 if (codec->ac97->bus == NULL) {
1004 mutex_unlock(&codec->mutex);
1008 codec->ac97->bus->ops = ops;
1009 codec->ac97->num = num;
1010 mutex_unlock(&codec->mutex);
1013 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
1016 * snd_soc_free_ac97_codec - free AC97 codec device
1017 * @codec: audio codec
1019 * Frees AC97 codec device resources.
1021 void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
1023 mutex_lock(&codec->mutex);
1024 kfree(codec->ac97->bus);
1027 mutex_unlock(&codec->mutex);
1029 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
1032 * snd_soc_update_bits - update codec register bits
1033 * @codec: audio codec
1034 * @reg: codec register
1035 * @mask: register mask
1038 * Writes new register value.
1040 * Returns 1 for change else 0.
1042 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
1043 unsigned short mask, unsigned short value)
1046 unsigned short old, new;
1048 mutex_lock(&io_mutex);
1049 old = snd_soc_read(codec, reg);
1050 new = (old & ~mask) | value;
1051 change = old != new;
1053 snd_soc_write(codec, reg, new);
1055 mutex_unlock(&io_mutex);
1058 EXPORT_SYMBOL_GPL(snd_soc_update_bits);
1061 * snd_soc_test_bits - test register for change
1062 * @codec: audio codec
1063 * @reg: codec register
1064 * @mask: register mask
1067 * Tests a register with a new value and checks if the new value is
1068 * different from the old value.
1070 * Returns 1 for change else 0.
1072 int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
1073 unsigned short mask, unsigned short value)
1076 unsigned short old, new;
1078 mutex_lock(&io_mutex);
1079 old = snd_soc_read(codec, reg);
1080 new = (old & ~mask) | value;
1081 change = old != new;
1082 mutex_unlock(&io_mutex);
1086 EXPORT_SYMBOL_GPL(snd_soc_test_bits);
1089 * snd_soc_new_pcms - create new sound card and pcms
1090 * @socdev: the SoC audio device
1092 * Create a new sound card based upon the codec and interface pcms.
1094 * Returns 0 for success, else error.
1096 int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid)
1098 struct snd_soc_codec *codec = socdev->codec;
1099 struct snd_soc_machine *machine = socdev->machine;
1102 mutex_lock(&codec->mutex);
1104 /* register a sound card */
1105 codec->card = snd_card_new(idx, xid, codec->owner, 0);
1107 printk(KERN_ERR "asoc: can't create sound card for codec %s\n",
1109 mutex_unlock(&codec->mutex);
1113 codec->card->dev = socdev->dev;
1114 codec->card->private_data = codec;
1115 strncpy(codec->card->driver, codec->name, sizeof(codec->card->driver));
1117 /* create the pcms */
1118 for (i = 0; i < machine->num_links; i++) {
1119 ret = soc_new_pcm(socdev, &machine->dai_link[i], i);
1121 printk(KERN_ERR "asoc: can't create pcm %s\n",
1122 machine->dai_link[i].stream_name);
1123 mutex_unlock(&codec->mutex);
1128 mutex_unlock(&codec->mutex);
1131 EXPORT_SYMBOL_GPL(snd_soc_new_pcms);
1134 * snd_soc_register_card - register sound card
1135 * @socdev: the SoC audio device
1137 * Register a SoC sound card. Also registers an AC97 device if the
1138 * codec is AC97 for ad hoc devices.
1140 * Returns 0 for success, else error.
1142 int snd_soc_register_card(struct snd_soc_device *socdev)
1144 struct snd_soc_codec *codec = socdev->codec;
1145 struct snd_soc_machine *machine = socdev->machine;
1146 int ret = 0, i, ac97 = 0, err = 0;
1148 for (i = 0; i < machine->num_links; i++) {
1149 if (socdev->machine->dai_link[i].init) {
1150 err = socdev->machine->dai_link[i].init(codec);
1152 printk(KERN_ERR "asoc: failed to init %s\n",
1153 socdev->machine->dai_link[i].stream_name);
1157 if (socdev->machine->dai_link[i].codec_dai->type ==
1158 SND_SOC_DAI_AC97_BUS)
1161 snprintf(codec->card->shortname, sizeof(codec->card->shortname),
1162 "%s", machine->name);
1163 snprintf(codec->card->longname, sizeof(codec->card->longname),
1164 "%s (%s)", machine->name, codec->name);
1166 ret = snd_card_register(codec->card);
1168 printk(KERN_ERR "asoc: failed to register soundcard for %s\n",
1173 mutex_lock(&codec->mutex);
1174 #ifdef CONFIG_SND_SOC_AC97_BUS
1176 ret = soc_ac97_dev_register(codec);
1178 printk(KERN_ERR "asoc: AC97 device register failed\n");
1179 snd_card_free(codec->card);
1180 mutex_unlock(&codec->mutex);
1186 err = snd_soc_dapm_sys_add(socdev->dev);
1188 printk(KERN_WARNING "asoc: failed to add dapm sysfs entries\n");
1190 err = device_create_file(socdev->dev, &dev_attr_codec_reg);
1192 printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");
1194 mutex_unlock(&codec->mutex);
1199 EXPORT_SYMBOL_GPL(snd_soc_register_card);
1202 * snd_soc_free_pcms - free sound card and pcms
1203 * @socdev: the SoC audio device
1205 * Frees sound card and pcms associated with the socdev.
1206 * Also unregister the codec if it is an AC97 device.
1208 void snd_soc_free_pcms(struct snd_soc_device *socdev)
1210 struct snd_soc_codec *codec = socdev->codec;
1211 #ifdef CONFIG_SND_SOC_AC97_BUS
1212 struct snd_soc_codec_dai *codec_dai;
1216 mutex_lock(&codec->mutex);
1217 #ifdef CONFIG_SND_SOC_AC97_BUS
1218 for (i = 0; i < codec->num_dai; i++) {
1219 codec_dai = &codec->dai[i];
1220 if (codec_dai->type == SND_SOC_DAI_AC97_BUS && codec->ac97) {
1221 soc_ac97_dev_unregister(codec);
1229 snd_card_free(codec->card);
1230 device_remove_file(socdev->dev, &dev_attr_codec_reg);
1231 mutex_unlock(&codec->mutex);
1233 EXPORT_SYMBOL_GPL(snd_soc_free_pcms);
1236 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
1237 * @substream: the pcm substream
1238 * @hw: the hardware parameters
1240 * Sets the substream runtime hardware parameters.
1242 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
1243 const struct snd_pcm_hardware *hw)
1245 struct snd_pcm_runtime *runtime = substream->runtime;
1246 runtime->hw.info = hw->info;
1247 runtime->hw.formats = hw->formats;
1248 runtime->hw.period_bytes_min = hw->period_bytes_min;
1249 runtime->hw.period_bytes_max = hw->period_bytes_max;
1250 runtime->hw.periods_min = hw->periods_min;
1251 runtime->hw.periods_max = hw->periods_max;
1252 runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
1253 runtime->hw.fifo_size = hw->fifo_size;
1256 EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
1259 * snd_soc_cnew - create new control
1260 * @_template: control template
1261 * @data: control private data
1262 * @lnng_name: control long name
1264 * Create a new mixer control from a template control.
1266 * Returns 0 for success, else error.
1268 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
1269 void *data, char *long_name)
1271 struct snd_kcontrol_new template;
1273 memcpy(&template, _template, sizeof(template));
1275 template.name = long_name;
1278 return snd_ctl_new1(&template, data);
1280 EXPORT_SYMBOL_GPL(snd_soc_cnew);
1283 * snd_soc_info_enum_double - enumerated double mixer info callback
1284 * @kcontrol: mixer control
1285 * @uinfo: control element information
1287 * Callback to provide information about a double enumerated
1290 * Returns 0 for success.
1292 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
1293 struct snd_ctl_elem_info *uinfo)
1295 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1297 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1298 uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
1299 uinfo->value.enumerated.items = e->mask;
1301 if (uinfo->value.enumerated.item > e->mask - 1)
1302 uinfo->value.enumerated.item = e->mask - 1;
1303 strcpy(uinfo->value.enumerated.name,
1304 e->texts[uinfo->value.enumerated.item]);
1307 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
1310 * snd_soc_get_enum_double - enumerated double mixer get callback
1311 * @kcontrol: mixer control
1312 * @uinfo: control element information
1314 * Callback to get the value of a double enumerated mixer.
1316 * Returns 0 for success.
1318 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
1319 struct snd_ctl_elem_value *ucontrol)
1321 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1322 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1323 unsigned short val, bitmask;
1325 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1327 val = snd_soc_read(codec, e->reg);
1328 ucontrol->value.enumerated.item[0]
1329 = (val >> e->shift_l) & (bitmask - 1);
1330 if (e->shift_l != e->shift_r)
1331 ucontrol->value.enumerated.item[1] =
1332 (val >> e->shift_r) & (bitmask - 1);
1336 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
1339 * snd_soc_put_enum_double - enumerated double mixer put callback
1340 * @kcontrol: mixer control
1341 * @uinfo: control element information
1343 * Callback to set the value of a double enumerated mixer.
1345 * Returns 0 for success.
1347 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
1348 struct snd_ctl_elem_value *ucontrol)
1350 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1351 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1353 unsigned short mask, bitmask;
1355 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1357 if (ucontrol->value.enumerated.item[0] > e->mask - 1)
1359 val = ucontrol->value.enumerated.item[0] << e->shift_l;
1360 mask = (bitmask - 1) << e->shift_l;
1361 if (e->shift_l != e->shift_r) {
1362 if (ucontrol->value.enumerated.item[1] > e->mask - 1)
1364 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1365 mask |= (bitmask - 1) << e->shift_r;
1368 return snd_soc_update_bits(codec, e->reg, mask, val);
1370 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
1373 * snd_soc_info_enum_ext - external enumerated single mixer info callback
1374 * @kcontrol: mixer control
1375 * @uinfo: control element information
1377 * Callback to provide information about an external enumerated
1380 * Returns 0 for success.
1382 int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
1383 struct snd_ctl_elem_info *uinfo)
1385 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1387 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1389 uinfo->value.enumerated.items = e->mask;
1391 if (uinfo->value.enumerated.item > e->mask - 1)
1392 uinfo->value.enumerated.item = e->mask - 1;
1393 strcpy(uinfo->value.enumerated.name,
1394 e->texts[uinfo->value.enumerated.item]);
1397 EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
1400 * snd_soc_info_volsw_ext - external single mixer info callback
1401 * @kcontrol: mixer control
1402 * @uinfo: control element information
1404 * Callback to provide information about a single external mixer control.
1406 * Returns 0 for success.
1408 int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
1409 struct snd_ctl_elem_info *uinfo)
1411 int max = kcontrol->private_value;
1414 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1416 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1419 uinfo->value.integer.min = 0;
1420 uinfo->value.integer.max = max;
1423 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
1426 * snd_soc_info_volsw - single mixer info callback
1427 * @kcontrol: mixer control
1428 * @uinfo: control element information
1430 * Callback to provide information about a single mixer control.
1432 * Returns 0 for success.
1434 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
1435 struct snd_ctl_elem_info *uinfo)
1437 int max = (kcontrol->private_value >> 16) & 0xff;
1438 int shift = (kcontrol->private_value >> 8) & 0x0f;
1439 int rshift = (kcontrol->private_value >> 12) & 0x0f;
1442 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1444 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1446 uinfo->count = shift == rshift ? 1 : 2;
1447 uinfo->value.integer.min = 0;
1448 uinfo->value.integer.max = max;
1451 EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
1454 * snd_soc_get_volsw - single mixer get callback
1455 * @kcontrol: mixer control
1456 * @uinfo: control element information
1458 * Callback to get the value of a single mixer control.
1460 * Returns 0 for success.
1462 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
1463 struct snd_ctl_elem_value *ucontrol)
1465 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1466 int reg = kcontrol->private_value & 0xff;
1467 int shift = (kcontrol->private_value >> 8) & 0x0f;
1468 int rshift = (kcontrol->private_value >> 12) & 0x0f;
1469 int max = (kcontrol->private_value >> 16) & 0xff;
1470 int mask = (1 << fls(max)) - 1;
1471 int invert = (kcontrol->private_value >> 24) & 0x01;
1473 ucontrol->value.integer.value[0] =
1474 (snd_soc_read(codec, reg) >> shift) & mask;
1475 if (shift != rshift)
1476 ucontrol->value.integer.value[1] =
1477 (snd_soc_read(codec, reg) >> rshift) & mask;
1479 ucontrol->value.integer.value[0] =
1480 max - ucontrol->value.integer.value[0];
1481 if (shift != rshift)
1482 ucontrol->value.integer.value[1] =
1483 max - ucontrol->value.integer.value[1];
1488 EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
1491 * snd_soc_put_volsw - single mixer put callback
1492 * @kcontrol: mixer control
1493 * @uinfo: control element information
1495 * Callback to set the value of a single mixer control.
1497 * Returns 0 for success.
1499 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
1500 struct snd_ctl_elem_value *ucontrol)
1502 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1503 int reg = kcontrol->private_value & 0xff;
1504 int shift = (kcontrol->private_value >> 8) & 0x0f;
1505 int rshift = (kcontrol->private_value >> 12) & 0x0f;
1506 int max = (kcontrol->private_value >> 16) & 0xff;
1507 int mask = (1 << fls(max)) - 1;
1508 int invert = (kcontrol->private_value >> 24) & 0x01;
1509 unsigned short val, val2, val_mask;
1511 val = (ucontrol->value.integer.value[0] & mask);
1514 val_mask = mask << shift;
1516 if (shift != rshift) {
1517 val2 = (ucontrol->value.integer.value[1] & mask);
1520 val_mask |= mask << rshift;
1521 val |= val2 << rshift;
1523 return snd_soc_update_bits(codec, reg, val_mask, val);
1525 EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
1528 * snd_soc_info_volsw_2r - double mixer info callback
1529 * @kcontrol: mixer control
1530 * @uinfo: control element information
1532 * Callback to provide information about a double mixer control that
1533 * spans 2 codec registers.
1535 * Returns 0 for success.
1537 int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
1538 struct snd_ctl_elem_info *uinfo)
1540 int max = (kcontrol->private_value >> 12) & 0xff;
1543 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1545 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1548 uinfo->value.integer.min = 0;
1549 uinfo->value.integer.max = max;
1552 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
1555 * snd_soc_get_volsw_2r - double mixer get callback
1556 * @kcontrol: mixer control
1557 * @uinfo: control element information
1559 * Callback to get the value of a double mixer control that spans 2 registers.
1561 * Returns 0 for success.
1563 int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
1564 struct snd_ctl_elem_value *ucontrol)
1566 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1567 int reg = kcontrol->private_value & 0xff;
1568 int reg2 = (kcontrol->private_value >> 24) & 0xff;
1569 int shift = (kcontrol->private_value >> 8) & 0x0f;
1570 int max = (kcontrol->private_value >> 12) & 0xff;
1571 int mask = (1<<fls(max))-1;
1572 int invert = (kcontrol->private_value >> 20) & 0x01;
1574 ucontrol->value.integer.value[0] =
1575 (snd_soc_read(codec, reg) >> shift) & mask;
1576 ucontrol->value.integer.value[1] =
1577 (snd_soc_read(codec, reg2) >> shift) & mask;
1579 ucontrol->value.integer.value[0] =
1580 max - ucontrol->value.integer.value[0];
1581 ucontrol->value.integer.value[1] =
1582 max - ucontrol->value.integer.value[1];
1587 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r);
1590 * snd_soc_put_volsw_2r - double mixer set callback
1591 * @kcontrol: mixer control
1592 * @uinfo: control element information
1594 * Callback to set the value of a double mixer control that spans 2 registers.
1596 * Returns 0 for success.
1598 int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
1599 struct snd_ctl_elem_value *ucontrol)
1601 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1602 int reg = kcontrol->private_value & 0xff;
1603 int reg2 = (kcontrol->private_value >> 24) & 0xff;
1604 int shift = (kcontrol->private_value >> 8) & 0x0f;
1605 int max = (kcontrol->private_value >> 12) & 0xff;
1606 int mask = (1 << fls(max)) - 1;
1607 int invert = (kcontrol->private_value >> 20) & 0x01;
1609 unsigned short val, val2, val_mask;
1611 val_mask = mask << shift;
1612 val = (ucontrol->value.integer.value[0] & mask);
1613 val2 = (ucontrol->value.integer.value[1] & mask);
1621 val2 = val2 << shift;
1623 err = snd_soc_update_bits(codec, reg, val_mask, val);
1627 err = snd_soc_update_bits(codec, reg2, val_mask, val2);
1630 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
1633 * snd_soc_info_volsw_s8 - signed mixer info callback
1634 * @kcontrol: mixer control
1635 * @uinfo: control element information
1637 * Callback to provide information about a signed mixer control.
1639 * Returns 0 for success.
1641 int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
1642 struct snd_ctl_elem_info *uinfo)
1644 int max = (signed char)((kcontrol->private_value >> 16) & 0xff);
1645 int min = (signed char)((kcontrol->private_value >> 24) & 0xff);
1647 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1649 uinfo->value.integer.min = 0;
1650 uinfo->value.integer.max = max-min;
1653 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
1656 * snd_soc_get_volsw_s8 - signed mixer get callback
1657 * @kcontrol: mixer control
1658 * @uinfo: control element information
1660 * Callback to get the value of a signed mixer control.
1662 * Returns 0 for success.
1664 int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
1665 struct snd_ctl_elem_value *ucontrol)
1667 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1668 int reg = kcontrol->private_value & 0xff;
1669 int min = (signed char)((kcontrol->private_value >> 24) & 0xff);
1670 int val = snd_soc_read(codec, reg);
1672 ucontrol->value.integer.value[0] =
1673 ((signed char)(val & 0xff))-min;
1674 ucontrol->value.integer.value[1] =
1675 ((signed char)((val >> 8) & 0xff))-min;
1678 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
1681 * snd_soc_put_volsw_sgn - signed mixer put callback
1682 * @kcontrol: mixer control
1683 * @uinfo: control element information
1685 * Callback to set the value of a signed mixer control.
1687 * Returns 0 for success.
1689 int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
1690 struct snd_ctl_elem_value *ucontrol)
1692 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1693 int reg = kcontrol->private_value & 0xff;
1694 int min = (signed char)((kcontrol->private_value >> 24) & 0xff);
1697 val = (ucontrol->value.integer.value[0]+min) & 0xff;
1698 val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
1700 return snd_soc_update_bits(codec, reg, 0xffff, val);
1702 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
1704 static int __devinit snd_soc_init(void)
1706 printk(KERN_INFO "ASoC version %s\n", SND_SOC_VERSION);
1707 return platform_driver_register(&soc_driver);
1710 static void snd_soc_exit(void)
1712 platform_driver_unregister(&soc_driver);
1715 module_init(snd_soc_init);
1716 module_exit(snd_soc_exit);
1718 /* Module information */
1719 MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com");
1720 MODULE_DESCRIPTION("ALSA SoC Core");
1721 MODULE_LICENSE("GPL");
1722 MODULE_ALIAS("platform:soc-audio");