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