96bce55572a040ce05d665af500b8aa800dc3c04
[linux-2.6.git] / sound / soc / soc-dapm.c
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  *  Revision history
14  *    12th Aug 2005   Initial version.
15  *    25th Oct 2005   Implemented path power domain.
16  *    18th Dec 2005   Implemented machine and stream level power domain.
17  *
18  *  Features:
19  *    o Changes power status of internal codec blocks depending on the
20  *      dynamic configuration of codec internal audio paths and active
21  *      DAC's/ADC's.
22  *    o Platform power domain - can support external components i.e. amps and
23  *      mic/meadphone insertion events.
24  *    o Automatic Mic Bias support
25  *    o Jack insertion power event initiation - e.g. hp insertion will enable
26  *      sinks, dacs, etc
27  *    o Delayed powerdown of audio susbsytem to reduce pops between a quick
28  *      device reopen.
29  *
30  *  Todo:
31  *    o DAPM power change sequencing - allow for configurable per
32  *      codec sequences.
33  *    o Support for analogue bias optimisation.
34  *    o Support for reduced codec oversampling rates.
35  *    o Support for reduced codec bias currents.
36  */
37
38 #include <linux/module.h>
39 #include <linux/moduleparam.h>
40 #include <linux/init.h>
41 #include <linux/delay.h>
42 #include <linux/pm.h>
43 #include <linux/bitops.h>
44 #include <linux/platform_device.h>
45 #include <linux/jiffies.h>
46 #include <sound/driver.h>
47 #include <sound/core.h>
48 #include <sound/pcm.h>
49 #include <sound/pcm_params.h>
50 #include <sound/soc-dapm.h>
51 #include <sound/initval.h>
52
53 /* debug */
54 #define DAPM_DEBUG 0
55 #if DAPM_DEBUG
56 #define dump_dapm(codec, action) dbg_dump_dapm(codec, action)
57 #define dbg(format, arg...) printk(format, ## arg)
58 #else
59 #define dump_dapm(codec, action)
60 #define dbg(format, arg...)
61 #endif
62
63 #define POP_DEBUG 0
64 #if POP_DEBUG
65 #define POP_TIME 500 /* 500 msecs - change if pop debug is too fast */
66 #define pop_wait(time) schedule_timeout_interruptible(msecs_to_jiffies(time))
67 #define pop_dbg(format, arg...) printk(format, ## arg); pop_wait(POP_TIME)
68 #else
69 #define pop_dbg(format, arg...)
70 #define pop_wait(time)
71 #endif
72
73 /* dapm power sequences - make this per codec in the future */
74 static int dapm_up_seq[] = {
75         snd_soc_dapm_pre, snd_soc_dapm_micbias, snd_soc_dapm_mic,
76         snd_soc_dapm_mux, snd_soc_dapm_dac, snd_soc_dapm_mixer, snd_soc_dapm_pga,
77         snd_soc_dapm_adc, snd_soc_dapm_hp, snd_soc_dapm_spk, snd_soc_dapm_post
78 };
79 static int dapm_down_seq[] = {
80         snd_soc_dapm_pre, snd_soc_dapm_adc, snd_soc_dapm_hp, snd_soc_dapm_spk,
81         snd_soc_dapm_pga, snd_soc_dapm_mixer, snd_soc_dapm_dac, snd_soc_dapm_mic,
82         snd_soc_dapm_micbias, snd_soc_dapm_mux, snd_soc_dapm_post
83 };
84
85 static int dapm_status = 1;
86 module_param(dapm_status, int, 0);
87 MODULE_PARM_DESC(dapm_status, "enable DPM sysfs entries");
88
89 /* create a new dapm widget */
90 static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
91         const struct snd_soc_dapm_widget *_widget)
92 {
93         return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
94 }
95
96 /* set up initial codec paths */
97 static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
98         struct snd_soc_dapm_path *p, int i)
99 {
100         switch (w->id) {
101         case snd_soc_dapm_switch:
102         case snd_soc_dapm_mixer: {
103                 int val;
104                 int reg = w->kcontrols[i].private_value & 0xff;
105                 int shift = (w->kcontrols[i].private_value >> 8) & 0x0f;
106                 int mask = (w->kcontrols[i].private_value >> 16) & 0xff;
107                 int invert = (w->kcontrols[i].private_value >> 24) & 0x01;
108
109                 val = snd_soc_read(w->codec, reg);
110                 val = (val >> shift) & mask;
111
112                 if ((invert && !val) || (!invert && val))
113                         p->connect = 1;
114                 else
115                         p->connect = 0;
116         }
117         break;
118         case snd_soc_dapm_mux: {
119                 struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value;
120                 int val, item, bitmask;
121
122                 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
123                 ;
124                 val = snd_soc_read(w->codec, e->reg);
125                 item = (val >> e->shift_l) & (bitmask - 1);
126
127                 p->connect = 0;
128                 for (i = 0; i < e->mask; i++) {
129                         if (!(strcmp(p->name, e->texts[i])) && item == i)
130                                 p->connect = 1;
131                 }
132         }
133         break;
134         /* does not effect routing - always connected */
135         case snd_soc_dapm_pga:
136         case snd_soc_dapm_output:
137         case snd_soc_dapm_adc:
138         case snd_soc_dapm_input:
139         case snd_soc_dapm_dac:
140         case snd_soc_dapm_micbias:
141         case snd_soc_dapm_vmid:
142                 p->connect = 1;
143         break;
144         /* does effect routing - dynamically connected */
145         case snd_soc_dapm_hp:
146         case snd_soc_dapm_mic:
147         case snd_soc_dapm_spk:
148         case snd_soc_dapm_line:
149         case snd_soc_dapm_pre:
150         case snd_soc_dapm_post:
151                 p->connect = 0;
152         break;
153         }
154 }
155
156 /* connect mux widget to it's interconnecting audio paths */
157 static int dapm_connect_mux(struct snd_soc_codec *codec,
158         struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
159         struct snd_soc_dapm_path *path, const char *control_name,
160         const struct snd_kcontrol_new *kcontrol)
161 {
162         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
163         int i;
164
165         for (i = 0; i < e->mask; i++) {
166                 if (!(strcmp(control_name, e->texts[i]))) {
167                         list_add(&path->list, &codec->dapm_paths);
168                         list_add(&path->list_sink, &dest->sources);
169                         list_add(&path->list_source, &src->sinks);
170                         path->name = (char*)e->texts[i];
171                         dapm_set_path_status(dest, path, 0);
172                         return 0;
173                 }
174         }
175
176         return -ENODEV;
177 }
178
179 /* connect mixer widget to it's interconnecting audio paths */
180 static int dapm_connect_mixer(struct snd_soc_codec *codec,
181         struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
182         struct snd_soc_dapm_path *path, const char *control_name)
183 {
184         int i;
185
186         /* search for mixer kcontrol */
187         for (i = 0; i < dest->num_kcontrols; i++) {
188                 if (!strcmp(control_name, dest->kcontrols[i].name)) {
189                         list_add(&path->list, &codec->dapm_paths);
190                         list_add(&path->list_sink, &dest->sources);
191                         list_add(&path->list_source, &src->sinks);
192                         path->name = dest->kcontrols[i].name;
193                         dapm_set_path_status(dest, path, i);
194                         return 0;
195                 }
196         }
197         return -ENODEV;
198 }
199
200 /* update dapm codec register bits */
201 static int dapm_update_bits(struct snd_soc_dapm_widget *widget)
202 {
203         int change, power;
204         unsigned short old, new;
205         struct snd_soc_codec *codec = widget->codec;
206
207         /* check for valid widgets */
208         if (widget->reg < 0 || widget->id == snd_soc_dapm_input ||
209                 widget->id == snd_soc_dapm_output ||
210                 widget->id == snd_soc_dapm_hp ||
211                 widget->id == snd_soc_dapm_mic ||
212                 widget->id == snd_soc_dapm_line ||
213                 widget->id == snd_soc_dapm_spk)
214                 return 0;
215
216         power = widget->power;
217         if (widget->invert)
218                 power = (power ? 0:1);
219
220         old = snd_soc_read(codec, widget->reg);
221         new = (old & ~(0x1 << widget->shift)) | (power << widget->shift);
222
223         change = old != new;
224         if (change) {
225                 pop_dbg("pop test %s : %s in %d ms\n", widget->name,
226                         widget->power ? "on" : "off", POP_TIME);
227                 snd_soc_write(codec, widget->reg, new);
228                 pop_wait(POP_TIME);
229         }
230         dbg("reg old %x new %x change %d\n", old, new, change);
231         return change;
232 }
233
234 /* ramps the volume up or down to minimise pops before or after a
235  * DAPM power event */
236 static int dapm_set_pga(struct snd_soc_dapm_widget *widget, int power)
237 {
238         const struct snd_kcontrol_new *k = widget->kcontrols;
239
240         if (widget->muted && !power)
241                 return 0;
242         if (!widget->muted && power)
243                 return 0;
244
245         if (widget->num_kcontrols && k) {
246                 int reg = k->private_value & 0xff;
247                 int shift = (k->private_value >> 8) & 0x0f;
248                 int mask = (k->private_value >> 16) & 0xff;
249                 int invert = (k->private_value >> 24) & 0x01;
250
251                 if (power) {
252                         int i;
253                         /* power up has happended, increase volume to last level */
254                         if (invert) {
255                                 for (i = mask; i > widget->saved_value; i--)
256                                         snd_soc_update_bits(widget->codec, reg, mask, i);
257                         } else {
258                                 for (i = 0; i < widget->saved_value; i++)
259                                         snd_soc_update_bits(widget->codec, reg, mask, i);
260                         }
261                         widget->muted = 0;
262                 } else {
263                         /* power down is about to occur, decrease volume to mute */
264                         int val = snd_soc_read(widget->codec, reg);
265                         int i = widget->saved_value = (val >> shift) & mask;
266                         if (invert) {
267                                 for (; i < mask; i++)
268                                         snd_soc_update_bits(widget->codec, reg, mask, i);
269                         } else {
270                                 for (; i > 0; i--)
271                                         snd_soc_update_bits(widget->codec, reg, mask, i);
272                         }
273                         widget->muted = 1;
274                 }
275         }
276         return 0;
277 }
278
279 /* create new dapm mixer control */
280 static int dapm_new_mixer(struct snd_soc_codec *codec,
281         struct snd_soc_dapm_widget *w)
282 {
283         int i, ret = 0;
284         char name[32];
285         struct snd_soc_dapm_path *path;
286
287         /* add kcontrol */
288         for (i = 0; i < w->num_kcontrols; i++) {
289
290                 /* match name */
291                 list_for_each_entry(path, &w->sources, list_sink) {
292
293                         /* mixer/mux paths name must match control name */
294                         if (path->name != (char*)w->kcontrols[i].name)
295                                 continue;
296
297                         /* add dapm control with long name */
298                         snprintf(name, 32, "%s %s", w->name, w->kcontrols[i].name);
299                         path->long_name = kstrdup (name, GFP_KERNEL);
300                         if (path->long_name == NULL)
301                                 return -ENOMEM;
302
303                         path->kcontrol = snd_soc_cnew(&w->kcontrols[i], w,
304                                 path->long_name);
305                         ret = snd_ctl_add(codec->card, path->kcontrol);
306                         if (ret < 0) {
307                                 printk(KERN_ERR "asoc: failed to add dapm kcontrol %s\n",
308                                                 path->long_name);
309                                 kfree(path->long_name);
310                                 path->long_name = NULL;
311                                 return ret;
312                         }
313                 }
314         }
315         return ret;
316 }
317
318 /* create new dapm mux control */
319 static int dapm_new_mux(struct snd_soc_codec *codec,
320         struct snd_soc_dapm_widget *w)
321 {
322         struct snd_soc_dapm_path *path = NULL;
323         struct snd_kcontrol *kcontrol;
324         int ret = 0;
325
326         if (!w->num_kcontrols) {
327                 printk(KERN_ERR "asoc: mux %s has no controls\n", w->name);
328                 return -EINVAL;
329         }
330
331         kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
332         ret = snd_ctl_add(codec->card, kcontrol);
333         if (ret < 0)
334                 goto err;
335
336         list_for_each_entry(path, &w->sources, list_sink)
337                 path->kcontrol = kcontrol;
338
339         return ret;
340
341 err:
342         printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
343         return ret;
344 }
345
346 /* create new dapm volume control */
347 static int dapm_new_pga(struct snd_soc_codec *codec,
348         struct snd_soc_dapm_widget *w)
349 {
350         struct snd_kcontrol *kcontrol;
351         int ret = 0;
352
353         if (!w->num_kcontrols)
354                 return -EINVAL;
355
356         kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
357         ret = snd_ctl_add(codec->card, kcontrol);
358         if (ret < 0) {
359                 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
360                 return ret;
361         }
362
363         return ret;
364 }
365
366 /* reset 'walked' bit for each dapm path */
367 static inline void dapm_clear_walk(struct snd_soc_codec *codec)
368 {
369         struct snd_soc_dapm_path *p;
370
371         list_for_each_entry(p, &codec->dapm_paths, list)
372                 p->walked = 0;
373 }
374
375 /*
376  * Recursively check for a completed path to an active or physically connected
377  * output widget. Returns number of complete paths.
378  */
379 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget)
380 {
381         struct snd_soc_dapm_path *path;
382         int con = 0;
383
384         if (widget->id == snd_soc_dapm_adc && widget->active)
385                 return 1;
386
387         if (widget->connected) {
388                 /* connected pin ? */
389                 if (widget->id == snd_soc_dapm_output && !widget->ext)
390                         return 1;
391
392                 /* connected jack or spk ? */
393                 if (widget->id == snd_soc_dapm_hp || widget->id == snd_soc_dapm_spk ||
394                         widget->id == snd_soc_dapm_line)
395                         return 1;
396         }
397
398         list_for_each_entry(path, &widget->sinks, list_source) {
399                 if (path->walked)
400                         continue;
401
402                 if (path->sink && path->connect) {
403                         path->walked = 1;
404                         con += is_connected_output_ep(path->sink);
405                 }
406         }
407
408         return con;
409 }
410
411 /*
412  * Recursively check for a completed path to an active or physically connected
413  * input widget. Returns number of complete paths.
414  */
415 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget)
416 {
417         struct snd_soc_dapm_path *path;
418         int con = 0;
419
420         /* active stream ? */
421         if (widget->id == snd_soc_dapm_dac && widget->active)
422                 return 1;
423
424         if (widget->connected) {
425                 /* connected pin ? */
426                 if (widget->id == snd_soc_dapm_input && !widget->ext)
427                         return 1;
428
429                 /* connected VMID/Bias for lower pops */
430                 if (widget->id == snd_soc_dapm_vmid)
431                         return 1;
432
433                 /* connected jack ? */
434                 if (widget->id == snd_soc_dapm_mic || widget->id == snd_soc_dapm_line)
435                         return 1;
436         }
437
438         list_for_each_entry(path, &widget->sources, list_sink) {
439                 if (path->walked)
440                         continue;
441
442                 if (path->source && path->connect) {
443                         path->walked = 1;
444                         con += is_connected_input_ep(path->source);
445                 }
446         }
447
448         return con;
449 }
450
451 /*
452  * Scan each dapm widget for complete audio path.
453  * A complete path is a route that has valid endpoints i.e.:-
454  *
455  *  o DAC to output pin.
456  *  o Input Pin to ADC.
457  *  o Input pin to Output pin (bypass, sidetone)
458  *  o DAC to ADC (loopback).
459  */
460 static int dapm_power_widgets(struct snd_soc_codec *codec, int event)
461 {
462         struct snd_soc_dapm_widget *w;
463         int in, out, i, c = 1, *seq = NULL, ret = 0, power_change, power;
464
465         /* do we have a sequenced stream event */
466         if (event == SND_SOC_DAPM_STREAM_START) {
467                 c = ARRAY_SIZE(dapm_up_seq);
468                 seq = dapm_up_seq;
469         } else if (event == SND_SOC_DAPM_STREAM_STOP) {
470                 c = ARRAY_SIZE(dapm_down_seq);
471                 seq = dapm_down_seq;
472         }
473
474         for(i = 0; i < c; i++) {
475                 list_for_each_entry(w, &codec->dapm_widgets, list) {
476
477                         /* is widget in stream order */
478                         if (seq && seq[i] && w->id != seq[i])
479                                 continue;
480
481                         /* vmid - no action */
482                         if (w->id == snd_soc_dapm_vmid)
483                                 continue;
484
485                         /* active ADC */
486                         if (w->id == snd_soc_dapm_adc && w->active) {
487                                 in = is_connected_input_ep(w);
488                                 dapm_clear_walk(w->codec);
489                                 w->power = (in != 0) ? 1 : 0;
490                                 dapm_update_bits(w);
491                                 continue;
492                         }
493
494                         /* active DAC */
495                         if (w->id == snd_soc_dapm_dac && w->active) {
496                                 out = is_connected_output_ep(w);
497                                 dapm_clear_walk(w->codec);
498                                 w->power = (out != 0) ? 1 : 0;
499                                 dapm_update_bits(w);
500                                 continue;
501                         }
502
503                         /* programmable gain/attenuation */
504                         if (w->id == snd_soc_dapm_pga) {
505                                 int on;
506                                 in = is_connected_input_ep(w);
507                                 dapm_clear_walk(w->codec);
508                                 out = is_connected_output_ep(w);
509                                 dapm_clear_walk(w->codec);
510                                 w->power = on = (out != 0 && in != 0) ? 1 : 0;
511
512                                 if (!on)
513                                         dapm_set_pga(w, on); /* lower volume to reduce pops */
514                                 dapm_update_bits(w);
515                                 if (on)
516                                         dapm_set_pga(w, on); /* restore volume from zero */
517
518                                 continue;
519                         }
520
521                         /* pre and post event widgets */
522                         if (w->id == snd_soc_dapm_pre) {
523                                 if (!w->event)
524                                         continue;
525
526                                 if (event == SND_SOC_DAPM_STREAM_START) {
527                                         ret = w->event(w, SND_SOC_DAPM_PRE_PMU);
528                                         if (ret < 0)
529                                                 return ret;
530                                 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
531                                         ret = w->event(w, SND_SOC_DAPM_PRE_PMD);
532                                         if (ret < 0)
533                                                 return ret;
534                                 }
535                                 continue;
536                         }
537                         if (w->id == snd_soc_dapm_post) {
538                                 if (!w->event)
539                                         continue;
540
541                                 if (event == SND_SOC_DAPM_STREAM_START) {
542                                         ret = w->event(w, SND_SOC_DAPM_POST_PMU);
543                                         if (ret < 0)
544                                                 return ret;
545                                 } else if (event == SND_SOC_DAPM_STREAM_STOP) {
546                                         ret = w->event(w, SND_SOC_DAPM_POST_PMD);
547                                         if (ret < 0)
548                                                 return ret;
549                                 }
550                                 continue;
551                         }
552
553                         /* all other widgets */
554                         in = is_connected_input_ep(w);
555                         dapm_clear_walk(w->codec);
556                         out = is_connected_output_ep(w);
557                         dapm_clear_walk(w->codec);
558                         power = (out != 0 && in != 0) ? 1 : 0;
559                         power_change = (w->power == power) ? 0: 1;
560                         w->power = power;
561
562                         /* call any power change event handlers */
563                         if (power_change) {
564                                 if (w->event) {
565                                         dbg("power %s event for %s flags %x\n",
566                                                 w->power ? "on" : "off", w->name, w->event_flags);
567                                         if (power) {
568                                                 /* power up event */
569                                                 if (w->event_flags & SND_SOC_DAPM_PRE_PMU) {
570                                                         ret = w->event(w, SND_SOC_DAPM_PRE_PMU);
571                                                         if (ret < 0)
572                                                                 return ret;
573                                                 }
574                                                 dapm_update_bits(w);
575                                                 if (w->event_flags & SND_SOC_DAPM_POST_PMU){
576                                                         ret = w->event(w, SND_SOC_DAPM_POST_PMU);
577                                                         if (ret < 0)
578                                                                 return ret;
579                                                 }
580                                         } else {
581                                                 /* power down event */
582                                                 if (w->event_flags & SND_SOC_DAPM_PRE_PMD) {
583                                                         ret = w->event(w, SND_SOC_DAPM_PRE_PMD);
584                                                         if (ret < 0)
585                                                                 return ret;
586                                                 }
587                                                 dapm_update_bits(w);
588                                                 if (w->event_flags & SND_SOC_DAPM_POST_PMD) {
589                                                         ret = w->event(w, SND_SOC_DAPM_POST_PMD);
590                                                         if (ret < 0)
591                                                                 return ret;
592                                                 }
593                                         }
594                                 } else
595                                         /* no event handler */
596                                         dapm_update_bits(w);
597                         }
598                 }
599         }
600
601         return ret;
602 }
603
604 #if DAPM_DEBUG
605 static void dbg_dump_dapm(struct snd_soc_codec* codec, const char *action)
606 {
607         struct snd_soc_dapm_widget *w;
608         struct snd_soc_dapm_path *p = NULL;
609         int in, out;
610
611         printk("DAPM %s %s\n", codec->name, action);
612
613         list_for_each_entry(w, &codec->dapm_widgets, list) {
614
615                 /* only display widgets that effect routing */
616                 switch (w->id) {
617                 case snd_soc_dapm_pre:
618                 case snd_soc_dapm_post:
619                 case snd_soc_dapm_vmid:
620                         continue;
621                 case snd_soc_dapm_mux:
622                 case snd_soc_dapm_output:
623                 case snd_soc_dapm_input:
624                 case snd_soc_dapm_switch:
625                 case snd_soc_dapm_hp:
626                 case snd_soc_dapm_mic:
627                 case snd_soc_dapm_spk:
628                 case snd_soc_dapm_line:
629                 case snd_soc_dapm_micbias:
630                 case snd_soc_dapm_dac:
631                 case snd_soc_dapm_adc:
632                 case snd_soc_dapm_pga:
633                 case snd_soc_dapm_mixer:
634                         if (w->name) {
635                                 in = is_connected_input_ep(w);
636                                 dapm_clear_walk(w->codec);
637                                 out = is_connected_output_ep(w);
638                                 dapm_clear_walk(w->codec);
639                                 printk("%s: %s  in %d out %d\n", w->name,
640                                         w->power ? "On":"Off",in, out);
641
642                                 list_for_each_entry(p, &w->sources, list_sink) {
643                                         if (p->connect)
644                                                 printk(" in  %s %s\n", p->name ? p->name : "static",
645                                                         p->source->name);
646                                 }
647                                 list_for_each_entry(p, &w->sinks, list_source) {
648                                         if (p->connect)
649                                                 printk(" out %s %s\n", p->name ? p->name : "static",
650                                                         p->sink->name);
651                                 }
652                         }
653                 break;
654                 }
655         }
656 }
657 #endif
658
659 /* test and update the power status of a mux widget */
660 static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
661                                  struct snd_kcontrol *kcontrol, int mask,
662                                  int val, struct soc_enum* e)
663 {
664         struct snd_soc_dapm_path *path;
665         int found = 0;
666
667         if (widget->id != snd_soc_dapm_mux)
668                 return -ENODEV;
669
670         if (!snd_soc_test_bits(widget->codec, e->reg, mask, val))
671                 return 0;
672
673         /* find dapm widget path assoc with kcontrol */
674         list_for_each_entry(path, &widget->codec->dapm_paths, list) {
675                 if (path->kcontrol != kcontrol)
676                         continue;
677
678                 if (!path->name || ! e->texts[val])
679                         continue;
680
681                 found = 1;
682                 /* we now need to match the string in the enum to the path */
683                 if (!(strcmp(path->name, e->texts[val])))
684                         path->connect = 1; /* new connection */
685                 else
686                         path->connect = 0; /* old connection must be powered down */
687         }
688
689         if (found)
690                 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
691
692         return 0;
693 }
694
695 /* test and update the power status of a mixer widget */
696 static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
697                                    struct snd_kcontrol *kcontrol, int reg,
698                                    int val_mask, int val, int invert)
699 {
700         struct snd_soc_dapm_path *path;
701         int found = 0;
702
703         if (widget->id != snd_soc_dapm_mixer)
704                 return -ENODEV;
705
706         if (!snd_soc_test_bits(widget->codec, reg, val_mask, val))
707                 return 0;
708
709         /* find dapm widget path assoc with kcontrol */
710         list_for_each_entry(path, &widget->codec->dapm_paths, list) {
711                 if (path->kcontrol != kcontrol)
712                         continue;
713
714                 /* found, now check type */
715                 found = 1;
716                 if (val)
717                         /* new connection */
718                         path->connect = invert ? 0:1;
719                 else
720                         /* old connection must be powered down */
721                         path->connect = invert ? 1:0;
722                 break;
723         }
724
725         if (found)
726                 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
727
728         return 0;
729 }
730
731 /* show dapm widget status in sys fs */
732 static ssize_t dapm_widget_show(struct device *dev,
733         struct device_attribute *attr, char *buf)
734 {
735         struct snd_soc_device *devdata = dev_get_drvdata(dev);
736         struct snd_soc_codec *codec = devdata->codec;
737         struct snd_soc_dapm_widget *w;
738         int count = 0;
739         char *state = "not set";
740
741         list_for_each_entry(w, &codec->dapm_widgets, list) {
742
743                 /* only display widgets that burnm power */
744                 switch (w->id) {
745                 case snd_soc_dapm_hp:
746                 case snd_soc_dapm_mic:
747                 case snd_soc_dapm_spk:
748                 case snd_soc_dapm_line:
749                 case snd_soc_dapm_micbias:
750                 case snd_soc_dapm_dac:
751                 case snd_soc_dapm_adc:
752                 case snd_soc_dapm_pga:
753                 case snd_soc_dapm_mixer:
754                         if (w->name)
755                                 count += sprintf(buf + count, "%s: %s\n",
756                                         w->name, w->power ? "On":"Off");
757                 break;
758                 default:
759                 break;
760                 }
761         }
762
763         switch(codec->dapm_state){
764         case SNDRV_CTL_POWER_D0:
765                 state = "D0";
766                 break;
767         case SNDRV_CTL_POWER_D1:
768                 state = "D1";
769                 break;
770         case SNDRV_CTL_POWER_D2:
771                 state = "D2";
772                 break;
773         case SNDRV_CTL_POWER_D3hot:
774                 state = "D3hot";
775                 break;
776         case SNDRV_CTL_POWER_D3cold:
777                 state = "D3cold";
778                 break;
779         }
780         count += sprintf(buf + count, "PM State: %s\n", state);
781
782         return count;
783 }
784
785 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
786
787 int snd_soc_dapm_sys_add(struct device *dev)
788 {
789         int ret = 0;
790
791         if (dapm_status)
792                 ret = device_create_file(dev, &dev_attr_dapm_widget);
793
794         return ret;
795 }
796
797 static void snd_soc_dapm_sys_remove(struct device *dev)
798 {
799         if (dapm_status)
800                 device_remove_file(dev, &dev_attr_dapm_widget);
801 }
802
803 /* free all dapm widgets and resources */
804 static void dapm_free_widgets(struct snd_soc_codec *codec)
805 {
806         struct snd_soc_dapm_widget *w, *next_w;
807         struct snd_soc_dapm_path *p, *next_p;
808
809         list_for_each_entry_safe(w, next_w, &codec->dapm_widgets, list) {
810                 list_del(&w->list);
811                 kfree(w);
812         }
813
814         list_for_each_entry_safe(p, next_p, &codec->dapm_paths, list) {
815                 list_del(&p->list);
816                 kfree(p->long_name);
817                 kfree(p);
818         }
819 }
820
821 /**
822  * snd_soc_dapm_sync_endpoints - scan and power dapm paths
823  * @codec: audio codec
824  *
825  * Walks all dapm audio paths and powers widgets according to their
826  * stream or path usage.
827  *
828  * Returns 0 for success.
829  */
830 int snd_soc_dapm_sync_endpoints(struct snd_soc_codec *codec)
831 {
832         return dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
833 }
834 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_endpoints);
835
836 /**
837  * snd_soc_dapm_connect_input - connect dapm widgets
838  * @codec: audio codec
839  * @sink: name of target widget
840  * @control: mixer control name
841  * @source: name of source name
842  *
843  * Connects 2 dapm widgets together via a named audio path. The sink is
844  * the widget receiving the audio signal, whilst the source is the sender
845  * of the audio signal.
846  *
847  * Returns 0 for success else error.
848  */
849 int snd_soc_dapm_connect_input(struct snd_soc_codec *codec, const char *sink,
850         const char * control, const char *source)
851 {
852         struct snd_soc_dapm_path *path;
853         struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
854         int ret = 0;
855
856         /* find src and dest widgets */
857         list_for_each_entry(w, &codec->dapm_widgets, list) {
858
859                 if (!wsink && !(strcmp(w->name, sink))) {
860                         wsink = w;
861                         continue;
862                 }
863                 if (!wsource && !(strcmp(w->name, source))) {
864                         wsource = w;
865                 }
866         }
867
868         if (wsource == NULL || wsink == NULL)
869                 return -ENODEV;
870
871         path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
872         if (!path)
873                 return -ENOMEM;
874
875         path->source = wsource;
876         path->sink = wsink;
877         INIT_LIST_HEAD(&path->list);
878         INIT_LIST_HEAD(&path->list_source);
879         INIT_LIST_HEAD(&path->list_sink);
880
881         /* check for external widgets */
882         if (wsink->id == snd_soc_dapm_input) {
883                 if (wsource->id == snd_soc_dapm_micbias ||
884                         wsource->id == snd_soc_dapm_mic ||
885                         wsink->id == snd_soc_dapm_line ||
886                         wsink->id == snd_soc_dapm_output)
887                         wsink->ext = 1;
888         }
889         if (wsource->id == snd_soc_dapm_output) {
890                 if (wsink->id == snd_soc_dapm_spk ||
891                         wsink->id == snd_soc_dapm_hp ||
892                         wsink->id == snd_soc_dapm_line ||
893                         wsink->id == snd_soc_dapm_input)
894                         wsource->ext = 1;
895         }
896
897         /* connect static paths */
898         if (control == NULL) {
899                 list_add(&path->list, &codec->dapm_paths);
900                 list_add(&path->list_sink, &wsink->sources);
901                 list_add(&path->list_source, &wsource->sinks);
902                 path->connect = 1;
903                 return 0;
904         }
905
906         /* connect dynamic paths */
907         switch(wsink->id) {
908         case snd_soc_dapm_adc:
909         case snd_soc_dapm_dac:
910         case snd_soc_dapm_pga:
911         case snd_soc_dapm_input:
912         case snd_soc_dapm_output:
913         case snd_soc_dapm_micbias:
914         case snd_soc_dapm_vmid:
915         case snd_soc_dapm_pre:
916         case snd_soc_dapm_post:
917                 list_add(&path->list, &codec->dapm_paths);
918                 list_add(&path->list_sink, &wsink->sources);
919                 list_add(&path->list_source, &wsource->sinks);
920                 path->connect = 1;
921                 return 0;
922         case snd_soc_dapm_mux:
923                 ret = dapm_connect_mux(codec, wsource, wsink, path, control,
924                         &wsink->kcontrols[0]);
925                 if (ret != 0)
926                         goto err;
927                 break;
928         case snd_soc_dapm_switch:
929         case snd_soc_dapm_mixer:
930                 ret = dapm_connect_mixer(codec, wsource, wsink, path, control);
931                 if (ret != 0)
932                         goto err;
933                 break;
934         case snd_soc_dapm_hp:
935         case snd_soc_dapm_mic:
936         case snd_soc_dapm_line:
937         case snd_soc_dapm_spk:
938                 list_add(&path->list, &codec->dapm_paths);
939                 list_add(&path->list_sink, &wsink->sources);
940                 list_add(&path->list_source, &wsource->sinks);
941                 path->connect = 0;
942                 return 0;
943         }
944         return 0;
945
946 err:
947         printk(KERN_WARNING "asoc: no dapm match for %s --> %s --> %s\n", source,
948                 control, sink);
949         kfree(path);
950         return ret;
951 }
952 EXPORT_SYMBOL_GPL(snd_soc_dapm_connect_input);
953
954 /**
955  * snd_soc_dapm_new_widgets - add new dapm widgets
956  * @codec: audio codec
957  *
958  * Checks the codec for any new dapm widgets and creates them if found.
959  *
960  * Returns 0 for success.
961  */
962 int snd_soc_dapm_new_widgets(struct snd_soc_codec *codec)
963 {
964         struct snd_soc_dapm_widget *w;
965
966         mutex_lock(&codec->mutex);
967         list_for_each_entry(w, &codec->dapm_widgets, list)
968         {
969                 if (w->new)
970                         continue;
971
972                 switch(w->id) {
973                 case snd_soc_dapm_switch:
974                 case snd_soc_dapm_mixer:
975                         dapm_new_mixer(codec, w);
976                         break;
977                 case snd_soc_dapm_mux:
978                         dapm_new_mux(codec, w);
979                         break;
980                 case snd_soc_dapm_adc:
981                 case snd_soc_dapm_dac:
982                 case snd_soc_dapm_pga:
983                         dapm_new_pga(codec, w);
984                         break;
985                 case snd_soc_dapm_input:
986                 case snd_soc_dapm_output:
987                 case snd_soc_dapm_micbias:
988                 case snd_soc_dapm_spk:
989                 case snd_soc_dapm_hp:
990                 case snd_soc_dapm_mic:
991                 case snd_soc_dapm_line:
992                 case snd_soc_dapm_vmid:
993                 case snd_soc_dapm_pre:
994                 case snd_soc_dapm_post:
995                         break;
996                 }
997                 w->new = 1;
998         }
999
1000         dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
1001         mutex_unlock(&codec->mutex);
1002         return 0;
1003 }
1004 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
1005
1006 /**
1007  * snd_soc_dapm_get_volsw - dapm mixer get callback
1008  * @kcontrol: mixer control
1009  * @uinfo: control element information
1010  *
1011  * Callback to get the value of a dapm mixer control.
1012  *
1013  * Returns 0 for success.
1014  */
1015 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
1016         struct snd_ctl_elem_value *ucontrol)
1017 {
1018         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1019         int reg = kcontrol->private_value & 0xff;
1020         int shift = (kcontrol->private_value >> 8) & 0x0f;
1021         int rshift = (kcontrol->private_value >> 12) & 0x0f;
1022         int mask = (kcontrol->private_value >> 16) & 0xff;
1023         int invert = (kcontrol->private_value >> 24) & 0x01;
1024
1025         /* return the saved value if we are powered down */
1026         if (widget->id == snd_soc_dapm_pga && !widget->power) {
1027                 ucontrol->value.integer.value[0] = widget->saved_value;
1028                 return 0;
1029         }
1030
1031         ucontrol->value.integer.value[0] =
1032                 (snd_soc_read(widget->codec, reg) >> shift) & mask;
1033         if (shift != rshift)
1034                 ucontrol->value.integer.value[1] =
1035                         (snd_soc_read(widget->codec, reg) >> rshift) & mask;
1036         if (invert) {
1037                 ucontrol->value.integer.value[0] =
1038                         mask - ucontrol->value.integer.value[0];
1039                 if (shift != rshift)
1040                         ucontrol->value.integer.value[1] =
1041                                 mask - ucontrol->value.integer.value[1];
1042         }
1043
1044         return 0;
1045 }
1046 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
1047
1048 /**
1049  * snd_soc_dapm_put_volsw - dapm mixer set callback
1050  * @kcontrol: mixer control
1051  * @uinfo: control element information
1052  *
1053  * Callback to set the value of a dapm mixer control.
1054  *
1055  * Returns 0 for success.
1056  */
1057 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
1058         struct snd_ctl_elem_value *ucontrol)
1059 {
1060         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1061         int reg = kcontrol->private_value & 0xff;
1062         int shift = (kcontrol->private_value >> 8) & 0x0f;
1063         int rshift = (kcontrol->private_value >> 12) & 0x0f;
1064         int mask = (kcontrol->private_value >> 16) & 0xff;
1065         int invert = (kcontrol->private_value >> 24) & 0x01;
1066         unsigned short val, val2, val_mask;
1067         int ret;
1068
1069         val = (ucontrol->value.integer.value[0] & mask);
1070
1071         if (invert)
1072                 val = mask - val;
1073         val_mask = mask << shift;
1074         val = val << shift;
1075         if (shift != rshift) {
1076                 val2 = (ucontrol->value.integer.value[1] & mask);
1077                 if (invert)
1078                         val2 = mask - val2;
1079                 val_mask |= mask << rshift;
1080                 val |= val2 << rshift;
1081         }
1082
1083         mutex_lock(&widget->codec->mutex);
1084         widget->value = val;
1085
1086         /* save volume value if the widget is powered down */
1087         if (widget->id == snd_soc_dapm_pga && !widget->power) {
1088                 widget->saved_value = val;
1089                 mutex_unlock(&widget->codec->mutex);
1090                 return 1;
1091         }
1092
1093         dapm_mixer_update_power(widget, kcontrol, reg, val_mask, val, invert);
1094         if (widget->event) {
1095                 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1096                         ret = widget->event(widget, SND_SOC_DAPM_PRE_REG);
1097                         if (ret < 0)
1098                                 goto out;
1099                 }
1100                 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1101                 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1102                         ret = widget->event(widget, SND_SOC_DAPM_POST_REG);
1103         } else
1104                 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1105
1106 out:
1107         mutex_unlock(&widget->codec->mutex);
1108         return ret;
1109 }
1110 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
1111
1112 /**
1113  * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
1114  * @kcontrol: mixer control
1115  * @uinfo: control element information
1116  *
1117  * Callback to get the value of a dapm enumerated double mixer control.
1118  *
1119  * Returns 0 for success.
1120  */
1121 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
1122         struct snd_ctl_elem_value *ucontrol)
1123 {
1124         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1125         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1126         unsigned short val, bitmask;
1127
1128         for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1129                 ;
1130         val = snd_soc_read(widget->codec, e->reg);
1131         ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
1132         if (e->shift_l != e->shift_r)
1133                 ucontrol->value.enumerated.item[1] =
1134                         (val >> e->shift_r) & (bitmask - 1);
1135
1136         return 0;
1137 }
1138 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
1139
1140 /**
1141  * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
1142  * @kcontrol: mixer control
1143  * @uinfo: control element information
1144  *
1145  * Callback to set the value of a dapm enumerated double mixer control.
1146  *
1147  * Returns 0 for success.
1148  */
1149 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
1150         struct snd_ctl_elem_value *ucontrol)
1151 {
1152         struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1153         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1154         unsigned short val, mux;
1155         unsigned short mask, bitmask;
1156         int ret = 0;
1157
1158         for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1159                 ;
1160         if (ucontrol->value.enumerated.item[0] > e->mask - 1)
1161                 return -EINVAL;
1162         mux = ucontrol->value.enumerated.item[0];
1163         val = mux << e->shift_l;
1164         mask = (bitmask - 1) << e->shift_l;
1165         if (e->shift_l != e->shift_r) {
1166                 if (ucontrol->value.enumerated.item[1] > e->mask - 1)
1167                         return -EINVAL;
1168                 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1169                 mask |= (bitmask - 1) << e->shift_r;
1170         }
1171
1172         mutex_lock(&widget->codec->mutex);
1173         widget->value = val;
1174         dapm_mux_update_power(widget, kcontrol, mask, mux, e);
1175         if (widget->event) {
1176                 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1177                         ret = widget->event(widget, SND_SOC_DAPM_PRE_REG);
1178                         if (ret < 0)
1179                                 goto out;
1180                 }
1181                 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1182                 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1183                         ret = widget->event(widget, SND_SOC_DAPM_POST_REG);
1184         } else
1185                 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1186
1187 out:
1188         mutex_unlock(&widget->codec->mutex);
1189         return ret;
1190 }
1191 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
1192
1193 /**
1194  * snd_soc_dapm_new_control - create new dapm control
1195  * @codec: audio codec
1196  * @widget: widget template
1197  *
1198  * Creates a new dapm control based upon the template.
1199  *
1200  * Returns 0 for success else error.
1201  */
1202 int snd_soc_dapm_new_control(struct snd_soc_codec *codec,
1203         const struct snd_soc_dapm_widget *widget)
1204 {
1205         struct snd_soc_dapm_widget *w;
1206
1207         if ((w = dapm_cnew_widget(widget)) == NULL)
1208                 return -ENOMEM;
1209
1210         w->codec = codec;
1211         INIT_LIST_HEAD(&w->sources);
1212         INIT_LIST_HEAD(&w->sinks);
1213         INIT_LIST_HEAD(&w->list);
1214         list_add(&w->list, &codec->dapm_widgets);
1215
1216         /* machine layer set ups unconnected pins and insertions */
1217         w->connected = 1;
1218         return 0;
1219 }
1220 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
1221
1222 /**
1223  * snd_soc_dapm_stream_event - send a stream event to the dapm core
1224  * @codec: audio codec
1225  * @stream: stream name
1226  * @event: stream event
1227  *
1228  * Sends a stream event to the dapm core. The core then makes any
1229  * necessary widget power changes.
1230  *
1231  * Returns 0 for success else error.
1232  */
1233 int snd_soc_dapm_stream_event(struct snd_soc_codec *codec,
1234         char *stream, int event)
1235 {
1236         struct snd_soc_dapm_widget *w;
1237
1238         if (stream == NULL)
1239                 return 0;
1240
1241         mutex_lock(&codec->mutex);
1242         list_for_each_entry(w, &codec->dapm_widgets, list)
1243         {
1244                 if (!w->sname)
1245                         continue;
1246                 dbg("widget %s\n %s stream %s event %d\n", w->name, w->sname,
1247                         stream, event);
1248                 if (strstr(w->sname, stream)) {
1249                         switch(event) {
1250                         case SND_SOC_DAPM_STREAM_START:
1251                                 w->active = 1;
1252                                 break;
1253                         case SND_SOC_DAPM_STREAM_STOP:
1254                                 w->active = 0;
1255                                 break;
1256                         case SND_SOC_DAPM_STREAM_SUSPEND:
1257                                 if (w->active)
1258                                         w->suspend = 1;
1259                                 w->active = 0;
1260                                 break;
1261                         case SND_SOC_DAPM_STREAM_RESUME:
1262                                 if (w->suspend) {
1263                                         w->active = 1;
1264                                         w->suspend = 0;
1265                                 }
1266                                 break;
1267                         case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
1268                                 break;
1269                         case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
1270                                 break;
1271                         }
1272                 }
1273         }
1274         mutex_unlock(&codec->mutex);
1275
1276         dapm_power_widgets(codec, event);
1277         dump_dapm(codec, __FUNCTION__);
1278         return 0;
1279 }
1280 EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event);
1281
1282 /**
1283  * snd_soc_dapm_set_endpoint - set audio endpoint status
1284  * @codec: audio codec
1285  * @endpoint: audio signal endpoint (or start point)
1286  * @status: point status
1287  *
1288  * Set audio endpoint status - connected or disconnected.
1289  *
1290  * Returns 0 for success else error.
1291  */
1292 int snd_soc_dapm_set_endpoint(struct snd_soc_codec *codec,
1293         char *endpoint, int status)
1294 {
1295         struct snd_soc_dapm_widget *w;
1296
1297         list_for_each_entry(w, &codec->dapm_widgets, list) {
1298                 if (!strcmp(w->name, endpoint)) {
1299                         w->connected = status;
1300                 }
1301         }
1302
1303         return 0;
1304 }
1305 EXPORT_SYMBOL_GPL(snd_soc_dapm_set_endpoint);
1306
1307 /**
1308  * snd_soc_dapm_free - free dapm resources
1309  * @socdev: SoC device
1310  *
1311  * Free all dapm widgets and resources.
1312  */
1313 void snd_soc_dapm_free(struct snd_soc_device *socdev)
1314 {
1315         struct snd_soc_codec *codec = socdev->codec;
1316
1317         snd_soc_dapm_sys_remove(socdev->dev);
1318         dapm_free_widgets(codec);
1319 }
1320 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
1321
1322 /* Module information */
1323 MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com");
1324 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
1325 MODULE_LICENSE("GPL");