?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hilkbd: Kill compiler warning and fix comment dyslexia
[wrt350n-kernel.git] / sound / soc / soc-dapm.c
blob7caf8c7b0ac5063c14a20784011de0951047e5c9
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->ext = 1;
887 }
888 if (wsource->id == snd_soc_dapm_output) {
889 if (wsink->id == snd_soc_dapm_spk ||
890 wsink->id == snd_soc_dapm_hp ||
891 wsink->id == snd_soc_dapm_line)
892 wsource->ext = 1;
893 }
894
895 /* connect static paths */
896 if (control == NULL) {
897 list_add(&path->list, &codec->dapm_paths);
898 list_add(&path->list_sink, &wsink->sources);
899 list_add(&path->list_source, &wsource->sinks);
900 path->connect = 1;
901 return 0;
902 }
903
904 /* connect dynamic paths */
905 switch(wsink->id) {
906 case snd_soc_dapm_adc:
907 case snd_soc_dapm_dac:
908 case snd_soc_dapm_pga:
909 case snd_soc_dapm_input:
910 case snd_soc_dapm_output:
911 case snd_soc_dapm_micbias:
912 case snd_soc_dapm_vmid:
913 case snd_soc_dapm_pre:
914 case snd_soc_dapm_post:
915 list_add(&path->list, &codec->dapm_paths);
916 list_add(&path->list_sink, &wsink->sources);
917 list_add(&path->list_source, &wsource->sinks);
918 path->connect = 1;
919 return 0;
920 case snd_soc_dapm_mux:
921 ret = dapm_connect_mux(codec, wsource, wsink, path, control,
922 &wsink->kcontrols[0]);
923 if (ret != 0)
924 goto err;
925 break;
926 case snd_soc_dapm_switch:
927 case snd_soc_dapm_mixer:
928 ret = dapm_connect_mixer(codec, wsource, wsink, path, control);
929 if (ret != 0)
930 goto err;
931 break;
932 case snd_soc_dapm_hp:
933 case snd_soc_dapm_mic:
934 case snd_soc_dapm_line:
935 case snd_soc_dapm_spk:
936 list_add(&path->list, &codec->dapm_paths);
937 list_add(&path->list_sink, &wsink->sources);
938 list_add(&path->list_source, &wsource->sinks);
939 path->connect = 0;
940 return 0;
941 }
942 return 0;
943
944 err:
945 printk(KERN_WARNING "asoc: no dapm match for %s --> %s --> %s\n", source,
946 control, sink);
947 kfree(path);
948 return ret;
949 }
950 EXPORT_SYMBOL_GPL(snd_soc_dapm_connect_input);
951
952 /**
953 * snd_soc_dapm_new_widgets - add new dapm widgets
954 * @codec: audio codec
955 *
956 * Checks the codec for any new dapm widgets and creates them if found.
957 *
958 * Returns 0 for success.
959 */
960 int snd_soc_dapm_new_widgets(struct snd_soc_codec *codec)
961 {
962 struct snd_soc_dapm_widget *w;
963
964 mutex_lock(&codec->mutex);
965 list_for_each_entry(w, &codec->dapm_widgets, list)
966 {
967 if (w->new)
968 continue;
969
970 switch(w->id) {
971 case snd_soc_dapm_switch:
972 case snd_soc_dapm_mixer:
973 dapm_new_mixer(codec, w);
974 break;
975 case snd_soc_dapm_mux:
976 dapm_new_mux(codec, w);
977 break;
978 case snd_soc_dapm_adc:
979 case snd_soc_dapm_dac:
980 case snd_soc_dapm_pga:
981 dapm_new_pga(codec, w);
982 break;
983 case snd_soc_dapm_input:
984 case snd_soc_dapm_output:
985 case snd_soc_dapm_micbias:
986 case snd_soc_dapm_spk:
987 case snd_soc_dapm_hp:
988 case snd_soc_dapm_mic:
989 case snd_soc_dapm_line:
990 case snd_soc_dapm_vmid:
991 case snd_soc_dapm_pre:
992 case snd_soc_dapm_post:
993 break;
994 }
995 w->new = 1;
996 }
997
998 dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
999 mutex_unlock(&codec->mutex);
1000 return 0;
1001 }
1002 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
1003
1004 /**
1005 * snd_soc_dapm_get_volsw - dapm mixer get callback
1006 * @kcontrol: mixer control
1007 * @uinfo: control element information
1008 *
1009 * Callback to get the value of a dapm mixer control.
1010 *
1011 * Returns 0 for success.
1012 */
1013 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
1014 struct snd_ctl_elem_value *ucontrol)
1015 {
1016 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1017 int reg = kcontrol->private_value & 0xff;
1018 int shift = (kcontrol->private_value >> 8) & 0x0f;
1019 int rshift = (kcontrol->private_value >> 12) & 0x0f;
1020 int mask = (kcontrol->private_value >> 16) & 0xff;
1021 int invert = (kcontrol->private_value >> 24) & 0x01;
1022
1023 /* return the saved value if we are powered down */
1024 if (widget->id == snd_soc_dapm_pga && !widget->power) {
1025 ucontrol->value.integer.value[0] = widget->saved_value;
1026 return 0;
1027 }
1028
1029 ucontrol->value.integer.value[0] =
1030 (snd_soc_read(widget->codec, reg) >> shift) & mask;
1031 if (shift != rshift)
1032 ucontrol->value.integer.value[1] =
1033 (snd_soc_read(widget->codec, reg) >> rshift) & mask;
1034 if (invert) {
1035 ucontrol->value.integer.value[0] =
1036 mask - ucontrol->value.integer.value[0];
1037 if (shift != rshift)
1038 ucontrol->value.integer.value[1] =
1039 mask - ucontrol->value.integer.value[1];
1040 }
1041
1042 return 0;
1043 }
1044 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
1045
1046 /**
1047 * snd_soc_dapm_put_volsw - dapm mixer set callback
1048 * @kcontrol: mixer control
1049 * @uinfo: control element information
1050 *
1051 * Callback to set the value of a dapm mixer control.
1052 *
1053 * Returns 0 for success.
1054 */
1055 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
1056 struct snd_ctl_elem_value *ucontrol)
1057 {
1058 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1059 int reg = kcontrol->private_value & 0xff;
1060 int shift = (kcontrol->private_value >> 8) & 0x0f;
1061 int rshift = (kcontrol->private_value >> 12) & 0x0f;
1062 int mask = (kcontrol->private_value >> 16) & 0xff;
1063 int invert = (kcontrol->private_value >> 24) & 0x01;
1064 unsigned short val, val2, val_mask;
1065 int ret;
1066
1067 val = (ucontrol->value.integer.value[0] & mask);
1068
1069 if (invert)
1070 val = mask - val;
1071 val_mask = mask << shift;
1072 val = val << shift;
1073 if (shift != rshift) {
1074 val2 = (ucontrol->value.integer.value[1] & mask);
1075 if (invert)
1076 val2 = mask - val2;
1077 val_mask |= mask << rshift;
1078 val |= val2 << rshift;
1079 }
1080
1081 mutex_lock(&widget->codec->mutex);
1082 widget->value = val;
1083
1084 /* save volume value if the widget is powered down */
1085 if (widget->id == snd_soc_dapm_pga && !widget->power) {
1086 widget->saved_value = val;
1087 mutex_unlock(&widget->codec->mutex);
1088 return 1;
1089 }
1090
1091 dapm_mixer_update_power(widget, kcontrol, reg, val_mask, val, invert);
1092 if (widget->event) {
1093 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1094 ret = widget->event(widget, SND_SOC_DAPM_PRE_REG);
1095 if (ret < 0)
1096 goto out;
1097 }
1098 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1099 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1100 ret = widget->event(widget, SND_SOC_DAPM_POST_REG);
1101 } else
1102 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1103
1104 out:
1105 mutex_unlock(&widget->codec->mutex);
1106 return ret;
1107 }
1108 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
1109
1110 /**
1111 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
1112 * @kcontrol: mixer control
1113 * @uinfo: control element information
1114 *
1115 * Callback to get the value of a dapm enumerated double mixer control.
1116 *
1117 * Returns 0 for success.
1118 */
1119 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
1120 struct snd_ctl_elem_value *ucontrol)
1121 {
1122 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1123 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1124 unsigned short val, bitmask;
1125
1126 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1127 ;
1128 val = snd_soc_read(widget->codec, e->reg);
1129 ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
1130 if (e->shift_l != e->shift_r)
1131 ucontrol->value.enumerated.item[1] =
1132 (val >> e->shift_r) & (bitmask - 1);
1133
1134 return 0;
1135 }
1136 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
1137
1138 /**
1139 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
1140 * @kcontrol: mixer control
1141 * @uinfo: control element information
1142 *
1143 * Callback to set the value of a dapm enumerated double mixer control.
1144 *
1145 * Returns 0 for success.
1146 */
1147 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
1148 struct snd_ctl_elem_value *ucontrol)
1149 {
1150 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol);
1151 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1152 unsigned short val, mux;
1153 unsigned short mask, bitmask;
1154 int ret = 0;
1155
1156 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1157 ;
1158 if (ucontrol->value.enumerated.item[0] > e->mask - 1)
1159 return -EINVAL;
1160 mux = ucontrol->value.enumerated.item[0];
1161 val = mux << e->shift_l;
1162 mask = (bitmask - 1) << e->shift_l;
1163 if (e->shift_l != e->shift_r) {
1164 if (ucontrol->value.enumerated.item[1] > e->mask - 1)
1165 return -EINVAL;
1166 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1167 mask |= (bitmask - 1) << e->shift_r;
1168 }
1169
1170 mutex_lock(&widget->codec->mutex);
1171 widget->value = val;
1172 dapm_mux_update_power(widget, kcontrol, mask, mux, e);
1173 if (widget->event) {
1174 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1175 ret = widget->event(widget, SND_SOC_DAPM_PRE_REG);
1176 if (ret < 0)
1177 goto out;
1178 }
1179 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1180 if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1181 ret = widget->event(widget, SND_SOC_DAPM_POST_REG);
1182 } else
1183 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1184
1185 out:
1186 mutex_unlock(&widget->codec->mutex);
1187 return ret;
1188 }
1189 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
1190
1191 /**
1192 * snd_soc_dapm_new_control - create new dapm control
1193 * @codec: audio codec
1194 * @widget: widget template
1195 *
1196 * Creates a new dapm control based upon the template.
1197 *
1198 * Returns 0 for success else error.
1199 */
1200 int snd_soc_dapm_new_control(struct snd_soc_codec *codec,
1201 const struct snd_soc_dapm_widget *widget)
1202 {
1203 struct snd_soc_dapm_widget *w;
1204
1205 if ((w = dapm_cnew_widget(widget)) == NULL)
1206 return -ENOMEM;
1207
1208 w->codec = codec;
1209 INIT_LIST_HEAD(&w->sources);
1210 INIT_LIST_HEAD(&w->sinks);
1211 INIT_LIST_HEAD(&w->list);
1212 list_add(&w->list, &codec->dapm_widgets);
1213
1214 /* machine layer set ups unconnected pins and insertions */
1215 w->connected = 1;
1216 return 0;
1217 }
1218 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
1219
1220 /**
1221 * snd_soc_dapm_stream_event - send a stream event to the dapm core
1222 * @codec: audio codec
1223 * @stream: stream name
1224 * @event: stream event
1225 *
1226 * Sends a stream event to the dapm core. The core then makes any
1227 * necessary widget power changes.
1228 *
1229 * Returns 0 for success else error.
1230 */
1231 int snd_soc_dapm_stream_event(struct snd_soc_codec *codec,
1232 char *stream, int event)
1233 {
1234 struct snd_soc_dapm_widget *w;
1235
1236 if (stream == NULL)
1237 return 0;
1238
1239 mutex_lock(&codec->mutex);
1240 list_for_each_entry(w, &codec->dapm_widgets, list)
1241 {
1242 if (!w->sname)
1243 continue;
1244 dbg("widget %s\n %s stream %s event %d\n", w->name, w->sname,
1245 stream, event);
1246 if (strstr(w->sname, stream)) {
1247 switch(event) {
1248 case SND_SOC_DAPM_STREAM_START:
1249 w->active = 1;
1250 break;
1251 case SND_SOC_DAPM_STREAM_STOP:
1252 w->active = 0;
1253 break;
1254 case SND_SOC_DAPM_STREAM_SUSPEND:
1255 if (w->active)
1256 w->suspend = 1;
1257 w->active = 0;
1258 break;
1259 case SND_SOC_DAPM_STREAM_RESUME:
1260 if (w->suspend) {
1261 w->active = 1;
1262 w->suspend = 0;
1263 }
1264 break;
1265 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
1266 break;
1267 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
1268 break;
1269 }
1270 }
1271 }
1272 mutex_unlock(&codec->mutex);
1273
1274 dapm_power_widgets(codec, event);
1275 dump_dapm(codec, __FUNCTION__);
1276 return 0;
1277 }
1278 EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event);
1279
1280 /**
1281 * snd_soc_dapm_set_endpoint - set audio endpoint status
1282 * @codec: audio codec
1283 * @endpoint: audio signal endpoint (or start point)
1284 * @status: point status
1285 *
1286 * Set audio endpoint status - connected or disconnected.
1287 *
1288 * Returns 0 for success else error.
1289 */
1290 int snd_soc_dapm_set_endpoint(struct snd_soc_codec *codec,
1291 char *endpoint, int status)
1292 {
1293 struct snd_soc_dapm_widget *w;
1294
1295 list_for_each_entry(w, &codec->dapm_widgets, list) {
1296 if (!strcmp(w->name, endpoint)) {
1297 w->connected = status;
1298 }
1299 }
1300
1301 return 0;
1302 }
1303 EXPORT_SYMBOL_GPL(snd_soc_dapm_set_endpoint);
1304
1305 /**
1306 * snd_soc_dapm_free - free dapm resources
1307 * @socdev: SoC device
1308 *
1309 * Free all dapm widgets and resources.
1310 */
1311 void snd_soc_dapm_free(struct snd_soc_device *socdev)
1312 {
1313 struct snd_soc_codec *codec = socdev->codec;
1314
1315 snd_soc_dapm_sys_remove(socdev->dev);
1316 dapm_free_widgets(codec);
1317 }
1318 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
1319
1320 /* Module information */
1321 MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com");
1322 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
1323 MODULE_LICENSE("GPL");
WRT350N Kernel Patches