2 * soc-dapm.c -- ALSA SoC Dynamic Audio Power Management
4 * Copyright 2005 Wolfson Microelectronics PLC.
5 * Author: Liam Girdwood
6 * liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
14 * o Changes power status of internal codec blocks depending on the
15 * dynamic configuration of codec internal audio paths and active
17 * o Platform power domain - can support external components i.e. amps and
18 * mic/meadphone insertion events.
19 * o Automatic Mic Bias support
20 * o Jack insertion power event initiation - e.g. hp insertion will enable
22 * o Delayed powerdown of audio susbsystem to reduce pops between a quick
26 * o DAPM power change sequencing - allow for configurable per
28 * o Support for analogue bias optimisation.
29 * o Support for reduced codec oversampling rates.
30 * o Support for reduced codec bias currents.
33 #include <linux/module.h>
34 #include <linux/moduleparam.h>
35 #include <linux/init.h>
36 #include <linux/delay.h>
38 #include <linux/bitops.h>
39 #include <linux/platform_device.h>
40 #include <linux/jiffies.h>
41 #include <sound/core.h>
42 #include <sound/pcm.h>
43 #include <sound/pcm_params.h>
44 #include <sound/soc-dapm.h>
45 #include <sound/initval.h>
50 #define dump_dapm(codec, action) dbg_dump_dapm(codec, action)
51 #define dbg(format, arg...) printk(format, ## arg)
53 #define dump_dapm(codec, action)
54 #define dbg(format, arg...)
59 #define POP_TIME 500 /* 500 msecs - change if pop debug is too fast */
60 #define pop_wait(time) schedule_timeout_uninterruptible(msecs_to_jiffies(time))
61 #define pop_dbg(format, arg...) printk(format, ## arg); pop_wait(POP_TIME)
63 #define pop_dbg(format, arg...)
64 #define pop_wait(time)
67 /* dapm power sequences - make this per codec in the future */
68 static int dapm_up_seq[] = {
69 snd_soc_dapm_pre, snd_soc_dapm_micbias, snd_soc_dapm_mic,
70 snd_soc_dapm_mux, snd_soc_dapm_dac, snd_soc_dapm_mixer, snd_soc_dapm_pga,
71 snd_soc_dapm_adc, snd_soc_dapm_hp, snd_soc_dapm_spk, snd_soc_dapm_post
73 static int dapm_down_seq[] = {
74 snd_soc_dapm_pre, snd_soc_dapm_adc, snd_soc_dapm_hp, snd_soc_dapm_spk,
75 snd_soc_dapm_pga, snd_soc_dapm_mixer, snd_soc_dapm_dac, snd_soc_dapm_mic,
76 snd_soc_dapm_micbias, snd_soc_dapm_mux, snd_soc_dapm_post
79 static int dapm_status = 1;
80 module_param(dapm_status, int, 0);
81 MODULE_PARM_DESC(dapm_status, "enable DPM sysfs entries");
83 /* create a new dapm widget */
84 static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
85 const struct snd_soc_dapm_widget *_widget)
87 return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
90 /* set up initial codec paths */
91 static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
92 struct snd_soc_dapm_path *p, int i)
95 case snd_soc_dapm_switch:
96 case snd_soc_dapm_mixer: {
98 int reg = w->kcontrols[i].private_value & 0xff;
99 int shift = (w->kcontrols[i].private_value >> 8) & 0x0f;
100 int mask = (w->kcontrols[i].private_value >> 16) & 0xff;
101 int invert = (w->kcontrols[i].private_value >> 24) & 0x01;
103 val = snd_soc_read(w->codec, reg);
104 val = (val >> shift) & mask;
106 if ((invert && !val) || (!invert && val))
112 case snd_soc_dapm_mux: {
113 struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value;
114 int val, item, bitmask;
116 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
118 val = snd_soc_read(w->codec, e->reg);
119 item = (val >> e->shift_l) & (bitmask - 1);
122 for (i = 0; i < e->mask; i++) {
123 if (!(strcmp(p->name, e->texts[i])) && item == i)
128 /* does not effect routing - always connected */
129 case snd_soc_dapm_pga:
130 case snd_soc_dapm_output:
131 case snd_soc_dapm_adc:
132 case snd_soc_dapm_input:
133 case snd_soc_dapm_dac:
134 case snd_soc_dapm_micbias:
135 case snd_soc_dapm_vmid:
138 /* does effect routing - dynamically connected */
139 case snd_soc_dapm_hp:
140 case snd_soc_dapm_mic:
141 case snd_soc_dapm_spk:
142 case snd_soc_dapm_line:
143 case snd_soc_dapm_pre:
144 case snd_soc_dapm_post:
150 /* connect mux widget to it's interconnecting audio paths */
151 static int dapm_connect_mux(struct snd_soc_codec *codec,
152 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
153 struct snd_soc_dapm_path *path, const char *control_name,
154 const struct snd_kcontrol_new *kcontrol)
156 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
159 for (i = 0; i < e->mask; i++) {
160 if (!(strcmp(control_name, e->texts[i]))) {
161 list_add(&path->list, &codec->dapm_paths);
162 list_add(&path->list_sink, &dest->sources);
163 list_add(&path->list_source, &src->sinks);
164 path->name = (char*)e->texts[i];
165 dapm_set_path_status(dest, path, 0);
173 /* connect mixer widget to it's interconnecting audio paths */
174 static int dapm_connect_mixer(struct snd_soc_codec *codec,
175 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
176 struct snd_soc_dapm_path *path, const char *control_name)
180 /* search for mixer kcontrol */
181 for (i = 0; i < dest->num_kcontrols; i++) {
182 if (!strcmp(control_name, dest->kcontrols[i].name)) {
183 list_add(&path->list, &codec->dapm_paths);
184 list_add(&path->list_sink, &dest->sources);
185 list_add(&path->list_source, &src->sinks);
186 path->name = dest->kcontrols[i].name;
187 dapm_set_path_status(dest, path, i);
194 /* update dapm codec register bits */
195 static int dapm_update_bits(struct snd_soc_dapm_widget *widget)
198 unsigned short old, new;
199 struct snd_soc_codec *codec = widget->codec;
201 /* check for valid widgets */
202 if (widget->reg < 0 || widget->id == snd_soc_dapm_input ||
203 widget->id == snd_soc_dapm_output ||
204 widget->id == snd_soc_dapm_hp ||
205 widget->id == snd_soc_dapm_mic ||
206 widget->id == snd_soc_dapm_line ||
207 widget->id == snd_soc_dapm_spk)
210 power = widget->power;
212 power = (power ? 0:1);
214 old = snd_soc_read(codec, widget->reg);
215 new = (old & ~(0x1 << widget->shift)) | (power << widget->shift);
219 pop_dbg("pop test %s : %s in %d ms\n", widget->name,
220 widget->power ? "on" : "off", POP_TIME);
221 snd_soc_write(codec, widget->reg, new);
224 dbg("reg %x old %x new %x change %d\n", widget->reg, old, new, change);
228 /* ramps the volume up or down to minimise pops before or after a
229 * DAPM power event */
230 static int dapm_set_pga(struct snd_soc_dapm_widget *widget, int power)
232 const struct snd_kcontrol_new *k = widget->kcontrols;
234 if (widget->muted && !power)
236 if (!widget->muted && power)
239 if (widget->num_kcontrols && k) {
240 int reg = k->private_value & 0xff;
241 int shift = (k->private_value >> 8) & 0x0f;
242 int mask = (k->private_value >> 16) & 0xff;
243 int invert = (k->private_value >> 24) & 0x01;
247 /* power up has happended, increase volume to last level */
249 for (i = mask; i > widget->saved_value; i--)
250 snd_soc_update_bits(widget->codec, reg, mask, i);
252 for (i = 0; i < widget->saved_value; i++)
253 snd_soc_update_bits(widget->codec, reg, mask, i);
257 /* power down is about to occur, decrease volume to mute */
258 int val = snd_soc_read(widget->codec, reg);
259 int i = widget->saved_value = (val >> shift) & mask;
261 for (; i < mask; i++)
262 snd_soc_update_bits(widget->codec, reg, mask, i);
265 snd_soc_update_bits(widget->codec, reg, mask, i);
273 /* create new dapm mixer control */
274 static int dapm_new_mixer(struct snd_soc_codec *codec,
275 struct snd_soc_dapm_widget *w)
279 struct snd_soc_dapm_path *path;
282 for (i = 0; i < w->num_kcontrols; i++) {
285 list_for_each_entry(path, &w->sources, list_sink) {
287 /* mixer/mux paths name must match control name */
288 if (path->name != (char*)w->kcontrols[i].name)
291 /* add dapm control with long name */
292 snprintf(name, 32, "%s %s", w->name, w->kcontrols[i].name);
293 path->long_name = kstrdup (name, GFP_KERNEL);
294 if (path->long_name == NULL)
297 path->kcontrol = snd_soc_cnew(&w->kcontrols[i], w,
299 ret = snd_ctl_add(codec->card, path->kcontrol);
301 printk(KERN_ERR "asoc: failed to add dapm kcontrol %s\n",
303 kfree(path->long_name);
304 path->long_name = NULL;
312 /* create new dapm mux control */
313 static int dapm_new_mux(struct snd_soc_codec *codec,
314 struct snd_soc_dapm_widget *w)
316 struct snd_soc_dapm_path *path = NULL;
317 struct snd_kcontrol *kcontrol;
320 if (!w->num_kcontrols) {
321 printk(KERN_ERR "asoc: mux %s has no controls\n", w->name);
325 kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
326 ret = snd_ctl_add(codec->card, kcontrol);
330 list_for_each_entry(path, &w->sources, list_sink)
331 path->kcontrol = kcontrol;
336 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
340 /* create new dapm volume control */
341 static int dapm_new_pga(struct snd_soc_codec *codec,
342 struct snd_soc_dapm_widget *w)
344 struct snd_kcontrol *kcontrol;
347 if (!w->num_kcontrols)
350 kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
351 ret = snd_ctl_add(codec->card, kcontrol);
353 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
360 /* reset 'walked' bit for each dapm path */
361 static inline void dapm_clear_walk(struct snd_soc_codec *codec)
363 struct snd_soc_dapm_path *p;
365 list_for_each_entry(p, &codec->dapm_paths, list)
370 * Recursively check for a completed path to an active or physically connected
371 * output widget. Returns number of complete paths.
373 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget)
375 struct snd_soc_dapm_path *path;
378 if (widget->id == snd_soc_dapm_adc && widget->active)
381 if (widget->connected) {
382 /* connected pin ? */
383 if (widget->id == snd_soc_dapm_output && !widget->ext)
386 /* connected jack or spk ? */
387 if (widget->id == snd_soc_dapm_hp || widget->id == snd_soc_dapm_spk ||
388 widget->id == snd_soc_dapm_line)
392 list_for_each_entry(path, &widget->sinks, list_source) {
396 if (path->sink && path->connect) {
398 con += is_connected_output_ep(path->sink);
406 * Recursively check for a completed path to an active or physically connected
407 * input widget. Returns number of complete paths.
409 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget)
411 struct snd_soc_dapm_path *path;
414 /* active stream ? */
415 if (widget->id == snd_soc_dapm_dac && widget->active)
418 if (widget->connected) {
419 /* connected pin ? */
420 if (widget->id == snd_soc_dapm_input && !widget->ext)
423 /* connected VMID/Bias for lower pops */
424 if (widget->id == snd_soc_dapm_vmid)
427 /* connected jack ? */
428 if (widget->id == snd_soc_dapm_mic || widget->id == snd_soc_dapm_line)
432 list_for_each_entry(path, &widget->sources, list_sink) {
436 if (path->source && path->connect) {
438 con += is_connected_input_ep(path->source);
446 * Scan each dapm widget for complete audio path.
447 * A complete path is a route that has valid endpoints i.e.:-
449 * o DAC to output pin.
450 * o Input Pin to ADC.
451 * o Input pin to Output pin (bypass, sidetone)
452 * o DAC to ADC (loopback).
454 static int dapm_power_widgets(struct snd_soc_codec *codec, int event)
456 struct snd_soc_dapm_widget *w;
457 int in, out, i, c = 1, *seq = NULL, ret = 0, power_change, power;
459 /* do we have a sequenced stream event */
460 if (event == SND_SOC_DAPM_STREAM_START) {
461 c = ARRAY_SIZE(dapm_up_seq);
463 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
464 c = ARRAY_SIZE(dapm_down_seq);
468 for(i = 0; i < c; i++) {
469 list_for_each_entry(w, &codec->dapm_widgets, list) {
471 /* is widget in stream order */
472 if (seq && seq[i] && w->id != seq[i])
475 /* vmid - no action */
476 if (w->id == snd_soc_dapm_vmid)
480 if (w->id == snd_soc_dapm_adc && w->active) {
481 in = is_connected_input_ep(w);
482 dapm_clear_walk(w->codec);
483 w->power = (in != 0) ? 1 : 0;
489 if (w->id == snd_soc_dapm_dac && w->active) {
490 out = is_connected_output_ep(w);
491 dapm_clear_walk(w->codec);
492 w->power = (out != 0) ? 1 : 0;
497 /* programmable gain/attenuation */
498 if (w->id == snd_soc_dapm_pga) {
500 in = is_connected_input_ep(w);
501 dapm_clear_walk(w->codec);
502 out = is_connected_output_ep(w);
503 dapm_clear_walk(w->codec);
504 w->power = on = (out != 0 && in != 0) ? 1 : 0;
507 dapm_set_pga(w, on); /* lower volume to reduce pops */
510 dapm_set_pga(w, on); /* restore volume from zero */
515 /* pre and post event widgets */
516 if (w->id == snd_soc_dapm_pre) {
520 if (event == SND_SOC_DAPM_STREAM_START) {
522 NULL, SND_SOC_DAPM_PRE_PMU);
525 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
527 NULL, SND_SOC_DAPM_PRE_PMD);
533 if (w->id == snd_soc_dapm_post) {
537 if (event == SND_SOC_DAPM_STREAM_START) {
539 NULL, SND_SOC_DAPM_POST_PMU);
542 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
544 NULL, SND_SOC_DAPM_POST_PMD);
551 /* all other widgets */
552 in = is_connected_input_ep(w);
553 dapm_clear_walk(w->codec);
554 out = is_connected_output_ep(w);
555 dapm_clear_walk(w->codec);
556 power = (out != 0 && in != 0) ? 1 : 0;
557 power_change = (w->power == power) ? 0: 1;
560 /* call any power change event handlers */
563 dbg("power %s event for %s flags %x\n",
564 w->power ? "on" : "off", w->name, w->event_flags);
567 if (w->event_flags & SND_SOC_DAPM_PRE_PMU) {
569 NULL, SND_SOC_DAPM_PRE_PMU);
574 if (w->event_flags & SND_SOC_DAPM_POST_PMU){
576 NULL, SND_SOC_DAPM_POST_PMU);
581 /* power down event */
582 if (w->event_flags & SND_SOC_DAPM_PRE_PMD) {
584 NULL, SND_SOC_DAPM_PRE_PMD);
589 if (w->event_flags & SND_SOC_DAPM_POST_PMD) {
591 NULL, SND_SOC_DAPM_POST_PMD);
597 /* no event handler */
607 static void dbg_dump_dapm(struct snd_soc_codec* codec, const char *action)
609 struct snd_soc_dapm_widget *w;
610 struct snd_soc_dapm_path *p = NULL;
613 printk("DAPM %s %s\n", codec->name, action);
615 list_for_each_entry(w, &codec->dapm_widgets, list) {
617 /* only display widgets that effect routing */
619 case snd_soc_dapm_pre:
620 case snd_soc_dapm_post:
621 case snd_soc_dapm_vmid:
623 case snd_soc_dapm_mux:
624 case snd_soc_dapm_output:
625 case snd_soc_dapm_input:
626 case snd_soc_dapm_switch:
627 case snd_soc_dapm_hp:
628 case snd_soc_dapm_mic:
629 case snd_soc_dapm_spk:
630 case snd_soc_dapm_line:
631 case snd_soc_dapm_micbias:
632 case snd_soc_dapm_dac:
633 case snd_soc_dapm_adc:
634 case snd_soc_dapm_pga:
635 case snd_soc_dapm_mixer:
637 in = is_connected_input_ep(w);
638 dapm_clear_walk(w->codec);
639 out = is_connected_output_ep(w);
640 dapm_clear_walk(w->codec);
641 printk("%s: %s in %d out %d\n", w->name,
642 w->power ? "On":"Off",in, out);
644 list_for_each_entry(p, &w->sources, list_sink) {
646 printk(" in %s %s\n", p->name ? p->name : "static",
649 list_for_each_entry(p, &w->sinks, list_source) {
651 printk(" out %s %s\n", p->name ? p->name : "static",
661 /* test and update the power status of a mux widget */
662 static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
663 struct snd_kcontrol *kcontrol, int mask,
664 int val, struct soc_enum* e)
666 struct snd_soc_dapm_path *path;
669 if (widget->id != snd_soc_dapm_mux)
672 if (!snd_soc_test_bits(widget->codec, e->reg, mask, val))
675 /* find dapm widget path assoc with kcontrol */
676 list_for_each_entry(path, &widget->codec->dapm_paths, list) {
677 if (path->kcontrol != kcontrol)
680 if (!path->name || ! e->texts[val])
684 /* we now need to match the string in the enum to the path */
685 if (!(strcmp(path->name, e->texts[val])))
686 path->connect = 1; /* new connection */
688 path->connect = 0; /* old connection must be powered down */
692 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
697 /* test and update the power status of a mixer or switch widget */
698 static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
699 struct snd_kcontrol *kcontrol, int reg,
700 int val_mask, int val, int invert)
702 struct snd_soc_dapm_path *path;
705 if (widget->id != snd_soc_dapm_mixer &&
706 widget->id != snd_soc_dapm_switch)
709 if (!snd_soc_test_bits(widget->codec, reg, val_mask, val))
712 /* find dapm widget path assoc with kcontrol */
713 list_for_each_entry(path, &widget->codec->dapm_paths, list) {
714 if (path->kcontrol != kcontrol)
717 /* found, now check type */
721 path->connect = invert ? 0:1;
723 /* old connection must be powered down */
724 path->connect = invert ? 1:0;
729 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
734 /* show dapm widget status in sys fs */
735 static ssize_t dapm_widget_show(struct device *dev,
736 struct device_attribute *attr, char *buf)
738 struct snd_soc_device *devdata = dev_get_drvdata(dev);
739 struct snd_soc_codec *codec = devdata->codec;
740 struct snd_soc_dapm_widget *w;
742 char *state = "not set";
744 list_for_each_entry(w, &codec->dapm_widgets, list) {
746 /* only display widgets that burnm power */
748 case snd_soc_dapm_hp:
749 case snd_soc_dapm_mic:
750 case snd_soc_dapm_spk:
751 case snd_soc_dapm_line:
752 case snd_soc_dapm_micbias:
753 case snd_soc_dapm_dac:
754 case snd_soc_dapm_adc:
755 case snd_soc_dapm_pga:
756 case snd_soc_dapm_mixer:
758 count += sprintf(buf + count, "%s: %s\n",
759 w->name, w->power ? "On":"Off");
766 switch (codec->bias_level) {
767 case SND_SOC_BIAS_ON:
770 case SND_SOC_BIAS_PREPARE:
773 case SND_SOC_BIAS_STANDBY:
776 case SND_SOC_BIAS_OFF:
780 count += sprintf(buf + count, "PM State: %s\n", state);
785 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
787 int snd_soc_dapm_sys_add(struct device *dev)
792 ret = device_create_file(dev, &dev_attr_dapm_widget);
797 static void snd_soc_dapm_sys_remove(struct device *dev)
800 device_remove_file(dev, &dev_attr_dapm_widget);
803 /* free all dapm widgets and resources */
804 static void dapm_free_widgets(struct snd_soc_codec *codec)
806 struct snd_soc_dapm_widget *w, *next_w;
807 struct snd_soc_dapm_path *p, *next_p;
809 list_for_each_entry_safe(w, next_w, &codec->dapm_widgets, list) {
814 list_for_each_entry_safe(p, next_p, &codec->dapm_paths, list) {
822 * snd_soc_dapm_sync_endpoints - scan and power dapm paths
823 * @codec: audio codec
825 * Walks all dapm audio paths and powers widgets according to their
826 * stream or path usage.
828 * Returns 0 for success.
830 int snd_soc_dapm_sync_endpoints(struct snd_soc_codec *codec)
832 return dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
834 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_endpoints);
836 static int snd_soc_dapm_add_route(struct snd_soc_codec *codec,
837 const char *sink, const char *control, const char *source)
839 struct snd_soc_dapm_path *path;
840 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
843 /* find src and dest widgets */
844 list_for_each_entry(w, &codec->dapm_widgets, list) {
846 if (!wsink && !(strcmp(w->name, sink))) {
850 if (!wsource && !(strcmp(w->name, source))) {
855 if (wsource == NULL || wsink == NULL)
858 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
862 path->source = wsource;
864 INIT_LIST_HEAD(&path->list);
865 INIT_LIST_HEAD(&path->list_source);
866 INIT_LIST_HEAD(&path->list_sink);
868 /* check for external widgets */
869 if (wsink->id == snd_soc_dapm_input) {
870 if (wsource->id == snd_soc_dapm_micbias ||
871 wsource->id == snd_soc_dapm_mic ||
872 wsink->id == snd_soc_dapm_line ||
873 wsink->id == snd_soc_dapm_output)
876 if (wsource->id == snd_soc_dapm_output) {
877 if (wsink->id == snd_soc_dapm_spk ||
878 wsink->id == snd_soc_dapm_hp ||
879 wsink->id == snd_soc_dapm_line ||
880 wsink->id == snd_soc_dapm_input)
884 /* connect static paths */
885 if (control == NULL) {
886 list_add(&path->list, &codec->dapm_paths);
887 list_add(&path->list_sink, &wsink->sources);
888 list_add(&path->list_source, &wsource->sinks);
893 /* connect dynamic paths */
895 case snd_soc_dapm_adc:
896 case snd_soc_dapm_dac:
897 case snd_soc_dapm_pga:
898 case snd_soc_dapm_input:
899 case snd_soc_dapm_output:
900 case snd_soc_dapm_micbias:
901 case snd_soc_dapm_vmid:
902 case snd_soc_dapm_pre:
903 case snd_soc_dapm_post:
904 list_add(&path->list, &codec->dapm_paths);
905 list_add(&path->list_sink, &wsink->sources);
906 list_add(&path->list_source, &wsource->sinks);
909 case snd_soc_dapm_mux:
910 ret = dapm_connect_mux(codec, wsource, wsink, path, control,
911 &wsink->kcontrols[0]);
915 case snd_soc_dapm_switch:
916 case snd_soc_dapm_mixer:
917 ret = dapm_connect_mixer(codec, wsource, wsink, path, control);
921 case snd_soc_dapm_hp:
922 case snd_soc_dapm_mic:
923 case snd_soc_dapm_line:
924 case snd_soc_dapm_spk:
925 list_add(&path->list, &codec->dapm_paths);
926 list_add(&path->list_sink, &wsink->sources);
927 list_add(&path->list_source, &wsource->sinks);
934 printk(KERN_WARNING "asoc: no dapm match for %s --> %s --> %s\n", source,
941 * snd_soc_dapm_connect_input - connect dapm widgets
942 * @codec: audio codec
943 * @sink: name of target widget
944 * @control: mixer control name
945 * @source: name of source name
947 * Connects 2 dapm widgets together via a named audio path. The sink is
948 * the widget receiving the audio signal, whilst the source is the sender
949 * of the audio signal.
951 * This function has been deprecated in favour of snd_soc_dapm_add_routes().
953 * Returns 0 for success else error.
955 int snd_soc_dapm_connect_input(struct snd_soc_codec *codec, const char *sink,
956 const char *control, const char *source)
958 return snd_soc_dapm_add_route(codec, sink, control, source);
960 EXPORT_SYMBOL_GPL(snd_soc_dapm_connect_input);
963 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
965 * @route: audio routes
966 * @num: number of routes
968 * Connects 2 dapm widgets together via a named audio path. The sink is
969 * the widget receiving the audio signal, whilst the source is the sender
970 * of the audio signal.
972 * Returns 0 for success else error. On error all resources can be freed
973 * with a call to snd_soc_card_free().
975 int snd_soc_dapm_add_routes(struct snd_soc_codec *codec,
976 const struct snd_soc_dapm_route *route, int num)
980 for (i = 0; i < num; i++) {
981 ret = snd_soc_dapm_add_route(codec, route->sink,
982 route->control, route->source);
984 printk(KERN_ERR "Failed to add route %s->%s\n",
994 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
997 * snd_soc_dapm_new_widgets - add new dapm widgets
998 * @codec: audio codec
1000 * Checks the codec for any new dapm widgets and creates them if found.
1002 * Returns 0 for success.
1004 int snd_soc_dapm_new_widgets(struct snd_soc_codec *codec)
1006 struct snd_soc_dapm_widget *w;
1008 list_for_each_entry(w, &codec->dapm_widgets, list)
1014 case snd_soc_dapm_switch:
1015 case snd_soc_dapm_mixer:
1016 dapm_new_mixer(codec, w);
1018 case snd_soc_dapm_mux:
1019 dapm_new_mux(codec, w);
1021 case snd_soc_dapm_adc:
1022 case snd_soc_dapm_dac:
1023 case snd_soc_dapm_pga:
1024 dapm_new_pga(codec, w);
1026 case snd_soc_dapm_input:
1027 case snd_soc_dapm_output:
1028 case snd_soc_dapm_micbias:
1029 case snd_soc_dapm_spk:
1030 case snd_soc_dapm_hp:
1031 case snd_soc_dapm_mic:
1032 case snd_soc_dapm_line:
1033 case snd_soc_dapm_vmid:
1034 case snd_soc_dapm_pre:
1035 case snd_soc_dapm_post:
1041 dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
1044 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
1047 * snd_soc_dapm_get_volsw - dapm mixer get callback
1048 * @kcontrol: mixer control
1049 * @uinfo: control element information
1051 * Callback to get the value of a dapm mixer control.
1053 * Returns 0 for success.
1055 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
1056 struct snd_ctl_elem_value *ucontrol)
1058 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1059 int reg = kcontrol->private_value & 0xff;
1060 int shift = (kcontrol->private_value >> 8) & 0x0f;
1061 int rshift = (kcontrol->private_value >> 12) & 0x0f;
1062 int max = (kcontrol->private_value >> 16) & 0xff;
1063 int invert = (kcontrol->private_value >> 24) & 0x01;
1064 int mask = (1 << fls(max)) - 1;
1066 /* return the saved value if we are powered down */
1067 if (widget->id == snd_soc_dapm_pga && !widget->power) {
1068 ucontrol->value.integer.value[0] = widget->saved_value;
1072 ucontrol->value.integer.value[0] =
1073 (snd_soc_read(widget->codec, reg) >> shift) & mask;
1074 if (shift != rshift)
1075 ucontrol->value.integer.value[1] =
1076 (snd_soc_read(widget->codec, reg) >> rshift) & mask;
1078 ucontrol->value.integer.value[0] =
1079 max - ucontrol->value.integer.value[0];
1080 if (shift != rshift)
1081 ucontrol->value.integer.value[1] =
1082 max - ucontrol->value.integer.value[1];
1087 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
1090 * snd_soc_dapm_put_volsw - dapm mixer set callback
1091 * @kcontrol: mixer control
1092 * @uinfo: control element information
1094 * Callback to set the value of a dapm mixer control.
1096 * Returns 0 for success.
1098 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
1099 struct snd_ctl_elem_value *ucontrol)
1101 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1102 int reg = kcontrol->private_value & 0xff;
1103 int shift = (kcontrol->private_value >> 8) & 0x0f;
1104 int rshift = (kcontrol->private_value >> 12) & 0x0f;
1105 int max = (kcontrol->private_value >> 16) & 0xff;
1106 int mask = (1 << fls(max)) - 1;
1107 int invert = (kcontrol->private_value >> 24) & 0x01;
1108 unsigned short val, val2, val_mask;
1111 val = (ucontrol->value.integer.value[0] & mask);
1115 val_mask = mask << shift;
1117 if (shift != rshift) {
1118 val2 = (ucontrol->value.integer.value[1] & mask);
1121 val_mask |= mask << rshift;
1122 val |= val2 << rshift;
1125 mutex_lock(&widget->codec->mutex);
1126 widget->value = val;
1128 /* save volume value if the widget is powered down */
1129 if (widget->id == snd_soc_dapm_pga && !widget->power) {
1130 widget->saved_value = val;
1131 mutex_unlock(&widget->codec->mutex);
1135 dapm_mixer_update_power(widget, kcontrol, reg, val_mask, val, invert);
1136 if (widget->event) {
1137 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1138 ret = widget->event(widget, kcontrol,
1139 SND_SOC_DAPM_PRE_REG);
1145 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1146 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1147 ret = widget->event(widget, kcontrol,
1148 SND_SOC_DAPM_POST_REG);
1150 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1153 mutex_unlock(&widget->codec->mutex);
1156 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
1159 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
1160 * @kcontrol: mixer control
1161 * @uinfo: control element information
1163 * Callback to get the value of a dapm enumerated double mixer control.
1165 * Returns 0 for success.
1167 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
1168 struct snd_ctl_elem_value *ucontrol)
1170 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1171 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1172 unsigned short val, bitmask;
1174 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1176 val = snd_soc_read(widget->codec, e->reg);
1177 ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
1178 if (e->shift_l != e->shift_r)
1179 ucontrol->value.enumerated.item[1] =
1180 (val >> e->shift_r) & (bitmask - 1);
1184 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
1187 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
1188 * @kcontrol: mixer control
1189 * @uinfo: control element information
1191 * Callback to set the value of a dapm enumerated double mixer control.
1193 * Returns 0 for success.
1195 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
1196 struct snd_ctl_elem_value *ucontrol)
1198 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1199 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1200 unsigned short val, mux;
1201 unsigned short mask, bitmask;
1204 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1206 if (ucontrol->value.enumerated.item[0] > e->mask - 1)
1208 mux = ucontrol->value.enumerated.item[0];
1209 val = mux << e->shift_l;
1210 mask = (bitmask - 1) << e->shift_l;
1211 if (e->shift_l != e->shift_r) {
1212 if (ucontrol->value.enumerated.item[1] > e->mask - 1)
1214 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1215 mask |= (bitmask - 1) << e->shift_r;
1218 mutex_lock(&widget->codec->mutex);
1219 widget->value = val;
1220 dapm_mux_update_power(widget, kcontrol, mask, mux, e);
1221 if (widget->event) {
1222 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1223 ret = widget->event(widget,
1224 kcontrol, SND_SOC_DAPM_PRE_REG);
1228 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1229 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1230 ret = widget->event(widget,
1231 kcontrol, SND_SOC_DAPM_POST_REG);
1233 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1236 mutex_unlock(&widget->codec->mutex);
1239 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
1242 * snd_soc_dapm_new_control - create new dapm control
1243 * @codec: audio codec
1244 * @widget: widget template
1246 * Creates a new dapm control based upon the template.
1248 * Returns 0 for success else error.
1250 int snd_soc_dapm_new_control(struct snd_soc_codec *codec,
1251 const struct snd_soc_dapm_widget *widget)
1253 struct snd_soc_dapm_widget *w;
1255 if ((w = dapm_cnew_widget(widget)) == NULL)
1259 INIT_LIST_HEAD(&w->sources);
1260 INIT_LIST_HEAD(&w->sinks);
1261 INIT_LIST_HEAD(&w->list);
1262 list_add(&w->list, &codec->dapm_widgets);
1264 /* machine layer set ups unconnected pins and insertions */
1268 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
1271 * snd_soc_dapm_new_controls - create new dapm controls
1272 * @codec: audio codec
1273 * @widget: widget array
1274 * @num: number of widgets
1276 * Creates new DAPM controls based upon the templates.
1278 * Returns 0 for success else error.
1280 int snd_soc_dapm_new_controls(struct snd_soc_codec *codec,
1281 const struct snd_soc_dapm_widget *widget,
1286 for (i = 0; i < num; i++) {
1287 ret = snd_soc_dapm_new_control(codec, widget);
1294 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
1298 * snd_soc_dapm_stream_event - send a stream event to the dapm core
1299 * @codec: audio codec
1300 * @stream: stream name
1301 * @event: stream event
1303 * Sends a stream event to the dapm core. The core then makes any
1304 * necessary widget power changes.
1306 * Returns 0 for success else error.
1308 int snd_soc_dapm_stream_event(struct snd_soc_codec *codec,
1309 char *stream, int event)
1311 struct snd_soc_dapm_widget *w;
1316 mutex_lock(&codec->mutex);
1317 list_for_each_entry(w, &codec->dapm_widgets, list)
1321 dbg("widget %s\n %s stream %s event %d\n", w->name, w->sname,
1323 if (strstr(w->sname, stream)) {
1325 case SND_SOC_DAPM_STREAM_START:
1328 case SND_SOC_DAPM_STREAM_STOP:
1331 case SND_SOC_DAPM_STREAM_SUSPEND:
1336 case SND_SOC_DAPM_STREAM_RESUME:
1342 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
1344 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
1349 mutex_unlock(&codec->mutex);
1351 dapm_power_widgets(codec, event);
1352 dump_dapm(codec, __func__);
1355 EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event);
1358 * snd_soc_dapm_set_bias_level - set the bias level for the system
1359 * @socdev: audio device
1360 * @level: level to configure
1362 * Configure the bias (power) levels for the SoC audio device.
1364 * Returns 0 for success else error.
1366 int snd_soc_dapm_set_bias_level(struct snd_soc_device *socdev,
1367 enum snd_soc_bias_level level)
1369 struct snd_soc_codec *codec = socdev->codec;
1370 struct snd_soc_machine *machine = socdev->machine;
1373 if (machine->set_bias_level)
1374 ret = machine->set_bias_level(machine, level);
1375 if (ret == 0 && codec->set_bias_level)
1376 ret = codec->set_bias_level(codec, level);
1382 * snd_soc_dapm_set_endpoint - set audio endpoint status
1383 * @codec: audio codec
1384 * @endpoint: audio signal endpoint (or start point)
1385 * @status: point status
1387 * Set audio endpoint status - connected or disconnected.
1389 * Returns 0 for success else error.
1391 int snd_soc_dapm_set_endpoint(struct snd_soc_codec *codec,
1392 char *endpoint, int status)
1394 struct snd_soc_dapm_widget *w;
1396 list_for_each_entry(w, &codec->dapm_widgets, list) {
1397 if (!strcmp(w->name, endpoint)) {
1398 w->connected = status;
1405 EXPORT_SYMBOL_GPL(snd_soc_dapm_set_endpoint);
1408 * snd_soc_dapm_get_endpoint_status - get audio endpoint status
1409 * @codec: audio codec
1410 * @endpoint: audio signal endpoint (or start point)
1412 * Get audio endpoint status - connected or disconnected.
1416 int snd_soc_dapm_get_endpoint_status(struct snd_soc_codec *codec,
1419 struct snd_soc_dapm_widget *w;
1421 list_for_each_entry(w, &codec->dapm_widgets, list) {
1422 if (!strcmp(w->name, endpoint))
1423 return w->connected;
1428 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_endpoint_status);
1431 * snd_soc_dapm_free - free dapm resources
1432 * @socdev: SoC device
1434 * Free all dapm widgets and resources.
1436 void snd_soc_dapm_free(struct snd_soc_device *socdev)
1438 struct snd_soc_codec *codec = socdev->codec;
1440 snd_soc_dapm_sys_remove(socdev->dev);
1441 dapm_free_widgets(codec);
1443 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
1445 /* Module information */
1446 MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com");
1447 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
1448 MODULE_LICENSE("GPL");