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