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>
49 #define dump_dapm(codec, action) dbg_dump_dapm(codec, action)
51 #define dump_dapm(codec, action)
54 /* dapm power sequences - make this per codec in the future */
55 static int dapm_up_seq[] = {
56 snd_soc_dapm_pre, snd_soc_dapm_micbias, snd_soc_dapm_mic,
57 snd_soc_dapm_mux, snd_soc_dapm_dac, snd_soc_dapm_mixer, snd_soc_dapm_pga,
58 snd_soc_dapm_adc, snd_soc_dapm_hp, snd_soc_dapm_spk, snd_soc_dapm_post
60 static int dapm_down_seq[] = {
61 snd_soc_dapm_pre, snd_soc_dapm_adc, snd_soc_dapm_hp, snd_soc_dapm_spk,
62 snd_soc_dapm_pga, snd_soc_dapm_mixer, snd_soc_dapm_dac, snd_soc_dapm_mic,
63 snd_soc_dapm_micbias, snd_soc_dapm_mux, snd_soc_dapm_post
66 static int dapm_status = 1;
67 module_param(dapm_status, int, 0);
68 MODULE_PARM_DESC(dapm_status, "enable DPM sysfs entries");
70 static unsigned int pop_time;
72 static void pop_wait(void)
75 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
78 static void pop_dbg(const char *fmt, ...)
92 /* create a new dapm widget */
93 static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
94 const struct snd_soc_dapm_widget *_widget)
96 return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
99 /* set up initial codec paths */
100 static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
101 struct snd_soc_dapm_path *p, int i)
104 case snd_soc_dapm_switch:
105 case snd_soc_dapm_mixer: {
107 struct soc_mixer_control *mc = (struct soc_mixer_control *)
108 w->kcontrols[i].private_value;
109 unsigned int reg = mc->reg;
110 unsigned int shift = mc->shift;
112 unsigned int mask = (1 << fls(max)) - 1;
113 unsigned int invert = mc->invert;
115 val = snd_soc_read(w->codec, reg);
116 val = (val >> shift) & mask;
118 if ((invert && !val) || (!invert && val))
124 case snd_soc_dapm_mux: {
125 struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value;
126 int val, item, bitmask;
128 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
130 val = snd_soc_read(w->codec, e->reg);
131 item = (val >> e->shift_l) & (bitmask - 1);
134 for (i = 0; i < e->max; i++) {
135 if (!(strcmp(p->name, e->texts[i])) && item == i)
140 /* does not effect routing - always connected */
141 case snd_soc_dapm_pga:
142 case snd_soc_dapm_output:
143 case snd_soc_dapm_adc:
144 case snd_soc_dapm_input:
145 case snd_soc_dapm_dac:
146 case snd_soc_dapm_micbias:
147 case snd_soc_dapm_vmid:
150 /* does effect routing - dynamically connected */
151 case snd_soc_dapm_hp:
152 case snd_soc_dapm_mic:
153 case snd_soc_dapm_spk:
154 case snd_soc_dapm_line:
155 case snd_soc_dapm_pre:
156 case snd_soc_dapm_post:
162 /* connect mux widget to it's interconnecting audio paths */
163 static int dapm_connect_mux(struct snd_soc_codec *codec,
164 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
165 struct snd_soc_dapm_path *path, const char *control_name,
166 const struct snd_kcontrol_new *kcontrol)
168 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
171 for (i = 0; i < e->max; i++) {
172 if (!(strcmp(control_name, e->texts[i]))) {
173 list_add(&path->list, &codec->dapm_paths);
174 list_add(&path->list_sink, &dest->sources);
175 list_add(&path->list_source, &src->sinks);
176 path->name = (char*)e->texts[i];
177 dapm_set_path_status(dest, path, 0);
185 /* connect mixer widget to it's interconnecting audio paths */
186 static int dapm_connect_mixer(struct snd_soc_codec *codec,
187 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
188 struct snd_soc_dapm_path *path, const char *control_name)
192 /* search for mixer kcontrol */
193 for (i = 0; i < dest->num_kcontrols; i++) {
194 if (!strcmp(control_name, dest->kcontrols[i].name)) {
195 list_add(&path->list, &codec->dapm_paths);
196 list_add(&path->list_sink, &dest->sources);
197 list_add(&path->list_source, &src->sinks);
198 path->name = dest->kcontrols[i].name;
199 dapm_set_path_status(dest, path, i);
206 /* update dapm codec register bits */
207 static int dapm_update_bits(struct snd_soc_dapm_widget *widget)
210 unsigned short old, new;
211 struct snd_soc_codec *codec = widget->codec;
213 /* check for valid widgets */
214 if (widget->reg < 0 || widget->id == snd_soc_dapm_input ||
215 widget->id == snd_soc_dapm_output ||
216 widget->id == snd_soc_dapm_hp ||
217 widget->id == snd_soc_dapm_mic ||
218 widget->id == snd_soc_dapm_line ||
219 widget->id == snd_soc_dapm_spk)
222 power = widget->power;
224 power = (power ? 0:1);
226 old = snd_soc_read(codec, widget->reg);
227 new = (old & ~(0x1 << widget->shift)) | (power << widget->shift);
231 pop_dbg("pop test %s : %s in %d ms\n", widget->name,
232 widget->power ? "on" : "off", pop_time);
233 snd_soc_write(codec, widget->reg, new);
236 pr_debug("reg %x old %x new %x change %d\n", widget->reg,
241 /* ramps the volume up or down to minimise pops before or after a
242 * DAPM power event */
243 static int dapm_set_pga(struct snd_soc_dapm_widget *widget, int power)
245 const struct snd_kcontrol_new *k = widget->kcontrols;
247 if (widget->muted && !power)
249 if (!widget->muted && power)
252 if (widget->num_kcontrols && k) {
253 struct soc_mixer_control *mc =
254 (struct soc_mixer_control *)k->private_value;
255 unsigned int reg = mc->reg;
256 unsigned int shift = mc->shift;
258 unsigned int mask = (1 << fls(max)) - 1;
259 unsigned int invert = mc->invert;
263 /* power up has happended, increase volume to last level */
265 for (i = max; i > widget->saved_value; i--)
266 snd_soc_update_bits(widget->codec, reg, mask, i);
268 for (i = 0; i < widget->saved_value; i++)
269 snd_soc_update_bits(widget->codec, reg, mask, i);
273 /* power down is about to occur, decrease volume to mute */
274 int val = snd_soc_read(widget->codec, reg);
275 int i = widget->saved_value = (val >> shift) & mask;
277 for (; i < mask; i++)
278 snd_soc_update_bits(widget->codec, reg, mask, i);
281 snd_soc_update_bits(widget->codec, reg, mask, i);
289 /* create new dapm mixer control */
290 static int dapm_new_mixer(struct snd_soc_codec *codec,
291 struct snd_soc_dapm_widget *w)
295 struct snd_soc_dapm_path *path;
298 for (i = 0; i < w->num_kcontrols; i++) {
301 list_for_each_entry(path, &w->sources, list_sink) {
303 /* mixer/mux paths name must match control name */
304 if (path->name != (char*)w->kcontrols[i].name)
307 /* add dapm control with long name */
308 snprintf(name, 32, "%s %s", w->name, w->kcontrols[i].name);
309 path->long_name = kstrdup (name, GFP_KERNEL);
310 if (path->long_name == NULL)
313 path->kcontrol = snd_soc_cnew(&w->kcontrols[i], w,
315 ret = snd_ctl_add(codec->card, path->kcontrol);
317 printk(KERN_ERR "asoc: failed to add dapm kcontrol %s\n",
319 kfree(path->long_name);
320 path->long_name = NULL;
328 /* create new dapm mux control */
329 static int dapm_new_mux(struct snd_soc_codec *codec,
330 struct snd_soc_dapm_widget *w)
332 struct snd_soc_dapm_path *path = NULL;
333 struct snd_kcontrol *kcontrol;
336 if (!w->num_kcontrols) {
337 printk(KERN_ERR "asoc: mux %s has no controls\n", w->name);
341 kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
342 ret = snd_ctl_add(codec->card, kcontrol);
346 list_for_each_entry(path, &w->sources, list_sink)
347 path->kcontrol = kcontrol;
352 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
356 /* create new dapm volume control */
357 static int dapm_new_pga(struct snd_soc_codec *codec,
358 struct snd_soc_dapm_widget *w)
360 struct snd_kcontrol *kcontrol;
363 if (!w->num_kcontrols)
366 kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
367 ret = snd_ctl_add(codec->card, kcontrol);
369 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
376 /* reset 'walked' bit for each dapm path */
377 static inline void dapm_clear_walk(struct snd_soc_codec *codec)
379 struct snd_soc_dapm_path *p;
381 list_for_each_entry(p, &codec->dapm_paths, list)
386 * Recursively check for a completed path to an active or physically connected
387 * output widget. Returns number of complete paths.
389 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget)
391 struct snd_soc_dapm_path *path;
394 if (widget->id == snd_soc_dapm_adc && widget->active)
397 if (widget->connected) {
398 /* connected pin ? */
399 if (widget->id == snd_soc_dapm_output && !widget->ext)
402 /* connected jack or spk ? */
403 if (widget->id == snd_soc_dapm_hp || widget->id == snd_soc_dapm_spk ||
404 widget->id == snd_soc_dapm_line)
408 list_for_each_entry(path, &widget->sinks, list_source) {
412 if (path->sink && path->connect) {
414 con += is_connected_output_ep(path->sink);
422 * Recursively check for a completed path to an active or physically connected
423 * input widget. Returns number of complete paths.
425 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget)
427 struct snd_soc_dapm_path *path;
430 /* active stream ? */
431 if (widget->id == snd_soc_dapm_dac && widget->active)
434 if (widget->connected) {
435 /* connected pin ? */
436 if (widget->id == snd_soc_dapm_input && !widget->ext)
439 /* connected VMID/Bias for lower pops */
440 if (widget->id == snd_soc_dapm_vmid)
443 /* connected jack ? */
444 if (widget->id == snd_soc_dapm_mic || widget->id == snd_soc_dapm_line)
448 list_for_each_entry(path, &widget->sources, list_sink) {
452 if (path->source && path->connect) {
454 con += is_connected_input_ep(path->source);
462 * Handler for generic register modifier widget.
464 int dapm_reg_event(struct snd_soc_dapm_widget *w,
465 struct snd_kcontrol *kcontrol, int event)
469 if (SND_SOC_DAPM_EVENT_ON(event))
474 snd_soc_update_bits(w->codec, -(w->reg + 1),
475 w->mask << w->shift, val << w->shift);
479 EXPORT_SYMBOL_GPL(dapm_reg_event);
482 * Scan each dapm widget for complete audio path.
483 * A complete path is a route that has valid endpoints i.e.:-
485 * o DAC to output pin.
486 * o Input Pin to ADC.
487 * o Input pin to Output pin (bypass, sidetone)
488 * o DAC to ADC (loopback).
490 static int dapm_power_widgets(struct snd_soc_codec *codec, int event)
492 struct snd_soc_dapm_widget *w;
493 int in, out, i, c = 1, *seq = NULL, ret = 0, power_change, power;
495 /* do we have a sequenced stream event */
496 if (event == SND_SOC_DAPM_STREAM_START) {
497 c = ARRAY_SIZE(dapm_up_seq);
499 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
500 c = ARRAY_SIZE(dapm_down_seq);
504 for(i = 0; i < c; i++) {
505 list_for_each_entry(w, &codec->dapm_widgets, list) {
507 /* is widget in stream order */
508 if (seq && seq[i] && w->id != seq[i])
511 /* vmid - no action */
512 if (w->id == snd_soc_dapm_vmid)
516 if (w->id == snd_soc_dapm_adc && w->active) {
517 in = is_connected_input_ep(w);
518 dapm_clear_walk(w->codec);
519 w->power = (in != 0) ? 1 : 0;
525 if (w->id == snd_soc_dapm_dac && w->active) {
526 out = is_connected_output_ep(w);
527 dapm_clear_walk(w->codec);
528 w->power = (out != 0) ? 1 : 0;
533 /* pre and post event widgets */
534 if (w->id == snd_soc_dapm_pre) {
538 if (event == SND_SOC_DAPM_STREAM_START) {
540 NULL, SND_SOC_DAPM_PRE_PMU);
543 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
545 NULL, SND_SOC_DAPM_PRE_PMD);
551 if (w->id == snd_soc_dapm_post) {
555 if (event == SND_SOC_DAPM_STREAM_START) {
557 NULL, SND_SOC_DAPM_POST_PMU);
560 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
562 NULL, SND_SOC_DAPM_POST_PMD);
569 /* all other widgets */
570 in = is_connected_input_ep(w);
571 dapm_clear_walk(w->codec);
572 out = is_connected_output_ep(w);
573 dapm_clear_walk(w->codec);
574 power = (out != 0 && in != 0) ? 1 : 0;
575 power_change = (w->power == power) ? 0: 1;
581 /* call any power change event handlers */
583 pr_debug("power %s event for %s flags %x\n",
584 w->power ? "on" : "off",
585 w->name, w->event_flags);
587 /* power up pre event */
588 if (power && w->event &&
589 (w->event_flags & SND_SOC_DAPM_PRE_PMU)) {
590 ret = w->event(w, NULL, SND_SOC_DAPM_PRE_PMU);
595 /* power down pre event */
596 if (!power && w->event &&
597 (w->event_flags & SND_SOC_DAPM_PRE_PMD)) {
598 ret = w->event(w, NULL, SND_SOC_DAPM_PRE_PMD);
603 /* Lower PGA volume to reduce pops */
604 if (w->id == snd_soc_dapm_pga && !power)
605 dapm_set_pga(w, power);
609 /* Raise PGA volume to reduce pops */
610 if (w->id == snd_soc_dapm_pga && power)
611 dapm_set_pga(w, power);
613 /* power up post event */
614 if (power && w->event &&
615 (w->event_flags & SND_SOC_DAPM_POST_PMU)) {
617 NULL, SND_SOC_DAPM_POST_PMU);
622 /* power down post event */
623 if (!power && w->event &&
624 (w->event_flags & SND_SOC_DAPM_POST_PMD)) {
625 ret = w->event(w, NULL, SND_SOC_DAPM_POST_PMD);
636 static void dbg_dump_dapm(struct snd_soc_codec* codec, const char *action)
638 struct snd_soc_dapm_widget *w;
639 struct snd_soc_dapm_path *p = NULL;
642 printk("DAPM %s %s\n", codec->name, action);
644 list_for_each_entry(w, &codec->dapm_widgets, list) {
646 /* only display widgets that effect routing */
648 case snd_soc_dapm_pre:
649 case snd_soc_dapm_post:
650 case snd_soc_dapm_vmid:
652 case snd_soc_dapm_mux:
653 case snd_soc_dapm_output:
654 case snd_soc_dapm_input:
655 case snd_soc_dapm_switch:
656 case snd_soc_dapm_hp:
657 case snd_soc_dapm_mic:
658 case snd_soc_dapm_spk:
659 case snd_soc_dapm_line:
660 case snd_soc_dapm_micbias:
661 case snd_soc_dapm_dac:
662 case snd_soc_dapm_adc:
663 case snd_soc_dapm_pga:
664 case snd_soc_dapm_mixer:
666 in = is_connected_input_ep(w);
667 dapm_clear_walk(w->codec);
668 out = is_connected_output_ep(w);
669 dapm_clear_walk(w->codec);
670 printk("%s: %s in %d out %d\n", w->name,
671 w->power ? "On":"Off",in, out);
673 list_for_each_entry(p, &w->sources, list_sink) {
675 printk(" in %s %s\n", p->name ? p->name : "static",
678 list_for_each_entry(p, &w->sinks, list_source) {
680 printk(" out %s %s\n", p->name ? p->name : "static",
690 /* test and update the power status of a mux widget */
691 static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
692 struct snd_kcontrol *kcontrol, int mask,
693 int val, struct soc_enum* e)
695 struct snd_soc_dapm_path *path;
698 if (widget->id != snd_soc_dapm_mux)
701 if (!snd_soc_test_bits(widget->codec, e->reg, mask, val))
704 /* find dapm widget path assoc with kcontrol */
705 list_for_each_entry(path, &widget->codec->dapm_paths, list) {
706 if (path->kcontrol != kcontrol)
709 if (!path->name || ! e->texts[val])
713 /* we now need to match the string in the enum to the path */
714 if (!(strcmp(path->name, e->texts[val])))
715 path->connect = 1; /* new connection */
717 path->connect = 0; /* old connection must be powered down */
721 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
722 dump_dapm(widget->codec, "mux power update");
728 /* test and update the power status of a mixer or switch widget */
729 static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
730 struct snd_kcontrol *kcontrol, int reg,
731 int val_mask, int val, int invert)
733 struct snd_soc_dapm_path *path;
736 if (widget->id != snd_soc_dapm_mixer &&
737 widget->id != snd_soc_dapm_switch)
740 if (!snd_soc_test_bits(widget->codec, reg, val_mask, val))
743 /* find dapm widget path assoc with kcontrol */
744 list_for_each_entry(path, &widget->codec->dapm_paths, list) {
745 if (path->kcontrol != kcontrol)
748 /* found, now check type */
752 path->connect = invert ? 0:1;
754 /* old connection must be powered down */
755 path->connect = invert ? 1:0;
760 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
761 dump_dapm(widget->codec, "mixer power update");
767 /* show dapm widget status in sys fs */
768 static ssize_t dapm_widget_show(struct device *dev,
769 struct device_attribute *attr, char *buf)
771 struct snd_soc_device *devdata = dev_get_drvdata(dev);
772 struct snd_soc_codec *codec = devdata->codec;
773 struct snd_soc_dapm_widget *w;
775 char *state = "not set";
777 list_for_each_entry(w, &codec->dapm_widgets, list) {
779 /* only display widgets that burnm power */
781 case snd_soc_dapm_hp:
782 case snd_soc_dapm_mic:
783 case snd_soc_dapm_spk:
784 case snd_soc_dapm_line:
785 case snd_soc_dapm_micbias:
786 case snd_soc_dapm_dac:
787 case snd_soc_dapm_adc:
788 case snd_soc_dapm_pga:
789 case snd_soc_dapm_mixer:
791 count += sprintf(buf + count, "%s: %s\n",
792 w->name, w->power ? "On":"Off");
799 switch (codec->bias_level) {
800 case SND_SOC_BIAS_ON:
803 case SND_SOC_BIAS_PREPARE:
806 case SND_SOC_BIAS_STANDBY:
809 case SND_SOC_BIAS_OFF:
813 count += sprintf(buf + count, "PM State: %s\n", state);
818 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
820 /* pop/click delay times */
821 static ssize_t dapm_pop_time_show(struct device *dev,
822 struct device_attribute *attr, char *buf)
824 return sprintf(buf, "%d\n", pop_time);
827 static ssize_t dapm_pop_time_store(struct device *dev,
828 struct device_attribute *attr,
829 const char *buf, size_t count)
834 if (strict_strtoul(buf, 10, &val) >= 0)
837 printk(KERN_ERR "Unable to parse pop_time setting\n");
842 static DEVICE_ATTR(dapm_pop_time, 0744, dapm_pop_time_show,
843 dapm_pop_time_store);
845 int snd_soc_dapm_sys_add(struct device *dev)
850 ret = device_create_file(dev, &dev_attr_dapm_widget);
853 ret = device_create_file(dev, &dev_attr_dapm_pop_time);
859 static void snd_soc_dapm_sys_remove(struct device *dev)
862 device_remove_file(dev, &dev_attr_dapm_pop_time);
863 device_remove_file(dev, &dev_attr_dapm_widget);
867 /* free all dapm widgets and resources */
868 static void dapm_free_widgets(struct snd_soc_codec *codec)
870 struct snd_soc_dapm_widget *w, *next_w;
871 struct snd_soc_dapm_path *p, *next_p;
873 list_for_each_entry_safe(w, next_w, &codec->dapm_widgets, list) {
878 list_for_each_entry_safe(p, next_p, &codec->dapm_paths, list) {
885 static int snd_soc_dapm_set_pin(struct snd_soc_codec *codec,
886 char *pin, int status)
888 struct snd_soc_dapm_widget *w;
890 list_for_each_entry(w, &codec->dapm_widgets, list) {
891 if (!strcmp(w->name, pin)) {
892 pr_debug("dapm: %s: pin %s\n", codec->name, pin);
893 w->connected = status;
898 pr_err("dapm: %s: configuring unknown pin %s\n", codec->name, pin);
903 * snd_soc_dapm_sync - scan and power dapm paths
904 * @codec: audio codec
906 * Walks all dapm audio paths and powers widgets according to their
907 * stream or path usage.
909 * Returns 0 for success.
911 int snd_soc_dapm_sync(struct snd_soc_codec *codec)
913 int ret = dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
914 dump_dapm(codec, "sync");
917 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
919 static int snd_soc_dapm_add_route(struct snd_soc_codec *codec,
920 const char *sink, const char *control, const char *source)
922 struct snd_soc_dapm_path *path;
923 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
926 /* find src and dest widgets */
927 list_for_each_entry(w, &codec->dapm_widgets, list) {
929 if (!wsink && !(strcmp(w->name, sink))) {
933 if (!wsource && !(strcmp(w->name, source))) {
938 if (wsource == NULL || wsink == NULL)
941 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
945 path->source = wsource;
947 INIT_LIST_HEAD(&path->list);
948 INIT_LIST_HEAD(&path->list_source);
949 INIT_LIST_HEAD(&path->list_sink);
951 /* check for external widgets */
952 if (wsink->id == snd_soc_dapm_input) {
953 if (wsource->id == snd_soc_dapm_micbias ||
954 wsource->id == snd_soc_dapm_mic ||
955 wsink->id == snd_soc_dapm_line ||
956 wsink->id == snd_soc_dapm_output)
959 if (wsource->id == snd_soc_dapm_output) {
960 if (wsink->id == snd_soc_dapm_spk ||
961 wsink->id == snd_soc_dapm_hp ||
962 wsink->id == snd_soc_dapm_line ||
963 wsink->id == snd_soc_dapm_input)
967 /* connect static paths */
968 if (control == NULL) {
969 list_add(&path->list, &codec->dapm_paths);
970 list_add(&path->list_sink, &wsink->sources);
971 list_add(&path->list_source, &wsource->sinks);
976 /* connect dynamic paths */
978 case snd_soc_dapm_adc:
979 case snd_soc_dapm_dac:
980 case snd_soc_dapm_pga:
981 case snd_soc_dapm_input:
982 case snd_soc_dapm_output:
983 case snd_soc_dapm_micbias:
984 case snd_soc_dapm_vmid:
985 case snd_soc_dapm_pre:
986 case snd_soc_dapm_post:
987 list_add(&path->list, &codec->dapm_paths);
988 list_add(&path->list_sink, &wsink->sources);
989 list_add(&path->list_source, &wsource->sinks);
992 case snd_soc_dapm_mux:
993 ret = dapm_connect_mux(codec, wsource, wsink, path, control,
994 &wsink->kcontrols[0]);
998 case snd_soc_dapm_switch:
999 case snd_soc_dapm_mixer:
1000 ret = dapm_connect_mixer(codec, wsource, wsink, path, control);
1004 case snd_soc_dapm_hp:
1005 case snd_soc_dapm_mic:
1006 case snd_soc_dapm_line:
1007 case snd_soc_dapm_spk:
1008 list_add(&path->list, &codec->dapm_paths);
1009 list_add(&path->list_sink, &wsink->sources);
1010 list_add(&path->list_source, &wsource->sinks);
1017 printk(KERN_WARNING "asoc: no dapm match for %s --> %s --> %s\n", source,
1024 * snd_soc_dapm_connect_input - connect dapm widgets
1025 * @codec: audio codec
1026 * @sink: name of target widget
1027 * @control: mixer control name
1028 * @source: name of source name
1030 * Connects 2 dapm widgets together via a named audio path. The sink is
1031 * the widget receiving the audio signal, whilst the source is the sender
1032 * of the audio signal.
1034 * This function has been deprecated in favour of snd_soc_dapm_add_routes().
1036 * Returns 0 for success else error.
1038 int snd_soc_dapm_connect_input(struct snd_soc_codec *codec, const char *sink,
1039 const char *control, const char *source)
1041 return snd_soc_dapm_add_route(codec, sink, control, source);
1043 EXPORT_SYMBOL_GPL(snd_soc_dapm_connect_input);
1046 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
1048 * @route: audio routes
1049 * @num: number of routes
1051 * Connects 2 dapm widgets together via a named audio path. The sink is
1052 * the widget receiving the audio signal, whilst the source is the sender
1053 * of the audio signal.
1055 * Returns 0 for success else error. On error all resources can be freed
1056 * with a call to snd_soc_card_free().
1058 int snd_soc_dapm_add_routes(struct snd_soc_codec *codec,
1059 const struct snd_soc_dapm_route *route, int num)
1063 for (i = 0; i < num; i++) {
1064 ret = snd_soc_dapm_add_route(codec, route->sink,
1065 route->control, route->source);
1067 printk(KERN_ERR "Failed to add route %s->%s\n",
1077 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
1080 * snd_soc_dapm_new_widgets - add new dapm widgets
1081 * @codec: audio codec
1083 * Checks the codec for any new dapm widgets and creates them if found.
1085 * Returns 0 for success.
1087 int snd_soc_dapm_new_widgets(struct snd_soc_codec *codec)
1089 struct snd_soc_dapm_widget *w;
1091 list_for_each_entry(w, &codec->dapm_widgets, list)
1097 case snd_soc_dapm_switch:
1098 case snd_soc_dapm_mixer:
1099 dapm_new_mixer(codec, w);
1101 case snd_soc_dapm_mux:
1102 dapm_new_mux(codec, w);
1104 case snd_soc_dapm_adc:
1105 case snd_soc_dapm_dac:
1106 case snd_soc_dapm_pga:
1107 dapm_new_pga(codec, w);
1109 case snd_soc_dapm_input:
1110 case snd_soc_dapm_output:
1111 case snd_soc_dapm_micbias:
1112 case snd_soc_dapm_spk:
1113 case snd_soc_dapm_hp:
1114 case snd_soc_dapm_mic:
1115 case snd_soc_dapm_line:
1116 case snd_soc_dapm_vmid:
1117 case snd_soc_dapm_pre:
1118 case snd_soc_dapm_post:
1124 dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
1127 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
1130 * snd_soc_dapm_get_volsw - dapm mixer get callback
1131 * @kcontrol: mixer control
1132 * @uinfo: control element information
1134 * Callback to get the value of a dapm mixer control.
1136 * Returns 0 for success.
1138 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
1139 struct snd_ctl_elem_value *ucontrol)
1141 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1142 struct soc_mixer_control *mc =
1143 (struct soc_mixer_control *)kcontrol->private_value;
1144 unsigned int reg = mc->reg;
1145 unsigned int shift = mc->shift;
1146 unsigned int rshift = mc->rshift;
1148 unsigned int invert = mc->invert;
1149 unsigned int mask = (1 << fls(max)) - 1;
1151 /* return the saved value if we are powered down */
1152 if (widget->id == snd_soc_dapm_pga && !widget->power) {
1153 ucontrol->value.integer.value[0] = widget->saved_value;
1157 ucontrol->value.integer.value[0] =
1158 (snd_soc_read(widget->codec, reg) >> shift) & mask;
1159 if (shift != rshift)
1160 ucontrol->value.integer.value[1] =
1161 (snd_soc_read(widget->codec, reg) >> rshift) & mask;
1163 ucontrol->value.integer.value[0] =
1164 max - ucontrol->value.integer.value[0];
1165 if (shift != rshift)
1166 ucontrol->value.integer.value[1] =
1167 max - ucontrol->value.integer.value[1];
1172 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
1175 * snd_soc_dapm_put_volsw - dapm mixer set callback
1176 * @kcontrol: mixer control
1177 * @uinfo: control element information
1179 * Callback to set the value of a dapm mixer control.
1181 * Returns 0 for success.
1183 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
1184 struct snd_ctl_elem_value *ucontrol)
1186 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1187 struct soc_mixer_control *mc =
1188 (struct soc_mixer_control *)kcontrol->private_value;
1189 unsigned int reg = mc->reg;
1190 unsigned int shift = mc->shift;
1191 unsigned int rshift = mc->rshift;
1193 unsigned int mask = (1 << fls(max)) - 1;
1194 unsigned int invert = mc->invert;
1195 unsigned short val, val2, val_mask;
1198 val = (ucontrol->value.integer.value[0] & mask);
1202 val_mask = mask << shift;
1204 if (shift != rshift) {
1205 val2 = (ucontrol->value.integer.value[1] & mask);
1208 val_mask |= mask << rshift;
1209 val |= val2 << rshift;
1212 mutex_lock(&widget->codec->mutex);
1213 widget->value = val;
1215 /* save volume value if the widget is powered down */
1216 if (widget->id == snd_soc_dapm_pga && !widget->power) {
1217 widget->saved_value = val;
1218 mutex_unlock(&widget->codec->mutex);
1222 dapm_mixer_update_power(widget, kcontrol, reg, val_mask, val, invert);
1223 if (widget->event) {
1224 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1225 ret = widget->event(widget, kcontrol,
1226 SND_SOC_DAPM_PRE_REG);
1232 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1233 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1234 ret = widget->event(widget, kcontrol,
1235 SND_SOC_DAPM_POST_REG);
1237 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1240 mutex_unlock(&widget->codec->mutex);
1243 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
1246 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
1247 * @kcontrol: mixer control
1248 * @uinfo: control element information
1250 * Callback to get the value of a dapm enumerated double mixer control.
1252 * Returns 0 for success.
1254 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
1255 struct snd_ctl_elem_value *ucontrol)
1257 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1258 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1259 unsigned short val, bitmask;
1261 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
1263 val = snd_soc_read(widget->codec, e->reg);
1264 ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
1265 if (e->shift_l != e->shift_r)
1266 ucontrol->value.enumerated.item[1] =
1267 (val >> e->shift_r) & (bitmask - 1);
1271 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
1274 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
1275 * @kcontrol: mixer control
1276 * @uinfo: control element information
1278 * Callback to set the value of a dapm enumerated double mixer control.
1280 * Returns 0 for success.
1282 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
1283 struct snd_ctl_elem_value *ucontrol)
1285 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1286 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1287 unsigned short val, mux;
1288 unsigned short mask, bitmask;
1291 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
1293 if (ucontrol->value.enumerated.item[0] > e->max - 1)
1295 mux = ucontrol->value.enumerated.item[0];
1296 val = mux << e->shift_l;
1297 mask = (bitmask - 1) << e->shift_l;
1298 if (e->shift_l != e->shift_r) {
1299 if (ucontrol->value.enumerated.item[1] > e->max - 1)
1301 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1302 mask |= (bitmask - 1) << e->shift_r;
1305 mutex_lock(&widget->codec->mutex);
1306 widget->value = val;
1307 dapm_mux_update_power(widget, kcontrol, mask, mux, e);
1308 if (widget->event) {
1309 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1310 ret = widget->event(widget,
1311 kcontrol, SND_SOC_DAPM_PRE_REG);
1315 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1316 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1317 ret = widget->event(widget,
1318 kcontrol, SND_SOC_DAPM_POST_REG);
1320 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1323 mutex_unlock(&widget->codec->mutex);
1326 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
1329 * snd_soc_dapm_new_control - create new dapm control
1330 * @codec: audio codec
1331 * @widget: widget template
1333 * Creates a new dapm control based upon the template.
1335 * Returns 0 for success else error.
1337 int snd_soc_dapm_new_control(struct snd_soc_codec *codec,
1338 const struct snd_soc_dapm_widget *widget)
1340 struct snd_soc_dapm_widget *w;
1342 if ((w = dapm_cnew_widget(widget)) == NULL)
1346 INIT_LIST_HEAD(&w->sources);
1347 INIT_LIST_HEAD(&w->sinks);
1348 INIT_LIST_HEAD(&w->list);
1349 list_add(&w->list, &codec->dapm_widgets);
1351 /* machine layer set ups unconnected pins and insertions */
1355 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
1358 * snd_soc_dapm_new_controls - create new dapm controls
1359 * @codec: audio codec
1360 * @widget: widget array
1361 * @num: number of widgets
1363 * Creates new DAPM controls based upon the templates.
1365 * Returns 0 for success else error.
1367 int snd_soc_dapm_new_controls(struct snd_soc_codec *codec,
1368 const struct snd_soc_dapm_widget *widget,
1373 for (i = 0; i < num; i++) {
1374 ret = snd_soc_dapm_new_control(codec, widget);
1381 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
1385 * snd_soc_dapm_stream_event - send a stream event to the dapm core
1386 * @codec: audio codec
1387 * @stream: stream name
1388 * @event: stream event
1390 * Sends a stream event to the dapm core. The core then makes any
1391 * necessary widget power changes.
1393 * Returns 0 for success else error.
1395 int snd_soc_dapm_stream_event(struct snd_soc_codec *codec,
1396 char *stream, int event)
1398 struct snd_soc_dapm_widget *w;
1403 mutex_lock(&codec->mutex);
1404 list_for_each_entry(w, &codec->dapm_widgets, list)
1408 pr_debug("widget %s\n %s stream %s event %d\n",
1409 w->name, w->sname, stream, event);
1410 if (strstr(w->sname, stream)) {
1412 case SND_SOC_DAPM_STREAM_START:
1415 case SND_SOC_DAPM_STREAM_STOP:
1418 case SND_SOC_DAPM_STREAM_SUSPEND:
1423 case SND_SOC_DAPM_STREAM_RESUME:
1429 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
1431 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
1436 mutex_unlock(&codec->mutex);
1438 dapm_power_widgets(codec, event);
1439 dump_dapm(codec, __func__);
1442 EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event);
1445 * snd_soc_dapm_set_bias_level - set the bias level for the system
1446 * @socdev: audio device
1447 * @level: level to configure
1449 * Configure the bias (power) levels for the SoC audio device.
1451 * Returns 0 for success else error.
1453 int snd_soc_dapm_set_bias_level(struct snd_soc_device *socdev,
1454 enum snd_soc_bias_level level)
1456 struct snd_soc_codec *codec = socdev->codec;
1457 struct snd_soc_machine *machine = socdev->machine;
1460 if (machine->set_bias_level)
1461 ret = machine->set_bias_level(machine, level);
1462 if (ret == 0 && codec->set_bias_level)
1463 ret = codec->set_bias_level(codec, level);
1469 * snd_soc_dapm_enable_pin - enable pin.
1470 * @snd_soc_codec: SoC codec
1473 * Enables input/output pin and it's parents or children widgets iff there is
1474 * a valid audio route and active audio stream.
1475 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
1476 * do any widget power switching.
1478 int snd_soc_dapm_enable_pin(struct snd_soc_codec *codec, char *pin)
1480 return snd_soc_dapm_set_pin(codec, pin, 1);
1482 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
1485 * snd_soc_dapm_disable_pin - disable pin.
1489 * Disables input/output pin and it's parents or children widgets.
1490 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
1491 * do any widget power switching.
1493 int snd_soc_dapm_disable_pin(struct snd_soc_codec *codec, char *pin)
1495 return snd_soc_dapm_set_pin(codec, pin, 0);
1497 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
1500 * snd_soc_dapm_get_pin_status - get audio pin status
1501 * @codec: audio codec
1502 * @pin: audio signal pin endpoint (or start point)
1504 * Get audio pin status - connected or disconnected.
1506 * Returns 1 for connected otherwise 0.
1508 int snd_soc_dapm_get_pin_status(struct snd_soc_codec *codec, char *pin)
1510 struct snd_soc_dapm_widget *w;
1512 list_for_each_entry(w, &codec->dapm_widgets, list) {
1513 if (!strcmp(w->name, pin))
1514 return w->connected;
1519 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
1522 * snd_soc_dapm_free - free dapm resources
1523 * @socdev: SoC device
1525 * Free all dapm widgets and resources.
1527 void snd_soc_dapm_free(struct snd_soc_device *socdev)
1529 struct snd_soc_codec *codec = socdev->codec;
1531 snd_soc_dapm_sys_remove(socdev->dev);
1532 dapm_free_widgets(codec);
1534 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
1536 /* Module information */
1537 MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com");
1538 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
1539 MODULE_LICENSE("GPL");