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