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