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