Merge branch 'pm-cpufreq-fixes'
[linux-2.6-microblaze.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 <lrg@slimlogic.co.uk>
6  *
7  *  This program is free software; you can redistribute  it and/or modify it
8  *  under  the terms of  the GNU General  Public License as published by the
9  *  Free Software Foundation;  either version 2 of the  License, or (at your
10  *  option) any later version.
11  *
12  *  Features:
13  *    o Changes power status of internal codec blocks depending on the
14  *      dynamic configuration of codec internal audio paths and active
15  *      DACs/ADCs.
16  *    o Platform power domain - can support external components i.e. amps and
17  *      mic/headphone insertion events.
18  *    o Automatic Mic Bias support
19  *    o Jack insertion power event initiation - e.g. hp insertion will enable
20  *      sinks, dacs, etc
21  *    o Delayed power down of audio subsystem to reduce pops between a quick
22  *      device reopen.
23  *
24  */
25
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/init.h>
29 #include <linux/async.h>
30 #include <linux/delay.h>
31 #include <linux/pm.h>
32 #include <linux/bitops.h>
33 #include <linux/platform_device.h>
34 #include <linux/jiffies.h>
35 #include <linux/debugfs.h>
36 #include <linux/pm_runtime.h>
37 #include <linux/regulator/consumer.h>
38 #include <linux/clk.h>
39 #include <linux/slab.h>
40 #include <sound/core.h>
41 #include <sound/pcm.h>
42 #include <sound/pcm_params.h>
43 #include <sound/soc.h>
44 #include <sound/initval.h>
45
46 #include <trace/events/asoc.h>
47
48 #define DAPM_UPDATE_STAT(widget, val) widget->dapm->card->dapm_stats.val++;
49
50 #define SND_SOC_DAPM_DIR_REVERSE(x) ((x == SND_SOC_DAPM_DIR_IN) ? \
51         SND_SOC_DAPM_DIR_OUT : SND_SOC_DAPM_DIR_IN)
52
53 #define snd_soc_dapm_for_each_direction(dir) \
54         for ((dir) = SND_SOC_DAPM_DIR_IN; (dir) <= SND_SOC_DAPM_DIR_OUT; \
55                 (dir)++)
56
57 static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
58         struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
59         const char *control,
60         int (*connected)(struct snd_soc_dapm_widget *source,
61                          struct snd_soc_dapm_widget *sink));
62
63 struct snd_soc_dapm_widget *
64 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
65                          const struct snd_soc_dapm_widget *widget);
66
67 struct snd_soc_dapm_widget *
68 snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
69                          const struct snd_soc_dapm_widget *widget);
70
71 /* dapm power sequences - make this per codec in the future */
72 static int dapm_up_seq[] = {
73         [snd_soc_dapm_pre] = 0,
74         [snd_soc_dapm_regulator_supply] = 1,
75         [snd_soc_dapm_clock_supply] = 1,
76         [snd_soc_dapm_supply] = 2,
77         [snd_soc_dapm_micbias] = 3,
78         [snd_soc_dapm_dai_link] = 2,
79         [snd_soc_dapm_dai_in] = 4,
80         [snd_soc_dapm_dai_out] = 4,
81         [snd_soc_dapm_aif_in] = 4,
82         [snd_soc_dapm_aif_out] = 4,
83         [snd_soc_dapm_mic] = 5,
84         [snd_soc_dapm_mux] = 6,
85         [snd_soc_dapm_demux] = 6,
86         [snd_soc_dapm_dac] = 7,
87         [snd_soc_dapm_switch] = 8,
88         [snd_soc_dapm_mixer] = 8,
89         [snd_soc_dapm_mixer_named_ctl] = 8,
90         [snd_soc_dapm_pga] = 9,
91         [snd_soc_dapm_adc] = 10,
92         [snd_soc_dapm_out_drv] = 11,
93         [snd_soc_dapm_hp] = 11,
94         [snd_soc_dapm_spk] = 11,
95         [snd_soc_dapm_line] = 11,
96         [snd_soc_dapm_kcontrol] = 12,
97         [snd_soc_dapm_post] = 13,
98 };
99
100 static int dapm_down_seq[] = {
101         [snd_soc_dapm_pre] = 0,
102         [snd_soc_dapm_kcontrol] = 1,
103         [snd_soc_dapm_adc] = 2,
104         [snd_soc_dapm_hp] = 3,
105         [snd_soc_dapm_spk] = 3,
106         [snd_soc_dapm_line] = 3,
107         [snd_soc_dapm_out_drv] = 3,
108         [snd_soc_dapm_pga] = 4,
109         [snd_soc_dapm_switch] = 5,
110         [snd_soc_dapm_mixer_named_ctl] = 5,
111         [snd_soc_dapm_mixer] = 5,
112         [snd_soc_dapm_dac] = 6,
113         [snd_soc_dapm_mic] = 7,
114         [snd_soc_dapm_micbias] = 8,
115         [snd_soc_dapm_mux] = 9,
116         [snd_soc_dapm_demux] = 9,
117         [snd_soc_dapm_aif_in] = 10,
118         [snd_soc_dapm_aif_out] = 10,
119         [snd_soc_dapm_dai_in] = 10,
120         [snd_soc_dapm_dai_out] = 10,
121         [snd_soc_dapm_dai_link] = 11,
122         [snd_soc_dapm_supply] = 12,
123         [snd_soc_dapm_clock_supply] = 13,
124         [snd_soc_dapm_regulator_supply] = 13,
125         [snd_soc_dapm_post] = 14,
126 };
127
128 static void dapm_assert_locked(struct snd_soc_dapm_context *dapm)
129 {
130         if (dapm->card && dapm->card->instantiated)
131                 lockdep_assert_held(&dapm->card->dapm_mutex);
132 }
133
134 static void pop_wait(u32 pop_time)
135 {
136         if (pop_time)
137                 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
138 }
139
140 static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
141 {
142         va_list args;
143         char *buf;
144
145         if (!pop_time)
146                 return;
147
148         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
149         if (buf == NULL)
150                 return;
151
152         va_start(args, fmt);
153         vsnprintf(buf, PAGE_SIZE, fmt, args);
154         dev_info(dev, "%s", buf);
155         va_end(args);
156
157         kfree(buf);
158 }
159
160 static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
161 {
162         return !list_empty(&w->dirty);
163 }
164
165 static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
166 {
167         dapm_assert_locked(w->dapm);
168
169         if (!dapm_dirty_widget(w)) {
170                 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
171                          w->name, reason);
172                 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
173         }
174 }
175
176 /*
177  * Common implementation for dapm_widget_invalidate_input_paths() and
178  * dapm_widget_invalidate_output_paths(). The function is inlined since the
179  * combined size of the two specialized functions is only marginally larger then
180  * the size of the generic function and at the same time the fast path of the
181  * specialized functions is significantly smaller than the generic function.
182  */
183 static __always_inline void dapm_widget_invalidate_paths(
184         struct snd_soc_dapm_widget *w, enum snd_soc_dapm_direction dir)
185 {
186         enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
187         struct snd_soc_dapm_widget *node;
188         struct snd_soc_dapm_path *p;
189         LIST_HEAD(list);
190
191         dapm_assert_locked(w->dapm);
192
193         if (w->endpoints[dir] == -1)
194                 return;
195
196         list_add_tail(&w->work_list, &list);
197         w->endpoints[dir] = -1;
198
199         list_for_each_entry(w, &list, work_list) {
200                 snd_soc_dapm_widget_for_each_path(w, dir, p) {
201                         if (p->is_supply || p->weak || !p->connect)
202                                 continue;
203                         node = p->node[rdir];
204                         if (node->endpoints[dir] != -1) {
205                                 node->endpoints[dir] = -1;
206                                 list_add_tail(&node->work_list, &list);
207                         }
208                 }
209         }
210 }
211
212 /*
213  * dapm_widget_invalidate_input_paths() - Invalidate the cached number of
214  *  input paths
215  * @w: The widget for which to invalidate the cached number of input paths
216  *
217  * Resets the cached number of inputs for the specified widget and all widgets
218  * that can be reached via outcoming paths from the widget.
219  *
220  * This function must be called if the number of output paths for a widget might
221  * have changed. E.g. if the source state of a widget changes or a path is added
222  * or activated with the widget as the sink.
223  */
224 static void dapm_widget_invalidate_input_paths(struct snd_soc_dapm_widget *w)
225 {
226         dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_IN);
227 }
228
229 /*
230  * dapm_widget_invalidate_output_paths() - Invalidate the cached number of
231  *  output paths
232  * @w: The widget for which to invalidate the cached number of output paths
233  *
234  * Resets the cached number of outputs for the specified widget and all widgets
235  * that can be reached via incoming paths from the widget.
236  *
237  * This function must be called if the number of output paths for a widget might
238  * have changed. E.g. if the sink state of a widget changes or a path is added
239  * or activated with the widget as the source.
240  */
241 static void dapm_widget_invalidate_output_paths(struct snd_soc_dapm_widget *w)
242 {
243         dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_OUT);
244 }
245
246 /*
247  * dapm_path_invalidate() - Invalidates the cached number of inputs and outputs
248  *  for the widgets connected to a path
249  * @p: The path to invalidate
250  *
251  * Resets the cached number of inputs for the sink of the path and the cached
252  * number of outputs for the source of the path.
253  *
254  * This function must be called when a path is added, removed or the connected
255  * state changes.
256  */
257 static void dapm_path_invalidate(struct snd_soc_dapm_path *p)
258 {
259         /*
260          * Weak paths or supply paths do not influence the number of input or
261          * output paths of their neighbors.
262          */
263         if (p->weak || p->is_supply)
264                 return;
265
266         /*
267          * The number of connected endpoints is the sum of the number of
268          * connected endpoints of all neighbors. If a node with 0 connected
269          * endpoints is either connected or disconnected that sum won't change,
270          * so there is no need to re-check the path.
271          */
272         if (p->source->endpoints[SND_SOC_DAPM_DIR_IN] != 0)
273                 dapm_widget_invalidate_input_paths(p->sink);
274         if (p->sink->endpoints[SND_SOC_DAPM_DIR_OUT] != 0)
275                 dapm_widget_invalidate_output_paths(p->source);
276 }
277
278 void dapm_mark_endpoints_dirty(struct snd_soc_card *card)
279 {
280         struct snd_soc_dapm_widget *w;
281
282         mutex_lock(&card->dapm_mutex);
283
284         list_for_each_entry(w, &card->widgets, list) {
285                 if (w->is_ep) {
286                         dapm_mark_dirty(w, "Rechecking endpoints");
287                         if (w->is_ep & SND_SOC_DAPM_EP_SINK)
288                                 dapm_widget_invalidate_output_paths(w);
289                         if (w->is_ep & SND_SOC_DAPM_EP_SOURCE)
290                                 dapm_widget_invalidate_input_paths(w);
291                 }
292         }
293
294         mutex_unlock(&card->dapm_mutex);
295 }
296 EXPORT_SYMBOL_GPL(dapm_mark_endpoints_dirty);
297
298 /* create a new dapm widget */
299 static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
300         const struct snd_soc_dapm_widget *_widget)
301 {
302         return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
303 }
304
305 struct dapm_kcontrol_data {
306         unsigned int value;
307         struct snd_soc_dapm_widget *widget;
308         struct list_head paths;
309         struct snd_soc_dapm_widget_list *wlist;
310 };
311
312 static int dapm_kcontrol_data_alloc(struct snd_soc_dapm_widget *widget,
313         struct snd_kcontrol *kcontrol, const char *ctrl_name)
314 {
315         struct dapm_kcontrol_data *data;
316         struct soc_mixer_control *mc;
317         struct soc_enum *e;
318         const char *name;
319         int ret;
320
321         data = kzalloc(sizeof(*data), GFP_KERNEL);
322         if (!data)
323                 return -ENOMEM;
324
325         INIT_LIST_HEAD(&data->paths);
326
327         switch (widget->id) {
328         case snd_soc_dapm_switch:
329         case snd_soc_dapm_mixer:
330         case snd_soc_dapm_mixer_named_ctl:
331                 mc = (struct soc_mixer_control *)kcontrol->private_value;
332
333                 if (mc->autodisable) {
334                         struct snd_soc_dapm_widget template;
335
336                         name = kasprintf(GFP_KERNEL, "%s %s", ctrl_name,
337                                          "Autodisable");
338                         if (!name) {
339                                 ret = -ENOMEM;
340                                 goto err_data;
341                         }
342
343                         memset(&template, 0, sizeof(template));
344                         template.reg = mc->reg;
345                         template.mask = (1 << fls(mc->max)) - 1;
346                         template.shift = mc->shift;
347                         if (mc->invert)
348                                 template.off_val = mc->max;
349                         else
350                                 template.off_val = 0;
351                         template.on_val = template.off_val;
352                         template.id = snd_soc_dapm_kcontrol;
353                         template.name = name;
354
355                         data->value = template.on_val;
356
357                         data->widget =
358                                 snd_soc_dapm_new_control_unlocked(widget->dapm,
359                                 &template);
360                         kfree(name);
361                         if (!data->widget) {
362                                 ret = -ENOMEM;
363                                 goto err_data;
364                         }
365                 }
366                 break;
367         case snd_soc_dapm_demux:
368         case snd_soc_dapm_mux:
369                 e = (struct soc_enum *)kcontrol->private_value;
370
371                 if (e->autodisable) {
372                         struct snd_soc_dapm_widget template;
373
374                         name = kasprintf(GFP_KERNEL, "%s %s", ctrl_name,
375                                          "Autodisable");
376                         if (!name) {
377                                 ret = -ENOMEM;
378                                 goto err_data;
379                         }
380
381                         memset(&template, 0, sizeof(template));
382                         template.reg = e->reg;
383                         template.mask = e->mask << e->shift_l;
384                         template.shift = e->shift_l;
385                         template.off_val = snd_soc_enum_item_to_val(e, 0);
386                         template.on_val = template.off_val;
387                         template.id = snd_soc_dapm_kcontrol;
388                         template.name = name;
389
390                         data->value = template.on_val;
391
392                         data->widget = snd_soc_dapm_new_control_unlocked(
393                                                 widget->dapm, &template);
394                         kfree(name);
395                         if (!data->widget) {
396                                 ret = -ENOMEM;
397                                 goto err_data;
398                         }
399
400                         snd_soc_dapm_add_path(widget->dapm, data->widget,
401                                               widget, NULL, NULL);
402                 }
403                 break;
404         default:
405                 break;
406         }
407
408         kcontrol->private_data = data;
409
410         return 0;
411
412 err_data:
413         kfree(data);
414         return ret;
415 }
416
417 static void dapm_kcontrol_free(struct snd_kcontrol *kctl)
418 {
419         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kctl);
420         kfree(data->wlist);
421         kfree(data);
422 }
423
424 static struct snd_soc_dapm_widget_list *dapm_kcontrol_get_wlist(
425         const struct snd_kcontrol *kcontrol)
426 {
427         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
428
429         return data->wlist;
430 }
431
432 static int dapm_kcontrol_add_widget(struct snd_kcontrol *kcontrol,
433         struct snd_soc_dapm_widget *widget)
434 {
435         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
436         struct snd_soc_dapm_widget_list *new_wlist;
437         unsigned int n;
438
439         if (data->wlist)
440                 n = data->wlist->num_widgets + 1;
441         else
442                 n = 1;
443
444         new_wlist = krealloc(data->wlist,
445                         sizeof(*new_wlist) + sizeof(widget) * n, GFP_KERNEL);
446         if (!new_wlist)
447                 return -ENOMEM;
448
449         new_wlist->widgets[n - 1] = widget;
450         new_wlist->num_widgets = n;
451
452         data->wlist = new_wlist;
453
454         return 0;
455 }
456
457 static void dapm_kcontrol_add_path(const struct snd_kcontrol *kcontrol,
458         struct snd_soc_dapm_path *path)
459 {
460         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
461
462         list_add_tail(&path->list_kcontrol, &data->paths);
463 }
464
465 static bool dapm_kcontrol_is_powered(const struct snd_kcontrol *kcontrol)
466 {
467         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
468
469         if (!data->widget)
470                 return true;
471
472         return data->widget->power;
473 }
474
475 static struct list_head *dapm_kcontrol_get_path_list(
476         const struct snd_kcontrol *kcontrol)
477 {
478         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
479
480         return &data->paths;
481 }
482
483 #define dapm_kcontrol_for_each_path(path, kcontrol) \
484         list_for_each_entry(path, dapm_kcontrol_get_path_list(kcontrol), \
485                 list_kcontrol)
486
487 unsigned int dapm_kcontrol_get_value(const struct snd_kcontrol *kcontrol)
488 {
489         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
490
491         return data->value;
492 }
493 EXPORT_SYMBOL_GPL(dapm_kcontrol_get_value);
494
495 static bool dapm_kcontrol_set_value(const struct snd_kcontrol *kcontrol,
496         unsigned int value)
497 {
498         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
499
500         if (data->value == value)
501                 return false;
502
503         if (data->widget)
504                 data->widget->on_val = value;
505
506         data->value = value;
507
508         return true;
509 }
510
511 /**
512  * snd_soc_dapm_kcontrol_widget() - Returns the widget associated to a
513  *   kcontrol
514  * @kcontrol: The kcontrol
515  */
516 struct snd_soc_dapm_widget *snd_soc_dapm_kcontrol_widget(
517                                 struct snd_kcontrol *kcontrol)
518 {
519         return dapm_kcontrol_get_wlist(kcontrol)->widgets[0];
520 }
521 EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_widget);
522
523 /**
524  * snd_soc_dapm_kcontrol_dapm() - Returns the dapm context associated to a
525  *  kcontrol
526  * @kcontrol: The kcontrol
527  *
528  * Note: This function must only be used on kcontrols that are known to have
529  * been registered for a CODEC. Otherwise the behaviour is undefined.
530  */
531 struct snd_soc_dapm_context *snd_soc_dapm_kcontrol_dapm(
532         struct snd_kcontrol *kcontrol)
533 {
534         return dapm_kcontrol_get_wlist(kcontrol)->widgets[0]->dapm;
535 }
536 EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_dapm);
537
538 static void dapm_reset(struct snd_soc_card *card)
539 {
540         struct snd_soc_dapm_widget *w;
541
542         lockdep_assert_held(&card->dapm_mutex);
543
544         memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
545
546         list_for_each_entry(w, &card->widgets, list) {
547                 w->new_power = w->power;
548                 w->power_checked = false;
549         }
550 }
551
552 static const char *soc_dapm_prefix(struct snd_soc_dapm_context *dapm)
553 {
554         if (!dapm->component)
555                 return NULL;
556         return dapm->component->name_prefix;
557 }
558
559 static int soc_dapm_read(struct snd_soc_dapm_context *dapm, int reg,
560         unsigned int *value)
561 {
562         if (!dapm->component)
563                 return -EIO;
564         return snd_soc_component_read(dapm->component, reg, value);
565 }
566
567 static int soc_dapm_update_bits(struct snd_soc_dapm_context *dapm,
568         int reg, unsigned int mask, unsigned int value)
569 {
570         if (!dapm->component)
571                 return -EIO;
572         return snd_soc_component_update_bits(dapm->component, reg,
573                                              mask, value);
574 }
575
576 static int soc_dapm_test_bits(struct snd_soc_dapm_context *dapm,
577         int reg, unsigned int mask, unsigned int value)
578 {
579         if (!dapm->component)
580                 return -EIO;
581         return snd_soc_component_test_bits(dapm->component, reg, mask, value);
582 }
583
584 static void soc_dapm_async_complete(struct snd_soc_dapm_context *dapm)
585 {
586         if (dapm->component)
587                 snd_soc_component_async_complete(dapm->component);
588 }
589
590 static struct snd_soc_dapm_widget *
591 dapm_wcache_lookup(struct snd_soc_dapm_wcache *wcache, const char *name)
592 {
593         struct snd_soc_dapm_widget *w = wcache->widget;
594         struct list_head *wlist;
595         const int depth = 2;
596         int i = 0;
597
598         if (w) {
599                 wlist = &w->dapm->card->widgets;
600
601                 list_for_each_entry_from(w, wlist, list) {
602                         if (!strcmp(name, w->name))
603                                 return w;
604
605                         if (++i == depth)
606                                 break;
607                 }
608         }
609
610         return NULL;
611 }
612
613 static inline void dapm_wcache_update(struct snd_soc_dapm_wcache *wcache,
614                                       struct snd_soc_dapm_widget *w)
615 {
616         wcache->widget = w;
617 }
618
619 /**
620  * snd_soc_dapm_force_bias_level() - Sets the DAPM bias level
621  * @dapm: The DAPM context for which to set the level
622  * @level: The level to set
623  *
624  * Forces the DAPM bias level to a specific state. It will call the bias level
625  * callback of DAPM context with the specified level. This will even happen if
626  * the context is already at the same level. Furthermore it will not go through
627  * the normal bias level sequencing, meaning any intermediate states between the
628  * current and the target state will not be entered.
629  *
630  * Note that the change in bias level is only temporary and the next time
631  * snd_soc_dapm_sync() is called the state will be set to the level as
632  * determined by the DAPM core. The function is mainly intended to be used to
633  * used during probe or resume from suspend to power up the device so
634  * initialization can be done, before the DAPM core takes over.
635  */
636 int snd_soc_dapm_force_bias_level(struct snd_soc_dapm_context *dapm,
637         enum snd_soc_bias_level level)
638 {
639         int ret = 0;
640
641         if (dapm->set_bias_level)
642                 ret = dapm->set_bias_level(dapm, level);
643
644         if (ret == 0)
645                 dapm->bias_level = level;
646
647         return ret;
648 }
649 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_bias_level);
650
651 /**
652  * snd_soc_dapm_set_bias_level - set the bias level for the system
653  * @dapm: DAPM context
654  * @level: level to configure
655  *
656  * Configure the bias (power) levels for the SoC audio device.
657  *
658  * Returns 0 for success else error.
659  */
660 static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
661                                        enum snd_soc_bias_level level)
662 {
663         struct snd_soc_card *card = dapm->card;
664         int ret = 0;
665
666         trace_snd_soc_bias_level_start(card, level);
667
668         if (card && card->set_bias_level)
669                 ret = card->set_bias_level(card, dapm, level);
670         if (ret != 0)
671                 goto out;
672
673         if (!card || dapm != &card->dapm)
674                 ret = snd_soc_dapm_force_bias_level(dapm, level);
675
676         if (ret != 0)
677                 goto out;
678
679         if (card && card->set_bias_level_post)
680                 ret = card->set_bias_level_post(card, dapm, level);
681 out:
682         trace_snd_soc_bias_level_done(card, level);
683
684         return ret;
685 }
686
687 /* connect mux widget to its interconnecting audio paths */
688 static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
689         struct snd_soc_dapm_path *path, const char *control_name,
690         struct snd_soc_dapm_widget *w)
691 {
692         const struct snd_kcontrol_new *kcontrol = &w->kcontrol_news[0];
693         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
694         unsigned int val, item;
695         int i;
696
697         if (e->reg != SND_SOC_NOPM) {
698                 soc_dapm_read(dapm, e->reg, &val);
699                 val = (val >> e->shift_l) & e->mask;
700                 item = snd_soc_enum_val_to_item(e, val);
701         } else {
702                 /* since a virtual mux has no backing registers to
703                  * decide which path to connect, it will try to match
704                  * with the first enumeration.  This is to ensure
705                  * that the default mux choice (the first) will be
706                  * correctly powered up during initialization.
707                  */
708                 item = 0;
709         }
710
711         for (i = 0; i < e->items; i++) {
712                 if (!(strcmp(control_name, e->texts[i]))) {
713                         path->name = e->texts[i];
714                         if (i == item)
715                                 path->connect = 1;
716                         else
717                                 path->connect = 0;
718                         return 0;
719                 }
720         }
721
722         return -ENODEV;
723 }
724
725 /* set up initial codec paths */
726 static void dapm_set_mixer_path_status(struct snd_soc_dapm_path *p, int i)
727 {
728         struct soc_mixer_control *mc = (struct soc_mixer_control *)
729                 p->sink->kcontrol_news[i].private_value;
730         unsigned int reg = mc->reg;
731         unsigned int shift = mc->shift;
732         unsigned int max = mc->max;
733         unsigned int mask = (1 << fls(max)) - 1;
734         unsigned int invert = mc->invert;
735         unsigned int val;
736
737         if (reg != SND_SOC_NOPM) {
738                 soc_dapm_read(p->sink->dapm, reg, &val);
739                 val = (val >> shift) & mask;
740                 if (invert)
741                         val = max - val;
742                 p->connect = !!val;
743         } else {
744                 p->connect = 0;
745         }
746 }
747
748 /* connect mixer widget to its interconnecting audio paths */
749 static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
750         struct snd_soc_dapm_path *path, const char *control_name)
751 {
752         int i;
753
754         /* search for mixer kcontrol */
755         for (i = 0; i < path->sink->num_kcontrols; i++) {
756                 if (!strcmp(control_name, path->sink->kcontrol_news[i].name)) {
757                         path->name = path->sink->kcontrol_news[i].name;
758                         dapm_set_mixer_path_status(path, i);
759                         return 0;
760                 }
761         }
762         return -ENODEV;
763 }
764
765 static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
766         struct snd_soc_dapm_widget *kcontrolw,
767         const struct snd_kcontrol_new *kcontrol_new,
768         struct snd_kcontrol **kcontrol)
769 {
770         struct snd_soc_dapm_widget *w;
771         int i;
772
773         *kcontrol = NULL;
774
775         list_for_each_entry(w, &dapm->card->widgets, list) {
776                 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
777                         continue;
778                 for (i = 0; i < w->num_kcontrols; i++) {
779                         if (&w->kcontrol_news[i] == kcontrol_new) {
780                                 if (w->kcontrols)
781                                         *kcontrol = w->kcontrols[i];
782                                 return 1;
783                         }
784                 }
785         }
786
787         return 0;
788 }
789
790 /*
791  * Determine if a kcontrol is shared. If it is, look it up. If it isn't,
792  * create it. Either way, add the widget into the control's widget list
793  */
794 static int dapm_create_or_share_kcontrol(struct snd_soc_dapm_widget *w,
795         int kci)
796 {
797         struct snd_soc_dapm_context *dapm = w->dapm;
798         struct snd_card *card = dapm->card->snd_card;
799         const char *prefix;
800         size_t prefix_len;
801         int shared;
802         struct snd_kcontrol *kcontrol;
803         bool wname_in_long_name, kcname_in_long_name;
804         char *long_name = NULL;
805         const char *name;
806         int ret = 0;
807
808         prefix = soc_dapm_prefix(dapm);
809         if (prefix)
810                 prefix_len = strlen(prefix) + 1;
811         else
812                 prefix_len = 0;
813
814         shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],
815                                          &kcontrol);
816
817         if (!kcontrol) {
818                 if (shared) {
819                         wname_in_long_name = false;
820                         kcname_in_long_name = true;
821                 } else {
822                         switch (w->id) {
823                         case snd_soc_dapm_switch:
824                         case snd_soc_dapm_mixer:
825                         case snd_soc_dapm_pga:
826                                 wname_in_long_name = true;
827                                 kcname_in_long_name = true;
828                                 break;
829                         case snd_soc_dapm_mixer_named_ctl:
830                                 wname_in_long_name = false;
831                                 kcname_in_long_name = true;
832                                 break;
833                         case snd_soc_dapm_demux:
834                         case snd_soc_dapm_mux:
835                                 wname_in_long_name = true;
836                                 kcname_in_long_name = false;
837                                 break;
838                         default:
839                                 return -EINVAL;
840                         }
841                 }
842
843                 if (wname_in_long_name && kcname_in_long_name) {
844                         /*
845                          * The control will get a prefix from the control
846                          * creation process but we're also using the same
847                          * prefix for widgets so cut the prefix off the
848                          * front of the widget name.
849                          */
850                         long_name = kasprintf(GFP_KERNEL, "%s %s",
851                                  w->name + prefix_len,
852                                  w->kcontrol_news[kci].name);
853                         if (long_name == NULL)
854                                 return -ENOMEM;
855
856                         name = long_name;
857                 } else if (wname_in_long_name) {
858                         long_name = NULL;
859                         name = w->name + prefix_len;
860                 } else {
861                         long_name = NULL;
862                         name = w->kcontrol_news[kci].name;
863                 }
864
865                 kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,
866                                         prefix);
867                 if (!kcontrol) {
868                         ret = -ENOMEM;
869                         goto exit_free;
870                 }
871
872                 kcontrol->private_free = dapm_kcontrol_free;
873
874                 ret = dapm_kcontrol_data_alloc(w, kcontrol, name);
875                 if (ret) {
876                         snd_ctl_free_one(kcontrol);
877                         goto exit_free;
878                 }
879
880                 ret = snd_ctl_add(card, kcontrol);
881                 if (ret < 0) {
882                         dev_err(dapm->dev,
883                                 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
884                                 w->name, name, ret);
885                         goto exit_free;
886                 }
887         }
888
889         ret = dapm_kcontrol_add_widget(kcontrol, w);
890         if (ret == 0)
891                 w->kcontrols[kci] = kcontrol;
892
893 exit_free:
894         kfree(long_name);
895
896         return ret;
897 }
898
899 /* create new dapm mixer control */
900 static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
901 {
902         int i, ret;
903         struct snd_soc_dapm_path *path;
904         struct dapm_kcontrol_data *data;
905
906         /* add kcontrol */
907         for (i = 0; i < w->num_kcontrols; i++) {
908                 /* match name */
909                 snd_soc_dapm_widget_for_each_source_path(w, path) {
910                         /* mixer/mux paths name must match control name */
911                         if (path->name != (char *)w->kcontrol_news[i].name)
912                                 continue;
913
914                         if (!w->kcontrols[i]) {
915                                 ret = dapm_create_or_share_kcontrol(w, i);
916                                 if (ret < 0)
917                                         return ret;
918                         }
919
920                         dapm_kcontrol_add_path(w->kcontrols[i], path);
921
922                         data = snd_kcontrol_chip(w->kcontrols[i]);
923                         if (data->widget)
924                                 snd_soc_dapm_add_path(data->widget->dapm,
925                                                       data->widget,
926                                                       path->source,
927                                                       NULL, NULL);
928                 }
929         }
930
931         return 0;
932 }
933
934 /* create new dapm mux control */
935 static int dapm_new_mux(struct snd_soc_dapm_widget *w)
936 {
937         struct snd_soc_dapm_context *dapm = w->dapm;
938         enum snd_soc_dapm_direction dir;
939         struct snd_soc_dapm_path *path;
940         const char *type;
941         int ret;
942
943         switch (w->id) {
944         case snd_soc_dapm_mux:
945                 dir = SND_SOC_DAPM_DIR_OUT;
946                 type = "mux";
947                 break;
948         case snd_soc_dapm_demux:
949                 dir = SND_SOC_DAPM_DIR_IN;
950                 type = "demux";
951                 break;
952         default:
953                 return -EINVAL;
954         }
955
956         if (w->num_kcontrols != 1) {
957                 dev_err(dapm->dev,
958                         "ASoC: %s %s has incorrect number of controls\n", type,
959                         w->name);
960                 return -EINVAL;
961         }
962
963         if (list_empty(&w->edges[dir])) {
964                 dev_err(dapm->dev, "ASoC: %s %s has no paths\n", type, w->name);
965                 return -EINVAL;
966         }
967
968         ret = dapm_create_or_share_kcontrol(w, 0);
969         if (ret < 0)
970                 return ret;
971
972         snd_soc_dapm_widget_for_each_path(w, dir, path) {
973                 if (path->name)
974                         dapm_kcontrol_add_path(w->kcontrols[0], path);
975         }
976
977         return 0;
978 }
979
980 /* create new dapm volume control */
981 static int dapm_new_pga(struct snd_soc_dapm_widget *w)
982 {
983         int i, ret;
984
985         for (i = 0; i < w->num_kcontrols; i++) {
986                 ret = dapm_create_or_share_kcontrol(w, i);
987                 if (ret < 0)
988                         return ret;
989         }
990
991         return 0;
992 }
993
994 /* create new dapm dai link control */
995 static int dapm_new_dai_link(struct snd_soc_dapm_widget *w)
996 {
997         int i, ret;
998         struct snd_kcontrol *kcontrol;
999         struct snd_soc_dapm_context *dapm = w->dapm;
1000         struct snd_card *card = dapm->card->snd_card;
1001
1002         /* create control for links with > 1 config */
1003         if (w->num_params <= 1)
1004                 return 0;
1005
1006         /* add kcontrol */
1007         for (i = 0; i < w->num_kcontrols; i++) {
1008                 kcontrol = snd_soc_cnew(&w->kcontrol_news[i], w,
1009                                         w->name, NULL);
1010                 ret = snd_ctl_add(card, kcontrol);
1011                 if (ret < 0) {
1012                         dev_err(dapm->dev,
1013                                 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
1014                                 w->name, w->kcontrol_news[i].name, ret);
1015                         return ret;
1016                 }
1017                 kcontrol->private_data = w;
1018                 w->kcontrols[i] = kcontrol;
1019         }
1020
1021         return 0;
1022 }
1023
1024 /* We implement power down on suspend by checking the power state of
1025  * the ALSA card - when we are suspending the ALSA state for the card
1026  * is set to D3.
1027  */
1028 static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
1029 {
1030         int level = snd_power_get_state(widget->dapm->card->snd_card);
1031
1032         switch (level) {
1033         case SNDRV_CTL_POWER_D3hot:
1034         case SNDRV_CTL_POWER_D3cold:
1035                 if (widget->ignore_suspend)
1036                         dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
1037                                 widget->name);
1038                 return widget->ignore_suspend;
1039         default:
1040                 return 1;
1041         }
1042 }
1043
1044 static int dapm_widget_list_create(struct snd_soc_dapm_widget_list **list,
1045         struct list_head *widgets)
1046 {
1047         struct snd_soc_dapm_widget *w;
1048         struct list_head *it;
1049         unsigned int size = 0;
1050         unsigned int i = 0;
1051
1052         list_for_each(it, widgets)
1053                 size++;
1054
1055         *list = kzalloc(sizeof(**list) + size * sizeof(*w), GFP_KERNEL);
1056         if (*list == NULL)
1057                 return -ENOMEM;
1058
1059         list_for_each_entry(w, widgets, work_list)
1060                 (*list)->widgets[i++] = w;
1061
1062         (*list)->num_widgets = i;
1063
1064         return 0;
1065 }
1066
1067 /*
1068  * Common implementation for is_connected_output_ep() and
1069  * is_connected_input_ep(). The function is inlined since the combined size of
1070  * the two specialized functions is only marginally larger then the size of the
1071  * generic function and at the same time the fast path of the specialized
1072  * functions is significantly smaller than the generic function.
1073  */
1074 static __always_inline int is_connected_ep(struct snd_soc_dapm_widget *widget,
1075         struct list_head *list, enum snd_soc_dapm_direction dir,
1076         int (*fn)(struct snd_soc_dapm_widget *, struct list_head *))
1077 {
1078         enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
1079         struct snd_soc_dapm_path *path;
1080         int con = 0;
1081
1082         if (widget->endpoints[dir] >= 0)
1083                 return widget->endpoints[dir];
1084
1085         DAPM_UPDATE_STAT(widget, path_checks);
1086
1087         /* do we need to add this widget to the list ? */
1088         if (list)
1089                 list_add_tail(&widget->work_list, list);
1090
1091         if ((widget->is_ep & SND_SOC_DAPM_DIR_TO_EP(dir)) && widget->connected) {
1092                 widget->endpoints[dir] = snd_soc_dapm_suspend_check(widget);
1093                 return widget->endpoints[dir];
1094         }
1095
1096         snd_soc_dapm_widget_for_each_path(widget, rdir, path) {
1097                 DAPM_UPDATE_STAT(widget, neighbour_checks);
1098
1099                 if (path->weak || path->is_supply)
1100                         continue;
1101
1102                 if (path->walking)
1103                         return 1;
1104
1105                 trace_snd_soc_dapm_path(widget, dir, path);
1106
1107                 if (path->connect) {
1108                         path->walking = 1;
1109                         con += fn(path->node[dir], list);
1110                         path->walking = 0;
1111                 }
1112         }
1113
1114         widget->endpoints[dir] = con;
1115
1116         return con;
1117 }
1118
1119 /*
1120  * Recursively check for a completed path to an active or physically connected
1121  * output widget. Returns number of complete paths.
1122  */
1123 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
1124         struct list_head *list)
1125 {
1126         return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_OUT,
1127                         is_connected_output_ep);
1128 }
1129
1130 /*
1131  * Recursively check for a completed path to an active or physically connected
1132  * input widget. Returns number of complete paths.
1133  */
1134 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
1135         struct list_head *list)
1136 {
1137         return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_IN,
1138                         is_connected_input_ep);
1139 }
1140
1141 /**
1142  * snd_soc_dapm_get_connected_widgets - query audio path and it's widgets.
1143  * @dai: the soc DAI.
1144  * @stream: stream direction.
1145  * @list: list of active widgets for this stream.
1146  *
1147  * Queries DAPM graph as to whether an valid audio stream path exists for
1148  * the initial stream specified by name. This takes into account
1149  * current mixer and mux kcontrol settings. Creates list of valid widgets.
1150  *
1151  * Returns the number of valid paths or negative error.
1152  */
1153 int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
1154         struct snd_soc_dapm_widget_list **list)
1155 {
1156         struct snd_soc_card *card = dai->component->card;
1157         struct snd_soc_dapm_widget *w;
1158         LIST_HEAD(widgets);
1159         int paths;
1160         int ret;
1161
1162         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1163
1164         /*
1165          * For is_connected_{output,input}_ep fully discover the graph we need
1166          * to reset the cached number of inputs and outputs.
1167          */
1168         list_for_each_entry(w, &card->widgets, list) {
1169                 w->endpoints[SND_SOC_DAPM_DIR_IN] = -1;
1170                 w->endpoints[SND_SOC_DAPM_DIR_OUT] = -1;
1171         }
1172
1173         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
1174                 paths = is_connected_output_ep(dai->playback_widget, &widgets);
1175         else
1176                 paths = is_connected_input_ep(dai->capture_widget, &widgets);
1177
1178         /* Drop starting point */
1179         list_del(widgets.next);
1180
1181         ret = dapm_widget_list_create(list, &widgets);
1182         if (ret)
1183                 paths = ret;
1184
1185         trace_snd_soc_dapm_connected(paths, stream);
1186         mutex_unlock(&card->dapm_mutex);
1187
1188         return paths;
1189 }
1190
1191 /*
1192  * Handler for regulator supply widget.
1193  */
1194 int dapm_regulator_event(struct snd_soc_dapm_widget *w,
1195                    struct snd_kcontrol *kcontrol, int event)
1196 {
1197         int ret;
1198
1199         soc_dapm_async_complete(w->dapm);
1200
1201         if (SND_SOC_DAPM_EVENT_ON(event)) {
1202                 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1203                         ret = regulator_allow_bypass(w->regulator, false);
1204                         if (ret != 0)
1205                                 dev_warn(w->dapm->dev,
1206                                          "ASoC: Failed to unbypass %s: %d\n",
1207                                          w->name, ret);
1208                 }
1209
1210                 return regulator_enable(w->regulator);
1211         } else {
1212                 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1213                         ret = regulator_allow_bypass(w->regulator, true);
1214                         if (ret != 0)
1215                                 dev_warn(w->dapm->dev,
1216                                          "ASoC: Failed to bypass %s: %d\n",
1217                                          w->name, ret);
1218                 }
1219
1220                 return regulator_disable_deferred(w->regulator, w->shift);
1221         }
1222 }
1223 EXPORT_SYMBOL_GPL(dapm_regulator_event);
1224
1225 /*
1226  * Handler for clock supply widget.
1227  */
1228 int dapm_clock_event(struct snd_soc_dapm_widget *w,
1229                    struct snd_kcontrol *kcontrol, int event)
1230 {
1231         if (!w->clk)
1232                 return -EIO;
1233
1234         soc_dapm_async_complete(w->dapm);
1235
1236 #ifdef CONFIG_HAVE_CLK
1237         if (SND_SOC_DAPM_EVENT_ON(event)) {
1238                 return clk_prepare_enable(w->clk);
1239         } else {
1240                 clk_disable_unprepare(w->clk);
1241                 return 0;
1242         }
1243 #endif
1244         return 0;
1245 }
1246 EXPORT_SYMBOL_GPL(dapm_clock_event);
1247
1248 static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1249 {
1250         if (w->power_checked)
1251                 return w->new_power;
1252
1253         if (w->force)
1254                 w->new_power = 1;
1255         else
1256                 w->new_power = w->power_check(w);
1257
1258         w->power_checked = true;
1259
1260         return w->new_power;
1261 }
1262
1263 /* Generic check to see if a widget should be powered.
1264  */
1265 static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1266 {
1267         int in, out;
1268
1269         DAPM_UPDATE_STAT(w, power_checks);
1270
1271         in = is_connected_input_ep(w, NULL);
1272         out = is_connected_output_ep(w, NULL);
1273         return out != 0 && in != 0;
1274 }
1275
1276 /* Check to see if a power supply is needed */
1277 static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1278 {
1279         struct snd_soc_dapm_path *path;
1280
1281         DAPM_UPDATE_STAT(w, power_checks);
1282
1283         /* Check if one of our outputs is connected */
1284         snd_soc_dapm_widget_for_each_sink_path(w, path) {
1285                 DAPM_UPDATE_STAT(w, neighbour_checks);
1286
1287                 if (path->weak)
1288                         continue;
1289
1290                 if (path->connected &&
1291                     !path->connected(path->source, path->sink))
1292                         continue;
1293
1294                 if (dapm_widget_power_check(path->sink))
1295                         return 1;
1296         }
1297
1298         return 0;
1299 }
1300
1301 static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1302 {
1303         return w->connected;
1304 }
1305
1306 static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
1307                             struct snd_soc_dapm_widget *b,
1308                             bool power_up)
1309 {
1310         int *sort;
1311
1312         if (power_up)
1313                 sort = dapm_up_seq;
1314         else
1315                 sort = dapm_down_seq;
1316
1317         if (sort[a->id] != sort[b->id])
1318                 return sort[a->id] - sort[b->id];
1319         if (a->subseq != b->subseq) {
1320                 if (power_up)
1321                         return a->subseq - b->subseq;
1322                 else
1323                         return b->subseq - a->subseq;
1324         }
1325         if (a->reg != b->reg)
1326                 return a->reg - b->reg;
1327         if (a->dapm != b->dapm)
1328                 return (unsigned long)a->dapm - (unsigned long)b->dapm;
1329
1330         return 0;
1331 }
1332
1333 /* Insert a widget in order into a DAPM power sequence. */
1334 static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
1335                             struct list_head *list,
1336                             bool power_up)
1337 {
1338         struct snd_soc_dapm_widget *w;
1339
1340         list_for_each_entry(w, list, power_list)
1341                 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
1342                         list_add_tail(&new_widget->power_list, &w->power_list);
1343                         return;
1344                 }
1345
1346         list_add_tail(&new_widget->power_list, list);
1347 }
1348
1349 static void dapm_seq_check_event(struct snd_soc_card *card,
1350                                  struct snd_soc_dapm_widget *w, int event)
1351 {
1352         const char *ev_name;
1353         int power, ret;
1354
1355         switch (event) {
1356         case SND_SOC_DAPM_PRE_PMU:
1357                 ev_name = "PRE_PMU";
1358                 power = 1;
1359                 break;
1360         case SND_SOC_DAPM_POST_PMU:
1361                 ev_name = "POST_PMU";
1362                 power = 1;
1363                 break;
1364         case SND_SOC_DAPM_PRE_PMD:
1365                 ev_name = "PRE_PMD";
1366                 power = 0;
1367                 break;
1368         case SND_SOC_DAPM_POST_PMD:
1369                 ev_name = "POST_PMD";
1370                 power = 0;
1371                 break;
1372         case SND_SOC_DAPM_WILL_PMU:
1373                 ev_name = "WILL_PMU";
1374                 power = 1;
1375                 break;
1376         case SND_SOC_DAPM_WILL_PMD:
1377                 ev_name = "WILL_PMD";
1378                 power = 0;
1379                 break;
1380         default:
1381                 WARN(1, "Unknown event %d\n", event);
1382                 return;
1383         }
1384
1385         if (w->new_power != power)
1386                 return;
1387
1388         if (w->event && (w->event_flags & event)) {
1389                 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
1390                         w->name, ev_name);
1391                 soc_dapm_async_complete(w->dapm);
1392                 trace_snd_soc_dapm_widget_event_start(w, event);
1393                 ret = w->event(w, NULL, event);
1394                 trace_snd_soc_dapm_widget_event_done(w, event);
1395                 if (ret < 0)
1396                         dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
1397                                ev_name, w->name, ret);
1398         }
1399 }
1400
1401 /* Apply the coalesced changes from a DAPM sequence */
1402 static void dapm_seq_run_coalesced(struct snd_soc_card *card,
1403                                    struct list_head *pending)
1404 {
1405         struct snd_soc_dapm_context *dapm;
1406         struct snd_soc_dapm_widget *w;
1407         int reg;
1408         unsigned int value = 0;
1409         unsigned int mask = 0;
1410
1411         w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
1412         reg = w->reg;
1413         dapm = w->dapm;
1414
1415         list_for_each_entry(w, pending, power_list) {
1416                 WARN_ON(reg != w->reg || dapm != w->dapm);
1417                 w->power = w->new_power;
1418
1419                 mask |= w->mask << w->shift;
1420                 if (w->power)
1421                         value |= w->on_val << w->shift;
1422                 else
1423                         value |= w->off_val << w->shift;
1424
1425                 pop_dbg(dapm->dev, card->pop_time,
1426                         "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1427                         w->name, reg, value, mask);
1428
1429                 /* Check for events */
1430                 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
1431                 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
1432         }
1433
1434         if (reg >= 0) {
1435                 /* Any widget will do, they should all be updating the
1436                  * same register.
1437                  */
1438
1439                 pop_dbg(dapm->dev, card->pop_time,
1440                         "pop test : Applying 0x%x/0x%x to %x in %dms\n",
1441                         value, mask, reg, card->pop_time);
1442                 pop_wait(card->pop_time);
1443                 soc_dapm_update_bits(dapm, reg, mask, value);
1444         }
1445
1446         list_for_each_entry(w, pending, power_list) {
1447                 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
1448                 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
1449         }
1450 }
1451
1452 /* Apply a DAPM power sequence.
1453  *
1454  * We walk over a pre-sorted list of widgets to apply power to.  In
1455  * order to minimise the number of writes to the device required
1456  * multiple widgets will be updated in a single write where possible.
1457  * Currently anything that requires more than a single write is not
1458  * handled.
1459  */
1460 static void dapm_seq_run(struct snd_soc_card *card,
1461         struct list_head *list, int event, bool power_up)
1462 {
1463         struct snd_soc_dapm_widget *w, *n;
1464         struct snd_soc_dapm_context *d;
1465         LIST_HEAD(pending);
1466         int cur_sort = -1;
1467         int cur_subseq = -1;
1468         int cur_reg = SND_SOC_NOPM;
1469         struct snd_soc_dapm_context *cur_dapm = NULL;
1470         int ret, i;
1471         int *sort;
1472
1473         if (power_up)
1474                 sort = dapm_up_seq;
1475         else
1476                 sort = dapm_down_seq;
1477
1478         list_for_each_entry_safe(w, n, list, power_list) {
1479                 ret = 0;
1480
1481                 /* Do we need to apply any queued changes? */
1482                 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
1483                     w->dapm != cur_dapm || w->subseq != cur_subseq) {
1484                         if (!list_empty(&pending))
1485                                 dapm_seq_run_coalesced(card, &pending);
1486
1487                         if (cur_dapm && cur_dapm->seq_notifier) {
1488                                 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1489                                         if (sort[i] == cur_sort)
1490                                                 cur_dapm->seq_notifier(cur_dapm,
1491                                                                        i,
1492                                                                        cur_subseq);
1493                         }
1494
1495                         if (cur_dapm && w->dapm != cur_dapm)
1496                                 soc_dapm_async_complete(cur_dapm);
1497
1498                         INIT_LIST_HEAD(&pending);
1499                         cur_sort = -1;
1500                         cur_subseq = INT_MIN;
1501                         cur_reg = SND_SOC_NOPM;
1502                         cur_dapm = NULL;
1503                 }
1504
1505                 switch (w->id) {
1506                 case snd_soc_dapm_pre:
1507                         if (!w->event)
1508                                 list_for_each_entry_safe_continue(w, n, list,
1509                                                                   power_list);
1510
1511                         if (event == SND_SOC_DAPM_STREAM_START)
1512                                 ret = w->event(w,
1513                                                NULL, SND_SOC_DAPM_PRE_PMU);
1514                         else if (event == SND_SOC_DAPM_STREAM_STOP)
1515                                 ret = w->event(w,
1516                                                NULL, SND_SOC_DAPM_PRE_PMD);
1517                         break;
1518
1519                 case snd_soc_dapm_post:
1520                         if (!w->event)
1521                                 list_for_each_entry_safe_continue(w, n, list,
1522                                                                   power_list);
1523
1524                         if (event == SND_SOC_DAPM_STREAM_START)
1525                                 ret = w->event(w,
1526                                                NULL, SND_SOC_DAPM_POST_PMU);
1527                         else if (event == SND_SOC_DAPM_STREAM_STOP)
1528                                 ret = w->event(w,
1529                                                NULL, SND_SOC_DAPM_POST_PMD);
1530                         break;
1531
1532                 default:
1533                         /* Queue it up for application */
1534                         cur_sort = sort[w->id];
1535                         cur_subseq = w->subseq;
1536                         cur_reg = w->reg;
1537                         cur_dapm = w->dapm;
1538                         list_move(&w->power_list, &pending);
1539                         break;
1540                 }
1541
1542                 if (ret < 0)
1543                         dev_err(w->dapm->dev,
1544                                 "ASoC: Failed to apply widget power: %d\n", ret);
1545         }
1546
1547         if (!list_empty(&pending))
1548                 dapm_seq_run_coalesced(card, &pending);
1549
1550         if (cur_dapm && cur_dapm->seq_notifier) {
1551                 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1552                         if (sort[i] == cur_sort)
1553                                 cur_dapm->seq_notifier(cur_dapm,
1554                                                        i, cur_subseq);
1555         }
1556
1557         list_for_each_entry(d, &card->dapm_list, list) {
1558                 soc_dapm_async_complete(d);
1559         }
1560 }
1561
1562 static void dapm_widget_update(struct snd_soc_card *card)
1563 {
1564         struct snd_soc_dapm_update *update = card->update;
1565         struct snd_soc_dapm_widget_list *wlist;
1566         struct snd_soc_dapm_widget *w = NULL;
1567         unsigned int wi;
1568         int ret;
1569
1570         if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
1571                 return;
1572
1573         wlist = dapm_kcontrol_get_wlist(update->kcontrol);
1574
1575         for (wi = 0; wi < wlist->num_widgets; wi++) {
1576                 w = wlist->widgets[wi];
1577
1578                 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1579                         ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1580                         if (ret != 0)
1581                                 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
1582                                            w->name, ret);
1583                 }
1584         }
1585
1586         if (!w)
1587                 return;
1588
1589         ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
1590                 update->val);
1591         if (ret < 0)
1592                 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
1593                         w->name, ret);
1594
1595         for (wi = 0; wi < wlist->num_widgets; wi++) {
1596                 w = wlist->widgets[wi];
1597
1598                 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1599                         ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1600                         if (ret != 0)
1601                                 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
1602                                            w->name, ret);
1603                 }
1604         }
1605 }
1606
1607 /* Async callback run prior to DAPM sequences - brings to _PREPARE if
1608  * they're changing state.
1609  */
1610 static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1611 {
1612         struct snd_soc_dapm_context *d = data;
1613         int ret;
1614
1615         /* If we're off and we're not supposed to be go into STANDBY */
1616         if (d->bias_level == SND_SOC_BIAS_OFF &&
1617             d->target_bias_level != SND_SOC_BIAS_OFF) {
1618                 if (d->dev)
1619                         pm_runtime_get_sync(d->dev);
1620
1621                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1622                 if (ret != 0)
1623                         dev_err(d->dev,
1624                                 "ASoC: Failed to turn on bias: %d\n", ret);
1625         }
1626
1627         /* Prepare for a transition to ON or away from ON */
1628         if ((d->target_bias_level == SND_SOC_BIAS_ON &&
1629              d->bias_level != SND_SOC_BIAS_ON) ||
1630             (d->target_bias_level != SND_SOC_BIAS_ON &&
1631              d->bias_level == SND_SOC_BIAS_ON)) {
1632                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1633                 if (ret != 0)
1634                         dev_err(d->dev,
1635                                 "ASoC: Failed to prepare bias: %d\n", ret);
1636         }
1637 }
1638
1639 /* Async callback run prior to DAPM sequences - brings to their final
1640  * state.
1641  */
1642 static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1643 {
1644         struct snd_soc_dapm_context *d = data;
1645         int ret;
1646
1647         /* If we just powered the last thing off drop to standby bias */
1648         if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1649             (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1650              d->target_bias_level == SND_SOC_BIAS_OFF)) {
1651                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1652                 if (ret != 0)
1653                         dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
1654                                 ret);
1655         }
1656
1657         /* If we're in standby and can support bias off then do that */
1658         if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1659             d->target_bias_level == SND_SOC_BIAS_OFF) {
1660                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1661                 if (ret != 0)
1662                         dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
1663                                 ret);
1664
1665                 if (d->dev)
1666                         pm_runtime_put(d->dev);
1667         }
1668
1669         /* If we just powered up then move to active bias */
1670         if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1671             d->target_bias_level == SND_SOC_BIAS_ON) {
1672                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1673                 if (ret != 0)
1674                         dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
1675                                 ret);
1676         }
1677 }
1678
1679 static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
1680                                        bool power, bool connect)
1681 {
1682         /* If a connection is being made or broken then that update
1683          * will have marked the peer dirty, otherwise the widgets are
1684          * not connected and this update has no impact. */
1685         if (!connect)
1686                 return;
1687
1688         /* If the peer is already in the state we're moving to then we
1689          * won't have an impact on it. */
1690         if (power != peer->power)
1691                 dapm_mark_dirty(peer, "peer state change");
1692 }
1693
1694 static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
1695                                   struct list_head *up_list,
1696                                   struct list_head *down_list)
1697 {
1698         struct snd_soc_dapm_path *path;
1699
1700         if (w->power == power)
1701                 return;
1702
1703         trace_snd_soc_dapm_widget_power(w, power);
1704
1705         /* If we changed our power state perhaps our neigbours changed
1706          * also.
1707          */
1708         snd_soc_dapm_widget_for_each_source_path(w, path)
1709                 dapm_widget_set_peer_power(path->source, power, path->connect);
1710
1711         /* Supplies can't affect their outputs, only their inputs */
1712         if (!w->is_supply) {
1713                 snd_soc_dapm_widget_for_each_sink_path(w, path)
1714                         dapm_widget_set_peer_power(path->sink, power,
1715                                                    path->connect);
1716         }
1717
1718         if (power)
1719                 dapm_seq_insert(w, up_list, true);
1720         else
1721                 dapm_seq_insert(w, down_list, false);
1722 }
1723
1724 static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1725                                   struct list_head *up_list,
1726                                   struct list_head *down_list)
1727 {
1728         int power;
1729
1730         switch (w->id) {
1731         case snd_soc_dapm_pre:
1732                 dapm_seq_insert(w, down_list, false);
1733                 break;
1734         case snd_soc_dapm_post:
1735                 dapm_seq_insert(w, up_list, true);
1736                 break;
1737
1738         default:
1739                 power = dapm_widget_power_check(w);
1740
1741                 dapm_widget_set_power(w, power, up_list, down_list);
1742                 break;
1743         }
1744 }
1745
1746 static bool dapm_idle_bias_off(struct snd_soc_dapm_context *dapm)
1747 {
1748         if (dapm->idle_bias_off)
1749                 return true;
1750
1751         switch (snd_power_get_state(dapm->card->snd_card)) {
1752         case SNDRV_CTL_POWER_D3hot:
1753         case SNDRV_CTL_POWER_D3cold:
1754                 return dapm->suspend_bias_off;
1755         default:
1756                 break;
1757         }
1758
1759         return false;
1760 }
1761
1762 /*
1763  * Scan each dapm widget for complete audio path.
1764  * A complete path is a route that has valid endpoints i.e.:-
1765  *
1766  *  o DAC to output pin.
1767  *  o Input Pin to ADC.
1768  *  o Input pin to Output pin (bypass, sidetone)
1769  *  o DAC to ADC (loopback).
1770  */
1771 static int dapm_power_widgets(struct snd_soc_card *card, int event)
1772 {
1773         struct snd_soc_dapm_widget *w;
1774         struct snd_soc_dapm_context *d;
1775         LIST_HEAD(up_list);
1776         LIST_HEAD(down_list);
1777         ASYNC_DOMAIN_EXCLUSIVE(async_domain);
1778         enum snd_soc_bias_level bias;
1779
1780         lockdep_assert_held(&card->dapm_mutex);
1781
1782         trace_snd_soc_dapm_start(card);
1783
1784         list_for_each_entry(d, &card->dapm_list, list) {
1785                 if (dapm_idle_bias_off(d))
1786                         d->target_bias_level = SND_SOC_BIAS_OFF;
1787                 else
1788                         d->target_bias_level = SND_SOC_BIAS_STANDBY;
1789         }
1790
1791         dapm_reset(card);
1792
1793         /* Check which widgets we need to power and store them in
1794          * lists indicating if they should be powered up or down.  We
1795          * only check widgets that have been flagged as dirty but note
1796          * that new widgets may be added to the dirty list while we
1797          * iterate.
1798          */
1799         list_for_each_entry(w, &card->dapm_dirty, dirty) {
1800                 dapm_power_one_widget(w, &up_list, &down_list);
1801         }
1802
1803         list_for_each_entry(w, &card->widgets, list) {
1804                 switch (w->id) {
1805                 case snd_soc_dapm_pre:
1806                 case snd_soc_dapm_post:
1807                         /* These widgets always need to be powered */
1808                         break;
1809                 default:
1810                         list_del_init(&w->dirty);
1811                         break;
1812                 }
1813
1814                 if (w->new_power) {
1815                         d = w->dapm;
1816
1817                         /* Supplies and micbiases only bring the
1818                          * context up to STANDBY as unless something
1819                          * else is active and passing audio they
1820                          * generally don't require full power.  Signal
1821                          * generators are virtual pins and have no
1822                          * power impact themselves.
1823                          */
1824                         switch (w->id) {
1825                         case snd_soc_dapm_siggen:
1826                         case snd_soc_dapm_vmid:
1827                                 break;
1828                         case snd_soc_dapm_supply:
1829                         case snd_soc_dapm_regulator_supply:
1830                         case snd_soc_dapm_clock_supply:
1831                         case snd_soc_dapm_micbias:
1832                                 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
1833                                         d->target_bias_level = SND_SOC_BIAS_STANDBY;
1834                                 break;
1835                         default:
1836                                 d->target_bias_level = SND_SOC_BIAS_ON;
1837                                 break;
1838                         }
1839                 }
1840
1841         }
1842
1843         /* Force all contexts in the card to the same bias state if
1844          * they're not ground referenced.
1845          */
1846         bias = SND_SOC_BIAS_OFF;
1847         list_for_each_entry(d, &card->dapm_list, list)
1848                 if (d->target_bias_level > bias)
1849                         bias = d->target_bias_level;
1850         list_for_each_entry(d, &card->dapm_list, list)
1851                 if (!dapm_idle_bias_off(d))
1852                         d->target_bias_level = bias;
1853
1854         trace_snd_soc_dapm_walk_done(card);
1855
1856         /* Run card bias changes at first */
1857         dapm_pre_sequence_async(&card->dapm, 0);
1858         /* Run other bias changes in parallel */
1859         list_for_each_entry(d, &card->dapm_list, list) {
1860                 if (d != &card->dapm)
1861                         async_schedule_domain(dapm_pre_sequence_async, d,
1862                                                 &async_domain);
1863         }
1864         async_synchronize_full_domain(&async_domain);
1865
1866         list_for_each_entry(w, &down_list, power_list) {
1867                 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
1868         }
1869
1870         list_for_each_entry(w, &up_list, power_list) {
1871                 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
1872         }
1873
1874         /* Power down widgets first; try to avoid amplifying pops. */
1875         dapm_seq_run(card, &down_list, event, false);
1876
1877         dapm_widget_update(card);
1878
1879         /* Now power up. */
1880         dapm_seq_run(card, &up_list, event, true);
1881
1882         /* Run all the bias changes in parallel */
1883         list_for_each_entry(d, &card->dapm_list, list) {
1884                 if (d != &card->dapm)
1885                         async_schedule_domain(dapm_post_sequence_async, d,
1886                                                 &async_domain);
1887         }
1888         async_synchronize_full_domain(&async_domain);
1889         /* Run card bias changes at last */
1890         dapm_post_sequence_async(&card->dapm, 0);
1891
1892         /* do we need to notify any clients that DAPM event is complete */
1893         list_for_each_entry(d, &card->dapm_list, list) {
1894                 if (d->stream_event)
1895                         d->stream_event(d, event);
1896         }
1897
1898         pop_dbg(card->dev, card->pop_time,
1899                 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
1900         pop_wait(card->pop_time);
1901
1902         trace_snd_soc_dapm_done(card);
1903
1904         return 0;
1905 }
1906
1907 #ifdef CONFIG_DEBUG_FS
1908 static ssize_t dapm_widget_power_read_file(struct file *file,
1909                                            char __user *user_buf,
1910                                            size_t count, loff_t *ppos)
1911 {
1912         struct snd_soc_dapm_widget *w = file->private_data;
1913         struct snd_soc_card *card = w->dapm->card;
1914         enum snd_soc_dapm_direction dir, rdir;
1915         char *buf;
1916         int in, out;
1917         ssize_t ret;
1918         struct snd_soc_dapm_path *p = NULL;
1919
1920         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1921         if (!buf)
1922                 return -ENOMEM;
1923
1924         mutex_lock(&card->dapm_mutex);
1925
1926         /* Supply widgets are not handled by is_connected_{input,output}_ep() */
1927         if (w->is_supply) {
1928                 in = 0;
1929                 out = 0;
1930         } else {
1931                 in = is_connected_input_ep(w, NULL);
1932                 out = is_connected_output_ep(w, NULL);
1933         }
1934
1935         ret = snprintf(buf, PAGE_SIZE, "%s: %s%s  in %d out %d",
1936                        w->name, w->power ? "On" : "Off",
1937                        w->force ? " (forced)" : "", in, out);
1938
1939         if (w->reg >= 0)
1940                 ret += snprintf(buf + ret, PAGE_SIZE - ret,
1941                                 " - R%d(0x%x) mask 0x%x",
1942                                 w->reg, w->reg, w->mask << w->shift);
1943
1944         ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1945
1946         if (w->sname)
1947                 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1948                                 w->sname,
1949                                 w->active ? "active" : "inactive");
1950
1951         snd_soc_dapm_for_each_direction(dir) {
1952                 rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
1953                 snd_soc_dapm_widget_for_each_path(w, dir, p) {
1954                         if (p->connected && !p->connected(w, p->node[rdir]))
1955                                 continue;
1956
1957                         if (!p->connect)
1958                                 continue;
1959
1960                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
1961                                         " %s  \"%s\" \"%s\"\n",
1962                                         (rdir == SND_SOC_DAPM_DIR_IN) ? "in" : "out",
1963                                         p->name ? p->name : "static",
1964                                         p->node[rdir]->name);
1965                 }
1966         }
1967
1968         mutex_unlock(&card->dapm_mutex);
1969
1970         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1971
1972         kfree(buf);
1973         return ret;
1974 }
1975
1976 static const struct file_operations dapm_widget_power_fops = {
1977         .open = simple_open,
1978         .read = dapm_widget_power_read_file,
1979         .llseek = default_llseek,
1980 };
1981
1982 static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
1983                                    size_t count, loff_t *ppos)
1984 {
1985         struct snd_soc_dapm_context *dapm = file->private_data;
1986         char *level;
1987
1988         switch (dapm->bias_level) {
1989         case SND_SOC_BIAS_ON:
1990                 level = "On\n";
1991                 break;
1992         case SND_SOC_BIAS_PREPARE:
1993                 level = "Prepare\n";
1994                 break;
1995         case SND_SOC_BIAS_STANDBY:
1996                 level = "Standby\n";
1997                 break;
1998         case SND_SOC_BIAS_OFF:
1999                 level = "Off\n";
2000                 break;
2001         default:
2002                 WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
2003                 level = "Unknown\n";
2004                 break;
2005         }
2006
2007         return simple_read_from_buffer(user_buf, count, ppos, level,
2008                                        strlen(level));
2009 }
2010
2011 static const struct file_operations dapm_bias_fops = {
2012         .open = simple_open,
2013         .read = dapm_bias_read_file,
2014         .llseek = default_llseek,
2015 };
2016
2017 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2018         struct dentry *parent)
2019 {
2020         struct dentry *d;
2021
2022         if (!parent)
2023                 return;
2024
2025         dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
2026
2027         if (!dapm->debugfs_dapm) {
2028                 dev_warn(dapm->dev,
2029                        "ASoC: Failed to create DAPM debugfs directory\n");
2030                 return;
2031         }
2032
2033         d = debugfs_create_file("bias_level", 0444,
2034                                 dapm->debugfs_dapm, dapm,
2035                                 &dapm_bias_fops);
2036         if (!d)
2037                 dev_warn(dapm->dev,
2038                          "ASoC: Failed to create bias level debugfs file\n");
2039 }
2040
2041 static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2042 {
2043         struct snd_soc_dapm_context *dapm = w->dapm;
2044         struct dentry *d;
2045
2046         if (!dapm->debugfs_dapm || !w->name)
2047                 return;
2048
2049         d = debugfs_create_file(w->name, 0444,
2050                                 dapm->debugfs_dapm, w,
2051                                 &dapm_widget_power_fops);
2052         if (!d)
2053                 dev_warn(w->dapm->dev,
2054                         "ASoC: Failed to create %s debugfs file\n",
2055                         w->name);
2056 }
2057
2058 static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2059 {
2060         debugfs_remove_recursive(dapm->debugfs_dapm);
2061 }
2062
2063 #else
2064 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2065         struct dentry *parent)
2066 {
2067 }
2068
2069 static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2070 {
2071 }
2072
2073 static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2074 {
2075 }
2076
2077 #endif
2078
2079 /*
2080  * soc_dapm_connect_path() - Connects or disconnects a path
2081  * @path: The path to update
2082  * @connect: The new connect state of the path. True if the path is connected,
2083  *  false if it is disconneted.
2084  * @reason: The reason why the path changed (for debugging only)
2085  */
2086 static void soc_dapm_connect_path(struct snd_soc_dapm_path *path,
2087         bool connect, const char *reason)
2088 {
2089         if (path->connect == connect)
2090                 return;
2091
2092         path->connect = connect;
2093         dapm_mark_dirty(path->source, reason);
2094         dapm_mark_dirty(path->sink, reason);
2095         dapm_path_invalidate(path);
2096 }
2097
2098 /* test and update the power status of a mux widget */
2099 static int soc_dapm_mux_update_power(struct snd_soc_card *card,
2100                                  struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
2101 {
2102         struct snd_soc_dapm_path *path;
2103         int found = 0;
2104         bool connect;
2105
2106         lockdep_assert_held(&card->dapm_mutex);
2107
2108         /* find dapm widget path assoc with kcontrol */
2109         dapm_kcontrol_for_each_path(path, kcontrol) {
2110                 found = 1;
2111                 /* we now need to match the string in the enum to the path */
2112                 if (!(strcmp(path->name, e->texts[mux])))
2113                         connect = true;
2114                 else
2115                         connect = false;
2116
2117                 soc_dapm_connect_path(path, connect, "mux update");
2118         }
2119
2120         if (found)
2121                 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2122
2123         return found;
2124 }
2125
2126 int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
2127         struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
2128         struct snd_soc_dapm_update *update)
2129 {
2130         struct snd_soc_card *card = dapm->card;
2131         int ret;
2132
2133         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2134         card->update = update;
2135         ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
2136         card->update = NULL;
2137         mutex_unlock(&card->dapm_mutex);
2138         if (ret > 0)
2139                 soc_dpcm_runtime_update(card);
2140         return ret;
2141 }
2142 EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
2143
2144 /* test and update the power status of a mixer or switch widget */
2145 static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
2146                                    struct snd_kcontrol *kcontrol, int connect)
2147 {
2148         struct snd_soc_dapm_path *path;
2149         int found = 0;
2150
2151         lockdep_assert_held(&card->dapm_mutex);
2152
2153         /* find dapm widget path assoc with kcontrol */
2154         dapm_kcontrol_for_each_path(path, kcontrol) {
2155                 found = 1;
2156                 soc_dapm_connect_path(path, connect, "mixer update");
2157         }
2158
2159         if (found)
2160                 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2161
2162         return found;
2163 }
2164
2165 int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
2166         struct snd_kcontrol *kcontrol, int connect,
2167         struct snd_soc_dapm_update *update)
2168 {
2169         struct snd_soc_card *card = dapm->card;
2170         int ret;
2171
2172         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2173         card->update = update;
2174         ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
2175         card->update = NULL;
2176         mutex_unlock(&card->dapm_mutex);
2177         if (ret > 0)
2178                 soc_dpcm_runtime_update(card);
2179         return ret;
2180 }
2181 EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
2182
2183 static ssize_t dapm_widget_show_component(struct snd_soc_component *cmpnt,
2184         char *buf)
2185 {
2186         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
2187         struct snd_soc_dapm_widget *w;
2188         int count = 0;
2189         char *state = "not set";
2190
2191         list_for_each_entry(w, &cmpnt->card->widgets, list) {
2192                 if (w->dapm != dapm)
2193                         continue;
2194
2195                 /* only display widgets that burnm power */
2196                 switch (w->id) {
2197                 case snd_soc_dapm_hp:
2198                 case snd_soc_dapm_mic:
2199                 case snd_soc_dapm_spk:
2200                 case snd_soc_dapm_line:
2201                 case snd_soc_dapm_micbias:
2202                 case snd_soc_dapm_dac:
2203                 case snd_soc_dapm_adc:
2204                 case snd_soc_dapm_pga:
2205                 case snd_soc_dapm_out_drv:
2206                 case snd_soc_dapm_mixer:
2207                 case snd_soc_dapm_mixer_named_ctl:
2208                 case snd_soc_dapm_supply:
2209                 case snd_soc_dapm_regulator_supply:
2210                 case snd_soc_dapm_clock_supply:
2211                         if (w->name)
2212                                 count += sprintf(buf + count, "%s: %s\n",
2213                                         w->name, w->power ? "On":"Off");
2214                 break;
2215                 default:
2216                 break;
2217                 }
2218         }
2219
2220         switch (snd_soc_dapm_get_bias_level(dapm)) {
2221         case SND_SOC_BIAS_ON:
2222                 state = "On";
2223                 break;
2224         case SND_SOC_BIAS_PREPARE:
2225                 state = "Prepare";
2226                 break;
2227         case SND_SOC_BIAS_STANDBY:
2228                 state = "Standby";
2229                 break;
2230         case SND_SOC_BIAS_OFF:
2231                 state = "Off";
2232                 break;
2233         }
2234         count += sprintf(buf + count, "PM State: %s\n", state);
2235
2236         return count;
2237 }
2238
2239 /* show dapm widget status in sys fs */
2240 static ssize_t dapm_widget_show(struct device *dev,
2241         struct device_attribute *attr, char *buf)
2242 {
2243         struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
2244         int i, count = 0;
2245
2246         mutex_lock(&rtd->card->dapm_mutex);
2247
2248         for (i = 0; i < rtd->num_codecs; i++) {
2249                 struct snd_soc_component *cmpnt = rtd->codec_dais[i]->component;
2250
2251                 count += dapm_widget_show_component(cmpnt, buf + count);
2252         }
2253
2254         mutex_unlock(&rtd->card->dapm_mutex);
2255
2256         return count;
2257 }
2258
2259 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
2260
2261 struct attribute *soc_dapm_dev_attrs[] = {
2262         &dev_attr_dapm_widget.attr,
2263         NULL
2264 };
2265
2266 static void dapm_free_path(struct snd_soc_dapm_path *path)
2267 {
2268         list_del(&path->list_node[SND_SOC_DAPM_DIR_IN]);
2269         list_del(&path->list_node[SND_SOC_DAPM_DIR_OUT]);
2270         list_del(&path->list_kcontrol);
2271         list_del(&path->list);
2272         kfree(path);
2273 }
2274
2275 void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w)
2276 {
2277         struct snd_soc_dapm_path *p, *next_p;
2278         enum snd_soc_dapm_direction dir;
2279
2280         list_del(&w->list);
2281         /*
2282          * remove source and sink paths associated to this widget.
2283          * While removing the path, remove reference to it from both
2284          * source and sink widgets so that path is removed only once.
2285          */
2286         snd_soc_dapm_for_each_direction(dir) {
2287                 snd_soc_dapm_widget_for_each_path_safe(w, dir, p, next_p)
2288                         dapm_free_path(p);
2289         }
2290
2291         kfree(w->kcontrols);
2292         kfree_const(w->name);
2293         kfree(w);
2294 }
2295
2296 void snd_soc_dapm_reset_cache(struct snd_soc_dapm_context *dapm)
2297 {
2298         dapm->path_sink_cache.widget = NULL;
2299         dapm->path_source_cache.widget = NULL;
2300 }
2301
2302 /* free all dapm widgets and resources */
2303 static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
2304 {
2305         struct snd_soc_dapm_widget *w, *next_w;
2306
2307         list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
2308                 if (w->dapm != dapm)
2309                         continue;
2310                 snd_soc_dapm_free_widget(w);
2311         }
2312         snd_soc_dapm_reset_cache(dapm);
2313 }
2314
2315 static struct snd_soc_dapm_widget *dapm_find_widget(
2316                         struct snd_soc_dapm_context *dapm, const char *pin,
2317                         bool search_other_contexts)
2318 {
2319         struct snd_soc_dapm_widget *w;
2320         struct snd_soc_dapm_widget *fallback = NULL;
2321
2322         list_for_each_entry(w, &dapm->card->widgets, list) {
2323                 if (!strcmp(w->name, pin)) {
2324                         if (w->dapm == dapm)
2325                                 return w;
2326                         else
2327                                 fallback = w;
2328                 }
2329         }
2330
2331         if (search_other_contexts)
2332                 return fallback;
2333
2334         return NULL;
2335 }
2336
2337 static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
2338                                 const char *pin, int status)
2339 {
2340         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
2341
2342         dapm_assert_locked(dapm);
2343
2344         if (!w) {
2345                 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
2346                 return -EINVAL;
2347         }
2348
2349         if (w->connected != status) {
2350                 dapm_mark_dirty(w, "pin configuration");
2351                 dapm_widget_invalidate_input_paths(w);
2352                 dapm_widget_invalidate_output_paths(w);
2353         }
2354
2355         w->connected = status;
2356         if (status == 0)
2357                 w->force = 0;
2358
2359         return 0;
2360 }
2361
2362 /**
2363  * snd_soc_dapm_sync_unlocked - scan and power dapm paths
2364  * @dapm: DAPM context
2365  *
2366  * Walks all dapm audio paths and powers widgets according to their
2367  * stream or path usage.
2368  *
2369  * Requires external locking.
2370  *
2371  * Returns 0 for success.
2372  */
2373 int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
2374 {
2375         /*
2376          * Suppress early reports (eg, jacks syncing their state) to avoid
2377          * silly DAPM runs during card startup.
2378          */
2379         if (!dapm->card || !dapm->card->instantiated)
2380                 return 0;
2381
2382         return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
2383 }
2384 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked);
2385
2386 /**
2387  * snd_soc_dapm_sync - scan and power dapm paths
2388  * @dapm: DAPM context
2389  *
2390  * Walks all dapm audio paths and powers widgets according to their
2391  * stream or path usage.
2392  *
2393  * Returns 0 for success.
2394  */
2395 int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
2396 {
2397         int ret;
2398
2399         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2400         ret = snd_soc_dapm_sync_unlocked(dapm);
2401         mutex_unlock(&dapm->card->dapm_mutex);
2402         return ret;
2403 }
2404 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
2405
2406 /*
2407  * dapm_update_widget_flags() - Re-compute widget sink and source flags
2408  * @w: The widget for which to update the flags
2409  *
2410  * Some widgets have a dynamic category which depends on which neighbors they
2411  * are connected to. This function update the category for these widgets.
2412  *
2413  * This function must be called whenever a path is added or removed to a widget.
2414  */
2415 static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
2416 {
2417         enum snd_soc_dapm_direction dir;
2418         struct snd_soc_dapm_path *p;
2419         unsigned int ep;
2420
2421         switch (w->id) {
2422         case snd_soc_dapm_input:
2423                 /* On a fully routed card a input is never a source */
2424                 if (w->dapm->card->fully_routed)
2425                         return;
2426                 ep = SND_SOC_DAPM_EP_SOURCE;
2427                 snd_soc_dapm_widget_for_each_source_path(w, p) {
2428                         if (p->source->id == snd_soc_dapm_micbias ||
2429                                 p->source->id == snd_soc_dapm_mic ||
2430                                 p->source->id == snd_soc_dapm_line ||
2431                                 p->source->id == snd_soc_dapm_output) {
2432                                         ep = 0;
2433                                         break;
2434                         }
2435                 }
2436                 break;
2437         case snd_soc_dapm_output:
2438                 /* On a fully routed card a output is never a sink */
2439                 if (w->dapm->card->fully_routed)
2440                         return;
2441                 ep = SND_SOC_DAPM_EP_SINK;
2442                 snd_soc_dapm_widget_for_each_sink_path(w, p) {
2443                         if (p->sink->id == snd_soc_dapm_spk ||
2444                                 p->sink->id == snd_soc_dapm_hp ||
2445                                 p->sink->id == snd_soc_dapm_line ||
2446                                 p->sink->id == snd_soc_dapm_input) {
2447                                         ep = 0;
2448                                         break;
2449                         }
2450                 }
2451                 break;
2452         case snd_soc_dapm_line:
2453                 ep = 0;
2454                 snd_soc_dapm_for_each_direction(dir) {
2455                         if (!list_empty(&w->edges[dir]))
2456                                 ep |= SND_SOC_DAPM_DIR_TO_EP(dir);
2457                 }
2458                 break;
2459         default:
2460                 return;
2461         }
2462
2463         w->is_ep = ep;
2464 }
2465
2466 static int snd_soc_dapm_check_dynamic_path(struct snd_soc_dapm_context *dapm,
2467         struct snd_soc_dapm_widget *source, struct snd_soc_dapm_widget *sink,
2468         const char *control)
2469 {
2470         bool dynamic_source = false;
2471         bool dynamic_sink = false;
2472
2473         if (!control)
2474                 return 0;
2475
2476         switch (source->id) {
2477         case snd_soc_dapm_demux:
2478                 dynamic_source = true;
2479                 break;
2480         default:
2481                 break;
2482         }
2483
2484         switch (sink->id) {
2485         case snd_soc_dapm_mux:
2486         case snd_soc_dapm_switch:
2487         case snd_soc_dapm_mixer:
2488         case snd_soc_dapm_mixer_named_ctl:
2489                 dynamic_sink = true;
2490                 break;
2491         default:
2492                 break;
2493         }
2494
2495         if (dynamic_source && dynamic_sink) {
2496                 dev_err(dapm->dev,
2497                         "Direct connection between demux and mixer/mux not supported for path %s -> [%s] -> %s\n",
2498                         source->name, control, sink->name);
2499                 return -EINVAL;
2500         } else if (!dynamic_source && !dynamic_sink) {
2501                 dev_err(dapm->dev,
2502                         "Control not supported for path %s -> [%s] -> %s\n",
2503                         source->name, control, sink->name);
2504                 return -EINVAL;
2505         }
2506
2507         return 0;
2508 }
2509
2510 static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
2511         struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
2512         const char *control,
2513         int (*connected)(struct snd_soc_dapm_widget *source,
2514                          struct snd_soc_dapm_widget *sink))
2515 {
2516         struct snd_soc_dapm_widget *widgets[2];
2517         enum snd_soc_dapm_direction dir;
2518         struct snd_soc_dapm_path *path;
2519         int ret;
2520
2521         if (wsink->is_supply && !wsource->is_supply) {
2522                 dev_err(dapm->dev,
2523                         "Connecting non-supply widget to supply widget is not supported (%s -> %s)\n",
2524                         wsource->name, wsink->name);
2525                 return -EINVAL;
2526         }
2527
2528         if (connected && !wsource->is_supply) {
2529                 dev_err(dapm->dev,
2530                         "connected() callback only supported for supply widgets (%s -> %s)\n",
2531                         wsource->name, wsink->name);
2532                 return -EINVAL;
2533         }
2534
2535         if (wsource->is_supply && control) {
2536                 dev_err(dapm->dev,
2537                         "Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
2538                         wsource->name, control, wsink->name);
2539                 return -EINVAL;
2540         }
2541
2542         ret = snd_soc_dapm_check_dynamic_path(dapm, wsource, wsink, control);
2543         if (ret)
2544                 return ret;
2545
2546         path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
2547         if (!path)
2548                 return -ENOMEM;
2549
2550         path->node[SND_SOC_DAPM_DIR_IN] = wsource;
2551         path->node[SND_SOC_DAPM_DIR_OUT] = wsink;
2552         widgets[SND_SOC_DAPM_DIR_IN] = wsource;
2553         widgets[SND_SOC_DAPM_DIR_OUT] = wsink;
2554
2555         path->connected = connected;
2556         INIT_LIST_HEAD(&path->list);
2557         INIT_LIST_HEAD(&path->list_kcontrol);
2558
2559         if (wsource->is_supply || wsink->is_supply)
2560                 path->is_supply = 1;
2561
2562         /* connect static paths */
2563         if (control == NULL) {
2564                 path->connect = 1;
2565         } else {
2566                 switch (wsource->id) {
2567                 case snd_soc_dapm_demux:
2568                         ret = dapm_connect_mux(dapm, path, control, wsource);
2569                         if (ret)
2570                                 goto err;
2571                         break;
2572                 default:
2573                         break;
2574                 }
2575
2576                 switch (wsink->id) {
2577                 case snd_soc_dapm_mux:
2578                         ret = dapm_connect_mux(dapm, path, control, wsink);
2579                         if (ret != 0)
2580                                 goto err;
2581                         break;
2582                 case snd_soc_dapm_switch:
2583                 case snd_soc_dapm_mixer:
2584                 case snd_soc_dapm_mixer_named_ctl:
2585                         ret = dapm_connect_mixer(dapm, path, control);
2586                         if (ret != 0)
2587                                 goto err;
2588                         break;
2589                 default:
2590                         break;
2591                 }
2592         }
2593
2594         list_add(&path->list, &dapm->card->paths);
2595         snd_soc_dapm_for_each_direction(dir)
2596                 list_add(&path->list_node[dir], &widgets[dir]->edges[dir]);
2597
2598         snd_soc_dapm_for_each_direction(dir) {
2599                 dapm_update_widget_flags(widgets[dir]);
2600                 dapm_mark_dirty(widgets[dir], "Route added");
2601         }
2602
2603         if (dapm->card->instantiated && path->connect)
2604                 dapm_path_invalidate(path);
2605
2606         return 0;
2607 err:
2608         kfree(path);
2609         return ret;
2610 }
2611
2612 static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
2613                                   const struct snd_soc_dapm_route *route)
2614 {
2615         struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
2616         struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
2617         const char *sink;
2618         const char *source;
2619         char prefixed_sink[80];
2620         char prefixed_source[80];
2621         const char *prefix;
2622         int ret;
2623
2624         prefix = soc_dapm_prefix(dapm);
2625         if (prefix) {
2626                 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
2627                          prefix, route->sink);
2628                 sink = prefixed_sink;
2629                 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
2630                          prefix, route->source);
2631                 source = prefixed_source;
2632         } else {
2633                 sink = route->sink;
2634                 source = route->source;
2635         }
2636
2637         wsource = dapm_wcache_lookup(&dapm->path_source_cache, source);
2638         wsink = dapm_wcache_lookup(&dapm->path_sink_cache, sink);
2639
2640         if (wsink && wsource)
2641                 goto skip_search;
2642
2643         /*
2644          * find src and dest widgets over all widgets but favor a widget from
2645          * current DAPM context
2646          */
2647         list_for_each_entry(w, &dapm->card->widgets, list) {
2648                 if (!wsink && !(strcmp(w->name, sink))) {
2649                         wtsink = w;
2650                         if (w->dapm == dapm) {
2651                                 wsink = w;
2652                                 if (wsource)
2653                                         break;
2654                         }
2655                         continue;
2656                 }
2657                 if (!wsource && !(strcmp(w->name, source))) {
2658                         wtsource = w;
2659                         if (w->dapm == dapm) {
2660                                 wsource = w;
2661                                 if (wsink)
2662                                         break;
2663                         }
2664                 }
2665         }
2666         /* use widget from another DAPM context if not found from this */
2667         if (!wsink)
2668                 wsink = wtsink;
2669         if (!wsource)
2670                 wsource = wtsource;
2671
2672         if (wsource == NULL) {
2673                 dev_err(dapm->dev, "ASoC: no source widget found for %s\n",
2674                         route->source);
2675                 return -ENODEV;
2676         }
2677         if (wsink == NULL) {
2678                 dev_err(dapm->dev, "ASoC: no sink widget found for %s\n",
2679                         route->sink);
2680                 return -ENODEV;
2681         }
2682
2683 skip_search:
2684         dapm_wcache_update(&dapm->path_sink_cache, wsink);
2685         dapm_wcache_update(&dapm->path_source_cache, wsource);
2686
2687         ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,
2688                 route->connected);
2689         if (ret)
2690                 goto err;
2691
2692         return 0;
2693 err:
2694         dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n",
2695                  source, route->control, sink);
2696         return ret;
2697 }
2698
2699 static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
2700                                   const struct snd_soc_dapm_route *route)
2701 {
2702         struct snd_soc_dapm_widget *wsource, *wsink;
2703         struct snd_soc_dapm_path *path, *p;
2704         const char *sink;
2705         const char *source;
2706         char prefixed_sink[80];
2707         char prefixed_source[80];
2708         const char *prefix;
2709
2710         if (route->control) {
2711                 dev_err(dapm->dev,
2712                         "ASoC: Removal of routes with controls not supported\n");
2713                 return -EINVAL;
2714         }
2715
2716         prefix = soc_dapm_prefix(dapm);
2717         if (prefix) {
2718                 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
2719                          prefix, route->sink);
2720                 sink = prefixed_sink;
2721                 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
2722                          prefix, route->source);
2723                 source = prefixed_source;
2724         } else {
2725                 sink = route->sink;
2726                 source = route->source;
2727         }
2728
2729         path = NULL;
2730         list_for_each_entry(p, &dapm->card->paths, list) {
2731                 if (strcmp(p->source->name, source) != 0)
2732                         continue;
2733                 if (strcmp(p->sink->name, sink) != 0)
2734                         continue;
2735                 path = p;
2736                 break;
2737         }
2738
2739         if (path) {
2740                 wsource = path->source;
2741                 wsink = path->sink;
2742
2743                 dapm_mark_dirty(wsource, "Route removed");
2744                 dapm_mark_dirty(wsink, "Route removed");
2745                 if (path->connect)
2746                         dapm_path_invalidate(path);
2747
2748                 dapm_free_path(path);
2749
2750                 /* Update any path related flags */
2751                 dapm_update_widget_flags(wsource);
2752                 dapm_update_widget_flags(wsink);
2753         } else {
2754                 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
2755                          source, sink);
2756         }
2757
2758         return 0;
2759 }
2760
2761 /**
2762  * snd_soc_dapm_add_routes - Add routes between DAPM widgets
2763  * @dapm: DAPM context
2764  * @route: audio routes
2765  * @num: number of routes
2766  *
2767  * Connects 2 dapm widgets together via a named audio path. The sink is
2768  * the widget receiving the audio signal, whilst the source is the sender
2769  * of the audio signal.
2770  *
2771  * Returns 0 for success else error. On error all resources can be freed
2772  * with a call to snd_soc_card_free().
2773  */
2774 int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
2775                             const struct snd_soc_dapm_route *route, int num)
2776 {
2777         int i, r, ret = 0;
2778
2779         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2780         for (i = 0; i < num; i++) {
2781                 r = snd_soc_dapm_add_route(dapm, route);
2782                 if (r < 0) {
2783                         dev_err(dapm->dev, "ASoC: Failed to add route %s -> %s -> %s\n",
2784                                 route->source,
2785                                 route->control ? route->control : "direct",
2786                                 route->sink);
2787                         ret = r;
2788                 }
2789                 route++;
2790         }
2791         mutex_unlock(&dapm->card->dapm_mutex);
2792
2793         return ret;
2794 }
2795 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
2796
2797 /**
2798  * snd_soc_dapm_del_routes - Remove routes between DAPM widgets
2799  * @dapm: DAPM context
2800  * @route: audio routes
2801  * @num: number of routes
2802  *
2803  * Removes routes from the DAPM context.
2804  */
2805 int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm,
2806                             const struct snd_soc_dapm_route *route, int num)
2807 {
2808         int i;
2809
2810         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2811         for (i = 0; i < num; i++) {
2812                 snd_soc_dapm_del_route(dapm, route);
2813                 route++;
2814         }
2815         mutex_unlock(&dapm->card->dapm_mutex);
2816
2817         return 0;
2818 }
2819 EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes);
2820
2821 static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
2822                                    const struct snd_soc_dapm_route *route)
2823 {
2824         struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
2825                                                               route->source,
2826                                                               true);
2827         struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
2828                                                             route->sink,
2829                                                             true);
2830         struct snd_soc_dapm_path *path;
2831         int count = 0;
2832
2833         if (!source) {
2834                 dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
2835                         route->source);
2836                 return -ENODEV;
2837         }
2838
2839         if (!sink) {
2840                 dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
2841                         route->sink);
2842                 return -ENODEV;
2843         }
2844
2845         if (route->control || route->connected)
2846                 dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
2847                          route->source, route->sink);
2848
2849         snd_soc_dapm_widget_for_each_sink_path(source, path) {
2850                 if (path->sink == sink) {
2851                         path->weak = 1;
2852                         count++;
2853                 }
2854         }
2855
2856         if (count == 0)
2857                 dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
2858                         route->source, route->sink);
2859         if (count > 1)
2860                 dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
2861                          count, route->source, route->sink);
2862
2863         return 0;
2864 }
2865
2866 /**
2867  * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
2868  * @dapm: DAPM context
2869  * @route: audio routes
2870  * @num: number of routes
2871  *
2872  * Mark existing routes matching those specified in the passed array
2873  * as being weak, meaning that they are ignored for the purpose of
2874  * power decisions.  The main intended use case is for sidetone paths
2875  * which couple audio between other independent paths if they are both
2876  * active in order to make the combination work better at the user
2877  * level but which aren't intended to be "used".
2878  *
2879  * Note that CODEC drivers should not use this as sidetone type paths
2880  * can frequently also be used as bypass paths.
2881  */
2882 int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
2883                              const struct snd_soc_dapm_route *route, int num)
2884 {
2885         int i, err;
2886         int ret = 0;
2887
2888         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2889         for (i = 0; i < num; i++) {
2890                 err = snd_soc_dapm_weak_route(dapm, route);
2891                 if (err)
2892                         ret = err;
2893                 route++;
2894         }
2895         mutex_unlock(&dapm->card->dapm_mutex);
2896
2897         return ret;
2898 }
2899 EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2900
2901 /**
2902  * snd_soc_dapm_new_widgets - add new dapm widgets
2903  * @card: card to be checked for new dapm widgets
2904  *
2905  * Checks the codec for any new dapm widgets and creates them if found.
2906  *
2907  * Returns 0 for success.
2908  */
2909 int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
2910 {
2911         struct snd_soc_dapm_widget *w;
2912         unsigned int val;
2913
2914         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2915
2916         list_for_each_entry(w, &card->widgets, list)
2917         {
2918                 if (w->new)
2919                         continue;
2920
2921                 if (w->num_kcontrols) {
2922                         w->kcontrols = kzalloc(w->num_kcontrols *
2923                                                 sizeof(struct snd_kcontrol *),
2924                                                 GFP_KERNEL);
2925                         if (!w->kcontrols) {
2926                                 mutex_unlock(&card->dapm_mutex);
2927                                 return -ENOMEM;
2928                         }
2929                 }
2930
2931                 switch(w->id) {
2932                 case snd_soc_dapm_switch:
2933                 case snd_soc_dapm_mixer:
2934                 case snd_soc_dapm_mixer_named_ctl:
2935                         dapm_new_mixer(w);
2936                         break;
2937                 case snd_soc_dapm_mux:
2938                 case snd_soc_dapm_demux:
2939                         dapm_new_mux(w);
2940                         break;
2941                 case snd_soc_dapm_pga:
2942                 case snd_soc_dapm_out_drv:
2943                         dapm_new_pga(w);
2944                         break;
2945                 case snd_soc_dapm_dai_link:
2946                         dapm_new_dai_link(w);
2947                         break;
2948                 default:
2949                         break;
2950                 }
2951
2952                 /* Read the initial power state from the device */
2953                 if (w->reg >= 0) {
2954                         soc_dapm_read(w->dapm, w->reg, &val);
2955                         val = val >> w->shift;
2956                         val &= w->mask;
2957                         if (val == w->on_val)
2958                                 w->power = 1;
2959                 }
2960
2961                 w->new = 1;
2962
2963                 dapm_mark_dirty(w, "new widget");
2964                 dapm_debugfs_add_widget(w);
2965         }
2966
2967         dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2968         mutex_unlock(&card->dapm_mutex);
2969         return 0;
2970 }
2971 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
2972
2973 /**
2974  * snd_soc_dapm_get_volsw - dapm mixer get callback
2975  * @kcontrol: mixer control
2976  * @ucontrol: control element information
2977  *
2978  * Callback to get the value of a dapm mixer control.
2979  *
2980  * Returns 0 for success.
2981  */
2982 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
2983         struct snd_ctl_elem_value *ucontrol)
2984 {
2985         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
2986         struct snd_soc_card *card = dapm->card;
2987         struct soc_mixer_control *mc =
2988                 (struct soc_mixer_control *)kcontrol->private_value;
2989         int reg = mc->reg;
2990         unsigned int shift = mc->shift;
2991         int max = mc->max;
2992         unsigned int mask = (1 << fls(max)) - 1;
2993         unsigned int invert = mc->invert;
2994         unsigned int val;
2995         int ret = 0;
2996
2997         if (snd_soc_volsw_is_stereo(mc))
2998                 dev_warn(dapm->dev,
2999                          "ASoC: Control '%s' is stereo, which is not supported\n",
3000                          kcontrol->id.name);
3001
3002         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3003         if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
3004                 ret = soc_dapm_read(dapm, reg, &val);
3005                 val = (val >> shift) & mask;
3006         } else {
3007                 val = dapm_kcontrol_get_value(kcontrol);
3008         }
3009         mutex_unlock(&card->dapm_mutex);
3010
3011         if (invert)
3012                 ucontrol->value.integer.value[0] = max - val;
3013         else
3014                 ucontrol->value.integer.value[0] = val;
3015
3016         return ret;
3017 }
3018 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
3019
3020 /**
3021  * snd_soc_dapm_put_volsw - dapm mixer set callback
3022  * @kcontrol: mixer control
3023  * @ucontrol: control element information
3024  *
3025  * Callback to set the value of a dapm mixer control.
3026  *
3027  * Returns 0 for success.
3028  */
3029 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
3030         struct snd_ctl_elem_value *ucontrol)
3031 {
3032         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3033         struct snd_soc_card *card = dapm->card;
3034         struct soc_mixer_control *mc =
3035                 (struct soc_mixer_control *)kcontrol->private_value;
3036         int reg = mc->reg;
3037         unsigned int shift = mc->shift;
3038         int max = mc->max;
3039         unsigned int mask = (1 << fls(max)) - 1;
3040         unsigned int invert = mc->invert;
3041         unsigned int val;
3042         int connect, change, reg_change = 0;
3043         struct snd_soc_dapm_update update;
3044         int ret = 0;
3045
3046         if (snd_soc_volsw_is_stereo(mc))
3047                 dev_warn(dapm->dev,
3048                          "ASoC: Control '%s' is stereo, which is not supported\n",
3049                          kcontrol->id.name);
3050
3051         val = (ucontrol->value.integer.value[0] & mask);
3052         connect = !!val;
3053
3054         if (invert)
3055                 val = max - val;
3056
3057         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3058
3059         change = dapm_kcontrol_set_value(kcontrol, val);
3060
3061         if (reg != SND_SOC_NOPM) {
3062                 mask = mask << shift;
3063                 val = val << shift;
3064
3065                 reg_change = soc_dapm_test_bits(dapm, reg, mask, val);
3066         }
3067
3068         if (change || reg_change) {
3069                 if (reg_change) {
3070                         update.kcontrol = kcontrol;
3071                         update.reg = reg;
3072                         update.mask = mask;
3073                         update.val = val;
3074                         card->update = &update;
3075                 }
3076                 change |= reg_change;
3077
3078                 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
3079
3080                 card->update = NULL;
3081         }
3082
3083         mutex_unlock(&card->dapm_mutex);
3084
3085         if (ret > 0)
3086                 soc_dpcm_runtime_update(card);
3087
3088         return change;
3089 }
3090 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
3091
3092 /**
3093  * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
3094  * @kcontrol: mixer control
3095  * @ucontrol: control element information
3096  *
3097  * Callback to get the value of a dapm enumerated double mixer control.
3098  *
3099  * Returns 0 for success.
3100  */
3101 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
3102         struct snd_ctl_elem_value *ucontrol)
3103 {
3104         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3105         struct snd_soc_card *card = dapm->card;
3106         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3107         unsigned int reg_val, val;
3108
3109         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3110         if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
3111                 int ret = soc_dapm_read(dapm, e->reg, &reg_val);
3112                 if (ret) {
3113                         mutex_unlock(&card->dapm_mutex);
3114                         return ret;
3115                 }
3116         } else {
3117                 reg_val = dapm_kcontrol_get_value(kcontrol);
3118         }
3119         mutex_unlock(&card->dapm_mutex);
3120
3121         val = (reg_val >> e->shift_l) & e->mask;
3122         ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
3123         if (e->shift_l != e->shift_r) {
3124                 val = (reg_val >> e->shift_r) & e->mask;
3125                 val = snd_soc_enum_val_to_item(e, val);
3126                 ucontrol->value.enumerated.item[1] = val;
3127         }
3128
3129         return 0;
3130 }
3131 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
3132
3133 /**
3134  * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
3135  * @kcontrol: mixer control
3136  * @ucontrol: control element information
3137  *
3138  * Callback to set the value of a dapm enumerated double mixer control.
3139  *
3140  * Returns 0 for success.
3141  */
3142 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
3143         struct snd_ctl_elem_value *ucontrol)
3144 {
3145         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3146         struct snd_soc_card *card = dapm->card;
3147         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3148         unsigned int *item = ucontrol->value.enumerated.item;
3149         unsigned int val, change, reg_change = 0;
3150         unsigned int mask;
3151         struct snd_soc_dapm_update update;
3152         int ret = 0;
3153
3154         if (item[0] >= e->items)
3155                 return -EINVAL;
3156
3157         val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
3158         mask = e->mask << e->shift_l;
3159         if (e->shift_l != e->shift_r) {
3160                 if (item[1] > e->items)
3161                         return -EINVAL;
3162                 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_l;
3163                 mask |= e->mask << e->shift_r;
3164         }
3165
3166         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3167
3168         change = dapm_kcontrol_set_value(kcontrol, val);
3169
3170         if (e->reg != SND_SOC_NOPM)
3171                 reg_change = soc_dapm_test_bits(dapm, e->reg, mask, val);
3172
3173         if (change || reg_change) {
3174                 if (reg_change) {
3175                         update.kcontrol = kcontrol;
3176                         update.reg = e->reg;
3177                         update.mask = mask;
3178                         update.val = val;
3179                         card->update = &update;
3180                 }
3181                 change |= reg_change;
3182
3183                 ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
3184
3185                 card->update = NULL;
3186         }
3187
3188         mutex_unlock(&card->dapm_mutex);
3189
3190         if (ret > 0)
3191                 soc_dpcm_runtime_update(card);
3192
3193         return change;
3194 }
3195 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
3196
3197 /**
3198  * snd_soc_dapm_info_pin_switch - Info for a pin switch
3199  *
3200  * @kcontrol: mixer control
3201  * @uinfo: control element information
3202  *
3203  * Callback to provide information about a pin switch control.
3204  */
3205 int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
3206                                  struct snd_ctl_elem_info *uinfo)
3207 {
3208         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3209         uinfo->count = 1;
3210         uinfo->value.integer.min = 0;
3211         uinfo->value.integer.max = 1;
3212
3213         return 0;
3214 }
3215 EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
3216
3217 /**
3218  * snd_soc_dapm_get_pin_switch - Get information for a pin switch
3219  *
3220  * @kcontrol: mixer control
3221  * @ucontrol: Value
3222  */
3223 int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
3224                                 struct snd_ctl_elem_value *ucontrol)
3225 {
3226         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
3227         const char *pin = (const char *)kcontrol->private_value;
3228
3229         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3230
3231         ucontrol->value.integer.value[0] =
3232                 snd_soc_dapm_get_pin_status(&card->dapm, pin);
3233
3234         mutex_unlock(&card->dapm_mutex);
3235
3236         return 0;
3237 }
3238 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
3239
3240 /**
3241  * snd_soc_dapm_put_pin_switch - Set information for a pin switch
3242  *
3243  * @kcontrol: mixer control
3244  * @ucontrol: Value
3245  */
3246 int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
3247                                 struct snd_ctl_elem_value *ucontrol)
3248 {
3249         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
3250         const char *pin = (const char *)kcontrol->private_value;
3251
3252         if (ucontrol->value.integer.value[0])
3253                 snd_soc_dapm_enable_pin(&card->dapm, pin);
3254         else
3255                 snd_soc_dapm_disable_pin(&card->dapm, pin);
3256
3257         snd_soc_dapm_sync(&card->dapm);
3258         return 0;
3259 }
3260 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
3261
3262 struct snd_soc_dapm_widget *
3263 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
3264         const struct snd_soc_dapm_widget *widget)
3265 {
3266         struct snd_soc_dapm_widget *w;
3267
3268         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3269         w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3270         if (!w)
3271                 dev_err(dapm->dev,
3272                         "ASoC: Failed to create DAPM control %s\n",
3273                         widget->name);
3274
3275         mutex_unlock(&dapm->card->dapm_mutex);
3276         return w;
3277 }
3278
3279 struct snd_soc_dapm_widget *
3280 snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
3281                          const struct snd_soc_dapm_widget *widget)
3282 {
3283         enum snd_soc_dapm_direction dir;
3284         struct snd_soc_dapm_widget *w;
3285         const char *prefix;
3286         int ret;
3287
3288         if ((w = dapm_cnew_widget(widget)) == NULL)
3289                 return NULL;
3290
3291         switch (w->id) {
3292         case snd_soc_dapm_regulator_supply:
3293                 w->regulator = devm_regulator_get(dapm->dev, w->name);
3294                 if (IS_ERR(w->regulator)) {
3295                         ret = PTR_ERR(w->regulator);
3296                         dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
3297                                 w->name, ret);
3298                         return NULL;
3299                 }
3300
3301                 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
3302                         ret = regulator_allow_bypass(w->regulator, true);
3303                         if (ret != 0)
3304                                 dev_warn(w->dapm->dev,
3305                                          "ASoC: Failed to bypass %s: %d\n",
3306                                          w->name, ret);
3307                 }
3308                 break;
3309         case snd_soc_dapm_clock_supply:
3310 #ifdef CONFIG_CLKDEV_LOOKUP
3311                 w->clk = devm_clk_get(dapm->dev, w->name);
3312                 if (IS_ERR(w->clk)) {
3313                         ret = PTR_ERR(w->clk);
3314                         dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
3315                                 w->name, ret);
3316                         return NULL;
3317                 }
3318 #else
3319                 return NULL;
3320 #endif
3321                 break;
3322         default:
3323                 break;
3324         }
3325
3326         prefix = soc_dapm_prefix(dapm);
3327         if (prefix)
3328                 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, widget->name);
3329         else
3330                 w->name = kstrdup_const(widget->name, GFP_KERNEL);
3331         if (w->name == NULL) {
3332                 kfree(w);
3333                 return NULL;
3334         }
3335
3336         switch (w->id) {
3337         case snd_soc_dapm_mic:
3338                 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3339                 w->power_check = dapm_generic_check_power;
3340                 break;
3341         case snd_soc_dapm_input:
3342                 if (!dapm->card->fully_routed)
3343                         w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3344                 w->power_check = dapm_generic_check_power;
3345                 break;
3346         case snd_soc_dapm_spk:
3347         case snd_soc_dapm_hp:
3348                 w->is_ep = SND_SOC_DAPM_EP_SINK;
3349                 w->power_check = dapm_generic_check_power;
3350                 break;
3351         case snd_soc_dapm_output:
3352                 if (!dapm->card->fully_routed)
3353                         w->is_ep = SND_SOC_DAPM_EP_SINK;
3354                 w->power_check = dapm_generic_check_power;
3355                 break;
3356         case snd_soc_dapm_vmid:
3357         case snd_soc_dapm_siggen:
3358                 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3359                 w->power_check = dapm_always_on_check_power;
3360                 break;
3361         case snd_soc_dapm_sink:
3362                 w->is_ep = SND_SOC_DAPM_EP_SINK;
3363                 w->power_check = dapm_always_on_check_power;
3364                 break;
3365
3366         case snd_soc_dapm_mux:
3367         case snd_soc_dapm_demux:
3368         case snd_soc_dapm_switch:
3369         case snd_soc_dapm_mixer:
3370         case snd_soc_dapm_mixer_named_ctl:
3371         case snd_soc_dapm_adc:
3372         case snd_soc_dapm_aif_out:
3373         case snd_soc_dapm_dac:
3374         case snd_soc_dapm_aif_in:
3375         case snd_soc_dapm_pga:
3376         case snd_soc_dapm_out_drv:
3377         case snd_soc_dapm_micbias:
3378         case snd_soc_dapm_line:
3379         case snd_soc_dapm_dai_link:
3380         case snd_soc_dapm_dai_out:
3381         case snd_soc_dapm_dai_in:
3382                 w->power_check = dapm_generic_check_power;
3383                 break;
3384         case snd_soc_dapm_supply:
3385         case snd_soc_dapm_regulator_supply:
3386         case snd_soc_dapm_clock_supply:
3387         case snd_soc_dapm_kcontrol:
3388                 w->is_supply = 1;
3389                 w->power_check = dapm_supply_check_power;
3390                 break;
3391         default:
3392                 w->power_check = dapm_always_on_check_power;
3393                 break;
3394         }
3395
3396         w->dapm = dapm;
3397         INIT_LIST_HEAD(&w->list);
3398         INIT_LIST_HEAD(&w->dirty);
3399         list_add_tail(&w->list, &dapm->card->widgets);
3400
3401         snd_soc_dapm_for_each_direction(dir) {
3402                 INIT_LIST_HEAD(&w->edges[dir]);
3403                 w->endpoints[dir] = -1;
3404         }
3405
3406         /* machine layer set ups unconnected pins and insertions */
3407         w->connected = 1;
3408         return w;
3409 }
3410
3411 /**
3412  * snd_soc_dapm_new_controls - create new dapm controls
3413  * @dapm: DAPM context
3414  * @widget: widget array
3415  * @num: number of widgets
3416  *
3417  * Creates new DAPM controls based upon the templates.
3418  *
3419  * Returns 0 for success else error.
3420  */
3421 int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
3422         const struct snd_soc_dapm_widget *widget,
3423         int num)
3424 {
3425         struct snd_soc_dapm_widget *w;
3426         int i;
3427         int ret = 0;
3428
3429         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
3430         for (i = 0; i < num; i++) {
3431                 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3432                 if (!w) {
3433                         dev_err(dapm->dev,
3434                                 "ASoC: Failed to create DAPM control %s\n",
3435                                 widget->name);
3436                         ret = -ENOMEM;
3437                         break;
3438                 }
3439                 widget++;
3440         }
3441         mutex_unlock(&dapm->card->dapm_mutex);
3442         return ret;
3443 }
3444 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
3445
3446 static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
3447                                   struct snd_kcontrol *kcontrol, int event)
3448 {
3449         struct snd_soc_dapm_path *source_p, *sink_p;
3450         struct snd_soc_dai *source, *sink;
3451         const struct snd_soc_pcm_stream *config = w->params + w->params_select;
3452         struct snd_pcm_substream substream;
3453         struct snd_pcm_hw_params *params = NULL;
3454         u64 fmt;
3455         int ret;
3456
3457         if (WARN_ON(!config) ||
3458             WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
3459                     list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
3460                 return -EINVAL;
3461
3462         /* We only support a single source and sink, pick the first */
3463         source_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_OUT],
3464                                     struct snd_soc_dapm_path,
3465                                     list_node[SND_SOC_DAPM_DIR_OUT]);
3466         sink_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_IN],
3467                                     struct snd_soc_dapm_path,
3468                                     list_node[SND_SOC_DAPM_DIR_IN]);
3469
3470         source = source_p->source->priv;
3471         sink = sink_p->sink->priv;
3472
3473         /* Be a little careful as we don't want to overflow the mask array */
3474         if (config->formats) {
3475                 fmt = ffs(config->formats) - 1;
3476         } else {
3477                 dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n",
3478                          config->formats);
3479                 fmt = 0;
3480         }
3481
3482         /* Currently very limited parameter selection */
3483         params = kzalloc(sizeof(*params), GFP_KERNEL);
3484         if (!params) {
3485                 ret = -ENOMEM;
3486                 goto out;
3487         }
3488         snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
3489
3490         hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
3491                 config->rate_min;
3492         hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
3493                 config->rate_max;
3494
3495         hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
3496                 = config->channels_min;
3497         hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
3498                 = config->channels_max;
3499
3500         memset(&substream, 0, sizeof(substream));
3501
3502         switch (event) {
3503         case SND_SOC_DAPM_PRE_PMU:
3504                 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3505                 if (source->driver->ops && source->driver->ops->startup) {
3506                         ret = source->driver->ops->startup(&substream, source);
3507                         if (ret < 0) {
3508                                 dev_err(source->dev,
3509                                         "ASoC: startup() failed: %d\n", ret);
3510                                 goto out;
3511                         }
3512                         source->active++;
3513                 }
3514                 ret = soc_dai_hw_params(&substream, params, source);
3515                 if (ret < 0)
3516                         goto out;
3517
3518                 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
3519                 if (sink->driver->ops && sink->driver->ops->startup) {
3520                         ret = sink->driver->ops->startup(&substream, sink);
3521                         if (ret < 0) {
3522                                 dev_err(sink->dev,
3523                                         "ASoC: startup() failed: %d\n", ret);
3524                                 goto out;
3525                         }
3526                         sink->active++;
3527                 }
3528                 ret = soc_dai_hw_params(&substream, params, sink);
3529                 if (ret < 0)
3530                         goto out;
3531                 break;
3532
3533         case SND_SOC_DAPM_POST_PMU:
3534                 ret = snd_soc_dai_digital_mute(sink, 0,
3535                                                SNDRV_PCM_STREAM_PLAYBACK);
3536                 if (ret != 0 && ret != -ENOTSUPP)
3537                         dev_warn(sink->dev, "ASoC: Failed to unmute: %d\n", ret);
3538                 ret = 0;
3539                 break;
3540
3541         case SND_SOC_DAPM_PRE_PMD:
3542                 ret = snd_soc_dai_digital_mute(sink, 1,
3543                                                SNDRV_PCM_STREAM_PLAYBACK);
3544                 if (ret != 0 && ret != -ENOTSUPP)
3545                         dev_warn(sink->dev, "ASoC: Failed to mute: %d\n", ret);
3546                 ret = 0;
3547
3548                 source->active--;
3549                 if (source->driver->ops && source->driver->ops->shutdown) {
3550                         substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3551                         source->driver->ops->shutdown(&substream, source);
3552                 }
3553
3554                 sink->active--;
3555                 if (sink->driver->ops && sink->driver->ops->shutdown) {
3556                         substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
3557                         sink->driver->ops->shutdown(&substream, sink);
3558                 }
3559                 break;
3560
3561         default:
3562                 WARN(1, "Unknown event %d\n", event);
3563                 ret = -EINVAL;
3564         }
3565
3566 out:
3567         kfree(params);
3568         return ret;
3569 }
3570
3571 static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
3572                           struct snd_ctl_elem_value *ucontrol)
3573 {
3574         struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3575
3576         ucontrol->value.enumerated.item[0] = w->params_select;
3577
3578         return 0;
3579 }
3580
3581 static int snd_soc_dapm_dai_link_put(struct snd_kcontrol *kcontrol,
3582                           struct snd_ctl_elem_value *ucontrol)
3583 {
3584         struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3585
3586         /* Can't change the config when widget is already powered */
3587         if (w->power)
3588                 return -EBUSY;
3589
3590         if (ucontrol->value.enumerated.item[0] == w->params_select)
3591                 return 0;
3592
3593         if (ucontrol->value.enumerated.item[0] >= w->num_params)
3594                 return -EINVAL;
3595
3596         w->params_select = ucontrol->value.enumerated.item[0];
3597
3598         return 0;
3599 }
3600
3601 int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
3602                          const struct snd_soc_pcm_stream *params,
3603                          unsigned int num_params,
3604                          struct snd_soc_dapm_widget *source,
3605                          struct snd_soc_dapm_widget *sink)
3606 {
3607         struct snd_soc_dapm_widget template;
3608         struct snd_soc_dapm_widget *w;
3609         char *link_name;
3610         int ret, count;
3611         unsigned long private_value;
3612         const char **w_param_text;
3613         struct soc_enum w_param_enum[] = {
3614                 SOC_ENUM_SINGLE(0, 0, 0, NULL),
3615         };
3616         struct snd_kcontrol_new kcontrol_dai_link[] = {
3617                 SOC_ENUM_EXT(NULL, w_param_enum[0],
3618                              snd_soc_dapm_dai_link_get,
3619                              snd_soc_dapm_dai_link_put),
3620         };
3621         const struct snd_soc_pcm_stream *config = params;
3622
3623         w_param_text = devm_kcalloc(card->dev, num_params,
3624                                         sizeof(char *), GFP_KERNEL);
3625         if (!w_param_text)
3626                 return -ENOMEM;
3627
3628         link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
3629                                    source->name, sink->name);
3630         if (!link_name) {
3631                 ret = -ENOMEM;
3632                 goto outfree_w_param;
3633         }
3634
3635         for (count = 0 ; count < num_params; count++) {
3636                 if (!config->stream_name) {
3637                         dev_warn(card->dapm.dev,
3638                                 "ASoC: anonymous config %d for dai link %s\n",
3639                                 count, link_name);
3640                         w_param_text[count] =
3641                                 devm_kasprintf(card->dev, GFP_KERNEL,
3642                                                "Anonymous Configuration %d",
3643                                                count);
3644                         if (!w_param_text[count]) {
3645                                 ret = -ENOMEM;
3646                                 goto outfree_link_name;
3647                         }
3648                 } else {
3649                         w_param_text[count] = devm_kmemdup(card->dev,
3650                                                 config->stream_name,
3651                                                 strlen(config->stream_name) + 1,
3652                                                 GFP_KERNEL);
3653                         if (!w_param_text[count]) {
3654                                 ret = -ENOMEM;
3655                                 goto outfree_link_name;
3656                         }
3657                 }
3658                 config++;
3659         }
3660         w_param_enum[0].items = num_params;
3661         w_param_enum[0].texts = w_param_text;
3662
3663         memset(&template, 0, sizeof(template));
3664         template.reg = SND_SOC_NOPM;
3665         template.id = snd_soc_dapm_dai_link;
3666         template.name = link_name;
3667         template.event = snd_soc_dai_link_event;
3668         template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
3669                 SND_SOC_DAPM_PRE_PMD;
3670         template.num_kcontrols = 1;
3671         /* duplicate w_param_enum on heap so that memory persists */
3672         private_value =
3673                 (unsigned long) devm_kmemdup(card->dev,
3674                         (void *)(kcontrol_dai_link[0].private_value),
3675                         sizeof(struct soc_enum), GFP_KERNEL);
3676         if (!private_value) {
3677                 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3678                         link_name);
3679                 ret = -ENOMEM;
3680                 goto outfree_link_name;
3681         }
3682         kcontrol_dai_link[0].private_value = private_value;
3683         /* duplicate kcontrol_dai_link on heap so that memory persists */
3684         template.kcontrol_news =
3685                                 devm_kmemdup(card->dev, &kcontrol_dai_link[0],
3686                                         sizeof(struct snd_kcontrol_new),
3687                                         GFP_KERNEL);
3688         if (!template.kcontrol_news) {
3689                 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3690                         link_name);
3691                 ret = -ENOMEM;
3692                 goto outfree_private_value;
3693         }
3694
3695         dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
3696
3697         w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
3698         if (!w) {
3699                 dev_err(card->dev, "ASoC: Failed to create %s widget\n",
3700                         link_name);
3701                 ret = -ENOMEM;
3702                 goto outfree_kcontrol_news;
3703         }
3704
3705         w->params = params;
3706         w->num_params = num_params;
3707
3708         ret = snd_soc_dapm_add_path(&card->dapm, source, w, NULL, NULL);
3709         if (ret)
3710                 goto outfree_w;
3711         return snd_soc_dapm_add_path(&card->dapm, w, sink, NULL, NULL);
3712
3713 outfree_w:
3714         devm_kfree(card->dev, w);
3715 outfree_kcontrol_news:
3716         devm_kfree(card->dev, (void *)template.kcontrol_news);
3717 outfree_private_value:
3718         devm_kfree(card->dev, (void *)private_value);
3719 outfree_link_name:
3720         devm_kfree(card->dev, link_name);
3721 outfree_w_param:
3722         for (count = 0 ; count < num_params; count++)
3723                 devm_kfree(card->dev, (void *)w_param_text[count]);
3724         devm_kfree(card->dev, w_param_text);
3725
3726         return ret;
3727 }
3728
3729 int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
3730                                  struct snd_soc_dai *dai)
3731 {
3732         struct snd_soc_dapm_widget template;
3733         struct snd_soc_dapm_widget *w;
3734
3735         WARN_ON(dapm->dev != dai->dev);
3736
3737         memset(&template, 0, sizeof(template));
3738         template.reg = SND_SOC_NOPM;
3739
3740         if (dai->driver->playback.stream_name) {
3741                 template.id = snd_soc_dapm_dai_in;
3742                 template.name = dai->driver->playback.stream_name;
3743                 template.sname = dai->driver->playback.stream_name;
3744
3745                 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
3746                         template.name);
3747
3748                 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
3749                 if (!w) {
3750                         dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
3751                                 dai->driver->playback.stream_name);
3752                         return -ENOMEM;
3753                 }
3754
3755                 w->priv = dai;
3756                 dai->playback_widget = w;
3757         }
3758
3759         if (dai->driver->capture.stream_name) {
3760                 template.id = snd_soc_dapm_dai_out;
3761                 template.name = dai->driver->capture.stream_name;
3762                 template.sname = dai->driver->capture.stream_name;
3763
3764                 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
3765                         template.name);
3766
3767                 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
3768                 if (!w) {
3769                         dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
3770                                 dai->driver->capture.stream_name);
3771                         return -ENOMEM;
3772                 }
3773
3774                 w->priv = dai;
3775                 dai->capture_widget = w;
3776         }
3777
3778         return 0;
3779 }
3780
3781 int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
3782 {
3783         struct snd_soc_dapm_widget *dai_w, *w;
3784         struct snd_soc_dapm_widget *src, *sink;
3785         struct snd_soc_dai *dai;
3786
3787         /* For each DAI widget... */
3788         list_for_each_entry(dai_w, &card->widgets, list) {
3789                 switch (dai_w->id) {
3790                 case snd_soc_dapm_dai_in:
3791                 case snd_soc_dapm_dai_out:
3792                         break;
3793                 default:
3794                         continue;
3795                 }
3796
3797                 dai = dai_w->priv;
3798
3799                 /* ...find all widgets with the same stream and link them */
3800                 list_for_each_entry(w, &card->widgets, list) {
3801                         if (w->dapm != dai_w->dapm)
3802                                 continue;
3803
3804                         switch (w->id) {
3805                         case snd_soc_dapm_dai_in:
3806                         case snd_soc_dapm_dai_out:
3807                                 continue;
3808                         default:
3809                                 break;
3810                         }
3811
3812                         if (!w->sname || !strstr(w->sname, dai_w->sname))
3813                                 continue;
3814
3815                         if (dai_w->id == snd_soc_dapm_dai_in) {
3816                                 src = dai_w;
3817                                 sink = w;
3818                         } else {
3819                                 src = w;
3820                                 sink = dai_w;
3821                         }
3822                         dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
3823                         snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
3824                 }
3825         }
3826
3827         return 0;
3828 }
3829
3830 static void dapm_connect_dai_link_widgets(struct snd_soc_card *card,
3831                                           struct snd_soc_pcm_runtime *rtd)
3832 {
3833         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
3834         struct snd_soc_dapm_widget *sink, *source;
3835         int i;
3836
3837         for (i = 0; i < rtd->num_codecs; i++) {
3838                 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
3839
3840                 /* connect BE DAI playback if widgets are valid */
3841                 if (codec_dai->playback_widget && cpu_dai->playback_widget) {
3842                         source = cpu_dai->playback_widget;
3843                         sink = codec_dai->playback_widget;
3844                         dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
3845                                 cpu_dai->component->name, source->name,
3846                                 codec_dai->component->name, sink->name);
3847
3848                         snd_soc_dapm_add_path(&card->dapm, source, sink,
3849                                 NULL, NULL);
3850                 }
3851
3852                 /* connect BE DAI capture if widgets are valid */
3853                 if (codec_dai->capture_widget && cpu_dai->capture_widget) {
3854                         source = codec_dai->capture_widget;
3855                         sink = cpu_dai->capture_widget;
3856                         dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
3857                                 codec_dai->component->name, source->name,
3858                                 cpu_dai->component->name, sink->name);
3859
3860                         snd_soc_dapm_add_path(&card->dapm, source, sink,
3861                                 NULL, NULL);
3862                 }
3863         }
3864 }
3865
3866 static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
3867         int event)
3868 {
3869         struct snd_soc_dapm_widget *w;
3870         unsigned int ep;
3871
3872         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
3873                 w = dai->playback_widget;
3874         else
3875                 w = dai->capture_widget;
3876
3877         if (w) {
3878                 dapm_mark_dirty(w, "stream event");
3879
3880                 if (w->id == snd_soc_dapm_dai_in) {
3881                         ep = SND_SOC_DAPM_EP_SOURCE;
3882                         dapm_widget_invalidate_input_paths(w);
3883                 } else {
3884                         ep = SND_SOC_DAPM_EP_SINK;
3885                         dapm_widget_invalidate_output_paths(w);
3886                 }
3887
3888                 switch (event) {
3889                 case SND_SOC_DAPM_STREAM_START:
3890                         w->active = 1;
3891                         w->is_ep = ep;
3892                         break;
3893                 case SND_SOC_DAPM_STREAM_STOP:
3894                         w->active = 0;
3895                         w->is_ep = 0;
3896                         break;
3897                 case SND_SOC_DAPM_STREAM_SUSPEND:
3898                 case SND_SOC_DAPM_STREAM_RESUME:
3899                 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
3900                 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
3901                         break;
3902                 }
3903         }
3904 }
3905
3906 void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
3907 {
3908         struct snd_soc_pcm_runtime *rtd;
3909
3910         /* for each BE DAI link... */
3911         list_for_each_entry(rtd, &card->rtd_list, list)  {
3912                 /*
3913                  * dynamic FE links have no fixed DAI mapping.
3914                  * CODEC<->CODEC links have no direct connection.
3915                  */
3916                 if (rtd->dai_link->dynamic || rtd->dai_link->params)
3917                         continue;
3918
3919                 dapm_connect_dai_link_widgets(card, rtd);
3920         }
3921 }
3922
3923 static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3924         int event)
3925 {
3926         int i;
3927
3928         soc_dapm_dai_stream_event(rtd->cpu_dai, stream, event);
3929         for (i = 0; i < rtd->num_codecs; i++)
3930                 soc_dapm_dai_stream_event(rtd->codec_dais[i], stream, event);
3931
3932         dapm_power_widgets(rtd->card, event);
3933 }
3934
3935 /**
3936  * snd_soc_dapm_stream_event - send a stream event to the dapm core
3937  * @rtd: PCM runtime data
3938  * @stream: stream name
3939  * @event: stream event
3940  *
3941  * Sends a stream event to the dapm core. The core then makes any
3942  * necessary widget power changes.
3943  *
3944  * Returns 0 for success else error.
3945  */
3946 void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3947                               int event)
3948 {
3949         struct snd_soc_card *card = rtd->card;
3950
3951         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3952         soc_dapm_stream_event(rtd, stream, event);
3953         mutex_unlock(&card->dapm_mutex);
3954 }
3955
3956 /**
3957  * snd_soc_dapm_enable_pin_unlocked - enable pin.
3958  * @dapm: DAPM context
3959  * @pin: pin name
3960  *
3961  * Enables input/output pin and its parents or children widgets iff there is
3962  * a valid audio route and active audio stream.
3963  *
3964  * Requires external locking.
3965  *
3966  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3967  * do any widget power switching.
3968  */
3969 int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
3970                                    const char *pin)
3971 {
3972         return snd_soc_dapm_set_pin(dapm, pin, 1);
3973 }
3974 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
3975
3976 /**
3977  * snd_soc_dapm_enable_pin - enable pin.
3978  * @dapm: DAPM context
3979  * @pin: pin name
3980  *
3981  * Enables input/output pin and its parents or children widgets iff there is
3982  * a valid audio route and active audio stream.
3983  *
3984  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3985  * do any widget power switching.
3986  */
3987 int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
3988 {
3989         int ret;
3990
3991         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3992
3993         ret = snd_soc_dapm_set_pin(dapm, pin, 1);
3994
3995         mutex_unlock(&dapm->card->dapm_mutex);
3996
3997         return ret;
3998 }
3999 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
4000
4001 /**
4002  * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
4003  * @dapm: DAPM context
4004  * @pin: pin name
4005  *
4006  * Enables input/output pin regardless of any other state.  This is
4007  * intended for use with microphone bias supplies used in microphone
4008  * jack detection.
4009  *
4010  * Requires external locking.
4011  *
4012  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4013  * do any widget power switching.
4014  */
4015 int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4016                                          const char *pin)
4017 {
4018         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4019
4020         if (!w) {
4021                 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4022                 return -EINVAL;
4023         }
4024
4025         dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
4026         if (!w->connected) {
4027                 /*
4028                  * w->force does not affect the number of input or output paths,
4029                  * so we only have to recheck if w->connected is changed
4030                  */
4031                 dapm_widget_invalidate_input_paths(w);
4032                 dapm_widget_invalidate_output_paths(w);
4033                 w->connected = 1;
4034         }
4035         w->force = 1;
4036         dapm_mark_dirty(w, "force enable");
4037
4038         return 0;
4039 }
4040 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
4041
4042 /**
4043  * snd_soc_dapm_force_enable_pin - force a pin to be enabled
4044  * @dapm: DAPM context
4045  * @pin: pin name
4046  *
4047  * Enables input/output pin regardless of any other state.  This is
4048  * intended for use with microphone bias supplies used in microphone
4049  * jack detection.
4050  *
4051  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4052  * do any widget power switching.
4053  */
4054 int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
4055                                   const char *pin)
4056 {
4057         int ret;
4058
4059         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4060
4061         ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
4062
4063         mutex_unlock(&dapm->card->dapm_mutex);
4064
4065         return ret;
4066 }
4067 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
4068
4069 /**
4070  * snd_soc_dapm_disable_pin_unlocked - disable pin.
4071  * @dapm: DAPM context
4072  * @pin: pin name
4073  *
4074  * Disables input/output pin and its parents or children widgets.
4075  *
4076  * Requires external locking.
4077  *
4078  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4079  * do any widget power switching.
4080  */
4081 int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4082                                     const char *pin)
4083 {
4084         return snd_soc_dapm_set_pin(dapm, pin, 0);
4085 }
4086 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
4087
4088 /**
4089  * snd_soc_dapm_disable_pin - disable pin.
4090  * @dapm: DAPM context
4091  * @pin: pin name
4092  *
4093  * Disables input/output pin and its parents or children widgets.
4094  *
4095  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4096  * do any widget power switching.
4097  */
4098 int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
4099                              const char *pin)
4100 {
4101         int ret;
4102
4103         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4104
4105         ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4106
4107         mutex_unlock(&dapm->card->dapm_mutex);
4108
4109         return ret;
4110 }
4111 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
4112
4113 /**
4114  * snd_soc_dapm_nc_pin_unlocked - permanently disable pin.
4115  * @dapm: DAPM context
4116  * @pin: pin name
4117  *
4118  * Marks the specified pin as being not connected, disabling it along
4119  * any parent or child widgets.  At present this is identical to
4120  * snd_soc_dapm_disable_pin() but in future it will be extended to do
4121  * additional things such as disabling controls which only affect
4122  * paths through the pin.
4123  *
4124  * Requires external locking.
4125  *
4126  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4127  * do any widget power switching.
4128  */
4129 int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
4130                                const char *pin)
4131 {
4132         return snd_soc_dapm_set_pin(dapm, pin, 0);
4133 }
4134 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
4135
4136 /**
4137  * snd_soc_dapm_nc_pin - permanently disable pin.
4138  * @dapm: DAPM context
4139  * @pin: pin name
4140  *
4141  * Marks the specified pin as being not connected, disabling it along
4142  * any parent or child widgets.  At present this is identical to
4143  * snd_soc_dapm_disable_pin() but in future it will be extended to do
4144  * additional things such as disabling controls which only affect
4145  * paths through the pin.
4146  *
4147  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4148  * do any widget power switching.
4149  */
4150 int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
4151 {
4152         int ret;
4153
4154         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4155
4156         ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4157
4158         mutex_unlock(&dapm->card->dapm_mutex);
4159
4160         return ret;
4161 }
4162 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
4163
4164 /**
4165  * snd_soc_dapm_get_pin_status - get audio pin status
4166  * @dapm: DAPM context
4167  * @pin: audio signal pin endpoint (or start point)
4168  *
4169  * Get audio pin status - connected or disconnected.
4170  *
4171  * Returns 1 for connected otherwise 0.
4172  */
4173 int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
4174                                 const char *pin)
4175 {
4176         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4177
4178         if (w)
4179                 return w->connected;
4180
4181         return 0;
4182 }
4183 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
4184
4185 /**
4186  * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
4187  * @dapm: DAPM context
4188  * @pin: audio signal pin endpoint (or start point)
4189  *
4190  * Mark the given endpoint or pin as ignoring suspend.  When the
4191  * system is disabled a path between two endpoints flagged as ignoring
4192  * suspend will not be disabled.  The path must already be enabled via
4193  * normal means at suspend time, it will not be turned on if it was not
4194  * already enabled.
4195  */
4196 int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
4197                                 const char *pin)
4198 {
4199         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
4200
4201         if (!w) {
4202                 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4203                 return -EINVAL;
4204         }
4205
4206         w->ignore_suspend = 1;
4207
4208         return 0;
4209 }
4210 EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
4211
4212 /**
4213  * snd_soc_dapm_free - free dapm resources
4214  * @dapm: DAPM context
4215  *
4216  * Free all dapm widgets and resources.
4217  */
4218 void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
4219 {
4220         dapm_debugfs_cleanup(dapm);
4221         dapm_free_widgets(dapm);
4222         list_del(&dapm->list);
4223 }
4224 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
4225
4226 static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
4227 {
4228         struct snd_soc_card *card = dapm->card;
4229         struct snd_soc_dapm_widget *w;
4230         LIST_HEAD(down_list);
4231         int powerdown = 0;
4232
4233         mutex_lock(&card->dapm_mutex);
4234
4235         list_for_each_entry(w, &dapm->card->widgets, list) {
4236                 if (w->dapm != dapm)
4237                         continue;
4238                 if (w->power) {
4239                         dapm_seq_insert(w, &down_list, false);
4240                         w->power = 0;
4241                         powerdown = 1;
4242                 }
4243         }
4244
4245         /* If there were no widgets to power down we're already in
4246          * standby.
4247          */
4248         if (powerdown) {
4249                 if (dapm->bias_level == SND_SOC_BIAS_ON)
4250                         snd_soc_dapm_set_bias_level(dapm,
4251                                                     SND_SOC_BIAS_PREPARE);
4252                 dapm_seq_run(card, &down_list, 0, false);
4253                 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
4254                         snd_soc_dapm_set_bias_level(dapm,
4255                                                     SND_SOC_BIAS_STANDBY);
4256         }
4257
4258         mutex_unlock(&card->dapm_mutex);
4259 }
4260
4261 /*
4262  * snd_soc_dapm_shutdown - callback for system shutdown
4263  */
4264 void snd_soc_dapm_shutdown(struct snd_soc_card *card)
4265 {
4266         struct snd_soc_dapm_context *dapm;
4267
4268         list_for_each_entry(dapm, &card->dapm_list, list) {
4269                 if (dapm != &card->dapm) {
4270                         soc_dapm_shutdown_dapm(dapm);
4271                         if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
4272                                 snd_soc_dapm_set_bias_level(dapm,
4273                                                             SND_SOC_BIAS_OFF);
4274                 }
4275         }
4276
4277         soc_dapm_shutdown_dapm(&card->dapm);
4278         if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
4279                 snd_soc_dapm_set_bias_level(&card->dapm,
4280                                             SND_SOC_BIAS_OFF);
4281 }
4282
4283 /* Module information */
4284 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
4285 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
4286 MODULE_LICENSE("GPL");