projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
nios2: fix __get_user()
[linux-2.6-block.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,
41d80025 313 struct snd_kcontrol *kcontrol, const char *ctrl_name)
e84357f7
LPC		 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
41d80025 336 name = kasprintf(GFP_KERNEL, "%s %s", ctrl_name,
773da9b3
CK		 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
41d80025 374 name = kasprintf(GFP_KERNEL, "%s %s", ctrl_name,
561ed680
CK		 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 873
41d80025 874 ret = dapm_kcontrol_data_alloc(w, kcontrol, name);
e84357f7
LPC		 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,
6742064a
PS		 1076 int (*fn)(struct snd_soc_dapm_widget *, struct list_head *,
1077 bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
1078 enum snd_soc_dapm_direction)),
1079 bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
1080 enum snd_soc_dapm_direction))
2b97eabc 1081{
a3423b02 1082 enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
2b97eabc
RP		 1083 struct snd_soc_dapm_path *path;
1084 int con = 0;
1085
a3423b02
LPC		 1086 if (widget->endpoints[dir] >= 0)
1087 return widget->endpoints[dir];
024dc078 1088
de02d078
MB		 1089 DAPM_UPDATE_STAT(widget, path_checks);
1090
1ce43acf
LPC		 1091 /* do we need to add this widget to the list ? */
1092 if (list)
1093 list_add_tail(&widget->work_list, list);
1094
09464974
JK		 1095 if (custom_stop_condition && custom_stop_condition(widget, dir)) {
1096 widget->endpoints[dir] = 1;
1097 return widget->endpoints[dir];
1098 }
6742064a 1099
a3423b02
LPC		 1100 if ((widget->is_ep & SND_SOC_DAPM_DIR_TO_EP(dir)) && widget->connected) {
1101 widget->endpoints[dir] = snd_soc_dapm_suspend_check(widget);
1102 return widget->endpoints[dir];
2b97eabc
RP		 1103 }
1104
a3423b02 1105 snd_soc_dapm_widget_for_each_path(widget, rdir, path) {
e56235e0
MB		 1106 DAPM_UPDATE_STAT(widget, neighbour_checks);
1107
c1862c8b 1108 if (path->weak || path->is_supply)
bf3a9e13
MB		 1109 continue;
1110
8af294b4
MB		 1111 if (path->walking)
1112 return 1;
1113
a3423b02 1114 trace_snd_soc_dapm_path(widget, dir, path);
ec2e3031 1115
7ddd4cd5 1116 if (path->connect) {
8af294b4 1117 path->walking = 1;
6742064a 1118 con += fn(path->node[dir], list, custom_stop_condition);
8af294b4 1119 path->walking = 0;
2b97eabc
RP		 1120 }
1121 }
1122
a3423b02 1123 widget->endpoints[dir] = con;
024dc078 1124
2b97eabc
RP		 1125 return con;
1126}
1127
a3423b02
LPC		 1128/*
1129 * Recursively check for a completed path to an active or physically connected
1130 * output widget. Returns number of complete paths.
6742064a
PS		 1131 *
1132 * Optionally, can be supplied with a function acting as a stopping condition.
1133 * This function takes the dapm widget currently being examined and the walk
1134 * direction as an arguments, it should return true if the walk should be
1135 * stopped and false otherwise.
a3423b02
LPC		 1136 */
1137static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
6742064a
PS		 1138 struct list_head *list,
1139 bool (*custom_stop_condition)(struct snd_soc_dapm_widget *i,
1140 enum snd_soc_dapm_direction))
a3423b02
LPC		 1141{
1142 return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_OUT,
6742064a 1143 is_connected_output_ep, custom_stop_condition);
a3423b02
LPC		 1144}
1145
2b97eabc
RP		 1146/*
1147 * Recursively check for a completed path to an active or physically connected
1148 * input widget. Returns number of complete paths.
6742064a
PS		 1149 *
1150 * Optionally, can be supplied with a function acting as a stopping condition.
1151 * This function takes the dapm widget currently being examined and the walk
1152 * direction as an arguments, it should return true if the walk should be
1153 * stopped and false otherwise.
2b97eabc 1154 */
ec2e3031 1155static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
6742064a
PS		 1156 struct list_head *list,
1157 bool (*custom_stop_condition)(struct snd_soc_dapm_widget *i,
1158 enum snd_soc_dapm_direction))
2b97eabc 1159{
a3423b02 1160 return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_IN,
6742064a 1161 is_connected_input_ep, custom_stop_condition);
2b97eabc
RP		 1162}
1163
ec2e3031
LG		 1164/**
1165 * snd_soc_dapm_get_connected_widgets - query audio path and it's widgets.
1166 * @dai: the soc DAI.
1167 * @stream: stream direction.
1168 * @list: list of active widgets for this stream.
6742064a
PS		 1169 * @custom_stop_condition: (optional) a function meant to stop the widget graph
1170 * walk based on custom logic.
ec2e3031
LG		 1171 *
1172 * Queries DAPM graph as to whether an valid audio stream path exists for
1173 * the initial stream specified by name. This takes into account
1174 * current mixer and mux kcontrol settings. Creates list of valid widgets.
1175 *
6742064a
PS		 1176 * Optionally, can be supplied with a function acting as a stopping condition.
1177 * This function takes the dapm widget currently being examined and the walk
1178 * direction as an arguments, it should return true if the walk should be
1179 * stopped and false otherwise.
1180 *
ec2e3031
LG		 1181 * Returns the number of valid paths or negative error.
1182 */
1183int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
6742064a
PS		 1184 struct snd_soc_dapm_widget_list **list,
1185 bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
1186 enum snd_soc_dapm_direction))
ec2e3031 1187{
313665b9 1188 struct snd_soc_card *card = dai->component->card;
92a99ea4 1189 struct snd_soc_dapm_widget *w;
1ce43acf 1190 LIST_HEAD(widgets);
ec2e3031 1191 int paths;
1ce43acf 1192 int ret;
ec2e3031
LG		 1193
1194 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
92a99ea4
LPC		 1195
1196 /*
1197 * For is_connected_{output,input}_ep fully discover the graph we need
1198 * to reset the cached number of inputs and outputs.
1199 */
1200 list_for_each_entry(w, &card->widgets, list) {
a3423b02
LPC		 1201 w->endpoints[SND_SOC_DAPM_DIR_IN] = -1;
1202 w->endpoints[SND_SOC_DAPM_DIR_OUT] = -1;
92a99ea4 1203 }
ec2e3031 1204
130897ac 1205 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
6742064a
PS		 1206 paths = is_connected_output_ep(dai->playback_widget, &widgets,
1207 custom_stop_condition);
130897ac 1208 else
6742064a
PS		 1209 paths = is_connected_input_ep(dai->capture_widget, &widgets,
1210 custom_stop_condition);
1ce43acf
LPC		 1211
1212 /* Drop starting point */
1213 list_del(widgets.next);
1214
1215 ret = dapm_widget_list_create(list, &widgets);
1216 if (ret)
30abbe77 1217 paths = ret;
ec2e3031
LG		 1218
1219 trace_snd_soc_dapm_connected(paths, stream);
ec2e3031
LG		 1220 mutex_unlock(&card->dapm_mutex);
1221
1222 return paths;
1223}
1224
62ea874a
MB		 1225/*
1226 * Handler for regulator supply widget.
1227 */
1228int dapm_regulator_event(struct snd_soc_dapm_widget *w,
1229 struct snd_kcontrol *kcontrol, int event)
1230{
c05b84d1
MB		 1231 int ret;
1232
eb270e98
MB		 1233 soc_dapm_async_complete(w->dapm);
1234
c05b84d1 1235 if (SND_SOC_DAPM_EVENT_ON(event)) {
de9ba98b 1236 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
8784c77a 1237 ret = regulator_allow_bypass(w->regulator, false);
c05b84d1
MB		 1238 if (ret != 0)
1239 dev_warn(w->dapm->dev,
30686c35 1240 "ASoC: Failed to unbypass %s: %d\n",
c05b84d1
MB		 1241 w->name, ret);
1242 }
1243
a3cc056b 1244 return regulator_enable(w->regulator);
c05b84d1 1245 } else {
de9ba98b 1246 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
8784c77a 1247 ret = regulator_allow_bypass(w->regulator, true);
c05b84d1
MB		 1248 if (ret != 0)
1249 dev_warn(w->dapm->dev,
30686c35 1250 "ASoC: Failed to bypass %s: %d\n",
c05b84d1
MB		 1251 w->name, ret);
1252 }
1253
a3cc056b 1254 return regulator_disable_deferred(w->regulator, w->shift);
c05b84d1 1255 }
62ea874a
MB		 1256}
1257EXPORT_SYMBOL_GPL(dapm_regulator_event);
1258
d7e7eb91
OL		 1259/*
1260 * Handler for clock supply widget.
1261 */
1262int dapm_clock_event(struct snd_soc_dapm_widget *w,
1263 struct snd_kcontrol *kcontrol, int event)
1264{
1265 if (!w->clk)
1266 return -EIO;
1267
eb270e98
MB		 1268 soc_dapm_async_complete(w->dapm);
1269
ec02995a 1270#ifdef CONFIG_HAVE_CLK
d7e7eb91 1271 if (SND_SOC_DAPM_EVENT_ON(event)) {
37c1b927 1272 return clk_prepare_enable(w->clk);
d7e7eb91 1273 } else {
37c1b927 1274 clk_disable_unprepare(w->clk);
d7e7eb91
OL		 1275 return 0;
1276 }
ec02995a 1277#endif
98b3cf12 1278 return 0;
d7e7eb91
OL		 1279}
1280EXPORT_SYMBOL_GPL(dapm_clock_event);
1281
d805002b
MB		 1282static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1283{
9b8a83b2
MB		 1284 if (w->power_checked)
1285 return w->new_power;
1286
d805002b 1287 if (w->force)
9b8a83b2 1288 w->new_power = 1;
d805002b 1289 else
9b8a83b2
MB		 1290 w->new_power = w->power_check(w);
1291
1292 w->power_checked = true;
1293
1294 return w->new_power;
d805002b
MB		 1295}
1296
cd0f2d47
MB		 1297/* Generic check to see if a widget should be powered.
1298 */
1299static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1300{
1301 int in, out;
1302
de02d078
MB		 1303 DAPM_UPDATE_STAT(w, power_checks);
1304
6742064a
PS		 1305 in = is_connected_input_ep(w, NULL, NULL);
1306 out = is_connected_output_ep(w, NULL, NULL);
cd0f2d47
MB		 1307 return out != 0 && in != 0;
1308}
1309
246d0a17
MB		 1310/* Check to see if a power supply is needed */
1311static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1312{
1313 struct snd_soc_dapm_path *path;
246d0a17 1314
de02d078
MB		 1315 DAPM_UPDATE_STAT(w, power_checks);
1316
246d0a17 1317 /* Check if one of our outputs is connected */
e63bfd45 1318 snd_soc_dapm_widget_for_each_sink_path(w, path) {
a8fdac83
MB		 1319 DAPM_UPDATE_STAT(w, neighbour_checks);
1320
bf3a9e13
MB		 1321 if (path->weak)
1322 continue;
1323
215edda3
MB		 1324 if (path->connected &&
1325 !path->connected(path->source, path->sink))
1326 continue;
1327
f68d7e16
MB		 1328 if (dapm_widget_power_check(path->sink))
1329 return 1;
246d0a17
MB		 1330 }
1331
f68d7e16 1332 return 0;
246d0a17
MB		 1333}
1334
35c64bca
MB		 1335static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1336{
20bb0184 1337 return w->connected;
35c64bca
MB		 1338}
1339
38357ab2
MB		 1340static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
1341 struct snd_soc_dapm_widget *b,
828a842f 1342 bool power_up)
42aa3418 1343{
828a842f
MB		 1344 int *sort;
1345
1346 if (power_up)
1347 sort = dapm_up_seq;
1348 else
1349 sort = dapm_down_seq;
1350
38357ab2
MB		 1351 if (sort[a->id] != sort[b->id])
1352 return sort[a->id] - sort[b->id];
20e4859d
MB		 1353 if (a->subseq != b->subseq) {
1354 if (power_up)
1355 return a->subseq - b->subseq;
1356 else
1357 return b->subseq - a->subseq;
1358 }
b22ead2a
MB		 1359 if (a->reg != b->reg)
1360 return a->reg - b->reg;
84dab567
MB		 1361 if (a->dapm != b->dapm)
1362 return (unsigned long)a->dapm - (unsigned long)b->dapm;
42aa3418 1363
38357ab2
MB		 1364 return 0;
1365}
42aa3418 1366
38357ab2
MB		 1367/* Insert a widget in order into a DAPM power sequence. */
1368static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
1369 struct list_head *list,
828a842f 1370 bool power_up)
38357ab2
MB		 1371{
1372 struct snd_soc_dapm_widget *w;
1373
1374 list_for_each_entry(w, list, power_list)
828a842f 1375 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
38357ab2
MB		 1376 list_add_tail(&new_widget->power_list, &w->power_list);
1377 return;
1378 }
1379
1380 list_add_tail(&new_widget->power_list, list);
1381}
1382
95dd5cd6 1383static void dapm_seq_check_event(struct snd_soc_card *card,
68f89ad8
MB		 1384 struct snd_soc_dapm_widget *w, int event)
1385{
68f89ad8
MB		 1386 const char *ev_name;
1387 int power, ret;
1388
1389 switch (event) {
1390 case SND_SOC_DAPM_PRE_PMU:
1391 ev_name = "PRE_PMU";
1392 power = 1;
1393 break;
1394 case SND_SOC_DAPM_POST_PMU:
1395 ev_name = "POST_PMU";
1396 power = 1;
1397 break;
1398 case SND_SOC_DAPM_PRE_PMD:
1399 ev_name = "PRE_PMD";
1400 power = 0;
1401 break;
1402 case SND_SOC_DAPM_POST_PMD:
1403 ev_name = "POST_PMD";
1404 power = 0;
1405 break;
80114129
MB		 1406 case SND_SOC_DAPM_WILL_PMU:
1407 ev_name = "WILL_PMU";
1408 power = 1;
1409 break;
1410 case SND_SOC_DAPM_WILL_PMD:
1411 ev_name = "WILL_PMD";
1412 power = 0;
1413 break;
68f89ad8 1414 default:
a6ed0608 1415 WARN(1, "Unknown event %d\n", event);
68f89ad8
MB		 1416 return;
1417 }
1418
39eb5fd1 1419 if (w->new_power != power)
68f89ad8
MB		 1420 return;
1421
1422 if (w->event && (w->event_flags & event)) {
95dd5cd6 1423 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
68f89ad8 1424 w->name, ev_name);
eb270e98 1425 soc_dapm_async_complete(w->dapm);
84e90930 1426 trace_snd_soc_dapm_widget_event_start(w, event);
68f89ad8 1427 ret = w->event(w, NULL, event);
84e90930 1428 trace_snd_soc_dapm_widget_event_done(w, event);
68f89ad8 1429 if (ret < 0)
95dd5cd6 1430 dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
68f89ad8
MB		 1431 ev_name, w->name, ret);
1432 }
1433}
1434
b22ead2a 1435/* Apply the coalesced changes from a DAPM sequence */
95dd5cd6 1436static void dapm_seq_run_coalesced(struct snd_soc_card *card,
b22ead2a 1437 struct list_head *pending)
163cac06 1438{
ce0fc93a 1439 struct snd_soc_dapm_context *dapm;
68f89ad8 1440 struct snd_soc_dapm_widget *w;
de9ba98b 1441 int reg;
b22ead2a
MB		 1442 unsigned int value = 0;
1443 unsigned int mask = 0;
b22ead2a 1444
ce0fc93a
LPC		 1445 w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
1446 reg = w->reg;
1447 dapm = w->dapm;
b22ead2a
MB		 1448
1449 list_for_each_entry(w, pending, power_list) {
ce0fc93a 1450 WARN_ON(reg != w->reg || dapm != w->dapm);
39eb5fd1 1451 w->power = w->new_power;
b22ead2a 1452
de9ba98b
LPC		 1453 mask |= w->mask << w->shift;
1454 if (w->power)
1455 value |= w->on_val << w->shift;
b22ead2a 1456 else
de9ba98b 1457 value |= w->off_val << w->shift;
b22ead2a 1458
ce0fc93a 1459 pop_dbg(dapm->dev, card->pop_time,
b22ead2a
MB		 1460 "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1461 w->name, reg, value, mask);
81628103 1462
68f89ad8 1463 /* Check for events */
95dd5cd6
LPC		 1464 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
1465 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
81628103
MB		 1466 }
1467
1468 if (reg >= 0) {
29376bc7
MB		 1469 /* Any widget will do, they should all be updating the
1470 * same register.
1471 */
29376bc7 1472
ce0fc93a 1473 pop_dbg(dapm->dev, card->pop_time,
81628103 1474 "pop test : Applying 0x%x/0x%x to %x in %dms\n",
3a45b867
JN		 1475 value, mask, reg, card->pop_time);
1476 pop_wait(card->pop_time);
ce0fc93a 1477 soc_dapm_update_bits(dapm, reg, mask, value);
b22ead2a
MB		 1478 }
1479
81628103 1480 list_for_each_entry(w, pending, power_list) {
95dd5cd6
LPC		 1481 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
1482 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
81628103 1483 }
b22ead2a 1484}
42aa3418 1485
b22ead2a
MB		 1486/* Apply a DAPM power sequence.
1487 *
1488 * We walk over a pre-sorted list of widgets to apply power to. In
1489 * order to minimise the number of writes to the device required
1490 * multiple widgets will be updated in a single write where possible.
1491 * Currently anything that requires more than a single write is not
1492 * handled.
1493 */
95dd5cd6
LPC		 1494static void dapm_seq_run(struct snd_soc_card *card,
1495 struct list_head *list, int event, bool power_up)
b22ead2a
MB		 1496{
1497 struct snd_soc_dapm_widget *w, *n;
eb270e98 1498 struct snd_soc_dapm_context *d;
b22ead2a
MB		 1499 LIST_HEAD(pending);
1500 int cur_sort = -1;
20e4859d 1501 int cur_subseq = -1;
b22ead2a 1502 int cur_reg = SND_SOC_NOPM;
7be31be8 1503 struct snd_soc_dapm_context *cur_dapm = NULL;
474b62d6 1504 int ret, i;
828a842f
MB		 1505 int *sort;
1506
1507 if (power_up)
1508 sort = dapm_up_seq;
1509 else
1510 sort = dapm_down_seq;
163cac06 1511
b22ead2a
MB		 1512 list_for_each_entry_safe(w, n, list, power_list) {
1513 ret = 0;
1514
1515 /* Do we need to apply any queued changes? */
7be31be8 1516 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
20e4859d 1517 w->dapm != cur_dapm || w->subseq != cur_subseq) {
b22ead2a 1518 if (!list_empty(&pending))
95dd5cd6 1519 dapm_seq_run_coalesced(card, &pending);
b22ead2a 1520
474b62d6
MB		 1521 if (cur_dapm && cur_dapm->seq_notifier) {
1522 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1523 if (sort[i] == cur_sort)
1524 cur_dapm->seq_notifier(cur_dapm,
f85a9e0d
MB		 1525 i,
1526 cur_subseq);
474b62d6
MB		 1527 }
1528
eb270e98
MB		 1529 if (cur_dapm && w->dapm != cur_dapm)
1530 soc_dapm_async_complete(cur_dapm);
1531
b22ead2a
MB		 1532 INIT_LIST_HEAD(&pending);
1533 cur_sort = -1;
b0b3e6f8 1534 cur_subseq = INT_MIN;
b22ead2a 1535 cur_reg = SND_SOC_NOPM;
7be31be8 1536 cur_dapm = NULL;
b22ead2a
MB		 1537 }
1538
163cac06
MB		 1539 switch (w->id) {
1540 case snd_soc_dapm_pre:
1541 if (!w->event)
b22ead2a
MB		 1542 list_for_each_entry_safe_continue(w, n, list,
1543 power_list);
163cac06 1544
b22ead2a 1545 if (event == SND_SOC_DAPM_STREAM_START)
163cac06
MB		 1546 ret = w->event(w,
1547 NULL, SND_SOC_DAPM_PRE_PMU);
b22ead2a 1548 else if (event == SND_SOC_DAPM_STREAM_STOP)
163cac06
MB		 1549 ret = w->event(w,
1550 NULL, SND_SOC_DAPM_PRE_PMD);
163cac06
MB		 1551 break;
1552
1553 case snd_soc_dapm_post:
1554 if (!w->event)
b22ead2a
MB		 1555 list_for_each_entry_safe_continue(w, n, list,
1556 power_list);
163cac06 1557
b22ead2a 1558 if (event == SND_SOC_DAPM_STREAM_START)
163cac06
MB		 1559 ret = w->event(w,
1560 NULL, SND_SOC_DAPM_POST_PMU);
b22ead2a 1561 else if (event == SND_SOC_DAPM_STREAM_STOP)
163cac06
MB		 1562 ret = w->event(w,
1563 NULL, SND_SOC_DAPM_POST_PMD);
163cac06
MB		 1564 break;
1565
b22ead2a 1566 default:
81628103
MB		 1567 /* Queue it up for application */
1568 cur_sort = sort[w->id];
20e4859d 1569 cur_subseq = w->subseq;
81628103 1570 cur_reg = w->reg;
7be31be8 1571 cur_dapm = w->dapm;
81628103
MB		 1572 list_move(&w->power_list, &pending);
1573 break;
163cac06 1574 }
b22ead2a
MB		 1575
1576 if (ret < 0)
f7d41ae8 1577 dev_err(w->dapm->dev,
30a6a1a4 1578 "ASoC: Failed to apply widget power: %d\n", ret);
6ea31b9f 1579 }
b22ead2a
MB		 1580
1581 if (!list_empty(&pending))
95dd5cd6 1582 dapm_seq_run_coalesced(card, &pending);
474b62d6
MB		 1583
1584 if (cur_dapm && cur_dapm->seq_notifier) {
1585 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1586 if (sort[i] == cur_sort)
1587 cur_dapm->seq_notifier(cur_dapm,
f85a9e0d 1588 i, cur_subseq);
474b62d6 1589 }
eb270e98
MB		 1590
1591 list_for_each_entry(d, &card->dapm_list, list) {
1592 soc_dapm_async_complete(d);
1593 }
42aa3418
MB		 1594}
1595
95dd5cd6 1596static void dapm_widget_update(struct snd_soc_card *card)
97404f2e 1597{
95dd5cd6 1598 struct snd_soc_dapm_update *update = card->update;
ce6cfaf1
LPC		 1599 struct snd_soc_dapm_widget_list *wlist;
1600 struct snd_soc_dapm_widget *w = NULL;
1601 unsigned int wi;
97404f2e
MB		 1602 int ret;
1603
57295073 1604 if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
97404f2e
MB		 1605 return;
1606
e84357f7 1607 wlist = dapm_kcontrol_get_wlist(update->kcontrol);
97404f2e 1608
ce6cfaf1
LPC		 1609 for (wi = 0; wi < wlist->num_widgets; wi++) {
1610 w = wlist->widgets[wi];
1611
1612 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1613 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1614 if (ret != 0)
95dd5cd6 1615 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
ce6cfaf1
LPC		 1616 w->name, ret);
1617 }
97404f2e
MB		 1618 }
1619
ce6cfaf1
LPC		 1620 if (!w)
1621 return;
1622
ce0fc93a
LPC		 1623 ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
1624 update->val);
97404f2e 1625 if (ret < 0)
95dd5cd6 1626 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
30a6a1a4 1627 w->name, ret);
97404f2e 1628
ce6cfaf1
LPC		 1629 for (wi = 0; wi < wlist->num_widgets; wi++) {
1630 w = wlist->widgets[wi];
1631
1632 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1633 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1634 if (ret != 0)
95dd5cd6 1635 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
ce6cfaf1
LPC		 1636 w->name, ret);
1637 }
97404f2e
MB		 1638 }
1639}
1640
9d0624a7
MB		 1641/* Async callback run prior to DAPM sequences - brings to _PREPARE if
1642 * they're changing state.
1643 */
1644static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1645{
1646 struct snd_soc_dapm_context *d = data;
1647 int ret;
1648
56fba41f
MB		 1649 /* If we're off and we're not supposed to be go into STANDBY */
1650 if (d->bias_level == SND_SOC_BIAS_OFF &&
1651 d->target_bias_level != SND_SOC_BIAS_OFF) {
f1aac484
MB		 1652 if (d->dev)
1653 pm_runtime_get_sync(d->dev);
1654
9d0624a7
MB		 1655 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1656 if (ret != 0)
1657 dev_err(d->dev,
30a6a1a4 1658 "ASoC: Failed to turn on bias: %d\n", ret);
9d0624a7
MB		 1659 }
1660
ce85a4d7
LPC		 1661 /* Prepare for a transition to ON or away from ON */
1662 if ((d->target_bias_level == SND_SOC_BIAS_ON &&
1663 d->bias_level != SND_SOC_BIAS_ON) ||
1664 (d->target_bias_level != SND_SOC_BIAS_ON &&
1665 d->bias_level == SND_SOC_BIAS_ON)) {
9d0624a7
MB		 1666 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1667 if (ret != 0)
1668 dev_err(d->dev,
30a6a1a4 1669 "ASoC: Failed to prepare bias: %d\n", ret);
9d0624a7
MB		 1670 }
1671}
1672
1673/* Async callback run prior to DAPM sequences - brings to their final
1674 * state.
1675 */
1676static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1677{
1678 struct snd_soc_dapm_context *d = data;
1679 int ret;
1680
1681 /* If we just powered the last thing off drop to standby bias */
56fba41f
MB		 1682 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1683 (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1684 d->target_bias_level == SND_SOC_BIAS_OFF)) {
9d0624a7
MB		 1685 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1686 if (ret != 0)
30a6a1a4 1687 dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
9d0624a7
MB		 1688 ret);
1689 }
97404f2e 1690
9d0624a7 1691 /* If we're in standby and can support bias off then do that */
56fba41f
MB		 1692 if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1693 d->target_bias_level == SND_SOC_BIAS_OFF) {
9d0624a7
MB		 1694 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1695 if (ret != 0)
30a6a1a4
LG		 1696 dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
1697 ret);
f1aac484
MB		 1698
1699 if (d->dev)
fb644e9c 1700 pm_runtime_put(d->dev);
9d0624a7
MB		 1701 }
1702
1703 /* If we just powered up then move to active bias */
56fba41f
MB		 1704 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1705 d->target_bias_level == SND_SOC_BIAS_ON) {
9d0624a7
MB		 1706 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1707 if (ret != 0)
30a6a1a4 1708 dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
9d0624a7
MB		 1709 ret);
1710 }
1711}
97404f2e 1712
fe4fda5d
MB		 1713static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
1714 bool power, bool connect)
1715{
1716 /* If a connection is being made or broken then that update
1717 * will have marked the peer dirty, otherwise the widgets are
1718 * not connected and this update has no impact. */
1719 if (!connect)
1720 return;
1721
1722 /* If the peer is already in the state we're moving to then we
1723 * won't have an impact on it. */
1724 if (power != peer->power)
75c1f891 1725 dapm_mark_dirty(peer, "peer state change");
fe4fda5d
MB		 1726}
1727
05623c43
MB		 1728static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
1729 struct list_head *up_list,
1730 struct list_head *down_list)
1731{
db432b41
MB		 1732 struct snd_soc_dapm_path *path;
1733
05623c43
MB		 1734 if (w->power == power)
1735 return;
1736
1737 trace_snd_soc_dapm_widget_power(w, power);
1738
db432b41 1739 /* If we changed our power state perhaps our neigbours changed
fe4fda5d 1740 * also.
db432b41 1741 */
e63bfd45 1742 snd_soc_dapm_widget_for_each_source_path(w, path)
7ddd4cd5
LPC		 1743 dapm_widget_set_peer_power(path->source, power, path->connect);
1744
6dd98b0a
LPC		 1745 /* Supplies can't affect their outputs, only their inputs */
1746 if (!w->is_supply) {
e63bfd45 1747 snd_soc_dapm_widget_for_each_sink_path(w, path)
7ddd4cd5
LPC		 1748 dapm_widget_set_peer_power(path->sink, power,
1749 path->connect);
db432b41
MB		 1750 }
1751
05623c43
MB		 1752 if (power)
1753 dapm_seq_insert(w, up_list, true);
1754 else
1755 dapm_seq_insert(w, down_list, false);
05623c43
MB		 1756}
1757
7c81beb0
MB		 1758static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1759 struct list_head *up_list,
1760 struct list_head *down_list)
1761{
7c81beb0
MB		 1762 int power;
1763
1764 switch (w->id) {
1765 case snd_soc_dapm_pre:
1766 dapm_seq_insert(w, down_list, false);
1767 break;
1768 case snd_soc_dapm_post:
1769 dapm_seq_insert(w, up_list, true);
1770 break;
1771
1772 default:
d805002b 1773 power = dapm_widget_power_check(w);
7c81beb0 1774
05623c43 1775 dapm_widget_set_power(w, power, up_list, down_list);
7c81beb0
MB		 1776 break;
1777 }
1778}
1779
86dbf2ac
LPC		 1780static bool dapm_idle_bias_off(struct snd_soc_dapm_context *dapm)
1781{
1782 if (dapm->idle_bias_off)
1783 return true;
1784
1785 switch (snd_power_get_state(dapm->card->snd_card)) {
1786 case SNDRV_CTL_POWER_D3hot:
1787 case SNDRV_CTL_POWER_D3cold:
1788 return dapm->suspend_bias_off;
1789 default:
1790 break;
1791 }
1792
1793 return false;
1794}
1795
2b97eabc
RP		 1796/*
1797 * Scan each dapm widget for complete audio path.
1798 * A complete path is a route that has valid endpoints i.e.:-
1799 *
1800 * o DAC to output pin.
1801 * o Input Pin to ADC.
1802 * o Input pin to Output pin (bypass, sidetone)
1803 * o DAC to ADC (loopback).
1804 */
95dd5cd6 1805static int dapm_power_widgets(struct snd_soc_card *card, int event)
2b97eabc
RP		 1806{
1807 struct snd_soc_dapm_widget *w;
7be31be8 1808 struct snd_soc_dapm_context *d;
291f3bbc
MB		 1809 LIST_HEAD(up_list);
1810 LIST_HEAD(down_list);
2955b47d 1811 ASYNC_DOMAIN_EXCLUSIVE(async_domain);
56fba41f 1812 enum snd_soc_bias_level bias;
6d3ddc81 1813
f9fa2b18
MB		 1814 lockdep_assert_held(&card->dapm_mutex);
1815
84e90930
MB		 1816 trace_snd_soc_dapm_start(card);
1817
56fba41f 1818 list_for_each_entry(d, &card->dapm_list, list) {
86dbf2ac 1819 if (dapm_idle_bias_off(d))
497098be
MB		 1820 d->target_bias_level = SND_SOC_BIAS_OFF;
1821 else
1822 d->target_bias_level = SND_SOC_BIAS_STANDBY;
56fba41f 1823 }
7be31be8 1824
6c120e19 1825 dapm_reset(card);
9b8a83b2 1826
6d3ddc81 1827 /* Check which widgets we need to power and store them in
db432b41
MB		 1828 * lists indicating if they should be powered up or down. We
1829 * only check widgets that have been flagged as dirty but note
1830 * that new widgets may be added to the dirty list while we
1831 * iterate.
6d3ddc81 1832 */
db432b41 1833 list_for_each_entry(w, &card->dapm_dirty, dirty) {
7c81beb0 1834 dapm_power_one_widget(w, &up_list, &down_list);
2b97eabc
RP		 1835 }
1836
f9de6d74 1837 list_for_each_entry(w, &card->widgets, list) {
0ff97ebf
MB		 1838 switch (w->id) {
1839 case snd_soc_dapm_pre:
1840 case snd_soc_dapm_post:
1841 /* These widgets always need to be powered */
1842 break;
1843 default:
1844 list_del_init(&w->dirty);
1845 break;
1846 }
db432b41 1847
39eb5fd1 1848 if (w->new_power) {
f9de6d74
MB		 1849 d = w->dapm;
1850
1851 /* Supplies and micbiases only bring the
1852 * context up to STANDBY as unless something
1853 * else is active and passing audio they
afe62367
MB		 1854 * generally don't require full power. Signal
1855 * generators are virtual pins and have no
1856 * power impact themselves.
f9de6d74
MB		 1857 */
1858 switch (w->id) {
afe62367 1859 case snd_soc_dapm_siggen:
da83fea6 1860 case snd_soc_dapm_vmid:
afe62367 1861 break;
f9de6d74 1862 case snd_soc_dapm_supply:
62ea874a 1863 case snd_soc_dapm_regulator_supply:
d7e7eb91 1864 case snd_soc_dapm_clock_supply:
f9de6d74
MB		 1865 case snd_soc_dapm_micbias:
1866 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
1867 d->target_bias_level = SND_SOC_BIAS_STANDBY;
1868 break;
1869 default:
1870 d->target_bias_level = SND_SOC_BIAS_ON;
1871 break;
1872 }
1873 }
1874
1875 }
1876
85a843c5
MB		 1877 /* Force all contexts in the card to the same bias state if
1878 * they're not ground referenced.
1879 */
56fba41f 1880 bias = SND_SOC_BIAS_OFF;
52ba67bf 1881 list_for_each_entry(d, &card->dapm_list, list)
56fba41f
MB		 1882 if (d->target_bias_level > bias)
1883 bias = d->target_bias_level;
52ba67bf 1884 list_for_each_entry(d, &card->dapm_list, list)
86dbf2ac 1885 if (!dapm_idle_bias_off(d))
85a843c5 1886 d->target_bias_level = bias;
52ba67bf 1887
de02d078 1888 trace_snd_soc_dapm_walk_done(card);
52ba67bf 1889
17282ba4
XX		 1890 /* Run card bias changes at first */
1891 dapm_pre_sequence_async(&card->dapm, 0);
1892 /* Run other bias changes in parallel */
1893 list_for_each_entry(d, &card->dapm_list, list) {
1894 if (d != &card->dapm)
1895 async_schedule_domain(dapm_pre_sequence_async, d,
1896 &async_domain);
1897 }
9d0624a7 1898 async_synchronize_full_domain(&async_domain);
452c5eaa 1899
cf1f7c6e 1900 list_for_each_entry(w, &down_list, power_list) {
95dd5cd6 1901 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
80114129
MB		 1902 }
1903
cf1f7c6e 1904 list_for_each_entry(w, &up_list, power_list) {
95dd5cd6 1905 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
80114129
MB		 1906 }
1907
6d3ddc81 1908 /* Power down widgets first; try to avoid amplifying pops. */
95dd5cd6 1909 dapm_seq_run(card, &down_list, event, false);
2b97eabc 1910
95dd5cd6 1911 dapm_widget_update(card);
97404f2e 1912
6d3ddc81 1913 /* Now power up. */
95dd5cd6 1914 dapm_seq_run(card, &up_list, event, true);
2b97eabc 1915
9d0624a7 1916 /* Run all the bias changes in parallel */
17282ba4
XX		 1917 list_for_each_entry(d, &card->dapm_list, list) {
1918 if (d != &card->dapm)
1919 async_schedule_domain(dapm_post_sequence_async, d,
1920 &async_domain);
1921 }
9d0624a7 1922 async_synchronize_full_domain(&async_domain);
17282ba4
XX		 1923 /* Run card bias changes at last */
1924 dapm_post_sequence_async(&card->dapm, 0);
452c5eaa 1925
8078d87f
LG		 1926 /* do we need to notify any clients that DAPM event is complete */
1927 list_for_each_entry(d, &card->dapm_list, list) {
1928 if (d->stream_event)
1929 d->stream_event(d, event);
1930 }
1931
95dd5cd6 1932 pop_dbg(card->dev, card->pop_time,
fd8d3bc0 1933 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
3a45b867 1934 pop_wait(card->pop_time);
cb507e7e 1935
84e90930
MB		 1936 trace_snd_soc_dapm_done(card);
1937
42aa3418 1938 return 0;
2b97eabc
RP		 1939}
1940
79fb9387 1941#ifdef CONFIG_DEBUG_FS
79fb9387
MB		 1942static ssize_t dapm_widget_power_read_file(struct file *file,
1943 char __user *user_buf,
1944 size_t count, loff_t *ppos)
1945{
1946 struct snd_soc_dapm_widget *w = file->private_data;
e50b1e06 1947 struct snd_soc_card *card = w->dapm->card;
a3423b02 1948 enum snd_soc_dapm_direction dir, rdir;
79fb9387
MB		 1949 char *buf;
1950 int in, out;
1951 ssize_t ret;
1952 struct snd_soc_dapm_path *p = NULL;
1953
1954 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1955 if (!buf)
1956 return -ENOMEM;
1957
e50b1e06
LPC		 1958 mutex_lock(&card->dapm_mutex);
1959
c1862c8b
LPC		 1960 /* Supply widgets are not handled by is_connected_{input,output}_ep() */
1961 if (w->is_supply) {
1962 in = 0;
1963 out = 0;
1964 } else {
6742064a
PS		 1965 in = is_connected_input_ep(w, NULL, NULL);
1966 out = is_connected_output_ep(w, NULL, NULL);
c1862c8b 1967 }
79fb9387 1968
f13ebada
MB		 1969 ret = snprintf(buf, PAGE_SIZE, "%s: %s%s in %d out %d",
1970 w->name, w->power ? "On" : "Off",
1971 w->force ? " (forced)" : "", in, out);
79fb9387 1972
d033c36a
MB		 1973 if (w->reg >= 0)
1974 ret += snprintf(buf + ret, PAGE_SIZE - ret,
de9ba98b
LPC		 1975 " - R%d(0x%x) mask 0x%x",
1976 w->reg, w->reg, w->mask << w->shift);
d033c36a
MB		 1977
1978 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1979
3eef08ba
MB		 1980 if (w->sname)
1981 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1982 w->sname,
1983 w->active ? "active" : "inactive");
79fb9387 1984
a3423b02
LPC		 1985 snd_soc_dapm_for_each_direction(dir) {
1986 rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
1987 snd_soc_dapm_widget_for_each_path(w, dir, p) {
1988 if (p->connected && !p->connected(w, p->node[rdir]))
1989 continue;
215edda3 1990
a3423b02
LPC		 1991 if (!p->connect)
1992 continue;
215edda3 1993
79fb9387 1994 ret += snprintf(buf + ret, PAGE_SIZE - ret,
a3423b02
LPC		 1995 " %s \"%s\" \"%s\"\n",
1996 (rdir == SND_SOC_DAPM_DIR_IN) ? "in" : "out",
79fb9387 1997 p->name ? p->name : "static",
a3423b02
LPC		 1998 p->node[rdir]->name);
1999 }
79fb9387
MB		 2000 }
2001
e50b1e06
LPC		 2002 mutex_unlock(&card->dapm_mutex);
2003
79fb9387
MB		 2004 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
2005
2006 kfree(buf);
2007 return ret;
2008}
2009
2010static const struct file_operations dapm_widget_power_fops = {
234e3405 2011 .open = simple_open,
79fb9387 2012 .read = dapm_widget_power_read_file,
6038f373 2013 .llseek = default_llseek,
79fb9387
MB		 2014};
2015
ef49e4fa
MB		 2016static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
2017 size_t count, loff_t *ppos)
2018{
2019 struct snd_soc_dapm_context *dapm = file->private_data;
2020 char *level;
2021
2022 switch (dapm->bias_level) {
2023 case SND_SOC_BIAS_ON:
2024 level = "On\n";
2025 break;
2026 case SND_SOC_BIAS_PREPARE:
2027 level = "Prepare\n";
2028 break;
2029 case SND_SOC_BIAS_STANDBY:
2030 level = "Standby\n";
2031 break;
2032 case SND_SOC_BIAS_OFF:
2033 level = "Off\n";
2034 break;
2035 default:
a6ed0608 2036 WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
ef49e4fa
MB		 2037 level = "Unknown\n";
2038 break;
2039 }
2040
2041 return simple_read_from_buffer(user_buf, count, ppos, level,
2042 strlen(level));
2043}
2044
2045static const struct file_operations dapm_bias_fops = {
234e3405 2046 .open = simple_open,
ef49e4fa
MB		 2047 .read = dapm_bias_read_file,
2048 .llseek = default_llseek,
2049};
2050
8eecaf62
LPC		 2051void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2052 struct dentry *parent)
79fb9387 2053{
79fb9387
MB		 2054 struct dentry *d;
2055
6553bf06
LPC		 2056 if (!parent)
2057 return;
2058
8eecaf62
LPC		 2059 dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
2060
2061 if (!dapm->debugfs_dapm) {
f1e90af2 2062 dev_warn(dapm->dev,
30a6a1a4 2063 "ASoC: Failed to create DAPM debugfs directory\n");
79fb9387 2064 return;
8eecaf62 2065 }
79fb9387 2066
ef49e4fa
MB		 2067 d = debugfs_create_file("bias_level", 0444,
2068 dapm->debugfs_dapm, dapm,
2069 &dapm_bias_fops);
2070 if (!d)
2071 dev_warn(dapm->dev,
2072 "ASoC: Failed to create bias level debugfs file\n");
d5d1e0be 2073}
ef49e4fa 2074
d5d1e0be
LPC		 2075static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2076{
2077 struct snd_soc_dapm_context *dapm = w->dapm;
2078 struct dentry *d;
79fb9387 2079
d5d1e0be
LPC		 2080 if (!dapm->debugfs_dapm || !w->name)
2081 return;
2082
2083 d = debugfs_create_file(w->name, 0444,
2084 dapm->debugfs_dapm, w,
2085 &dapm_widget_power_fops);
2086 if (!d)
2087 dev_warn(w->dapm->dev,
2088 "ASoC: Failed to create %s debugfs file\n",
2089 w->name);
79fb9387 2090}
d5d1e0be 2091
6c45e126
LPC		 2092static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2093{
2094 debugfs_remove_recursive(dapm->debugfs_dapm);
2095}
2096
79fb9387 2097#else
8eecaf62
LPC		 2098void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2099 struct dentry *parent)
79fb9387
MB		 2100{
2101}
d5d1e0be
LPC		 2102
2103static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2104{
2105}
2106
6c45e126
LPC		 2107static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2108{
2109}
2110
79fb9387
MB		 2111#endif
2112
4a201948
LPC		 2113/*
2114 * soc_dapm_connect_path() - Connects or disconnects a path
2115 * @path: The path to update
2116 * @connect: The new connect state of the path. True if the path is connected,
2117 * false if it is disconneted.
2118 * @reason: The reason why the path changed (for debugging only)
2119 */
2120static void soc_dapm_connect_path(struct snd_soc_dapm_path *path,
2121 bool connect, const char *reason)
2122{
2123 if (path->connect == connect)
2124 return;
2125
2126 path->connect = connect;
2127 dapm_mark_dirty(path->source, reason);
2128 dapm_mark_dirty(path->sink, reason);
92a99ea4 2129 dapm_path_invalidate(path);
4a201948
LPC		 2130}
2131
2b97eabc 2132/* test and update the power status of a mux widget */
95dd5cd6 2133static int soc_dapm_mux_update_power(struct snd_soc_card *card,
40f02cd9 2134 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
2b97eabc
RP		 2135{
2136 struct snd_soc_dapm_path *path;
2137 int found = 0;
4a201948 2138 bool connect;
2b97eabc 2139
f9fa2b18
MB		 2140 lockdep_assert_held(&card->dapm_mutex);
2141
2b97eabc 2142 /* find dapm widget path assoc with kcontrol */
5106b92f 2143 dapm_kcontrol_for_each_path(path, kcontrol) {
2b97eabc
RP		 2144 found = 1;
2145 /* we now need to match the string in the enum to the path */
4a201948
LPC		 2146 if (!(strcmp(path->name, e->texts[mux])))
2147 connect = true;
2148 else
2149 connect = false;
2150
2151 soc_dapm_connect_path(path, connect, "mux update");
2b97eabc
RP		 2152 }
2153
ce6cfaf1 2154 if (found)
95dd5cd6 2155 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2b97eabc 2156
618dae11 2157 return found;
2b97eabc 2158}
4edbb345 2159
ce6cfaf1 2160int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
6b3fc03b
LPC		 2161 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
2162 struct snd_soc_dapm_update *update)
4edbb345 2163{
ce6cfaf1 2164 struct snd_soc_card *card = dapm->card;
4edbb345
LG		 2165 int ret;
2166
3cd04343 2167 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
564c6504 2168 card->update = update;
95dd5cd6 2169 ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
564c6504 2170 card->update = NULL;
4edbb345 2171 mutex_unlock(&card->dapm_mutex);
618dae11 2172 if (ret > 0)
c3f48ae6 2173 soc_dpcm_runtime_update(card);
4edbb345
LG		 2174 return ret;
2175}
40f02cd9 2176EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
2b97eabc 2177
1b075e3f 2178/* test and update the power status of a mixer or switch widget */
95dd5cd6 2179static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
283375ce 2180 struct snd_kcontrol *kcontrol, int connect)
2b97eabc
RP		 2181{
2182 struct snd_soc_dapm_path *path;
2183 int found = 0;
2184
f9fa2b18
MB		 2185 lockdep_assert_held(&card->dapm_mutex);
2186
2b97eabc 2187 /* find dapm widget path assoc with kcontrol */
5106b92f 2188 dapm_kcontrol_for_each_path(path, kcontrol) {
2b97eabc 2189 found = 1;
4a201948 2190 soc_dapm_connect_path(path, connect, "mixer update");
2b97eabc
RP		 2191 }
2192
ce6cfaf1 2193 if (found)
95dd5cd6 2194 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2b97eabc 2195
618dae11 2196 return found;
2b97eabc 2197}
4edbb345 2198
ce6cfaf1 2199int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
6b3fc03b
LPC		 2200 struct snd_kcontrol *kcontrol, int connect,
2201 struct snd_soc_dapm_update *update)
4edbb345 2202{
ce6cfaf1 2203 struct snd_soc_card *card = dapm->card;
4edbb345
LG		 2204 int ret;
2205
3cd04343 2206 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
564c6504 2207 card->update = update;
95dd5cd6 2208 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
564c6504 2209 card->update = NULL;
4edbb345 2210 mutex_unlock(&card->dapm_mutex);
618dae11 2211 if (ret > 0)
c3f48ae6 2212 soc_dpcm_runtime_update(card);
4edbb345
LG		 2213 return ret;
2214}
40f02cd9 2215EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
2b97eabc 2216
b3c25fb7
LPC		 2217static ssize_t dapm_widget_show_component(struct snd_soc_component *cmpnt,
2218 char *buf)
2b97eabc 2219{
b3c25fb7 2220 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
2b97eabc
RP		 2221 struct snd_soc_dapm_widget *w;
2222 int count = 0;
2223 char *state = "not set";
2224
47325078
MB		 2225 /* card won't be set for the dummy component, as a spot fix
2226 * we're checking for that case specifically here but in future
2227 * we will ensure that the dummy component looks like others.
2228 */
2229 if (!cmpnt->card)
2230 return 0;
2231
b3c25fb7
LPC		 2232 list_for_each_entry(w, &cmpnt->card->widgets, list) {
2233 if (w->dapm != dapm)
97c866de 2234 continue;
2b97eabc
RP		 2235
2236 /* only display widgets that burnm power */
2237 switch (w->id) {
2238 case snd_soc_dapm_hp:
2239 case snd_soc_dapm_mic:
2240 case snd_soc_dapm_spk:
2241 case snd_soc_dapm_line:
2242 case snd_soc_dapm_micbias:
2243 case snd_soc_dapm_dac:
2244 case snd_soc_dapm_adc:
2245 case snd_soc_dapm_pga:
d88429a6 2246 case snd_soc_dapm_out_drv:
2b97eabc 2247 case snd_soc_dapm_mixer:
ca9c1aae 2248 case snd_soc_dapm_mixer_named_ctl:
246d0a17 2249 case snd_soc_dapm_supply:
62ea874a 2250 case snd_soc_dapm_regulator_supply:
d7e7eb91 2251 case snd_soc_dapm_clock_supply:
2b97eabc
RP		 2252 if (w->name)
2253 count += sprintf(buf + count, "%s: %s\n",
2254 w->name, w->power ? "On":"Off");
2255 break;
2256 default:
2257 break;
2258 }
2259 }
2260
b3c25fb7 2261 switch (snd_soc_dapm_get_bias_level(dapm)) {
0be9898a
MB		 2262 case SND_SOC_BIAS_ON:
2263 state = "On";
2b97eabc 2264 break;
0be9898a
MB		 2265 case SND_SOC_BIAS_PREPARE:
2266 state = "Prepare";
2b97eabc 2267 break;
0be9898a
MB		 2268 case SND_SOC_BIAS_STANDBY:
2269 state = "Standby";
2b97eabc 2270 break;
0be9898a
MB		 2271 case SND_SOC_BIAS_OFF:
2272 state = "Off";
2b97eabc
RP		 2273 break;
2274 }
2275 count += sprintf(buf + count, "PM State: %s\n", state);
2276
2277 return count;
2278}
2279
44ba2641
BC		 2280/* show dapm widget status in sys fs */
2281static ssize_t dapm_widget_show(struct device *dev,
2282 struct device_attribute *attr, char *buf)
2283{
2284 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
2285 int i, count = 0;
2286
e50b1e06
LPC		 2287 mutex_lock(&rtd->card->dapm_mutex);
2288
44ba2641 2289 for (i = 0; i < rtd->num_codecs; i++) {
b3c25fb7
LPC		 2290 struct snd_soc_component *cmpnt = rtd->codec_dais[i]->component;
2291
2292 count += dapm_widget_show_component(cmpnt, buf + count);
44ba2641
BC		 2293 }
2294
e50b1e06
LPC		 2295 mutex_unlock(&rtd->card->dapm_mutex);
2296
44ba2641
BC		 2297 return count;
2298}
2299
2b97eabc
RP		 2300static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
2301
d29697dc
TI		 2302struct attribute *soc_dapm_dev_attrs[] = {
2303 &dev_attr_dapm_widget.attr,
2304 NULL
2305};
2b97eabc 2306
8872293f
LPC		 2307static void dapm_free_path(struct snd_soc_dapm_path *path)
2308{
a3423b02
LPC		 2309 list_del(&path->list_node[SND_SOC_DAPM_DIR_IN]);
2310 list_del(&path->list_node[SND_SOC_DAPM_DIR_OUT]);
5106b92f 2311 list_del(&path->list_kcontrol);
8872293f 2312 list_del(&path->list);
8872293f
LPC		 2313 kfree(path);
2314}
2315
b97e2698
LPC		 2316void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w)
2317{
2318 struct snd_soc_dapm_path *p, *next_p;
a3423b02 2319 enum snd_soc_dapm_direction dir;
b97e2698
LPC		 2320
2321 list_del(&w->list);
2322 /*
2323 * remove source and sink paths associated to this widget.
2324 * While removing the path, remove reference to it from both
2325 * source and sink widgets so that path is removed only once.
2326 */
a3423b02
LPC		 2327 snd_soc_dapm_for_each_direction(dir) {
2328 snd_soc_dapm_widget_for_each_path_safe(w, dir, p, next_p)
2329 dapm_free_path(p);
2330 }
b97e2698
LPC		 2331
2332 kfree(w->kcontrols);
48068961 2333 kfree_const(w->name);
b97e2698
LPC		 2334 kfree(w);
2335}
2336
fd589a1b
JS		 2337void snd_soc_dapm_reset_cache(struct snd_soc_dapm_context *dapm)
2338{
2339 dapm->path_sink_cache.widget = NULL;
2340 dapm->path_source_cache.widget = NULL;
2341}
2342
2b97eabc 2343/* free all dapm widgets and resources */
ce6120cc 2344static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
2b97eabc
RP		 2345{
2346 struct snd_soc_dapm_widget *w, *next_w;
2b97eabc 2347
97c866de
JN		 2348 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
2349 if (w->dapm != dapm)
2350 continue;
b97e2698 2351 snd_soc_dapm_free_widget(w);
2b97eabc 2352 }
fd589a1b 2353 snd_soc_dapm_reset_cache(dapm);
2b97eabc
RP		 2354}
2355
91a5fca4
LPC		 2356static struct snd_soc_dapm_widget *dapm_find_widget(
2357 struct snd_soc_dapm_context *dapm, const char *pin,
2358 bool search_other_contexts)
a5302181
LG		 2359{
2360 struct snd_soc_dapm_widget *w;
91a5fca4 2361 struct snd_soc_dapm_widget *fallback = NULL;
a5302181 2362
97c866de 2363 list_for_each_entry(w, &dapm->card->widgets, list) {
a5302181 2364 if (!strcmp(w->name, pin)) {
91a5fca4
LPC		 2365 if (w->dapm == dapm)
2366 return w;
2367 else
2368 fallback = w;
a5302181
LG		 2369 }
2370 }
2371
91a5fca4
LPC		 2372 if (search_other_contexts)
2373 return fallback;
2374
2375 return NULL;
2376}
2377
2378static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
2379 const char *pin, int status)
2380{
2381 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
2382
f9fa2b18
MB		 2383 dapm_assert_locked(dapm);
2384
91a5fca4 2385 if (!w) {
30a6a1a4 2386 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
91a5fca4 2387 return -EINVAL;
0d86733c
MB		 2388 }
2389
92a99ea4 2390 if (w->connected != status) {
1a8b2d9d 2391 dapm_mark_dirty(w, "pin configuration");
92a99ea4
LPC		 2392 dapm_widget_invalidate_input_paths(w);
2393 dapm_widget_invalidate_output_paths(w);
2394 }
1a8b2d9d 2395
91a5fca4
LPC		 2396 w->connected = status;
2397 if (status == 0)
2398 w->force = 0;
2399
2400 return 0;
a5302181
LG		 2401}
2402
2b97eabc 2403/**
3eb29dfb 2404 * snd_soc_dapm_sync_unlocked - scan and power dapm paths
ce6120cc 2405 * @dapm: DAPM context
2b97eabc
RP		 2406 *
2407 * Walks all dapm audio paths and powers widgets according to their
2408 * stream or path usage.
2409 *
3eb29dfb
CK		 2410 * Requires external locking.
2411 *
2b97eabc
RP		 2412 * Returns 0 for success.
2413 */
3eb29dfb 2414int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
2b97eabc 2415{
4f4c0072
MB		 2416 /*
2417 * Suppress early reports (eg, jacks syncing their state) to avoid
2418 * silly DAPM runs during card startup.
2419 */
2420 if (!dapm->card || !dapm->card->instantiated)
2421 return 0;
2422
3eb29dfb
CK		 2423 return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
2424}
2425EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked);
2426
2427/**
2428 * snd_soc_dapm_sync - scan and power dapm paths
2429 * @dapm: DAPM context
2430 *
2431 * Walks all dapm audio paths and powers widgets according to their
2432 * stream or path usage.
2433 *
2434 * Returns 0 for success.
2435 */
2436int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
2437{
2438 int ret;
2439
3cd04343 2440 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3eb29dfb 2441 ret = snd_soc_dapm_sync_unlocked(dapm);
a73fb2df
LG		 2442 mutex_unlock(&dapm->card->dapm_mutex);
2443 return ret;
2b97eabc 2444}
a5302181 2445EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
2b97eabc 2446
6dd98b0a
LPC		 2447/*
2448 * dapm_update_widget_flags() - Re-compute widget sink and source flags
2449 * @w: The widget for which to update the flags
2450 *
2451 * Some widgets have a dynamic category which depends on which neighbors they
2452 * are connected to. This function update the category for these widgets.
2453 *
2454 * This function must be called whenever a path is added or removed to a widget.
2455 */
2456static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
2457{
a3423b02 2458 enum snd_soc_dapm_direction dir;
6dd98b0a 2459 struct snd_soc_dapm_path *p;
a3423b02 2460 unsigned int ep;
6dd98b0a
LPC		 2461
2462 switch (w->id) {
2463 case snd_soc_dapm_input:
86d75003
LPC		 2464 /* On a fully routed card a input is never a source */
2465 if (w->dapm->card->fully_routed)
a3423b02
LPC		 2466 return;
2467 ep = SND_SOC_DAPM_EP_SOURCE;
e63bfd45 2468 snd_soc_dapm_widget_for_each_source_path(w, p) {
6dd98b0a
LPC		 2469 if (p->source->id == snd_soc_dapm_micbias ||
2470 p->source->id == snd_soc_dapm_mic ||
2471 p->source->id == snd_soc_dapm_line ||
2472 p->source->id == snd_soc_dapm_output) {
a3423b02 2473 ep = 0;
6dd98b0a
LPC		 2474 break;
2475 }
2476 }
2477 break;
2478 case snd_soc_dapm_output:
86d75003
LPC		 2479 /* On a fully routed card a output is never a sink */
2480 if (w->dapm->card->fully_routed)
a3423b02
LPC		 2481 return;
2482 ep = SND_SOC_DAPM_EP_SINK;
e63bfd45 2483 snd_soc_dapm_widget_for_each_sink_path(w, p) {
6dd98b0a
LPC		 2484 if (p->sink->id == snd_soc_dapm_spk ||
2485 p->sink->id == snd_soc_dapm_hp ||
2486 p->sink->id == snd_soc_dapm_line ||
2487 p->sink->id == snd_soc_dapm_input) {
a3423b02 2488 ep = 0;
6dd98b0a
LPC		 2489 break;
2490 }
2491 }
2492 break;
2493 case snd_soc_dapm_line:
a3423b02
LPC		 2494 ep = 0;
2495 snd_soc_dapm_for_each_direction(dir) {
2496 if (!list_empty(&w->edges[dir]))
2497 ep |= SND_SOC_DAPM_DIR_TO_EP(dir);
2498 }
6dd98b0a
LPC		 2499 break;
2500 default:
a3423b02 2501 return;
6dd98b0a 2502 }
a3423b02
LPC		 2503
2504 w->is_ep = ep;
6dd98b0a
LPC		 2505}
2506
d714f97c
LPC		 2507static int snd_soc_dapm_check_dynamic_path(struct snd_soc_dapm_context *dapm,
2508 struct snd_soc_dapm_widget *source, struct snd_soc_dapm_widget *sink,
2509 const char *control)
2510{
2511 bool dynamic_source = false;
2512 bool dynamic_sink = false;
2513
2514 if (!control)
2515 return 0;
2516
2517 switch (source->id) {
2518 case snd_soc_dapm_demux:
2519 dynamic_source = true;
2520 break;
2521 default:
2522 break;
2523 }
2524
2525 switch (sink->id) {
2526 case snd_soc_dapm_mux:
2527 case snd_soc_dapm_switch:
2528 case snd_soc_dapm_mixer:
2529 case snd_soc_dapm_mixer_named_ctl:
2530 dynamic_sink = true;
2531 break;
2532 default:
2533 break;
2534 }
2535
2536 if (dynamic_source && dynamic_sink) {
2537 dev_err(dapm->dev,
2538 "Direct connection between demux and mixer/mux not supported for path %s -> [%s] -> %s\n",
2539 source->name, control, sink->name);
2540 return -EINVAL;
2541 } else if (!dynamic_source && !dynamic_sink) {
2542 dev_err(dapm->dev,
2543 "Control not supported for path %s -> [%s] -> %s\n",
2544 source->name, control, sink->name);
2545 return -EINVAL;
2546 }
2547
2548 return 0;
2549}
2550
2553628e
LPC		 2551static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
2552 struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
2553 const char *control,
2554 int (*connected)(struct snd_soc_dapm_widget *source,
2555 struct snd_soc_dapm_widget *sink))
2b97eabc 2556{
a3423b02
LPC		 2557 struct snd_soc_dapm_widget *widgets[2];
2558 enum snd_soc_dapm_direction dir;
2b97eabc 2559 struct snd_soc_dapm_path *path;
2553628e 2560 int ret;
2b97eabc 2561
e409dfbf
LPC		 2562 if (wsink->is_supply && !wsource->is_supply) {
2563 dev_err(dapm->dev,
2564 "Connecting non-supply widget to supply widget is not supported (%s -> %s)\n",
2565 wsource->name, wsink->name);
2566 return -EINVAL;
2567 }
2568
2569 if (connected && !wsource->is_supply) {
2570 dev_err(dapm->dev,
2571 "connected() callback only supported for supply widgets (%s -> %s)\n",
2572 wsource->name, wsink->name);
2573 return -EINVAL;
2574 }
2575
2576 if (wsource->is_supply && control) {
2577 dev_err(dapm->dev,
2578 "Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
2579 wsource->name, control, wsink->name);
2580 return -EINVAL;
2581 }
2582
d714f97c
LPC		 2583 ret = snd_soc_dapm_check_dynamic_path(dapm, wsource, wsink, control);
2584 if (ret)
2585 return ret;
2586
2b97eabc
RP		 2587 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
2588 if (!path)
2589 return -ENOMEM;
2590
a3423b02
LPC		 2591 path->node[SND_SOC_DAPM_DIR_IN] = wsource;
2592 path->node[SND_SOC_DAPM_DIR_OUT] = wsink;
2593 widgets[SND_SOC_DAPM_DIR_IN] = wsource;
2594 widgets[SND_SOC_DAPM_DIR_OUT] = wsink;
2595
2553628e 2596 path->connected = connected;
2b97eabc 2597 INIT_LIST_HEAD(&path->list);
69c2d346 2598 INIT_LIST_HEAD(&path->list_kcontrol);
2b97eabc 2599
c1862c8b
LPC		 2600 if (wsource->is_supply || wsink->is_supply)
2601 path->is_supply = 1;
2602
2b97eabc
RP		 2603 /* connect static paths */
2604 if (control == NULL) {
2b97eabc 2605 path->connect = 1;
5fe5b767 2606 } else {
d714f97c
LPC		 2607 switch (wsource->id) {
2608 case snd_soc_dapm_demux:
2609 ret = dapm_connect_mux(dapm, path, control, wsource);
2610 if (ret)
2611 goto err;
2612 break;
2613 default:
2614 break;
2615 }
2616
5fe5b767
LPC		 2617 switch (wsink->id) {
2618 case snd_soc_dapm_mux:
d714f97c 2619 ret = dapm_connect_mux(dapm, path, control, wsink);
5fe5b767
LPC		 2620 if (ret != 0)
2621 goto err;
2622 break;
2623 case snd_soc_dapm_switch:
2624 case snd_soc_dapm_mixer:
2625 case snd_soc_dapm_mixer_named_ctl:
2626 ret = dapm_connect_mixer(dapm, path, control);
2627 if (ret != 0)
2628 goto err;
2629 break;
2630 default:
d714f97c 2631 break;
5fe5b767 2632 }
2b97eabc 2633 }
fabd0384 2634
5fe5b767 2635 list_add(&path->list, &dapm->card->paths);
a3423b02
LPC		 2636 snd_soc_dapm_for_each_direction(dir)
2637 list_add(&path->list_node[dir], &widgets[dir]->edges[dir]);
5fe5b767 2638
a3423b02
LPC		 2639 snd_soc_dapm_for_each_direction(dir) {
2640 dapm_update_widget_flags(widgets[dir]);
2641 dapm_mark_dirty(widgets[dir], "Route added");
2642 }
5fe5b767 2643
92a99ea4
LPC		 2644 if (dapm->card->instantiated && path->connect)
2645 dapm_path_invalidate(path);
2646
2b97eabc 2647 return 0;
2553628e
LPC		 2648err:
2649 kfree(path);
2650 return ret;
2651}
2b97eabc 2652
2553628e 2653static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
a4e9154c 2654 const struct snd_soc_dapm_route *route)
2553628e
LPC		 2655{
2656 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
2657 struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
2658 const char *sink;
2659 const char *source;
2660 char prefixed_sink[80];
2661 char prefixed_source[80];
94f99c87 2662 const char *prefix;
2553628e
LPC		 2663 int ret;
2664
94f99c87
LPC		 2665 prefix = soc_dapm_prefix(dapm);
2666 if (prefix) {
2553628e 2667 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
94f99c87 2668 prefix, route->sink);
2553628e
LPC		 2669 sink = prefixed_sink;
2670 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
94f99c87 2671 prefix, route->source);
2553628e
LPC		 2672 source = prefixed_source;
2673 } else {
2674 sink = route->sink;
2675 source = route->source;
2676 }
2677
45a110a1
CK		 2678 wsource = dapm_wcache_lookup(&dapm->path_source_cache, source);
2679 wsink = dapm_wcache_lookup(&dapm->path_sink_cache, sink);
2680
2681 if (wsink && wsource)
2682 goto skip_search;
2683
2553628e
LPC		 2684 /*
2685 * find src and dest widgets over all widgets but favor a widget from
2686 * current DAPM context
2687 */
2688 list_for_each_entry(w, &dapm->card->widgets, list) {
2689 if (!wsink && !(strcmp(w->name, sink))) {
2690 wtsink = w;
70c75109 2691 if (w->dapm == dapm) {
2553628e 2692 wsink = w;
70c75109
CK		 2693 if (wsource)
2694 break;
2695 }
2553628e
LPC		 2696 continue;
2697 }
2698 if (!wsource && !(strcmp(w->name, source))) {
2699 wtsource = w;
70c75109 2700 if (w->dapm == dapm) {
2553628e 2701 wsource = w;
70c75109
CK		 2702 if (wsink)
2703 break;
2704 }
2553628e
LPC		 2705 }
2706 }
2707 /* use widget from another DAPM context if not found from this */
2708 if (!wsink)
2709 wsink = wtsink;
2710 if (!wsource)
2711 wsource = wtsource;
2712
2713 if (wsource == NULL) {
2714 dev_err(dapm->dev, "ASoC: no source widget found for %s\n",
2715 route->source);
2716 return -ENODEV;
2717 }
2718 if (wsink == NULL) {
2719 dev_err(dapm->dev, "ASoC: no sink widget found for %s\n",
2720 route->sink);
2721 return -ENODEV;
2722 }
2723
45a110a1
CK		 2724skip_search:
2725 dapm_wcache_update(&dapm->path_sink_cache, wsink);
2726 dapm_wcache_update(&dapm->path_source_cache, wsource);
2727
2553628e
LPC		 2728 ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,
2729 route->connected);
2730 if (ret)
2731 goto err;
2732
2733 return 0;
2b97eabc 2734err:
30a6a1a4 2735 dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n",
2553628e 2736 source, route->control, sink);
2b97eabc
RP		 2737 return ret;
2738}
105f1c28 2739
efcc3c61
MB		 2740static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
2741 const struct snd_soc_dapm_route *route)
2742{
6dd98b0a 2743 struct snd_soc_dapm_widget *wsource, *wsink;
efcc3c61
MB		 2744 struct snd_soc_dapm_path *path, *p;
2745 const char *sink;
2746 const char *source;
2747 char prefixed_sink[80];
2748 char prefixed_source[80];
94f99c87 2749 const char *prefix;
efcc3c61
MB		 2750
2751 if (route->control) {
2752 dev_err(dapm->dev,
30a6a1a4 2753 "ASoC: Removal of routes with controls not supported\n");
efcc3c61
MB		 2754 return -EINVAL;
2755 }
2756
94f99c87
LPC		 2757 prefix = soc_dapm_prefix(dapm);
2758 if (prefix) {
efcc3c61 2759 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
94f99c87 2760 prefix, route->sink);
efcc3c61
MB		 2761 sink = prefixed_sink;
2762 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
94f99c87 2763 prefix, route->source);
efcc3c61
MB		 2764 source = prefixed_source;
2765 } else {
2766 sink = route->sink;
2767 source = route->source;
2768 }
2769
2770 path = NULL;
2771 list_for_each_entry(p, &dapm->card->paths, list) {
2772 if (strcmp(p->source->name, source) != 0)
2773 continue;
2774 if (strcmp(p->sink->name, sink) != 0)
2775 continue;
2776 path = p;
2777 break;
2778 }
2779
2780 if (path) {
6dd98b0a
LPC		 2781 wsource = path->source;
2782 wsink = path->sink;
2783
2784 dapm_mark_dirty(wsource, "Route removed");
2785 dapm_mark_dirty(wsink, "Route removed");
92a99ea4
LPC		 2786 if (path->connect)
2787 dapm_path_invalidate(path);
efcc3c61 2788
8872293f 2789 dapm_free_path(path);
6dd98b0a
LPC		 2790
2791 /* Update any path related flags */
2792 dapm_update_widget_flags(wsource);
2793 dapm_update_widget_flags(wsink);
efcc3c61 2794 } else {
30a6a1a4 2795 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
efcc3c61
MB		 2796 source, sink);
2797 }
2798
2799 return 0;
2800}
2801
105f1c28
MB		 2802/**
2803 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
ce6120cc 2804 * @dapm: DAPM context
105f1c28
MB		 2805 * @route: audio routes
2806 * @num: number of routes
2807 *
2808 * Connects 2 dapm widgets together via a named audio path. The sink is
2809 * the widget receiving the audio signal, whilst the source is the sender
2810 * of the audio signal.
2811 *
2812 * Returns 0 for success else error. On error all resources can be freed
2813 * with a call to snd_soc_card_free().
2814 */
ce6120cc 2815int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
105f1c28
MB		 2816 const struct snd_soc_dapm_route *route, int num)
2817{
62d4a4b9 2818 int i, r, ret = 0;
105f1c28 2819
a73fb2df 2820 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
105f1c28 2821 for (i = 0; i < num; i++) {
a4e9154c 2822 r = snd_soc_dapm_add_route(dapm, route);
62d4a4b9 2823 if (r < 0) {
30a6a1a4
LG		 2824 dev_err(dapm->dev, "ASoC: Failed to add route %s -> %s -> %s\n",
2825 route->source,
2826 route->control ? route->control : "direct",
2827 route->sink);
62d4a4b9 2828 ret = r;
105f1c28
MB		 2829 }
2830 route++;
2831 }
a73fb2df 2832 mutex_unlock(&dapm->card->dapm_mutex);
105f1c28 2833
60884c27 2834 return ret;
105f1c28
MB		 2835}
2836EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
2837
efcc3c61
MB		 2838/**
2839 * snd_soc_dapm_del_routes - Remove routes between DAPM widgets
2840 * @dapm: DAPM context
2841 * @route: audio routes
2842 * @num: number of routes
2843 *
2844 * Removes routes from the DAPM context.
2845 */
2846int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm,
2847 const struct snd_soc_dapm_route *route, int num)
2848{
e066ea22 2849 int i;
efcc3c61
MB		 2850
2851 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2852 for (i = 0; i < num; i++) {
2853 snd_soc_dapm_del_route(dapm, route);
2854 route++;
2855 }
2856 mutex_unlock(&dapm->card->dapm_mutex);
2857
e066ea22 2858 return 0;
efcc3c61
MB		 2859}
2860EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes);
2861
bf3a9e13
MB		 2862static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
2863 const struct snd_soc_dapm_route *route)
2864{
2865 struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
2866 route->source,
2867 true);
2868 struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
2869 route->sink,
2870 true);
2871 struct snd_soc_dapm_path *path;
2872 int count = 0;
2873
2874 if (!source) {
30a6a1a4 2875 dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
bf3a9e13
MB		 2876 route->source);
2877 return -ENODEV;
2878 }
2879
2880 if (!sink) {
30a6a1a4 2881 dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
bf3a9e13
MB		 2882 route->sink);
2883 return -ENODEV;
2884 }
2885
2886 if (route->control || route->connected)
30a6a1a4 2887 dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
bf3a9e13
MB		 2888 route->source, route->sink);
2889
e63bfd45 2890 snd_soc_dapm_widget_for_each_sink_path(source, path) {
bf3a9e13
MB		 2891 if (path->sink == sink) {
2892 path->weak = 1;
2893 count++;
2894 }
2895 }
2896
2897 if (count == 0)
30a6a1a4 2898 dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
bf3a9e13
MB		 2899 route->source, route->sink);
2900 if (count > 1)
30a6a1a4 2901 dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
bf3a9e13
MB		 2902 count, route->source, route->sink);
2903
2904 return 0;
2905}
2906
2907/**
2908 * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
2909 * @dapm: DAPM context
2910 * @route: audio routes
2911 * @num: number of routes
2912 *
2913 * Mark existing routes matching those specified in the passed array
2914 * as being weak, meaning that they are ignored for the purpose of
2915 * power decisions. The main intended use case is for sidetone paths
2916 * which couple audio between other independent paths if they are both
2917 * active in order to make the combination work better at the user
2918 * level but which aren't intended to be "used".
2919 *
2920 * Note that CODEC drivers should not use this as sidetone type paths
2921 * can frequently also be used as bypass paths.
2922 */
2923int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
2924 const struct snd_soc_dapm_route *route, int num)
2925{
2926 int i, err;
2927 int ret = 0;
2928
a73fb2df 2929 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
bf3a9e13
MB		 2930 for (i = 0; i < num; i++) {
2931 err = snd_soc_dapm_weak_route(dapm, route);
2932 if (err)
2933 ret = err;
2934 route++;
2935 }
a73fb2df 2936 mutex_unlock(&dapm->card->dapm_mutex);
bf3a9e13
MB		 2937
2938 return ret;
2939}
2940EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2941
2b97eabc
RP		 2942/**
2943 * snd_soc_dapm_new_widgets - add new dapm widgets
628536ea 2944 * @card: card to be checked for new dapm widgets
2b97eabc
RP		 2945 *
2946 * Checks the codec for any new dapm widgets and creates them if found.
2947 *
2948 * Returns 0 for success.
2949 */
824ef826 2950int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
2b97eabc
RP		 2951{
2952 struct snd_soc_dapm_widget *w;
b66a70d5 2953 unsigned int val;
2b97eabc 2954
95dd5cd6 2955 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
a73fb2df 2956
95dd5cd6 2957 list_for_each_entry(w, &card->widgets, list)
2b97eabc
RP		 2958 {
2959 if (w->new)
2960 continue;
2961
fad59888
SW		 2962 if (w->num_kcontrols) {
2963 w->kcontrols = kzalloc(w->num_kcontrols *
2964 sizeof(struct snd_kcontrol *),
2965 GFP_KERNEL);
a73fb2df 2966 if (!w->kcontrols) {
95dd5cd6 2967 mutex_unlock(&card->dapm_mutex);
fad59888 2968 return -ENOMEM;
a73fb2df 2969 }
fad59888
SW		 2970 }
2971
2b97eabc
RP		 2972 switch(w->id) {
2973 case snd_soc_dapm_switch:
2974 case snd_soc_dapm_mixer:
ca9c1aae 2975 case snd_soc_dapm_mixer_named_ctl:
4b80b8c2 2976 dapm_new_mixer(w);
2b97eabc
RP		 2977 break;
2978 case snd_soc_dapm_mux:
d714f97c 2979 case snd_soc_dapm_demux:
4b80b8c2 2980 dapm_new_mux(w);
2b97eabc 2981 break;
2b97eabc 2982 case snd_soc_dapm_pga:
d88429a6 2983 case snd_soc_dapm_out_drv:
4b80b8c2 2984 dapm_new_pga(w);
2b97eabc 2985 break;
c6615082
NO		 2986 case snd_soc_dapm_dai_link:
2987 dapm_new_dai_link(w);
2988 break;
7ca3a18b 2989 default:
2b97eabc
RP		 2990 break;
2991 }
b66a70d5
MB		 2992
2993 /* Read the initial power state from the device */
2994 if (w->reg >= 0) {
ce0fc93a 2995 soc_dapm_read(w->dapm, w->reg, &val);
f7d3c170 2996 val = val >> w->shift;
de9ba98b
LPC		 2997 val &= w->mask;
2998 if (val == w->on_val)
b66a70d5
MB		 2999 w->power = 1;
3000 }
3001
2b97eabc 3002 w->new = 1;
d5d1e0be 3003
7508b12a 3004 dapm_mark_dirty(w, "new widget");
d5d1e0be 3005 dapm_debugfs_add_widget(w);
2b97eabc
RP		 3006 }
3007
95dd5cd6
LPC		 3008 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
3009 mutex_unlock(&card->dapm_mutex);
2b97eabc
RP		 3010 return 0;
3011}
3012EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
3013
3014/**
3015 * snd_soc_dapm_get_volsw - dapm mixer get callback
3016 * @kcontrol: mixer control
ac11a2b3 3017 * @ucontrol: control element information
2b97eabc
RP		 3018 *
3019 * Callback to get the value of a dapm mixer control.
3020 *
3021 * Returns 0 for success.
3022 */
3023int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
3024 struct snd_ctl_elem_value *ucontrol)
3025{
ce0fc93a
LPC		 3026 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3027 struct snd_soc_card *card = dapm->card;
4eaa9819
JS		 3028 struct soc_mixer_control *mc =
3029 (struct soc_mixer_control *)kcontrol->private_value;
249ce138 3030 int reg = mc->reg;
815ecf8d 3031 unsigned int shift = mc->shift;
4eaa9819 3032 int max = mc->max;
815ecf8d 3033 unsigned int mask = (1 << fls(max)) - 1;
da602ab8 3034 unsigned int invert = mc->invert;
57295073 3035 unsigned int val;
ce0fc93a 3036 int ret = 0;
da602ab8
BT		 3037
3038 if (snd_soc_volsw_is_stereo(mc))
ce0fc93a 3039 dev_warn(dapm->dev,
30a6a1a4 3040 "ASoC: Control '%s' is stereo, which is not supported\n",
da602ab8 3041 kcontrol->id.name);
2b97eabc 3042
57295073 3043 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
ce0fc93a
LPC		 3044 if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
3045 ret = soc_dapm_read(dapm, reg, &val);
3046 val = (val >> shift) & mask;
3047 } else {
57295073 3048 val = dapm_kcontrol_get_value(kcontrol);
ce0fc93a 3049 }
57295073
LPC		 3050 mutex_unlock(&card->dapm_mutex);
3051
da602ab8 3052 if (invert)
57295073
LPC		 3053 ucontrol->value.integer.value[0] = max - val;
3054 else
3055 ucontrol->value.integer.value[0] = val;
2b97eabc 3056
ce0fc93a 3057 return ret;
2b97eabc
RP		 3058}
3059EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
3060
3061/**
3062 * snd_soc_dapm_put_volsw - dapm mixer set callback
3063 * @kcontrol: mixer control
ac11a2b3 3064 * @ucontrol: control element information
2b97eabc
RP		 3065 *
3066 * Callback to set the value of a dapm mixer control.
3067 *
3068 * Returns 0 for success.
3069 */
3070int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
3071 struct snd_ctl_elem_value *ucontrol)
3072{
ce0fc93a
LPC		 3073 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3074 struct snd_soc_card *card = dapm->card;
4eaa9819
JS		 3075 struct soc_mixer_control *mc =
3076 (struct soc_mixer_control *)kcontrol->private_value;
249ce138 3077 int reg = mc->reg;
815ecf8d 3078 unsigned int shift = mc->shift;
4eaa9819 3079 int max = mc->max;
815ecf8d
JS		 3080 unsigned int mask = (1 << fls(max)) - 1;
3081 unsigned int invert = mc->invert;
e9cf7049 3082 unsigned int val;
18626c7e 3083 int connect, change, reg_change = 0;
97404f2e 3084 struct snd_soc_dapm_update update;
52765976 3085 int ret = 0;
2b97eabc 3086
da602ab8 3087 if (snd_soc_volsw_is_stereo(mc))
ce0fc93a 3088 dev_warn(dapm->dev,
30a6a1a4 3089 "ASoC: Control '%s' is stereo, which is not supported\n",
da602ab8
BT		 3090 kcontrol->id.name);
3091
2b97eabc 3092 val = (ucontrol->value.integer.value[0] & mask);
8a720718 3093 connect = !!val;
2b97eabc
RP		 3094
3095 if (invert)
a7a4ac86 3096 val = max - val;
2b97eabc 3097
3cd04343 3098 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2b97eabc 3099
249ce138 3100 change = dapm_kcontrol_set_value(kcontrol, val);
97404f2e 3101
18626c7e
JN		 3102 if (reg != SND_SOC_NOPM) {
3103 mask = mask << shift;
3104 val = val << shift;
3105
ce0fc93a 3106 reg_change = soc_dapm_test_bits(dapm, reg, mask, val);
18626c7e
JN		 3107 }
3108
3109 if (change || reg_change) {
3110 if (reg_change) {
3111 update.kcontrol = kcontrol;
3112 update.reg = reg;
3113 update.mask = mask;
3114 update.val = val;
3115 card->update = &update;
249ce138 3116 }
18626c7e 3117 change |= reg_change;
97404f2e 3118
52765976 3119 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
fafd2176 3120
564c6504 3121 card->update = NULL;
283375ce
MB		 3122 }
3123
a73fb2df 3124 mutex_unlock(&card->dapm_mutex);
52765976
NC		 3125
3126 if (ret > 0)
3127 soc_dpcm_runtime_update(card);
3128
56a67834 3129 return change;
2b97eabc
RP		 3130}
3131EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
3132
3133/**
3134 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
3135 * @kcontrol: mixer control
ac11a2b3 3136 * @ucontrol: control element information
2b97eabc
RP		 3137 *
3138 * Callback to get the value of a dapm enumerated double mixer control.
3139 *
3140 * Returns 0 for success.
3141 */
3142int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
3143 struct snd_ctl_elem_value *ucontrol)
3144{
ce0fc93a 3145 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
561ed680 3146 struct snd_soc_card *card = dapm->card;
2b97eabc 3147 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3727b496 3148 unsigned int reg_val, val;
52765976 3149
561ed680
CK		 3150 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3151 if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
69128316 3152 int ret = soc_dapm_read(dapm, e->reg, &reg_val);
964a0b89
CK		 3153 if (ret) {
3154 mutex_unlock(&card->dapm_mutex);
69128316 3155 return ret;
964a0b89 3156 }
69128316 3157 } else {
236aaa68 3158 reg_val = dapm_kcontrol_get_value(kcontrol);
69128316 3159 }
561ed680 3160 mutex_unlock(&card->dapm_mutex);
2e72f8e3 3161
2e72f8e3 3162 val = (reg_val >> e->shift_l) & e->mask;
3727b496 3163 ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
2e72f8e3
PU		 3164 if (e->shift_l != e->shift_r) {
3165 val = (reg_val >> e->shift_r) & e->mask;
3727b496
LPC		 3166 val = snd_soc_enum_val_to_item(e, val);
3167 ucontrol->value.enumerated.item[1] = val;
2e72f8e3
PU		 3168 }
3169
69128316 3170 return 0;
2e72f8e3 3171}
2b97eabc 3172EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
2e72f8e3
PU		 3173
3174/**
2b97eabc 3175 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
2e72f8e3
PU		 3176 * @kcontrol: mixer control
3177 * @ucontrol: control element information
3178 *
2b97eabc 3179 * Callback to set the value of a dapm enumerated double mixer control.
2e72f8e3
PU		 3180 *
3181 * Returns 0 for success.
3182 */
2b97eabc 3183int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
2e72f8e3
PU		 3184 struct snd_ctl_elem_value *ucontrol)
3185{
ce0fc93a
LPC		 3186 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3187 struct snd_soc_card *card = dapm->card;
74155556 3188 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3727b496 3189 unsigned int *item = ucontrol->value.enumerated.item;
561ed680 3190 unsigned int val, change, reg_change = 0;
46f5822f 3191 unsigned int mask;
97404f2e 3192 struct snd_soc_dapm_update update;
52765976 3193 int ret = 0;
2e72f8e3 3194
3727b496 3195 if (item[0] >= e->items)
2e72f8e3 3196 return -EINVAL;
3727b496
LPC		 3197
3198 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
2e72f8e3
PU		 3199 mask = e->mask << e->shift_l;
3200 if (e->shift_l != e->shift_r) {
3727b496 3201 if (item[1] > e->items)
2e72f8e3 3202 return -EINVAL;
3727b496 3203 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_l;
2e72f8e3
PU		 3204 mask |= e->mask << e->shift_r;
3205 }
3206
3cd04343 3207 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
fafd2176 3208
561ed680
CK		 3209 change = dapm_kcontrol_set_value(kcontrol, val);
3210
236aaa68 3211 if (e->reg != SND_SOC_NOPM)
561ed680 3212 reg_change = soc_dapm_test_bits(dapm, e->reg, mask, val);
236aaa68 3213
561ed680
CK		 3214 if (change || reg_change) {
3215 if (reg_change) {
236aaa68
LPC		 3216 update.kcontrol = kcontrol;
3217 update.reg = e->reg;
3218 update.mask = mask;
3219 update.val = val;
3220 card->update = &update;
3221 }
561ed680 3222 change |= reg_change;
1642e3d4 3223
3727b496 3224 ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
fafd2176 3225
564c6504 3226 card->update = NULL;
fafd2176 3227 }
2e72f8e3 3228
a73fb2df 3229 mutex_unlock(&card->dapm_mutex);
52765976
NC		 3230
3231 if (ret > 0)
3232 soc_dpcm_runtime_update(card);
3233
97404f2e 3234 return change;
2e72f8e3 3235}
2b97eabc 3236EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
2e72f8e3 3237
8b37dbd2
MB		 3238/**
3239 * snd_soc_dapm_info_pin_switch - Info for a pin switch
3240 *
3241 * @kcontrol: mixer control
3242 * @uinfo: control element information
3243 *
3244 * Callback to provide information about a pin switch control.
3245 */
3246int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
3247 struct snd_ctl_elem_info *uinfo)
3248{
3249 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3250 uinfo->count = 1;
3251 uinfo->value.integer.min = 0;
3252 uinfo->value.integer.max = 1;
3253
3254 return 0;
3255}
3256EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
3257
3258/**
3259 * snd_soc_dapm_get_pin_switch - Get information for a pin switch
3260 *
3261 * @kcontrol: mixer control
3262 * @ucontrol: Value
3263 */
3264int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
3265 struct snd_ctl_elem_value *ucontrol)
3266{
48a8c394 3267 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
8b37dbd2
MB		 3268 const char *pin = (const char *)kcontrol->private_value;
3269
3cd04343 3270 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
8b37dbd2
MB		 3271
3272 ucontrol->value.integer.value[0] =
48a8c394 3273 snd_soc_dapm_get_pin_status(&card->dapm, pin);
8b37dbd2 3274
a73fb2df 3275 mutex_unlock(&card->dapm_mutex);
8b37dbd2
MB		 3276
3277 return 0;
3278}
3279EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
3280
3281/**
3282 * snd_soc_dapm_put_pin_switch - Set information for a pin switch
3283 *
3284 * @kcontrol: mixer control
3285 * @ucontrol: Value
3286 */
3287int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
3288 struct snd_ctl_elem_value *ucontrol)
3289{
48a8c394 3290 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
8b37dbd2
MB		 3291 const char *pin = (const char *)kcontrol->private_value;
3292
8b37dbd2 3293 if (ucontrol->value.integer.value[0])
48a8c394 3294 snd_soc_dapm_enable_pin(&card->dapm, pin);
8b37dbd2 3295 else
48a8c394 3296 snd_soc_dapm_disable_pin(&card->dapm, pin);
8b37dbd2 3297
a73fb2df 3298 snd_soc_dapm_sync(&card->dapm);
8b37dbd2
MB		 3299 return 0;
3300}
3301EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
3302
cc76e7de 3303struct snd_soc_dapm_widget *
5ba06fc9 3304snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
02aa78ab
LG		 3305 const struct snd_soc_dapm_widget *widget)
3306{
3307 struct snd_soc_dapm_widget *w;
3308
3309 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3310 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3311 if (!w)
3312 dev_err(dapm->dev,
3313 "ASoC: Failed to create DAPM control %s\n",
3314 widget->name);
3315
3316 mutex_unlock(&dapm->card->dapm_mutex);
3317 return w;
3318}
a5d5639f 3319EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
02aa78ab
LG		 3320
3321struct snd_soc_dapm_widget *
3322snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
5ba06fc9 3323 const struct snd_soc_dapm_widget *widget)
2b97eabc 3324{
a3423b02 3325 enum snd_soc_dapm_direction dir;
2b97eabc 3326 struct snd_soc_dapm_widget *w;
94f99c87 3327 const char *prefix;
62ea874a 3328 int ret;
2b97eabc
RP		 3329
3330 if ((w = dapm_cnew_widget(widget)) == NULL)
5ba06fc9 3331 return NULL;
2b97eabc 3332
62ea874a
MB		 3333 switch (w->id) {
3334 case snd_soc_dapm_regulator_supply:
a3cc056b
LG		 3335 w->regulator = devm_regulator_get(dapm->dev, w->name);
3336 if (IS_ERR(w->regulator)) {
3337 ret = PTR_ERR(w->regulator);
30a6a1a4 3338 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
62ea874a 3339 w->name, ret);
5ba06fc9 3340 return NULL;
62ea874a 3341 }
8784c77a 3342
de9ba98b 3343 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
8784c77a
MB		 3344 ret = regulator_allow_bypass(w->regulator, true);
3345 if (ret != 0)
3346 dev_warn(w->dapm->dev,
30686c35 3347 "ASoC: Failed to bypass %s: %d\n",
8784c77a
MB		 3348 w->name, ret);
3349 }
62ea874a 3350 break;
d7e7eb91 3351 case snd_soc_dapm_clock_supply:
165961ef 3352#ifdef CONFIG_CLKDEV_LOOKUP
695594f1 3353 w->clk = devm_clk_get(dapm->dev, w->name);
d7e7eb91
OL		 3354 if (IS_ERR(w->clk)) {
3355 ret = PTR_ERR(w->clk);
30a6a1a4 3356 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
d7e7eb91
OL		 3357 w->name, ret);
3358 return NULL;
3359 }
ec02995a
MB		 3360#else
3361 return NULL;
3362#endif
d7e7eb91 3363 break;
62ea874a
MB		 3364 default:
3365 break;
3366 }
2b97eabc 3367
94f99c87 3368 prefix = soc_dapm_prefix(dapm);
a798c24a 3369 if (prefix)
94f99c87 3370 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, widget->name);
a798c24a 3371 else
48068961 3372 w->name = kstrdup_const(widget->name, GFP_KERNEL);
ead9b919
JN		 3373 if (w->name == NULL) {
3374 kfree(w);
5ba06fc9 3375 return NULL;
ead9b919 3376 }
ead9b919 3377
7ca3a18b 3378 switch (w->id) {
6dd98b0a 3379 case snd_soc_dapm_mic:
a3423b02 3380 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
7ca3a18b
MB		 3381 w->power_check = dapm_generic_check_power;
3382 break;
86d75003
LPC		 3383 case snd_soc_dapm_input:
3384 if (!dapm->card->fully_routed)
a3423b02 3385 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
86d75003
LPC		 3386 w->power_check = dapm_generic_check_power;
3387 break;
6dd98b0a
LPC		 3388 case snd_soc_dapm_spk:
3389 case snd_soc_dapm_hp:
a3423b02 3390 w->is_ep = SND_SOC_DAPM_EP_SINK;
7ca3a18b
MB		 3391 w->power_check = dapm_generic_check_power;
3392 break;
86d75003
LPC		 3393 case snd_soc_dapm_output:
3394 if (!dapm->card->fully_routed)
a3423b02 3395 w->is_ep = SND_SOC_DAPM_EP_SINK;
86d75003
LPC		 3396 w->power_check = dapm_generic_check_power;
3397 break;
6dd98b0a
LPC		 3398 case snd_soc_dapm_vmid:
3399 case snd_soc_dapm_siggen:
a3423b02 3400 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
6dd98b0a
LPC		 3401 w->power_check = dapm_always_on_check_power;
3402 break;
56b4437f
VK		 3403 case snd_soc_dapm_sink:
3404 w->is_ep = SND_SOC_DAPM_EP_SINK;
3405 w->power_check = dapm_always_on_check_power;
3406 break;
3407
6dd98b0a 3408 case snd_soc_dapm_mux:
d714f97c 3409 case snd_soc_dapm_demux:
6dd98b0a
LPC		 3410 case snd_soc_dapm_switch:
3411 case snd_soc_dapm_mixer:
3412 case snd_soc_dapm_mixer_named_ctl:
63c69a6e
MB		 3413 case snd_soc_dapm_adc:
3414 case snd_soc_dapm_aif_out:
3415 case snd_soc_dapm_dac:
3416 case snd_soc_dapm_aif_in:
7ca3a18b
MB		 3417 case snd_soc_dapm_pga:
3418 case snd_soc_dapm_out_drv:
7ca3a18b 3419 case snd_soc_dapm_micbias:
7ca3a18b 3420 case snd_soc_dapm_line:
c74184ed 3421 case snd_soc_dapm_dai_link:
cdef2ad3
LPC		 3422 case snd_soc_dapm_dai_out:
3423 case snd_soc_dapm_dai_in:
7ca3a18b
MB		 3424 w->power_check = dapm_generic_check_power;
3425 break;
3426 case snd_soc_dapm_supply:
62ea874a 3427 case snd_soc_dapm_regulator_supply:
d7e7eb91 3428 case snd_soc_dapm_clock_supply:
57295073 3429 case snd_soc_dapm_kcontrol:
6dd98b0a 3430 w->is_supply = 1;
7ca3a18b
MB		 3431 w->power_check = dapm_supply_check_power;
3432 break;
3433 default:
3434 w->power_check = dapm_always_on_check_power;
3435 break;
3436 }
3437
ce6120cc 3438 w->dapm = dapm;
2b97eabc 3439 INIT_LIST_HEAD(&w->list);
db432b41 3440 INIT_LIST_HEAD(&w->dirty);
92fa1242 3441 list_add_tail(&w->list, &dapm->card->widgets);
2b97eabc 3442
a3423b02
LPC		 3443 snd_soc_dapm_for_each_direction(dir) {
3444 INIT_LIST_HEAD(&w->edges[dir]);
3445 w->endpoints[dir] = -1;
3446 }
92a99ea4 3447
2b97eabc
RP		 3448 /* machine layer set ups unconnected pins and insertions */
3449 w->connected = 1;
5ba06fc9 3450 return w;
2b97eabc 3451}
2b97eabc 3452
4ba1327a
MB		 3453/**
3454 * snd_soc_dapm_new_controls - create new dapm controls
ce6120cc 3455 * @dapm: DAPM context
4ba1327a
MB		 3456 * @widget: widget array
3457 * @num: number of widgets
3458 *
3459 * Creates new DAPM controls based upon the templates.
3460 *
3461 * Returns 0 for success else error.
3462 */
ce6120cc 3463int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
4ba1327a
MB		 3464 const struct snd_soc_dapm_widget *widget,
3465 int num)
3466{
5ba06fc9
MB		 3467 struct snd_soc_dapm_widget *w;
3468 int i;
60884c27 3469 int ret = 0;
4ba1327a 3470
a73fb2df 3471 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
4ba1327a 3472 for (i = 0; i < num; i++) {
02aa78ab 3473 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
5ba06fc9 3474 if (!w) {
f7d41ae8 3475 dev_err(dapm->dev,
5ba06fc9
MB		 3476 "ASoC: Failed to create DAPM control %s\n",
3477 widget->name);
60884c27
DC		 3478 ret = -ENOMEM;
3479 break;
b8b33cb5 3480 }
4ba1327a
MB		 3481 widget++;
3482 }
a73fb2df 3483 mutex_unlock(&dapm->card->dapm_mutex);
60884c27 3484 return ret;
4ba1327a
MB		 3485}
3486EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
3487
c74184ed
MB		 3488static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
3489 struct snd_kcontrol *kcontrol, int event)
3490{
3491 struct snd_soc_dapm_path *source_p, *sink_p;
3492 struct snd_soc_dai *source, *sink;
c6615082 3493 const struct snd_soc_pcm_stream *config = w->params + w->params_select;
c74184ed 3494 struct snd_pcm_substream substream;
9747cec2 3495 struct snd_pcm_hw_params *params = NULL;
c74184ed
MB		 3496 u64 fmt;
3497 int ret;
3498
bf4edea8 3499 if (WARN_ON(!config) ||
a3423b02
LPC		 3500 WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
3501 list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
bf4edea8 3502 return -EINVAL;
c74184ed
MB		 3503
3504 /* We only support a single source and sink, pick the first */
a3423b02
LPC		 3505 source_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_OUT],
3506 struct snd_soc_dapm_path,
3507 list_node[SND_SOC_DAPM_DIR_OUT]);
3508 sink_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_IN],
3509 struct snd_soc_dapm_path,
3510 list_node[SND_SOC_DAPM_DIR_IN]);
c74184ed
MB		 3511
3512 source = source_p->source->priv;
3513 sink = sink_p->sink->priv;
3514
3515 /* Be a little careful as we don't want to overflow the mask array */
3516 if (config->formats) {
3517 fmt = ffs(config->formats) - 1;
3518 } else {
30a6a1a4 3519 dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n",
c74184ed
MB		 3520 config->formats);
3521 fmt = 0;
3522 }
3523
3524 /* Currently very limited parameter selection */
9747cec2
MB		 3525 params = kzalloc(sizeof(*params), GFP_KERNEL);
3526 if (!params) {
3527 ret = -ENOMEM;
3528 goto out;
3529 }
3530 snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
c74184ed 3531
9747cec2 3532 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
c74184ed 3533 config->rate_min;
9747cec2 3534 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
c74184ed
MB		 3535 config->rate_max;
3536
9747cec2 3537 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
c74184ed 3538 = config->channels_min;
9747cec2 3539 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
c74184ed
MB		 3540 = config->channels_max;
3541
3542 memset(&substream, 0, sizeof(substream));
3543
3544 switch (event) {
3545 case SND_SOC_DAPM_PRE_PMU:
93e6958a 3546 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
9b8ef9f6
JK		 3547 if (source->driver->ops && source->driver->ops->startup) {
3548 ret = source->driver->ops->startup(&substream, source);
3549 if (ret < 0) {
3550 dev_err(source->dev,
3551 "ASoC: startup() failed: %d\n", ret);
3552 goto out;
3553 }
3554 source->active++;
3555 }
93e6958a
BC		 3556 ret = soc_dai_hw_params(&substream, params, source);
3557 if (ret < 0)
3558 goto out;
c74184ed 3559
93e6958a 3560 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
9b8ef9f6
JK		 3561 if (sink->driver->ops && sink->driver->ops->startup) {
3562 ret = sink->driver->ops->startup(&substream, sink);
3563 if (ret < 0) {
3564 dev_err(sink->dev,
3565 "ASoC: startup() failed: %d\n", ret);
3566 goto out;
3567 }
3568 sink->active++;
3569 }
93e6958a
BC		 3570 ret = soc_dai_hw_params(&substream, params, sink);
3571 if (ret < 0)
3572 goto out;
c74184ed
MB		 3573 break;
3574
3575 case SND_SOC_DAPM_POST_PMU:
da18396f
MB		 3576 ret = snd_soc_dai_digital_mute(sink, 0,
3577 SNDRV_PCM_STREAM_PLAYBACK);
c74184ed 3578 if (ret != 0 && ret != -ENOTSUPP)
30a6a1a4 3579 dev_warn(sink->dev, "ASoC: Failed to unmute: %d\n", ret);
9747cec2 3580 ret = 0;
c74184ed
MB		 3581 break;
3582
3583 case SND_SOC_DAPM_PRE_PMD:
da18396f
MB		 3584 ret = snd_soc_dai_digital_mute(sink, 1,
3585 SNDRV_PCM_STREAM_PLAYBACK);
c74184ed 3586 if (ret != 0 && ret != -ENOTSUPP)
30a6a1a4 3587 dev_warn(sink->dev, "ASoC: Failed to mute: %d\n", ret);
9747cec2 3588 ret = 0;
9b8ef9f6
JK		 3589
3590 source->active--;
3591 if (source->driver->ops && source->driver->ops->shutdown) {
3592 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3593 source->driver->ops->shutdown(&substream, source);
3594 }
3595
3596 sink->active--;
3597 if (sink->driver->ops && sink->driver->ops->shutdown) {
3598 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
3599 sink->driver->ops->shutdown(&substream, sink);
3600 }
c74184ed
MB		 3601 break;
3602
3603 default:
a6ed0608 3604 WARN(1, "Unknown event %d\n", event);
75881df3 3605 ret = -EINVAL;
c74184ed
MB		 3606 }
3607
9747cec2
MB		 3608out:
3609 kfree(params);
3610 return ret;
c74184ed
MB		 3611}
3612
c6615082
NO		 3613static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
3614 struct snd_ctl_elem_value *ucontrol)
3615{
3616 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3617
741338f9 3618 ucontrol->value.enumerated.item[0] = w->params_select;
c6615082
NO		 3619
3620 return 0;
3621}
3622
3623static int snd_soc_dapm_dai_link_put(struct snd_kcontrol *kcontrol,
3624 struct snd_ctl_elem_value *ucontrol)
3625{
3626 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3627
3628 /* Can't change the config when widget is already powered */
3629 if (w->power)
3630 return -EBUSY;
3631
741338f9 3632 if (ucontrol->value.enumerated.item[0] == w->params_select)
c6615082
NO		 3633 return 0;
3634
741338f9 3635 if (ucontrol->value.enumerated.item[0] >= w->num_params)
c6615082
NO		 3636 return -EINVAL;
3637
741338f9 3638 w->params_select = ucontrol->value.enumerated.item[0];
c6615082
NO		 3639
3640 return 0;
3641}
3642
c74184ed
MB		 3643int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
3644 const struct snd_soc_pcm_stream *params,
c6615082 3645 unsigned int num_params,
c74184ed
MB		 3646 struct snd_soc_dapm_widget *source,
3647 struct snd_soc_dapm_widget *sink)
3648{
c74184ed
MB		 3649 struct snd_soc_dapm_widget template;
3650 struct snd_soc_dapm_widget *w;
c74184ed 3651 char *link_name;
c6615082
NO		 3652 int ret, count;
3653 unsigned long private_value;
3654 const char **w_param_text;
3655 struct soc_enum w_param_enum[] = {
3656 SOC_ENUM_SINGLE(0, 0, 0, NULL),
3657 };
3658 struct snd_kcontrol_new kcontrol_dai_link[] = {
3659 SOC_ENUM_EXT(NULL, w_param_enum[0],
3660 snd_soc_dapm_dai_link_get,
3661 snd_soc_dapm_dai_link_put),
3662 };
3663 const struct snd_soc_pcm_stream *config = params;
3664
3665 w_param_text = devm_kcalloc(card->dev, num_params,
3666 sizeof(char *), GFP_KERNEL);
3667 if (!w_param_text)
c74184ed 3668 return -ENOMEM;
c74184ed 3669
46172b6c
CK		 3670 link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
3671 source->name, sink->name);
c6615082
NO		 3672 if (!link_name) {
3673 ret = -ENOMEM;
3674 goto outfree_w_param;
3675 }
c74184ed 3676
c6615082
NO		 3677 for (count = 0 ; count < num_params; count++) {
3678 if (!config->stream_name) {
3679 dev_warn(card->dapm.dev,
3680 "ASoC: anonymous config %d for dai link %s\n",
3681 count, link_name);
c6615082 3682 w_param_text[count] =
46172b6c
CK		 3683 devm_kasprintf(card->dev, GFP_KERNEL,
3684 "Anonymous Configuration %d",
3685 count);
c6615082
NO		 3686 if (!w_param_text[count]) {
3687 ret = -ENOMEM;
3688 goto outfree_link_name;
3689 }
c6615082
NO		 3690 } else {
3691 w_param_text[count] = devm_kmemdup(card->dev,
3692 config->stream_name,
3693 strlen(config->stream_name) + 1,
3694 GFP_KERNEL);
3695 if (!w_param_text[count]) {
3696 ret = -ENOMEM;
3697 goto outfree_link_name;
3698 }
3699 }
3700 config++;
3701 }
3702 w_param_enum[0].items = num_params;
3703 w_param_enum[0].texts = w_param_text;
c74184ed
MB		 3704
3705 memset(&template, 0, sizeof(template));
3706 template.reg = SND_SOC_NOPM;
3707 template.id = snd_soc_dapm_dai_link;
3708 template.name = link_name;
3709 template.event = snd_soc_dai_link_event;
3710 template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
3711 SND_SOC_DAPM_PRE_PMD;
c6615082
NO		 3712 template.num_kcontrols = 1;
3713 /* duplicate w_param_enum on heap so that memory persists */
3714 private_value =
3715 (unsigned long) devm_kmemdup(card->dev,
3716 (void *)(kcontrol_dai_link[0].private_value),
3717 sizeof(struct soc_enum), GFP_KERNEL);
3718 if (!private_value) {
3719 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3720 link_name);
3721 ret = -ENOMEM;
3722 goto outfree_link_name;
3723 }
3724 kcontrol_dai_link[0].private_value = private_value;
3725 /* duplicate kcontrol_dai_link on heap so that memory persists */
3726 template.kcontrol_news =
3727 devm_kmemdup(card->dev, &kcontrol_dai_link[0],
3728 sizeof(struct snd_kcontrol_new),
3729 GFP_KERNEL);
3730 if (!template.kcontrol_news) {
3731 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3732 link_name);
3733 ret = -ENOMEM;
3734 goto outfree_private_value;
3735 }
c74184ed 3736
30a6a1a4 3737 dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
c74184ed 3738
02aa78ab 3739 w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
c74184ed 3740 if (!w) {
30a6a1a4 3741 dev_err(card->dev, "ASoC: Failed to create %s widget\n",
c74184ed 3742 link_name);
c6615082
NO		 3743 ret = -ENOMEM;
3744 goto outfree_kcontrol_news;
c74184ed
MB		 3745 }
3746
3747 w->params = params;
c6615082 3748 w->num_params = num_params;
c74184ed 3749
fe83897f
LPC		 3750 ret = snd_soc_dapm_add_path(&card->dapm, source, w, NULL, NULL);
3751 if (ret)
c6615082 3752 goto outfree_w;
fe83897f 3753 return snd_soc_dapm_add_path(&card->dapm, w, sink, NULL, NULL);
c6615082
NO		 3754
3755outfree_w:
3756 devm_kfree(card->dev, w);
3757outfree_kcontrol_news:
3758 devm_kfree(card->dev, (void *)template.kcontrol_news);
3759outfree_private_value:
3760 devm_kfree(card->dev, (void *)private_value);
3761outfree_link_name:
3762 devm_kfree(card->dev, link_name);
3763outfree_w_param:
3764 for (count = 0 ; count < num_params; count++)
3765 devm_kfree(card->dev, (void *)w_param_text[count]);
3766 devm_kfree(card->dev, w_param_text);
3767
3768 return ret;
c74184ed
MB		 3769}
3770
888df395
MB		 3771int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
3772 struct snd_soc_dai *dai)
2b97eabc 3773{
888df395 3774 struct snd_soc_dapm_widget template;
2b97eabc
RP		 3775 struct snd_soc_dapm_widget *w;
3776
888df395
MB		 3777 WARN_ON(dapm->dev != dai->dev);
3778
3779 memset(&template, 0, sizeof(template));
3780 template.reg = SND_SOC_NOPM;
3781
3782 if (dai->driver->playback.stream_name) {
4616274d 3783 template.id = snd_soc_dapm_dai_in;
888df395
MB		 3784 template.name = dai->driver->playback.stream_name;
3785 template.sname = dai->driver->playback.stream_name;
3786
30a6a1a4 3787 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
888df395
MB		 3788 template.name);
3789
02aa78ab 3790 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
888df395 3791 if (!w) {
30a6a1a4 3792 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
888df395 3793 dai->driver->playback.stream_name);
298402a3 3794 return -ENOMEM;
888df395
MB		 3795 }
3796
3797 w->priv = dai;
3798 dai->playback_widget = w;
3799 }
3800
3801 if (dai->driver->capture.stream_name) {
4616274d 3802 template.id = snd_soc_dapm_dai_out;
888df395
MB		 3803 template.name = dai->driver->capture.stream_name;
3804 template.sname = dai->driver->capture.stream_name;
3805
30a6a1a4 3806 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
888df395
MB		 3807 template.name);
3808
02aa78ab 3809 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
888df395 3810 if (!w) {
30a6a1a4 3811 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
888df395 3812 dai->driver->capture.stream_name);
298402a3 3813 return -ENOMEM;
888df395
MB		 3814 }
3815
3816 w->priv = dai;
3817 dai->capture_widget = w;
3818 }
3819
3820 return 0;
3821}
3822
3823int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
3824{
3825 struct snd_soc_dapm_widget *dai_w, *w;
0f9bd7b1 3826 struct snd_soc_dapm_widget *src, *sink;
888df395 3827 struct snd_soc_dai *dai;
888df395
MB		 3828
3829 /* For each DAI widget... */
3830 list_for_each_entry(dai_w, &card->widgets, list) {
4616274d
MB		 3831 switch (dai_w->id) {
3832 case snd_soc_dapm_dai_in:
3833 case snd_soc_dapm_dai_out:
3834 break;
3835 default:
2b97eabc 3836 continue;
4616274d 3837 }
888df395
MB		 3838
3839 dai = dai_w->priv;
3840
3841 /* ...find all widgets with the same stream and link them */
3842 list_for_each_entry(w, &card->widgets, list) {
3843 if (w->dapm != dai_w->dapm)
3844 continue;
3845
4616274d
MB		 3846 switch (w->id) {
3847 case snd_soc_dapm_dai_in:
3848 case snd_soc_dapm_dai_out:
888df395 3849 continue;
4616274d
MB		 3850 default:
3851 break;
3852 }
888df395 3853
a798c24a 3854 if (!w->sname || !strstr(w->sname, dai_w->sname))
888df395
MB		 3855 continue;
3856
0f9bd7b1
LPC		 3857 if (dai_w->id == snd_soc_dapm_dai_in) {
3858 src = dai_w;
3859 sink = w;
3860 } else {
3861 src = w;
3862 sink = dai_w;
2b97eabc 3863 }
0f9bd7b1
LPC		 3864 dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
3865 snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
2b97eabc
RP		 3866 }
3867 }
2b97eabc 3868
888df395
MB		 3869 return 0;
3870}
64a648c2 3871
44ba2641
BC		 3872static void dapm_connect_dai_link_widgets(struct snd_soc_card *card,
3873 struct snd_soc_pcm_runtime *rtd)
b893ea5f 3874{
44ba2641 3875 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
9887c20b 3876 struct snd_soc_dapm_widget *sink, *source;
b893ea5f
LG		 3877 int i;
3878
44ba2641
BC		 3879 for (i = 0; i < rtd->num_codecs; i++) {
3880 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
b893ea5f 3881
b893ea5f
LG		 3882 /* connect BE DAI playback if widgets are valid */
3883 if (codec_dai->playback_widget && cpu_dai->playback_widget) {
9887c20b
LPC		 3884 source = cpu_dai->playback_widget;
3885 sink = codec_dai->playback_widget;
b893ea5f 3886 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
f4333203
LPC		 3887 cpu_dai->component->name, source->name,
3888 codec_dai->component->name, sink->name);
b893ea5f 3889
9887c20b
LPC		 3890 snd_soc_dapm_add_path(&card->dapm, source, sink,
3891 NULL, NULL);
b893ea5f
LG		 3892 }
3893
3894 /* connect BE DAI capture if widgets are valid */
3895 if (codec_dai->capture_widget && cpu_dai->capture_widget) {
9887c20b
LPC		 3896 source = codec_dai->capture_widget;
3897 sink = cpu_dai->capture_widget;
b893ea5f 3898 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
f4333203
LPC		 3899 codec_dai->component->name, source->name,
3900 cpu_dai->component->name, sink->name);
b893ea5f 3901
9887c20b
LPC		 3902 snd_soc_dapm_add_path(&card->dapm, source, sink,
3903 NULL, NULL);
b893ea5f 3904 }
b893ea5f
LG		 3905 }
3906}
3907
c471fdd1 3908static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
d9b0951b 3909 int event)
2b97eabc 3910{
c471fdd1 3911 struct snd_soc_dapm_widget *w;
a3423b02 3912 unsigned int ep;
7bd3a6f3 3913
c471fdd1
LPC		 3914 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
3915 w = dai->playback_widget;
3916 else
3917 w = dai->capture_widget;
fe360685 3918
c471fdd1
LPC		 3919 if (w) {
3920 dapm_mark_dirty(w, "stream event");
d9b0951b 3921
a3423b02
LPC		 3922 if (w->id == snd_soc_dapm_dai_in) {
3923 ep = SND_SOC_DAPM_EP_SOURCE;
3924 dapm_widget_invalidate_input_paths(w);
3925 } else {
3926 ep = SND_SOC_DAPM_EP_SINK;
3927 dapm_widget_invalidate_output_paths(w);
3928 }
3929
d9b0951b
LG		 3930 switch (event) {
3931 case SND_SOC_DAPM_STREAM_START:
c471fdd1 3932 w->active = 1;
a3423b02 3933 w->is_ep = ep;
d9b0951b
LG		 3934 break;
3935 case SND_SOC_DAPM_STREAM_STOP:
c471fdd1 3936 w->active = 0;
a3423b02 3937 w->is_ep = 0;
d9b0951b
LG		 3938 break;
3939 case SND_SOC_DAPM_STREAM_SUSPEND:
3940 case SND_SOC_DAPM_STREAM_RESUME:
3941 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
3942 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
3943 break;
3944 }
3945 }
c471fdd1 3946}
d9b0951b 3947
44ba2641
BC		 3948void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
3949{
1a497983 3950 struct snd_soc_pcm_runtime *rtd;
44ba2641
BC		 3951
3952 /* for each BE DAI link... */
1a497983 3953 list_for_each_entry(rtd, &card->rtd_list, list) {
44ba2641
BC		 3954 /*
3955 * dynamic FE links have no fixed DAI mapping.
3956 * CODEC<->CODEC links have no direct connection.
3957 */
3958 if (rtd->dai_link->dynamic || rtd->dai_link->params)
3959 continue;
3960
3961 dapm_connect_dai_link_widgets(card, rtd);
3962 }
3963}
3964
c471fdd1
LPC		 3965static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3966 int event)
3967{
44ba2641
BC		 3968 int i;
3969
c471fdd1 3970 soc_dapm_dai_stream_event(rtd->cpu_dai, stream, event);
44ba2641
BC		 3971 for (i = 0; i < rtd->num_codecs; i++)
3972 soc_dapm_dai_stream_event(rtd->codec_dais[i], stream, event);
2b97eabc 3973
95dd5cd6 3974 dapm_power_widgets(rtd->card, event);
ce6120cc
LG		 3975}
3976
3977/**
3978 * snd_soc_dapm_stream_event - send a stream event to the dapm core
3979 * @rtd: PCM runtime data
3980 * @stream: stream name
3981 * @event: stream event
3982 *
3983 * Sends a stream event to the dapm core. The core then makes any
3984 * necessary widget power changes.
3985 *
3986 * Returns 0 for success else error.
3987 */
d9b0951b
LG		 3988void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3989 int event)
ce6120cc 3990{
a73fb2df 3991 struct snd_soc_card *card = rtd->card;
ce6120cc 3992
3cd04343 3993 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
d9b0951b 3994 soc_dapm_stream_event(rtd, stream, event);
a73fb2df 3995 mutex_unlock(&card->dapm_mutex);
2b97eabc 3996}
2b97eabc 3997
11391100
CK		 3998/**
3999 * snd_soc_dapm_enable_pin_unlocked - enable pin.
4000 * @dapm: DAPM context
4001 * @pin: pin name
4002 *
4003 * Enables input/output pin and its parents or children widgets iff there is
4004 * a valid audio route and active audio stream.
4005 *
4006 * Requires external locking.
4007 *
4008 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4009 * do any widget power switching.
4010 */
4011int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4012 const char *pin)
4013{
4014 return snd_soc_dapm_set_pin(dapm, pin, 1);
4015}
4016EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
4017
2b97eabc 4018/**
a5302181 4019 * snd_soc_dapm_enable_pin - enable pin.
ce6120cc 4020 * @dapm: DAPM context
a5302181 4021 * @pin: pin name
2b97eabc 4022 *
74b8f955 4023 * Enables input/output pin and its parents or children widgets iff there is
a5302181 4024 * a valid audio route and active audio stream.
11391100 4025 *
a5302181
LG		 4026 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4027 * do any widget power switching.
2b97eabc 4028 */
ce6120cc 4029int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
2b97eabc 4030{
11391100
CK		 4031 int ret;
4032
4033 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4034
4035 ret = snd_soc_dapm_set_pin(dapm, pin, 1);
4036
4037 mutex_unlock(&dapm->card->dapm_mutex);
4038
4039 return ret;
a5302181
LG		 4040}
4041EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
2b97eabc 4042
da34183e 4043/**
11391100 4044 * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
ce6120cc 4045 * @dapm: DAPM context
da34183e
MB		 4046 * @pin: pin name
4047 *
4048 * Enables input/output pin regardless of any other state. This is
4049 * intended for use with microphone bias supplies used in microphone
4050 * jack detection.
4051 *
11391100
CK		 4052 * Requires external locking.
4053 *
da34183e
MB		 4054 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4055 * do any widget power switching.
4056 */
11391100
CK		 4057int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4058 const char *pin)
da34183e 4059{
91a5fca4 4060 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
da34183e 4061
91a5fca4 4062 if (!w) {
30a6a1a4 4063 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
91a5fca4 4064 return -EINVAL;
0d86733c
MB		 4065 }
4066
30a6a1a4 4067 dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
92a99ea4
LPC		 4068 if (!w->connected) {
4069 /*
4070 * w->force does not affect the number of input or output paths,
4071 * so we only have to recheck if w->connected is changed
4072 */
4073 dapm_widget_invalidate_input_paths(w);
4074 dapm_widget_invalidate_output_paths(w);
4075 w->connected = 1;
4076 }
91a5fca4 4077 w->force = 1;
75c1f891 4078 dapm_mark_dirty(w, "force enable");
da34183e 4079
91a5fca4 4080 return 0;
da34183e 4081}
11391100
CK		 4082EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
4083
4084/**
4085 * snd_soc_dapm_force_enable_pin - force a pin to be enabled
4086 * @dapm: DAPM context
4087 * @pin: pin name
4088 *
4089 * Enables input/output pin regardless of any other state. This is
4090 * intended for use with microphone bias supplies used in microphone
4091 * jack detection.
4092 *
4093 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4094 * do any widget power switching.
4095 */
4096int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
4097 const char *pin)
4098{
4099 int ret;
4100
4101 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4102
4103 ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
4104
4105 mutex_unlock(&dapm->card->dapm_mutex);
4106
4107 return ret;
4108}
da34183e
MB		 4109EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
4110
11391100
CK		 4111/**
4112 * snd_soc_dapm_disable_pin_unlocked - disable pin.
4113 * @dapm: DAPM context
4114 * @pin: pin name
4115 *
4116 * Disables input/output pin and its parents or children widgets.
4117 *
4118 * Requires external locking.
4119 *
4120 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4121 * do any widget power switching.
4122 */
4123int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4124 const char *pin)
4125{
4126 return snd_soc_dapm_set_pin(dapm, pin, 0);
4127}
4128EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
4129
a5302181
LG		 4130/**
4131 * snd_soc_dapm_disable_pin - disable pin.
ce6120cc 4132 * @dapm: DAPM context
a5302181
LG		 4133 * @pin: pin name
4134 *
74b8f955 4135 * Disables input/output pin and its parents or children widgets.
11391100 4136 *
a5302181
LG		 4137 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4138 * do any widget power switching.
4139 */
ce6120cc
LG		 4140int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
4141 const char *pin)
a5302181 4142{
11391100
CK		 4143 int ret;
4144
4145 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4146
4147 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4148
4149 mutex_unlock(&dapm->card->dapm_mutex);
4150
4151 return ret;
2b97eabc 4152}
a5302181 4153EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
2b97eabc 4154
11391100
CK		 4155/**
4156 * snd_soc_dapm_nc_pin_unlocked - permanently disable pin.
4157 * @dapm: DAPM context
4158 * @pin: pin name
4159 *
4160 * Marks the specified pin as being not connected, disabling it along
4161 * any parent or child widgets. At present this is identical to
4162 * snd_soc_dapm_disable_pin() but in future it will be extended to do
4163 * additional things such as disabling controls which only affect
4164 * paths through the pin.
4165 *
4166 * Requires external locking.
4167 *
4168 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4169 * do any widget power switching.
4170 */
4171int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
4172 const char *pin)
4173{
4174 return snd_soc_dapm_set_pin(dapm, pin, 0);
4175}
4176EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
4177
5817b52a
MB		 4178/**
4179 * snd_soc_dapm_nc_pin - permanently disable pin.
ce6120cc 4180 * @dapm: DAPM context
5817b52a
MB		 4181 * @pin: pin name
4182 *
4183 * Marks the specified pin as being not connected, disabling it along
4184 * any parent or child widgets. At present this is identical to
4185 * snd_soc_dapm_disable_pin() but in future it will be extended to do
4186 * additional things such as disabling controls which only affect
4187 * paths through the pin.
4188 *
4189 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4190 * do any widget power switching.
4191 */
ce6120cc 4192int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
5817b52a 4193{
11391100
CK		 4194 int ret;
4195
4196 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4197
4198 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4199
4200 mutex_unlock(&dapm->card->dapm_mutex);
4201
4202 return ret;
5817b52a
MB		 4203}
4204EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
4205
eeec12bf 4206/**
a5302181 4207 * snd_soc_dapm_get_pin_status - get audio pin status
ce6120cc 4208 * @dapm: DAPM context
a5302181 4209 * @pin: audio signal pin endpoint (or start point)
eeec12bf 4210 *
a5302181 4211 * Get audio pin status - connected or disconnected.
eeec12bf 4212 *
a5302181 4213 * Returns 1 for connected otherwise 0.
eeec12bf 4214 */
ce6120cc
LG		 4215int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
4216 const char *pin)
eeec12bf 4217{
91a5fca4 4218 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
eeec12bf 4219
91a5fca4
LPC		 4220 if (w)
4221 return w->connected;
a68b38ad 4222
eeec12bf
GG		 4223 return 0;
4224}
a5302181 4225EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
eeec12bf 4226
1547aba9
MB		 4227/**
4228 * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
ce6120cc 4229 * @dapm: DAPM context
1547aba9
MB		 4230 * @pin: audio signal pin endpoint (or start point)
4231 *
4232 * Mark the given endpoint or pin as ignoring suspend. When the
4233 * system is disabled a path between two endpoints flagged as ignoring
4234 * suspend will not be disabled. The path must already be enabled via
4235 * normal means at suspend time, it will not be turned on if it was not
4236 * already enabled.
4237 */
ce6120cc
LG		 4238int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
4239 const char *pin)
1547aba9 4240{
91a5fca4 4241 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
1547aba9 4242
91a5fca4 4243 if (!w) {
30a6a1a4 4244 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
91a5fca4 4245 return -EINVAL;
1547aba9
MB		 4246 }
4247
91a5fca4
LPC		 4248 w->ignore_suspend = 1;
4249
4250 return 0;
1547aba9
MB		 4251}
4252EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
4253
2b97eabc
RP		 4254/**
4255 * snd_soc_dapm_free - free dapm resources
728a5222 4256 * @dapm: DAPM context
2b97eabc
RP		 4257 *
4258 * Free all dapm widgets and resources.
4259 */
ce6120cc 4260void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
2b97eabc 4261{
6c45e126 4262 dapm_debugfs_cleanup(dapm);
ce6120cc 4263 dapm_free_widgets(dapm);
7be31be8 4264 list_del(&dapm->list);
2b97eabc
RP		 4265}
4266EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
4267
57996358 4268static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
51737470 4269{
01005a72 4270 struct snd_soc_card *card = dapm->card;
51737470
MB		 4271 struct snd_soc_dapm_widget *w;
4272 LIST_HEAD(down_list);
4273 int powerdown = 0;
4274
01005a72
LG		 4275 mutex_lock(&card->dapm_mutex);
4276
97c866de
JN		 4277 list_for_each_entry(w, &dapm->card->widgets, list) {
4278 if (w->dapm != dapm)
4279 continue;
51737470 4280 if (w->power) {
828a842f 4281 dapm_seq_insert(w, &down_list, false);
c2caa4da 4282 w->power = 0;
51737470
MB		 4283 powerdown = 1;
4284 }
4285 }
4286
4287 /* If there were no widgets to power down we're already in
4288 * standby.
4289 */
4290 if (powerdown) {
7679e42e
MB		 4291 if (dapm->bias_level == SND_SOC_BIAS_ON)
4292 snd_soc_dapm_set_bias_level(dapm,
4293 SND_SOC_BIAS_PREPARE);
95dd5cd6 4294 dapm_seq_run(card, &down_list, 0, false);
7679e42e
MB		 4295 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
4296 snd_soc_dapm_set_bias_level(dapm,
4297 SND_SOC_BIAS_STANDBY);
51737470 4298 }
01005a72
LG		 4299
4300 mutex_unlock(&card->dapm_mutex);
f0fba2ad
LG		 4301}
4302
4303/*
4304 * snd_soc_dapm_shutdown - callback for system shutdown
4305 */
4306void snd_soc_dapm_shutdown(struct snd_soc_card *card)
4307{
57996358 4308 struct snd_soc_dapm_context *dapm;
f0fba2ad 4309
57996358 4310 list_for_each_entry(dapm, &card->dapm_list, list) {
17282ba4
XX		 4311 if (dapm != &card->dapm) {
4312 soc_dapm_shutdown_dapm(dapm);
4313 if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
4314 snd_soc_dapm_set_bias_level(dapm,
4315 SND_SOC_BIAS_OFF);
4316 }
ce6120cc 4317 }
17282ba4
XX		 4318
4319 soc_dapm_shutdown_dapm(&card->dapm);
4320 if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
4321 snd_soc_dapm_set_bias_level(&card->dapm,
4322 SND_SOC_BIAS_OFF);
51737470
MB		 4323}
4324
2b97eabc 4325/* Module information */
d331124d 4326MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
2b97eabc
RP		 4327MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
4328MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)