[ARM] Remove asm/hardware.h, use asm/arch/hardware.h instead
[linux-2.6/libata-dev.git] / sound / soc / soc-dapm.c
blob820347c9ae4bbc5d5281e981e94f0cd27d2e28ae
1 /*
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.
13 * Features:
14 * o Changes power status of internal codec blocks depending on the
15 * dynamic configuration of codec internal audio paths and active
16 * DAC's/ADC's.
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
21 * sinks, dacs, etc
22 * o Delayed powerdown of audio susbsystem to reduce pops between a quick
23 * device reopen.
25 * Todo:
26 * o DAPM power change sequencing - allow for configurable per
27 * codec sequences.
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>
37 #include <linux/pm.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>
47 /* debug */
48 #ifdef DEBUG
49 #define dump_dapm(codec, action) dbg_dump_dapm(codec, action)
50 #else
51 #define dump_dapm(codec, action)
52 #endif
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)
74 if (pop_time)
75 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
78 static void pop_dbg(const char *fmt, ...)
80 va_list args;
82 va_start(args, fmt);
84 if (pop_time) {
85 vprintk(fmt, args);
86 pop_wait();
89 va_end(args);
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)
103 switch (w->id) {
104 case snd_soc_dapm_switch:
105 case snd_soc_dapm_mixer: {
106 int val;
107 int reg = w->kcontrols[i].private_value & 0xff;
108 int shift = (w->kcontrols[i].private_value >> 8) & 0x0f;
109 int mask = (w->kcontrols[i].private_value >> 16) & 0xff;
110 int invert = (w->kcontrols[i].private_value >> 24) & 0x01;
112 val = snd_soc_read(w->codec, reg);
113 val = (val >> shift) & mask;
115 if ((invert && !val) || (!invert && val))
116 p->connect = 1;
117 else
118 p->connect = 0;
120 break;
121 case snd_soc_dapm_mux: {
122 struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value;
123 int val, item, bitmask;
125 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
127 val = snd_soc_read(w->codec, e->reg);
128 item = (val >> e->shift_l) & (bitmask - 1);
130 p->connect = 0;
131 for (i = 0; i < e->mask; i++) {
132 if (!(strcmp(p->name, e->texts[i])) && item == i)
133 p->connect = 1;
136 break;
137 /* does not effect routing - always connected */
138 case snd_soc_dapm_pga:
139 case snd_soc_dapm_output:
140 case snd_soc_dapm_adc:
141 case snd_soc_dapm_input:
142 case snd_soc_dapm_dac:
143 case snd_soc_dapm_micbias:
144 case snd_soc_dapm_vmid:
145 p->connect = 1;
146 break;
147 /* does effect routing - dynamically connected */
148 case snd_soc_dapm_hp:
149 case snd_soc_dapm_mic:
150 case snd_soc_dapm_spk:
151 case snd_soc_dapm_line:
152 case snd_soc_dapm_pre:
153 case snd_soc_dapm_post:
154 p->connect = 0;
155 break;
159 /* connect mux widget to it's interconnecting audio paths */
160 static int dapm_connect_mux(struct snd_soc_codec *codec,
161 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
162 struct snd_soc_dapm_path *path, const char *control_name,
163 const struct snd_kcontrol_new *kcontrol)
165 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
166 int i;
168 for (i = 0; i < e->mask; i++) {
169 if (!(strcmp(control_name, e->texts[i]))) {
170 list_add(&path->list, &codec->dapm_paths);
171 list_add(&path->list_sink, &dest->sources);
172 list_add(&path->list_source, &src->sinks);
173 path->name = (char*)e->texts[i];
174 dapm_set_path_status(dest, path, 0);
175 return 0;
179 return -ENODEV;
182 /* connect mixer widget to it's interconnecting audio paths */
183 static int dapm_connect_mixer(struct snd_soc_codec *codec,
184 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
185 struct snd_soc_dapm_path *path, const char *control_name)
187 int i;
189 /* search for mixer kcontrol */
190 for (i = 0; i < dest->num_kcontrols; i++) {
191 if (!strcmp(control_name, dest->kcontrols[i].name)) {
192 list_add(&path->list, &codec->dapm_paths);
193 list_add(&path->list_sink, &dest->sources);
194 list_add(&path->list_source, &src->sinks);
195 path->name = dest->kcontrols[i].name;
196 dapm_set_path_status(dest, path, i);
197 return 0;
200 return -ENODEV;
203 /* update dapm codec register bits */
204 static int dapm_update_bits(struct snd_soc_dapm_widget *widget)
206 int change, power;
207 unsigned short old, new;
208 struct snd_soc_codec *codec = widget->codec;
210 /* check for valid widgets */
211 if (widget->reg < 0 || widget->id == snd_soc_dapm_input ||
212 widget->id == snd_soc_dapm_output ||
213 widget->id == snd_soc_dapm_hp ||
214 widget->id == snd_soc_dapm_mic ||
215 widget->id == snd_soc_dapm_line ||
216 widget->id == snd_soc_dapm_spk)
217 return 0;
219 power = widget->power;
220 if (widget->invert)
221 power = (power ? 0:1);
223 old = snd_soc_read(codec, widget->reg);
224 new = (old & ~(0x1 << widget->shift)) | (power << widget->shift);
226 change = old != new;
227 if (change) {
228 pop_dbg("pop test %s : %s in %d ms\n", widget->name,
229 widget->power ? "on" : "off", pop_time);
230 snd_soc_write(codec, widget->reg, new);
231 pop_wait();
233 pr_debug("reg %x old %x new %x change %d\n", widget->reg,
234 old, new, change);
235 return change;
238 /* ramps the volume up or down to minimise pops before or after a
239 * DAPM power event */
240 static int dapm_set_pga(struct snd_soc_dapm_widget *widget, int power)
242 const struct snd_kcontrol_new *k = widget->kcontrols;
244 if (widget->muted && !power)
245 return 0;
246 if (!widget->muted && power)
247 return 0;
249 if (widget->num_kcontrols && k) {
250 int reg = k->private_value & 0xff;
251 int shift = (k->private_value >> 8) & 0x0f;
252 int mask = (k->private_value >> 16) & 0xff;
253 int invert = (k->private_value >> 24) & 0x01;
255 if (power) {
256 int i;
257 /* power up has happended, increase volume to last level */
258 if (invert) {
259 for (i = mask; i > widget->saved_value; i--)
260 snd_soc_update_bits(widget->codec, reg, mask, i);
261 } else {
262 for (i = 0; i < widget->saved_value; i++)
263 snd_soc_update_bits(widget->codec, reg, mask, i);
265 widget->muted = 0;
266 } else {
267 /* power down is about to occur, decrease volume to mute */
268 int val = snd_soc_read(widget->codec, reg);
269 int i = widget->saved_value = (val >> shift) & mask;
270 if (invert) {
271 for (; i < mask; i++)
272 snd_soc_update_bits(widget->codec, reg, mask, i);
273 } else {
274 for (; i > 0; i--)
275 snd_soc_update_bits(widget->codec, reg, mask, i);
277 widget->muted = 1;
280 return 0;
283 /* create new dapm mixer control */
284 static int dapm_new_mixer(struct snd_soc_codec *codec,
285 struct snd_soc_dapm_widget *w)
287 int i, ret = 0;
288 char name[32];
289 struct snd_soc_dapm_path *path;
291 /* add kcontrol */
292 for (i = 0; i < w->num_kcontrols; i++) {
294 /* match name */
295 list_for_each_entry(path, &w->sources, list_sink) {
297 /* mixer/mux paths name must match control name */
298 if (path->name != (char*)w->kcontrols[i].name)
299 continue;
301 /* add dapm control with long name */
302 snprintf(name, 32, "%s %s", w->name, w->kcontrols[i].name);
303 path->long_name = kstrdup (name, GFP_KERNEL);
304 if (path->long_name == NULL)
305 return -ENOMEM;
307 path->kcontrol = snd_soc_cnew(&w->kcontrols[i], w,
308 path->long_name);
309 ret = snd_ctl_add(codec->card, path->kcontrol);
310 if (ret < 0) {
311 printk(KERN_ERR "asoc: failed to add dapm kcontrol %s\n",
312 path->long_name);
313 kfree(path->long_name);
314 path->long_name = NULL;
315 return ret;
319 return ret;
322 /* create new dapm mux control */
323 static int dapm_new_mux(struct snd_soc_codec *codec,
324 struct snd_soc_dapm_widget *w)
326 struct snd_soc_dapm_path *path = NULL;
327 struct snd_kcontrol *kcontrol;
328 int ret = 0;
330 if (!w->num_kcontrols) {
331 printk(KERN_ERR "asoc: mux %s has no controls\n", w->name);
332 return -EINVAL;
335 kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
336 ret = snd_ctl_add(codec->card, kcontrol);
337 if (ret < 0)
338 goto err;
340 list_for_each_entry(path, &w->sources, list_sink)
341 path->kcontrol = kcontrol;
343 return ret;
345 err:
346 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
347 return ret;
350 /* create new dapm volume control */
351 static int dapm_new_pga(struct snd_soc_codec *codec,
352 struct snd_soc_dapm_widget *w)
354 struct snd_kcontrol *kcontrol;
355 int ret = 0;
357 if (!w->num_kcontrols)
358 return -EINVAL;
360 kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
361 ret = snd_ctl_add(codec->card, kcontrol);
362 if (ret < 0) {
363 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
364 return ret;
367 return ret;
370 /* reset 'walked' bit for each dapm path */
371 static inline void dapm_clear_walk(struct snd_soc_codec *codec)
373 struct snd_soc_dapm_path *p;
375 list_for_each_entry(p, &codec->dapm_paths, list)
376 p->walked = 0;
380 * Recursively check for a completed path to an active or physically connected
381 * output widget. Returns number of complete paths.
383 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget)
385 struct snd_soc_dapm_path *path;
386 int con = 0;
388 if (widget->id == snd_soc_dapm_adc && widget->active)
389 return 1;
391 if (widget->connected) {
392 /* connected pin ? */
393 if (widget->id == snd_soc_dapm_output && !widget->ext)
394 return 1;
396 /* connected jack or spk ? */
397 if (widget->id == snd_soc_dapm_hp || widget->id == snd_soc_dapm_spk ||
398 widget->id == snd_soc_dapm_line)
399 return 1;
402 list_for_each_entry(path, &widget->sinks, list_source) {
403 if (path->walked)
404 continue;
406 if (path->sink && path->connect) {
407 path->walked = 1;
408 con += is_connected_output_ep(path->sink);
412 return con;
416 * Recursively check for a completed path to an active or physically connected
417 * input widget. Returns number of complete paths.
419 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget)
421 struct snd_soc_dapm_path *path;
422 int con = 0;
424 /* active stream ? */
425 if (widget->id == snd_soc_dapm_dac && widget->active)
426 return 1;
428 if (widget->connected) {
429 /* connected pin ? */
430 if (widget->id == snd_soc_dapm_input && !widget->ext)
431 return 1;
433 /* connected VMID/Bias for lower pops */
434 if (widget->id == snd_soc_dapm_vmid)
435 return 1;
437 /* connected jack ? */
438 if (widget->id == snd_soc_dapm_mic || widget->id == snd_soc_dapm_line)
439 return 1;
442 list_for_each_entry(path, &widget->sources, list_sink) {
443 if (path->walked)
444 continue;
446 if (path->source && path->connect) {
447 path->walked = 1;
448 con += is_connected_input_ep(path->source);
452 return con;
456 * Handler for generic register modifier widget.
458 int dapm_reg_event(struct snd_soc_dapm_widget *w,
459 struct snd_kcontrol *kcontrol, int event)
461 unsigned int val;
463 if (SND_SOC_DAPM_EVENT_ON(event))
464 val = w->on_val;
465 else
466 val = w->off_val;
468 snd_soc_update_bits(w->codec, -(w->reg + 1),
469 w->mask << w->shift, val << w->shift);
471 return 0;
475 * Scan each dapm widget for complete audio path.
476 * A complete path is a route that has valid endpoints i.e.:-
478 * o DAC to output pin.
479 * o Input Pin to ADC.
480 * o Input pin to Output pin (bypass, sidetone)
481 * o DAC to ADC (loopback).
483 static int dapm_power_widgets(struct snd_soc_codec *codec, int event)
485 struct snd_soc_dapm_widget *w;
486 int in, out, i, c = 1, *seq = NULL, ret = 0, power_change, power;
488 /* do we have a sequenced stream event */
489 if (event == SND_SOC_DAPM_STREAM_START) {
490 c = ARRAY_SIZE(dapm_up_seq);
491 seq = dapm_up_seq;
492 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
493 c = ARRAY_SIZE(dapm_down_seq);
494 seq = dapm_down_seq;
497 for(i = 0; i < c; i++) {
498 list_for_each_entry(w, &codec->dapm_widgets, list) {
500 /* is widget in stream order */
501 if (seq && seq[i] && w->id != seq[i])
502 continue;
504 /* vmid - no action */
505 if (w->id == snd_soc_dapm_vmid)
506 continue;
508 /* active ADC */
509 if (w->id == snd_soc_dapm_adc && w->active) {
510 in = is_connected_input_ep(w);
511 dapm_clear_walk(w->codec);
512 w->power = (in != 0) ? 1 : 0;
513 dapm_update_bits(w);
514 continue;
517 /* active DAC */
518 if (w->id == snd_soc_dapm_dac && w->active) {
519 out = is_connected_output_ep(w);
520 dapm_clear_walk(w->codec);
521 w->power = (out != 0) ? 1 : 0;
522 dapm_update_bits(w);
523 continue;
526 /* pre and post event widgets */
527 if (w->id == snd_soc_dapm_pre) {
528 if (!w->event)
529 continue;
531 if (event == SND_SOC_DAPM_STREAM_START) {
532 ret = w->event(w,
533 NULL, SND_SOC_DAPM_PRE_PMU);
534 if (ret < 0)
535 return ret;
536 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
537 ret = w->event(w,
538 NULL, SND_SOC_DAPM_PRE_PMD);
539 if (ret < 0)
540 return ret;
542 continue;
544 if (w->id == snd_soc_dapm_post) {
545 if (!w->event)
546 continue;
548 if (event == SND_SOC_DAPM_STREAM_START) {
549 ret = w->event(w,
550 NULL, SND_SOC_DAPM_POST_PMU);
551 if (ret < 0)
552 return ret;
553 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
554 ret = w->event(w,
555 NULL, SND_SOC_DAPM_POST_PMD);
556 if (ret < 0)
557 return ret;
559 continue;
562 /* all other widgets */
563 in = is_connected_input_ep(w);
564 dapm_clear_walk(w->codec);
565 out = is_connected_output_ep(w);
566 dapm_clear_walk(w->codec);
567 power = (out != 0 && in != 0) ? 1 : 0;
568 power_change = (w->power == power) ? 0: 1;
569 w->power = power;
571 if (!power_change)
572 continue;
574 /* call any power change event handlers */
575 if (w->event)
576 pr_debug("power %s event for %s flags %x\n",
577 w->power ? "on" : "off",
578 w->name, w->event_flags);
580 /* power up pre event */
581 if (power && w->event &&
582 (w->event_flags & SND_SOC_DAPM_PRE_PMU)) {
583 ret = w->event(w, NULL, SND_SOC_DAPM_PRE_PMU);
584 if (ret < 0)
585 return ret;
588 /* power down pre event */
589 if (!power && w->event &&
590 (w->event_flags & SND_SOC_DAPM_PRE_PMD)) {
591 ret = w->event(w, NULL, SND_SOC_DAPM_PRE_PMD);
592 if (ret < 0)
593 return ret;
596 /* Lower PGA volume to reduce pops */
597 if (w->id == snd_soc_dapm_pga && !power)
598 dapm_set_pga(w, power);
600 dapm_update_bits(w);
602 /* Raise PGA volume to reduce pops */
603 if (w->id == snd_soc_dapm_pga && power)
604 dapm_set_pga(w, power);
606 /* power up post event */
607 if (power && w->event &&
608 (w->event_flags & SND_SOC_DAPM_POST_PMU)) {
609 ret = w->event(w,
610 NULL, SND_SOC_DAPM_POST_PMU);
611 if (ret < 0)
612 return ret;
615 /* power down post event */
616 if (!power && w->event &&
617 (w->event_flags & SND_SOC_DAPM_POST_PMD)) {
618 ret = w->event(w, NULL, SND_SOC_DAPM_POST_PMD);
619 if (ret < 0)
620 return ret;
625 return ret;
628 #ifdef DEBUG
629 static void dbg_dump_dapm(struct snd_soc_codec* codec, const char *action)
631 struct snd_soc_dapm_widget *w;
632 struct snd_soc_dapm_path *p = NULL;
633 int in, out;
635 printk("DAPM %s %s\n", codec->name, action);
637 list_for_each_entry(w, &codec->dapm_widgets, list) {
639 /* only display widgets that effect routing */
640 switch (w->id) {
641 case snd_soc_dapm_pre:
642 case snd_soc_dapm_post:
643 case snd_soc_dapm_vmid:
644 continue;
645 case snd_soc_dapm_mux:
646 case snd_soc_dapm_output:
647 case snd_soc_dapm_input:
648 case snd_soc_dapm_switch:
649 case snd_soc_dapm_hp:
650 case snd_soc_dapm_mic:
651 case snd_soc_dapm_spk:
652 case snd_soc_dapm_line:
653 case snd_soc_dapm_micbias:
654 case snd_soc_dapm_dac:
655 case snd_soc_dapm_adc:
656 case snd_soc_dapm_pga:
657 case snd_soc_dapm_mixer:
658 if (w->name) {
659 in = is_connected_input_ep(w);
660 dapm_clear_walk(w->codec);
661 out = is_connected_output_ep(w);
662 dapm_clear_walk(w->codec);
663 printk("%s: %s in %d out %d\n", w->name,
664 w->power ? "On":"Off",in, out);
666 list_for_each_entry(p, &w->sources, list_sink) {
667 if (p->connect)
668 printk(" in %s %s\n", p->name ? p->name : "static",
669 p->source->name);
671 list_for_each_entry(p, &w->sinks, list_source) {
672 if (p->connect)
673 printk(" out %s %s\n", p->name ? p->name : "static",
674 p->sink->name);
677 break;
681 #endif
683 /* test and update the power status of a mux widget */
684 static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
685 struct snd_kcontrol *kcontrol, int mask,
686 int val, struct soc_enum* e)
688 struct snd_soc_dapm_path *path;
689 int found = 0;
691 if (widget->id != snd_soc_dapm_mux)
692 return -ENODEV;
694 if (!snd_soc_test_bits(widget->codec, e->reg, mask, val))
695 return 0;
697 /* find dapm widget path assoc with kcontrol */
698 list_for_each_entry(path, &widget->codec->dapm_paths, list) {
699 if (path->kcontrol != kcontrol)
700 continue;
702 if (!path->name || ! e->texts[val])
703 continue;
705 found = 1;
706 /* we now need to match the string in the enum to the path */
707 if (!(strcmp(path->name, e->texts[val])))
708 path->connect = 1; /* new connection */
709 else
710 path->connect = 0; /* old connection must be powered down */
713 if (found) {
714 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
715 dump_dapm(widget->codec, "mux power update");
718 return 0;
721 /* test and update the power status of a mixer or switch widget */
722 static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
723 struct snd_kcontrol *kcontrol, int reg,
724 int val_mask, int val, int invert)
726 struct snd_soc_dapm_path *path;
727 int found = 0;
729 if (widget->id != snd_soc_dapm_mixer &&
730 widget->id != snd_soc_dapm_switch)
731 return -ENODEV;
733 if (!snd_soc_test_bits(widget->codec, reg, val_mask, val))
734 return 0;
736 /* find dapm widget path assoc with kcontrol */
737 list_for_each_entry(path, &widget->codec->dapm_paths, list) {
738 if (path->kcontrol != kcontrol)
739 continue;
741 /* found, now check type */
742 found = 1;
743 if (val)
744 /* new connection */
745 path->connect = invert ? 0:1;
746 else
747 /* old connection must be powered down */
748 path->connect = invert ? 1:0;
749 break;
752 if (found) {
753 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
754 dump_dapm(widget->codec, "mixer power update");
757 return 0;
760 /* show dapm widget status in sys fs */
761 static ssize_t dapm_widget_show(struct device *dev,
762 struct device_attribute *attr, char *buf)
764 struct snd_soc_device *devdata = dev_get_drvdata(dev);
765 struct snd_soc_codec *codec = devdata->codec;
766 struct snd_soc_dapm_widget *w;
767 int count = 0;
768 char *state = "not set";
770 list_for_each_entry(w, &codec->dapm_widgets, list) {
772 /* only display widgets that burnm power */
773 switch (w->id) {
774 case snd_soc_dapm_hp:
775 case snd_soc_dapm_mic:
776 case snd_soc_dapm_spk:
777 case snd_soc_dapm_line:
778 case snd_soc_dapm_micbias:
779 case snd_soc_dapm_dac:
780 case snd_soc_dapm_adc:
781 case snd_soc_dapm_pga:
782 case snd_soc_dapm_mixer:
783 if (w->name)
784 count += sprintf(buf + count, "%s: %s\n",
785 w->name, w->power ? "On":"Off");
786 break;
787 default:
788 break;
792 switch (codec->bias_level) {
793 case SND_SOC_BIAS_ON:
794 state = "On";
795 break;
796 case SND_SOC_BIAS_PREPARE:
797 state = "Prepare";
798 break;
799 case SND_SOC_BIAS_STANDBY:
800 state = "Standby";
801 break;
802 case SND_SOC_BIAS_OFF:
803 state = "Off";
804 break;
806 count += sprintf(buf + count, "PM State: %s\n", state);
808 return count;
811 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
813 /* pop/click delay times */
814 static ssize_t dapm_pop_time_show(struct device *dev,
815 struct device_attribute *attr, char *buf)
817 return sprintf(buf, "%d\n", pop_time);
820 static ssize_t dapm_pop_time_store(struct device *dev,
821 struct device_attribute *attr,
822 const char *buf, size_t count)
825 unsigned long val;
827 if (strict_strtoul(buf, 10, &val) >= 0)
828 pop_time = val;
829 else
830 printk(KERN_ERR "Unable to parse pop_time setting\n");
832 return count;
835 static DEVICE_ATTR(dapm_pop_time, 0744, dapm_pop_time_show,
836 dapm_pop_time_store);
838 int snd_soc_dapm_sys_add(struct device *dev)
840 int ret = 0;
842 if (dapm_status) {
843 ret = device_create_file(dev, &dev_attr_dapm_widget);
845 if (ret == 0)
846 ret = device_create_file(dev, &dev_attr_dapm_pop_time);
849 return ret;
852 static void snd_soc_dapm_sys_remove(struct device *dev)
854 if (dapm_status) {
855 device_remove_file(dev, &dev_attr_dapm_pop_time);
856 device_remove_file(dev, &dev_attr_dapm_widget);
860 /* free all dapm widgets and resources */
861 static void dapm_free_widgets(struct snd_soc_codec *codec)
863 struct snd_soc_dapm_widget *w, *next_w;
864 struct snd_soc_dapm_path *p, *next_p;
866 list_for_each_entry_safe(w, next_w, &codec->dapm_widgets, list) {
867 list_del(&w->list);
868 kfree(w);
871 list_for_each_entry_safe(p, next_p, &codec->dapm_paths, list) {
872 list_del(&p->list);
873 kfree(p->long_name);
874 kfree(p);
878 static int snd_soc_dapm_set_pin(struct snd_soc_codec *codec,
879 char *pin, int status)
881 struct snd_soc_dapm_widget *w;
883 list_for_each_entry(w, &codec->dapm_widgets, list) {
884 if (!strcmp(w->name, pin)) {
885 pr_debug("dapm: %s: pin %s\n", codec->name, pin);
886 w->connected = status;
887 return 0;
891 pr_err("dapm: %s: configuring unknown pin %s\n", codec->name, pin);
892 return -EINVAL;
896 * snd_soc_dapm_sync - scan and power dapm paths
897 * @codec: audio codec
899 * Walks all dapm audio paths and powers widgets according to their
900 * stream or path usage.
902 * Returns 0 for success.
904 int snd_soc_dapm_sync(struct snd_soc_codec *codec)
906 int ret = dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
907 dump_dapm(codec, "sync");
908 return ret;
910 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
912 static int snd_soc_dapm_add_route(struct snd_soc_codec *codec,
913 const char *sink, const char *control, const char *source)
915 struct snd_soc_dapm_path *path;
916 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
917 int ret = 0;
919 /* find src and dest widgets */
920 list_for_each_entry(w, &codec->dapm_widgets, list) {
922 if (!wsink && !(strcmp(w->name, sink))) {
923 wsink = w;
924 continue;
926 if (!wsource && !(strcmp(w->name, source))) {
927 wsource = w;
931 if (wsource == NULL || wsink == NULL)
932 return -ENODEV;
934 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
935 if (!path)
936 return -ENOMEM;
938 path->source = wsource;
939 path->sink = wsink;
940 INIT_LIST_HEAD(&path->list);
941 INIT_LIST_HEAD(&path->list_source);
942 INIT_LIST_HEAD(&path->list_sink);
944 /* check for external widgets */
945 if (wsink->id == snd_soc_dapm_input) {
946 if (wsource->id == snd_soc_dapm_micbias ||
947 wsource->id == snd_soc_dapm_mic ||
948 wsink->id == snd_soc_dapm_line ||
949 wsink->id == snd_soc_dapm_output)
950 wsink->ext = 1;
952 if (wsource->id == snd_soc_dapm_output) {
953 if (wsink->id == snd_soc_dapm_spk ||
954 wsink->id == snd_soc_dapm_hp ||
955 wsink->id == snd_soc_dapm_line ||
956 wsink->id == snd_soc_dapm_input)
957 wsource->ext = 1;
960 /* connect static paths */
961 if (control == NULL) {
962 list_add(&path->list, &codec->dapm_paths);
963 list_add(&path->list_sink, &wsink->sources);
964 list_add(&path->list_source, &wsource->sinks);
965 path->connect = 1;
966 return 0;
969 /* connect dynamic paths */
970 switch(wsink->id) {
971 case snd_soc_dapm_adc:
972 case snd_soc_dapm_dac:
973 case snd_soc_dapm_pga:
974 case snd_soc_dapm_input:
975 case snd_soc_dapm_output:
976 case snd_soc_dapm_micbias:
977 case snd_soc_dapm_vmid:
978 case snd_soc_dapm_pre:
979 case snd_soc_dapm_post:
980 list_add(&path->list, &codec->dapm_paths);
981 list_add(&path->list_sink, &wsink->sources);
982 list_add(&path->list_source, &wsource->sinks);
983 path->connect = 1;
984 return 0;
985 case snd_soc_dapm_mux:
986 ret = dapm_connect_mux(codec, wsource, wsink, path, control,
987 &wsink->kcontrols[0]);
988 if (ret != 0)
989 goto err;
990 break;
991 case snd_soc_dapm_switch:
992 case snd_soc_dapm_mixer:
993 ret = dapm_connect_mixer(codec, wsource, wsink, path, control);
994 if (ret != 0)
995 goto err;
996 break;
997 case snd_soc_dapm_hp:
998 case snd_soc_dapm_mic:
999 case snd_soc_dapm_line:
1000 case snd_soc_dapm_spk:
1001 list_add(&path->list, &codec->dapm_paths);
1002 list_add(&path->list_sink, &wsink->sources);
1003 list_add(&path->list_source, &wsource->sinks);
1004 path->connect = 0;
1005 return 0;
1007 return 0;
1009 err:
1010 printk(KERN_WARNING "asoc: no dapm match for %s --> %s --> %s\n", source,
1011 control, sink);
1012 kfree(path);
1013 return ret;
1017 * snd_soc_dapm_connect_input - connect dapm widgets
1018 * @codec: audio codec
1019 * @sink: name of target widget
1020 * @control: mixer control name
1021 * @source: name of source name
1023 * Connects 2 dapm widgets together via a named audio path. The sink is
1024 * the widget receiving the audio signal, whilst the source is the sender
1025 * of the audio signal.
1027 * This function has been deprecated in favour of snd_soc_dapm_add_routes().
1029 * Returns 0 for success else error.
1031 int snd_soc_dapm_connect_input(struct snd_soc_codec *codec, const char *sink,
1032 const char *control, const char *source)
1034 return snd_soc_dapm_add_route(codec, sink, control, source);
1036 EXPORT_SYMBOL_GPL(snd_soc_dapm_connect_input);
1039 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
1040 * @codec: codec
1041 * @route: audio routes
1042 * @num: number of routes
1044 * Connects 2 dapm widgets together via a named audio path. The sink is
1045 * the widget receiving the audio signal, whilst the source is the sender
1046 * of the audio signal.
1048 * Returns 0 for success else error. On error all resources can be freed
1049 * with a call to snd_soc_card_free().
1051 int snd_soc_dapm_add_routes(struct snd_soc_codec *codec,
1052 const struct snd_soc_dapm_route *route, int num)
1054 int i, ret;
1056 for (i = 0; i < num; i++) {
1057 ret = snd_soc_dapm_add_route(codec, route->sink,
1058 route->control, route->source);
1059 if (ret < 0) {
1060 printk(KERN_ERR "Failed to add route %s->%s\n",
1061 route->source,
1062 route->sink);
1063 return ret;
1065 route++;
1068 return 0;
1070 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
1073 * snd_soc_dapm_new_widgets - add new dapm widgets
1074 * @codec: audio codec
1076 * Checks the codec for any new dapm widgets and creates them if found.
1078 * Returns 0 for success.
1080 int snd_soc_dapm_new_widgets(struct snd_soc_codec *codec)
1082 struct snd_soc_dapm_widget *w;
1084 list_for_each_entry(w, &codec->dapm_widgets, list)
1086 if (w->new)
1087 continue;
1089 switch(w->id) {
1090 case snd_soc_dapm_switch:
1091 case snd_soc_dapm_mixer:
1092 dapm_new_mixer(codec, w);
1093 break;
1094 case snd_soc_dapm_mux:
1095 dapm_new_mux(codec, w);
1096 break;
1097 case snd_soc_dapm_adc:
1098 case snd_soc_dapm_dac:
1099 case snd_soc_dapm_pga:
1100 dapm_new_pga(codec, w);
1101 break;
1102 case snd_soc_dapm_input:
1103 case snd_soc_dapm_output:
1104 case snd_soc_dapm_micbias:
1105 case snd_soc_dapm_spk:
1106 case snd_soc_dapm_hp:
1107 case snd_soc_dapm_mic:
1108 case snd_soc_dapm_line:
1109 case snd_soc_dapm_vmid:
1110 case snd_soc_dapm_pre:
1111 case snd_soc_dapm_post:
1112 break;
1114 w->new = 1;
1117 dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
1118 return 0;
1120 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
1123 * snd_soc_dapm_get_volsw - dapm mixer get callback
1124 * @kcontrol: mixer control
1125 * @uinfo: control element information
1127 * Callback to get the value of a dapm mixer control.
1129 * Returns 0 for success.
1131 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
1132 struct snd_ctl_elem_value *ucontrol)
1134 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1135 int reg = kcontrol->private_value & 0xff;
1136 int shift = (kcontrol->private_value >> 8) & 0x0f;
1137 int rshift = (kcontrol->private_value >> 12) & 0x0f;
1138 int max = (kcontrol->private_value >> 16) & 0xff;
1139 int invert = (kcontrol->private_value >> 24) & 0x01;
1140 int mask = (1 << fls(max)) - 1;
1142 /* return the saved value if we are powered down */
1143 if (widget->id == snd_soc_dapm_pga && !widget->power) {
1144 ucontrol->value.integer.value[0] = widget->saved_value;
1145 return 0;
1148 ucontrol->value.integer.value[0] =
1149 (snd_soc_read(widget->codec, reg) >> shift) & mask;
1150 if (shift != rshift)
1151 ucontrol->value.integer.value[1] =
1152 (snd_soc_read(widget->codec, reg) >> rshift) & mask;
1153 if (invert) {
1154 ucontrol->value.integer.value[0] =
1155 max - ucontrol->value.integer.value[0];
1156 if (shift != rshift)
1157 ucontrol->value.integer.value[1] =
1158 max - ucontrol->value.integer.value[1];
1161 return 0;
1163 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
1166 * snd_soc_dapm_put_volsw - dapm mixer set callback
1167 * @kcontrol: mixer control
1168 * @uinfo: control element information
1170 * Callback to set the value of a dapm mixer control.
1172 * Returns 0 for success.
1174 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
1175 struct snd_ctl_elem_value *ucontrol)
1177 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1178 int reg = kcontrol->private_value & 0xff;
1179 int shift = (kcontrol->private_value >> 8) & 0x0f;
1180 int rshift = (kcontrol->private_value >> 12) & 0x0f;
1181 int max = (kcontrol->private_value >> 16) & 0xff;
1182 int mask = (1 << fls(max)) - 1;
1183 int invert = (kcontrol->private_value >> 24) & 0x01;
1184 unsigned short val, val2, val_mask;
1185 int ret;
1187 val = (ucontrol->value.integer.value[0] & mask);
1189 if (invert)
1190 val = max - val;
1191 val_mask = mask << shift;
1192 val = val << shift;
1193 if (shift != rshift) {
1194 val2 = (ucontrol->value.integer.value[1] & mask);
1195 if (invert)
1196 val2 = max - val2;
1197 val_mask |= mask << rshift;
1198 val |= val2 << rshift;
1201 mutex_lock(&widget->codec->mutex);
1202 widget->value = val;
1204 /* save volume value if the widget is powered down */
1205 if (widget->id == snd_soc_dapm_pga && !widget->power) {
1206 widget->saved_value = val;
1207 mutex_unlock(&widget->codec->mutex);
1208 return 1;
1211 dapm_mixer_update_power(widget, kcontrol, reg, val_mask, val, invert);
1212 if (widget->event) {
1213 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1214 ret = widget->event(widget, kcontrol,
1215 SND_SOC_DAPM_PRE_REG);
1216 if (ret < 0) {
1217 ret = 1;
1218 goto out;
1221 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1222 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1223 ret = widget->event(widget, kcontrol,
1224 SND_SOC_DAPM_POST_REG);
1225 } else
1226 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1228 out:
1229 mutex_unlock(&widget->codec->mutex);
1230 return ret;
1232 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
1235 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
1236 * @kcontrol: mixer control
1237 * @uinfo: control element information
1239 * Callback to get the value of a dapm enumerated double mixer control.
1241 * Returns 0 for success.
1243 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
1244 struct snd_ctl_elem_value *ucontrol)
1246 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1247 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1248 unsigned short val, bitmask;
1250 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1252 val = snd_soc_read(widget->codec, e->reg);
1253 ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
1254 if (e->shift_l != e->shift_r)
1255 ucontrol->value.enumerated.item[1] =
1256 (val >> e->shift_r) & (bitmask - 1);
1258 return 0;
1260 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
1263 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
1264 * @kcontrol: mixer control
1265 * @uinfo: control element information
1267 * Callback to set the value of a dapm enumerated double mixer control.
1269 * Returns 0 for success.
1271 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
1272 struct snd_ctl_elem_value *ucontrol)
1274 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1275 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1276 unsigned short val, mux;
1277 unsigned short mask, bitmask;
1278 int ret = 0;
1280 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1282 if (ucontrol->value.enumerated.item[0] > e->mask - 1)
1283 return -EINVAL;
1284 mux = ucontrol->value.enumerated.item[0];
1285 val = mux << e->shift_l;
1286 mask = (bitmask - 1) << e->shift_l;
1287 if (e->shift_l != e->shift_r) {
1288 if (ucontrol->value.enumerated.item[1] > e->mask - 1)
1289 return -EINVAL;
1290 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1291 mask |= (bitmask - 1) << e->shift_r;
1294 mutex_lock(&widget->codec->mutex);
1295 widget->value = val;
1296 dapm_mux_update_power(widget, kcontrol, mask, mux, e);
1297 if (widget->event) {
1298 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1299 ret = widget->event(widget,
1300 kcontrol, SND_SOC_DAPM_PRE_REG);
1301 if (ret < 0)
1302 goto out;
1304 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1305 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1306 ret = widget->event(widget,
1307 kcontrol, SND_SOC_DAPM_POST_REG);
1308 } else
1309 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1311 out:
1312 mutex_unlock(&widget->codec->mutex);
1313 return ret;
1315 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
1318 * snd_soc_dapm_new_control - create new dapm control
1319 * @codec: audio codec
1320 * @widget: widget template
1322 * Creates a new dapm control based upon the template.
1324 * Returns 0 for success else error.
1326 int snd_soc_dapm_new_control(struct snd_soc_codec *codec,
1327 const struct snd_soc_dapm_widget *widget)
1329 struct snd_soc_dapm_widget *w;
1331 if ((w = dapm_cnew_widget(widget)) == NULL)
1332 return -ENOMEM;
1334 w->codec = codec;
1335 INIT_LIST_HEAD(&w->sources);
1336 INIT_LIST_HEAD(&w->sinks);
1337 INIT_LIST_HEAD(&w->list);
1338 list_add(&w->list, &codec->dapm_widgets);
1340 /* machine layer set ups unconnected pins and insertions */
1341 w->connected = 1;
1342 return 0;
1344 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
1347 * snd_soc_dapm_new_controls - create new dapm controls
1348 * @codec: audio codec
1349 * @widget: widget array
1350 * @num: number of widgets
1352 * Creates new DAPM controls based upon the templates.
1354 * Returns 0 for success else error.
1356 int snd_soc_dapm_new_controls(struct snd_soc_codec *codec,
1357 const struct snd_soc_dapm_widget *widget,
1358 int num)
1360 int i, ret;
1362 for (i = 0; i < num; i++) {
1363 ret = snd_soc_dapm_new_control(codec, widget);
1364 if (ret < 0)
1365 return ret;
1366 widget++;
1368 return 0;
1370 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
1374 * snd_soc_dapm_stream_event - send a stream event to the dapm core
1375 * @codec: audio codec
1376 * @stream: stream name
1377 * @event: stream event
1379 * Sends a stream event to the dapm core. The core then makes any
1380 * necessary widget power changes.
1382 * Returns 0 for success else error.
1384 int snd_soc_dapm_stream_event(struct snd_soc_codec *codec,
1385 char *stream, int event)
1387 struct snd_soc_dapm_widget *w;
1389 if (stream == NULL)
1390 return 0;
1392 mutex_lock(&codec->mutex);
1393 list_for_each_entry(w, &codec->dapm_widgets, list)
1395 if (!w->sname)
1396 continue;
1397 pr_debug("widget %s\n %s stream %s event %d\n",
1398 w->name, w->sname, stream, event);
1399 if (strstr(w->sname, stream)) {
1400 switch(event) {
1401 case SND_SOC_DAPM_STREAM_START:
1402 w->active = 1;
1403 break;
1404 case SND_SOC_DAPM_STREAM_STOP:
1405 w->active = 0;
1406 break;
1407 case SND_SOC_DAPM_STREAM_SUSPEND:
1408 if (w->active)
1409 w->suspend = 1;
1410 w->active = 0;
1411 break;
1412 case SND_SOC_DAPM_STREAM_RESUME:
1413 if (w->suspend) {
1414 w->active = 1;
1415 w->suspend = 0;
1417 break;
1418 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
1419 break;
1420 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
1421 break;
1425 mutex_unlock(&codec->mutex);
1427 dapm_power_widgets(codec, event);
1428 dump_dapm(codec, __func__);
1429 return 0;
1431 EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event);
1434 * snd_soc_dapm_set_bias_level - set the bias level for the system
1435 * @socdev: audio device
1436 * @level: level to configure
1438 * Configure the bias (power) levels for the SoC audio device.
1440 * Returns 0 for success else error.
1442 int snd_soc_dapm_set_bias_level(struct snd_soc_device *socdev,
1443 enum snd_soc_bias_level level)
1445 struct snd_soc_codec *codec = socdev->codec;
1446 struct snd_soc_machine *machine = socdev->machine;
1447 int ret = 0;
1449 if (machine->set_bias_level)
1450 ret = machine->set_bias_level(machine, level);
1451 if (ret == 0 && codec->set_bias_level)
1452 ret = codec->set_bias_level(codec, level);
1454 return ret;
1458 * snd_soc_dapm_enable_pin - enable pin.
1459 * @snd_soc_codec: SoC codec
1460 * @pin: pin name
1462 * Enables input/output pin and it's parents or children widgets iff there is
1463 * a valid audio route and active audio stream.
1464 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
1465 * do any widget power switching.
1467 int snd_soc_dapm_enable_pin(struct snd_soc_codec *codec, char *pin)
1469 return snd_soc_dapm_set_pin(codec, pin, 1);
1471 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
1474 * snd_soc_dapm_disable_pin - disable pin.
1475 * @codec: SoC codec
1476 * @pin: pin name
1478 * Disables input/output pin and it's parents or children widgets.
1479 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
1480 * do any widget power switching.
1482 int snd_soc_dapm_disable_pin(struct snd_soc_codec *codec, char *pin)
1484 return snd_soc_dapm_set_pin(codec, pin, 0);
1486 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
1489 * snd_soc_dapm_get_pin_status - get audio pin status
1490 * @codec: audio codec
1491 * @pin: audio signal pin endpoint (or start point)
1493 * Get audio pin status - connected or disconnected.
1495 * Returns 1 for connected otherwise 0.
1497 int snd_soc_dapm_get_pin_status(struct snd_soc_codec *codec, char *pin)
1499 struct snd_soc_dapm_widget *w;
1501 list_for_each_entry(w, &codec->dapm_widgets, list) {
1502 if (!strcmp(w->name, pin))
1503 return w->connected;
1506 return 0;
1508 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
1511 * snd_soc_dapm_free - free dapm resources
1512 * @socdev: SoC device
1514 * Free all dapm widgets and resources.
1516 void snd_soc_dapm_free(struct snd_soc_device *socdev)
1518 struct snd_soc_codec *codec = socdev->codec;
1520 snd_soc_dapm_sys_remove(socdev->dev);
1521 dapm_free_widgets(codec);
1523 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
1525 /* Module information */
1526 MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com");
1527 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
1528 MODULE_LICENSE("GPL");