]> git.karo-electronics.de Git - mv-sheeva.git/blob
2536382
[mv-sheeva.git] /
1 /*
2  * soc-dapm.c  --  ALSA SoC Dynamic Audio Power Management
3  *
4  * Copyright 2005 Wolfson Microelectronics PLC.
5  * Author: Liam Girdwood
6  *         liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com
7  *
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.
12  *
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.
24  *
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.
31  */
32
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>
46
47 /* debug */
48 #define DAPM_DEBUG 0
49 #if DAPM_DEBUG
50 #define dump_dapm(codec, action) dbg_dump_dapm(codec, action)
51 #define dbg(format, arg...) printk(format, ## arg)
52 #else
53 #define dump_dapm(codec, action)
54 #define dbg(format, arg...)
55 #endif
56
57 #define POP_DEBUG 0
58 #if POP_DEBUG
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)
62 #else
63 #define pop_dbg(format, arg...)
64 #define pop_wait(time)
65 #endif
66
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
72 };
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
77 };
78
79 static int dapm_status = 1;
80 module_param(dapm_status, int, 0);
81 MODULE_PARM_DESC(dapm_status, "enable DPM sysfs entries");
82
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)
86 {
87         return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
88 }
89
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)
93 {
94         switch (w->id) {
95         case snd_soc_dapm_switch:
96         case snd_soc_dapm_mixer: {
97                 int val;
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;
102
103                 val = snd_soc_read(w->codec, reg);
104                 val = (val >> shift) & mask;
105
106                 if ((invert && !val) || (!invert && val))
107                         p->connect = 1;
108                 else
109                         p->connect = 0;
110         }
111         break;
112         case snd_soc_dapm_mux: {
113                 struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value;
114                 int val, item, bitmask;
115
116                 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
117                 ;
118                 val = snd_soc_read(w->codec, e->reg);
119                 item = (val >> e->shift_l) & (bitmask - 1);
120
121                 p->connect = 0;
122                 for (i = 0; i < e->mask; i++) {
123                         if (!(strcmp(p->name, e->texts[i])) && item == i)
124                                 p->connect = 1;
125                 }
126         }
127         break;
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:
136                 p->connect = 1;
137         break;
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:
145                 p->connect = 0;
146         break;
147         }
148 }
149
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)
155 {
156         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
157         int i;
158
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);
166                         return 0;
167                 }
168         }
169
170         return -ENODEV;
171 }
172
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)
177 {
178         int i;
179
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);
188                         return 0;
189                 }
190         }
191         return -ENODEV;
192 }
193
194 /* update dapm codec register bits */
195 static int dapm_update_bits(struct snd_soc_dapm_widget *widget)
196 {
197         int change, power;
198         unsigned short old, new;
199         struct snd_soc_codec *codec = widget->codec;
200
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)
208                 return 0;
209
210         power = widget->power;
211         if (widget->invert)
212                 power = (power ? 0:1);
213
214         old = snd_soc_read(codec, widget->reg);
215         new = (old & ~(0x1 << widget->shift)) | (power << widget->shift);
216
217         change = old != new;
218         if (change) {
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);
222                 pop_wait(POP_TIME);
223         }
224         dbg("reg %x old %x new %x change %d\n", widget->reg, old, new, change);
225         return change;
226 }
227
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)
231 {
232         const struct snd_kcontrol_new *k = widget->kcontrols;
233
234         if (widget->muted && !power)
235                 return 0;
236         if (!widget->muted && power)
237                 return 0;
238
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;
244
245                 if (power) {
246                         int i;
247                         /* power up has happended, increase volume to last level */
248                         if (invert) {
249                                 for (i = mask; i > widget->saved_value; i--)
250                                         snd_soc_update_bits(widget->codec, reg, mask, i);
251                         } else {
252                                 for (i = 0; i < widget->saved_value; i++)
253                                         snd_soc_update_bits(widget->codec, reg, mask, i);
254                         }
255                         widget->muted = 0;
256                 } else {
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;
260                         if (invert) {
261                                 for (; i < mask; i++)
262                                         snd_soc_update_bits(widget->codec, reg, mask, i);
263                         } else {
264                                 for (; i > 0; i--)
265                                         snd_soc_update_bits(widget->codec, reg, mask, i);
266                         }
267                         widget->muted = 1;
268                 }
269         }
270         return 0;
271 }
272
273 /* create new dapm mixer control */
274 static int dapm_new_mixer(struct snd_soc_codec *codec,
275         struct snd_soc_dapm_widget *w)
276 {
277         int i, ret = 0;
278         char name[32];
279         struct snd_soc_dapm_path *path;
280
281         /* add kcontrol */
282         for (i = 0; i < w->num_kcontrols; i++) {
283
284                 /* match name */
285                 list_for_each_entry(path, &w->sources, list_sink) {
286
287                         /* mixer/mux paths name must match control name */
288                         if (path->name != (char*)w->kcontrols[i].name)
289                                 continue;
290
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)
295                                 return -ENOMEM;
296
297                         path->kcontrol = snd_soc_cnew(&w->kcontrols[i], w,
298                                 path->long_name);
299                         ret = snd_ctl_add(codec->card, path->kcontrol);
300                         if (ret < 0) {
301                                 printk(KERN_ERR "asoc: failed to add dapm kcontrol %s\n",
302                                                 path->long_name);
303                                 kfree(path->long_name);
304                                 path->long_name = NULL;
305                                 return ret;
306                         }
307                 }
308         }
309         return ret;
310 }
311
312 /* create new dapm mux control */
313 static int dapm_new_mux(struct snd_soc_codec *codec,
314         struct snd_soc_dapm_widget *w)
315 {
316         struct snd_soc_dapm_path *path = NULL;
317         struct snd_kcontrol *kcontrol;
318         int ret = 0;
319
320         if (!w->num_kcontrols) {
321                 printk(KERN_ERR "asoc: mux %s has no controls\n", w->name);
322                 return -EINVAL;
323         }
324
325         kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
326         ret = snd_ctl_add(codec->card, kcontrol);
327         if (ret < 0)
328                 goto err;
329
330         list_for_each_entry(path, &w->sources, list_sink)
331                 path->kcontrol = kcontrol;
332
333         return ret;
334
335 err:
336         printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
337         return ret;
338 }
339
340 /* create new dapm volume control */
341 static int dapm_new_pga(struct snd_soc_codec *codec,
342         struct snd_soc_dapm_widget *w)
343 {
344         struct snd_kcontrol *kcontrol;
345         int ret = 0;
346
347         if (!w->num_kcontrols)
348                 return -EINVAL;
349
350         kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
351         ret = snd_ctl_add(codec->card, kcontrol);
352         if (ret < 0) {
353                 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
354                 return ret;
355         }
356
357         return ret;
358 }
359
360 /* reset 'walked' bit for each dapm path */
361 static inline void dapm_clear_walk(struct snd_soc_codec *codec)
362 {
363         struct snd_soc_dapm_path *p;
364
365         list_for_each_entry(p, &codec->dapm_paths, list)
366                 p->walked = 0;
367 }
368
369 /*
370  * Recursively check for a completed path to an active or physically connected
371  * output widget. Returns number of complete paths.
372  */
373 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget)
374 {
375         struct snd_soc_dapm_path *path;
376         int con = 0;
377
378         if (widget->id == snd_soc_dapm_adc && widget->active)
379                 return 1;
380
381         if (widget->connected) {
382                 /* connected pin ? */
383                 if (widget->id == snd_soc_dapm_output && !widget->ext)
384                         return 1;
385
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)
389                         return 1;
390         }
391
392         list_for_each_entry(path, &widget->sinks, list_source) {
393                 if (path->walked)
394                         continue;
395
396                 if (path->sink && path->connect) {
397                         path->walked = 1;
398                         con += is_connected_output_ep(path->sink);
399                 }
400         }
401
402         return con;
403 }
404
405 /*
406  * Recursively check for a completed path to an active or physically connected
407  * input widget. Returns number of complete paths.
408  */
409 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget)
410 {
411         struct snd_soc_dapm_path *path;
412         int con = 0;
413
414         /* active stream ? */
415         if (widget->id == snd_soc_dapm_dac && widget->active)
416                 return 1;
417
418         if (widget->connected) {
419                 /* connected pin ? */
420                 if (widget->id == snd_soc_dapm_input && !widget->ext)
421                         return 1;
422
423                 /* connected VMID/Bias for lower pops */
424                 if (widget->id == snd_soc_dapm_vmid)
425                         return 1;
426
427                 /* connected jack ? */
428                 if (widget->id == snd_soc_dapm_mic || widget->id == snd_soc_dapm_line)
429                         return 1;
430         }
431
432         list_for_each_entry(path, &widget->sources, list_sink) {
433                 if (path->walked)
434                         continue;
435
436                 if (path->source && path->connect) {
437                         path->walked = 1;
438                         con += is_connected_input_ep(path->source);
439                 }
440         }
441
442         return con;
443 }
444
445 /*
446  * Handler for generic register modifier widget.
447  */
448 int dapm_reg_event(struct snd_soc_dapm_widget *w,
449                    struct snd_kcontrol *kcontrol, int event)
450 {
451         unsigned int val;
452
453         if (SND_SOC_DAPM_EVENT_ON(event))
454                 val = w->on_val;
455         else
456                 val = w->off_val;
457
458         snd_soc_update_bits(w->codec, -(w->reg + 1),
459                             w->mask << w->shift, val << w->shift);
460
461         return 0;
462 }
463
464 /*
465  * Scan each dapm widget for complete audio path.
466  * A complete path is a route that has valid endpoints i.e.:-
467  *
468  *  o DAC to output pin.
469  *  o Input Pin to ADC.
470  *  o Input pin to Output pin (bypass, sidetone)
471  *  o DAC to ADC (loopback).
472  */
473 static int dapm_power_widgets(struct snd_soc_codec *codec, int event)
474 {
475         struct snd_soc_dapm_widget *w;
476         int in, out, i, c = 1, *seq = NULL, ret = 0, power_change, power;
477
478         /* do we have a sequenced stream event */
479         if (event == SND_SOC_DAPM_STREAM_START) {
480                 c = ARRAY_SIZE(dapm_up_seq);
481                 seq = dapm_up_seq;
482         } else if (event == SND_SOC_DAPM_STREAM_STOP) {
483                 c = ARRAY_SIZE(dapm_down_seq);
484                 seq = dapm_down_seq;
485         }
486
487         for(i = 0; i < c; i++) {
488                 list_for_each_entry(w, &codec->dapm_widgets, list) {
489
490                         /* is widget in stream order */
491                         if (seq && seq[i] && w->id != seq[i])
492                                 continue;
493
494                         /* vmid - no action */
495                         if (w->id == snd_soc_dapm_vmid)
496                                 continue;
497
498                         /* active ADC */
499                         if (w->id == snd_soc_dapm_adc && w->active) {
500                                 in = is_connected_input_ep(w);
501                                 dapm_clear_walk(w->codec);
502                                 w->power = (in != 0) ? 1 : 0;
503                                 dapm_update_bits(w);
504                                 continue;
505                         }
506
507                         /* active DAC */
508                         if (w->id == snd_soc_dapm_dac && w->active) {
509                                 out = is_connected_output_ep(w);
510                                 dapm_clear_walk(w->codec);
511                                 w->power = (out != 0) ? 1 : 0;
512                                 dapm_update_bits(w);
513                                 continue;
514                         }
515
516                         /* programmable gain/attenuation */
517                         if (w->id == snd_soc_dapm_pga) {
518                                 int on;
519                                 in = is_connected_input_ep(w);
520                                 dapm_clear_walk(w->codec);
521                                 out = is_connected_output_ep(w);
522                                 dapm_clear_walk(w->codec);
523                                 w->power = on = (out != 0 && in != 0) ? 1 : 0;
524
525                                 if (!on)
526                                         dapm_set_pga(w, on); /* lower volume to reduce pops */
527                                 dapm_update_bits(w);
528                                 if (on)
529                                         dapm_set_pga(w, on); /* restore volume from zero */
530
531                                 continue;
532                         }
533
534                         /* pre and post event widgets */
535                         if (w->id == snd_soc_dapm_pre) {
536                                 if (!w->event)
537                                         continue;
538
539                                 if (event == SND_SOC_DAPM_STREAM_START) {
540                                         ret = w->event(w,
541                                                 NULL, SND_SOC_DAPM_PRE_PMU);
542                                         if (ret < 0)
543                                                 return ret;
544                                 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
545                                         ret = w->event(w,
546                                                 NULL, SND_SOC_DAPM_PRE_PMD);
547                                         if (ret < 0)
548                                                 return ret;
549                                 }
550                                 continue;
551                         }
552                         if (w->id == snd_soc_dapm_post) {
553                                 if (!w->event)
554                                         continue;
555
556                                 if (event == SND_SOC_DAPM_STREAM_START) {
557                                         ret = w->event(w,
558                                                 NULL, SND_SOC_DAPM_POST_PMU);
559                                         if (ret < 0)
560                                                 return ret;
561                                 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
562                                         ret = w->event(w,
563                                                 NULL, SND_SOC_DAPM_POST_PMD);
564                                         if (ret < 0)
565                                                 return ret;
566                                 }
567                                 continue;
568                         }
569
570                         /* all other widgets */
571                         in = is_connected_input_ep(w);
572                         dapm_clear_walk(w->codec);
573                         out = is_connected_output_ep(w);
574                         dapm_clear_walk(w->codec);
575                         power = (out != 0 && in != 0) ? 1 : 0;
576                         power_change = (w->power == power) ? 0: 1;
577                         w->power = power;
578
579                         /* call any power change event handlers */
580                         if (power_change) {
581                                 if (w->event) {
582                                         dbg("power %s event for %s flags %x\n",
583                                                 w->power ? "on" : "off", w->name, w->event_flags);
584                                         if (power) {
585                                                 /* power up event */
586                                                 if (w->event_flags & SND_SOC_DAPM_PRE_PMU) {
587                                                         ret = w->event(w,
588                                                                 NULL, SND_SOC_DAPM_PRE_PMU);
589                                                         if (ret < 0)
590                                                                 return ret;
591                                                 }
592                                                 dapm_update_bits(w);
593                                                 if (w->event_flags & SND_SOC_DAPM_POST_PMU){
594                                                         ret = w->event(w,
595                                                                 NULL, SND_SOC_DAPM_POST_PMU);
596                                                         if (ret < 0)
597                                                                 return ret;
598                                                 }
599                                         } else {
600                                                 /* power down event */
601                                                 if (w->event_flags & SND_SOC_DAPM_PRE_PMD) {
602                                                         ret = w->event(w,
603                                                                 NULL, SND_SOC_DAPM_PRE_PMD);
604                                                         if (ret < 0)
605                                                                 return ret;
606                                                 }
607                                                 dapm_update_bits(w);
608                                                 if (w->event_flags & SND_SOC_DAPM_POST_PMD) {
609                                                         ret = w->event(w,
610                                                                 NULL, SND_SOC_DAPM_POST_PMD);
611                                                         if (ret < 0)
612                                                                 return ret;
613                                                 }
614                                         }
615                                 } else
616                                         /* no event handler */
617                                         dapm_update_bits(w);
618                         }
619                 }
620         }
621
622         return ret;
623 }
624
625 #if DAPM_DEBUG
626 static void dbg_dump_dapm(struct snd_soc_codec* codec, const char *action)
627 {
628         struct snd_soc_dapm_widget *w;
629         struct snd_soc_dapm_path *p = NULL;
630         int in, out;
631
632         printk("DAPM %s %s\n", codec->name, action);
633
634         list_for_each_entry(w, &codec->dapm_widgets, list) {
635
636                 /* only display widgets that effect routing */
637                 switch (w->id) {
638                 case snd_soc_dapm_pre:
639                 case snd_soc_dapm_post:
640                 case snd_soc_dapm_vmid:
641                         continue;
642                 case snd_soc_dapm_mux:
643                 case snd_soc_dapm_output:
644                 case snd_soc_dapm_input:
645                 case snd_soc_dapm_switch:
646                 case snd_soc_dapm_hp:
647                 case snd_soc_dapm_mic:
648                 case snd_soc_dapm_spk:
649                 case snd_soc_dapm_line:
650                 case snd_soc_dapm_micbias:
651                 case snd_soc_dapm_dac:
652                 case snd_soc_dapm_adc:
653                 case snd_soc_dapm_pga:
654                 case snd_soc_dapm_mixer:
655                         if (w->name) {
656                                 in = is_connected_input_ep(w);
657                                 dapm_clear_walk(w->codec);
658                                 out = is_connected_output_ep(w);
659                                 dapm_clear_walk(w->codec);
660                                 printk("%s: %s  in %d out %d\n", w->name,
661                                         w->power ? "On":"Off",in, out);
662
663                                 list_for_each_entry(p, &w->sources, list_sink) {
664                                         if (p->connect)
665                                                 printk(" in  %s %s\n", p->name ? p->name : "static",
666                                                         p->source->name);
667                                 }
668                                 list_for_each_entry(p, &w->sinks, list_source) {
669                                         if (p->connect)
670                                                 printk(" out %s %s\n", p->name ? p->name : "static",
671                                                         p->sink->name);
672                                 }
673                         }
674                 break;
675                 }
676         }
677 }
678 #endif
679
680 /* test and update the power status of a mux widget */
681 static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
682                                  struct snd_kcontrol *kcontrol, int mask,
683                                  int val, struct soc_enum* e)
684 {
685         struct snd_soc_dapm_path *path;
686         int found = 0;
687
688         if (widget->id != snd_soc_dapm_mux)
689                 return -ENODEV;
690
691         if (!snd_soc_test_bits(widget->codec, e->reg, mask, val))
692                 return 0;
693
694         /* find dapm widget path assoc with kcontrol */
695         list_for_each_entry(path, &widget->codec->dapm_paths, list) {
696                 if (path->kcontrol != kcontrol)
697                         continue;
698
699                 if (!path->name || ! e->texts[val])
700                         continue;
701
702                 found = 1;
703                 /* we now need to match the string in the enum to the path */
704                 if (!(strcmp(path->name, e->texts[val])))
705                         path->connect = 1; /* new connection */
706                 else
707                         path->connect = 0; /* old connection must be powered down */
708         }
709
710         if (found)
711                 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
712
713         return 0;
714 }
715
716 /* test and update the power status of a mixer or switch widget */
717 static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
718                                    struct snd_kcontrol *kcontrol, int reg,
719                                    int val_mask, int val, int invert)
720 {
721         struct snd_soc_dapm_path *path;
722         int found = 0;
723
724         if (widget->id != snd_soc_dapm_mixer &&
725             widget->id != snd_soc_dapm_switch)
726                 return -ENODEV;
727
728         if (!snd_soc_test_bits(widget->codec, reg, val_mask, val))
729                 return 0;
730
731         /* find dapm widget path assoc with kcontrol */
732         list_for_each_entry(path, &widget->codec->dapm_paths, list) {
733                 if (path->kcontrol != kcontrol)
734                         continue;
735
736                 /* found, now check type */
737                 found = 1;
738                 if (val)
739                         /* new connection */
740                         path->connect = invert ? 0:1;
741                 else
742                         /* old connection must be powered down */
743                         path->connect = invert ? 1:0;
744                 break;
745         }
746
747         if (found)
748                 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
749
750         return 0;
751 }
752
753 /* show dapm widget status in sys fs */
754 static ssize_t dapm_widget_show(struct device *dev,
755         struct device_attribute *attr, char *buf)
756 {
757         struct snd_soc_device *devdata = dev_get_drvdata(dev);
758         struct snd_soc_codec *codec = devdata->codec;
759         struct snd_soc_dapm_widget *w;
760         int count = 0;
761         char *state = "not set";
762
763         list_for_each_entry(w, &codec->dapm_widgets, list) {
764
765                 /* only display widgets that burnm power */
766                 switch (w->id) {
767                 case snd_soc_dapm_hp:
768                 case snd_soc_dapm_mic:
769                 case snd_soc_dapm_spk:
770                 case snd_soc_dapm_line:
771                 case snd_soc_dapm_micbias:
772                 case snd_soc_dapm_dac:
773                 case snd_soc_dapm_adc:
774                 case snd_soc_dapm_pga:
775                 case snd_soc_dapm_mixer:
776                         if (w->name)
777                                 count += sprintf(buf + count, "%s: %s\n",
778                                         w->name, w->power ? "On":"Off");
779                 break;
780                 default:
781                 break;
782                 }
783         }
784
785         switch (codec->bias_level) {
786         case SND_SOC_BIAS_ON:
787                 state = "On";
788                 break;
789         case SND_SOC_BIAS_PREPARE:
790                 state = "Prepare";
791                 break;
792         case SND_SOC_BIAS_STANDBY:
793                 state = "Standby";
794                 break;
795         case SND_SOC_BIAS_OFF:
796                 state = "Off";
797                 break;
798         }
799         count += sprintf(buf + count, "PM State: %s\n", state);
800
801         return count;
802 }
803
804 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
805
806 int snd_soc_dapm_sys_add(struct device *dev)
807 {
808         int ret = 0;
809
810         if (dapm_status)
811                 ret = device_create_file(dev, &dev_attr_dapm_widget);
812
813         return ret;
814 }
815
816 static void snd_soc_dapm_sys_remove(struct device *dev)
817 {
818         if (dapm_status)
819                 device_remove_file(dev, &dev_attr_dapm_widget);
820 }
821
822 /* free all dapm widgets and resources */
823 static void dapm_free_widgets(struct snd_soc_codec *codec)
824 {
825         struct snd_soc_dapm_widget *w, *next_w;
826         struct snd_soc_dapm_path *p, *next_p;
827
828         list_for_each_entry_safe(w, next_w, &codec->dapm_widgets, list) {
829                 list_del(&w->list);
830                 kfree(w);
831         }
832
833         list_for_each_entry_safe(p, next_p, &codec->dapm_paths, list) {
834                 list_del(&p->list);
835                 kfree(p->long_name);
836                 kfree(p);
837         }
838 }
839
840 /**
841  * snd_soc_dapm_sync_endpoints - scan and power dapm paths
842  * @codec: audio codec
843  *
844  * Walks all dapm audio paths and powers widgets according to their
845  * stream or path usage.
846  *
847  * Returns 0 for success.
848  */
849 int snd_soc_dapm_sync_endpoints(struct snd_soc_codec *codec)
850 {
851         return dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
852 }
853 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_endpoints);
854
855 static int snd_soc_dapm_add_route(struct snd_soc_codec *codec,
856         const char *sink, const char *control, const char *source)
857 {
858         struct snd_soc_dapm_path *path;
859         struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
860         int ret = 0;
861
862         /* find src and dest widgets */
863         list_for_each_entry(w, &codec->dapm_widgets, list) {
864
865                 if (!wsink && !(strcmp(w->name, sink))) {
866                         wsink = w;
867                         continue;
868                 }
869                 if (!wsource && !(strcmp(w->name, source))) {
870                         wsource = w;
871                 }
872         }
873
874         if (wsource == NULL || wsink == NULL)
875                 return -ENODEV;
876
877         path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
878         if (!path)
879                 return -ENOMEM;
880
881         path->source = wsource;
882         path->sink = wsink;
883         INIT_LIST_HEAD(&path->list);
884         INIT_LIST_HEAD(&path->list_source);
885         INIT_LIST_HEAD(&path->list_sink);
886
887         /* check for external widgets */
888         if (wsink->id == snd_soc_dapm_input) {
889                 if (wsource->id == snd_soc_dapm_micbias ||
890                         wsource->id == snd_soc_dapm_mic ||
891                         wsink->id == snd_soc_dapm_line ||
892                         wsink->id == snd_soc_dapm_output)
893                         wsink->ext = 1;
894         }
895         if (wsource->id == snd_soc_dapm_output) {
896                 if (wsink->id == snd_soc_dapm_spk ||
897                         wsink->id == snd_soc_dapm_hp ||
898                         wsink->id == snd_soc_dapm_line ||
899                         wsink->id == snd_soc_dapm_input)
900                         wsource->ext = 1;
901         }
902
903         /* connect static paths */
904         if (control == NULL) {
905                 list_add(&path->list, &codec->dapm_paths);
906                 list_add(&path->list_sink, &wsink->sources);
907                 list_add(&path->list_source, &wsource->sinks);
908                 path->connect = 1;
909                 return 0;
910         }
911
912         /* connect dynamic paths */
913         switch(wsink->id) {
914         case snd_soc_dapm_adc:
915         case snd_soc_dapm_dac:
916         case snd_soc_dapm_pga:
917         case snd_soc_dapm_input:
918         case snd_soc_dapm_output:
919         case snd_soc_dapm_micbias:
920         case snd_soc_dapm_vmid:
921         case snd_soc_dapm_pre:
922         case snd_soc_dapm_post:
923                 list_add(&path->list, &codec->dapm_paths);
924                 list_add(&path->list_sink, &wsink->sources);
925                 list_add(&path->list_source, &wsource->sinks);
926                 path->connect = 1;
927                 return 0;
928         case snd_soc_dapm_mux:
929                 ret = dapm_connect_mux(codec, wsource, wsink, path, control,
930                         &wsink->kcontrols[0]);
931                 if (ret != 0)
932                         goto err;
933                 break;
934         case snd_soc_dapm_switch:
935         case snd_soc_dapm_mixer:
936                 ret = dapm_connect_mixer(codec, wsource, wsink, path, control);
937                 if (ret != 0)
938                         goto err;
939                 break;
940         case snd_soc_dapm_hp:
941         case snd_soc_dapm_mic:
942         case snd_soc_dapm_line:
943         case snd_soc_dapm_spk:
944                 list_add(&path->list, &codec->dapm_paths);
945                 list_add(&path->list_sink, &wsink->sources);
946                 list_add(&path->list_source, &wsource->sinks);
947                 path->connect = 0;
948                 return 0;
949         }
950         return 0;
951
952 err:
953         printk(KERN_WARNING "asoc: no dapm match for %s --> %s --> %s\n", source,
954                 control, sink);
955         kfree(path);
956         return ret;
957 }
958
959 /**
960  * snd_soc_dapm_connect_input - connect dapm widgets
961  * @codec: audio codec
962  * @sink: name of target widget
963  * @control: mixer control name
964  * @source: name of source name
965  *
966  * Connects 2 dapm widgets together via a named audio path. The sink is
967  * the widget receiving the audio signal, whilst the source is the sender
968  * of the audio signal.
969  *
970  * This function has been deprecated in favour of snd_soc_dapm_add_routes().
971  *
972  * Returns 0 for success else error.
973  */
974 int snd_soc_dapm_connect_input(struct snd_soc_codec *codec, const char *sink,
975         const char *control, const char *source)
976 {
977         return snd_soc_dapm_add_route(codec, sink, control, source);
978 }
979 EXPORT_SYMBOL_GPL(snd_soc_dapm_connect_input);
980
981 /**
982  * snd_soc_dapm_add_routes - Add routes between DAPM widgets
983  * @codec: codec
984  * @route: audio routes
985  * @num: number of routes
986  *
987  * Connects 2 dapm widgets together via a named audio path. The sink is
988  * the widget receiving the audio signal, whilst the source is the sender
989  * of the audio signal.
990  *
991  * Returns 0 for success else error. On error all resources can be freed
992  * with a call to snd_soc_card_free().
993  */
994 int snd_soc_dapm_add_routes(struct snd_soc_codec *codec,
995                             const struct snd_soc_dapm_route *route, int num)
996 {
997         int i, ret;
998
999         for (i = 0; i < num; i++) {
1000                 ret = snd_soc_dapm_add_route(codec, route->sink,
1001                                              route->control, route->source);
1002                 if (ret < 0) {
1003                         printk(KERN_ERR "Failed to add route %s->%s\n",
1004                                route->source,
1005                                route->sink);
1006                         return ret;
1007                 }
1008                 route++;
1009         }
1010
1011         return 0;
1012 }
1013 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
1014
1015 /**
1016  * snd_soc_dapm_new_widgets - add new dapm widgets
1017  * @codec: audio codec
1018  *
1019  * Checks the codec for any new dapm widgets and creates them if found.
1020  *
1021  * Returns 0 for success.
1022  */
1023 int snd_soc_dapm_new_widgets(struct snd_soc_codec *codec)
1024 {
1025         struct snd_soc_dapm_widget *w;
1026
1027         list_for_each_entry(w, &codec->dapm_widgets, list)
1028         {
1029                 if (w->new)
1030                         continue;
1031
1032                 switch(w->id) {
1033                 case snd_soc_dapm_switch:
1034                 case snd_soc_dapm_mixer:
1035                         dapm_new_mixer(codec, w);
1036                         break;
1037                 case snd_soc_dapm_mux:
1038                         dapm_new_mux(codec, w);
1039                         break;
1040                 case snd_soc_dapm_adc:
1041                 case snd_soc_dapm_dac:
1042                 case snd_soc_dapm_pga:
1043                         dapm_new_pga(codec, w);
1044                         break;
1045                 case snd_soc_dapm_input:
1046                 case snd_soc_dapm_output:
1047                 case snd_soc_dapm_micbias:
1048                 case snd_soc_dapm_spk:
1049                 case snd_soc_dapm_hp:
1050                 case snd_soc_dapm_mic:
1051                 case snd_soc_dapm_line:
1052                 case snd_soc_dapm_vmid:
1053                 case snd_soc_dapm_pre:
1054                 case snd_soc_dapm_post:
1055                         break;
1056                 }
1057                 w->new = 1;
1058         }
1059
1060         dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
1061         return 0;
1062 }
1063 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
1064
1065 /**
1066  * snd_soc_dapm_get_volsw - dapm mixer get callback
1067  * @kcontrol: mixer control
1068  * @uinfo: control element information
1069  *
1070  * Callback to get the value of a dapm mixer control.
1071  *
1072  * Returns 0 for success.
1073  */
1074 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
1075         struct snd_ctl_elem_value *ucontrol)
1076 {
1077         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1078         int reg = kcontrol->private_value & 0xff;
1079         int shift = (kcontrol->private_value >> 8) & 0x0f;
1080         int rshift = (kcontrol->private_value >> 12) & 0x0f;
1081         int max = (kcontrol->private_value >> 16) & 0xff;
1082         int invert = (kcontrol->private_value >> 24) & 0x01;
1083         int mask = (1 << fls(max)) - 1;
1084
1085         /* return the saved value if we are powered down */
1086         if (widget->id == snd_soc_dapm_pga && !widget->power) {
1087                 ucontrol->value.integer.value[0] = widget->saved_value;
1088                 return 0;
1089         }
1090
1091         ucontrol->value.integer.value[0] =
1092                 (snd_soc_read(widget->codec, reg) >> shift) & mask;
1093         if (shift != rshift)
1094                 ucontrol->value.integer.value[1] =
1095                         (snd_soc_read(widget->codec, reg) >> rshift) & mask;
1096         if (invert) {
1097                 ucontrol->value.integer.value[0] =
1098                         max - ucontrol->value.integer.value[0];
1099                 if (shift != rshift)
1100                         ucontrol->value.integer.value[1] =
1101                                 max - ucontrol->value.integer.value[1];
1102         }
1103
1104         return 0;
1105 }
1106 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
1107
1108 /**
1109  * snd_soc_dapm_put_volsw - dapm mixer set callback
1110  * @kcontrol: mixer control
1111  * @uinfo: control element information
1112  *
1113  * Callback to set the value of a dapm mixer control.
1114  *
1115  * Returns 0 for success.
1116  */
1117 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
1118         struct snd_ctl_elem_value *ucontrol)
1119 {
1120         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1121         int reg = kcontrol->private_value & 0xff;
1122         int shift = (kcontrol->private_value >> 8) & 0x0f;
1123         int rshift = (kcontrol->private_value >> 12) & 0x0f;
1124         int max = (kcontrol->private_value >> 16) & 0xff;
1125         int mask = (1 << fls(max)) - 1;
1126         int invert = (kcontrol->private_value >> 24) & 0x01;
1127         unsigned short val, val2, val_mask;
1128         int ret;
1129
1130         val = (ucontrol->value.integer.value[0] & mask);
1131
1132         if (invert)
1133                 val = max - val;
1134         val_mask = mask << shift;
1135         val = val << shift;
1136         if (shift != rshift) {
1137                 val2 = (ucontrol->value.integer.value[1] & mask);
1138                 if (invert)
1139                         val2 = max - val2;
1140                 val_mask |= mask << rshift;
1141                 val |= val2 << rshift;
1142         }
1143
1144         mutex_lock(&widget->codec->mutex);
1145         widget->value = val;
1146
1147         /* save volume value if the widget is powered down */
1148         if (widget->id == snd_soc_dapm_pga && !widget->power) {
1149                 widget->saved_value = val;
1150                 mutex_unlock(&widget->codec->mutex);
1151                 return 1;
1152         }
1153
1154         dapm_mixer_update_power(widget, kcontrol, reg, val_mask, val, invert);
1155         if (widget->event) {
1156                 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1157                         ret = widget->event(widget, kcontrol,
1158                                                 SND_SOC_DAPM_PRE_REG);
1159                         if (ret < 0) {
1160                                 ret = 1;
1161                                 goto out;
1162                         }
1163                 }
1164                 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1165                 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1166                         ret = widget->event(widget, kcontrol,
1167                                                 SND_SOC_DAPM_POST_REG);
1168         } else
1169                 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1170
1171 out:
1172         mutex_unlock(&widget->codec->mutex);
1173         return ret;
1174 }
1175 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
1176
1177 /**
1178  * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
1179  * @kcontrol: mixer control
1180  * @uinfo: control element information
1181  *
1182  * Callback to get the value of a dapm enumerated double mixer control.
1183  *
1184  * Returns 0 for success.
1185  */
1186 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
1187         struct snd_ctl_elem_value *ucontrol)
1188 {
1189         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1190         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1191         unsigned short val, bitmask;
1192
1193         for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1194                 ;
1195         val = snd_soc_read(widget->codec, e->reg);
1196         ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
1197         if (e->shift_l != e->shift_r)
1198                 ucontrol->value.enumerated.item[1] =
1199                         (val >> e->shift_r) & (bitmask - 1);
1200
1201         return 0;
1202 }
1203 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
1204
1205 /**
1206  * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
1207  * @kcontrol: mixer control
1208  * @uinfo: control element information
1209  *
1210  * Callback to set the value of a dapm enumerated double mixer control.
1211  *
1212  * Returns 0 for success.
1213  */
1214 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
1215         struct snd_ctl_elem_value *ucontrol)
1216 {
1217         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1218         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1219         unsigned short val, mux;
1220         unsigned short mask, bitmask;
1221         int ret = 0;
1222
1223         for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1224                 ;
1225         if (ucontrol->value.enumerated.item[0] > e->mask - 1)
1226                 return -EINVAL;
1227         mux = ucontrol->value.enumerated.item[0];
1228         val = mux << e->shift_l;
1229         mask = (bitmask - 1) << e->shift_l;
1230         if (e->shift_l != e->shift_r) {
1231                 if (ucontrol->value.enumerated.item[1] > e->mask - 1)
1232                         return -EINVAL;
1233                 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1234                 mask |= (bitmask - 1) << e->shift_r;
1235         }
1236
1237         mutex_lock(&widget->codec->mutex);
1238         widget->value = val;
1239         dapm_mux_update_power(widget, kcontrol, mask, mux, e);
1240         if (widget->event) {
1241                 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1242                         ret = widget->event(widget,
1243                                 kcontrol, SND_SOC_DAPM_PRE_REG);
1244                         if (ret < 0)
1245                                 goto out;
1246                 }
1247                 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1248                 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1249                         ret = widget->event(widget,
1250                                 kcontrol, SND_SOC_DAPM_POST_REG);
1251         } else
1252                 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1253
1254 out:
1255         mutex_unlock(&widget->codec->mutex);
1256         return ret;
1257 }
1258 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
1259
1260 /**
1261  * snd_soc_dapm_new_control - create new dapm control
1262  * @codec: audio codec
1263  * @widget: widget template
1264  *
1265  * Creates a new dapm control based upon the template.
1266  *
1267  * Returns 0 for success else error.
1268  */
1269 int snd_soc_dapm_new_control(struct snd_soc_codec *codec,
1270         const struct snd_soc_dapm_widget *widget)
1271 {
1272         struct snd_soc_dapm_widget *w;
1273
1274         if ((w = dapm_cnew_widget(widget)) == NULL)
1275                 return -ENOMEM;
1276
1277         w->codec = codec;
1278         INIT_LIST_HEAD(&w->sources);
1279         INIT_LIST_HEAD(&w->sinks);
1280         INIT_LIST_HEAD(&w->list);
1281         list_add(&w->list, &codec->dapm_widgets);
1282
1283         /* machine layer set ups unconnected pins and insertions */
1284         w->connected = 1;
1285         return 0;
1286 }
1287 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
1288
1289 /**
1290  * snd_soc_dapm_new_controls - create new dapm controls
1291  * @codec: audio codec
1292  * @widget: widget array
1293  * @num: number of widgets
1294  *
1295  * Creates new DAPM controls based upon the templates.
1296  *
1297  * Returns 0 for success else error.
1298  */
1299 int snd_soc_dapm_new_controls(struct snd_soc_codec *codec,
1300         const struct snd_soc_dapm_widget *widget,
1301         int num)
1302 {
1303         int i, ret;
1304
1305         for (i = 0; i < num; i++) {
1306                 ret = snd_soc_dapm_new_control(codec, widget);
1307                 if (ret < 0)
1308                         return ret;
1309                 widget++;
1310         }
1311         return 0;
1312 }
1313 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
1314
1315
1316 /**
1317  * snd_soc_dapm_stream_event - send a stream event to the dapm core
1318  * @codec: audio codec
1319  * @stream: stream name
1320  * @event: stream event
1321  *
1322  * Sends a stream event to the dapm core. The core then makes any
1323  * necessary widget power changes.
1324  *
1325  * Returns 0 for success else error.
1326  */
1327 int snd_soc_dapm_stream_event(struct snd_soc_codec *codec,
1328         char *stream, int event)
1329 {
1330         struct snd_soc_dapm_widget *w;
1331
1332         if (stream == NULL)
1333                 return 0;
1334
1335         mutex_lock(&codec->mutex);
1336         list_for_each_entry(w, &codec->dapm_widgets, list)
1337         {
1338                 if (!w->sname)
1339                         continue;
1340                 dbg("widget %s\n %s stream %s event %d\n", w->name, w->sname,
1341                         stream, event);
1342                 if (strstr(w->sname, stream)) {
1343                         switch(event) {
1344                         case SND_SOC_DAPM_STREAM_START:
1345                                 w->active = 1;
1346                                 break;
1347                         case SND_SOC_DAPM_STREAM_STOP:
1348                                 w->active = 0;
1349                                 break;
1350                         case SND_SOC_DAPM_STREAM_SUSPEND:
1351                                 if (w->active)
1352                                         w->suspend = 1;
1353                                 w->active = 0;
1354                                 break;
1355                         case SND_SOC_DAPM_STREAM_RESUME:
1356                                 if (w->suspend) {
1357                                         w->active = 1;
1358                                         w->suspend = 0;
1359                                 }
1360                                 break;
1361                         case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
1362                                 break;
1363                         case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
1364                                 break;
1365                         }
1366                 }
1367         }
1368         mutex_unlock(&codec->mutex);
1369
1370         dapm_power_widgets(codec, event);
1371         dump_dapm(codec, __func__);
1372         return 0;
1373 }
1374 EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event);
1375
1376 /**
1377  * snd_soc_dapm_set_bias_level - set the bias level for the system
1378  * @socdev: audio device
1379  * @level: level to configure
1380  *
1381  * Configure the bias (power) levels for the SoC audio device.
1382  *
1383  * Returns 0 for success else error.
1384  */
1385 int snd_soc_dapm_set_bias_level(struct snd_soc_device *socdev,
1386                                 enum snd_soc_bias_level level)
1387 {
1388         struct snd_soc_codec *codec = socdev->codec;
1389         struct snd_soc_machine *machine = socdev->machine;
1390         int ret = 0;
1391
1392         if (machine->set_bias_level)
1393                 ret = machine->set_bias_level(machine, level);
1394         if (ret == 0 && codec->set_bias_level)
1395                 ret = codec->set_bias_level(codec, level);
1396
1397         return ret;
1398 }
1399
1400 /**
1401  * snd_soc_dapm_set_endpoint - set audio endpoint status
1402  * @codec: audio codec
1403  * @endpoint: audio signal endpoint (or start point)
1404  * @status: point status
1405  *
1406  * Set audio endpoint status - connected or disconnected.
1407  *
1408  * Returns 0 for success else error.
1409  */
1410 int snd_soc_dapm_set_endpoint(struct snd_soc_codec *codec,
1411         char *endpoint, int status)
1412 {
1413         struct snd_soc_dapm_widget *w;
1414
1415         list_for_each_entry(w, &codec->dapm_widgets, list) {
1416                 if (!strcmp(w->name, endpoint)) {
1417                         w->connected = status;
1418                         return 0;
1419                 }
1420         }
1421
1422         return -ENODEV;
1423 }
1424 EXPORT_SYMBOL_GPL(snd_soc_dapm_set_endpoint);
1425
1426 /**
1427  * snd_soc_dapm_get_endpoint_status - get audio endpoint status
1428  * @codec: audio codec
1429  * @endpoint: audio signal endpoint (or start point)
1430  *
1431  * Get audio endpoint status - connected or disconnected.
1432  *
1433  * Returns status
1434  */
1435 int snd_soc_dapm_get_endpoint_status(struct snd_soc_codec *codec,
1436         char *endpoint)
1437 {
1438         struct snd_soc_dapm_widget *w;
1439
1440         list_for_each_entry(w, &codec->dapm_widgets, list) {
1441                 if (!strcmp(w->name, endpoint))
1442                         return w->connected;
1443         }
1444
1445         return 0;
1446 }
1447 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_endpoint_status);
1448
1449 /**
1450  * snd_soc_dapm_free - free dapm resources
1451  * @socdev: SoC device
1452  *
1453  * Free all dapm widgets and resources.
1454  */
1455 void snd_soc_dapm_free(struct snd_soc_device *socdev)
1456 {
1457         struct snd_soc_codec *codec = socdev->codec;
1458
1459         snd_soc_dapm_sys_remove(socdev->dev);
1460         dapm_free_widgets(codec);
1461 }
1462 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
1463
1464 /* Module information */
1465 MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com");
1466 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
1467 MODULE_LICENSE("GPL");