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