projects / GitHub / moto-9609 / android_kernel_motorola_exynos9610.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'pm-devfreq'
[GitHub/moto-9609/android_kernel_motorola_exynos9610.git] / sound / soc / soc-dapm.c
CommitLineData
2b97eabc
RP		 1/*
2 * soc-dapm.c -- ALSA SoC Dynamic Audio Power Management
3 *
4 * Copyright 2005 Wolfson Microelectronics PLC.
d331124d 5 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
2b97eabc
RP		 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 *
2b97eabc
RP		 12 * Features:
13 * o Changes power status of internal codec blocks depending on the
14 * dynamic configuration of codec internal audio paths and active
74b8f955 15 * DACs/ADCs.
2b97eabc 16 * o Platform power domain - can support external components i.e. amps and
612a3fec 17 * mic/headphone insertion events.
2b97eabc
RP		 18 * o Automatic Mic Bias support
19 * o Jack insertion power event initiation - e.g. hp insertion will enable
20 * sinks, dacs, etc
612a3fec 21 * o Delayed power down of audio subsystem to reduce pops between a quick
2b97eabc
RP		 22 * device reopen.
23 *
2b97eabc
RP		 24 */
25
26#include <linux/module.h>
27#include <linux/moduleparam.h>
28#include <linux/init.h>
9d0624a7 29#include <linux/async.h>
2b97eabc
RP		 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>
20496ff3 35#include <linux/debugfs.h>
f1aac484 36#include <linux/pm_runtime.h>
62ea874a 37#include <linux/regulator/consumer.h>
d7e7eb91 38#include <linux/clk.h>
5a0e3ad6 39#include <linux/slab.h>
2b97eabc
RP		 40#include <sound/core.h>
41#include <sound/pcm.h>
42#include <sound/pcm_params.h>
ce6120cc 43#include <sound/soc.h>
2b97eabc
RP		 44#include <sound/initval.h>
45
84e90930
MB		 46#include <trace/events/asoc.h>
47
de02d078
MB		 48#define DAPM_UPDATE_STAT(widget, val) widget->dapm->card->dapm_stats.val++;
49
a3423b02
LPC		 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
57295073
LPC		 57static 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));
5353f65b 62
cc76e7de 63struct snd_soc_dapm_widget *
57295073
LPC		 64snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
65 const struct snd_soc_dapm_widget *widget);
66
02aa78ab
LG		 67struct snd_soc_dapm_widget *
68snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
57295073
LPC		 69 const struct snd_soc_dapm_widget *widget);
70
2b97eabc
RP		 71/* dapm power sequences - make this per codec in the future */
72static int dapm_up_seq[] = {
38357ab2 73 [snd_soc_dapm_pre] = 0,
62ea874a 74 [snd_soc_dapm_regulator_supply] = 1,
d7e7eb91 75 [snd_soc_dapm_clock_supply] = 1,
1dd275b6
MB		 76 [snd_soc_dapm_supply] = 2,
77 [snd_soc_dapm_micbias] = 3,
c74184ed 78 [snd_soc_dapm_dai_link] = 2,
1dd275b6
MB		 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,
d714f97c 85 [snd_soc_dapm_demux] = 6,
1dd275b6
MB		 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,
2b97eabc 98};
ca9c1aae 99
2b97eabc 100static int dapm_down_seq[] = {
38357ab2 101 [snd_soc_dapm_pre] = 0,
57295073
LPC		 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,
38357ab2 108 [snd_soc_dapm_pga] = 4,
efc77e36 109 [snd_soc_dapm_switch] = 5,
38357ab2 110 [snd_soc_dapm_mixer_named_ctl] = 5,
e3d4dabd
MB		 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,
d714f97c 116 [snd_soc_dapm_demux] = 9,
010ff262
MB		 117 [snd_soc_dapm_aif_in] = 10,
118 [snd_soc_dapm_aif_out] = 10,
4616274d
MB		 119 [snd_soc_dapm_dai_in] = 10,
120 [snd_soc_dapm_dai_out] = 10,
c74184ed 121 [snd_soc_dapm_dai_link] = 11,
c74184ed 122 [snd_soc_dapm_supply] = 12,
1dd275b6
MB		 123 [snd_soc_dapm_clock_supply] = 13,
124 [snd_soc_dapm_regulator_supply] = 13,
125 [snd_soc_dapm_post] = 14,
2b97eabc
RP		 126};
127
f9fa2b18
MB		 128static 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
12ef193d 134static void pop_wait(u32 pop_time)
15e4c72f
MB		 135{
136 if (pop_time)
137 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
138}
139
fd8d3bc0 140static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
15e4c72f
MB		 141{
142 va_list args;
fd8d3bc0 143 char *buf;
15e4c72f 144
fd8d3bc0
JN		 145 if (!pop_time)
146 return;
15e4c72f 147
fd8d3bc0
JN		 148 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
149 if (buf == NULL)
150 return;
15e4c72f 151
fd8d3bc0
JN		 152 va_start(args, fmt);
153 vsnprintf(buf, PAGE_SIZE, fmt, args);
9d01df06 154 dev_info(dev, "%s", buf);
15e4c72f 155 va_end(args);
fd8d3bc0
JN		 156
157 kfree(buf);
15e4c72f
MB		 158}
159
db432b41
MB		 160static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
161{
162 return !list_empty(&w->dirty);
163}
164
492c0a18 165static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
db432b41 166{
f9fa2b18
MB		 167 dapm_assert_locked(w->dapm);
168
75c1f891
MB		 169 if (!dapm_dirty_widget(w)) {
170 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
171 w->name, reason);
db432b41 172 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
75c1f891 173 }
db432b41
MB		 174}
175
92a99ea4 176/*
a3423b02
LPC		 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.
92a99ea4 182 */
a3423b02
LPC		 183static __always_inline void dapm_widget_invalidate_paths(
184 struct snd_soc_dapm_widget *w, enum snd_soc_dapm_direction dir)
92a99ea4 185{
a3423b02
LPC		 186 enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
187 struct snd_soc_dapm_widget *node;
92a99ea4
LPC		 188 struct snd_soc_dapm_path *p;
189 LIST_HEAD(list);
190
191 dapm_assert_locked(w->dapm);
192
a3423b02 193 if (w->endpoints[dir] == -1)
92a99ea4
LPC		 194 return;
195
92a99ea4 196 list_add_tail(&w->work_list, &list);
a3423b02 197 w->endpoints[dir] = -1;
92a99ea4
LPC		 198
199 list_for_each_entry(w, &list, work_list) {
a3423b02 200 snd_soc_dapm_widget_for_each_path(w, dir, p) {
92a99ea4
LPC		 201 if (p->is_supply || p->weak || !p->connect)
202 continue;
a3423b02
LPC		 203 node = p->node[rdir];
204 if (node->endpoints[dir] != -1) {
205 node->endpoints[dir] = -1;
206 list_add_tail(&node->work_list, &list);
92a99ea4
LPC		 207 }
208 }
209 }
210}
211
a3423b02
LPC		 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 */
224static 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
92a99ea4
LPC		 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 */
241static void dapm_widget_invalidate_output_paths(struct snd_soc_dapm_widget *w)
242{
a3423b02 243 dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_OUT);
92a99ea4
LPC		 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 */
257static 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 */
a3423b02 272 if (p->source->endpoints[SND_SOC_DAPM_DIR_IN] != 0)
92a99ea4 273 dapm_widget_invalidate_input_paths(p->sink);
a3423b02 274 if (p->sink->endpoints[SND_SOC_DAPM_DIR_OUT] != 0)
92a99ea4
LPC		 275 dapm_widget_invalidate_output_paths(p->source);
276}
277
8be4da29 278void dapm_mark_endpoints_dirty(struct snd_soc_card *card)
e2d32ff6 279{
e2d32ff6
MB		 280 struct snd_soc_dapm_widget *w;
281
282 mutex_lock(&card->dapm_mutex);
283
284 list_for_each_entry(w, &card->widgets, list) {
a3423b02 285 if (w->is_ep) {
8be4da29 286 dapm_mark_dirty(w, "Rechecking endpoints");
a3423b02 287 if (w->is_ep & SND_SOC_DAPM_EP_SINK)
92a99ea4 288 dapm_widget_invalidate_output_paths(w);
a3423b02 289 if (w->is_ep & SND_SOC_DAPM_EP_SOURCE)
92a99ea4
LPC		 290 dapm_widget_invalidate_input_paths(w);
291 }
e2d32ff6
MB		 292 }
293
294 mutex_unlock(&card->dapm_mutex);
295}
8be4da29 296EXPORT_SYMBOL_GPL(dapm_mark_endpoints_dirty);
e2d32ff6 297
2b97eabc 298/* create a new dapm widget */
88cb4290 299static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
2b97eabc
RP		 300 const struct snd_soc_dapm_widget *_widget)
301{
88cb4290 302 return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
2b97eabc
RP		 303}
304
e84357f7 305struct dapm_kcontrol_data {
cf7c1de2 306 unsigned int value;
57295073 307 struct snd_soc_dapm_widget *widget;
5106b92f 308 struct list_head paths;
2c75bdf3 309 struct snd_soc_dapm_widget_list *wlist;
e84357f7
LPC		 310};
311
312static int dapm_kcontrol_data_alloc(struct snd_soc_dapm_widget *widget,
313 struct snd_kcontrol *kcontrol)
314{
315 struct dapm_kcontrol_data *data;
57295073 316 struct soc_mixer_control *mc;
561ed680 317 struct soc_enum *e;
773da9b3
CK		 318 const char *name;
319 int ret;
e84357f7 320
2c75bdf3 321 data = kzalloc(sizeof(*data), GFP_KERNEL);
40b7bea1 322 if (!data)
e84357f7 323 return -ENOMEM;
e84357f7 324
5106b92f 325 INIT_LIST_HEAD(&data->paths);
e84357f7 326
57295073
LPC		 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
773da9b3
CK		 336 name = kasprintf(GFP_KERNEL, "%s %s", kcontrol->id.name,
337 "Autodisable");
338 if (!name) {
339 ret = -ENOMEM;
340 goto err_data;
341 }
342
57295073
LPC		 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;
773da9b3 353 template.name = name;
57295073 354
2daabd78
LPC		 355 data->value = template.on_val;
356
02aa78ab
LG		 357 data->widget =
358 snd_soc_dapm_new_control_unlocked(widget->dapm,
57295073 359 &template);
e18077b6 360 kfree(name);
57295073 361 if (!data->widget) {
773da9b3 362 ret = -ENOMEM;
e18077b6 363 goto err_data;
57295073
LPC		 364 }
365 }
366 break;
d714f97c 367 case snd_soc_dapm_demux:
561ed680
CK		 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", kcontrol->id.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
ffacb48e
CK		 392 data->widget = snd_soc_dapm_new_control_unlocked(
393 widget->dapm, &template);
e18077b6 394 kfree(name);
561ed680
CK		 395 if (!data->widget) {
396 ret = -ENOMEM;
e18077b6 397 goto err_data;
561ed680
CK		 398 }
399
400 snd_soc_dapm_add_path(widget->dapm, data->widget,
401 widget, NULL, NULL);
402 }
403 break;
57295073
LPC		 404 default:
405 break;
406 }
407
e84357f7
LPC		 408 kcontrol->private_data = data;
409
410 return 0;
773da9b3 411
773da9b3
CK		 412err_data:
413 kfree(data);
414 return ret;
e84357f7
LPC		 415}
416
417static void dapm_kcontrol_free(struct snd_kcontrol *kctl)
418{
419 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kctl);
2c75bdf3 420 kfree(data->wlist);
e84357f7
LPC		 421 kfree(data);
422}
423
424static 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
2c75bdf3 429 return data->wlist;
e84357f7
LPC		 430}
431
432static 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);
2c75bdf3
LPC		 436 struct snd_soc_dapm_widget_list *new_wlist;
437 unsigned int n;
e84357f7 438
2c75bdf3
LPC		 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)
e84357f7
LPC		 447 return -ENOMEM;
448
2c75bdf3
LPC		 449 new_wlist->widgets[n - 1] = widget;
450 new_wlist->num_widgets = n;
e84357f7 451
2c75bdf3 452 data->wlist = new_wlist;
e84357f7
LPC		 453
454 return 0;
455}
456
5106b92f
LPC		 457static 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);
57295073
LPC		 463}
464
465static 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;
5106b92f
LPC		 473}
474
475static 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
5dc0158a 487unsigned int dapm_kcontrol_get_value(const struct snd_kcontrol *kcontrol)
cf7c1de2
LPC		 488{
489 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
490
491 return data->value;
492}
5dc0158a 493EXPORT_SYMBOL_GPL(dapm_kcontrol_get_value);
cf7c1de2
LPC		 494
495static 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
57295073
LPC		 503 if (data->widget)
504 data->widget->on_val = value;
505
cf7c1de2
LPC		 506 data->value = value;
507
508 return true;
509}
510
93e39a11
M		 511/**
512 * snd_soc_dapm_kcontrol_widget() - Returns the widget associated to a
513 * kcontrol
514 * @kcontrol: The kcontrol
515 */
516struct 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}
521EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_widget);
522
ce0fc93a
LPC		 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 */
531struct 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}
536EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_dapm);
537
6c120e19
LG		 538static void dapm_reset(struct snd_soc_card *card)
539{
540 struct snd_soc_dapm_widget *w;
541
f9fa2b18
MB		 542 lockdep_assert_held(&card->dapm_mutex);
543
6c120e19
LG		 544 memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
545
546 list_for_each_entry(w, &card->widgets, list) {
39eb5fd1 547 w->new_power = w->power;
6c120e19 548 w->power_checked = false;
6c120e19
LG		 549 }
550}
551
94f99c87
LPC		 552static 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
ce0fc93a 559static int soc_dapm_read(struct snd_soc_dapm_context *dapm, int reg,
f7d3c170 560 unsigned int *value)
0445bdf4 561{
ce0fc93a 562 if (!dapm->component)
e2c330b9 563 return -EIO;
ce0fc93a 564 return snd_soc_component_read(dapm->component, reg, value);
49575fb5
LG		 565}
566
ce0fc93a 567static int soc_dapm_update_bits(struct snd_soc_dapm_context *dapm,
e2c330b9 568 int reg, unsigned int mask, unsigned int value)
49575fb5 569{
ce0fc93a 570 if (!dapm->component)
e2c330b9 571 return -EIO;
fcf6c5ea
MB		 572 return snd_soc_component_update_bits(dapm->component, reg,
573 mask, value);
49575fb5
LG		 574}
575
ce0fc93a
LPC		 576static 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
eb270e98
MB		 584static void soc_dapm_async_complete(struct snd_soc_dapm_context *dapm)
585{
e2c330b9
LPC		 586 if (dapm->component)
587 snd_soc_component_async_complete(dapm->component);
0445bdf4
LG		 588}
589
45a110a1
CK		 590static struct snd_soc_dapm_widget *
591dapm_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
613static 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
fa880775
LPC		 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 */
636int 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
f4bf8d77
LPC		 644 if (ret == 0)
645 dapm->bias_level = level;
646
fa880775
LPC		 647 return ret;
648}
649EXPORT_SYMBOL_GPL(snd_soc_dapm_force_bias_level);
650
452c5eaa
MB		 651/**
652 * snd_soc_dapm_set_bias_level - set the bias level for the system
ed5a4c47 653 * @dapm: DAPM context
452c5eaa
MB		 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 */
ed5a4c47 660static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
ce6120cc 661 enum snd_soc_bias_level level)
452c5eaa 662{
ed5a4c47 663 struct snd_soc_card *card = dapm->card;
452c5eaa
MB		 664 int ret = 0;
665
84e90930
MB		 666 trace_snd_soc_bias_level_start(card, level);
667
f0fba2ad 668 if (card && card->set_bias_level)
d4c6005f 669 ret = card->set_bias_level(card, dapm, level);
171ec6b0
MB		 670 if (ret != 0)
671 goto out;
672
fa880775
LPC		 673 if (!card || dapm != &card->dapm)
674 ret = snd_soc_dapm_force_bias_level(dapm, level);
4123128e 675
171ec6b0
MB		 676 if (ret != 0)
677 goto out;
678
679 if (card && card->set_bias_level_post)
d4c6005f 680 ret = card->set_bias_level_post(card, dapm, level);
171ec6b0 681out:
84e90930
MB		 682 trace_snd_soc_bias_level_done(card, level);
683
452c5eaa
MB		 684 return ret;
685}
686
74b8f955 687/* connect mux widget to its interconnecting audio paths */
ce6120cc 688static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
d714f97c
LPC		 689 struct snd_soc_dapm_path *path, const char *control_name,
690 struct snd_soc_dapm_widget *w)
2b97eabc 691{
d714f97c 692 const struct snd_kcontrol_new *kcontrol = &w->kcontrol_news[0];
2b97eabc 693 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
234c0b8f 694 unsigned int val, item;
2b97eabc 695 int i;
24ff33ac 696
234c0b8f 697 if (e->reg != SND_SOC_NOPM) {
ce0fc93a 698 soc_dapm_read(dapm, e->reg, &val);
234c0b8f
LPC		 699 val = (val >> e->shift_l) & e->mask;
700 item = snd_soc_enum_val_to_item(e, val);
701 } else {
24ff33ac
DP		 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 */
234c0b8f 708 item = 0;
24ff33ac 709 }
2e72f8e3 710
9a8d38db 711 for (i = 0; i < e->items; i++) {
2b97eabc 712 if (!(strcmp(control_name, e->texts[i]))) {
98ad73c9 713 path->name = e->texts[i];
234c0b8f
LPC		 714 if (i == item)
715 path->connect = 1;
716 else
717 path->connect = 0;
2b97eabc
RP		 718 return 0;
719 }
720 }
721
722 return -ENODEV;
723}
724
234c0b8f 725/* set up initial codec paths */
5fe5b767 726static void dapm_set_mixer_path_status(struct snd_soc_dapm_path *p, int i)
234c0b8f
LPC		 727{
728 struct soc_mixer_control *mc = (struct soc_mixer_control *)
5fe5b767 729 p->sink->kcontrol_news[i].private_value;
234c0b8f
LPC		 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) {
5fe5b767 738 soc_dapm_read(p->sink->dapm, reg, &val);
234c0b8f
LPC		 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
74b8f955 748/* connect mixer widget to its interconnecting audio paths */
ce6120cc 749static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
2b97eabc
RP		 750 struct snd_soc_dapm_path *path, const char *control_name)
751{
752 int i;
753
754 /* search for mixer kcontrol */
5fe5b767
LPC		 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);
2b97eabc
RP		 759 return 0;
760 }
761 }
762 return -ENODEV;
763}
764
af46800b 765static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
1007da06 766 struct snd_soc_dapm_widget *kcontrolw,
af46800b
SW		 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) {
1007da06
SW		 776 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
777 continue;
af46800b
SW		 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
85762e71
SW		 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 */
19a2557b 794static int dapm_create_or_share_kcontrol(struct snd_soc_dapm_widget *w,
946d92a1 795 int kci)
2b97eabc 796{
4b80b8c2 797 struct snd_soc_dapm_context *dapm = w->dapm;
12ea2c78 798 struct snd_card *card = dapm->card->snd_card;
efb7ac3f 799 const char *prefix;
85762e71
SW		 800 size_t prefix_len;
801 int shared;
802 struct snd_kcontrol *kcontrol;
85762e71 803 bool wname_in_long_name, kcname_in_long_name;
e5092c96 804 char *long_name = NULL;
85762e71 805 const char *name;
e5092c96 806 int ret = 0;
efb7ac3f 807
94f99c87 808 prefix = soc_dapm_prefix(dapm);
3e5ff4df
MB		 809 if (prefix)
810 prefix_len = strlen(prefix) + 1;
811 else
812 prefix_len = 0;
813
85762e71
SW		 814 shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],
815 &kcontrol);
2b97eabc 816
85762e71
SW		 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:
19a2557b 825 case snd_soc_dapm_pga:
85762e71
SW		 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;
d714f97c 833 case snd_soc_dapm_demux:
85762e71 834 case snd_soc_dapm_mux:
85762e71
SW		 835 wname_in_long_name = true;
836 kcname_in_long_name = false;
837 break;
838 default:
85762e71 839 return -EINVAL;
82cd8764 840 }
85762e71
SW		 841 }
842
843 if (wname_in_long_name && kcname_in_long_name) {
85762e71
SW		 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.
ca9c1aae 849 */
2b581074 850 long_name = kasprintf(GFP_KERNEL, "%s %s",
85762e71
SW		 851 w->name + prefix_len,
852 w->kcontrol_news[kci].name);
e84357f7 853 if (long_name == NULL)
2b581074 854 return -ENOMEM;
85762e71
SW		 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 }
ca9c1aae 864
e84357f7 865 kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,
85762e71 866 prefix);
e5092c96
DM		 867 if (!kcontrol) {
868 ret = -ENOMEM;
869 goto exit_free;
870 }
871
9356e9d5 872 kcontrol->private_free = dapm_kcontrol_free;
e84357f7
LPC		 873
874 ret = dapm_kcontrol_data_alloc(w, kcontrol);
875 if (ret) {
876 snd_ctl_free_one(kcontrol);
e5092c96 877 goto exit_free;
e84357f7
LPC		 878 }
879
85762e71
SW		 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);
e5092c96 885 goto exit_free;
85762e71 886 }
85762e71 887 }
2b97eabc 888
2c75bdf3 889 ret = dapm_kcontrol_add_widget(kcontrol, w);
e5092c96
DM		 890 if (ret == 0)
891 w->kcontrols[kci] = kcontrol;
2c75bdf3 892
e5092c96
DM		 893exit_free:
894 kfree(long_name);
ca9c1aae 895
e5092c96 896 return ret;
85762e71 897}
219b93f5 898
85762e71
SW		 899/* create new dapm mixer control */
900static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
901{
902 int i, ret;
903 struct snd_soc_dapm_path *path;
561ed680 904 struct dapm_kcontrol_data *data;
85762e71
SW		 905
906 /* add kcontrol */
907 for (i = 0; i < w->num_kcontrols; i++) {
908 /* match name */
e63bfd45 909 snd_soc_dapm_widget_for_each_source_path(w, path) {
85762e71
SW		 910 /* mixer/mux paths name must match control name */
911 if (path->name != (char *)w->kcontrol_news[i].name)
912 continue;
913
561ed680 914 if (!w->kcontrols[i]) {
19a2557b 915 ret = dapm_create_or_share_kcontrol(w, i);
561ed680
CK		 916 if (ret < 0)
917 return ret;
2b97eabc 918 }
85762e71 919
946d92a1 920 dapm_kcontrol_add_path(w->kcontrols[i], path);
561ed680
CK		 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);
2b97eabc
RP		 928 }
929 }
85762e71
SW		 930
931 return 0;
2b97eabc
RP		 932}
933
934/* create new dapm mux control */
4b80b8c2 935static int dapm_new_mux(struct snd_soc_dapm_widget *w)
2b97eabc 936{
4b80b8c2 937 struct snd_soc_dapm_context *dapm = w->dapm;
a3423b02 938 enum snd_soc_dapm_direction dir;
85762e71 939 struct snd_soc_dapm_path *path;
d714f97c 940 const char *type;
af46800b 941 int ret;
2b97eabc 942
d714f97c
LPC		 943 switch (w->id) {
944 case snd_soc_dapm_mux:
a3423b02 945 dir = SND_SOC_DAPM_DIR_OUT;
d714f97c
LPC		 946 type = "mux";
947 break;
948 case snd_soc_dapm_demux:
a3423b02 949 dir = SND_SOC_DAPM_DIR_IN;
d714f97c
LPC		 950 type = "demux";
951 break;
952 default:
953 return -EINVAL;
954 }
955
af46800b
SW		 956 if (w->num_kcontrols != 1) {
957 dev_err(dapm->dev,
d714f97c 958 "ASoC: %s %s has incorrect number of controls\n", type,
af46800b 959 w->name);
2b97eabc
RP		 960 return -EINVAL;
961 }
962
a3423b02 963 if (list_empty(&w->edges[dir])) {
d714f97c 964 dev_err(dapm->dev, "ASoC: %s %s has no paths\n", type, w->name);
85762e71 965 return -EINVAL;
af46800b 966 }
ce6120cc 967
19a2557b 968 ret = dapm_create_or_share_kcontrol(w, 0);
85762e71
SW		 969 if (ret < 0)
970 return ret;
fad59888 971
a3423b02
LPC		 972 snd_soc_dapm_widget_for_each_path(w, dir, path) {
973 if (path->name)
974 dapm_kcontrol_add_path(w->kcontrols[0], path);
98407efc 975 }
2b97eabc 976
af46800b 977 return 0;
2b97eabc
RP		 978}
979
980/* create new dapm volume control */
4b80b8c2 981static int dapm_new_pga(struct snd_soc_dapm_widget *w)
2b97eabc 982{
19a2557b
JK		 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 }
2b97eabc 990
a6c65736 991 return 0;
2b97eabc
RP		 992}
993
c6615082
NO		 994/* create new dapm dai link control */
995static 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
9949788b
MB		 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 */
1028static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
1029{
12ea2c78 1030 int level = snd_power_get_state(widget->dapm->card->snd_card);
9949788b 1031
f0fba2ad 1032 switch (level) {
9949788b
MB		 1033 case SNDRV_CTL_POWER_D3hot:
1034 case SNDRV_CTL_POWER_D3cold:
1547aba9 1035 if (widget->ignore_suspend)
30a6a1a4 1036 dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
f7d41ae8 1037 widget->name);
1547aba9 1038 return widget->ignore_suspend;
9949788b
MB		 1039 default:
1040 return 1;
1041 }
1042}
1043
1ce43acf
LPC		 1044static int dapm_widget_list_create(struct snd_soc_dapm_widget_list **list,
1045 struct list_head *widgets)
ec2e3031 1046{
1ce43acf
LPC		 1047 struct snd_soc_dapm_widget *w;
1048 struct list_head *it;
1049 unsigned int size = 0;
1050 unsigned int i = 0;
ec2e3031 1051
1ce43acf
LPC		 1052 list_for_each(it, widgets)
1053 size++;
ec2e3031 1054
1ce43acf
LPC		 1055 *list = kzalloc(sizeof(**list) + size * sizeof(*w), GFP_KERNEL);
1056 if (*list == NULL)
ec2e3031 1057 return -ENOMEM;
ec2e3031 1058
1ce43acf
LPC		 1059 list_for_each_entry(w, widgets, work_list)
1060 (*list)->widgets[i++] = w;
ec2e3031 1061
1ce43acf
LPC		 1062 (*list)->num_widgets = i;
1063
1064 return 0;
ec2e3031
LG		 1065}
1066
2b97eabc 1067/*
a3423b02
LPC		 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.
2b97eabc 1073 */
a3423b02
LPC		 1074static __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 *))
2b97eabc 1077{
a3423b02 1078 enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
2b97eabc
RP		 1079 struct snd_soc_dapm_path *path;
1080 int con = 0;
1081
a3423b02
LPC		 1082 if (widget->endpoints[dir] >= 0)
1083 return widget->endpoints[dir];
024dc078 1084
de02d078
MB		 1085 DAPM_UPDATE_STAT(widget, path_checks);
1086
1ce43acf
LPC		 1087 /* do we need to add this widget to the list ? */
1088 if (list)
1089 list_add_tail(&widget->work_list, list);
1090
a3423b02
LPC		 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];
2b97eabc
RP		 1094 }
1095
a3423b02 1096 snd_soc_dapm_widget_for_each_path(widget, rdir, path) {
e56235e0
MB		 1097 DAPM_UPDATE_STAT(widget, neighbour_checks);
1098
c1862c8b 1099 if (path->weak || path->is_supply)
bf3a9e13
MB		 1100 continue;
1101
8af294b4
MB		 1102 if (path->walking)
1103 return 1;
1104
a3423b02 1105 trace_snd_soc_dapm_path(widget, dir, path);
ec2e3031 1106
7ddd4cd5 1107 if (path->connect) {
8af294b4 1108 path->walking = 1;
a3423b02 1109 con += fn(path->node[dir], list);
8af294b4 1110 path->walking = 0;
2b97eabc
RP		 1111 }
1112 }
1113
a3423b02 1114 widget->endpoints[dir] = con;
024dc078 1115
2b97eabc
RP		 1116 return con;
1117}
1118
a3423b02
LPC		 1119/*
1120 * Recursively check for a completed path to an active or physically connected
1121 * output widget. Returns number of complete paths.
1122 */
1123static 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
2b97eabc
RP		 1130/*
1131 * Recursively check for a completed path to an active or physically connected
1132 * input widget. Returns number of complete paths.
1133 */
ec2e3031 1134static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
1ce43acf 1135 struct list_head *list)
2b97eabc 1136{
a3423b02
LPC		 1137 return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_IN,
1138 is_connected_input_ep);
2b97eabc
RP		 1139}
1140
ec2e3031
LG		 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 */
1153int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
1154 struct snd_soc_dapm_widget_list **list)
1155{
313665b9 1156 struct snd_soc_card *card = dai->component->card;
92a99ea4 1157 struct snd_soc_dapm_widget *w;
1ce43acf 1158 LIST_HEAD(widgets);
ec2e3031 1159 int paths;
1ce43acf 1160 int ret;
ec2e3031
LG		 1161
1162 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
92a99ea4
LPC		 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) {
a3423b02
LPC		 1169 w->endpoints[SND_SOC_DAPM_DIR_IN] = -1;
1170 w->endpoints[SND_SOC_DAPM_DIR_OUT] = -1;
92a99ea4 1171 }
ec2e3031 1172
130897ac 1173 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
1ce43acf 1174 paths = is_connected_output_ep(dai->playback_widget, &widgets);
130897ac 1175 else
1ce43acf
LPC		 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)
30abbe77 1183 paths = ret;
ec2e3031
LG		 1184
1185 trace_snd_soc_dapm_connected(paths, stream);
ec2e3031
LG		 1186 mutex_unlock(&card->dapm_mutex);
1187
1188 return paths;
1189}
1190
62ea874a
MB		 1191/*
1192 * Handler for regulator supply widget.
1193 */
1194int dapm_regulator_event(struct snd_soc_dapm_widget *w,
1195 struct snd_kcontrol *kcontrol, int event)
1196{
c05b84d1
MB		 1197 int ret;
1198
eb270e98
MB		 1199 soc_dapm_async_complete(w->dapm);
1200
c05b84d1 1201 if (SND_SOC_DAPM_EVENT_ON(event)) {
de9ba98b 1202 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
8784c77a 1203 ret = regulator_allow_bypass(w->regulator, false);
c05b84d1
MB		 1204 if (ret != 0)
1205 dev_warn(w->dapm->dev,
30686c35 1206 "ASoC: Failed to unbypass %s: %d\n",
c05b84d1
MB		 1207 w->name, ret);
1208 }
1209
a3cc056b 1210 return regulator_enable(w->regulator);
c05b84d1 1211 } else {
de9ba98b 1212 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
8784c77a 1213 ret = regulator_allow_bypass(w->regulator, true);
c05b84d1
MB		 1214 if (ret != 0)
1215 dev_warn(w->dapm->dev,
30686c35 1216 "ASoC: Failed to bypass %s: %d\n",
c05b84d1
MB		 1217 w->name, ret);
1218 }
1219
a3cc056b 1220 return regulator_disable_deferred(w->regulator, w->shift);
c05b84d1 1221 }
62ea874a
MB		 1222}
1223EXPORT_SYMBOL_GPL(dapm_regulator_event);
1224
d7e7eb91
OL		 1225/*
1226 * Handler for clock supply widget.
1227 */
1228int 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
eb270e98
MB		 1234 soc_dapm_async_complete(w->dapm);
1235
ec02995a 1236#ifdef CONFIG_HAVE_CLK
d7e7eb91 1237 if (SND_SOC_DAPM_EVENT_ON(event)) {
37c1b927 1238 return clk_prepare_enable(w->clk);
d7e7eb91 1239 } else {
37c1b927 1240 clk_disable_unprepare(w->clk);
d7e7eb91
OL		 1241 return 0;
1242 }
ec02995a 1243#endif
98b3cf12 1244 return 0;
d7e7eb91
OL		 1245}
1246EXPORT_SYMBOL_GPL(dapm_clock_event);
1247
d805002b
MB		 1248static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1249{
9b8a83b2
MB		 1250 if (w->power_checked)
1251 return w->new_power;
1252
d805002b 1253 if (w->force)
9b8a83b2 1254 w->new_power = 1;
d805002b 1255 else
9b8a83b2
MB		 1256 w->new_power = w->power_check(w);
1257
1258 w->power_checked = true;
1259
1260 return w->new_power;
d805002b
MB		 1261}
1262
cd0f2d47
MB		 1263/* Generic check to see if a widget should be powered.
1264 */
1265static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1266{
1267 int in, out;
1268
de02d078
MB		 1269 DAPM_UPDATE_STAT(w, power_checks);
1270
ec2e3031 1271 in = is_connected_input_ep(w, NULL);
ec2e3031 1272 out = is_connected_output_ep(w, NULL);
cd0f2d47
MB		 1273 return out != 0 && in != 0;
1274}
1275
246d0a17
MB		 1276/* Check to see if a power supply is needed */
1277static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1278{
1279 struct snd_soc_dapm_path *path;
246d0a17 1280
de02d078
MB		 1281 DAPM_UPDATE_STAT(w, power_checks);
1282
246d0a17 1283 /* Check if one of our outputs is connected */
e63bfd45 1284 snd_soc_dapm_widget_for_each_sink_path(w, path) {
a8fdac83
MB		 1285 DAPM_UPDATE_STAT(w, neighbour_checks);
1286
bf3a9e13
MB		 1287 if (path->weak)
1288 continue;
1289
215edda3
MB		 1290 if (path->connected &&
1291 !path->connected(path->source, path->sink))
1292 continue;
1293
f68d7e16
MB		 1294 if (dapm_widget_power_check(path->sink))
1295 return 1;
246d0a17
MB		 1296 }
1297
f68d7e16 1298 return 0;
246d0a17
MB		 1299}
1300
35c64bca
MB		 1301static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1302{
1303 return 1;
1304}
1305
38357ab2
MB		 1306static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
1307 struct snd_soc_dapm_widget *b,
828a842f 1308 bool power_up)
42aa3418 1309{
828a842f
MB		 1310 int *sort;
1311
1312 if (power_up)
1313 sort = dapm_up_seq;
1314 else
1315 sort = dapm_down_seq;
1316
38357ab2
MB		 1317 if (sort[a->id] != sort[b->id])
1318 return sort[a->id] - sort[b->id];
20e4859d
MB		 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 }
b22ead2a
MB		 1325 if (a->reg != b->reg)
1326 return a->reg - b->reg;
84dab567
MB		 1327 if (a->dapm != b->dapm)
1328 return (unsigned long)a->dapm - (unsigned long)b->dapm;
42aa3418 1329
38357ab2
MB		 1330 return 0;
1331}
42aa3418 1332
38357ab2
MB		 1333/* Insert a widget in order into a DAPM power sequence. */
1334static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
1335 struct list_head *list,
828a842f 1336 bool power_up)
38357ab2
MB		 1337{
1338 struct snd_soc_dapm_widget *w;
1339
1340 list_for_each_entry(w, list, power_list)
828a842f 1341 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
38357ab2
MB		 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
95dd5cd6 1349static void dapm_seq_check_event(struct snd_soc_card *card,
68f89ad8
MB		 1350 struct snd_soc_dapm_widget *w, int event)
1351{
68f89ad8
MB		 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;
80114129
MB		 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;
68f89ad8 1380 default:
a6ed0608 1381 WARN(1, "Unknown event %d\n", event);
68f89ad8
MB		 1382 return;
1383 }
1384
39eb5fd1 1385 if (w->new_power != power)
68f89ad8
MB		 1386 return;
1387
1388 if (w->event && (w->event_flags & event)) {
95dd5cd6 1389 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
68f89ad8 1390 w->name, ev_name);
eb270e98 1391 soc_dapm_async_complete(w->dapm);
84e90930 1392 trace_snd_soc_dapm_widget_event_start(w, event);
68f89ad8 1393 ret = w->event(w, NULL, event);
84e90930 1394 trace_snd_soc_dapm_widget_event_done(w, event);
68f89ad8 1395 if (ret < 0)
95dd5cd6 1396 dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
68f89ad8
MB		 1397 ev_name, w->name, ret);
1398 }
1399}
1400
b22ead2a 1401/* Apply the coalesced changes from a DAPM sequence */
95dd5cd6 1402static void dapm_seq_run_coalesced(struct snd_soc_card *card,
b22ead2a 1403 struct list_head *pending)
163cac06 1404{
ce0fc93a 1405 struct snd_soc_dapm_context *dapm;
68f89ad8 1406 struct snd_soc_dapm_widget *w;
de9ba98b 1407 int reg;
b22ead2a
MB		 1408 unsigned int value = 0;
1409 unsigned int mask = 0;
b22ead2a 1410
ce0fc93a
LPC		 1411 w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
1412 reg = w->reg;
1413 dapm = w->dapm;
b22ead2a
MB		 1414
1415 list_for_each_entry(w, pending, power_list) {
ce0fc93a 1416 WARN_ON(reg != w->reg || dapm != w->dapm);
39eb5fd1 1417 w->power = w->new_power;
b22ead2a 1418
de9ba98b
LPC		 1419 mask |= w->mask << w->shift;
1420 if (w->power)
1421 value |= w->on_val << w->shift;
b22ead2a 1422 else
de9ba98b 1423 value |= w->off_val << w->shift;
b22ead2a 1424
ce0fc93a 1425 pop_dbg(dapm->dev, card->pop_time,
b22ead2a
MB		 1426 "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1427 w->name, reg, value, mask);
81628103 1428
68f89ad8 1429 /* Check for events */
95dd5cd6
LPC		 1430 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
1431 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
81628103
MB		 1432 }
1433
1434 if (reg >= 0) {
29376bc7
MB		 1435 /* Any widget will do, they should all be updating the
1436 * same register.
1437 */
29376bc7 1438
ce0fc93a 1439 pop_dbg(dapm->dev, card->pop_time,
81628103 1440 "pop test : Applying 0x%x/0x%x to %x in %dms\n",
3a45b867
JN		 1441 value, mask, reg, card->pop_time);
1442 pop_wait(card->pop_time);
ce0fc93a 1443 soc_dapm_update_bits(dapm, reg, mask, value);
b22ead2a
MB		 1444 }
1445
81628103 1446 list_for_each_entry(w, pending, power_list) {
95dd5cd6
LPC		 1447 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
1448 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
81628103 1449 }
b22ead2a 1450}
42aa3418 1451
b22ead2a
MB		 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 */
95dd5cd6
LPC		 1460static void dapm_seq_run(struct snd_soc_card *card,
1461 struct list_head *list, int event, bool power_up)
b22ead2a
MB		 1462{
1463 struct snd_soc_dapm_widget *w, *n;
eb270e98 1464 struct snd_soc_dapm_context *d;
b22ead2a
MB		 1465 LIST_HEAD(pending);
1466 int cur_sort = -1;
20e4859d 1467 int cur_subseq = -1;
b22ead2a 1468 int cur_reg = SND_SOC_NOPM;
7be31be8 1469 struct snd_soc_dapm_context *cur_dapm = NULL;
474b62d6 1470 int ret, i;
828a842f
MB		 1471 int *sort;
1472
1473 if (power_up)
1474 sort = dapm_up_seq;
1475 else
1476 sort = dapm_down_seq;
163cac06 1477
b22ead2a
MB		 1478 list_for_each_entry_safe(w, n, list, power_list) {
1479 ret = 0;
1480
1481 /* Do we need to apply any queued changes? */
7be31be8 1482 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
20e4859d 1483 w->dapm != cur_dapm || w->subseq != cur_subseq) {
b22ead2a 1484 if (!list_empty(&pending))
95dd5cd6 1485 dapm_seq_run_coalesced(card, &pending);
b22ead2a 1486
474b62d6
MB		 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,
f85a9e0d
MB		 1491 i,
1492 cur_subseq);
474b62d6
MB		 1493 }
1494
eb270e98
MB		 1495 if (cur_dapm && w->dapm != cur_dapm)
1496 soc_dapm_async_complete(cur_dapm);
1497
b22ead2a
MB		 1498 INIT_LIST_HEAD(&pending);
1499 cur_sort = -1;
b0b3e6f8 1500 cur_subseq = INT_MIN;
b22ead2a 1501 cur_reg = SND_SOC_NOPM;
7be31be8 1502 cur_dapm = NULL;
b22ead2a
MB		 1503 }
1504
163cac06
MB		 1505 switch (w->id) {
1506 case snd_soc_dapm_pre:
1507 if (!w->event)
b22ead2a
MB		 1508 list_for_each_entry_safe_continue(w, n, list,
1509 power_list);
163cac06 1510
b22ead2a 1511 if (event == SND_SOC_DAPM_STREAM_START)
163cac06
MB		 1512 ret = w->event(w,
1513 NULL, SND_SOC_DAPM_PRE_PMU);
b22ead2a 1514 else if (event == SND_SOC_DAPM_STREAM_STOP)
163cac06
MB		 1515 ret = w->event(w,
1516 NULL, SND_SOC_DAPM_PRE_PMD);
163cac06
MB		 1517 break;
1518
1519 case snd_soc_dapm_post:
1520 if (!w->event)
b22ead2a
MB		 1521 list_for_each_entry_safe_continue(w, n, list,
1522 power_list);
163cac06 1523
b22ead2a 1524 if (event == SND_SOC_DAPM_STREAM_START)
163cac06
MB		 1525 ret = w->event(w,
1526 NULL, SND_SOC_DAPM_POST_PMU);
b22ead2a 1527 else if (event == SND_SOC_DAPM_STREAM_STOP)
163cac06
MB		 1528 ret = w->event(w,
1529 NULL, SND_SOC_DAPM_POST_PMD);
163cac06
MB		 1530 break;
1531
b22ead2a 1532 default:
81628103
MB		 1533 /* Queue it up for application */
1534 cur_sort = sort[w->id];
20e4859d 1535 cur_subseq = w->subseq;
81628103 1536 cur_reg = w->reg;
7be31be8 1537 cur_dapm = w->dapm;
81628103
MB		 1538 list_move(&w->power_list, &pending);
1539 break;
163cac06 1540 }
b22ead2a
MB		 1541
1542 if (ret < 0)
f7d41ae8 1543 dev_err(w->dapm->dev,
30a6a1a4 1544 "ASoC: Failed to apply widget power: %d\n", ret);
6ea31b9f 1545 }
b22ead2a
MB		 1546
1547 if (!list_empty(&pending))
95dd5cd6 1548 dapm_seq_run_coalesced(card, &pending);
474b62d6
MB		 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,
f85a9e0d 1554 i, cur_subseq);
474b62d6 1555 }
eb270e98
MB		 1556
1557 list_for_each_entry(d, &card->dapm_list, list) {
1558 soc_dapm_async_complete(d);
1559 }
42aa3418
MB		 1560}
1561
95dd5cd6 1562static void dapm_widget_update(struct snd_soc_card *card)
97404f2e 1563{
95dd5cd6 1564 struct snd_soc_dapm_update *update = card->update;
ce6cfaf1
LPC		 1565 struct snd_soc_dapm_widget_list *wlist;
1566 struct snd_soc_dapm_widget *w = NULL;
1567 unsigned int wi;
97404f2e
MB		 1568 int ret;
1569
57295073 1570 if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
97404f2e
MB		 1571 return;
1572
e84357f7 1573 wlist = dapm_kcontrol_get_wlist(update->kcontrol);
97404f2e 1574
ce6cfaf1
LPC		 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)
95dd5cd6 1581 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
ce6cfaf1
LPC		 1582 w->name, ret);
1583 }
97404f2e
MB		 1584 }
1585
ce6cfaf1
LPC		 1586 if (!w)
1587 return;
1588
ce0fc93a
LPC		 1589 ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
1590 update->val);
97404f2e 1591 if (ret < 0)
95dd5cd6 1592 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
30a6a1a4 1593 w->name, ret);
97404f2e 1594
ce6cfaf1
LPC		 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)
95dd5cd6 1601 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
ce6cfaf1
LPC		 1602 w->name, ret);
1603 }
97404f2e
MB		 1604 }
1605}
1606
9d0624a7
MB		 1607/* Async callback run prior to DAPM sequences - brings to _PREPARE if
1608 * they're changing state.
1609 */
1610static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1611{
1612 struct snd_soc_dapm_context *d = data;
1613 int ret;
1614
56fba41f
MB		 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) {
f1aac484
MB		 1618 if (d->dev)
1619 pm_runtime_get_sync(d->dev);
1620
9d0624a7
MB		 1621 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1622 if (ret != 0)
1623 dev_err(d->dev,
30a6a1a4 1624 "ASoC: Failed to turn on bias: %d\n", ret);
9d0624a7
MB		 1625 }
1626
ce85a4d7
LPC		 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)) {
9d0624a7
MB		 1632 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1633 if (ret != 0)
1634 dev_err(d->dev,
30a6a1a4 1635 "ASoC: Failed to prepare bias: %d\n", ret);
9d0624a7
MB		 1636 }
1637}
1638
1639/* Async callback run prior to DAPM sequences - brings to their final
1640 * state.
1641 */
1642static 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 */
56fba41f
MB		 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)) {
9d0624a7
MB		 1651 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1652 if (ret != 0)
30a6a1a4 1653 dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
9d0624a7
MB		 1654 ret);
1655 }
97404f2e 1656
9d0624a7 1657 /* If we're in standby and can support bias off then do that */
56fba41f
MB		 1658 if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1659 d->target_bias_level == SND_SOC_BIAS_OFF) {
9d0624a7
MB		 1660 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1661 if (ret != 0)
30a6a1a4
LG		 1662 dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
1663 ret);
f1aac484
MB		 1664
1665 if (d->dev)
fb644e9c 1666 pm_runtime_put(d->dev);
9d0624a7
MB		 1667 }
1668
1669 /* If we just powered up then move to active bias */
56fba41f
MB		 1670 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1671 d->target_bias_level == SND_SOC_BIAS_ON) {
9d0624a7
MB		 1672 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1673 if (ret != 0)
30a6a1a4 1674 dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
9d0624a7
MB		 1675 ret);
1676 }
1677}
97404f2e 1678
fe4fda5d
MB		 1679static 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)
75c1f891 1691 dapm_mark_dirty(peer, "peer state change");
fe4fda5d
MB		 1692}
1693
05623c43
MB		 1694static 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{
db432b41
MB		 1698 struct snd_soc_dapm_path *path;
1699
05623c43
MB		 1700 if (w->power == power)
1701 return;
1702
1703 trace_snd_soc_dapm_widget_power(w, power);
1704
db432b41 1705 /* If we changed our power state perhaps our neigbours changed
fe4fda5d 1706 * also.
db432b41 1707 */
e63bfd45 1708 snd_soc_dapm_widget_for_each_source_path(w, path)
7ddd4cd5
LPC		 1709 dapm_widget_set_peer_power(path->source, power, path->connect);
1710
6dd98b0a
LPC		 1711 /* Supplies can't affect their outputs, only their inputs */
1712 if (!w->is_supply) {
e63bfd45 1713 snd_soc_dapm_widget_for_each_sink_path(w, path)
7ddd4cd5
LPC		 1714 dapm_widget_set_peer_power(path->sink, power,
1715 path->connect);
db432b41
MB		 1716 }
1717
05623c43
MB		 1718 if (power)
1719 dapm_seq_insert(w, up_list, true);
1720 else
1721 dapm_seq_insert(w, down_list, false);
05623c43
MB		 1722}
1723
7c81beb0
MB		 1724static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1725 struct list_head *up_list,
1726 struct list_head *down_list)
1727{
7c81beb0
MB		 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:
d805002b 1739 power = dapm_widget_power_check(w);
7c81beb0 1740
05623c43 1741 dapm_widget_set_power(w, power, up_list, down_list);
7c81beb0
MB		 1742 break;
1743 }
1744}
1745
86dbf2ac
LPC		 1746static 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
2b97eabc
RP		 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 */
95dd5cd6 1771static int dapm_power_widgets(struct snd_soc_card *card, int event)
2b97eabc
RP		 1772{
1773 struct snd_soc_dapm_widget *w;
7be31be8 1774 struct snd_soc_dapm_context *d;
291f3bbc
MB		 1775 LIST_HEAD(up_list);
1776 LIST_HEAD(down_list);
2955b47d 1777 ASYNC_DOMAIN_EXCLUSIVE(async_domain);
56fba41f 1778 enum snd_soc_bias_level bias;
6d3ddc81 1779
f9fa2b18
MB		 1780 lockdep_assert_held(&card->dapm_mutex);
1781
84e90930
MB		 1782 trace_snd_soc_dapm_start(card);
1783
56fba41f 1784 list_for_each_entry(d, &card->dapm_list, list) {
86dbf2ac 1785 if (dapm_idle_bias_off(d))
497098be
MB		 1786 d->target_bias_level = SND_SOC_BIAS_OFF;
1787 else
1788 d->target_bias_level = SND_SOC_BIAS_STANDBY;
56fba41f 1789 }
7be31be8 1790
6c120e19 1791 dapm_reset(card);
9b8a83b2 1792
6d3ddc81 1793 /* Check which widgets we need to power and store them in
db432b41
MB		 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.
6d3ddc81 1798 */
db432b41 1799 list_for_each_entry(w, &card->dapm_dirty, dirty) {
7c81beb0 1800 dapm_power_one_widget(w, &up_list, &down_list);
2b97eabc
RP		 1801 }
1802
f9de6d74 1803 list_for_each_entry(w, &card->widgets, list) {
0ff97ebf
MB		 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 }
db432b41 1813
39eb5fd1 1814 if (w->new_power) {
f9de6d74
MB		 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
afe62367
MB		 1820 * generally don't require full power. Signal
1821 * generators are virtual pins and have no
1822 * power impact themselves.
f9de6d74
MB		 1823 */
1824 switch (w->id) {
afe62367 1825 case snd_soc_dapm_siggen:
da83fea6 1826 case snd_soc_dapm_vmid:
afe62367 1827 break;
f9de6d74 1828 case snd_soc_dapm_supply:
62ea874a 1829 case snd_soc_dapm_regulator_supply:
d7e7eb91 1830 case snd_soc_dapm_clock_supply:
f9de6d74
MB		 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
85a843c5
MB		 1843 /* Force all contexts in the card to the same bias state if
1844 * they're not ground referenced.
1845 */
56fba41f 1846 bias = SND_SOC_BIAS_OFF;
52ba67bf 1847 list_for_each_entry(d, &card->dapm_list, list)
56fba41f
MB		 1848 if (d->target_bias_level > bias)
1849 bias = d->target_bias_level;
52ba67bf 1850 list_for_each_entry(d, &card->dapm_list, list)
86dbf2ac 1851 if (!dapm_idle_bias_off(d))
85a843c5 1852 d->target_bias_level = bias;
52ba67bf 1853
de02d078 1854 trace_snd_soc_dapm_walk_done(card);
52ba67bf 1855
17282ba4
XX		 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 }
9d0624a7 1864 async_synchronize_full_domain(&async_domain);
452c5eaa 1865
cf1f7c6e 1866 list_for_each_entry(w, &down_list, power_list) {
95dd5cd6 1867 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
80114129
MB		 1868 }
1869
cf1f7c6e 1870 list_for_each_entry(w, &up_list, power_list) {
95dd5cd6 1871 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
80114129
MB		 1872 }
1873
6d3ddc81 1874 /* Power down widgets first; try to avoid amplifying pops. */
95dd5cd6 1875 dapm_seq_run(card, &down_list, event, false);
2b97eabc 1876
95dd5cd6 1877 dapm_widget_update(card);
97404f2e 1878
6d3ddc81 1879 /* Now power up. */
95dd5cd6 1880 dapm_seq_run(card, &up_list, event, true);
2b97eabc 1881
9d0624a7 1882 /* Run all the bias changes in parallel */
17282ba4
XX		 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 }
9d0624a7 1888 async_synchronize_full_domain(&async_domain);
17282ba4
XX		 1889 /* Run card bias changes at last */
1890 dapm_post_sequence_async(&card->dapm, 0);
452c5eaa 1891
8078d87f
LG		 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
95dd5cd6 1898 pop_dbg(card->dev, card->pop_time,
fd8d3bc0 1899 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
3a45b867 1900 pop_wait(card->pop_time);
cb507e7e 1901
84e90930
MB		 1902 trace_snd_soc_dapm_done(card);
1903
42aa3418 1904 return 0;
2b97eabc
RP		 1905}
1906
79fb9387 1907#ifdef CONFIG_DEBUG_FS
79fb9387
MB		 1908static 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;
e50b1e06 1913 struct snd_soc_card *card = w->dapm->card;
a3423b02 1914 enum snd_soc_dapm_direction dir, rdir;
79fb9387
MB		 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
e50b1e06
LPC		 1924 mutex_lock(&card->dapm_mutex);
1925
c1862c8b
LPC		 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 }
79fb9387 1934
f13ebada
MB		 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);
79fb9387 1938
d033c36a
MB		 1939 if (w->reg >= 0)
1940 ret += snprintf(buf + ret, PAGE_SIZE - ret,
de9ba98b
LPC		 1941 " - R%d(0x%x) mask 0x%x",
1942 w->reg, w->reg, w->mask << w->shift);
d033c36a
MB		 1943
1944 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1945
3eef08ba
MB		 1946 if (w->sname)
1947 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1948 w->sname,
1949 w->active ? "active" : "inactive");
79fb9387 1950
a3423b02
LPC		 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;
215edda3 1956
a3423b02
LPC		 1957 if (!p->connect)
1958 continue;
215edda3 1959
79fb9387 1960 ret += snprintf(buf + ret, PAGE_SIZE - ret,
a3423b02
LPC		 1961 " %s \"%s\" \"%s\"\n",
1962 (rdir == SND_SOC_DAPM_DIR_IN) ? "in" : "out",
79fb9387 1963 p->name ? p->name : "static",
a3423b02
LPC		 1964 p->node[rdir]->name);
1965 }
79fb9387
MB		 1966 }
1967
e50b1e06
LPC		 1968 mutex_unlock(&card->dapm_mutex);
1969
79fb9387
MB		 1970 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1971
1972 kfree(buf);
1973 return ret;
1974}
1975
1976static const struct file_operations dapm_widget_power_fops = {
234e3405 1977 .open = simple_open,
79fb9387 1978 .read = dapm_widget_power_read_file,
6038f373 1979 .llseek = default_llseek,
79fb9387
MB		 1980};
1981
ef49e4fa
MB		 1982static 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:
a6ed0608 2002 WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
ef49e4fa
MB		 2003 level = "Unknown\n";
2004 break;
2005 }
2006
2007 return simple_read_from_buffer(user_buf, count, ppos, level,
2008 strlen(level));
2009}
2010
2011static const struct file_operations dapm_bias_fops = {
234e3405 2012 .open = simple_open,
ef49e4fa
MB		 2013 .read = dapm_bias_read_file,
2014 .llseek = default_llseek,
2015};
2016
8eecaf62
LPC		 2017void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2018 struct dentry *parent)
79fb9387 2019{
79fb9387
MB		 2020 struct dentry *d;
2021
6553bf06
LPC		 2022 if (!parent)
2023 return;
2024
8eecaf62
LPC		 2025 dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
2026
2027 if (!dapm->debugfs_dapm) {
f1e90af2 2028 dev_warn(dapm->dev,
30a6a1a4 2029 "ASoC: Failed to create DAPM debugfs directory\n");
79fb9387 2030 return;
8eecaf62 2031 }
79fb9387 2032
ef49e4fa
MB		 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");
d5d1e0be 2039}
ef49e4fa 2040
d5d1e0be
LPC		 2041static 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;
79fb9387 2045
d5d1e0be
LPC		 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);
79fb9387 2056}
d5d1e0be 2057
6c45e126
LPC		 2058static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2059{
2060 debugfs_remove_recursive(dapm->debugfs_dapm);
2061}
2062
79fb9387 2063#else
8eecaf62
LPC		 2064void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2065 struct dentry *parent)
79fb9387
MB		 2066{
2067}
d5d1e0be
LPC		 2068
2069static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2070{
2071}
2072
6c45e126
LPC		 2073static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2074{
2075}
2076
79fb9387
MB		 2077#endif
2078
4a201948
LPC		 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 */
2086static 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);
92a99ea4 2095 dapm_path_invalidate(path);
4a201948
LPC		 2096}
2097
2b97eabc 2098/* test and update the power status of a mux widget */
95dd5cd6 2099static int soc_dapm_mux_update_power(struct snd_soc_card *card,
40f02cd9 2100 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
2b97eabc
RP		 2101{
2102 struct snd_soc_dapm_path *path;
2103 int found = 0;
4a201948 2104 bool connect;
2b97eabc 2105
f9fa2b18
MB		 2106 lockdep_assert_held(&card->dapm_mutex);
2107
2b97eabc 2108 /* find dapm widget path assoc with kcontrol */
5106b92f 2109 dapm_kcontrol_for_each_path(path, kcontrol) {
2b97eabc
RP		 2110 found = 1;
2111 /* we now need to match the string in the enum to the path */
4a201948
LPC		 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");
2b97eabc
RP		 2118 }
2119
ce6cfaf1 2120 if (found)
95dd5cd6 2121 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2b97eabc 2122
618dae11 2123 return found;
2b97eabc 2124}
4edbb345 2125
ce6cfaf1 2126int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
6b3fc03b
LPC		 2127 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
2128 struct snd_soc_dapm_update *update)
4edbb345 2129{
ce6cfaf1 2130 struct snd_soc_card *card = dapm->card;
4edbb345
LG		 2131 int ret;
2132
3cd04343 2133 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
564c6504 2134 card->update = update;
95dd5cd6 2135 ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
564c6504 2136 card->update = NULL;
4edbb345 2137 mutex_unlock(&card->dapm_mutex);
618dae11 2138 if (ret > 0)
c3f48ae6 2139 soc_dpcm_runtime_update(card);
4edbb345
LG		 2140 return ret;
2141}
40f02cd9 2142EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
2b97eabc 2143
1b075e3f 2144/* test and update the power status of a mixer or switch widget */
95dd5cd6 2145static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
283375ce 2146 struct snd_kcontrol *kcontrol, int connect)
2b97eabc
RP		 2147{
2148 struct snd_soc_dapm_path *path;
2149 int found = 0;
2150
f9fa2b18
MB		 2151 lockdep_assert_held(&card->dapm_mutex);
2152
2b97eabc 2153 /* find dapm widget path assoc with kcontrol */
5106b92f 2154 dapm_kcontrol_for_each_path(path, kcontrol) {
2b97eabc 2155 found = 1;
4a201948 2156 soc_dapm_connect_path(path, connect, "mixer update");
2b97eabc
RP		 2157 }
2158
ce6cfaf1 2159 if (found)
95dd5cd6 2160 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2b97eabc 2161
618dae11 2162 return found;
2b97eabc 2163}
4edbb345 2164
ce6cfaf1 2165int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
6b3fc03b
LPC		 2166 struct snd_kcontrol *kcontrol, int connect,
2167 struct snd_soc_dapm_update *update)
4edbb345 2168{
ce6cfaf1 2169 struct snd_soc_card *card = dapm->card;
4edbb345
LG		 2170 int ret;
2171
3cd04343 2172 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
564c6504 2173 card->update = update;
95dd5cd6 2174 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
564c6504 2175 card->update = NULL;
4edbb345 2176 mutex_unlock(&card->dapm_mutex);
618dae11 2177 if (ret > 0)
c3f48ae6 2178 soc_dpcm_runtime_update(card);
4edbb345
LG		 2179 return ret;
2180}
40f02cd9 2181EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
2b97eabc 2182
b3c25fb7
LPC		 2183static ssize_t dapm_widget_show_component(struct snd_soc_component *cmpnt,
2184 char *buf)
2b97eabc 2185{
b3c25fb7 2186 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
2b97eabc
RP		 2187 struct snd_soc_dapm_widget *w;
2188 int count = 0;
2189 char *state = "not set";
2190
b3c25fb7
LPC		 2191 list_for_each_entry(w, &cmpnt->card->widgets, list) {
2192 if (w->dapm != dapm)
97c866de 2193 continue;
2b97eabc
RP		 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:
d88429a6 2205 case snd_soc_dapm_out_drv:
2b97eabc 2206 case snd_soc_dapm_mixer:
ca9c1aae 2207 case snd_soc_dapm_mixer_named_ctl:
246d0a17 2208 case snd_soc_dapm_supply:
62ea874a 2209 case snd_soc_dapm_regulator_supply:
d7e7eb91 2210 case snd_soc_dapm_clock_supply:
2b97eabc
RP		 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
b3c25fb7 2220 switch (snd_soc_dapm_get_bias_level(dapm)) {
0be9898a
MB		 2221 case SND_SOC_BIAS_ON:
2222 state = "On";
2b97eabc 2223 break;
0be9898a
MB		 2224 case SND_SOC_BIAS_PREPARE:
2225 state = "Prepare";
2b97eabc 2226 break;
0be9898a
MB		 2227 case SND_SOC_BIAS_STANDBY:
2228 state = "Standby";
2b97eabc 2229 break;
0be9898a
MB		 2230 case SND_SOC_BIAS_OFF:
2231 state = "Off";
2b97eabc
RP		 2232 break;
2233 }
2234 count += sprintf(buf + count, "PM State: %s\n", state);
2235
2236 return count;
2237}
2238
44ba2641
BC		 2239/* show dapm widget status in sys fs */
2240static 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
e50b1e06
LPC		 2246 mutex_lock(&rtd->card->dapm_mutex);
2247
44ba2641 2248 for (i = 0; i < rtd->num_codecs; i++) {
b3c25fb7
LPC		 2249 struct snd_soc_component *cmpnt = rtd->codec_dais[i]->component;
2250
2251 count += dapm_widget_show_component(cmpnt, buf + count);
44ba2641
BC		 2252 }
2253
e50b1e06
LPC		 2254 mutex_unlock(&rtd->card->dapm_mutex);
2255
44ba2641
BC		 2256 return count;
2257}
2258
2b97eabc
RP		 2259static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
2260
d29697dc
TI		 2261struct attribute *soc_dapm_dev_attrs[] = {
2262 &dev_attr_dapm_widget.attr,
2263 NULL
2264};
2b97eabc 2265
8872293f
LPC		 2266static void dapm_free_path(struct snd_soc_dapm_path *path)
2267{
a3423b02
LPC		 2268 list_del(&path->list_node[SND_SOC_DAPM_DIR_IN]);
2269 list_del(&path->list_node[SND_SOC_DAPM_DIR_OUT]);
5106b92f 2270 list_del(&path->list_kcontrol);
8872293f 2271 list_del(&path->list);
8872293f
LPC		 2272 kfree(path);
2273}
2274
b97e2698
LPC		 2275void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w)
2276{
2277 struct snd_soc_dapm_path *p, *next_p;
a3423b02 2278 enum snd_soc_dapm_direction dir;
b97e2698
LPC		 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 */
a3423b02
LPC		 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 }
b97e2698
LPC		 2290
2291 kfree(w->kcontrols);
48068961 2292 kfree_const(w->name);
b97e2698
LPC		 2293 kfree(w);
2294}
2295
fd589a1b
JS		 2296void 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
2b97eabc 2302/* free all dapm widgets and resources */
ce6120cc 2303static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
2b97eabc
RP		 2304{
2305 struct snd_soc_dapm_widget *w, *next_w;
2b97eabc 2306
97c866de
JN		 2307 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
2308 if (w->dapm != dapm)
2309 continue;
b97e2698 2310 snd_soc_dapm_free_widget(w);
2b97eabc 2311 }
fd589a1b 2312 snd_soc_dapm_reset_cache(dapm);
2b97eabc
RP		 2313}
2314
91a5fca4
LPC		 2315static struct snd_soc_dapm_widget *dapm_find_widget(
2316 struct snd_soc_dapm_context *dapm, const char *pin,
2317 bool search_other_contexts)
a5302181
LG		 2318{
2319 struct snd_soc_dapm_widget *w;
91a5fca4 2320 struct snd_soc_dapm_widget *fallback = NULL;
a5302181 2321
97c866de 2322 list_for_each_entry(w, &dapm->card->widgets, list) {
a5302181 2323 if (!strcmp(w->name, pin)) {
91a5fca4
LPC		 2324 if (w->dapm == dapm)
2325 return w;
2326 else
2327 fallback = w;
a5302181
LG		 2328 }
2329 }
2330
91a5fca4
LPC		 2331 if (search_other_contexts)
2332 return fallback;
2333
2334 return NULL;
2335}
2336
2337static 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
f9fa2b18
MB		 2342 dapm_assert_locked(dapm);
2343
91a5fca4 2344 if (!w) {
30a6a1a4 2345 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
91a5fca4 2346 return -EINVAL;
0d86733c
MB		 2347 }
2348
92a99ea4 2349 if (w->connected != status) {
1a8b2d9d 2350 dapm_mark_dirty(w, "pin configuration");
92a99ea4
LPC		 2351 dapm_widget_invalidate_input_paths(w);
2352 dapm_widget_invalidate_output_paths(w);
2353 }
1a8b2d9d 2354
91a5fca4
LPC		 2355 w->connected = status;
2356 if (status == 0)
2357 w->force = 0;
2358
2359 return 0;
a5302181
LG		 2360}
2361
2b97eabc 2362/**
3eb29dfb 2363 * snd_soc_dapm_sync_unlocked - scan and power dapm paths
ce6120cc 2364 * @dapm: DAPM context
2b97eabc
RP		 2365 *
2366 * Walks all dapm audio paths and powers widgets according to their
2367 * stream or path usage.
2368 *
3eb29dfb
CK		 2369 * Requires external locking.
2370 *
2b97eabc
RP		 2371 * Returns 0 for success.
2372 */
3eb29dfb 2373int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
2b97eabc 2374{
4f4c0072
MB		 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
3eb29dfb
CK		 2382 return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
2383}
2384EXPORT_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 */
2395int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
2396{
2397 int ret;
2398
3cd04343 2399 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3eb29dfb 2400 ret = snd_soc_dapm_sync_unlocked(dapm);
a73fb2df
LG		 2401 mutex_unlock(&dapm->card->dapm_mutex);
2402 return ret;
2b97eabc 2403}
a5302181 2404EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
2b97eabc 2405
6dd98b0a
LPC		 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 */
2415static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
2416{
a3423b02 2417 enum snd_soc_dapm_direction dir;
6dd98b0a 2418 struct snd_soc_dapm_path *p;
a3423b02 2419 unsigned int ep;
6dd98b0a
LPC		 2420
2421 switch (w->id) {
2422 case snd_soc_dapm_input:
86d75003
LPC		 2423 /* On a fully routed card a input is never a source */
2424 if (w->dapm->card->fully_routed)
a3423b02
LPC		 2425 return;
2426 ep = SND_SOC_DAPM_EP_SOURCE;
e63bfd45 2427 snd_soc_dapm_widget_for_each_source_path(w, p) {
6dd98b0a
LPC		 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) {
a3423b02 2432 ep = 0;
6dd98b0a
LPC		 2433 break;
2434 }
2435 }
2436 break;
2437 case snd_soc_dapm_output:
86d75003
LPC		 2438 /* On a fully routed card a output is never a sink */
2439 if (w->dapm->card->fully_routed)
a3423b02
LPC		 2440 return;
2441 ep = SND_SOC_DAPM_EP_SINK;
e63bfd45 2442 snd_soc_dapm_widget_for_each_sink_path(w, p) {
6dd98b0a
LPC		 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) {
a3423b02 2447 ep = 0;
6dd98b0a
LPC		 2448 break;
2449 }
2450 }
2451 break;
2452 case snd_soc_dapm_line:
a3423b02
LPC		 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 }
6dd98b0a
LPC		 2458 break;
2459 default:
a3423b02 2460 return;
6dd98b0a 2461 }
a3423b02
LPC		 2462
2463 w->is_ep = ep;
6dd98b0a
LPC		 2464}
2465
d714f97c
LPC		 2466static 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
2553628e
LPC		 2510static 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))
2b97eabc 2515{
a3423b02
LPC		 2516 struct snd_soc_dapm_widget *widgets[2];
2517 enum snd_soc_dapm_direction dir;
2b97eabc 2518 struct snd_soc_dapm_path *path;
2553628e 2519 int ret;
2b97eabc 2520
e409dfbf
LPC		 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
d714f97c
LPC		 2542 ret = snd_soc_dapm_check_dynamic_path(dapm, wsource, wsink, control);
2543 if (ret)
2544 return ret;
2545
2b97eabc
RP		 2546 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
2547 if (!path)
2548 return -ENOMEM;
2549
a3423b02
LPC		 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
2553628e 2555 path->connected = connected;
2b97eabc 2556 INIT_LIST_HEAD(&path->list);
69c2d346 2557 INIT_LIST_HEAD(&path->list_kcontrol);
2b97eabc 2558
c1862c8b
LPC		 2559 if (wsource->is_supply || wsink->is_supply)
2560 path->is_supply = 1;
2561
2b97eabc
RP		 2562 /* connect static paths */
2563 if (control == NULL) {
2b97eabc 2564 path->connect = 1;
5fe5b767 2565 } else {
d714f97c
LPC		 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
5fe5b767
LPC		 2576 switch (wsink->id) {
2577 case snd_soc_dapm_mux:
d714f97c 2578 ret = dapm_connect_mux(dapm, path, control, wsink);
5fe5b767
LPC		 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:
d714f97c 2590 break;
5fe5b767 2591 }
2b97eabc 2592 }
fabd0384 2593
5fe5b767 2594 list_add(&path->list, &dapm->card->paths);
a3423b02
LPC		 2595 snd_soc_dapm_for_each_direction(dir)
2596 list_add(&path->list_node[dir], &widgets[dir]->edges[dir]);
5fe5b767 2597
a3423b02
LPC		 2598 snd_soc_dapm_for_each_direction(dir) {
2599 dapm_update_widget_flags(widgets[dir]);
2600 dapm_mark_dirty(widgets[dir], "Route added");
2601 }
5fe5b767 2602
92a99ea4
LPC		 2603 if (dapm->card->instantiated && path->connect)
2604 dapm_path_invalidate(path);
2605
2b97eabc 2606 return 0;
2553628e
LPC		 2607err:
2608 kfree(path);
2609 return ret;
2610}
2b97eabc 2611
2553628e 2612static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
a4e9154c 2613 const struct snd_soc_dapm_route *route)
2553628e
LPC		 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];
94f99c87 2621 const char *prefix;
2553628e
LPC		 2622 int ret;
2623
94f99c87
LPC		 2624 prefix = soc_dapm_prefix(dapm);
2625 if (prefix) {
2553628e 2626 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
94f99c87 2627 prefix, route->sink);
2553628e
LPC		 2628 sink = prefixed_sink;
2629 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
94f99c87 2630 prefix, route->source);
2553628e
LPC		 2631 source = prefixed_source;
2632 } else {
2633 sink = route->sink;
2634 source = route->source;
2635 }
2636
45a110a1
CK		 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
2553628e
LPC		 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;
70c75109 2650 if (w->dapm == dapm) {
2553628e 2651 wsink = w;
70c75109
CK		 2652 if (wsource)
2653 break;
2654 }
2553628e
LPC		 2655 continue;
2656 }
2657 if (!wsource && !(strcmp(w->name, source))) {
2658 wtsource = w;
70c75109 2659 if (w->dapm == dapm) {
2553628e 2660 wsource = w;
70c75109
CK		 2661 if (wsink)
2662 break;
2663 }
2553628e
LPC		 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
45a110a1
CK		 2683skip_search:
2684 dapm_wcache_update(&dapm->path_sink_cache, wsink);
2685 dapm_wcache_update(&dapm->path_source_cache, wsource);
2686
2553628e
LPC		 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;
2b97eabc 2693err:
30a6a1a4 2694 dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n",
2553628e 2695 source, route->control, sink);
2b97eabc
RP		 2696 return ret;
2697}
105f1c28 2698
efcc3c61
MB		 2699static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
2700 const struct snd_soc_dapm_route *route)
2701{
6dd98b0a 2702 struct snd_soc_dapm_widget *wsource, *wsink;
efcc3c61
MB		 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];
94f99c87 2708 const char *prefix;
efcc3c61
MB		 2709
2710 if (route->control) {
2711 dev_err(dapm->dev,
30a6a1a4 2712 "ASoC: Removal of routes with controls not supported\n");
efcc3c61
MB		 2713 return -EINVAL;
2714 }
2715
94f99c87
LPC		 2716 prefix = soc_dapm_prefix(dapm);
2717 if (prefix) {
efcc3c61 2718 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
94f99c87 2719 prefix, route->sink);
efcc3c61
MB		 2720 sink = prefixed_sink;
2721 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
94f99c87 2722 prefix, route->source);
efcc3c61
MB		 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) {
6dd98b0a
LPC		 2740 wsource = path->source;
2741 wsink = path->sink;
2742
2743 dapm_mark_dirty(wsource, "Route removed");
2744 dapm_mark_dirty(wsink, "Route removed");
92a99ea4
LPC		 2745 if (path->connect)
2746 dapm_path_invalidate(path);
efcc3c61 2747
8872293f 2748 dapm_free_path(path);
6dd98b0a
LPC		 2749
2750 /* Update any path related flags */
2751 dapm_update_widget_flags(wsource);
2752 dapm_update_widget_flags(wsink);
efcc3c61 2753 } else {
30a6a1a4 2754 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
efcc3c61
MB		 2755 source, sink);
2756 }
2757
2758 return 0;
2759}
2760
105f1c28
MB		 2761/**
2762 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
ce6120cc 2763 * @dapm: DAPM context
105f1c28
MB		 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 */
ce6120cc 2774int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
105f1c28
MB		 2775 const struct snd_soc_dapm_route *route, int num)
2776{
62d4a4b9 2777 int i, r, ret = 0;
105f1c28 2778
a73fb2df 2779 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
105f1c28 2780 for (i = 0; i < num; i++) {
a4e9154c 2781 r = snd_soc_dapm_add_route(dapm, route);
62d4a4b9 2782 if (r < 0) {
30a6a1a4
LG		 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);
62d4a4b9 2787 ret = r;
105f1c28
MB		 2788 }
2789 route++;
2790 }
a73fb2df 2791 mutex_unlock(&dapm->card->dapm_mutex);
105f1c28 2792
60884c27 2793 return ret;
105f1c28
MB		 2794}
2795EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
2796
efcc3c61
MB		 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 */
2805int 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, ret = 0;
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 ret;
2818}
2819EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes);
2820
bf3a9e13
MB		 2821static 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) {
30a6a1a4 2834 dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
bf3a9e13
MB		 2835 route->source);
2836 return -ENODEV;
2837 }
2838
2839 if (!sink) {
30a6a1a4 2840 dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
bf3a9e13
MB		 2841 route->sink);
2842 return -ENODEV;
2843 }
2844
2845 if (route->control || route->connected)
30a6a1a4 2846 dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
bf3a9e13
MB		 2847 route->source, route->sink);
2848
e63bfd45 2849 snd_soc_dapm_widget_for_each_sink_path(source, path) {
bf3a9e13
MB		 2850 if (path->sink == sink) {
2851 path->weak = 1;
2852 count++;
2853 }
2854 }
2855
2856 if (count == 0)
30a6a1a4 2857 dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
bf3a9e13
MB		 2858 route->source, route->sink);
2859 if (count > 1)
30a6a1a4 2860 dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
bf3a9e13
MB		 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 */
2882int 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
a73fb2df 2888 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
bf3a9e13
MB		 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 }
a73fb2df 2895 mutex_unlock(&dapm->card->dapm_mutex);
bf3a9e13
MB		 2896
2897 return ret;
2898}
2899EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2900
2b97eabc
RP		 2901/**
2902 * snd_soc_dapm_new_widgets - add new dapm widgets
628536ea 2903 * @card: card to be checked for new dapm widgets
2b97eabc
RP		 2904 *
2905 * Checks the codec for any new dapm widgets and creates them if found.
2906 *
2907 * Returns 0 for success.
2908 */
824ef826 2909int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
2b97eabc
RP		 2910{
2911 struct snd_soc_dapm_widget *w;
b66a70d5 2912 unsigned int val;
2b97eabc 2913
95dd5cd6 2914 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
a73fb2df 2915
95dd5cd6 2916 list_for_each_entry(w, &card->widgets, list)
2b97eabc
RP		 2917 {
2918 if (w->new)
2919 continue;
2920
fad59888
SW		 2921 if (w->num_kcontrols) {
2922 w->kcontrols = kzalloc(w->num_kcontrols *
2923 sizeof(struct snd_kcontrol *),
2924 GFP_KERNEL);
a73fb2df 2925 if (!w->kcontrols) {
95dd5cd6 2926 mutex_unlock(&card->dapm_mutex);
fad59888 2927 return -ENOMEM;
a73fb2df 2928 }
fad59888
SW		 2929 }
2930
2b97eabc
RP		 2931 switch(w->id) {
2932 case snd_soc_dapm_switch:
2933 case snd_soc_dapm_mixer:
ca9c1aae 2934 case snd_soc_dapm_mixer_named_ctl:
4b80b8c2 2935 dapm_new_mixer(w);
2b97eabc
RP		 2936 break;
2937 case snd_soc_dapm_mux:
d714f97c 2938 case snd_soc_dapm_demux:
4b80b8c2 2939 dapm_new_mux(w);
2b97eabc 2940 break;
2b97eabc 2941 case snd_soc_dapm_pga:
d88429a6 2942 case snd_soc_dapm_out_drv:
4b80b8c2 2943 dapm_new_pga(w);
2b97eabc 2944 break;
c6615082
NO		 2945 case snd_soc_dapm_dai_link:
2946 dapm_new_dai_link(w);
2947 break;
7ca3a18b 2948 default:
2b97eabc
RP		 2949 break;
2950 }
b66a70d5
MB		 2951
2952 /* Read the initial power state from the device */
2953 if (w->reg >= 0) {
ce0fc93a 2954 soc_dapm_read(w->dapm, w->reg, &val);
f7d3c170 2955 val = val >> w->shift;
de9ba98b
LPC		 2956 val &= w->mask;
2957 if (val == w->on_val)
b66a70d5
MB		 2958 w->power = 1;
2959 }
2960
2b97eabc 2961 w->new = 1;
d5d1e0be 2962
7508b12a 2963 dapm_mark_dirty(w, "new widget");
d5d1e0be 2964 dapm_debugfs_add_widget(w);
2b97eabc
RP		 2965 }
2966
95dd5cd6
LPC		 2967 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2968 mutex_unlock(&card->dapm_mutex);
2b97eabc
RP		 2969 return 0;
2970}
2971EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
2972
2973/**
2974 * snd_soc_dapm_get_volsw - dapm mixer get callback
2975 * @kcontrol: mixer control
ac11a2b3 2976 * @ucontrol: control element information
2b97eabc
RP		 2977 *
2978 * Callback to get the value of a dapm mixer control.
2979 *
2980 * Returns 0 for success.
2981 */
2982int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
2983 struct snd_ctl_elem_value *ucontrol)
2984{
ce0fc93a
LPC		 2985 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
2986 struct snd_soc_card *card = dapm->card;
4eaa9819
JS		 2987 struct soc_mixer_control *mc =
2988 (struct soc_mixer_control *)kcontrol->private_value;
249ce138 2989 int reg = mc->reg;
815ecf8d 2990 unsigned int shift = mc->shift;
4eaa9819 2991 int max = mc->max;
815ecf8d 2992 unsigned int mask = (1 << fls(max)) - 1;
da602ab8 2993 unsigned int invert = mc->invert;
57295073 2994 unsigned int val;
ce0fc93a 2995 int ret = 0;
da602ab8
BT		 2996
2997 if (snd_soc_volsw_is_stereo(mc))
ce0fc93a 2998 dev_warn(dapm->dev,
30a6a1a4 2999 "ASoC: Control '%s' is stereo, which is not supported\n",
da602ab8 3000 kcontrol->id.name);
2b97eabc 3001
57295073 3002 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
ce0fc93a
LPC		 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 {
57295073 3007 val = dapm_kcontrol_get_value(kcontrol);
ce0fc93a 3008 }
57295073
LPC		 3009 mutex_unlock(&card->dapm_mutex);
3010
da602ab8 3011 if (invert)
57295073
LPC		 3012 ucontrol->value.integer.value[0] = max - val;
3013 else
3014 ucontrol->value.integer.value[0] = val;
2b97eabc 3015
ce0fc93a 3016 return ret;
2b97eabc
RP		 3017}
3018EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
3019
3020/**
3021 * snd_soc_dapm_put_volsw - dapm mixer set callback
3022 * @kcontrol: mixer control
ac11a2b3 3023 * @ucontrol: control element information
2b97eabc
RP		 3024 *
3025 * Callback to set the value of a dapm mixer control.
3026 *
3027 * Returns 0 for success.
3028 */
3029int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
3030 struct snd_ctl_elem_value *ucontrol)
3031{
ce0fc93a
LPC		 3032 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3033 struct snd_soc_card *card = dapm->card;
4eaa9819
JS		 3034 struct soc_mixer_control *mc =
3035 (struct soc_mixer_control *)kcontrol->private_value;
249ce138 3036 int reg = mc->reg;
815ecf8d 3037 unsigned int shift = mc->shift;
4eaa9819 3038 int max = mc->max;
815ecf8d
JS		 3039 unsigned int mask = (1 << fls(max)) - 1;
3040 unsigned int invert = mc->invert;
e9cf7049 3041 unsigned int val;
18626c7e 3042 int connect, change, reg_change = 0;
97404f2e 3043 struct snd_soc_dapm_update update;
52765976 3044 int ret = 0;
2b97eabc 3045
da602ab8 3046 if (snd_soc_volsw_is_stereo(mc))
ce0fc93a 3047 dev_warn(dapm->dev,
30a6a1a4 3048 "ASoC: Control '%s' is stereo, which is not supported\n",
da602ab8
BT		 3049 kcontrol->id.name);
3050
2b97eabc 3051 val = (ucontrol->value.integer.value[0] & mask);
8a720718 3052 connect = !!val;
2b97eabc
RP		 3053
3054 if (invert)
a7a4ac86 3055 val = max - val;
2b97eabc 3056
3cd04343 3057 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2b97eabc 3058
249ce138 3059 change = dapm_kcontrol_set_value(kcontrol, val);
97404f2e 3060
18626c7e
JN		 3061 if (reg != SND_SOC_NOPM) {
3062 mask = mask << shift;
3063 val = val << shift;
3064
ce0fc93a 3065 reg_change = soc_dapm_test_bits(dapm, reg, mask, val);
18626c7e
JN		 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;
249ce138 3075 }
18626c7e 3076 change |= reg_change;
97404f2e 3077
52765976 3078 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
fafd2176 3079
564c6504 3080 card->update = NULL;
283375ce
MB		 3081 }
3082
a73fb2df 3083 mutex_unlock(&card->dapm_mutex);
52765976
NC		 3084
3085 if (ret > 0)
3086 soc_dpcm_runtime_update(card);
3087
56a67834 3088 return change;
2b97eabc
RP		 3089}
3090EXPORT_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
ac11a2b3 3095 * @ucontrol: control element information
2b97eabc
RP		 3096 *
3097 * Callback to get the value of a dapm enumerated double mixer control.
3098 *
3099 * Returns 0 for success.
3100 */
3101int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
3102 struct snd_ctl_elem_value *ucontrol)
3103{
ce0fc93a 3104 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
561ed680 3105 struct snd_soc_card *card = dapm->card;
2b97eabc 3106 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3727b496 3107 unsigned int reg_val, val;
52765976 3108
561ed680
CK		 3109 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3110 if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
69128316 3111 int ret = soc_dapm_read(dapm, e->reg, &reg_val);
964a0b89
CK		 3112 if (ret) {
3113 mutex_unlock(&card->dapm_mutex);
69128316 3114 return ret;
964a0b89 3115 }
69128316 3116 } else {
236aaa68 3117 reg_val = dapm_kcontrol_get_value(kcontrol);
69128316 3118 }
561ed680 3119 mutex_unlock(&card->dapm_mutex);
2e72f8e3 3120
2e72f8e3 3121 val = (reg_val >> e->shift_l) & e->mask;
3727b496 3122 ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
2e72f8e3
PU		 3123 if (e->shift_l != e->shift_r) {
3124 val = (reg_val >> e->shift_r) & e->mask;
3727b496
LPC		 3125 val = snd_soc_enum_val_to_item(e, val);
3126 ucontrol->value.enumerated.item[1] = val;
2e72f8e3
PU		 3127 }
3128
69128316 3129 return 0;
2e72f8e3 3130}
2b97eabc 3131EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
2e72f8e3
PU		 3132
3133/**
2b97eabc 3134 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
2e72f8e3
PU		 3135 * @kcontrol: mixer control
3136 * @ucontrol: control element information
3137 *
2b97eabc 3138 * Callback to set the value of a dapm enumerated double mixer control.
2e72f8e3
PU		 3139 *
3140 * Returns 0 for success.
3141 */
2b97eabc 3142int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
2e72f8e3
PU		 3143 struct snd_ctl_elem_value *ucontrol)
3144{
ce0fc93a
LPC		 3145 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3146 struct snd_soc_card *card = dapm->card;
74155556 3147 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3727b496 3148 unsigned int *item = ucontrol->value.enumerated.item;
561ed680 3149 unsigned int val, change, reg_change = 0;
46f5822f 3150 unsigned int mask;
97404f2e 3151 struct snd_soc_dapm_update update;
52765976 3152 int ret = 0;
2e72f8e3 3153
3727b496 3154 if (item[0] >= e->items)
2e72f8e3 3155 return -EINVAL;
3727b496
LPC		 3156
3157 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
2e72f8e3
PU		 3158 mask = e->mask << e->shift_l;
3159 if (e->shift_l != e->shift_r) {
3727b496 3160 if (item[1] > e->items)
2e72f8e3 3161 return -EINVAL;
3727b496 3162 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_l;
2e72f8e3
PU		 3163 mask |= e->mask << e->shift_r;
3164 }
3165
3cd04343 3166 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
fafd2176 3167
561ed680
CK		 3168 change = dapm_kcontrol_set_value(kcontrol, val);
3169
236aaa68 3170 if (e->reg != SND_SOC_NOPM)
561ed680 3171 reg_change = soc_dapm_test_bits(dapm, e->reg, mask, val);
236aaa68 3172
561ed680
CK		 3173 if (change || reg_change) {
3174 if (reg_change) {
236aaa68
LPC		 3175 update.kcontrol = kcontrol;
3176 update.reg = e->reg;
3177 update.mask = mask;
3178 update.val = val;
3179 card->update = &update;
3180 }
561ed680 3181 change |= reg_change;
1642e3d4 3182
3727b496 3183 ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
fafd2176 3184
564c6504 3185 card->update = NULL;
fafd2176 3186 }
2e72f8e3 3187
a73fb2df 3188 mutex_unlock(&card->dapm_mutex);
52765976
NC		 3189
3190 if (ret > 0)
3191 soc_dpcm_runtime_update(card);
3192
97404f2e 3193 return change;
2e72f8e3 3194}
2b97eabc 3195EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
2e72f8e3 3196
8b37dbd2
MB		 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 */
3205int 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}
3215EXPORT_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 */
3223int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
3224 struct snd_ctl_elem_value *ucontrol)
3225{
48a8c394 3226 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
8b37dbd2
MB		 3227 const char *pin = (const char *)kcontrol->private_value;
3228
3cd04343 3229 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
8b37dbd2
MB		 3230
3231 ucontrol->value.integer.value[0] =
48a8c394 3232 snd_soc_dapm_get_pin_status(&card->dapm, pin);
8b37dbd2 3233
a73fb2df 3234 mutex_unlock(&card->dapm_mutex);
8b37dbd2
MB		 3235
3236 return 0;
3237}
3238EXPORT_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 */
3246int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
3247 struct snd_ctl_elem_value *ucontrol)
3248{
48a8c394 3249 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
8b37dbd2
MB		 3250 const char *pin = (const char *)kcontrol->private_value;
3251
8b37dbd2 3252 if (ucontrol->value.integer.value[0])
48a8c394 3253 snd_soc_dapm_enable_pin(&card->dapm, pin);
8b37dbd2 3254 else
48a8c394 3255 snd_soc_dapm_disable_pin(&card->dapm, pin);
8b37dbd2 3256
a73fb2df 3257 snd_soc_dapm_sync(&card->dapm);
8b37dbd2
MB		 3258 return 0;
3259}
3260EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
3261
cc76e7de 3262struct snd_soc_dapm_widget *
5ba06fc9 3263snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
02aa78ab
LG		 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
3279struct snd_soc_dapm_widget *
3280snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
5ba06fc9 3281 const struct snd_soc_dapm_widget *widget)
2b97eabc 3282{
a3423b02 3283 enum snd_soc_dapm_direction dir;
2b97eabc 3284 struct snd_soc_dapm_widget *w;
94f99c87 3285 const char *prefix;
62ea874a 3286 int ret;
2b97eabc
RP		 3287
3288 if ((w = dapm_cnew_widget(widget)) == NULL)
5ba06fc9 3289 return NULL;
2b97eabc 3290
62ea874a
MB		 3291 switch (w->id) {
3292 case snd_soc_dapm_regulator_supply:
a3cc056b
LG		 3293 w->regulator = devm_regulator_get(dapm->dev, w->name);
3294 if (IS_ERR(w->regulator)) {
3295 ret = PTR_ERR(w->regulator);
30a6a1a4 3296 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
62ea874a 3297 w->name, ret);
5ba06fc9 3298 return NULL;
62ea874a 3299 }
8784c77a 3300
de9ba98b 3301 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
8784c77a
MB		 3302 ret = regulator_allow_bypass(w->regulator, true);
3303 if (ret != 0)
3304 dev_warn(w->dapm->dev,
30686c35 3305 "ASoC: Failed to bypass %s: %d\n",
8784c77a
MB		 3306 w->name, ret);
3307 }
62ea874a 3308 break;
d7e7eb91 3309 case snd_soc_dapm_clock_supply:
165961ef 3310#ifdef CONFIG_CLKDEV_LOOKUP
695594f1 3311 w->clk = devm_clk_get(dapm->dev, w->name);
d7e7eb91
OL		 3312 if (IS_ERR(w->clk)) {
3313 ret = PTR_ERR(w->clk);
30a6a1a4 3314 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
d7e7eb91
OL		 3315 w->name, ret);
3316 return NULL;
3317 }
ec02995a
MB		 3318#else
3319 return NULL;
3320#endif
d7e7eb91 3321 break;
62ea874a
MB		 3322 default:
3323 break;
3324 }
2b97eabc 3325
94f99c87 3326 prefix = soc_dapm_prefix(dapm);
a798c24a 3327 if (prefix)
94f99c87 3328 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, widget->name);
a798c24a 3329 else
48068961 3330 w->name = kstrdup_const(widget->name, GFP_KERNEL);
ead9b919
JN		 3331 if (w->name == NULL) {
3332 kfree(w);
5ba06fc9 3333 return NULL;
ead9b919 3334 }
ead9b919 3335
7ca3a18b 3336 switch (w->id) {
6dd98b0a 3337 case snd_soc_dapm_mic:
a3423b02 3338 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
7ca3a18b
MB		 3339 w->power_check = dapm_generic_check_power;
3340 break;
86d75003
LPC		 3341 case snd_soc_dapm_input:
3342 if (!dapm->card->fully_routed)
a3423b02 3343 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
86d75003
LPC		 3344 w->power_check = dapm_generic_check_power;
3345 break;
6dd98b0a
LPC		 3346 case snd_soc_dapm_spk:
3347 case snd_soc_dapm_hp:
a3423b02 3348 w->is_ep = SND_SOC_DAPM_EP_SINK;
7ca3a18b
MB		 3349 w->power_check = dapm_generic_check_power;
3350 break;
86d75003
LPC		 3351 case snd_soc_dapm_output:
3352 if (!dapm->card->fully_routed)
a3423b02 3353 w->is_ep = SND_SOC_DAPM_EP_SINK;
86d75003
LPC		 3354 w->power_check = dapm_generic_check_power;
3355 break;
6dd98b0a
LPC		 3356 case snd_soc_dapm_vmid:
3357 case snd_soc_dapm_siggen:
a3423b02 3358 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
6dd98b0a
LPC		 3359 w->power_check = dapm_always_on_check_power;
3360 break;
3361 case snd_soc_dapm_mux:
d714f97c 3362 case snd_soc_dapm_demux:
6dd98b0a
LPC		 3363 case snd_soc_dapm_switch:
3364 case snd_soc_dapm_mixer:
3365 case snd_soc_dapm_mixer_named_ctl:
63c69a6e
MB		 3366 case snd_soc_dapm_adc:
3367 case snd_soc_dapm_aif_out:
3368 case snd_soc_dapm_dac:
3369 case snd_soc_dapm_aif_in:
7ca3a18b
MB		 3370 case snd_soc_dapm_pga:
3371 case snd_soc_dapm_out_drv:
7ca3a18b 3372 case snd_soc_dapm_micbias:
7ca3a18b 3373 case snd_soc_dapm_line:
c74184ed 3374 case snd_soc_dapm_dai_link:
cdef2ad3
LPC		 3375 case snd_soc_dapm_dai_out:
3376 case snd_soc_dapm_dai_in:
7ca3a18b
MB		 3377 w->power_check = dapm_generic_check_power;
3378 break;
3379 case snd_soc_dapm_supply:
62ea874a 3380 case snd_soc_dapm_regulator_supply:
d7e7eb91 3381 case snd_soc_dapm_clock_supply:
57295073 3382 case snd_soc_dapm_kcontrol:
6dd98b0a 3383 w->is_supply = 1;
7ca3a18b
MB		 3384 w->power_check = dapm_supply_check_power;
3385 break;
3386 default:
3387 w->power_check = dapm_always_on_check_power;
3388 break;
3389 }
3390
ce6120cc 3391 w->dapm = dapm;
2b97eabc 3392 INIT_LIST_HEAD(&w->list);
db432b41 3393 INIT_LIST_HEAD(&w->dirty);
92fa1242 3394 list_add_tail(&w->list, &dapm->card->widgets);
2b97eabc 3395
a3423b02
LPC		 3396 snd_soc_dapm_for_each_direction(dir) {
3397 INIT_LIST_HEAD(&w->edges[dir]);
3398 w->endpoints[dir] = -1;
3399 }
92a99ea4 3400
2b97eabc
RP		 3401 /* machine layer set ups unconnected pins and insertions */
3402 w->connected = 1;
5ba06fc9 3403 return w;
2b97eabc 3404}
2b97eabc 3405
4ba1327a
MB		 3406/**
3407 * snd_soc_dapm_new_controls - create new dapm controls
ce6120cc 3408 * @dapm: DAPM context
4ba1327a
MB		 3409 * @widget: widget array
3410 * @num: number of widgets
3411 *
3412 * Creates new DAPM controls based upon the templates.
3413 *
3414 * Returns 0 for success else error.
3415 */
ce6120cc 3416int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
4ba1327a
MB		 3417 const struct snd_soc_dapm_widget *widget,
3418 int num)
3419{
5ba06fc9
MB		 3420 struct snd_soc_dapm_widget *w;
3421 int i;
60884c27 3422 int ret = 0;
4ba1327a 3423
a73fb2df 3424 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
4ba1327a 3425 for (i = 0; i < num; i++) {
02aa78ab 3426 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
5ba06fc9 3427 if (!w) {
f7d41ae8 3428 dev_err(dapm->dev,
5ba06fc9
MB		 3429 "ASoC: Failed to create DAPM control %s\n",
3430 widget->name);
60884c27
DC		 3431 ret = -ENOMEM;
3432 break;
b8b33cb5 3433 }
4ba1327a
MB		 3434 widget++;
3435 }
a73fb2df 3436 mutex_unlock(&dapm->card->dapm_mutex);
60884c27 3437 return ret;
4ba1327a
MB		 3438}
3439EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
3440
c74184ed
MB		 3441static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
3442 struct snd_kcontrol *kcontrol, int event)
3443{
3444 struct snd_soc_dapm_path *source_p, *sink_p;
3445 struct snd_soc_dai *source, *sink;
c6615082 3446 const struct snd_soc_pcm_stream *config = w->params + w->params_select;
c74184ed 3447 struct snd_pcm_substream substream;
9747cec2 3448 struct snd_pcm_hw_params *params = NULL;
c74184ed
MB		 3449 u64 fmt;
3450 int ret;
3451
bf4edea8 3452 if (WARN_ON(!config) ||
a3423b02
LPC		 3453 WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
3454 list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
bf4edea8 3455 return -EINVAL;
c74184ed
MB		 3456
3457 /* We only support a single source and sink, pick the first */
a3423b02
LPC		 3458 source_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_OUT],
3459 struct snd_soc_dapm_path,
3460 list_node[SND_SOC_DAPM_DIR_OUT]);
3461 sink_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_IN],
3462 struct snd_soc_dapm_path,
3463 list_node[SND_SOC_DAPM_DIR_IN]);
c74184ed
MB		 3464
3465 source = source_p->source->priv;
3466 sink = sink_p->sink->priv;
3467
3468 /* Be a little careful as we don't want to overflow the mask array */
3469 if (config->formats) {
3470 fmt = ffs(config->formats) - 1;
3471 } else {
30a6a1a4 3472 dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n",
c74184ed
MB		 3473 config->formats);
3474 fmt = 0;
3475 }
3476
3477 /* Currently very limited parameter selection */
9747cec2
MB		 3478 params = kzalloc(sizeof(*params), GFP_KERNEL);
3479 if (!params) {
3480 ret = -ENOMEM;
3481 goto out;
3482 }
3483 snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
c74184ed 3484
9747cec2 3485 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
c74184ed 3486 config->rate_min;
9747cec2 3487 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
c74184ed
MB		 3488 config->rate_max;
3489
9747cec2 3490 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
c74184ed 3491 = config->channels_min;
9747cec2 3492 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
c74184ed
MB		 3493 = config->channels_max;
3494
3495 memset(&substream, 0, sizeof(substream));
3496
3497 switch (event) {
3498 case SND_SOC_DAPM_PRE_PMU:
93e6958a 3499 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
9b8ef9f6
JK		 3500 if (source->driver->ops && source->driver->ops->startup) {
3501 ret = source->driver->ops->startup(&substream, source);
3502 if (ret < 0) {
3503 dev_err(source->dev,
3504 "ASoC: startup() failed: %d\n", ret);
3505 goto out;
3506 }
3507 source->active++;
3508 }
93e6958a
BC		 3509 ret = soc_dai_hw_params(&substream, params, source);
3510 if (ret < 0)
3511 goto out;
c74184ed 3512
93e6958a 3513 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
9b8ef9f6
JK		 3514 if (sink->driver->ops && sink->driver->ops->startup) {
3515 ret = sink->driver->ops->startup(&substream, sink);
3516 if (ret < 0) {
3517 dev_err(sink->dev,
3518 "ASoC: startup() failed: %d\n", ret);
3519 goto out;
3520 }
3521 sink->active++;
3522 }
93e6958a
BC		 3523 ret = soc_dai_hw_params(&substream, params, sink);
3524 if (ret < 0)
3525 goto out;
c74184ed
MB		 3526 break;
3527
3528 case SND_SOC_DAPM_POST_PMU:
da18396f
MB		 3529 ret = snd_soc_dai_digital_mute(sink, 0,
3530 SNDRV_PCM_STREAM_PLAYBACK);
c74184ed 3531 if (ret != 0 && ret != -ENOTSUPP)
30a6a1a4 3532 dev_warn(sink->dev, "ASoC: Failed to unmute: %d\n", ret);
9747cec2 3533 ret = 0;
c74184ed
MB		 3534 break;
3535
3536 case SND_SOC_DAPM_PRE_PMD:
da18396f
MB		 3537 ret = snd_soc_dai_digital_mute(sink, 1,
3538 SNDRV_PCM_STREAM_PLAYBACK);
c74184ed 3539 if (ret != 0 && ret != -ENOTSUPP)
30a6a1a4 3540 dev_warn(sink->dev, "ASoC: Failed to mute: %d\n", ret);
9747cec2 3541 ret = 0;
9b8ef9f6
JK		 3542
3543 source->active--;
3544 if (source->driver->ops && source->driver->ops->shutdown) {
3545 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3546 source->driver->ops->shutdown(&substream, source);
3547 }
3548
3549 sink->active--;
3550 if (sink->driver->ops && sink->driver->ops->shutdown) {
3551 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
3552 sink->driver->ops->shutdown(&substream, sink);
3553 }
c74184ed
MB		 3554 break;
3555
3556 default:
a6ed0608 3557 WARN(1, "Unknown event %d\n", event);
75881df3 3558 ret = -EINVAL;
c74184ed
MB		 3559 }
3560
9747cec2
MB		 3561out:
3562 kfree(params);
3563 return ret;
c74184ed
MB		 3564}
3565
c6615082
NO		 3566static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
3567 struct snd_ctl_elem_value *ucontrol)
3568{
3569 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3570
3571 ucontrol->value.integer.value[0] = w->params_select;
3572
3573 return 0;
3574}
3575
3576static int snd_soc_dapm_dai_link_put(struct snd_kcontrol *kcontrol,
3577 struct snd_ctl_elem_value *ucontrol)
3578{
3579 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3580
3581 /* Can't change the config when widget is already powered */
3582 if (w->power)
3583 return -EBUSY;
3584
3585 if (ucontrol->value.integer.value[0] == w->params_select)
3586 return 0;
3587
3588 if (ucontrol->value.integer.value[0] >= w->num_params)
3589 return -EINVAL;
3590
3591 w->params_select = ucontrol->value.integer.value[0];
3592
3593 return 0;
3594}
3595
c74184ed
MB		 3596int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
3597 const struct snd_soc_pcm_stream *params,
c6615082 3598 unsigned int num_params,
c74184ed
MB		 3599 struct snd_soc_dapm_widget *source,
3600 struct snd_soc_dapm_widget *sink)
3601{
c74184ed
MB		 3602 struct snd_soc_dapm_widget template;
3603 struct snd_soc_dapm_widget *w;
c74184ed 3604 char *link_name;
c6615082
NO		 3605 int ret, count;
3606 unsigned long private_value;
3607 const char **w_param_text;
3608 struct soc_enum w_param_enum[] = {
3609 SOC_ENUM_SINGLE(0, 0, 0, NULL),
3610 };
3611 struct snd_kcontrol_new kcontrol_dai_link[] = {
3612 SOC_ENUM_EXT(NULL, w_param_enum[0],
3613 snd_soc_dapm_dai_link_get,
3614 snd_soc_dapm_dai_link_put),
3615 };
3616 const struct snd_soc_pcm_stream *config = params;
3617
3618 w_param_text = devm_kcalloc(card->dev, num_params,
3619 sizeof(char *), GFP_KERNEL);
3620 if (!w_param_text)
c74184ed 3621 return -ENOMEM;
c74184ed 3622
46172b6c
CK		 3623 link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
3624 source->name, sink->name);
c6615082
NO		 3625 if (!link_name) {
3626 ret = -ENOMEM;
3627 goto outfree_w_param;
3628 }
c74184ed 3629
c6615082
NO		 3630 for (count = 0 ; count < num_params; count++) {
3631 if (!config->stream_name) {
3632 dev_warn(card->dapm.dev,
3633 "ASoC: anonymous config %d for dai link %s\n",
3634 count, link_name);
c6615082 3635 w_param_text[count] =
46172b6c
CK		 3636 devm_kasprintf(card->dev, GFP_KERNEL,
3637 "Anonymous Configuration %d",
3638 count);
c6615082
NO		 3639 if (!w_param_text[count]) {
3640 ret = -ENOMEM;
3641 goto outfree_link_name;
3642 }
c6615082
NO		 3643 } else {
3644 w_param_text[count] = devm_kmemdup(card->dev,
3645 config->stream_name,
3646 strlen(config->stream_name) + 1,
3647 GFP_KERNEL);
3648 if (!w_param_text[count]) {
3649 ret = -ENOMEM;
3650 goto outfree_link_name;
3651 }
3652 }
3653 config++;
3654 }
3655 w_param_enum[0].items = num_params;
3656 w_param_enum[0].texts = w_param_text;
c74184ed
MB		 3657
3658 memset(&template, 0, sizeof(template));
3659 template.reg = SND_SOC_NOPM;
3660 template.id = snd_soc_dapm_dai_link;
3661 template.name = link_name;
3662 template.event = snd_soc_dai_link_event;
3663 template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
3664 SND_SOC_DAPM_PRE_PMD;
c6615082
NO		 3665 template.num_kcontrols = 1;
3666 /* duplicate w_param_enum on heap so that memory persists */
3667 private_value =
3668 (unsigned long) devm_kmemdup(card->dev,
3669 (void *)(kcontrol_dai_link[0].private_value),
3670 sizeof(struct soc_enum), GFP_KERNEL);
3671 if (!private_value) {
3672 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3673 link_name);
3674 ret = -ENOMEM;
3675 goto outfree_link_name;
3676 }
3677 kcontrol_dai_link[0].private_value = private_value;
3678 /* duplicate kcontrol_dai_link on heap so that memory persists */
3679 template.kcontrol_news =
3680 devm_kmemdup(card->dev, &kcontrol_dai_link[0],
3681 sizeof(struct snd_kcontrol_new),
3682 GFP_KERNEL);
3683 if (!template.kcontrol_news) {
3684 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3685 link_name);
3686 ret = -ENOMEM;
3687 goto outfree_private_value;
3688 }
c74184ed 3689
30a6a1a4 3690 dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
c74184ed 3691
02aa78ab 3692 w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
c74184ed 3693 if (!w) {
30a6a1a4 3694 dev_err(card->dev, "ASoC: Failed to create %s widget\n",
c74184ed 3695 link_name);
c6615082
NO		 3696 ret = -ENOMEM;
3697 goto outfree_kcontrol_news;
c74184ed
MB		 3698 }
3699
3700 w->params = params;
c6615082 3701 w->num_params = num_params;
c74184ed 3702
fe83897f
LPC		 3703 ret = snd_soc_dapm_add_path(&card->dapm, source, w, NULL, NULL);
3704 if (ret)
c6615082 3705 goto outfree_w;
fe83897f 3706 return snd_soc_dapm_add_path(&card->dapm, w, sink, NULL, NULL);
c6615082
NO		 3707
3708outfree_w:
3709 devm_kfree(card->dev, w);
3710outfree_kcontrol_news:
3711 devm_kfree(card->dev, (void *)template.kcontrol_news);
3712outfree_private_value:
3713 devm_kfree(card->dev, (void *)private_value);
3714outfree_link_name:
3715 devm_kfree(card->dev, link_name);
3716outfree_w_param:
3717 for (count = 0 ; count < num_params; count++)
3718 devm_kfree(card->dev, (void *)w_param_text[count]);
3719 devm_kfree(card->dev, w_param_text);
3720
3721 return ret;
c74184ed
MB		 3722}
3723
888df395
MB		 3724int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
3725 struct snd_soc_dai *dai)
2b97eabc 3726{
888df395 3727 struct snd_soc_dapm_widget template;
2b97eabc
RP		 3728 struct snd_soc_dapm_widget *w;
3729
888df395
MB		 3730 WARN_ON(dapm->dev != dai->dev);
3731
3732 memset(&template, 0, sizeof(template));
3733 template.reg = SND_SOC_NOPM;
3734
3735 if (dai->driver->playback.stream_name) {
4616274d 3736 template.id = snd_soc_dapm_dai_in;
888df395
MB		 3737 template.name = dai->driver->playback.stream_name;
3738 template.sname = dai->driver->playback.stream_name;
3739
30a6a1a4 3740 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
888df395
MB		 3741 template.name);
3742
02aa78ab 3743 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
888df395 3744 if (!w) {
30a6a1a4 3745 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
888df395 3746 dai->driver->playback.stream_name);
298402a3 3747 return -ENOMEM;
888df395
MB		 3748 }
3749
3750 w->priv = dai;
3751 dai->playback_widget = w;
3752 }
3753
3754 if (dai->driver->capture.stream_name) {
4616274d 3755 template.id = snd_soc_dapm_dai_out;
888df395
MB		 3756 template.name = dai->driver->capture.stream_name;
3757 template.sname = dai->driver->capture.stream_name;
3758
30a6a1a4 3759 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
888df395
MB		 3760 template.name);
3761
02aa78ab 3762 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
888df395 3763 if (!w) {
30a6a1a4 3764 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
888df395 3765 dai->driver->capture.stream_name);
298402a3 3766 return -ENOMEM;
888df395
MB		 3767 }
3768
3769 w->priv = dai;
3770 dai->capture_widget = w;
3771 }
3772
3773 return 0;
3774}
3775
3776int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
3777{
3778 struct snd_soc_dapm_widget *dai_w, *w;
0f9bd7b1 3779 struct snd_soc_dapm_widget *src, *sink;
888df395 3780 struct snd_soc_dai *dai;
888df395
MB		 3781
3782 /* For each DAI widget... */
3783 list_for_each_entry(dai_w, &card->widgets, list) {
4616274d
MB		 3784 switch (dai_w->id) {
3785 case snd_soc_dapm_dai_in:
3786 case snd_soc_dapm_dai_out:
3787 break;
3788 default:
2b97eabc 3789 continue;
4616274d 3790 }
888df395
MB		 3791
3792 dai = dai_w->priv;
3793
3794 /* ...find all widgets with the same stream and link them */
3795 list_for_each_entry(w, &card->widgets, list) {
3796 if (w->dapm != dai_w->dapm)
3797 continue;
3798
4616274d
MB		 3799 switch (w->id) {
3800 case snd_soc_dapm_dai_in:
3801 case snd_soc_dapm_dai_out:
888df395 3802 continue;
4616274d
MB		 3803 default:
3804 break;
3805 }
888df395 3806
a798c24a 3807 if (!w->sname || !strstr(w->sname, dai_w->sname))
888df395
MB		 3808 continue;
3809
0f9bd7b1
LPC		 3810 if (dai_w->id == snd_soc_dapm_dai_in) {
3811 src = dai_w;
3812 sink = w;
3813 } else {
3814 src = w;
3815 sink = dai_w;
2b97eabc 3816 }
0f9bd7b1
LPC		 3817 dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
3818 snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
2b97eabc
RP		 3819 }
3820 }
2b97eabc 3821
888df395
MB		 3822 return 0;
3823}
64a648c2 3824
44ba2641
BC		 3825static void dapm_connect_dai_link_widgets(struct snd_soc_card *card,
3826 struct snd_soc_pcm_runtime *rtd)
b893ea5f 3827{
44ba2641 3828 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
9887c20b 3829 struct snd_soc_dapm_widget *sink, *source;
b893ea5f
LG		 3830 int i;
3831
44ba2641
BC		 3832 for (i = 0; i < rtd->num_codecs; i++) {
3833 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
b893ea5f 3834
b893ea5f
LG		 3835 /* connect BE DAI playback if widgets are valid */
3836 if (codec_dai->playback_widget && cpu_dai->playback_widget) {
9887c20b
LPC		 3837 source = cpu_dai->playback_widget;
3838 sink = codec_dai->playback_widget;
b893ea5f 3839 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
f4333203
LPC		 3840 cpu_dai->component->name, source->name,
3841 codec_dai->component->name, sink->name);
b893ea5f 3842
9887c20b
LPC		 3843 snd_soc_dapm_add_path(&card->dapm, source, sink,
3844 NULL, NULL);
b893ea5f
LG		 3845 }
3846
3847 /* connect BE DAI capture if widgets are valid */
3848 if (codec_dai->capture_widget && cpu_dai->capture_widget) {
9887c20b
LPC		 3849 source = codec_dai->capture_widget;
3850 sink = cpu_dai->capture_widget;
b893ea5f 3851 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
f4333203
LPC		 3852 codec_dai->component->name, source->name,
3853 cpu_dai->component->name, sink->name);
b893ea5f 3854
9887c20b
LPC		 3855 snd_soc_dapm_add_path(&card->dapm, source, sink,
3856 NULL, NULL);
b893ea5f 3857 }
b893ea5f
LG		 3858 }
3859}
3860
c471fdd1 3861static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
d9b0951b 3862 int event)
2b97eabc 3863{
c471fdd1 3864 struct snd_soc_dapm_widget *w;
a3423b02 3865 unsigned int ep;
7bd3a6f3 3866
c471fdd1
LPC		 3867 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
3868 w = dai->playback_widget;
3869 else
3870 w = dai->capture_widget;
fe360685 3871
c471fdd1
LPC		 3872 if (w) {
3873 dapm_mark_dirty(w, "stream event");
d9b0951b 3874
a3423b02
LPC		 3875 if (w->id == snd_soc_dapm_dai_in) {
3876 ep = SND_SOC_DAPM_EP_SOURCE;
3877 dapm_widget_invalidate_input_paths(w);
3878 } else {
3879 ep = SND_SOC_DAPM_EP_SINK;
3880 dapm_widget_invalidate_output_paths(w);
3881 }
3882
d9b0951b
LG		 3883 switch (event) {
3884 case SND_SOC_DAPM_STREAM_START:
c471fdd1 3885 w->active = 1;
a3423b02 3886 w->is_ep = ep;
d9b0951b
LG		 3887 break;
3888 case SND_SOC_DAPM_STREAM_STOP:
c471fdd1 3889 w->active = 0;
a3423b02 3890 w->is_ep = 0;
d9b0951b
LG		 3891 break;
3892 case SND_SOC_DAPM_STREAM_SUSPEND:
3893 case SND_SOC_DAPM_STREAM_RESUME:
3894 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
3895 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
3896 break;
3897 }
3898 }
c471fdd1 3899}
d9b0951b 3900
44ba2641
BC		 3901void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
3902{
3903 struct snd_soc_pcm_runtime *rtd = card->rtd;
3904 int i;
3905
3906 /* for each BE DAI link... */
3907 for (i = 0; i < card->num_rtd; i++) {
3908 rtd = &card->rtd[i];
3909
3910 /*
3911 * dynamic FE links have no fixed DAI mapping.
3912 * CODEC<->CODEC links have no direct connection.
3913 */
3914 if (rtd->dai_link->dynamic || rtd->dai_link->params)
3915 continue;
3916
3917 dapm_connect_dai_link_widgets(card, rtd);
3918 }
3919}
3920
c471fdd1
LPC		 3921static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3922 int event)
3923{
44ba2641
BC		 3924 int i;
3925
c471fdd1 3926 soc_dapm_dai_stream_event(rtd->cpu_dai, stream, event);
44ba2641
BC		 3927 for (i = 0; i < rtd->num_codecs; i++)
3928 soc_dapm_dai_stream_event(rtd->codec_dais[i], stream, event);
2b97eabc 3929
95dd5cd6 3930 dapm_power_widgets(rtd->card, event);
ce6120cc
LG		 3931}
3932
3933/**
3934 * snd_soc_dapm_stream_event - send a stream event to the dapm core
3935 * @rtd: PCM runtime data
3936 * @stream: stream name
3937 * @event: stream event
3938 *
3939 * Sends a stream event to the dapm core. The core then makes any
3940 * necessary widget power changes.
3941 *
3942 * Returns 0 for success else error.
3943 */
d9b0951b
LG		 3944void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3945 int event)
ce6120cc 3946{
a73fb2df 3947 struct snd_soc_card *card = rtd->card;
ce6120cc 3948
3cd04343 3949 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
d9b0951b 3950 soc_dapm_stream_event(rtd, stream, event);
a73fb2df 3951 mutex_unlock(&card->dapm_mutex);
2b97eabc 3952}
2b97eabc 3953
11391100
CK		 3954/**
3955 * snd_soc_dapm_enable_pin_unlocked - enable pin.
3956 * @dapm: DAPM context
3957 * @pin: pin name
3958 *
3959 * Enables input/output pin and its parents or children widgets iff there is
3960 * a valid audio route and active audio stream.
3961 *
3962 * Requires external locking.
3963 *
3964 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3965 * do any widget power switching.
3966 */
3967int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
3968 const char *pin)
3969{
3970 return snd_soc_dapm_set_pin(dapm, pin, 1);
3971}
3972EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
3973
2b97eabc 3974/**
a5302181 3975 * snd_soc_dapm_enable_pin - enable pin.
ce6120cc 3976 * @dapm: DAPM context
a5302181 3977 * @pin: pin name
2b97eabc 3978 *
74b8f955 3979 * Enables input/output pin and its parents or children widgets iff there is
a5302181 3980 * a valid audio route and active audio stream.
11391100 3981 *
a5302181
LG		 3982 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3983 * do any widget power switching.
2b97eabc 3984 */
ce6120cc 3985int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
2b97eabc 3986{
11391100
CK		 3987 int ret;
3988
3989 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3990
3991 ret = snd_soc_dapm_set_pin(dapm, pin, 1);
3992
3993 mutex_unlock(&dapm->card->dapm_mutex);
3994
3995 return ret;
a5302181
LG		 3996}
3997EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
2b97eabc 3998
da34183e 3999/**
11391100 4000 * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
ce6120cc 4001 * @dapm: DAPM context
da34183e
MB		 4002 * @pin: pin name
4003 *
4004 * Enables input/output pin regardless of any other state. This is
4005 * intended for use with microphone bias supplies used in microphone
4006 * jack detection.
4007 *
11391100
CK		 4008 * Requires external locking.
4009 *
da34183e
MB		 4010 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4011 * do any widget power switching.
4012 */
11391100
CK		 4013int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4014 const char *pin)
da34183e 4015{
91a5fca4 4016 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
da34183e 4017
91a5fca4 4018 if (!w) {
30a6a1a4 4019 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
91a5fca4 4020 return -EINVAL;
0d86733c
MB		 4021 }
4022
30a6a1a4 4023 dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
92a99ea4
LPC		 4024 if (!w->connected) {
4025 /*
4026 * w->force does not affect the number of input or output paths,
4027 * so we only have to recheck if w->connected is changed
4028 */
4029 dapm_widget_invalidate_input_paths(w);
4030 dapm_widget_invalidate_output_paths(w);
4031 w->connected = 1;
4032 }
91a5fca4 4033 w->force = 1;
75c1f891 4034 dapm_mark_dirty(w, "force enable");
da34183e 4035
91a5fca4 4036 return 0;
da34183e 4037}
11391100
CK		 4038EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
4039
4040/**
4041 * snd_soc_dapm_force_enable_pin - force a pin to be enabled
4042 * @dapm: DAPM context
4043 * @pin: pin name
4044 *
4045 * Enables input/output pin regardless of any other state. This is
4046 * intended for use with microphone bias supplies used in microphone
4047 * jack detection.
4048 *
4049 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4050 * do any widget power switching.
4051 */
4052int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
4053 const char *pin)
4054{
4055 int ret;
4056
4057 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4058
4059 ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
4060
4061 mutex_unlock(&dapm->card->dapm_mutex);
4062
4063 return ret;
4064}
da34183e
MB		 4065EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
4066
11391100
CK		 4067/**
4068 * snd_soc_dapm_disable_pin_unlocked - disable pin.
4069 * @dapm: DAPM context
4070 * @pin: pin name
4071 *
4072 * Disables input/output pin and its parents or children widgets.
4073 *
4074 * Requires external locking.
4075 *
4076 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4077 * do any widget power switching.
4078 */
4079int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4080 const char *pin)
4081{
4082 return snd_soc_dapm_set_pin(dapm, pin, 0);
4083}
4084EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
4085
a5302181
LG		 4086/**
4087 * snd_soc_dapm_disable_pin - disable pin.
ce6120cc 4088 * @dapm: DAPM context
a5302181
LG		 4089 * @pin: pin name
4090 *
74b8f955 4091 * Disables input/output pin and its parents or children widgets.
11391100 4092 *
a5302181
LG		 4093 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4094 * do any widget power switching.
4095 */
ce6120cc
LG		 4096int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
4097 const char *pin)
a5302181 4098{
11391100
CK		 4099 int ret;
4100
4101 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4102
4103 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4104
4105 mutex_unlock(&dapm->card->dapm_mutex);
4106
4107 return ret;
2b97eabc 4108}
a5302181 4109EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
2b97eabc 4110
11391100
CK		 4111/**
4112 * snd_soc_dapm_nc_pin_unlocked - permanently disable pin.
4113 * @dapm: DAPM context
4114 * @pin: pin name
4115 *
4116 * Marks the specified pin as being not connected, disabling it along
4117 * any parent or child widgets. At present this is identical to
4118 * snd_soc_dapm_disable_pin() but in future it will be extended to do
4119 * additional things such as disabling controls which only affect
4120 * paths through the pin.
4121 *
4122 * Requires external locking.
4123 *
4124 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4125 * do any widget power switching.
4126 */
4127int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
4128 const char *pin)
4129{
4130 return snd_soc_dapm_set_pin(dapm, pin, 0);
4131}
4132EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
4133
5817b52a
MB		 4134/**
4135 * snd_soc_dapm_nc_pin - permanently disable pin.
ce6120cc 4136 * @dapm: DAPM context
5817b52a
MB		 4137 * @pin: pin name
4138 *
4139 * Marks the specified pin as being not connected, disabling it along
4140 * any parent or child widgets. At present this is identical to
4141 * snd_soc_dapm_disable_pin() but in future it will be extended to do
4142 * additional things such as disabling controls which only affect
4143 * paths through the pin.
4144 *
4145 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4146 * do any widget power switching.
4147 */
ce6120cc 4148int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
5817b52a 4149{
11391100
CK		 4150 int ret;
4151
4152 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4153
4154 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4155
4156 mutex_unlock(&dapm->card->dapm_mutex);
4157
4158 return ret;
5817b52a
MB		 4159}
4160EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
4161
eeec12bf 4162/**
a5302181 4163 * snd_soc_dapm_get_pin_status - get audio pin status
ce6120cc 4164 * @dapm: DAPM context
a5302181 4165 * @pin: audio signal pin endpoint (or start point)
eeec12bf 4166 *
a5302181 4167 * Get audio pin status - connected or disconnected.
eeec12bf 4168 *
a5302181 4169 * Returns 1 for connected otherwise 0.
eeec12bf 4170 */
ce6120cc
LG		 4171int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
4172 const char *pin)
eeec12bf 4173{
91a5fca4 4174 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
eeec12bf 4175
91a5fca4
LPC		 4176 if (w)
4177 return w->connected;
a68b38ad 4178
eeec12bf
GG		 4179 return 0;
4180}
a5302181 4181EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
eeec12bf 4182
1547aba9
MB		 4183/**
4184 * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
ce6120cc 4185 * @dapm: DAPM context
1547aba9
MB		 4186 * @pin: audio signal pin endpoint (or start point)
4187 *
4188 * Mark the given endpoint or pin as ignoring suspend. When the
4189 * system is disabled a path between two endpoints flagged as ignoring
4190 * suspend will not be disabled. The path must already be enabled via
4191 * normal means at suspend time, it will not be turned on if it was not
4192 * already enabled.
4193 */
ce6120cc
LG		 4194int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
4195 const char *pin)
1547aba9 4196{
91a5fca4 4197 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
1547aba9 4198
91a5fca4 4199 if (!w) {
30a6a1a4 4200 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
91a5fca4 4201 return -EINVAL;
1547aba9
MB		 4202 }
4203
91a5fca4
LPC		 4204 w->ignore_suspend = 1;
4205
4206 return 0;
1547aba9
MB		 4207}
4208EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
4209
2b97eabc
RP		 4210/**
4211 * snd_soc_dapm_free - free dapm resources
728a5222 4212 * @dapm: DAPM context
2b97eabc
RP		 4213 *
4214 * Free all dapm widgets and resources.
4215 */
ce6120cc 4216void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
2b97eabc 4217{
6c45e126 4218 dapm_debugfs_cleanup(dapm);
ce6120cc 4219 dapm_free_widgets(dapm);
7be31be8 4220 list_del(&dapm->list);
2b97eabc
RP		 4221}
4222EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
4223
57996358 4224static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
51737470 4225{
01005a72 4226 struct snd_soc_card *card = dapm->card;
51737470
MB		 4227 struct snd_soc_dapm_widget *w;
4228 LIST_HEAD(down_list);
4229 int powerdown = 0;
4230
01005a72
LG		 4231 mutex_lock(&card->dapm_mutex);
4232
97c866de
JN		 4233 list_for_each_entry(w, &dapm->card->widgets, list) {
4234 if (w->dapm != dapm)
4235 continue;
51737470 4236 if (w->power) {
828a842f 4237 dapm_seq_insert(w, &down_list, false);
c2caa4da 4238 w->power = 0;
51737470
MB		 4239 powerdown = 1;
4240 }
4241 }
4242
4243 /* If there were no widgets to power down we're already in
4244 * standby.
4245 */
4246 if (powerdown) {
7679e42e
MB		 4247 if (dapm->bias_level == SND_SOC_BIAS_ON)
4248 snd_soc_dapm_set_bias_level(dapm,
4249 SND_SOC_BIAS_PREPARE);
95dd5cd6 4250 dapm_seq_run(card, &down_list, 0, false);
7679e42e
MB		 4251 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
4252 snd_soc_dapm_set_bias_level(dapm,
4253 SND_SOC_BIAS_STANDBY);
51737470 4254 }
01005a72
LG		 4255
4256 mutex_unlock(&card->dapm_mutex);
f0fba2ad
LG		 4257}
4258
4259/*
4260 * snd_soc_dapm_shutdown - callback for system shutdown
4261 */
4262void snd_soc_dapm_shutdown(struct snd_soc_card *card)
4263{
57996358 4264 struct snd_soc_dapm_context *dapm;
f0fba2ad 4265
57996358 4266 list_for_each_entry(dapm, &card->dapm_list, list) {
17282ba4
XX		 4267 if (dapm != &card->dapm) {
4268 soc_dapm_shutdown_dapm(dapm);
4269 if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
4270 snd_soc_dapm_set_bias_level(dapm,
4271 SND_SOC_BIAS_OFF);
4272 }
ce6120cc 4273 }
17282ba4
XX		 4274
4275 soc_dapm_shutdown_dapm(&card->dapm);
4276 if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
4277 snd_soc_dapm_set_bias_level(&card->dapm,
4278 SND_SOC_BIAS_OFF);
51737470
MB		 4279}
4280
2b97eabc 4281/* Module information */
d331124d 4282MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
2b97eabc
RP		 4283MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
4284MODULE_LICENSE("GPL");