2 * soc-core.c -- ALSA SoC Audio Layer
4 * Copyright 2005 Wolfson Microelectronics PLC.
5 * Copyright 2005 Openedhand Ltd.
7 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
8 * with code, comments and ideas from :-
9 * Richard Purdie <richard@openedhand.com>
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
17 * o Add hw rules to enforce rates, etc.
18 * o More testing with other codecs/machines.
19 * o Add more codecs and platforms to ensure good API coverage.
20 * o Support TDM on PCM and I2S
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
28 #include <linux/bitops.h>
29 #include <linux/debugfs.h>
30 #include <linux/platform_device.h>
31 #include <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_dai *cpu_dai = machine->cpu_dai;
138 struct snd_soc_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_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_dai *cpu_dai = machine->cpu_dai;
327 struct snd_soc_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 /* Muting the DAC suppresses artifacts caused during digital
344 * shutdown, for example from stopping clocks.
346 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
347 snd_soc_dai_digital_mute(codec_dai, 1);
349 if (cpu_dai->ops.shutdown)
350 cpu_dai->ops.shutdown(substream);
352 if (codec_dai->ops.shutdown)
353 codec_dai->ops.shutdown(substream);
355 if (machine->ops && machine->ops->shutdown)
356 machine->ops->shutdown(substream);
358 if (platform->pcm_ops->close)
359 platform->pcm_ops->close(substream);
360 cpu_dai->runtime = NULL;
362 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
363 /* start delayed pop wq here for playback streams */
364 codec_dai->pop_wait = 1;
365 schedule_delayed_work(&socdev->delayed_work,
366 msecs_to_jiffies(pmdown_time));
368 /* capture streams can be powered down now */
369 snd_soc_dapm_stream_event(codec,
370 codec_dai->capture.stream_name,
371 SND_SOC_DAPM_STREAM_STOP);
373 if (codec->active == 0 && codec_dai->pop_wait == 0)
374 snd_soc_dapm_set_bias_level(socdev,
375 SND_SOC_BIAS_STANDBY);
378 mutex_unlock(&pcm_mutex);
383 * Called by ALSA when the PCM substream is prepared, can set format, sample
384 * rate, etc. This function is non atomic and can be called multiple times,
385 * it can refer to the runtime info.
387 static int soc_pcm_prepare(struct snd_pcm_substream *substream)
389 struct snd_soc_pcm_runtime *rtd = substream->private_data;
390 struct snd_soc_device *socdev = rtd->socdev;
391 struct snd_soc_dai_link *machine = rtd->dai;
392 struct snd_soc_platform *platform = socdev->platform;
393 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
394 struct snd_soc_dai *codec_dai = machine->codec_dai;
395 struct snd_soc_codec *codec = socdev->codec;
398 mutex_lock(&pcm_mutex);
400 if (machine->ops && machine->ops->prepare) {
401 ret = machine->ops->prepare(substream);
403 printk(KERN_ERR "asoc: machine prepare error\n");
408 if (platform->pcm_ops->prepare) {
409 ret = platform->pcm_ops->prepare(substream);
411 printk(KERN_ERR "asoc: platform prepare error\n");
416 if (codec_dai->ops.prepare) {
417 ret = codec_dai->ops.prepare(substream);
419 printk(KERN_ERR "asoc: codec DAI prepare error\n");
424 if (cpu_dai->ops.prepare) {
425 ret = cpu_dai->ops.prepare(substream);
427 printk(KERN_ERR "asoc: cpu DAI prepare error\n");
432 /* we only want to start a DAPM playback stream if we are not waiting
433 * on an existing one stopping */
434 if (codec_dai->pop_wait) {
435 /* we are waiting for the delayed work to start */
436 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
437 snd_soc_dapm_stream_event(socdev->codec,
438 codec_dai->capture.stream_name,
439 SND_SOC_DAPM_STREAM_START);
441 codec_dai->pop_wait = 0;
442 cancel_delayed_work(&socdev->delayed_work);
443 snd_soc_dai_digital_mute(codec_dai, 0);
446 /* no delayed work - do we need to power up codec */
447 if (codec->bias_level != SND_SOC_BIAS_ON) {
449 snd_soc_dapm_set_bias_level(socdev,
450 SND_SOC_BIAS_PREPARE);
452 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
453 snd_soc_dapm_stream_event(codec,
454 codec_dai->playback.stream_name,
455 SND_SOC_DAPM_STREAM_START);
457 snd_soc_dapm_stream_event(codec,
458 codec_dai->capture.stream_name,
459 SND_SOC_DAPM_STREAM_START);
461 snd_soc_dapm_set_bias_level(socdev, SND_SOC_BIAS_ON);
462 snd_soc_dai_digital_mute(codec_dai, 0);
465 /* codec already powered - power on widgets */
466 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
467 snd_soc_dapm_stream_event(codec,
468 codec_dai->playback.stream_name,
469 SND_SOC_DAPM_STREAM_START);
471 snd_soc_dapm_stream_event(codec,
472 codec_dai->capture.stream_name,
473 SND_SOC_DAPM_STREAM_START);
475 snd_soc_dai_digital_mute(codec_dai, 0);
480 mutex_unlock(&pcm_mutex);
485 * Called by ALSA when the hardware params are set by application. This
486 * function can also be called multiple times and can allocate buffers
487 * (using snd_pcm_lib_* ). It's non-atomic.
489 static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
490 struct snd_pcm_hw_params *params)
492 struct snd_soc_pcm_runtime *rtd = substream->private_data;
493 struct snd_soc_device *socdev = rtd->socdev;
494 struct snd_soc_dai_link *machine = rtd->dai;
495 struct snd_soc_platform *platform = socdev->platform;
496 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
497 struct snd_soc_dai *codec_dai = machine->codec_dai;
500 mutex_lock(&pcm_mutex);
502 if (machine->ops && machine->ops->hw_params) {
503 ret = machine->ops->hw_params(substream, params);
505 printk(KERN_ERR "asoc: machine hw_params failed\n");
510 if (codec_dai->ops.hw_params) {
511 ret = codec_dai->ops.hw_params(substream, params);
513 printk(KERN_ERR "asoc: can't set codec %s hw params\n",
519 if (cpu_dai->ops.hw_params) {
520 ret = cpu_dai->ops.hw_params(substream, params);
522 printk(KERN_ERR "asoc: interface %s hw params failed\n",
528 if (platform->pcm_ops->hw_params) {
529 ret = platform->pcm_ops->hw_params(substream, params);
531 printk(KERN_ERR "asoc: platform %s hw params failed\n",
538 mutex_unlock(&pcm_mutex);
542 if (cpu_dai->ops.hw_free)
543 cpu_dai->ops.hw_free(substream);
546 if (codec_dai->ops.hw_free)
547 codec_dai->ops.hw_free(substream);
550 if (machine->ops && machine->ops->hw_free)
551 machine->ops->hw_free(substream);
553 mutex_unlock(&pcm_mutex);
558 * Free's resources allocated by hw_params, can be called multiple times
560 static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
562 struct snd_soc_pcm_runtime *rtd = substream->private_data;
563 struct snd_soc_device *socdev = rtd->socdev;
564 struct snd_soc_dai_link *machine = rtd->dai;
565 struct snd_soc_platform *platform = socdev->platform;
566 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
567 struct snd_soc_dai *codec_dai = machine->codec_dai;
568 struct snd_soc_codec *codec = socdev->codec;
570 mutex_lock(&pcm_mutex);
572 /* apply codec digital mute */
574 snd_soc_dai_digital_mute(codec_dai, 1);
576 /* free any machine hw params */
577 if (machine->ops && machine->ops->hw_free)
578 machine->ops->hw_free(substream);
580 /* free any DMA resources */
581 if (platform->pcm_ops->hw_free)
582 platform->pcm_ops->hw_free(substream);
584 /* now free hw params for the DAI's */
585 if (codec_dai->ops.hw_free)
586 codec_dai->ops.hw_free(substream);
588 if (cpu_dai->ops.hw_free)
589 cpu_dai->ops.hw_free(substream);
591 mutex_unlock(&pcm_mutex);
595 static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
597 struct snd_soc_pcm_runtime *rtd = substream->private_data;
598 struct snd_soc_device *socdev = rtd->socdev;
599 struct snd_soc_dai_link *machine = rtd->dai;
600 struct snd_soc_platform *platform = socdev->platform;
601 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
602 struct snd_soc_dai *codec_dai = machine->codec_dai;
605 if (codec_dai->ops.trigger) {
606 ret = codec_dai->ops.trigger(substream, cmd);
611 if (platform->pcm_ops->trigger) {
612 ret = platform->pcm_ops->trigger(substream, cmd);
617 if (cpu_dai->ops.trigger) {
618 ret = cpu_dai->ops.trigger(substream, cmd);
625 /* ASoC PCM operations */
626 static struct snd_pcm_ops soc_pcm_ops = {
627 .open = soc_pcm_open,
628 .close = soc_codec_close,
629 .hw_params = soc_pcm_hw_params,
630 .hw_free = soc_pcm_hw_free,
631 .prepare = soc_pcm_prepare,
632 .trigger = soc_pcm_trigger,
636 /* powers down audio subsystem for suspend */
637 static int soc_suspend(struct platform_device *pdev, pm_message_t state)
639 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
640 struct snd_soc_machine *machine = socdev->machine;
641 struct snd_soc_platform *platform = socdev->platform;
642 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
643 struct snd_soc_codec *codec = socdev->codec;
646 /* Due to the resume being scheduled into a workqueue we could
647 * suspend before that's finished - wait for it to complete.
649 snd_power_lock(codec->card);
650 snd_power_wait(codec->card, SNDRV_CTL_POWER_D0);
651 snd_power_unlock(codec->card);
653 /* we're going to block userspace touching us until resume completes */
654 snd_power_change_state(codec->card, SNDRV_CTL_POWER_D3hot);
656 /* mute any active DAC's */
657 for (i = 0; i < machine->num_links; i++) {
658 struct snd_soc_dai *dai = machine->dai_link[i].codec_dai;
659 if (dai->dai_ops.digital_mute && dai->playback.active)
660 dai->dai_ops.digital_mute(dai, 1);
663 /* suspend all pcms */
664 for (i = 0; i < machine->num_links; i++)
665 snd_pcm_suspend_all(machine->dai_link[i].pcm);
667 if (machine->suspend_pre)
668 machine->suspend_pre(pdev, state);
670 for (i = 0; i < machine->num_links; i++) {
671 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
672 if (cpu_dai->suspend && cpu_dai->type != SND_SOC_DAI_AC97)
673 cpu_dai->suspend(pdev, cpu_dai);
674 if (platform->suspend)
675 platform->suspend(pdev, cpu_dai);
678 /* close any waiting streams and save state */
679 run_delayed_work(&socdev->delayed_work);
680 codec->suspend_bias_level = codec->bias_level;
682 for (i = 0; i < codec->num_dai; i++) {
683 char *stream = codec->dai[i].playback.stream_name;
685 snd_soc_dapm_stream_event(codec, stream,
686 SND_SOC_DAPM_STREAM_SUSPEND);
687 stream = codec->dai[i].capture.stream_name;
689 snd_soc_dapm_stream_event(codec, stream,
690 SND_SOC_DAPM_STREAM_SUSPEND);
693 if (codec_dev->suspend)
694 codec_dev->suspend(pdev, state);
696 for (i = 0; i < machine->num_links; i++) {
697 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
698 if (cpu_dai->suspend && cpu_dai->type == SND_SOC_DAI_AC97)
699 cpu_dai->suspend(pdev, cpu_dai);
702 if (machine->suspend_post)
703 machine->suspend_post(pdev, state);
708 /* deferred resume work, so resume can complete before we finished
709 * setting our codec back up, which can be very slow on I2C
711 static void soc_resume_deferred(struct work_struct *work)
713 struct snd_soc_device *socdev = container_of(work,
714 struct snd_soc_device,
715 deferred_resume_work);
716 struct snd_soc_machine *machine = socdev->machine;
717 struct snd_soc_platform *platform = socdev->platform;
718 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
719 struct snd_soc_codec *codec = socdev->codec;
720 struct platform_device *pdev = to_platform_device(socdev->dev);
723 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
724 * so userspace apps are blocked from touching us
727 dev_info(socdev->dev, "starting resume work\n");
729 if (machine->resume_pre)
730 machine->resume_pre(pdev);
732 for (i = 0; i < machine->num_links; i++) {
733 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
734 if (cpu_dai->resume && cpu_dai->type == SND_SOC_DAI_AC97)
735 cpu_dai->resume(pdev, cpu_dai);
738 if (codec_dev->resume)
739 codec_dev->resume(pdev);
741 for (i = 0; i < codec->num_dai; i++) {
742 char *stream = codec->dai[i].playback.stream_name;
744 snd_soc_dapm_stream_event(codec, stream,
745 SND_SOC_DAPM_STREAM_RESUME);
746 stream = codec->dai[i].capture.stream_name;
748 snd_soc_dapm_stream_event(codec, stream,
749 SND_SOC_DAPM_STREAM_RESUME);
752 /* unmute any active DACs */
753 for (i = 0; i < machine->num_links; i++) {
754 struct snd_soc_dai *dai = machine->dai_link[i].codec_dai;
755 if (dai->dai_ops.digital_mute && dai->playback.active)
756 dai->dai_ops.digital_mute(dai, 0);
759 for (i = 0; i < machine->num_links; i++) {
760 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
761 if (cpu_dai->resume && cpu_dai->type != SND_SOC_DAI_AC97)
762 cpu_dai->resume(pdev, cpu_dai);
763 if (platform->resume)
764 platform->resume(pdev, cpu_dai);
767 if (machine->resume_post)
768 machine->resume_post(pdev);
770 dev_info(socdev->dev, "resume work completed\n");
772 /* userspace can access us now we are back as we were before */
773 snd_power_change_state(codec->card, SNDRV_CTL_POWER_D0);
776 /* powers up audio subsystem after a suspend */
777 static int soc_resume(struct platform_device *pdev)
779 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
781 dev_info(socdev->dev, "scheduling resume work\n");
783 if (!schedule_work(&socdev->deferred_resume_work))
784 dev_err(socdev->dev, "work item may be lost\n");
790 #define soc_suspend NULL
791 #define soc_resume NULL
794 /* probes a new socdev */
795 static int soc_probe(struct platform_device *pdev)
798 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
799 struct snd_soc_machine *machine = socdev->machine;
800 struct snd_soc_platform *platform = socdev->platform;
801 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
803 if (machine->probe) {
804 ret = machine->probe(pdev);
809 for (i = 0; i < machine->num_links; i++) {
810 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
811 if (cpu_dai->probe) {
812 ret = cpu_dai->probe(pdev, cpu_dai);
818 if (codec_dev->probe) {
819 ret = codec_dev->probe(pdev);
824 if (platform->probe) {
825 ret = platform->probe(pdev);
830 /* DAPM stream work */
831 INIT_DELAYED_WORK(&socdev->delayed_work, close_delayed_work);
833 /* deferred resume work */
834 INIT_WORK(&socdev->deferred_resume_work, soc_resume_deferred);
840 if (codec_dev->remove)
841 codec_dev->remove(pdev);
844 for (i--; i >= 0; i--) {
845 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
847 cpu_dai->remove(pdev, cpu_dai);
851 machine->remove(pdev);
856 /* removes a socdev */
857 static int soc_remove(struct platform_device *pdev)
860 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
861 struct snd_soc_machine *machine = socdev->machine;
862 struct snd_soc_platform *platform = socdev->platform;
863 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
865 run_delayed_work(&socdev->delayed_work);
867 if (platform->remove)
868 platform->remove(pdev);
870 if (codec_dev->remove)
871 codec_dev->remove(pdev);
873 for (i = 0; i < machine->num_links; i++) {
874 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
876 cpu_dai->remove(pdev, cpu_dai);
880 machine->remove(pdev);
885 /* ASoC platform driver */
886 static struct platform_driver soc_driver = {
889 .owner = THIS_MODULE,
892 .remove = soc_remove,
893 .suspend = soc_suspend,
894 .resume = soc_resume,
897 /* create a new pcm */
898 static int soc_new_pcm(struct snd_soc_device *socdev,
899 struct snd_soc_dai_link *dai_link, int num)
901 struct snd_soc_codec *codec = socdev->codec;
902 struct snd_soc_dai *codec_dai = dai_link->codec_dai;
903 struct snd_soc_dai *cpu_dai = dai_link->cpu_dai;
904 struct snd_soc_pcm_runtime *rtd;
907 int ret = 0, playback = 0, capture = 0;
909 rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
914 rtd->socdev = socdev;
915 codec_dai->codec = socdev->codec;
917 /* check client and interface hw capabilities */
918 sprintf(new_name, "%s %s-%s-%d", dai_link->stream_name, codec_dai->name,
919 get_dai_name(cpu_dai->type), num);
921 if (codec_dai->playback.channels_min)
923 if (codec_dai->capture.channels_min)
926 ret = snd_pcm_new(codec->card, new_name, codec->pcm_devs++, playback,
929 printk(KERN_ERR "asoc: can't create pcm for codec %s\n",
936 pcm->private_data = rtd;
937 soc_pcm_ops.mmap = socdev->platform->pcm_ops->mmap;
938 soc_pcm_ops.pointer = socdev->platform->pcm_ops->pointer;
939 soc_pcm_ops.ioctl = socdev->platform->pcm_ops->ioctl;
940 soc_pcm_ops.copy = socdev->platform->pcm_ops->copy;
941 soc_pcm_ops.silence = socdev->platform->pcm_ops->silence;
942 soc_pcm_ops.ack = socdev->platform->pcm_ops->ack;
943 soc_pcm_ops.page = socdev->platform->pcm_ops->page;
946 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops);
949 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops);
951 ret = socdev->platform->pcm_new(codec->card, codec_dai, pcm);
953 printk(KERN_ERR "asoc: platform pcm constructor failed\n");
958 pcm->private_free = socdev->platform->pcm_free;
959 printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name,
964 /* codec register dump */
965 static ssize_t soc_codec_reg_show(struct snd_soc_device *devdata, char *buf)
967 struct snd_soc_codec *codec = devdata->codec;
968 int i, step = 1, count = 0;
970 if (!codec->reg_cache_size)
973 if (codec->reg_cache_step)
974 step = codec->reg_cache_step;
976 count += sprintf(buf, "%s registers\n", codec->name);
977 for (i = 0; i < codec->reg_cache_size; i += step) {
978 count += sprintf(buf + count, "%2x: ", i);
979 if (count >= PAGE_SIZE - 1)
982 if (codec->display_register)
983 count += codec->display_register(codec, buf + count,
984 PAGE_SIZE - count, i);
986 count += snprintf(buf + count, PAGE_SIZE - count,
987 "%4x", codec->read(codec, i));
989 if (count >= PAGE_SIZE - 1)
992 count += snprintf(buf + count, PAGE_SIZE - count, "\n");
993 if (count >= PAGE_SIZE - 1)
997 /* Truncate count; min() would cause a warning */
998 if (count >= PAGE_SIZE)
999 count = PAGE_SIZE - 1;
1003 static ssize_t codec_reg_show(struct device *dev,
1004 struct device_attribute *attr, char *buf)
1006 struct snd_soc_device *devdata = dev_get_drvdata(dev);
1007 return soc_codec_reg_show(devdata, buf);
1010 static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
1012 #ifdef CONFIG_DEBUG_FS
1013 static int codec_reg_open_file(struct inode *inode, struct file *file)
1015 file->private_data = inode->i_private;
1019 static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
1020 size_t count, loff_t *ppos)
1023 struct snd_soc_device *devdata = file->private_data;
1024 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1027 ret = soc_codec_reg_show(devdata, buf);
1029 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1034 static ssize_t codec_reg_write_file(struct file *file,
1035 const char __user *user_buf, size_t count, loff_t *ppos)
1040 unsigned long reg, value;
1042 struct snd_soc_device *devdata = file->private_data;
1043 struct snd_soc_codec *codec = devdata->codec;
1045 buf_size = min(count, (sizeof(buf)-1));
1046 if (copy_from_user(buf, user_buf, buf_size))
1050 if (codec->reg_cache_step)
1051 step = codec->reg_cache_step;
1053 while (*start == ' ')
1055 reg = simple_strtoul(start, &start, 16);
1056 if ((reg >= codec->reg_cache_size) || (reg % step))
1058 while (*start == ' ')
1060 if (strict_strtoul(start, 16, &value))
1062 codec->write(codec, reg, value);
1066 static const struct file_operations codec_reg_fops = {
1067 .open = codec_reg_open_file,
1068 .read = codec_reg_read_file,
1069 .write = codec_reg_write_file,
1072 static void soc_init_debugfs(struct snd_soc_device *socdev)
1074 struct dentry *root, *file;
1075 struct snd_soc_codec *codec = socdev->codec;
1076 root = debugfs_create_dir(dev_name(socdev->dev), NULL);
1077 if (IS_ERR(root) || !root)
1080 file = debugfs_create_file("codec_reg", 0644,
1081 root, socdev, &codec_reg_fops);
1085 file = debugfs_create_u32("dapm_pop_time", 0744,
1086 root, &codec->pop_time);
1089 socdev->debugfs_root = root;
1092 debugfs_remove_recursive(root);
1094 dev_err(socdev->dev, "debugfs is not available\n");
1097 static void soc_cleanup_debugfs(struct snd_soc_device *socdev)
1099 debugfs_remove_recursive(socdev->debugfs_root);
1100 socdev->debugfs_root = NULL;
1105 static inline void soc_init_debugfs(struct snd_soc_device *socdev)
1109 static inline void soc_cleanup_debugfs(struct snd_soc_device *socdev)
1115 * snd_soc_new_ac97_codec - initailise AC97 device
1116 * @codec: audio codec
1117 * @ops: AC97 bus operations
1118 * @num: AC97 codec number
1120 * Initialises AC97 codec resources for use by ad-hoc devices only.
1122 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
1123 struct snd_ac97_bus_ops *ops, int num)
1125 mutex_lock(&codec->mutex);
1127 codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
1128 if (codec->ac97 == NULL) {
1129 mutex_unlock(&codec->mutex);
1133 codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
1134 if (codec->ac97->bus == NULL) {
1137 mutex_unlock(&codec->mutex);
1141 codec->ac97->bus->ops = ops;
1142 codec->ac97->num = num;
1143 mutex_unlock(&codec->mutex);
1146 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
1149 * snd_soc_free_ac97_codec - free AC97 codec device
1150 * @codec: audio codec
1152 * Frees AC97 codec device resources.
1154 void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
1156 mutex_lock(&codec->mutex);
1157 kfree(codec->ac97->bus);
1160 mutex_unlock(&codec->mutex);
1162 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
1165 * snd_soc_update_bits - update codec register bits
1166 * @codec: audio codec
1167 * @reg: codec register
1168 * @mask: register mask
1171 * Writes new register value.
1173 * Returns 1 for change else 0.
1175 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
1176 unsigned short mask, unsigned short value)
1179 unsigned short old, new;
1181 mutex_lock(&io_mutex);
1182 old = snd_soc_read(codec, reg);
1183 new = (old & ~mask) | value;
1184 change = old != new;
1186 snd_soc_write(codec, reg, new);
1188 mutex_unlock(&io_mutex);
1191 EXPORT_SYMBOL_GPL(snd_soc_update_bits);
1194 * snd_soc_test_bits - test register for change
1195 * @codec: audio codec
1196 * @reg: codec register
1197 * @mask: register mask
1200 * Tests a register with a new value and checks if the new value is
1201 * different from the old value.
1203 * Returns 1 for change else 0.
1205 int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
1206 unsigned short mask, unsigned short value)
1209 unsigned short old, new;
1211 mutex_lock(&io_mutex);
1212 old = snd_soc_read(codec, reg);
1213 new = (old & ~mask) | value;
1214 change = old != new;
1215 mutex_unlock(&io_mutex);
1219 EXPORT_SYMBOL_GPL(snd_soc_test_bits);
1222 * snd_soc_new_pcms - create new sound card and pcms
1223 * @socdev: the SoC audio device
1225 * Create a new sound card based upon the codec and interface pcms.
1227 * Returns 0 for success, else error.
1229 int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid)
1231 struct snd_soc_codec *codec = socdev->codec;
1232 struct snd_soc_machine *machine = socdev->machine;
1235 mutex_lock(&codec->mutex);
1237 /* register a sound card */
1238 codec->card = snd_card_new(idx, xid, codec->owner, 0);
1240 printk(KERN_ERR "asoc: can't create sound card for codec %s\n",
1242 mutex_unlock(&codec->mutex);
1246 codec->card->dev = socdev->dev;
1247 codec->card->private_data = codec;
1248 strncpy(codec->card->driver, codec->name, sizeof(codec->card->driver));
1250 /* create the pcms */
1251 for (i = 0; i < machine->num_links; i++) {
1252 ret = soc_new_pcm(socdev, &machine->dai_link[i], i);
1254 printk(KERN_ERR "asoc: can't create pcm %s\n",
1255 machine->dai_link[i].stream_name);
1256 mutex_unlock(&codec->mutex);
1261 mutex_unlock(&codec->mutex);
1264 EXPORT_SYMBOL_GPL(snd_soc_new_pcms);
1267 * snd_soc_register_card - register sound card
1268 * @socdev: the SoC audio device
1270 * Register a SoC sound card. Also registers an AC97 device if the
1271 * codec is AC97 for ad hoc devices.
1273 * Returns 0 for success, else error.
1275 int snd_soc_register_card(struct snd_soc_device *socdev)
1277 struct snd_soc_codec *codec = socdev->codec;
1278 struct snd_soc_machine *machine = socdev->machine;
1279 int ret = 0, i, ac97 = 0, err = 0;
1281 for (i = 0; i < machine->num_links; i++) {
1282 if (socdev->machine->dai_link[i].init) {
1283 err = socdev->machine->dai_link[i].init(codec);
1285 printk(KERN_ERR "asoc: failed to init %s\n",
1286 socdev->machine->dai_link[i].stream_name);
1290 if (socdev->machine->dai_link[i].codec_dai->type ==
1291 SND_SOC_DAI_AC97_BUS)
1294 snprintf(codec->card->shortname, sizeof(codec->card->shortname),
1295 "%s", machine->name);
1296 snprintf(codec->card->longname, sizeof(codec->card->longname),
1297 "%s (%s)", machine->name, codec->name);
1299 ret = snd_card_register(codec->card);
1301 printk(KERN_ERR "asoc: failed to register soundcard for %s\n",
1306 mutex_lock(&codec->mutex);
1307 #ifdef CONFIG_SND_SOC_AC97_BUS
1309 ret = soc_ac97_dev_register(codec);
1311 printk(KERN_ERR "asoc: AC97 device register failed\n");
1312 snd_card_free(codec->card);
1313 mutex_unlock(&codec->mutex);
1319 err = snd_soc_dapm_sys_add(socdev->dev);
1321 printk(KERN_WARNING "asoc: failed to add dapm sysfs entries\n");
1323 err = device_create_file(socdev->dev, &dev_attr_codec_reg);
1325 printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");
1327 soc_init_debugfs(socdev);
1328 mutex_unlock(&codec->mutex);
1333 EXPORT_SYMBOL_GPL(snd_soc_register_card);
1336 * snd_soc_free_pcms - free sound card and pcms
1337 * @socdev: the SoC audio device
1339 * Frees sound card and pcms associated with the socdev.
1340 * Also unregister the codec if it is an AC97 device.
1342 void snd_soc_free_pcms(struct snd_soc_device *socdev)
1344 struct snd_soc_codec *codec = socdev->codec;
1345 #ifdef CONFIG_SND_SOC_AC97_BUS
1346 struct snd_soc_dai *codec_dai;
1350 mutex_lock(&codec->mutex);
1351 soc_cleanup_debugfs(socdev);
1352 #ifdef CONFIG_SND_SOC_AC97_BUS
1353 for (i = 0; i < codec->num_dai; i++) {
1354 codec_dai = &codec->dai[i];
1355 if (codec_dai->type == SND_SOC_DAI_AC97_BUS && codec->ac97) {
1356 soc_ac97_dev_unregister(codec);
1364 snd_card_free(codec->card);
1365 device_remove_file(socdev->dev, &dev_attr_codec_reg);
1366 mutex_unlock(&codec->mutex);
1368 EXPORT_SYMBOL_GPL(snd_soc_free_pcms);
1371 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
1372 * @substream: the pcm substream
1373 * @hw: the hardware parameters
1375 * Sets the substream runtime hardware parameters.
1377 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
1378 const struct snd_pcm_hardware *hw)
1380 struct snd_pcm_runtime *runtime = substream->runtime;
1381 runtime->hw.info = hw->info;
1382 runtime->hw.formats = hw->formats;
1383 runtime->hw.period_bytes_min = hw->period_bytes_min;
1384 runtime->hw.period_bytes_max = hw->period_bytes_max;
1385 runtime->hw.periods_min = hw->periods_min;
1386 runtime->hw.periods_max = hw->periods_max;
1387 runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
1388 runtime->hw.fifo_size = hw->fifo_size;
1391 EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
1394 * snd_soc_cnew - create new control
1395 * @_template: control template
1396 * @data: control private data
1397 * @lnng_name: control long name
1399 * Create a new mixer control from a template control.
1401 * Returns 0 for success, else error.
1403 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
1404 void *data, char *long_name)
1406 struct snd_kcontrol_new template;
1408 memcpy(&template, _template, sizeof(template));
1410 template.name = long_name;
1413 return snd_ctl_new1(&template, data);
1415 EXPORT_SYMBOL_GPL(snd_soc_cnew);
1418 * snd_soc_info_enum_double - enumerated double mixer info callback
1419 * @kcontrol: mixer control
1420 * @uinfo: control element information
1422 * Callback to provide information about a double enumerated
1425 * Returns 0 for success.
1427 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
1428 struct snd_ctl_elem_info *uinfo)
1430 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1432 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1433 uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
1434 uinfo->value.enumerated.items = e->max;
1436 if (uinfo->value.enumerated.item > e->max - 1)
1437 uinfo->value.enumerated.item = e->max - 1;
1438 strcpy(uinfo->value.enumerated.name,
1439 e->texts[uinfo->value.enumerated.item]);
1442 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
1445 * snd_soc_get_enum_double - enumerated double mixer get callback
1446 * @kcontrol: mixer control
1447 * @uinfo: control element information
1449 * Callback to get the value of a double enumerated mixer.
1451 * Returns 0 for success.
1453 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
1454 struct snd_ctl_elem_value *ucontrol)
1456 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1457 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1458 unsigned short val, bitmask;
1460 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
1462 val = snd_soc_read(codec, e->reg);
1463 ucontrol->value.enumerated.item[0]
1464 = (val >> e->shift_l) & (bitmask - 1);
1465 if (e->shift_l != e->shift_r)
1466 ucontrol->value.enumerated.item[1] =
1467 (val >> e->shift_r) & (bitmask - 1);
1471 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
1474 * snd_soc_put_enum_double - enumerated double mixer put callback
1475 * @kcontrol: mixer control
1476 * @uinfo: control element information
1478 * Callback to set the value of a double enumerated mixer.
1480 * Returns 0 for success.
1482 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
1483 struct snd_ctl_elem_value *ucontrol)
1485 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1486 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1488 unsigned short mask, bitmask;
1490 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
1492 if (ucontrol->value.enumerated.item[0] > e->max - 1)
1494 val = ucontrol->value.enumerated.item[0] << e->shift_l;
1495 mask = (bitmask - 1) << e->shift_l;
1496 if (e->shift_l != e->shift_r) {
1497 if (ucontrol->value.enumerated.item[1] > e->max - 1)
1499 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1500 mask |= (bitmask - 1) << e->shift_r;
1503 return snd_soc_update_bits(codec, e->reg, mask, val);
1505 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
1508 * snd_soc_info_enum_ext - external enumerated single mixer info callback
1509 * @kcontrol: mixer control
1510 * @uinfo: control element information
1512 * Callback to provide information about an external enumerated
1515 * Returns 0 for success.
1517 int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
1518 struct snd_ctl_elem_info *uinfo)
1520 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1522 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1524 uinfo->value.enumerated.items = e->max;
1526 if (uinfo->value.enumerated.item > e->max - 1)
1527 uinfo->value.enumerated.item = e->max - 1;
1528 strcpy(uinfo->value.enumerated.name,
1529 e->texts[uinfo->value.enumerated.item]);
1532 EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
1535 * snd_soc_info_volsw_ext - external single mixer info callback
1536 * @kcontrol: mixer control
1537 * @uinfo: control element information
1539 * Callback to provide information about a single external mixer control.
1541 * Returns 0 for success.
1543 int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
1544 struct snd_ctl_elem_info *uinfo)
1546 int max = kcontrol->private_value;
1549 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1551 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1554 uinfo->value.integer.min = 0;
1555 uinfo->value.integer.max = max;
1558 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
1561 * snd_soc_info_volsw - single mixer info callback
1562 * @kcontrol: mixer control
1563 * @uinfo: control element information
1565 * Callback to provide information about a single mixer control.
1567 * Returns 0 for success.
1569 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
1570 struct snd_ctl_elem_info *uinfo)
1572 struct soc_mixer_control *mc =
1573 (struct soc_mixer_control *)kcontrol->private_value;
1575 unsigned int shift = mc->min;
1576 unsigned int rshift = mc->rshift;
1579 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1581 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1583 uinfo->count = shift == rshift ? 1 : 2;
1584 uinfo->value.integer.min = 0;
1585 uinfo->value.integer.max = max;
1588 EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
1591 * snd_soc_get_volsw - single mixer get callback
1592 * @kcontrol: mixer control
1593 * @uinfo: control element information
1595 * Callback to get the value of a single mixer control.
1597 * Returns 0 for success.
1599 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
1600 struct snd_ctl_elem_value *ucontrol)
1602 struct soc_mixer_control *mc =
1603 (struct soc_mixer_control *)kcontrol->private_value;
1604 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1605 unsigned int reg = mc->reg;
1606 unsigned int shift = mc->shift;
1607 unsigned int rshift = mc->rshift;
1609 unsigned int mask = (1 << fls(max)) - 1;
1610 unsigned int invert = mc->invert;
1612 ucontrol->value.integer.value[0] =
1613 (snd_soc_read(codec, reg) >> shift) & mask;
1614 if (shift != rshift)
1615 ucontrol->value.integer.value[1] =
1616 (snd_soc_read(codec, reg) >> rshift) & mask;
1618 ucontrol->value.integer.value[0] =
1619 max - ucontrol->value.integer.value[0];
1620 if (shift != rshift)
1621 ucontrol->value.integer.value[1] =
1622 max - ucontrol->value.integer.value[1];
1627 EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
1630 * snd_soc_put_volsw - single mixer put callback
1631 * @kcontrol: mixer control
1632 * @uinfo: control element information
1634 * Callback to set the value of a single mixer control.
1636 * Returns 0 for success.
1638 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
1639 struct snd_ctl_elem_value *ucontrol)
1641 struct soc_mixer_control *mc =
1642 (struct soc_mixer_control *)kcontrol->private_value;
1643 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1644 unsigned int reg = mc->reg;
1645 unsigned int shift = mc->shift;
1646 unsigned int rshift = mc->rshift;
1648 unsigned int mask = (1 << fls(max)) - 1;
1649 unsigned int invert = mc->invert;
1650 unsigned short val, val2, val_mask;
1652 val = (ucontrol->value.integer.value[0] & mask);
1655 val_mask = mask << shift;
1657 if (shift != rshift) {
1658 val2 = (ucontrol->value.integer.value[1] & mask);
1661 val_mask |= mask << rshift;
1662 val |= val2 << rshift;
1664 return snd_soc_update_bits(codec, reg, val_mask, val);
1666 EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
1669 * snd_soc_info_volsw_2r - double mixer info callback
1670 * @kcontrol: mixer control
1671 * @uinfo: control element information
1673 * Callback to provide information about a double mixer control that
1674 * spans 2 codec registers.
1676 * Returns 0 for success.
1678 int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
1679 struct snd_ctl_elem_info *uinfo)
1681 struct soc_mixer_control *mc =
1682 (struct soc_mixer_control *)kcontrol->private_value;
1686 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1688 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1691 uinfo->value.integer.min = 0;
1692 uinfo->value.integer.max = max;
1695 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
1698 * snd_soc_get_volsw_2r - double mixer get callback
1699 * @kcontrol: mixer control
1700 * @uinfo: control element information
1702 * Callback to get the value of a double mixer control that spans 2 registers.
1704 * Returns 0 for success.
1706 int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
1707 struct snd_ctl_elem_value *ucontrol)
1709 struct soc_mixer_control *mc =
1710 (struct soc_mixer_control *)kcontrol->private_value;
1711 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1712 unsigned int reg = mc->reg;
1713 unsigned int reg2 = mc->rreg;
1714 unsigned int shift = mc->shift;
1716 unsigned int mask = (1<<fls(max))-1;
1717 unsigned int invert = mc->invert;
1719 ucontrol->value.integer.value[0] =
1720 (snd_soc_read(codec, reg) >> shift) & mask;
1721 ucontrol->value.integer.value[1] =
1722 (snd_soc_read(codec, reg2) >> shift) & mask;
1724 ucontrol->value.integer.value[0] =
1725 max - ucontrol->value.integer.value[0];
1726 ucontrol->value.integer.value[1] =
1727 max - ucontrol->value.integer.value[1];
1732 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r);
1735 * snd_soc_put_volsw_2r - double mixer set callback
1736 * @kcontrol: mixer control
1737 * @uinfo: control element information
1739 * Callback to set the value of a double mixer control that spans 2 registers.
1741 * Returns 0 for success.
1743 int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
1744 struct snd_ctl_elem_value *ucontrol)
1746 struct soc_mixer_control *mc =
1747 (struct soc_mixer_control *)kcontrol->private_value;
1748 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1749 unsigned int reg = mc->reg;
1750 unsigned int reg2 = mc->rreg;
1751 unsigned int shift = mc->shift;
1753 unsigned int mask = (1 << fls(max)) - 1;
1754 unsigned int invert = mc->invert;
1756 unsigned short val, val2, val_mask;
1758 val_mask = mask << shift;
1759 val = (ucontrol->value.integer.value[0] & mask);
1760 val2 = (ucontrol->value.integer.value[1] & mask);
1768 val2 = val2 << shift;
1770 err = snd_soc_update_bits(codec, reg, val_mask, val);
1774 err = snd_soc_update_bits(codec, reg2, val_mask, val2);
1777 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
1780 * snd_soc_info_volsw_s8 - signed mixer info callback
1781 * @kcontrol: mixer control
1782 * @uinfo: control element information
1784 * Callback to provide information about a signed mixer control.
1786 * Returns 0 for success.
1788 int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
1789 struct snd_ctl_elem_info *uinfo)
1791 struct soc_mixer_control *mc =
1792 (struct soc_mixer_control *)kcontrol->private_value;
1796 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1798 uinfo->value.integer.min = 0;
1799 uinfo->value.integer.max = max-min;
1802 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
1805 * snd_soc_get_volsw_s8 - signed mixer get callback
1806 * @kcontrol: mixer control
1807 * @uinfo: control element information
1809 * Callback to get the value of a signed mixer control.
1811 * Returns 0 for success.
1813 int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
1814 struct snd_ctl_elem_value *ucontrol)
1816 struct soc_mixer_control *mc =
1817 (struct soc_mixer_control *)kcontrol->private_value;
1818 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1819 unsigned int reg = mc->reg;
1821 int val = snd_soc_read(codec, reg);
1823 ucontrol->value.integer.value[0] =
1824 ((signed char)(val & 0xff))-min;
1825 ucontrol->value.integer.value[1] =
1826 ((signed char)((val >> 8) & 0xff))-min;
1829 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
1832 * snd_soc_put_volsw_sgn - signed mixer put callback
1833 * @kcontrol: mixer control
1834 * @uinfo: control element information
1836 * Callback to set the value of a signed mixer control.
1838 * Returns 0 for success.
1840 int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
1841 struct snd_ctl_elem_value *ucontrol)
1843 struct soc_mixer_control *mc =
1844 (struct soc_mixer_control *)kcontrol->private_value;
1845 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1846 unsigned int reg = mc->reg;
1850 val = (ucontrol->value.integer.value[0]+min) & 0xff;
1851 val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
1853 return snd_soc_update_bits(codec, reg, 0xffff, val);
1855 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
1858 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
1860 * @clk_id: DAI specific clock ID
1861 * @freq: new clock frequency in Hz
1862 * @dir: new clock direction - input/output.
1864 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
1866 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
1867 unsigned int freq, int dir)
1869 if (dai->dai_ops.set_sysclk)
1870 return dai->dai_ops.set_sysclk(dai, clk_id, freq, dir);
1874 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
1877 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
1879 * @clk_id: DAI specific clock divider ID
1880 * @div: new clock divisor.
1882 * Configures the clock dividers. This is used to derive the best DAI bit and
1883 * frame clocks from the system or master clock. It's best to set the DAI bit
1884 * and frame clocks as low as possible to save system power.
1886 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
1887 int div_id, int div)
1889 if (dai->dai_ops.set_clkdiv)
1890 return dai->dai_ops.set_clkdiv(dai, div_id, div);
1894 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
1897 * snd_soc_dai_set_pll - configure DAI PLL.
1899 * @pll_id: DAI specific PLL ID
1900 * @freq_in: PLL input clock frequency in Hz
1901 * @freq_out: requested PLL output clock frequency in Hz
1903 * Configures and enables PLL to generate output clock based on input clock.
1905 int snd_soc_dai_set_pll(struct snd_soc_dai *dai,
1906 int pll_id, unsigned int freq_in, unsigned int freq_out)
1908 if (dai->dai_ops.set_pll)
1909 return dai->dai_ops.set_pll(dai, pll_id, freq_in, freq_out);
1913 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
1916 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
1918 * @clk_id: DAI specific clock ID
1919 * @fmt: SND_SOC_DAIFMT_ format value.
1921 * Configures the DAI hardware format and clocking.
1923 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
1925 if (dai->dai_ops.set_fmt)
1926 return dai->dai_ops.set_fmt(dai, fmt);
1930 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
1933 * snd_soc_dai_set_tdm_slot - configure DAI TDM.
1935 * @mask: DAI specific mask representing used slots.
1936 * @slots: Number of slots in use.
1938 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
1941 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
1942 unsigned int mask, int slots)
1944 if (dai->dai_ops.set_sysclk)
1945 return dai->dai_ops.set_tdm_slot(dai, mask, slots);
1949 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
1952 * snd_soc_dai_set_tristate - configure DAI system or master clock.
1954 * @tristate: tristate enable
1956 * Tristates the DAI so that others can use it.
1958 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
1960 if (dai->dai_ops.set_sysclk)
1961 return dai->dai_ops.set_tristate(dai, tristate);
1965 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
1968 * snd_soc_dai_digital_mute - configure DAI system or master clock.
1970 * @mute: mute enable
1972 * Mutes the DAI DAC.
1974 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
1976 if (dai->dai_ops.digital_mute)
1977 return dai->dai_ops.digital_mute(dai, mute);
1981 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
1983 static int __devinit snd_soc_init(void)
1985 printk(KERN_INFO "ASoC version %s\n", SND_SOC_VERSION);
1986 return platform_driver_register(&soc_driver);
1989 static void snd_soc_exit(void)
1991 platform_driver_unregister(&soc_driver);
1994 module_init(snd_soc_init);
1995 module_exit(snd_soc_exit);
1997 /* Module information */
1998 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
1999 MODULE_DESCRIPTION("ALSA SoC Core");
2000 MODULE_LICENSE("GPL");
2001 MODULE_ALIAS("platform:soc-audio");