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