blob: 1b4a6eb4317430f2822d35f90200818e35079265 [file] [log] [blame]
Richard Purdie2b97eab2006-10-06 18:32:18 +02001/*
2 * soc-dapm.c -- ALSA SoC Dynamic Audio Power Management
3 *
4 * Copyright 2005 Wolfson Microelectronics PLC.
Liam Girdwoodd3311242008-10-12 13:17:36 +01005 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
Richard Purdie2b97eab2006-10-06 18:32:18 +02006 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
11 *
Richard Purdie2b97eab2006-10-06 18:32:18 +020012 * Features:
13 * o Changes power status of internal codec blocks depending on the
14 * dynamic configuration of codec internal audio paths and active
Mark Brown74b8f952009-06-06 11:26:15 +010015 * DACs/ADCs.
Richard Purdie2b97eab2006-10-06 18:32:18 +020016 * o Platform power domain - can support external components i.e. amps and
Liam Girdwood612a3fe2012-02-06 16:05:29 +000017 * mic/headphone insertion events.
Richard Purdie2b97eab2006-10-06 18:32:18 +020018 * o Automatic Mic Bias support
19 * o Jack insertion power event initiation - e.g. hp insertion will enable
20 * sinks, dacs, etc
Liam Girdwood612a3fe2012-02-06 16:05:29 +000021 * o Delayed power down of audio subsystem to reduce pops between a quick
Richard Purdie2b97eab2006-10-06 18:32:18 +020022 * device reopen.
23 *
Richard Purdie2b97eab2006-10-06 18:32:18 +020024 */
25
26#include <linux/module.h>
27#include <linux/moduleparam.h>
28#include <linux/init.h>
Mark Brown9d0624a2011-02-18 11:49:43 -080029#include <linux/async.h>
Richard Purdie2b97eab2006-10-06 18:32:18 +020030#include <linux/delay.h>
31#include <linux/pm.h>
32#include <linux/bitops.h>
33#include <linux/platform_device.h>
34#include <linux/jiffies.h>
Takashi Iwai20496ff2009-08-24 09:40:34 +020035#include <linux/debugfs.h>
Mark Brownf1aac482011-12-05 15:17:06 +000036#include <linux/pm_runtime.h>
Mark Brown62ea8742012-01-21 21:14:48 +000037#include <linux/regulator/consumer.h>
Ola Liljad7e7eb92012-05-24 15:26:25 +020038#include <linux/clk.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090039#include <linux/slab.h>
Richard Purdie2b97eab2006-10-06 18:32:18 +020040#include <sound/core.h>
41#include <sound/pcm.h>
42#include <sound/pcm_params.h>
Liam Girdwoodce6120c2010-11-05 15:53:46 +020043#include <sound/soc.h>
Richard Purdie2b97eab2006-10-06 18:32:18 +020044#include <sound/initval.h>
45
Mark Brown84e90932010-11-04 00:07:02 -040046#include <trace/events/asoc.h>
47
Mark Brownde02d072011-09-20 21:43:24 +010048#define DAPM_UPDATE_STAT(widget, val) widget->dapm->card->dapm_stats.val++;
49
Lars-Peter Clausen57295072013-08-05 11:27:31 +020050static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
51 struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
52 const char *control,
53 int (*connected)(struct snd_soc_dapm_widget *source,
54 struct snd_soc_dapm_widget *sink));
Vladimir Zapolskiy5353f652015-06-02 00:57:53 +030055
Liam Girdwoodcc76e7d2015-06-04 15:13:09 +010056struct snd_soc_dapm_widget *
Vladimir Zapolskiy5353f652015-06-02 00:57:53 +030057snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
58 const struct snd_soc_dapm_widget *widget);
59
Liam Girdwood02aa78a2015-05-25 18:21:17 +010060struct snd_soc_dapm_widget *
61snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausen57295072013-08-05 11:27:31 +020062 const struct snd_soc_dapm_widget *widget);
63
Richard Purdie2b97eab2006-10-06 18:32:18 +020064/* dapm power sequences - make this per codec in the future */
65static int dapm_up_seq[] = {
Mark Brown38357ab2009-06-06 19:03:23 +010066 [snd_soc_dapm_pre] = 0,
Mark Brown62ea8742012-01-21 21:14:48 +000067 [snd_soc_dapm_regulator_supply] = 1,
Ola Liljad7e7eb92012-05-24 15:26:25 +020068 [snd_soc_dapm_clock_supply] = 1,
Mark Brown1dd275b2013-10-09 13:56:37 +010069 [snd_soc_dapm_supply] = 2,
70 [snd_soc_dapm_micbias] = 3,
Mark Brownc74184e2012-04-04 22:12:09 +010071 [snd_soc_dapm_dai_link] = 2,
Mark Brown1dd275b2013-10-09 13:56:37 +010072 [snd_soc_dapm_dai_in] = 4,
73 [snd_soc_dapm_dai_out] = 4,
74 [snd_soc_dapm_aif_in] = 4,
75 [snd_soc_dapm_aif_out] = 4,
76 [snd_soc_dapm_mic] = 5,
77 [snd_soc_dapm_mux] = 6,
Lars-Peter Clausend714f972015-05-01 18:02:43 +020078 [snd_soc_dapm_demux] = 6,
Mark Brown1dd275b2013-10-09 13:56:37 +010079 [snd_soc_dapm_dac] = 7,
80 [snd_soc_dapm_switch] = 8,
81 [snd_soc_dapm_mixer] = 8,
82 [snd_soc_dapm_mixer_named_ctl] = 8,
83 [snd_soc_dapm_pga] = 9,
84 [snd_soc_dapm_adc] = 10,
85 [snd_soc_dapm_out_drv] = 11,
86 [snd_soc_dapm_hp] = 11,
87 [snd_soc_dapm_spk] = 11,
88 [snd_soc_dapm_line] = 11,
89 [snd_soc_dapm_kcontrol] = 12,
90 [snd_soc_dapm_post] = 13,
Richard Purdie2b97eab2006-10-06 18:32:18 +020091};
Ian Moltonca9c1aa2009-01-06 20:11:51 +000092
Richard Purdie2b97eab2006-10-06 18:32:18 +020093static int dapm_down_seq[] = {
Mark Brown38357ab2009-06-06 19:03:23 +010094 [snd_soc_dapm_pre] = 0,
Lars-Peter Clausen57295072013-08-05 11:27:31 +020095 [snd_soc_dapm_kcontrol] = 1,
96 [snd_soc_dapm_adc] = 2,
97 [snd_soc_dapm_hp] = 3,
98 [snd_soc_dapm_spk] = 3,
99 [snd_soc_dapm_line] = 3,
100 [snd_soc_dapm_out_drv] = 3,
Mark Brown38357ab2009-06-06 19:03:23 +0100101 [snd_soc_dapm_pga] = 4,
Lars-Peter Clausenefc77e32013-06-14 13:16:50 +0200102 [snd_soc_dapm_switch] = 5,
Mark Brown38357ab2009-06-06 19:03:23 +0100103 [snd_soc_dapm_mixer_named_ctl] = 5,
Mark Browne3d4dab2009-06-07 13:08:45 +0100104 [snd_soc_dapm_mixer] = 5,
105 [snd_soc_dapm_dac] = 6,
106 [snd_soc_dapm_mic] = 7,
107 [snd_soc_dapm_micbias] = 8,
108 [snd_soc_dapm_mux] = 9,
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200109 [snd_soc_dapm_demux] = 9,
Mark Brown010ff262009-08-17 17:39:22 +0100110 [snd_soc_dapm_aif_in] = 10,
111 [snd_soc_dapm_aif_out] = 10,
Mark Brown46162742013-06-05 19:36:11 +0100112 [snd_soc_dapm_dai_in] = 10,
113 [snd_soc_dapm_dai_out] = 10,
Mark Brownc74184e2012-04-04 22:12:09 +0100114 [snd_soc_dapm_dai_link] = 11,
Mark Brownc74184e2012-04-04 22:12:09 +0100115 [snd_soc_dapm_supply] = 12,
Mark Brown1dd275b2013-10-09 13:56:37 +0100116 [snd_soc_dapm_clock_supply] = 13,
117 [snd_soc_dapm_regulator_supply] = 13,
118 [snd_soc_dapm_post] = 14,
Richard Purdie2b97eab2006-10-06 18:32:18 +0200119};
120
Mark Brownf9fa2b12014-03-06 16:49:11 +0800121static void dapm_assert_locked(struct snd_soc_dapm_context *dapm)
122{
123 if (dapm->card && dapm->card->instantiated)
124 lockdep_assert_held(&dapm->card->dapm_mutex);
125}
126
Troy Kisky12ef1932008-10-13 17:42:14 -0700127static void pop_wait(u32 pop_time)
Mark Brown15e4c722008-07-02 11:51:20 +0100128{
129 if (pop_time)
130 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
131}
132
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200133static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
Mark Brown15e4c722008-07-02 11:51:20 +0100134{
135 va_list args;
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200136 char *buf;
137
138 if (!pop_time)
139 return;
140
141 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
142 if (buf == NULL)
143 return;
Mark Brown15e4c722008-07-02 11:51:20 +0100144
145 va_start(args, fmt);
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200146 vsnprintf(buf, PAGE_SIZE, fmt, args);
Takashi Iwai9d01df02010-12-22 14:08:40 +0100147 dev_info(dev, "%s", buf);
Mark Brown15e4c722008-07-02 11:51:20 +0100148 va_end(args);
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200149
150 kfree(buf);
Mark Brown15e4c722008-07-02 11:51:20 +0100151}
152
Mark Browndb432b42011-10-03 21:06:40 +0100153static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
154{
155 return !list_empty(&w->dirty);
156}
157
Mark Brown492c0a12014-03-06 16:15:48 +0800158static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
Mark Browndb432b42011-10-03 21:06:40 +0100159{
Mark Brownf9fa2b12014-03-06 16:49:11 +0800160 dapm_assert_locked(w->dapm);
161
Mark Brown75c1f892011-10-04 22:28:08 +0100162 if (!dapm_dirty_widget(w)) {
163 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
164 w->name, reason);
Mark Browndb432b42011-10-03 21:06:40 +0100165 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
Mark Brown75c1f892011-10-04 22:28:08 +0100166 }
Mark Browndb432b42011-10-03 21:06:40 +0100167}
168
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200169/*
170 * dapm_widget_invalidate_input_paths() - Invalidate the cached number of input
171 * paths
172 * @w: The widget for which to invalidate the cached number of input paths
173 *
174 * The function resets the cached number of inputs for the specified widget and
175 * all widgets that can be reached via outgoing paths from the widget.
176 *
177 * This function must be called if the number of input paths for a widget might
178 * have changed. E.g. if the source state of a widget changes or a path is added
179 * or activated with the widget as the sink.
180 */
181static void dapm_widget_invalidate_input_paths(struct snd_soc_dapm_widget *w)
182{
183 struct snd_soc_dapm_widget *sink;
184 struct snd_soc_dapm_path *p;
185 LIST_HEAD(list);
186
187 dapm_assert_locked(w->dapm);
188
189 if (w->inputs == -1)
190 return;
191
192 w->inputs = -1;
193 list_add_tail(&w->work_list, &list);
194
195 list_for_each_entry(w, &list, work_list) {
196 list_for_each_entry(p, &w->sinks, list_source) {
197 if (p->is_supply || p->weak || !p->connect)
198 continue;
199 sink = p->sink;
200 if (sink->inputs != -1) {
201 sink->inputs = -1;
202 list_add_tail(&sink->work_list, &list);
203 }
204 }
205 }
206}
207
208/*
209 * dapm_widget_invalidate_output_paths() - Invalidate the cached number of
210 * output paths
211 * @w: The widget for which to invalidate the cached number of output paths
212 *
213 * Resets the cached number of outputs for the specified widget and all widgets
214 * that can be reached via incoming paths from the widget.
215 *
216 * This function must be called if the number of output paths for a widget might
217 * have changed. E.g. if the sink state of a widget changes or a path is added
218 * or activated with the widget as the source.
219 */
220static void dapm_widget_invalidate_output_paths(struct snd_soc_dapm_widget *w)
221{
222 struct snd_soc_dapm_widget *source;
223 struct snd_soc_dapm_path *p;
224 LIST_HEAD(list);
225
226 dapm_assert_locked(w->dapm);
227
228 if (w->outputs == -1)
229 return;
230
231 w->outputs = -1;
232 list_add_tail(&w->work_list, &list);
233
234 list_for_each_entry(w, &list, work_list) {
235 list_for_each_entry(p, &w->sources, list_sink) {
236 if (p->is_supply || p->weak || !p->connect)
237 continue;
238 source = p->source;
239 if (source->outputs != -1) {
240 source->outputs = -1;
241 list_add_tail(&source->work_list, &list);
242 }
243 }
244 }
245}
246
247/*
248 * dapm_path_invalidate() - Invalidates the cached number of inputs and outputs
249 * for the widgets connected to a path
250 * @p: The path to invalidate
251 *
252 * Resets the cached number of inputs for the sink of the path and the cached
253 * number of outputs for the source of the path.
254 *
255 * This function must be called when a path is added, removed or the connected
256 * state changes.
257 */
258static void dapm_path_invalidate(struct snd_soc_dapm_path *p)
259{
260 /*
261 * Weak paths or supply paths do not influence the number of input or
262 * output paths of their neighbors.
263 */
264 if (p->weak || p->is_supply)
265 return;
266
267 /*
268 * The number of connected endpoints is the sum of the number of
269 * connected endpoints of all neighbors. If a node with 0 connected
270 * endpoints is either connected or disconnected that sum won't change,
271 * so there is no need to re-check the path.
272 */
273 if (p->source->inputs != 0)
274 dapm_widget_invalidate_input_paths(p->sink);
275 if (p->sink->outputs != 0)
276 dapm_widget_invalidate_output_paths(p->source);
277}
278
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200279void dapm_mark_endpoints_dirty(struct snd_soc_card *card)
Mark Browne2d32ff2012-08-31 17:38:32 -0700280{
Mark Browne2d32ff2012-08-31 17:38:32 -0700281 struct snd_soc_dapm_widget *w;
282
283 mutex_lock(&card->dapm_mutex);
284
285 list_for_each_entry(w, &card->widgets, list) {
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200286 if (w->is_sink || w->is_source) {
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200287 dapm_mark_dirty(w, "Rechecking endpoints");
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200288 if (w->is_sink)
289 dapm_widget_invalidate_output_paths(w);
290 if (w->is_source)
291 dapm_widget_invalidate_input_paths(w);
292 }
Mark Browne2d32ff2012-08-31 17:38:32 -0700293 }
294
295 mutex_unlock(&card->dapm_mutex);
296}
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200297EXPORT_SYMBOL_GPL(dapm_mark_endpoints_dirty);
Mark Browne2d32ff2012-08-31 17:38:32 -0700298
Richard Purdie2b97eab2006-10-06 18:32:18 +0200299/* create a new dapm widget */
Takashi Iwai88cb4292007-02-05 14:56:20 +0100300static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
Richard Purdie2b97eab2006-10-06 18:32:18 +0200301 const struct snd_soc_dapm_widget *_widget)
302{
Takashi Iwai88cb4292007-02-05 14:56:20 +0100303 return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200304}
305
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200306struct dapm_kcontrol_data {
Lars-Peter Clausencf7c1de2013-07-29 17:13:59 +0200307 unsigned int value;
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200308 struct snd_soc_dapm_widget *widget;
Lars-Peter Clausen5106b922013-07-29 17:14:00 +0200309 struct list_head paths;
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200310 struct snd_soc_dapm_widget_list *wlist;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200311};
312
313static int dapm_kcontrol_data_alloc(struct snd_soc_dapm_widget *widget,
314 struct snd_kcontrol *kcontrol)
315{
316 struct dapm_kcontrol_data *data;
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200317 struct soc_mixer_control *mc;
Charles Keepax561ed682015-05-01 12:37:26 +0100318 struct soc_enum *e;
Charles Keepax773da9b2015-05-01 12:37:25 +0100319 const char *name;
320 int ret;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200321
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200322 data = kzalloc(sizeof(*data), GFP_KERNEL);
Charles Keepax40b7bea2015-05-01 12:37:24 +0100323 if (!data)
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200324 return -ENOMEM;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200325
Lars-Peter Clausen5106b922013-07-29 17:14:00 +0200326 INIT_LIST_HEAD(&data->paths);
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200327
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200328 switch (widget->id) {
329 case snd_soc_dapm_switch:
330 case snd_soc_dapm_mixer:
331 case snd_soc_dapm_mixer_named_ctl:
332 mc = (struct soc_mixer_control *)kcontrol->private_value;
333
334 if (mc->autodisable) {
335 struct snd_soc_dapm_widget template;
336
Charles Keepax773da9b2015-05-01 12:37:25 +0100337 name = kasprintf(GFP_KERNEL, "%s %s", kcontrol->id.name,
338 "Autodisable");
339 if (!name) {
340 ret = -ENOMEM;
341 goto err_data;
342 }
343
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200344 memset(&template, 0, sizeof(template));
345 template.reg = mc->reg;
346 template.mask = (1 << fls(mc->max)) - 1;
347 template.shift = mc->shift;
348 if (mc->invert)
349 template.off_val = mc->max;
350 else
351 template.off_val = 0;
352 template.on_val = template.off_val;
353 template.id = snd_soc_dapm_kcontrol;
Charles Keepax773da9b2015-05-01 12:37:25 +0100354 template.name = name;
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200355
Lars-Peter Clausen2daabd72013-08-30 17:39:33 +0200356 data->value = template.on_val;
357
Liam Girdwood02aa78a2015-05-25 18:21:17 +0100358 data->widget =
359 snd_soc_dapm_new_control_unlocked(widget->dapm,
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200360 &template);
361 if (!data->widget) {
Charles Keepax773da9b2015-05-01 12:37:25 +0100362 ret = -ENOMEM;
363 goto err_name;
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200364 }
365 }
366 break;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200367 case snd_soc_dapm_demux:
Charles Keepax561ed682015-05-01 12:37:26 +0100368 case snd_soc_dapm_mux:
369 e = (struct soc_enum *)kcontrol->private_value;
370
371 if (e->autodisable) {
372 struct snd_soc_dapm_widget template;
373
374 name = kasprintf(GFP_KERNEL, "%s %s", kcontrol->id.name,
375 "Autodisable");
376 if (!name) {
377 ret = -ENOMEM;
378 goto err_data;
379 }
380
381 memset(&template, 0, sizeof(template));
382 template.reg = e->reg;
383 template.mask = e->mask << e->shift_l;
384 template.shift = e->shift_l;
385 template.off_val = snd_soc_enum_item_to_val(e, 0);
386 template.on_val = template.off_val;
387 template.id = snd_soc_dapm_kcontrol;
388 template.name = name;
389
390 data->value = template.on_val;
391
392 data->widget = snd_soc_dapm_new_control(widget->dapm,
393 &template);
394 if (!data->widget) {
395 ret = -ENOMEM;
396 goto err_name;
397 }
398
399 snd_soc_dapm_add_path(widget->dapm, data->widget,
400 widget, NULL, NULL);
401 }
402 break;
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200403 default:
404 break;
405 }
406
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200407 kcontrol->private_data = data;
408
409 return 0;
Charles Keepax773da9b2015-05-01 12:37:25 +0100410
411err_name:
412 kfree(name);
413err_data:
414 kfree(data);
415 return ret;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200416}
417
418static void dapm_kcontrol_free(struct snd_kcontrol *kctl)
419{
420 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kctl);
Charles Keepax773da9b2015-05-01 12:37:25 +0100421 if (data->widget)
422 kfree(data->widget->name);
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200423 kfree(data->wlist);
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200424 kfree(data);
425}
426
427static struct snd_soc_dapm_widget_list *dapm_kcontrol_get_wlist(
428 const struct snd_kcontrol *kcontrol)
429{
430 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
431
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200432 return data->wlist;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200433}
434
435static int dapm_kcontrol_add_widget(struct snd_kcontrol *kcontrol,
436 struct snd_soc_dapm_widget *widget)
437{
438 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200439 struct snd_soc_dapm_widget_list *new_wlist;
440 unsigned int n;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200441
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200442 if (data->wlist)
443 n = data->wlist->num_widgets + 1;
444 else
445 n = 1;
446
447 new_wlist = krealloc(data->wlist,
448 sizeof(*new_wlist) + sizeof(widget) * n, GFP_KERNEL);
449 if (!new_wlist)
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200450 return -ENOMEM;
451
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200452 new_wlist->widgets[n - 1] = widget;
453 new_wlist->num_widgets = n;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200454
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200455 data->wlist = new_wlist;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200456
457 return 0;
458}
459
Lars-Peter Clausen5106b922013-07-29 17:14:00 +0200460static void dapm_kcontrol_add_path(const struct snd_kcontrol *kcontrol,
461 struct snd_soc_dapm_path *path)
462{
463 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
464
465 list_add_tail(&path->list_kcontrol, &data->paths);
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200466}
467
468static bool dapm_kcontrol_is_powered(const struct snd_kcontrol *kcontrol)
469{
470 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
471
472 if (!data->widget)
473 return true;
474
475 return data->widget->power;
Lars-Peter Clausen5106b922013-07-29 17:14:00 +0200476}
477
478static struct list_head *dapm_kcontrol_get_path_list(
479 const struct snd_kcontrol *kcontrol)
480{
481 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
482
483 return &data->paths;
484}
485
486#define dapm_kcontrol_for_each_path(path, kcontrol) \
487 list_for_each_entry(path, dapm_kcontrol_get_path_list(kcontrol), \
488 list_kcontrol)
489
Subhransu S. Prusty5dc0158a2014-09-19 16:46:05 +0530490unsigned int dapm_kcontrol_get_value(const struct snd_kcontrol *kcontrol)
Lars-Peter Clausencf7c1de2013-07-29 17:13:59 +0200491{
492 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
493
494 return data->value;
495}
Subhransu S. Prusty5dc0158a2014-09-19 16:46:05 +0530496EXPORT_SYMBOL_GPL(dapm_kcontrol_get_value);
Lars-Peter Clausencf7c1de2013-07-29 17:13:59 +0200497
498static bool dapm_kcontrol_set_value(const struct snd_kcontrol *kcontrol,
499 unsigned int value)
500{
501 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
502
503 if (data->value == value)
504 return false;
505
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200506 if (data->widget)
507 data->widget->on_val = value;
508
Lars-Peter Clausencf7c1de2013-07-29 17:13:59 +0200509 data->value = value;
510
511 return true;
512}
513
Lars-Peter Clauseneee5d7f2013-07-29 17:13:57 +0200514/**
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200515 * snd_soc_dapm_kcontrol_dapm() - Returns the dapm context associated to a
516 * kcontrol
517 * @kcontrol: The kcontrol
518 *
519 * Note: This function must only be used on kcontrols that are known to have
520 * been registered for a CODEC. Otherwise the behaviour is undefined.
521 */
522struct snd_soc_dapm_context *snd_soc_dapm_kcontrol_dapm(
523 struct snd_kcontrol *kcontrol)
524{
525 return dapm_kcontrol_get_wlist(kcontrol)->widgets[0]->dapm;
526}
527EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_dapm);
528
Liam Girdwood6c120e12012-02-15 15:15:34 +0000529static void dapm_reset(struct snd_soc_card *card)
530{
531 struct snd_soc_dapm_widget *w;
532
Mark Brownf9fa2b12014-03-06 16:49:11 +0800533 lockdep_assert_held(&card->dapm_mutex);
534
Liam Girdwood6c120e12012-02-15 15:15:34 +0000535 memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
536
537 list_for_each_entry(w, &card->widgets, list) {
Lars-Peter Clausen39eb5fd2013-07-29 17:14:03 +0200538 w->new_power = w->power;
Liam Girdwood6c120e12012-02-15 15:15:34 +0000539 w->power_checked = false;
Liam Girdwood6c120e12012-02-15 15:15:34 +0000540 }
541}
542
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +0200543static const char *soc_dapm_prefix(struct snd_soc_dapm_context *dapm)
544{
545 if (!dapm->component)
546 return NULL;
547 return dapm->component->name_prefix;
548}
549
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200550static int soc_dapm_read(struct snd_soc_dapm_context *dapm, int reg,
Arun Shamanna Lakshmif7d3c172014-01-14 15:31:54 -0800551 unsigned int *value)
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100552{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200553 if (!dapm->component)
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +0200554 return -EIO;
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200555 return snd_soc_component_read(dapm->component, reg, value);
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100556}
557
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200558static int soc_dapm_update_bits(struct snd_soc_dapm_context *dapm,
Bard Liao34775012014-04-17 20:12:56 +0800559 int reg, unsigned int mask, unsigned int value)
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100560{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200561 if (!dapm->component)
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +0200562 return -EIO;
Mark Brownfcf6c5e2014-12-15 13:08:48 +0000563 return snd_soc_component_update_bits(dapm->component, reg,
564 mask, value);
Liam Girdwood49575fb52012-03-06 18:16:19 +0000565}
566
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200567static int soc_dapm_test_bits(struct snd_soc_dapm_context *dapm,
568 int reg, unsigned int mask, unsigned int value)
569{
570 if (!dapm->component)
571 return -EIO;
572 return snd_soc_component_test_bits(dapm->component, reg, mask, value);
573}
574
Mark Browneb270e92013-10-09 13:52:52 +0100575static void soc_dapm_async_complete(struct snd_soc_dapm_context *dapm)
576{
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +0200577 if (dapm->component)
578 snd_soc_component_async_complete(dapm->component);
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100579}
580
Charles Keepax45a110a2015-05-11 13:50:30 +0100581static struct snd_soc_dapm_widget *
582dapm_wcache_lookup(struct snd_soc_dapm_wcache *wcache, const char *name)
583{
584 struct snd_soc_dapm_widget *w = wcache->widget;
585 struct list_head *wlist;
586 const int depth = 2;
587 int i = 0;
588
589 if (w) {
590 wlist = &w->dapm->card->widgets;
591
592 list_for_each_entry_from(w, wlist, list) {
593 if (!strcmp(name, w->name))
594 return w;
595
596 if (++i == depth)
597 break;
598 }
599 }
600
601 return NULL;
602}
603
604static inline void dapm_wcache_update(struct snd_soc_dapm_wcache *wcache,
605 struct snd_soc_dapm_widget *w)
606{
607 wcache->widget = w;
608}
609
Mark Brown452c5ea2009-05-17 21:41:23 +0100610/**
Lars-Peter Clausenfa880772015-04-27 22:13:23 +0200611 * snd_soc_dapm_force_bias_level() - Sets the DAPM bias level
612 * @dapm: The DAPM context for which to set the level
613 * @level: The level to set
614 *
615 * Forces the DAPM bias level to a specific state. It will call the bias level
616 * callback of DAPM context with the specified level. This will even happen if
617 * the context is already at the same level. Furthermore it will not go through
618 * the normal bias level sequencing, meaning any intermediate states between the
619 * current and the target state will not be entered.
620 *
621 * Note that the change in bias level is only temporary and the next time
622 * snd_soc_dapm_sync() is called the state will be set to the level as
623 * determined by the DAPM core. The function is mainly intended to be used to
624 * used during probe or resume from suspend to power up the device so
625 * initialization can be done, before the DAPM core takes over.
626 */
627int snd_soc_dapm_force_bias_level(struct snd_soc_dapm_context *dapm,
628 enum snd_soc_bias_level level)
629{
630 int ret = 0;
631
632 if (dapm->set_bias_level)
633 ret = dapm->set_bias_level(dapm, level);
634
Lars-Peter Clausenf4bf8d72015-04-27 22:13:25 +0200635 if (ret == 0)
636 dapm->bias_level = level;
637
Lars-Peter Clausenfa880772015-04-27 22:13:23 +0200638 return ret;
639}
640EXPORT_SYMBOL_GPL(snd_soc_dapm_force_bias_level);
641
642/**
Mark Brown452c5ea2009-05-17 21:41:23 +0100643 * snd_soc_dapm_set_bias_level - set the bias level for the system
Mark Browned5a4c42011-02-18 11:12:42 -0800644 * @dapm: DAPM context
Mark Brown452c5ea2009-05-17 21:41:23 +0100645 * @level: level to configure
646 *
647 * Configure the bias (power) levels for the SoC audio device.
648 *
649 * Returns 0 for success else error.
650 */
Mark Browned5a4c42011-02-18 11:12:42 -0800651static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200652 enum snd_soc_bias_level level)
Mark Brown452c5ea2009-05-17 21:41:23 +0100653{
Mark Browned5a4c42011-02-18 11:12:42 -0800654 struct snd_soc_card *card = dapm->card;
Mark Brown452c5ea2009-05-17 21:41:23 +0100655 int ret = 0;
656
Mark Brown84e90932010-11-04 00:07:02 -0400657 trace_snd_soc_bias_level_start(card, level);
658
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000659 if (card && card->set_bias_level)
Mark Brownd4c60052011-06-06 19:13:23 +0100660 ret = card->set_bias_level(card, dapm, level);
Mark Brown171ec6b2011-06-06 18:15:19 +0100661 if (ret != 0)
662 goto out;
Mark Brown452c5ea2009-05-17 21:41:23 +0100663
Lars-Peter Clausenfa880772015-04-27 22:13:23 +0200664 if (!card || dapm != &card->dapm)
665 ret = snd_soc_dapm_force_bias_level(dapm, level);
Liam Girdwood41231282012-07-06 16:56:16 +0100666
Mark Brown171ec6b2011-06-06 18:15:19 +0100667 if (ret != 0)
668 goto out;
669
670 if (card && card->set_bias_level_post)
Mark Brownd4c60052011-06-06 19:13:23 +0100671 ret = card->set_bias_level_post(card, dapm, level);
Mark Brown171ec6b2011-06-06 18:15:19 +0100672out:
Mark Brown84e90932010-11-04 00:07:02 -0400673 trace_snd_soc_bias_level_done(card, level);
674
Mark Brown452c5ea2009-05-17 21:41:23 +0100675 return ret;
676}
677
Mark Brown74b8f952009-06-06 11:26:15 +0100678/* connect mux widget to its interconnecting audio paths */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200679static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200680 struct snd_soc_dapm_path *path, const char *control_name,
681 struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200682{
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200683 const struct snd_kcontrol_new *kcontrol = &w->kcontrol_news[0];
Richard Purdie2b97eab2006-10-06 18:32:18 +0200684 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100685 unsigned int val, item;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200686 int i;
687
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100688 if (e->reg != SND_SOC_NOPM) {
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200689 soc_dapm_read(dapm, e->reg, &val);
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100690 val = (val >> e->shift_l) & e->mask;
691 item = snd_soc_enum_val_to_item(e, val);
692 } else {
693 /* since a virtual mux has no backing registers to
694 * decide which path to connect, it will try to match
695 * with the first enumeration. This is to ensure
696 * that the default mux choice (the first) will be
697 * correctly powered up during initialization.
698 */
699 item = 0;
700 }
701
Takashi Iwai9a8d38d2014-02-18 08:11:42 +0100702 for (i = 0; i < e->items; i++) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200703 if (!(strcmp(control_name, e->texts[i]))) {
Rasmus Villemoes98ad73c2014-10-21 17:01:15 +0200704 path->name = e->texts[i];
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100705 if (i == item)
706 path->connect = 1;
707 else
708 path->connect = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200709 return 0;
710 }
711 }
712
713 return -ENODEV;
714}
715
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100716/* set up initial codec paths */
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +0200717static void dapm_set_mixer_path_status(struct snd_soc_dapm_path *p, int i)
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100718{
719 struct soc_mixer_control *mc = (struct soc_mixer_control *)
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +0200720 p->sink->kcontrol_news[i].private_value;
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100721 unsigned int reg = mc->reg;
722 unsigned int shift = mc->shift;
723 unsigned int max = mc->max;
724 unsigned int mask = (1 << fls(max)) - 1;
725 unsigned int invert = mc->invert;
726 unsigned int val;
727
728 if (reg != SND_SOC_NOPM) {
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +0200729 soc_dapm_read(p->sink->dapm, reg, &val);
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100730 val = (val >> shift) & mask;
731 if (invert)
732 val = max - val;
733 p->connect = !!val;
734 } else {
735 p->connect = 0;
736 }
737}
738
Mark Brown74b8f952009-06-06 11:26:15 +0100739/* connect mixer widget to its interconnecting audio paths */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200740static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
Richard Purdie2b97eab2006-10-06 18:32:18 +0200741 struct snd_soc_dapm_path *path, const char *control_name)
742{
743 int i;
744
745 /* search for mixer kcontrol */
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +0200746 for (i = 0; i < path->sink->num_kcontrols; i++) {
747 if (!strcmp(control_name, path->sink->kcontrol_news[i].name)) {
748 path->name = path->sink->kcontrol_news[i].name;
749 dapm_set_mixer_path_status(path, i);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200750 return 0;
751 }
752 }
753 return -ENODEV;
754}
755
Stephen Warrenaf468002011-04-28 17:38:01 -0600756static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
Stephen Warren1007da02011-05-26 09:57:33 -0600757 struct snd_soc_dapm_widget *kcontrolw,
Stephen Warrenaf468002011-04-28 17:38:01 -0600758 const struct snd_kcontrol_new *kcontrol_new,
759 struct snd_kcontrol **kcontrol)
760{
761 struct snd_soc_dapm_widget *w;
762 int i;
763
764 *kcontrol = NULL;
765
766 list_for_each_entry(w, &dapm->card->widgets, list) {
Stephen Warren1007da02011-05-26 09:57:33 -0600767 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
768 continue;
Stephen Warrenaf468002011-04-28 17:38:01 -0600769 for (i = 0; i < w->num_kcontrols; i++) {
770 if (&w->kcontrol_news[i] == kcontrol_new) {
771 if (w->kcontrols)
772 *kcontrol = w->kcontrols[i];
773 return 1;
774 }
775 }
776 }
777
778 return 0;
779}
780
Stephen Warren85762e72013-03-29 15:40:10 -0600781/*
782 * Determine if a kcontrol is shared. If it is, look it up. If it isn't,
783 * create it. Either way, add the widget into the control's widget list
784 */
785static int dapm_create_or_share_mixmux_kcontrol(struct snd_soc_dapm_widget *w,
Mark Brown946d92a2013-08-12 23:28:42 +0100786 int kci)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200787{
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200788 struct snd_soc_dapm_context *dapm = w->dapm;
Mark Brown12ea2c72011-03-02 18:17:32 +0000789 struct snd_card *card = dapm->card->snd_card;
Mark Brownefb7ac32011-03-08 17:23:24 +0000790 const char *prefix;
Stephen Warren85762e72013-03-29 15:40:10 -0600791 size_t prefix_len;
792 int shared;
793 struct snd_kcontrol *kcontrol;
Stephen Warren85762e72013-03-29 15:40:10 -0600794 bool wname_in_long_name, kcname_in_long_name;
Daniel Macke5092c92014-10-07 13:41:24 +0200795 char *long_name = NULL;
Stephen Warren85762e72013-03-29 15:40:10 -0600796 const char *name;
Daniel Macke5092c92014-10-07 13:41:24 +0200797 int ret = 0;
Mark Brownefb7ac32011-03-08 17:23:24 +0000798
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +0200799 prefix = soc_dapm_prefix(dapm);
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000800 if (prefix)
801 prefix_len = strlen(prefix) + 1;
802 else
803 prefix_len = 0;
804
Stephen Warren85762e72013-03-29 15:40:10 -0600805 shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],
806 &kcontrol);
807
Stephen Warren85762e72013-03-29 15:40:10 -0600808 if (!kcontrol) {
809 if (shared) {
810 wname_in_long_name = false;
811 kcname_in_long_name = true;
812 } else {
813 switch (w->id) {
814 case snd_soc_dapm_switch:
815 case snd_soc_dapm_mixer:
816 wname_in_long_name = true;
817 kcname_in_long_name = true;
818 break;
819 case snd_soc_dapm_mixer_named_ctl:
820 wname_in_long_name = false;
821 kcname_in_long_name = true;
822 break;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200823 case snd_soc_dapm_demux:
Stephen Warren85762e72013-03-29 15:40:10 -0600824 case snd_soc_dapm_mux:
Stephen Warren85762e72013-03-29 15:40:10 -0600825 wname_in_long_name = true;
826 kcname_in_long_name = false;
827 break;
828 default:
Stephen Warren85762e72013-03-29 15:40:10 -0600829 return -EINVAL;
830 }
831 }
832
833 if (wname_in_long_name && kcname_in_long_name) {
Stephen Warren85762e72013-03-29 15:40:10 -0600834 /*
835 * The control will get a prefix from the control
836 * creation process but we're also using the same
837 * prefix for widgets so cut the prefix off the
838 * front of the widget name.
839 */
Lars-Peter Clausen2b581072013-05-14 11:05:32 +0200840 long_name = kasprintf(GFP_KERNEL, "%s %s",
Stephen Warren85762e72013-03-29 15:40:10 -0600841 w->name + prefix_len,
842 w->kcontrol_news[kci].name);
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200843 if (long_name == NULL)
Lars-Peter Clausen2b581072013-05-14 11:05:32 +0200844 return -ENOMEM;
Stephen Warren85762e72013-03-29 15:40:10 -0600845
846 name = long_name;
847 } else if (wname_in_long_name) {
848 long_name = NULL;
849 name = w->name + prefix_len;
850 } else {
851 long_name = NULL;
852 name = w->kcontrol_news[kci].name;
853 }
854
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200855 kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,
Stephen Warren85762e72013-03-29 15:40:10 -0600856 prefix);
Daniel Macke5092c92014-10-07 13:41:24 +0200857 if (!kcontrol) {
858 ret = -ENOMEM;
859 goto exit_free;
860 }
861
Lars-Peter Clausen9356e9d2013-08-01 14:08:06 +0200862 kcontrol->private_free = dapm_kcontrol_free;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200863
864 ret = dapm_kcontrol_data_alloc(w, kcontrol);
865 if (ret) {
866 snd_ctl_free_one(kcontrol);
Daniel Macke5092c92014-10-07 13:41:24 +0200867 goto exit_free;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200868 }
869
Stephen Warren85762e72013-03-29 15:40:10 -0600870 ret = snd_ctl_add(card, kcontrol);
871 if (ret < 0) {
872 dev_err(dapm->dev,
873 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
874 w->name, name, ret);
Daniel Macke5092c92014-10-07 13:41:24 +0200875 goto exit_free;
Stephen Warren85762e72013-03-29 15:40:10 -0600876 }
Stephen Warren85762e72013-03-29 15:40:10 -0600877 }
878
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200879 ret = dapm_kcontrol_add_widget(kcontrol, w);
Daniel Macke5092c92014-10-07 13:41:24 +0200880 if (ret == 0)
881 w->kcontrols[kci] = kcontrol;
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200882
Daniel Macke5092c92014-10-07 13:41:24 +0200883exit_free:
884 kfree(long_name);
Stephen Warren85762e72013-03-29 15:40:10 -0600885
Daniel Macke5092c92014-10-07 13:41:24 +0200886 return ret;
Stephen Warren85762e72013-03-29 15:40:10 -0600887}
888
889/* create new dapm mixer control */
890static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
891{
892 int i, ret;
893 struct snd_soc_dapm_path *path;
Charles Keepax561ed682015-05-01 12:37:26 +0100894 struct dapm_kcontrol_data *data;
Stephen Warren85762e72013-03-29 15:40:10 -0600895
Richard Purdie2b97eab2006-10-06 18:32:18 +0200896 /* add kcontrol */
897 for (i = 0; i < w->num_kcontrols; i++) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200898 /* match name */
899 list_for_each_entry(path, &w->sources, list_sink) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200900 /* mixer/mux paths name must match control name */
Stephen Warren82cfecd2011-04-28 17:37:58 -0600901 if (path->name != (char *)w->kcontrol_news[i].name)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200902 continue;
903
Charles Keepax561ed682015-05-01 12:37:26 +0100904 if (!w->kcontrols[i]) {
905 ret = dapm_create_or_share_mixmux_kcontrol(w, i);
906 if (ret < 0)
907 return ret;
Lars-Peter Clausen82cd8762011-08-15 20:15:21 +0200908 }
909
Mark Brown946d92a2013-08-12 23:28:42 +0100910 dapm_kcontrol_add_path(w->kcontrols[i], path);
Charles Keepax561ed682015-05-01 12:37:26 +0100911
912 data = snd_kcontrol_chip(w->kcontrols[i]);
913 if (data->widget)
914 snd_soc_dapm_add_path(data->widget->dapm,
915 data->widget,
916 path->source,
917 NULL, NULL);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200918 }
919 }
Stephen Warren85762e72013-03-29 15:40:10 -0600920
921 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200922}
923
924/* create new dapm mux control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200925static int dapm_new_mux(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200926{
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200927 struct snd_soc_dapm_context *dapm = w->dapm;
Stephen Warren85762e72013-03-29 15:40:10 -0600928 struct snd_soc_dapm_path *path;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200929 struct list_head *paths;
930 const char *type;
Stephen Warrenaf468002011-04-28 17:38:01 -0600931 int ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200932
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200933 switch (w->id) {
934 case snd_soc_dapm_mux:
935 paths = &w->sources;
936 type = "mux";
937 break;
938 case snd_soc_dapm_demux:
939 paths = &w->sinks;
940 type = "demux";
941 break;
942 default:
943 return -EINVAL;
944 }
945
Stephen Warrenaf468002011-04-28 17:38:01 -0600946 if (w->num_kcontrols != 1) {
947 dev_err(dapm->dev,
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200948 "ASoC: %s %s has incorrect number of controls\n", type,
Stephen Warrenaf468002011-04-28 17:38:01 -0600949 w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200950 return -EINVAL;
951 }
952
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200953 if (list_empty(paths)) {
954 dev_err(dapm->dev, "ASoC: %s %s has no paths\n", type, w->name);
Stephen Warren85762e72013-03-29 15:40:10 -0600955 return -EINVAL;
Stephen Warrenaf468002011-04-28 17:38:01 -0600956 }
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200957
Mark Brown946d92a2013-08-12 23:28:42 +0100958 ret = dapm_create_or_share_mixmux_kcontrol(w, 0);
Stephen Warren85762e72013-03-29 15:40:10 -0600959 if (ret < 0)
960 return ret;
Stephen Warrenfad59882011-04-28 17:37:59 -0600961
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200962 if (w->id == snd_soc_dapm_mux) {
963 list_for_each_entry(path, &w->sources, list_sink) {
964 if (path->name)
965 dapm_kcontrol_add_path(w->kcontrols[0], path);
966 }
967 } else {
968 list_for_each_entry(path, &w->sinks, list_source) {
969 if (path->name)
970 dapm_kcontrol_add_path(w->kcontrols[0], path);
971 }
Lars-Peter Clausen98407ef2014-10-25 17:41:57 +0200972 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200973
Stephen Warrenaf468002011-04-28 17:38:01 -0600974 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200975}
976
977/* create new dapm volume control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200978static int dapm_new_pga(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200979{
Mark Browna6c65732010-03-03 17:45:21 +0000980 if (w->num_kcontrols)
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +0200981 dev_err(w->dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +0000982 "ASoC: PGA controls not supported: '%s'\n", w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200983
Mark Browna6c65732010-03-03 17:45:21 +0000984 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200985}
986
Nikesh Oswalc6615082015-02-02 17:06:44 +0000987/* create new dapm dai link control */
988static int dapm_new_dai_link(struct snd_soc_dapm_widget *w)
989{
990 int i, ret;
991 struct snd_kcontrol *kcontrol;
992 struct snd_soc_dapm_context *dapm = w->dapm;
993 struct snd_card *card = dapm->card->snd_card;
994
995 /* create control for links with > 1 config */
996 if (w->num_params <= 1)
997 return 0;
998
999 /* add kcontrol */
1000 for (i = 0; i < w->num_kcontrols; i++) {
1001 kcontrol = snd_soc_cnew(&w->kcontrol_news[i], w,
1002 w->name, NULL);
1003 ret = snd_ctl_add(card, kcontrol);
1004 if (ret < 0) {
1005 dev_err(dapm->dev,
1006 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
1007 w->name, w->kcontrol_news[i].name, ret);
1008 return ret;
1009 }
1010 kcontrol->private_data = w;
1011 w->kcontrols[i] = kcontrol;
1012 }
1013
1014 return 0;
1015}
1016
Mark Brown99497882010-05-07 20:24:05 +01001017/* We implement power down on suspend by checking the power state of
1018 * the ALSA card - when we are suspending the ALSA state for the card
1019 * is set to D3.
1020 */
1021static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
1022{
Mark Brown12ea2c72011-03-02 18:17:32 +00001023 int level = snd_power_get_state(widget->dapm->card->snd_card);
Mark Brown99497882010-05-07 20:24:05 +01001024
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001025 switch (level) {
Mark Brown99497882010-05-07 20:24:05 +01001026 case SNDRV_CTL_POWER_D3hot:
1027 case SNDRV_CTL_POWER_D3cold:
Mark Brown1547aba2010-05-07 21:11:40 +01001028 if (widget->ignore_suspend)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001029 dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02001030 widget->name);
Mark Brown1547aba2010-05-07 21:11:40 +01001031 return widget->ignore_suspend;
Mark Brown99497882010-05-07 20:24:05 +01001032 default:
1033 return 1;
1034 }
1035}
1036
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001037/* add widget to list if it's not already in the list */
1038static int dapm_list_add_widget(struct snd_soc_dapm_widget_list **list,
1039 struct snd_soc_dapm_widget *w)
1040{
1041 struct snd_soc_dapm_widget_list *wlist;
1042 int wlistsize, wlistentries, i;
1043
1044 if (*list == NULL)
1045 return -EINVAL;
1046
1047 wlist = *list;
1048
1049 /* is this widget already in the list */
1050 for (i = 0; i < wlist->num_widgets; i++) {
1051 if (wlist->widgets[i] == w)
1052 return 0;
1053 }
1054
1055 /* allocate some new space */
1056 wlistentries = wlist->num_widgets + 1;
1057 wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
1058 wlistentries * sizeof(struct snd_soc_dapm_widget *);
1059 *list = krealloc(wlist, wlistsize, GFP_KERNEL);
1060 if (*list == NULL) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001061 dev_err(w->dapm->dev, "ASoC: can't allocate widget list for %s\n",
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001062 w->name);
1063 return -ENOMEM;
1064 }
1065 wlist = *list;
1066
1067 /* insert the widget */
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001068 dev_dbg(w->dapm->dev, "ASoC: added %s in widget list pos %d\n",
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001069 w->name, wlist->num_widgets);
1070
1071 wlist->widgets[wlist->num_widgets] = w;
1072 wlist->num_widgets++;
1073 return 1;
1074}
1075
Richard Purdie2b97eab2006-10-06 18:32:18 +02001076/*
1077 * Recursively check for a completed path to an active or physically connected
1078 * output widget. Returns number of complete paths.
1079 */
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001080static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
1081 struct snd_soc_dapm_widget_list **list)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001082{
1083 struct snd_soc_dapm_path *path;
1084 int con = 0;
1085
Mark Brown024dc072011-10-09 11:52:05 +01001086 if (widget->outputs >= 0)
1087 return widget->outputs;
1088
Mark Brownde02d072011-09-20 21:43:24 +01001089 DAPM_UPDATE_STAT(widget, path_checks);
1090
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02001091 if (widget->is_sink && widget->connected) {
1092 widget->outputs = snd_soc_dapm_suspend_check(widget);
1093 return widget->outputs;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001094 }
1095
1096 list_for_each_entry(path, &widget->sinks, list_source) {
Mark Browne56235e2011-09-21 18:19:14 +01001097 DAPM_UPDATE_STAT(widget, neighbour_checks);
1098
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02001099 if (path->weak || path->is_supply)
Mark Brownbf3a9e12011-06-13 16:42:29 +01001100 continue;
1101
Mark Brown8af294b2013-02-22 17:48:15 +00001102 if (path->walking)
1103 return 1;
1104
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001105 trace_snd_soc_dapm_output_path(widget, path);
1106
Lars-Peter Clausen7ddd4cd2014-10-20 19:36:34 +02001107 if (path->connect) {
Mark Brown8af294b2013-02-22 17:48:15 +00001108 path->walking = 1;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001109
1110 /* do we need to add this widget to the list ? */
1111 if (list) {
1112 int err;
1113 err = dapm_list_add_widget(list, path->sink);
1114 if (err < 0) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001115 dev_err(widget->dapm->dev,
1116 "ASoC: could not add widget %s\n",
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001117 widget->name);
Mark Brown8af294b2013-02-22 17:48:15 +00001118 path->walking = 0;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001119 return con;
1120 }
1121 }
1122
1123 con += is_connected_output_ep(path->sink, list);
Mark Brown8af294b2013-02-22 17:48:15 +00001124
1125 path->walking = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001126 }
1127 }
1128
Mark Brown024dc072011-10-09 11:52:05 +01001129 widget->outputs = con;
1130
Richard Purdie2b97eab2006-10-06 18:32:18 +02001131 return con;
1132}
1133
1134/*
1135 * Recursively check for a completed path to an active or physically connected
1136 * input widget. Returns number of complete paths.
1137 */
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001138static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
1139 struct snd_soc_dapm_widget_list **list)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001140{
1141 struct snd_soc_dapm_path *path;
1142 int con = 0;
1143
Mark Brown024dc072011-10-09 11:52:05 +01001144 if (widget->inputs >= 0)
1145 return widget->inputs;
1146
Mark Brownde02d072011-09-20 21:43:24 +01001147 DAPM_UPDATE_STAT(widget, path_checks);
1148
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02001149 if (widget->is_source && widget->connected) {
1150 widget->inputs = snd_soc_dapm_suspend_check(widget);
1151 return widget->inputs;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001152 }
1153
1154 list_for_each_entry(path, &widget->sources, list_sink) {
Mark Browne56235e2011-09-21 18:19:14 +01001155 DAPM_UPDATE_STAT(widget, neighbour_checks);
1156
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02001157 if (path->weak || path->is_supply)
Mark Brownbf3a9e12011-06-13 16:42:29 +01001158 continue;
1159
Mark Brown8af294b2013-02-22 17:48:15 +00001160 if (path->walking)
1161 return 1;
1162
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001163 trace_snd_soc_dapm_input_path(widget, path);
1164
Lars-Peter Clausen7ddd4cd2014-10-20 19:36:34 +02001165 if (path->connect) {
Mark Brown8af294b2013-02-22 17:48:15 +00001166 path->walking = 1;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001167
1168 /* do we need to add this widget to the list ? */
1169 if (list) {
1170 int err;
Liam Girdwood90c6ce02012-06-05 19:27:15 +01001171 err = dapm_list_add_widget(list, path->source);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001172 if (err < 0) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001173 dev_err(widget->dapm->dev,
1174 "ASoC: could not add widget %s\n",
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001175 widget->name);
Mark Brown8af294b2013-02-22 17:48:15 +00001176 path->walking = 0;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001177 return con;
1178 }
1179 }
1180
1181 con += is_connected_input_ep(path->source, list);
Mark Brown8af294b2013-02-22 17:48:15 +00001182
1183 path->walking = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001184 }
1185 }
1186
Mark Brown024dc072011-10-09 11:52:05 +01001187 widget->inputs = con;
1188
Richard Purdie2b97eab2006-10-06 18:32:18 +02001189 return con;
1190}
1191
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001192/**
1193 * snd_soc_dapm_get_connected_widgets - query audio path and it's widgets.
1194 * @dai: the soc DAI.
1195 * @stream: stream direction.
1196 * @list: list of active widgets for this stream.
1197 *
1198 * Queries DAPM graph as to whether an valid audio stream path exists for
1199 * the initial stream specified by name. This takes into account
1200 * current mixer and mux kcontrol settings. Creates list of valid widgets.
1201 *
1202 * Returns the number of valid paths or negative error.
1203 */
1204int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
1205 struct snd_soc_dapm_widget_list **list)
1206{
Lars-Peter Clausen313665b2014-11-04 11:30:58 +01001207 struct snd_soc_card *card = dai->component->card;
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02001208 struct snd_soc_dapm_widget *w;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001209 int paths;
1210
1211 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02001212
1213 /*
1214 * For is_connected_{output,input}_ep fully discover the graph we need
1215 * to reset the cached number of inputs and outputs.
1216 */
1217 list_for_each_entry(w, &card->widgets, list) {
1218 w->inputs = -1;
1219 w->outputs = -1;
1220 }
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001221
Lars-Peter Clausen130897a2014-10-20 19:36:39 +02001222 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001223 paths = is_connected_output_ep(dai->playback_widget, list);
Lars-Peter Clausen130897a2014-10-20 19:36:39 +02001224 else
Liam Girdwoodd298caa2012-06-01 18:03:00 +01001225 paths = is_connected_input_ep(dai->capture_widget, list);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001226
1227 trace_snd_soc_dapm_connected(paths, stream);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001228 mutex_unlock(&card->dapm_mutex);
1229
1230 return paths;
1231}
1232
Richard Purdie2b97eab2006-10-06 18:32:18 +02001233/*
Mark Brown62ea8742012-01-21 21:14:48 +00001234 * Handler for regulator supply widget.
1235 */
1236int dapm_regulator_event(struct snd_soc_dapm_widget *w,
1237 struct snd_kcontrol *kcontrol, int event)
1238{
Mark Brownc05b84d2012-09-07 12:57:11 +08001239 int ret;
1240
Mark Browneb270e92013-10-09 13:52:52 +01001241 soc_dapm_async_complete(w->dapm);
1242
Mark Brownc05b84d2012-09-07 12:57:11 +08001243 if (SND_SOC_DAPM_EVENT_ON(event)) {
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001244 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
Mark Brown8784c772013-01-10 19:33:47 +00001245 ret = regulator_allow_bypass(w->regulator, false);
Mark Brownc05b84d2012-09-07 12:57:11 +08001246 if (ret != 0)
1247 dev_warn(w->dapm->dev,
Charles Keepax30686c32014-02-18 16:05:27 +00001248 "ASoC: Failed to unbypass %s: %d\n",
Mark Brownc05b84d2012-09-07 12:57:11 +08001249 w->name, ret);
1250 }
1251
Liam Girdwooda3cc0562012-03-09 17:20:16 +00001252 return regulator_enable(w->regulator);
Mark Brownc05b84d2012-09-07 12:57:11 +08001253 } else {
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001254 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
Mark Brown8784c772013-01-10 19:33:47 +00001255 ret = regulator_allow_bypass(w->regulator, true);
Mark Brownc05b84d2012-09-07 12:57:11 +08001256 if (ret != 0)
1257 dev_warn(w->dapm->dev,
Charles Keepax30686c32014-02-18 16:05:27 +00001258 "ASoC: Failed to bypass %s: %d\n",
Mark Brownc05b84d2012-09-07 12:57:11 +08001259 w->name, ret);
1260 }
1261
Liam Girdwooda3cc0562012-03-09 17:20:16 +00001262 return regulator_disable_deferred(w->regulator, w->shift);
Mark Brownc05b84d2012-09-07 12:57:11 +08001263 }
Mark Brown62ea8742012-01-21 21:14:48 +00001264}
1265EXPORT_SYMBOL_GPL(dapm_regulator_event);
1266
Ola Liljad7e7eb92012-05-24 15:26:25 +02001267/*
1268 * Handler for clock supply widget.
1269 */
1270int dapm_clock_event(struct snd_soc_dapm_widget *w,
1271 struct snd_kcontrol *kcontrol, int event)
1272{
1273 if (!w->clk)
1274 return -EIO;
1275
Mark Browneb270e92013-10-09 13:52:52 +01001276 soc_dapm_async_complete(w->dapm);
1277
Mark Brownec029952012-06-04 08:16:20 +01001278#ifdef CONFIG_HAVE_CLK
Ola Liljad7e7eb92012-05-24 15:26:25 +02001279 if (SND_SOC_DAPM_EVENT_ON(event)) {
Fabio Baltieri37c1b922013-04-30 16:09:52 +02001280 return clk_prepare_enable(w->clk);
Ola Liljad7e7eb92012-05-24 15:26:25 +02001281 } else {
Fabio Baltieri37c1b922013-04-30 16:09:52 +02001282 clk_disable_unprepare(w->clk);
Ola Liljad7e7eb92012-05-24 15:26:25 +02001283 return 0;
1284 }
Mark Brownec029952012-06-04 08:16:20 +01001285#endif
Marek Belisko98b3cf12012-07-12 23:00:16 +02001286 return 0;
Ola Liljad7e7eb92012-05-24 15:26:25 +02001287}
1288EXPORT_SYMBOL_GPL(dapm_clock_event);
1289
Mark Brownd8050022011-09-28 18:28:23 +01001290static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1291{
Mark Brown9b8a83b2011-10-04 22:15:59 +01001292 if (w->power_checked)
1293 return w->new_power;
1294
Mark Brownd8050022011-09-28 18:28:23 +01001295 if (w->force)
Mark Brown9b8a83b2011-10-04 22:15:59 +01001296 w->new_power = 1;
Mark Brownd8050022011-09-28 18:28:23 +01001297 else
Mark Brown9b8a83b2011-10-04 22:15:59 +01001298 w->new_power = w->power_check(w);
1299
1300 w->power_checked = true;
1301
1302 return w->new_power;
Mark Brownd8050022011-09-28 18:28:23 +01001303}
1304
Mark Browncd0f2d42009-04-20 16:56:59 +01001305/* Generic check to see if a widget should be powered.
1306 */
1307static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1308{
1309 int in, out;
1310
Mark Brownde02d072011-09-20 21:43:24 +01001311 DAPM_UPDATE_STAT(w, power_checks);
1312
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001313 in = is_connected_input_ep(w, NULL);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001314 out = is_connected_output_ep(w, NULL);
Mark Browncd0f2d42009-04-20 16:56:59 +01001315 return out != 0 && in != 0;
1316}
1317
Mark Brown246d0a12009-04-22 18:24:55 +01001318/* Check to see if a power supply is needed */
1319static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1320{
1321 struct snd_soc_dapm_path *path;
Mark Brown246d0a12009-04-22 18:24:55 +01001322
Mark Brownde02d072011-09-20 21:43:24 +01001323 DAPM_UPDATE_STAT(w, power_checks);
1324
Mark Brown246d0a12009-04-22 18:24:55 +01001325 /* Check if one of our outputs is connected */
1326 list_for_each_entry(path, &w->sinks, list_source) {
Mark Browna8fdac82011-09-28 18:20:26 +01001327 DAPM_UPDATE_STAT(w, neighbour_checks);
1328
Mark Brownbf3a9e12011-06-13 16:42:29 +01001329 if (path->weak)
1330 continue;
1331
Mark Brown215edda2009-09-08 18:59:05 +01001332 if (path->connected &&
1333 !path->connected(path->source, path->sink))
1334 continue;
1335
Mark Brownf68d7e12011-10-04 22:57:50 +01001336 if (dapm_widget_power_check(path->sink))
1337 return 1;
Mark Brown246d0a12009-04-22 18:24:55 +01001338 }
1339
Mark Brownf68d7e12011-10-04 22:57:50 +01001340 return 0;
Mark Brown246d0a12009-04-22 18:24:55 +01001341}
1342
Mark Brown35c64bc2011-09-28 18:23:53 +01001343static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1344{
1345 return 1;
1346}
1347
Mark Brown38357ab2009-06-06 19:03:23 +01001348static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
1349 struct snd_soc_dapm_widget *b,
Mark Brown828a8422011-01-15 13:14:30 +00001350 bool power_up)
Mark Brown42aa3412009-03-01 19:21:10 +00001351{
Mark Brown828a8422011-01-15 13:14:30 +00001352 int *sort;
1353
1354 if (power_up)
1355 sort = dapm_up_seq;
1356 else
1357 sort = dapm_down_seq;
1358
Mark Brown38357ab2009-06-06 19:03:23 +01001359 if (sort[a->id] != sort[b->id])
1360 return sort[a->id] - sort[b->id];
Mark Brown20e48592011-01-15 13:40:50 +00001361 if (a->subseq != b->subseq) {
1362 if (power_up)
1363 return a->subseq - b->subseq;
1364 else
1365 return b->subseq - a->subseq;
1366 }
Mark Brownb22ead22009-06-07 12:51:26 +01001367 if (a->reg != b->reg)
1368 return a->reg - b->reg;
Mark Brown84dab562010-11-12 15:28:42 +00001369 if (a->dapm != b->dapm)
1370 return (unsigned long)a->dapm - (unsigned long)b->dapm;
Mark Brown42aa3412009-03-01 19:21:10 +00001371
Mark Brown38357ab2009-06-06 19:03:23 +01001372 return 0;
1373}
Mark Brown42aa3412009-03-01 19:21:10 +00001374
Mark Brown38357ab2009-06-06 19:03:23 +01001375/* Insert a widget in order into a DAPM power sequence. */
1376static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
1377 struct list_head *list,
Mark Brown828a8422011-01-15 13:14:30 +00001378 bool power_up)
Mark Brown38357ab2009-06-06 19:03:23 +01001379{
1380 struct snd_soc_dapm_widget *w;
1381
1382 list_for_each_entry(w, list, power_list)
Mark Brown828a8422011-01-15 13:14:30 +00001383 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
Mark Brown38357ab2009-06-06 19:03:23 +01001384 list_add_tail(&new_widget->power_list, &w->power_list);
1385 return;
Mark Brown42aa3412009-03-01 19:21:10 +00001386 }
Mark Brown6ea31b92009-04-20 17:15:41 +01001387
Mark Brown38357ab2009-06-06 19:03:23 +01001388 list_add_tail(&new_widget->power_list, list);
1389}
Mark Brown42aa3412009-03-01 19:21:10 +00001390
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001391static void dapm_seq_check_event(struct snd_soc_card *card,
Mark Brown68f89ad2010-11-03 23:51:49 -04001392 struct snd_soc_dapm_widget *w, int event)
1393{
Mark Brown68f89ad2010-11-03 23:51:49 -04001394 const char *ev_name;
1395 int power, ret;
1396
1397 switch (event) {
1398 case SND_SOC_DAPM_PRE_PMU:
1399 ev_name = "PRE_PMU";
1400 power = 1;
1401 break;
1402 case SND_SOC_DAPM_POST_PMU:
1403 ev_name = "POST_PMU";
1404 power = 1;
1405 break;
1406 case SND_SOC_DAPM_PRE_PMD:
1407 ev_name = "PRE_PMD";
1408 power = 0;
1409 break;
1410 case SND_SOC_DAPM_POST_PMD:
1411 ev_name = "POST_PMD";
1412 power = 0;
1413 break;
Mark Brown80114122013-02-25 15:14:19 +00001414 case SND_SOC_DAPM_WILL_PMU:
1415 ev_name = "WILL_PMU";
1416 power = 1;
1417 break;
1418 case SND_SOC_DAPM_WILL_PMD:
1419 ev_name = "WILL_PMD";
1420 power = 0;
1421 break;
Mark Brown68f89ad2010-11-03 23:51:49 -04001422 default:
Takashi Iwaia6ed0602013-11-06 11:07:19 +01001423 WARN(1, "Unknown event %d\n", event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001424 return;
1425 }
1426
Lars-Peter Clausen39eb5fd2013-07-29 17:14:03 +02001427 if (w->new_power != power)
Mark Brown68f89ad2010-11-03 23:51:49 -04001428 return;
1429
1430 if (w->event && (w->event_flags & event)) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001431 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
Mark Brown68f89ad2010-11-03 23:51:49 -04001432 w->name, ev_name);
Mark Browneb270e92013-10-09 13:52:52 +01001433 soc_dapm_async_complete(w->dapm);
Mark Brown84e90932010-11-04 00:07:02 -04001434 trace_snd_soc_dapm_widget_event_start(w, event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001435 ret = w->event(w, NULL, event);
Mark Brown84e90932010-11-04 00:07:02 -04001436 trace_snd_soc_dapm_widget_event_done(w, event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001437 if (ret < 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001438 dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
Mark Brown68f89ad2010-11-03 23:51:49 -04001439 ev_name, w->name, ret);
1440 }
1441}
1442
Mark Brownb22ead22009-06-07 12:51:26 +01001443/* Apply the coalesced changes from a DAPM sequence */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001444static void dapm_seq_run_coalesced(struct snd_soc_card *card,
Mark Brownb22ead22009-06-07 12:51:26 +01001445 struct list_head *pending)
Mark Brown163cac02009-06-07 10:12:52 +01001446{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001447 struct snd_soc_dapm_context *dapm;
Mark Brown68f89ad2010-11-03 23:51:49 -04001448 struct snd_soc_dapm_widget *w;
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001449 int reg;
Mark Brownb22ead22009-06-07 12:51:26 +01001450 unsigned int value = 0;
1451 unsigned int mask = 0;
Mark Brownb22ead22009-06-07 12:51:26 +01001452
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001453 w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
1454 reg = w->reg;
1455 dapm = w->dapm;
Mark Brownb22ead22009-06-07 12:51:26 +01001456
1457 list_for_each_entry(w, pending, power_list) {
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001458 WARN_ON(reg != w->reg || dapm != w->dapm);
Lars-Peter Clausen39eb5fd2013-07-29 17:14:03 +02001459 w->power = w->new_power;
Mark Brownb22ead22009-06-07 12:51:26 +01001460
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001461 mask |= w->mask << w->shift;
1462 if (w->power)
1463 value |= w->on_val << w->shift;
Mark Brownb22ead22009-06-07 12:51:26 +01001464 else
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001465 value |= w->off_val << w->shift;
Mark Brownb22ead22009-06-07 12:51:26 +01001466
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001467 pop_dbg(dapm->dev, card->pop_time,
Mark Brownb22ead22009-06-07 12:51:26 +01001468 "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1469 w->name, reg, value, mask);
Mark Brown81628102009-06-07 13:21:24 +01001470
Mark Brown68f89ad2010-11-03 23:51:49 -04001471 /* Check for events */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001472 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
1473 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
Mark Brownb22ead22009-06-07 12:51:26 +01001474 }
1475
Mark Brown81628102009-06-07 13:21:24 +01001476 if (reg >= 0) {
Mark Brown29376bc2011-06-19 13:49:28 +01001477 /* Any widget will do, they should all be updating the
1478 * same register.
1479 */
Mark Brown29376bc2011-06-19 13:49:28 +01001480
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001481 pop_dbg(dapm->dev, card->pop_time,
Mark Brown81628102009-06-07 13:21:24 +01001482 "pop test : Applying 0x%x/0x%x to %x in %dms\n",
Jarkko Nikula3a45b862010-11-05 20:35:21 +02001483 value, mask, reg, card->pop_time);
1484 pop_wait(card->pop_time);
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001485 soc_dapm_update_bits(dapm, reg, mask, value);
Mark Brown81628102009-06-07 13:21:24 +01001486 }
1487
1488 list_for_each_entry(w, pending, power_list) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001489 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
1490 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
Mark Brown42aa3412009-03-01 19:21:10 +00001491 }
Mark Brown42aa3412009-03-01 19:21:10 +00001492}
1493
Mark Brownb22ead22009-06-07 12:51:26 +01001494/* Apply a DAPM power sequence.
1495 *
1496 * We walk over a pre-sorted list of widgets to apply power to. In
1497 * order to minimise the number of writes to the device required
1498 * multiple widgets will be updated in a single write where possible.
1499 * Currently anything that requires more than a single write is not
1500 * handled.
1501 */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001502static void dapm_seq_run(struct snd_soc_card *card,
1503 struct list_head *list, int event, bool power_up)
Mark Brownb22ead22009-06-07 12:51:26 +01001504{
1505 struct snd_soc_dapm_widget *w, *n;
Mark Browneb270e92013-10-09 13:52:52 +01001506 struct snd_soc_dapm_context *d;
Mark Brownb22ead22009-06-07 12:51:26 +01001507 LIST_HEAD(pending);
1508 int cur_sort = -1;
Mark Brown20e48592011-01-15 13:40:50 +00001509 int cur_subseq = -1;
Mark Brownb22ead22009-06-07 12:51:26 +01001510 int cur_reg = SND_SOC_NOPM;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001511 struct snd_soc_dapm_context *cur_dapm = NULL;
Mark Brown474b62d2011-01-18 16:14:44 +00001512 int ret, i;
Mark Brown828a8422011-01-15 13:14:30 +00001513 int *sort;
1514
1515 if (power_up)
1516 sort = dapm_up_seq;
1517 else
1518 sort = dapm_down_seq;
Mark Brown163cac02009-06-07 10:12:52 +01001519
Mark Brownb22ead22009-06-07 12:51:26 +01001520 list_for_each_entry_safe(w, n, list, power_list) {
1521 ret = 0;
1522
1523 /* Do we need to apply any queued changes? */
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001524 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
Mark Brown20e48592011-01-15 13:40:50 +00001525 w->dapm != cur_dapm || w->subseq != cur_subseq) {
Mark Brownb22ead22009-06-07 12:51:26 +01001526 if (!list_empty(&pending))
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001527 dapm_seq_run_coalesced(card, &pending);
Mark Brownb22ead22009-06-07 12:51:26 +01001528
Mark Brown474b62d2011-01-18 16:14:44 +00001529 if (cur_dapm && cur_dapm->seq_notifier) {
1530 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1531 if (sort[i] == cur_sort)
1532 cur_dapm->seq_notifier(cur_dapm,
Mark Brownf85a9e02011-01-26 21:41:28 +00001533 i,
1534 cur_subseq);
Mark Brown474b62d2011-01-18 16:14:44 +00001535 }
1536
Mark Browneb270e92013-10-09 13:52:52 +01001537 if (cur_dapm && w->dapm != cur_dapm)
1538 soc_dapm_async_complete(cur_dapm);
1539
Mark Brownb22ead22009-06-07 12:51:26 +01001540 INIT_LIST_HEAD(&pending);
1541 cur_sort = -1;
Mark Brownb0b3e6f2011-07-16 10:55:08 +09001542 cur_subseq = INT_MIN;
Mark Brownb22ead22009-06-07 12:51:26 +01001543 cur_reg = SND_SOC_NOPM;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001544 cur_dapm = NULL;
Mark Brownb22ead22009-06-07 12:51:26 +01001545 }
1546
Mark Brown163cac02009-06-07 10:12:52 +01001547 switch (w->id) {
1548 case snd_soc_dapm_pre:
1549 if (!w->event)
Mark Brownb22ead22009-06-07 12:51:26 +01001550 list_for_each_entry_safe_continue(w, n, list,
1551 power_list);
Mark Brown163cac02009-06-07 10:12:52 +01001552
Mark Brownb22ead22009-06-07 12:51:26 +01001553 if (event == SND_SOC_DAPM_STREAM_START)
Mark Brown163cac02009-06-07 10:12:52 +01001554 ret = w->event(w,
1555 NULL, SND_SOC_DAPM_PRE_PMU);
Mark Brownb22ead22009-06-07 12:51:26 +01001556 else if (event == SND_SOC_DAPM_STREAM_STOP)
Mark Brown163cac02009-06-07 10:12:52 +01001557 ret = w->event(w,
1558 NULL, SND_SOC_DAPM_PRE_PMD);
Mark Brown163cac02009-06-07 10:12:52 +01001559 break;
1560
1561 case snd_soc_dapm_post:
1562 if (!w->event)
Mark Brownb22ead22009-06-07 12:51:26 +01001563 list_for_each_entry_safe_continue(w, n, list,
1564 power_list);
Mark Brown163cac02009-06-07 10:12:52 +01001565
Mark Brownb22ead22009-06-07 12:51:26 +01001566 if (event == SND_SOC_DAPM_STREAM_START)
Mark Brown163cac02009-06-07 10:12:52 +01001567 ret = w->event(w,
1568 NULL, SND_SOC_DAPM_POST_PMU);
Mark Brownb22ead22009-06-07 12:51:26 +01001569 else if (event == SND_SOC_DAPM_STREAM_STOP)
Mark Brown163cac02009-06-07 10:12:52 +01001570 ret = w->event(w,
1571 NULL, SND_SOC_DAPM_POST_PMD);
Mark Brownb22ead22009-06-07 12:51:26 +01001572 break;
1573
Mark Brown163cac02009-06-07 10:12:52 +01001574 default:
Mark Brown81628102009-06-07 13:21:24 +01001575 /* Queue it up for application */
1576 cur_sort = sort[w->id];
Mark Brown20e48592011-01-15 13:40:50 +00001577 cur_subseq = w->subseq;
Mark Brown81628102009-06-07 13:21:24 +01001578 cur_reg = w->reg;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001579 cur_dapm = w->dapm;
Mark Brown81628102009-06-07 13:21:24 +01001580 list_move(&w->power_list, &pending);
1581 break;
Mark Brown163cac02009-06-07 10:12:52 +01001582 }
Mark Brownb22ead22009-06-07 12:51:26 +01001583
1584 if (ret < 0)
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02001585 dev_err(w->dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001586 "ASoC: Failed to apply widget power: %d\n", ret);
Mark Brown163cac02009-06-07 10:12:52 +01001587 }
Mark Brownb22ead22009-06-07 12:51:26 +01001588
1589 if (!list_empty(&pending))
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001590 dapm_seq_run_coalesced(card, &pending);
Mark Brown474b62d2011-01-18 16:14:44 +00001591
1592 if (cur_dapm && cur_dapm->seq_notifier) {
1593 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1594 if (sort[i] == cur_sort)
1595 cur_dapm->seq_notifier(cur_dapm,
Mark Brownf85a9e02011-01-26 21:41:28 +00001596 i, cur_subseq);
Mark Brown474b62d2011-01-18 16:14:44 +00001597 }
Mark Browneb270e92013-10-09 13:52:52 +01001598
1599 list_for_each_entry(d, &card->dapm_list, list) {
1600 soc_dapm_async_complete(d);
1601 }
Mark Brown163cac02009-06-07 10:12:52 +01001602}
1603
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001604static void dapm_widget_update(struct snd_soc_card *card)
Mark Brown97404f22010-12-14 16:13:57 +00001605{
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001606 struct snd_soc_dapm_update *update = card->update;
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001607 struct snd_soc_dapm_widget_list *wlist;
1608 struct snd_soc_dapm_widget *w = NULL;
1609 unsigned int wi;
Mark Brown97404f22010-12-14 16:13:57 +00001610 int ret;
1611
Lars-Peter Clausen57295072013-08-05 11:27:31 +02001612 if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
Mark Brown97404f22010-12-14 16:13:57 +00001613 return;
1614
Lars-Peter Clausene84357f2013-07-29 17:13:58 +02001615 wlist = dapm_kcontrol_get_wlist(update->kcontrol);
Mark Brown97404f22010-12-14 16:13:57 +00001616
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001617 for (wi = 0; wi < wlist->num_widgets; wi++) {
1618 w = wlist->widgets[wi];
1619
1620 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1621 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1622 if (ret != 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001623 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001624 w->name, ret);
1625 }
Mark Brown97404f22010-12-14 16:13:57 +00001626 }
1627
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001628 if (!w)
1629 return;
1630
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001631 ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
1632 update->val);
Mark Brown97404f22010-12-14 16:13:57 +00001633 if (ret < 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001634 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001635 w->name, ret);
Mark Brown97404f22010-12-14 16:13:57 +00001636
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001637 for (wi = 0; wi < wlist->num_widgets; wi++) {
1638 w = wlist->widgets[wi];
1639
1640 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1641 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1642 if (ret != 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001643 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001644 w->name, ret);
1645 }
Mark Brown97404f22010-12-14 16:13:57 +00001646 }
1647}
1648
Mark Brown9d0624a2011-02-18 11:49:43 -08001649/* Async callback run prior to DAPM sequences - brings to _PREPARE if
1650 * they're changing state.
1651 */
1652static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1653{
1654 struct snd_soc_dapm_context *d = data;
1655 int ret;
Mark Brown97404f22010-12-14 16:13:57 +00001656
Mark Brown56fba412011-06-04 11:25:10 +01001657 /* If we're off and we're not supposed to be go into STANDBY */
1658 if (d->bias_level == SND_SOC_BIAS_OFF &&
1659 d->target_bias_level != SND_SOC_BIAS_OFF) {
Mark Brownf1aac482011-12-05 15:17:06 +00001660 if (d->dev)
1661 pm_runtime_get_sync(d->dev);
1662
Mark Brown9d0624a2011-02-18 11:49:43 -08001663 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1664 if (ret != 0)
1665 dev_err(d->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001666 "ASoC: Failed to turn on bias: %d\n", ret);
Mark Brown9d0624a2011-02-18 11:49:43 -08001667 }
1668
Lars-Peter Clausence85a4d2014-05-06 10:32:15 +02001669 /* Prepare for a transition to ON or away from ON */
1670 if ((d->target_bias_level == SND_SOC_BIAS_ON &&
1671 d->bias_level != SND_SOC_BIAS_ON) ||
1672 (d->target_bias_level != SND_SOC_BIAS_ON &&
1673 d->bias_level == SND_SOC_BIAS_ON)) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001674 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1675 if (ret != 0)
1676 dev_err(d->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001677 "ASoC: Failed to prepare bias: %d\n", ret);
Mark Brown9d0624a2011-02-18 11:49:43 -08001678 }
1679}
1680
1681/* Async callback run prior to DAPM sequences - brings to their final
1682 * state.
1683 */
1684static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1685{
1686 struct snd_soc_dapm_context *d = data;
1687 int ret;
1688
1689 /* If we just powered the last thing off drop to standby bias */
Mark Brown56fba412011-06-04 11:25:10 +01001690 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1691 (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1692 d->target_bias_level == SND_SOC_BIAS_OFF)) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001693 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1694 if (ret != 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001695 dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
Mark Brown9d0624a2011-02-18 11:49:43 -08001696 ret);
1697 }
1698
1699 /* If we're in standby and can support bias off then do that */
Mark Brown56fba412011-06-04 11:25:10 +01001700 if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1701 d->target_bias_level == SND_SOC_BIAS_OFF) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001702 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1703 if (ret != 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001704 dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
1705 ret);
Mark Brownf1aac482011-12-05 15:17:06 +00001706
1707 if (d->dev)
Mark Brownfb644e92012-01-25 19:53:58 +00001708 pm_runtime_put(d->dev);
Mark Brown9d0624a2011-02-18 11:49:43 -08001709 }
1710
1711 /* If we just powered up then move to active bias */
Mark Brown56fba412011-06-04 11:25:10 +01001712 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1713 d->target_bias_level == SND_SOC_BIAS_ON) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001714 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1715 if (ret != 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001716 dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
Mark Brown9d0624a2011-02-18 11:49:43 -08001717 ret);
1718 }
1719}
Mark Brown97404f22010-12-14 16:13:57 +00001720
Mark Brownfe4fda52011-10-03 22:36:57 +01001721static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
1722 bool power, bool connect)
1723{
1724 /* If a connection is being made or broken then that update
1725 * will have marked the peer dirty, otherwise the widgets are
1726 * not connected and this update has no impact. */
1727 if (!connect)
1728 return;
1729
1730 /* If the peer is already in the state we're moving to then we
1731 * won't have an impact on it. */
1732 if (power != peer->power)
Mark Brown75c1f892011-10-04 22:28:08 +01001733 dapm_mark_dirty(peer, "peer state change");
Mark Brownfe4fda52011-10-03 22:36:57 +01001734}
1735
Mark Brown05623c42011-09-28 17:02:31 +01001736static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
1737 struct list_head *up_list,
1738 struct list_head *down_list)
1739{
Mark Browndb432b42011-10-03 21:06:40 +01001740 struct snd_soc_dapm_path *path;
1741
Mark Brown05623c42011-09-28 17:02:31 +01001742 if (w->power == power)
1743 return;
1744
1745 trace_snd_soc_dapm_widget_power(w, power);
1746
Mark Browndb432b42011-10-03 21:06:40 +01001747 /* If we changed our power state perhaps our neigbours changed
Mark Brownfe4fda52011-10-03 22:36:57 +01001748 * also.
Mark Browndb432b42011-10-03 21:06:40 +01001749 */
Lars-Peter Clausen7ddd4cd2014-10-20 19:36:34 +02001750 list_for_each_entry(path, &w->sources, list_sink)
1751 dapm_widget_set_peer_power(path->source, power, path->connect);
1752
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02001753 /* Supplies can't affect their outputs, only their inputs */
1754 if (!w->is_supply) {
Lars-Peter Clausen7ddd4cd2014-10-20 19:36:34 +02001755 list_for_each_entry(path, &w->sinks, list_source)
1756 dapm_widget_set_peer_power(path->sink, power,
1757 path->connect);
Mark Browndb432b42011-10-03 21:06:40 +01001758 }
1759
Mark Brown05623c42011-09-28 17:02:31 +01001760 if (power)
1761 dapm_seq_insert(w, up_list, true);
1762 else
1763 dapm_seq_insert(w, down_list, false);
Mark Brown05623c42011-09-28 17:02:31 +01001764}
1765
Mark Brown7c81beb2011-09-20 22:22:32 +01001766static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1767 struct list_head *up_list,
1768 struct list_head *down_list)
1769{
Mark Brown7c81beb2011-09-20 22:22:32 +01001770 int power;
1771
1772 switch (w->id) {
1773 case snd_soc_dapm_pre:
1774 dapm_seq_insert(w, down_list, false);
1775 break;
1776 case snd_soc_dapm_post:
1777 dapm_seq_insert(w, up_list, true);
1778 break;
1779
1780 default:
Mark Brownd8050022011-09-28 18:28:23 +01001781 power = dapm_widget_power_check(w);
Mark Brown7c81beb2011-09-20 22:22:32 +01001782
Mark Brown05623c42011-09-28 17:02:31 +01001783 dapm_widget_set_power(w, power, up_list, down_list);
Mark Brown7c81beb2011-09-20 22:22:32 +01001784 break;
1785 }
1786}
1787
Lars-Peter Clausen86dbf2a2014-09-04 19:44:06 +02001788static bool dapm_idle_bias_off(struct snd_soc_dapm_context *dapm)
1789{
1790 if (dapm->idle_bias_off)
1791 return true;
1792
1793 switch (snd_power_get_state(dapm->card->snd_card)) {
1794 case SNDRV_CTL_POWER_D3hot:
1795 case SNDRV_CTL_POWER_D3cold:
1796 return dapm->suspend_bias_off;
1797 default:
1798 break;
1799 }
1800
1801 return false;
1802}
1803
Mark Brown42aa3412009-03-01 19:21:10 +00001804/*
Richard Purdie2b97eab2006-10-06 18:32:18 +02001805 * Scan each dapm widget for complete audio path.
1806 * A complete path is a route that has valid endpoints i.e.:-
1807 *
1808 * o DAC to output pin.
1809 * o Input Pin to ADC.
1810 * o Input pin to Output pin (bypass, sidetone)
1811 * o DAC to ADC (loopback).
1812 */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001813static int dapm_power_widgets(struct snd_soc_card *card, int event)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001814{
1815 struct snd_soc_dapm_widget *w;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001816 struct snd_soc_dapm_context *d;
Mark Brown291f3bb2009-06-07 13:57:17 +01001817 LIST_HEAD(up_list);
1818 LIST_HEAD(down_list);
Dan Williams2955b472012-07-09 19:33:25 -07001819 ASYNC_DOMAIN_EXCLUSIVE(async_domain);
Mark Brown56fba412011-06-04 11:25:10 +01001820 enum snd_soc_bias_level bias;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001821
Mark Brownf9fa2b12014-03-06 16:49:11 +08001822 lockdep_assert_held(&card->dapm_mutex);
1823
Mark Brown84e90932010-11-04 00:07:02 -04001824 trace_snd_soc_dapm_start(card);
1825
Mark Brown56fba412011-06-04 11:25:10 +01001826 list_for_each_entry(d, &card->dapm_list, list) {
Lars-Peter Clausen86dbf2a2014-09-04 19:44:06 +02001827 if (dapm_idle_bias_off(d))
Mark Brown497098be2012-03-08 15:06:09 +00001828 d->target_bias_level = SND_SOC_BIAS_OFF;
1829 else
1830 d->target_bias_level = SND_SOC_BIAS_STANDBY;
Mark Brown56fba412011-06-04 11:25:10 +01001831 }
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001832
Liam Girdwood6c120e12012-02-15 15:15:34 +00001833 dapm_reset(card);
Mark Brown9b8a83b2011-10-04 22:15:59 +01001834
Mark Brown6d3ddc82009-05-16 17:47:29 +01001835 /* Check which widgets we need to power and store them in
Mark Browndb432b42011-10-03 21:06:40 +01001836 * lists indicating if they should be powered up or down. We
1837 * only check widgets that have been flagged as dirty but note
1838 * that new widgets may be added to the dirty list while we
1839 * iterate.
Mark Brown6d3ddc82009-05-16 17:47:29 +01001840 */
Mark Browndb432b42011-10-03 21:06:40 +01001841 list_for_each_entry(w, &card->dapm_dirty, dirty) {
Mark Brown7c81beb2011-09-20 22:22:32 +01001842 dapm_power_one_widget(w, &up_list, &down_list);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001843 }
1844
Mark Brownf9de6d72011-09-28 17:19:47 +01001845 list_for_each_entry(w, &card->widgets, list) {
Mark Brown0ff97eb2012-07-20 17:29:34 +01001846 switch (w->id) {
1847 case snd_soc_dapm_pre:
1848 case snd_soc_dapm_post:
1849 /* These widgets always need to be powered */
1850 break;
1851 default:
1852 list_del_init(&w->dirty);
1853 break;
1854 }
Mark Browndb432b42011-10-03 21:06:40 +01001855
Lars-Peter Clausen39eb5fd2013-07-29 17:14:03 +02001856 if (w->new_power) {
Mark Brownf9de6d72011-09-28 17:19:47 +01001857 d = w->dapm;
1858
1859 /* Supplies and micbiases only bring the
1860 * context up to STANDBY as unless something
1861 * else is active and passing audio they
Mark Brownafe62362012-01-25 19:55:22 +00001862 * generally don't require full power. Signal
1863 * generators are virtual pins and have no
1864 * power impact themselves.
Mark Brownf9de6d72011-09-28 17:19:47 +01001865 */
1866 switch (w->id) {
Mark Brownafe62362012-01-25 19:55:22 +00001867 case snd_soc_dapm_siggen:
Lars-Peter Clausenda83fea2013-10-05 19:26:17 +02001868 case snd_soc_dapm_vmid:
Mark Brownafe62362012-01-25 19:55:22 +00001869 break;
Mark Brownf9de6d72011-09-28 17:19:47 +01001870 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00001871 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02001872 case snd_soc_dapm_clock_supply:
Mark Brownf9de6d72011-09-28 17:19:47 +01001873 case snd_soc_dapm_micbias:
1874 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
1875 d->target_bias_level = SND_SOC_BIAS_STANDBY;
1876 break;
1877 default:
1878 d->target_bias_level = SND_SOC_BIAS_ON;
1879 break;
1880 }
1881 }
1882
1883 }
1884
Mark Brown85a843c2011-09-21 21:29:47 +01001885 /* Force all contexts in the card to the same bias state if
1886 * they're not ground referenced.
1887 */
Mark Brown56fba412011-06-04 11:25:10 +01001888 bias = SND_SOC_BIAS_OFF;
Mark Brown52ba67b2011-04-04 21:05:11 +09001889 list_for_each_entry(d, &card->dapm_list, list)
Mark Brown56fba412011-06-04 11:25:10 +01001890 if (d->target_bias_level > bias)
1891 bias = d->target_bias_level;
Mark Brown52ba67b2011-04-04 21:05:11 +09001892 list_for_each_entry(d, &card->dapm_list, list)
Lars-Peter Clausen86dbf2a2014-09-04 19:44:06 +02001893 if (!dapm_idle_bias_off(d))
Mark Brown85a843c2011-09-21 21:29:47 +01001894 d->target_bias_level = bias;
Mark Brown52ba67b2011-04-04 21:05:11 +09001895
Mark Brownde02d072011-09-20 21:43:24 +01001896 trace_snd_soc_dapm_walk_done(card);
Mark Brown52ba67b2011-04-04 21:05:11 +09001897
Xiang Xiao17282ba2014-03-02 00:04:03 +08001898 /* Run card bias changes at first */
1899 dapm_pre_sequence_async(&card->dapm, 0);
1900 /* Run other bias changes in parallel */
1901 list_for_each_entry(d, &card->dapm_list, list) {
1902 if (d != &card->dapm)
1903 async_schedule_domain(dapm_pre_sequence_async, d,
1904 &async_domain);
1905 }
Mark Brown9d0624a2011-02-18 11:49:43 -08001906 async_synchronize_full_domain(&async_domain);
Mark Brown452c5ea2009-05-17 21:41:23 +01001907
Lars-Peter Clausencf1f7c62013-05-23 00:12:53 +02001908 list_for_each_entry(w, &down_list, power_list) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001909 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
Mark Brown80114122013-02-25 15:14:19 +00001910 }
1911
Lars-Peter Clausencf1f7c62013-05-23 00:12:53 +02001912 list_for_each_entry(w, &up_list, power_list) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001913 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
Mark Brown80114122013-02-25 15:14:19 +00001914 }
1915
Mark Brown6d3ddc82009-05-16 17:47:29 +01001916 /* Power down widgets first; try to avoid amplifying pops. */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001917 dapm_seq_run(card, &down_list, event, false);
Mark Brown6d3ddc82009-05-16 17:47:29 +01001918
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001919 dapm_widget_update(card);
Mark Brown97404f22010-12-14 16:13:57 +00001920
Mark Brown6d3ddc82009-05-16 17:47:29 +01001921 /* Now power up. */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001922 dapm_seq_run(card, &up_list, event, true);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001923
Mark Brown9d0624a2011-02-18 11:49:43 -08001924 /* Run all the bias changes in parallel */
Xiang Xiao17282ba2014-03-02 00:04:03 +08001925 list_for_each_entry(d, &card->dapm_list, list) {
1926 if (d != &card->dapm)
1927 async_schedule_domain(dapm_post_sequence_async, d,
1928 &async_domain);
1929 }
Mark Brown9d0624a2011-02-18 11:49:43 -08001930 async_synchronize_full_domain(&async_domain);
Xiang Xiao17282ba2014-03-02 00:04:03 +08001931 /* Run card bias changes at last */
1932 dapm_post_sequence_async(&card->dapm, 0);
Mark Brown452c5ea2009-05-17 21:41:23 +01001933
Liam Girdwood8078d872012-02-15 15:15:35 +00001934 /* do we need to notify any clients that DAPM event is complete */
1935 list_for_each_entry(d, &card->dapm_list, list) {
1936 if (d->stream_event)
1937 d->stream_event(d, event);
1938 }
1939
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001940 pop_dbg(card->dev, card->pop_time,
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +02001941 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
Jarkko Nikula3a45b862010-11-05 20:35:21 +02001942 pop_wait(card->pop_time);
Mark Browncb507e72009-07-08 18:54:57 +01001943
Mark Brown84e90932010-11-04 00:07:02 -04001944 trace_snd_soc_dapm_done(card);
1945
Mark Brown42aa3412009-03-01 19:21:10 +00001946 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001947}
1948
Mark Brown79fb9382009-08-21 16:38:13 +01001949#ifdef CONFIG_DEBUG_FS
Mark Brown79fb9382009-08-21 16:38:13 +01001950static ssize_t dapm_widget_power_read_file(struct file *file,
1951 char __user *user_buf,
1952 size_t count, loff_t *ppos)
1953{
1954 struct snd_soc_dapm_widget *w = file->private_data;
1955 char *buf;
1956 int in, out;
1957 ssize_t ret;
1958 struct snd_soc_dapm_path *p = NULL;
1959
1960 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1961 if (!buf)
1962 return -ENOMEM;
1963
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02001964 /* Supply widgets are not handled by is_connected_{input,output}_ep() */
1965 if (w->is_supply) {
1966 in = 0;
1967 out = 0;
1968 } else {
1969 in = is_connected_input_ep(w, NULL);
1970 out = is_connected_output_ep(w, NULL);
1971 }
Mark Brown79fb9382009-08-21 16:38:13 +01001972
Mark Brownf13ebad2012-03-03 18:01:01 +00001973 ret = snprintf(buf, PAGE_SIZE, "%s: %s%s in %d out %d",
1974 w->name, w->power ? "On" : "Off",
1975 w->force ? " (forced)" : "", in, out);
Mark Brown79fb9382009-08-21 16:38:13 +01001976
Mark Brownd033c362009-12-04 15:25:56 +00001977 if (w->reg >= 0)
1978 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001979 " - R%d(0x%x) mask 0x%x",
1980 w->reg, w->reg, w->mask << w->shift);
Mark Brownd033c362009-12-04 15:25:56 +00001981
1982 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1983
Mark Brown3eef08b2009-09-14 16:49:00 +01001984 if (w->sname)
1985 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1986 w->sname,
1987 w->active ? "active" : "inactive");
Mark Brown79fb9382009-08-21 16:38:13 +01001988
1989 list_for_each_entry(p, &w->sources, list_sink) {
Takashi Iwaiff186202013-10-28 14:21:49 +01001990 if (p->connected && !p->connected(w, p->source))
Mark Brown215edda2009-09-08 18:59:05 +01001991 continue;
1992
Mark Brown79fb9382009-08-21 16:38:13 +01001993 if (p->connect)
1994 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Dimitris Papastamos67f5ed62011-02-24 17:09:32 +00001995 " in \"%s\" \"%s\"\n",
Mark Brown79fb9382009-08-21 16:38:13 +01001996 p->name ? p->name : "static",
1997 p->source->name);
1998 }
1999 list_for_each_entry(p, &w->sinks, list_source) {
Mark Brown215edda2009-09-08 18:59:05 +01002000 if (p->connected && !p->connected(w, p->sink))
2001 continue;
2002
Mark Brown79fb9382009-08-21 16:38:13 +01002003 if (p->connect)
2004 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Dimitris Papastamos67f5ed62011-02-24 17:09:32 +00002005 " out \"%s\" \"%s\"\n",
Mark Brown79fb9382009-08-21 16:38:13 +01002006 p->name ? p->name : "static",
2007 p->sink->name);
2008 }
2009
2010 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
2011
2012 kfree(buf);
2013 return ret;
2014}
2015
2016static const struct file_operations dapm_widget_power_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -07002017 .open = simple_open,
Mark Brown79fb9382009-08-21 16:38:13 +01002018 .read = dapm_widget_power_read_file,
Arnd Bergmann6038f372010-08-15 18:52:59 +02002019 .llseek = default_llseek,
Mark Brown79fb9382009-08-21 16:38:13 +01002020};
2021
Mark Brownef49e4f2011-04-04 20:48:13 +09002022static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
2023 size_t count, loff_t *ppos)
2024{
2025 struct snd_soc_dapm_context *dapm = file->private_data;
2026 char *level;
2027
2028 switch (dapm->bias_level) {
2029 case SND_SOC_BIAS_ON:
2030 level = "On\n";
2031 break;
2032 case SND_SOC_BIAS_PREPARE:
2033 level = "Prepare\n";
2034 break;
2035 case SND_SOC_BIAS_STANDBY:
2036 level = "Standby\n";
2037 break;
2038 case SND_SOC_BIAS_OFF:
2039 level = "Off\n";
2040 break;
2041 default:
Takashi Iwaia6ed0602013-11-06 11:07:19 +01002042 WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
Mark Brownef49e4f2011-04-04 20:48:13 +09002043 level = "Unknown\n";
2044 break;
2045 }
2046
2047 return simple_read_from_buffer(user_buf, count, ppos, level,
2048 strlen(level));
2049}
2050
2051static const struct file_operations dapm_bias_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -07002052 .open = simple_open,
Mark Brownef49e4f2011-04-04 20:48:13 +09002053 .read = dapm_bias_read_file,
2054 .llseek = default_llseek,
2055};
2056
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002057void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2058 struct dentry *parent)
Mark Brown79fb9382009-08-21 16:38:13 +01002059{
Mark Brown79fb9382009-08-21 16:38:13 +01002060 struct dentry *d;
2061
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +02002062 if (!parent)
2063 return;
2064
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002065 dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
2066
2067 if (!dapm->debugfs_dapm) {
Liam Girdwoodf1e90af2012-03-06 18:13:25 +00002068 dev_warn(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002069 "ASoC: Failed to create DAPM debugfs directory\n");
Mark Brown79fb9382009-08-21 16:38:13 +01002070 return;
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002071 }
Mark Brown79fb9382009-08-21 16:38:13 +01002072
Mark Brownef49e4f2011-04-04 20:48:13 +09002073 d = debugfs_create_file("bias_level", 0444,
2074 dapm->debugfs_dapm, dapm,
2075 &dapm_bias_fops);
2076 if (!d)
2077 dev_warn(dapm->dev,
2078 "ASoC: Failed to create bias level debugfs file\n");
Mark Brown79fb9382009-08-21 16:38:13 +01002079}
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002080
2081static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2082{
2083 struct snd_soc_dapm_context *dapm = w->dapm;
2084 struct dentry *d;
2085
2086 if (!dapm->debugfs_dapm || !w->name)
2087 return;
2088
2089 d = debugfs_create_file(w->name, 0444,
2090 dapm->debugfs_dapm, w,
2091 &dapm_widget_power_fops);
2092 if (!d)
2093 dev_warn(w->dapm->dev,
2094 "ASoC: Failed to create %s debugfs file\n",
2095 w->name);
2096}
2097
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02002098static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2099{
2100 debugfs_remove_recursive(dapm->debugfs_dapm);
2101}
2102
Mark Brown79fb9382009-08-21 16:38:13 +01002103#else
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002104void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2105 struct dentry *parent)
Mark Brown79fb9382009-08-21 16:38:13 +01002106{
2107}
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002108
2109static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2110{
2111}
2112
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02002113static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2114{
2115}
2116
Mark Brown79fb9382009-08-21 16:38:13 +01002117#endif
2118
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002119/*
2120 * soc_dapm_connect_path() - Connects or disconnects a path
2121 * @path: The path to update
2122 * @connect: The new connect state of the path. True if the path is connected,
2123 * false if it is disconneted.
2124 * @reason: The reason why the path changed (for debugging only)
2125 */
2126static void soc_dapm_connect_path(struct snd_soc_dapm_path *path,
2127 bool connect, const char *reason)
2128{
2129 if (path->connect == connect)
2130 return;
2131
2132 path->connect = connect;
2133 dapm_mark_dirty(path->source, reason);
2134 dapm_mark_dirty(path->sink, reason);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002135 dapm_path_invalidate(path);
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002136}
2137
Richard Purdie2b97eab2006-10-06 18:32:18 +02002138/* test and update the power status of a mux widget */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002139static int soc_dapm_mux_update_power(struct snd_soc_card *card,
Liam Girdwood40f02cd2012-02-06 16:05:14 +00002140 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002141{
2142 struct snd_soc_dapm_path *path;
2143 int found = 0;
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002144 bool connect;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002145
Mark Brownf9fa2b12014-03-06 16:49:11 +08002146 lockdep_assert_held(&card->dapm_mutex);
2147
Richard Purdie2b97eab2006-10-06 18:32:18 +02002148 /* find dapm widget path assoc with kcontrol */
Lars-Peter Clausen5106b922013-07-29 17:14:00 +02002149 dapm_kcontrol_for_each_path(path, kcontrol) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002150 found = 1;
2151 /* we now need to match the string in the enum to the path */
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002152 if (!(strcmp(path->name, e->texts[mux])))
2153 connect = true;
2154 else
2155 connect = false;
2156
2157 soc_dapm_connect_path(path, connect, "mux update");
Richard Purdie2b97eab2006-10-06 18:32:18 +02002158 }
2159
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002160 if (found)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002161 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002162
Liam Girdwood618dae12012-04-25 12:12:51 +01002163 return found;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002164}
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002165
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002166int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausen6b3fc032013-07-24 15:27:38 +02002167 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
2168 struct snd_soc_dapm_update *update)
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002169{
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002170 struct snd_soc_card *card = dapm->card;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002171 int ret;
2172
Liam Girdwood3cd04342012-03-09 12:02:08 +00002173 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002174 card->update = update;
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002175 ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002176 card->update = NULL;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002177 mutex_unlock(&card->dapm_mutex);
Liam Girdwood618dae12012-04-25 12:12:51 +01002178 if (ret > 0)
Lars-Peter Clausenc3f48ae2013-07-24 15:27:36 +02002179 soc_dpcm_runtime_update(card);
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002180 return ret;
2181}
Liam Girdwood40f02cd2012-02-06 16:05:14 +00002182EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002183
Milan plzik1b075e32008-01-10 14:39:46 +01002184/* test and update the power status of a mixer or switch widget */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002185static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
Mark Brown283375c2009-12-07 18:09:03 +00002186 struct snd_kcontrol *kcontrol, int connect)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002187{
2188 struct snd_soc_dapm_path *path;
2189 int found = 0;
2190
Mark Brownf9fa2b12014-03-06 16:49:11 +08002191 lockdep_assert_held(&card->dapm_mutex);
2192
Richard Purdie2b97eab2006-10-06 18:32:18 +02002193 /* find dapm widget path assoc with kcontrol */
Lars-Peter Clausen5106b922013-07-29 17:14:00 +02002194 dapm_kcontrol_for_each_path(path, kcontrol) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002195 found = 1;
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002196 soc_dapm_connect_path(path, connect, "mixer update");
Richard Purdie2b97eab2006-10-06 18:32:18 +02002197 }
2198
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002199 if (found)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002200 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002201
Liam Girdwood618dae12012-04-25 12:12:51 +01002202 return found;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002203}
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002204
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002205int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausen6b3fc032013-07-24 15:27:38 +02002206 struct snd_kcontrol *kcontrol, int connect,
2207 struct snd_soc_dapm_update *update)
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002208{
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002209 struct snd_soc_card *card = dapm->card;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002210 int ret;
2211
Liam Girdwood3cd04342012-03-09 12:02:08 +00002212 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002213 card->update = update;
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002214 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002215 card->update = NULL;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002216 mutex_unlock(&card->dapm_mutex);
Liam Girdwood618dae12012-04-25 12:12:51 +01002217 if (ret > 0)
Lars-Peter Clausenc3f48ae2013-07-24 15:27:36 +02002218 soc_dpcm_runtime_update(card);
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002219 return ret;
2220}
Liam Girdwood40f02cd2012-02-06 16:05:14 +00002221EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002222
Benoit Cousson44ba2642014-07-08 23:19:36 +02002223static ssize_t dapm_widget_show_codec(struct snd_soc_codec *codec, char *buf)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002224{
Richard Purdie2b97eab2006-10-06 18:32:18 +02002225 struct snd_soc_dapm_widget *w;
2226 int count = 0;
2227 char *state = "not set";
2228
Lars-Peter Clausen00200102014-07-17 22:01:07 +02002229 list_for_each_entry(w, &codec->component.card->widgets, list) {
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002230 if (w->dapm != &codec->dapm)
2231 continue;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002232
2233 /* only display widgets that burnm power */
2234 switch (w->id) {
2235 case snd_soc_dapm_hp:
2236 case snd_soc_dapm_mic:
2237 case snd_soc_dapm_spk:
2238 case snd_soc_dapm_line:
2239 case snd_soc_dapm_micbias:
2240 case snd_soc_dapm_dac:
2241 case snd_soc_dapm_adc:
2242 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06002243 case snd_soc_dapm_out_drv:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002244 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00002245 case snd_soc_dapm_mixer_named_ctl:
Mark Brown246d0a12009-04-22 18:24:55 +01002246 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00002247 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02002248 case snd_soc_dapm_clock_supply:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002249 if (w->name)
2250 count += sprintf(buf + count, "%s: %s\n",
2251 w->name, w->power ? "On":"Off");
2252 break;
2253 default:
2254 break;
2255 }
2256 }
2257
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002258 switch (codec->dapm.bias_level) {
Mark Brown0be98982008-05-19 12:31:28 +02002259 case SND_SOC_BIAS_ON:
2260 state = "On";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002261 break;
Mark Brown0be98982008-05-19 12:31:28 +02002262 case SND_SOC_BIAS_PREPARE:
2263 state = "Prepare";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002264 break;
Mark Brown0be98982008-05-19 12:31:28 +02002265 case SND_SOC_BIAS_STANDBY:
2266 state = "Standby";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002267 break;
Mark Brown0be98982008-05-19 12:31:28 +02002268 case SND_SOC_BIAS_OFF:
2269 state = "Off";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002270 break;
2271 }
2272 count += sprintf(buf + count, "PM State: %s\n", state);
2273
2274 return count;
2275}
2276
Benoit Cousson44ba2642014-07-08 23:19:36 +02002277/* show dapm widget status in sys fs */
2278static ssize_t dapm_widget_show(struct device *dev,
2279 struct device_attribute *attr, char *buf)
2280{
2281 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
2282 int i, count = 0;
2283
2284 for (i = 0; i < rtd->num_codecs; i++) {
2285 struct snd_soc_codec *codec = rtd->codec_dais[i]->codec;
2286 count += dapm_widget_show_codec(codec, buf + count);
2287 }
2288
2289 return count;
2290}
2291
Richard Purdie2b97eab2006-10-06 18:32:18 +02002292static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
2293
Takashi Iwaid29697d2015-01-30 20:16:37 +01002294struct attribute *soc_dapm_dev_attrs[] = {
2295 &dev_attr_dapm_widget.attr,
2296 NULL
2297};
Richard Purdie2b97eab2006-10-06 18:32:18 +02002298
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002299static void dapm_free_path(struct snd_soc_dapm_path *path)
2300{
2301 list_del(&path->list_sink);
2302 list_del(&path->list_source);
Lars-Peter Clausen5106b922013-07-29 17:14:00 +02002303 list_del(&path->list_kcontrol);
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002304 list_del(&path->list);
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002305 kfree(path);
2306}
2307
Richard Purdie2b97eab2006-10-06 18:32:18 +02002308/* free all dapm widgets and resources */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002309static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002310{
2311 struct snd_soc_dapm_widget *w, *next_w;
2312 struct snd_soc_dapm_path *p, *next_p;
2313
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002314 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
2315 if (w->dapm != dapm)
2316 continue;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002317 list_del(&w->list);
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02002318 /*
2319 * remove source and sink paths associated to this widget.
2320 * While removing the path, remove reference to it from both
2321 * source and sink widgets so that path is removed only once.
2322 */
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002323 list_for_each_entry_safe(p, next_p, &w->sources, list_sink)
2324 dapm_free_path(p);
2325
2326 list_for_each_entry_safe(p, next_p, &w->sinks, list_source)
2327 dapm_free_path(p);
2328
Stephen Warrenfad59882011-04-28 17:37:59 -06002329 kfree(w->kcontrols);
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002330 kfree(w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002331 kfree(w);
2332 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02002333}
2334
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002335static struct snd_soc_dapm_widget *dapm_find_widget(
2336 struct snd_soc_dapm_context *dapm, const char *pin,
2337 bool search_other_contexts)
2338{
2339 struct snd_soc_dapm_widget *w;
2340 struct snd_soc_dapm_widget *fallback = NULL;
2341
2342 list_for_each_entry(w, &dapm->card->widgets, list) {
2343 if (!strcmp(w->name, pin)) {
2344 if (w->dapm == dapm)
2345 return w;
2346 else
2347 fallback = w;
2348 }
2349 }
2350
2351 if (search_other_contexts)
2352 return fallback;
2353
2354 return NULL;
2355}
2356
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002357static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
Mark Brown16499232009-01-07 18:25:13 +00002358 const char *pin, int status)
Liam Girdwooda5302182008-07-07 13:35:17 +01002359{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002360 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Liam Girdwooda5302182008-07-07 13:35:17 +01002361
Mark Brownf9fa2b12014-03-06 16:49:11 +08002362 dapm_assert_locked(dapm);
2363
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002364 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002365 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002366 return -EINVAL;
Liam Girdwooda5302182008-07-07 13:35:17 +01002367 }
2368
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002369 if (w->connected != status) {
Mark Brown1a8b2d92012-02-16 11:50:07 -08002370 dapm_mark_dirty(w, "pin configuration");
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002371 dapm_widget_invalidate_input_paths(w);
2372 dapm_widget_invalidate_output_paths(w);
2373 }
Mark Brown1a8b2d92012-02-16 11:50:07 -08002374
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002375 w->connected = status;
2376 if (status == 0)
2377 w->force = 0;
Mark Brown0d867332011-04-06 11:38:14 +09002378
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002379 return 0;
Liam Girdwooda5302182008-07-07 13:35:17 +01002380}
2381
Richard Purdie2b97eab2006-10-06 18:32:18 +02002382/**
Charles Keepax3eb29df2014-02-18 15:22:15 +00002383 * snd_soc_dapm_sync_unlocked - scan and power dapm paths
2384 * @dapm: DAPM context
2385 *
2386 * Walks all dapm audio paths and powers widgets according to their
2387 * stream or path usage.
2388 *
2389 * Requires external locking.
2390 *
2391 * Returns 0 for success.
2392 */
2393int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
2394{
2395 /*
2396 * Suppress early reports (eg, jacks syncing their state) to avoid
2397 * silly DAPM runs during card startup.
2398 */
2399 if (!dapm->card || !dapm->card->instantiated)
2400 return 0;
2401
2402 return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
2403}
2404EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked);
2405
2406/**
Liam Girdwooda5302182008-07-07 13:35:17 +01002407 * snd_soc_dapm_sync - scan and power dapm paths
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002408 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02002409 *
2410 * Walks all dapm audio paths and powers widgets according to their
2411 * stream or path usage.
2412 *
2413 * Returns 0 for success.
2414 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002415int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002416{
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002417 int ret;
2418
Liam Girdwood3cd04342012-03-09 12:02:08 +00002419 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Charles Keepax3eb29df2014-02-18 15:22:15 +00002420 ret = snd_soc_dapm_sync_unlocked(dapm);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002421 mutex_unlock(&dapm->card->dapm_mutex);
2422 return ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002423}
Liam Girdwooda5302182008-07-07 13:35:17 +01002424EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002425
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002426/*
2427 * dapm_update_widget_flags() - Re-compute widget sink and source flags
2428 * @w: The widget for which to update the flags
2429 *
2430 * Some widgets have a dynamic category which depends on which neighbors they
2431 * are connected to. This function update the category for these widgets.
2432 *
2433 * This function must be called whenever a path is added or removed to a widget.
2434 */
2435static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
2436{
2437 struct snd_soc_dapm_path *p;
2438
2439 switch (w->id) {
2440 case snd_soc_dapm_input:
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01002441 /* On a fully routed card a input is never a source */
2442 if (w->dapm->card->fully_routed)
2443 break;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002444 w->is_source = 1;
2445 list_for_each_entry(p, &w->sources, list_sink) {
2446 if (p->source->id == snd_soc_dapm_micbias ||
2447 p->source->id == snd_soc_dapm_mic ||
2448 p->source->id == snd_soc_dapm_line ||
2449 p->source->id == snd_soc_dapm_output) {
2450 w->is_source = 0;
2451 break;
2452 }
2453 }
2454 break;
2455 case snd_soc_dapm_output:
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01002456 /* On a fully routed card a output is never a sink */
2457 if (w->dapm->card->fully_routed)
2458 break;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002459 w->is_sink = 1;
2460 list_for_each_entry(p, &w->sinks, list_source) {
2461 if (p->sink->id == snd_soc_dapm_spk ||
2462 p->sink->id == snd_soc_dapm_hp ||
2463 p->sink->id == snd_soc_dapm_line ||
2464 p->sink->id == snd_soc_dapm_input) {
2465 w->is_sink = 0;
2466 break;
2467 }
2468 }
2469 break;
2470 case snd_soc_dapm_line:
2471 w->is_sink = !list_empty(&w->sources);
2472 w->is_source = !list_empty(&w->sinks);
2473 break;
2474 default:
2475 break;
2476 }
2477}
2478
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002479static int snd_soc_dapm_check_dynamic_path(struct snd_soc_dapm_context *dapm,
2480 struct snd_soc_dapm_widget *source, struct snd_soc_dapm_widget *sink,
2481 const char *control)
2482{
2483 bool dynamic_source = false;
2484 bool dynamic_sink = false;
2485
2486 if (!control)
2487 return 0;
2488
2489 switch (source->id) {
2490 case snd_soc_dapm_demux:
2491 dynamic_source = true;
2492 break;
2493 default:
2494 break;
2495 }
2496
2497 switch (sink->id) {
2498 case snd_soc_dapm_mux:
2499 case snd_soc_dapm_switch:
2500 case snd_soc_dapm_mixer:
2501 case snd_soc_dapm_mixer_named_ctl:
2502 dynamic_sink = true;
2503 break;
2504 default:
2505 break;
2506 }
2507
2508 if (dynamic_source && dynamic_sink) {
2509 dev_err(dapm->dev,
2510 "Direct connection between demux and mixer/mux not supported for path %s -> [%s] -> %s\n",
2511 source->name, control, sink->name);
2512 return -EINVAL;
2513 } else if (!dynamic_source && !dynamic_sink) {
2514 dev_err(dapm->dev,
2515 "Control not supported for path %s -> [%s] -> %s\n",
2516 source->name, control, sink->name);
2517 return -EINVAL;
2518 }
2519
2520 return 0;
2521}
2522
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002523static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
2524 struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
2525 const char *control,
2526 int (*connected)(struct snd_soc_dapm_widget *source,
2527 struct snd_soc_dapm_widget *sink))
Richard Purdie2b97eab2006-10-06 18:32:18 +02002528{
2529 struct snd_soc_dapm_path *path;
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002530 int ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002531
Lars-Peter Clausene409dfb2014-10-25 17:42:02 +02002532 if (wsink->is_supply && !wsource->is_supply) {
2533 dev_err(dapm->dev,
2534 "Connecting non-supply widget to supply widget is not supported (%s -> %s)\n",
2535 wsource->name, wsink->name);
2536 return -EINVAL;
2537 }
2538
2539 if (connected && !wsource->is_supply) {
2540 dev_err(dapm->dev,
2541 "connected() callback only supported for supply widgets (%s -> %s)\n",
2542 wsource->name, wsink->name);
2543 return -EINVAL;
2544 }
2545
2546 if (wsource->is_supply && control) {
2547 dev_err(dapm->dev,
2548 "Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
2549 wsource->name, control, wsink->name);
2550 return -EINVAL;
2551 }
2552
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002553 ret = snd_soc_dapm_check_dynamic_path(dapm, wsource, wsink, control);
2554 if (ret)
2555 return ret;
2556
Richard Purdie2b97eab2006-10-06 18:32:18 +02002557 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
2558 if (!path)
2559 return -ENOMEM;
2560
2561 path->source = wsource;
2562 path->sink = wsink;
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002563 path->connected = connected;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002564 INIT_LIST_HEAD(&path->list);
Mark Brown69c2d342013-08-13 00:20:36 +01002565 INIT_LIST_HEAD(&path->list_kcontrol);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002566 INIT_LIST_HEAD(&path->list_source);
2567 INIT_LIST_HEAD(&path->list_sink);
2568
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02002569 if (wsource->is_supply || wsink->is_supply)
2570 path->is_supply = 1;
2571
Richard Purdie2b97eab2006-10-06 18:32:18 +02002572 /* connect static paths */
2573 if (control == NULL) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002574 path->connect = 1;
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002575 } else {
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002576 switch (wsource->id) {
2577 case snd_soc_dapm_demux:
2578 ret = dapm_connect_mux(dapm, path, control, wsource);
2579 if (ret)
2580 goto err;
2581 break;
2582 default:
2583 break;
2584 }
2585
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002586 switch (wsink->id) {
2587 case snd_soc_dapm_mux:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002588 ret = dapm_connect_mux(dapm, path, control, wsink);
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002589 if (ret != 0)
2590 goto err;
2591 break;
2592 case snd_soc_dapm_switch:
2593 case snd_soc_dapm_mixer:
2594 case snd_soc_dapm_mixer_named_ctl:
2595 ret = dapm_connect_mixer(dapm, path, control);
2596 if (ret != 0)
2597 goto err;
2598 break;
2599 default:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002600 break;
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002601 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02002602 }
2603
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002604 list_add(&path->list, &dapm->card->paths);
2605 list_add(&path->list_sink, &wsink->sources);
2606 list_add(&path->list_source, &wsource->sinks);
2607
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002608 dapm_update_widget_flags(wsource);
2609 dapm_update_widget_flags(wsink);
2610
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002611 dapm_mark_dirty(wsource, "Route added");
2612 dapm_mark_dirty(wsink, "Route added");
Mark Brownfabd0382012-07-05 17:20:06 +01002613
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002614 if (dapm->card->instantiated && path->connect)
2615 dapm_path_invalidate(path);
2616
Richard Purdie2b97eab2006-10-06 18:32:18 +02002617 return 0;
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002618err:
2619 kfree(path);
2620 return ret;
2621}
Richard Purdie2b97eab2006-10-06 18:32:18 +02002622
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002623static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausena4e91542014-05-07 16:20:25 +02002624 const struct snd_soc_dapm_route *route)
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002625{
2626 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
2627 struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
2628 const char *sink;
2629 const char *source;
2630 char prefixed_sink[80];
2631 char prefixed_source[80];
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002632 const char *prefix;
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002633 int ret;
2634
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002635 prefix = soc_dapm_prefix(dapm);
2636 if (prefix) {
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002637 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002638 prefix, route->sink);
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002639 sink = prefixed_sink;
2640 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002641 prefix, route->source);
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002642 source = prefixed_source;
2643 } else {
2644 sink = route->sink;
2645 source = route->source;
2646 }
2647
Charles Keepax45a110a2015-05-11 13:50:30 +01002648 wsource = dapm_wcache_lookup(&dapm->path_source_cache, source);
2649 wsink = dapm_wcache_lookup(&dapm->path_sink_cache, sink);
2650
2651 if (wsink && wsource)
2652 goto skip_search;
2653
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002654 /*
2655 * find src and dest widgets over all widgets but favor a widget from
2656 * current DAPM context
2657 */
2658 list_for_each_entry(w, &dapm->card->widgets, list) {
2659 if (!wsink && !(strcmp(w->name, sink))) {
2660 wtsink = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002661 if (w->dapm == dapm) {
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002662 wsink = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002663 if (wsource)
2664 break;
2665 }
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002666 continue;
2667 }
2668 if (!wsource && !(strcmp(w->name, source))) {
2669 wtsource = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002670 if (w->dapm == dapm) {
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002671 wsource = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002672 if (wsink)
2673 break;
2674 }
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002675 }
2676 }
2677 /* use widget from another DAPM context if not found from this */
2678 if (!wsink)
2679 wsink = wtsink;
2680 if (!wsource)
2681 wsource = wtsource;
2682
2683 if (wsource == NULL) {
2684 dev_err(dapm->dev, "ASoC: no source widget found for %s\n",
2685 route->source);
2686 return -ENODEV;
2687 }
2688 if (wsink == NULL) {
2689 dev_err(dapm->dev, "ASoC: no sink widget found for %s\n",
2690 route->sink);
2691 return -ENODEV;
2692 }
2693
Charles Keepax45a110a2015-05-11 13:50:30 +01002694skip_search:
2695 dapm_wcache_update(&dapm->path_sink_cache, wsink);
2696 dapm_wcache_update(&dapm->path_source_cache, wsource);
2697
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002698 ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,
2699 route->connected);
2700 if (ret)
2701 goto err;
2702
2703 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002704err:
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002705 dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n",
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002706 source, route->control, sink);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002707 return ret;
2708}
Mark Brown105f1c22008-05-13 14:52:19 +02002709
Mark Brownefcc3c62012-07-05 17:24:19 +01002710static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
2711 const struct snd_soc_dapm_route *route)
2712{
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002713 struct snd_soc_dapm_widget *wsource, *wsink;
Mark Brownefcc3c62012-07-05 17:24:19 +01002714 struct snd_soc_dapm_path *path, *p;
2715 const char *sink;
2716 const char *source;
2717 char prefixed_sink[80];
2718 char prefixed_source[80];
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002719 const char *prefix;
Mark Brownefcc3c62012-07-05 17:24:19 +01002720
2721 if (route->control) {
2722 dev_err(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002723 "ASoC: Removal of routes with controls not supported\n");
Mark Brownefcc3c62012-07-05 17:24:19 +01002724 return -EINVAL;
2725 }
2726
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002727 prefix = soc_dapm_prefix(dapm);
2728 if (prefix) {
Mark Brownefcc3c62012-07-05 17:24:19 +01002729 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002730 prefix, route->sink);
Mark Brownefcc3c62012-07-05 17:24:19 +01002731 sink = prefixed_sink;
2732 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002733 prefix, route->source);
Mark Brownefcc3c62012-07-05 17:24:19 +01002734 source = prefixed_source;
2735 } else {
2736 sink = route->sink;
2737 source = route->source;
2738 }
2739
2740 path = NULL;
2741 list_for_each_entry(p, &dapm->card->paths, list) {
2742 if (strcmp(p->source->name, source) != 0)
2743 continue;
2744 if (strcmp(p->sink->name, sink) != 0)
2745 continue;
2746 path = p;
2747 break;
2748 }
2749
2750 if (path) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002751 wsource = path->source;
2752 wsink = path->sink;
2753
2754 dapm_mark_dirty(wsource, "Route removed");
2755 dapm_mark_dirty(wsink, "Route removed");
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002756 if (path->connect)
2757 dapm_path_invalidate(path);
Mark Brownefcc3c62012-07-05 17:24:19 +01002758
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002759 dapm_free_path(path);
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002760
2761 /* Update any path related flags */
2762 dapm_update_widget_flags(wsource);
2763 dapm_update_widget_flags(wsink);
Mark Brownefcc3c62012-07-05 17:24:19 +01002764 } else {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002765 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
Mark Brownefcc3c62012-07-05 17:24:19 +01002766 source, sink);
2767 }
2768
2769 return 0;
2770}
2771
Mark Brown105f1c22008-05-13 14:52:19 +02002772/**
Mark Brown105f1c22008-05-13 14:52:19 +02002773 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002774 * @dapm: DAPM context
Mark Brown105f1c22008-05-13 14:52:19 +02002775 * @route: audio routes
2776 * @num: number of routes
2777 *
2778 * Connects 2 dapm widgets together via a named audio path. The sink is
2779 * the widget receiving the audio signal, whilst the source is the sender
2780 * of the audio signal.
2781 *
2782 * Returns 0 for success else error. On error all resources can be freed
2783 * with a call to snd_soc_card_free().
2784 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002785int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
Mark Brown105f1c22008-05-13 14:52:19 +02002786 const struct snd_soc_dapm_route *route, int num)
2787{
Mark Brown62d4a4b2012-06-22 12:21:49 +01002788 int i, r, ret = 0;
Mark Brown105f1c22008-05-13 14:52:19 +02002789
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002790 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brown105f1c22008-05-13 14:52:19 +02002791 for (i = 0; i < num; i++) {
Lars-Peter Clausena4e91542014-05-07 16:20:25 +02002792 r = snd_soc_dapm_add_route(dapm, route);
Mark Brown62d4a4b2012-06-22 12:21:49 +01002793 if (r < 0) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002794 dev_err(dapm->dev, "ASoC: Failed to add route %s -> %s -> %s\n",
2795 route->source,
2796 route->control ? route->control : "direct",
2797 route->sink);
Mark Brown62d4a4b2012-06-22 12:21:49 +01002798 ret = r;
Mark Brown105f1c22008-05-13 14:52:19 +02002799 }
2800 route++;
2801 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002802 mutex_unlock(&dapm->card->dapm_mutex);
Mark Brown105f1c22008-05-13 14:52:19 +02002803
Dan Carpenter60884c22012-04-13 22:25:43 +03002804 return ret;
Mark Brown105f1c22008-05-13 14:52:19 +02002805}
2806EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
2807
Mark Brownefcc3c62012-07-05 17:24:19 +01002808/**
2809 * snd_soc_dapm_del_routes - Remove routes between DAPM widgets
2810 * @dapm: DAPM context
2811 * @route: audio routes
2812 * @num: number of routes
2813 *
2814 * Removes routes from the DAPM context.
2815 */
2816int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm,
2817 const struct snd_soc_dapm_route *route, int num)
2818{
2819 int i, ret = 0;
2820
2821 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2822 for (i = 0; i < num; i++) {
2823 snd_soc_dapm_del_route(dapm, route);
2824 route++;
2825 }
2826 mutex_unlock(&dapm->card->dapm_mutex);
2827
2828 return ret;
2829}
2830EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes);
2831
Mark Brownbf3a9e12011-06-13 16:42:29 +01002832static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
2833 const struct snd_soc_dapm_route *route)
2834{
2835 struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
2836 route->source,
2837 true);
2838 struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
2839 route->sink,
2840 true);
2841 struct snd_soc_dapm_path *path;
2842 int count = 0;
2843
2844 if (!source) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002845 dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002846 route->source);
2847 return -ENODEV;
2848 }
2849
2850 if (!sink) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002851 dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002852 route->sink);
2853 return -ENODEV;
2854 }
2855
2856 if (route->control || route->connected)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002857 dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002858 route->source, route->sink);
2859
2860 list_for_each_entry(path, &source->sinks, list_source) {
2861 if (path->sink == sink) {
2862 path->weak = 1;
2863 count++;
2864 }
2865 }
2866
2867 if (count == 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002868 dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002869 route->source, route->sink);
2870 if (count > 1)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002871 dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002872 count, route->source, route->sink);
2873
2874 return 0;
2875}
2876
2877/**
2878 * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
2879 * @dapm: DAPM context
2880 * @route: audio routes
2881 * @num: number of routes
2882 *
2883 * Mark existing routes matching those specified in the passed array
2884 * as being weak, meaning that they are ignored for the purpose of
2885 * power decisions. The main intended use case is for sidetone paths
2886 * which couple audio between other independent paths if they are both
2887 * active in order to make the combination work better at the user
2888 * level but which aren't intended to be "used".
2889 *
2890 * Note that CODEC drivers should not use this as sidetone type paths
2891 * can frequently also be used as bypass paths.
2892 */
2893int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
2894 const struct snd_soc_dapm_route *route, int num)
2895{
2896 int i, err;
2897 int ret = 0;
2898
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002899 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brownbf3a9e12011-06-13 16:42:29 +01002900 for (i = 0; i < num; i++) {
2901 err = snd_soc_dapm_weak_route(dapm, route);
2902 if (err)
2903 ret = err;
2904 route++;
2905 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002906 mutex_unlock(&dapm->card->dapm_mutex);
Mark Brownbf3a9e12011-06-13 16:42:29 +01002907
2908 return ret;
2909}
2910EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2911
Mark Brown105f1c22008-05-13 14:52:19 +02002912/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02002913 * snd_soc_dapm_new_widgets - add new dapm widgets
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002914 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02002915 *
2916 * Checks the codec for any new dapm widgets and creates them if found.
2917 *
2918 * Returns 0 for success.
2919 */
Lars-Peter Clausen824ef822013-08-27 15:51:01 +02002920int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002921{
2922 struct snd_soc_dapm_widget *w;
Mark Brownb66a70d2011-02-09 18:04:11 +00002923 unsigned int val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002924
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002925 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002926
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002927 list_for_each_entry(w, &card->widgets, list)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002928 {
2929 if (w->new)
2930 continue;
2931
Stephen Warrenfad59882011-04-28 17:37:59 -06002932 if (w->num_kcontrols) {
2933 w->kcontrols = kzalloc(w->num_kcontrols *
2934 sizeof(struct snd_kcontrol *),
2935 GFP_KERNEL);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002936 if (!w->kcontrols) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002937 mutex_unlock(&card->dapm_mutex);
Stephen Warrenfad59882011-04-28 17:37:59 -06002938 return -ENOMEM;
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002939 }
Stephen Warrenfad59882011-04-28 17:37:59 -06002940 }
2941
Richard Purdie2b97eab2006-10-06 18:32:18 +02002942 switch(w->id) {
2943 case snd_soc_dapm_switch:
2944 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00002945 case snd_soc_dapm_mixer_named_ctl:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002946 dapm_new_mixer(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002947 break;
2948 case snd_soc_dapm_mux:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002949 case snd_soc_dapm_demux:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002950 dapm_new_mux(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002951 break;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002952 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06002953 case snd_soc_dapm_out_drv:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002954 dapm_new_pga(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002955 break;
Nikesh Oswalc6615082015-02-02 17:06:44 +00002956 case snd_soc_dapm_dai_link:
2957 dapm_new_dai_link(w);
2958 break;
Mark Brown7ca3a182011-10-08 14:04:50 +01002959 default:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002960 break;
2961 }
Mark Brownb66a70d2011-02-09 18:04:11 +00002962
2963 /* Read the initial power state from the device */
2964 if (w->reg >= 0) {
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002965 soc_dapm_read(w->dapm, w->reg, &val);
Arun Shamanna Lakshmif7d3c172014-01-14 15:31:54 -08002966 val = val >> w->shift;
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02002967 val &= w->mask;
2968 if (val == w->on_val)
Mark Brownb66a70d2011-02-09 18:04:11 +00002969 w->power = 1;
2970 }
2971
Richard Purdie2b97eab2006-10-06 18:32:18 +02002972 w->new = 1;
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002973
Mark Brown7508b122011-10-05 12:09:12 +01002974 dapm_mark_dirty(w, "new widget");
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002975 dapm_debugfs_add_widget(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002976 }
2977
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002978 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2979 mutex_unlock(&card->dapm_mutex);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002980 return 0;
2981}
2982EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
2983
2984/**
2985 * snd_soc_dapm_get_volsw - dapm mixer get callback
2986 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002987 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02002988 *
2989 * Callback to get the value of a dapm mixer control.
2990 *
2991 * Returns 0 for success.
2992 */
2993int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
2994 struct snd_ctl_elem_value *ucontrol)
2995{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002996 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
2997 struct snd_soc_card *card = dapm->card;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002998 struct soc_mixer_control *mc =
2999 (struct soc_mixer_control *)kcontrol->private_value;
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003000 int reg = mc->reg;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003001 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01003002 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003003 unsigned int mask = (1 << fls(max)) - 1;
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003004 unsigned int invert = mc->invert;
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003005 unsigned int val;
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003006 int ret = 0;
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003007
3008 if (snd_soc_volsw_is_stereo(mc))
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003009 dev_warn(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003010 "ASoC: Control '%s' is stereo, which is not supported\n",
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003011 kcontrol->id.name);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003012
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003013 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003014 if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
3015 ret = soc_dapm_read(dapm, reg, &val);
3016 val = (val >> shift) & mask;
3017 } else {
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003018 val = dapm_kcontrol_get_value(kcontrol);
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003019 }
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003020 mutex_unlock(&card->dapm_mutex);
3021
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003022 if (invert)
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003023 ucontrol->value.integer.value[0] = max - val;
3024 else
3025 ucontrol->value.integer.value[0] = val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003026
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003027 return ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003028}
3029EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
3030
3031/**
3032 * snd_soc_dapm_put_volsw - dapm mixer set callback
3033 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00003034 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02003035 *
3036 * Callback to set the value of a dapm mixer control.
3037 *
3038 * Returns 0 for success.
3039 */
3040int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
3041 struct snd_ctl_elem_value *ucontrol)
3042{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003043 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3044 struct snd_soc_card *card = dapm->card;
Jon Smirl4eaa9812008-07-29 11:42:26 +01003045 struct soc_mixer_control *mc =
3046 (struct soc_mixer_control *)kcontrol->private_value;
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003047 int reg = mc->reg;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003048 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01003049 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003050 unsigned int mask = (1 << fls(max)) - 1;
3051 unsigned int invert = mc->invert;
Stephen Warrene9cf7042011-01-27 14:54:05 -07003052 unsigned int val;
Jarkko Nikula18626c72014-06-09 14:20:29 +03003053 int connect, change, reg_change = 0;
Mark Brown97404f22010-12-14 16:13:57 +00003054 struct snd_soc_dapm_update update;
Nenghua Cao52765972013-12-13 20:13:49 +08003055 int ret = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003056
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003057 if (snd_soc_volsw_is_stereo(mc))
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003058 dev_warn(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003059 "ASoC: Control '%s' is stereo, which is not supported\n",
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003060 kcontrol->id.name);
3061
Richard Purdie2b97eab2006-10-06 18:32:18 +02003062 val = (ucontrol->value.integer.value[0] & mask);
Benoît Thébaudeau8a720712012-06-18 22:41:28 +02003063 connect = !!val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003064
3065 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01003066 val = max - val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003067
Liam Girdwood3cd04342012-03-09 12:02:08 +00003068 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003069
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003070 change = dapm_kcontrol_set_value(kcontrol, val);
Mark Brown283375c2009-12-07 18:09:03 +00003071
Jarkko Nikula18626c72014-06-09 14:20:29 +03003072 if (reg != SND_SOC_NOPM) {
3073 mask = mask << shift;
3074 val = val << shift;
Lars-Peter Clausenc9e065c2014-05-04 19:17:05 +02003075
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003076 reg_change = soc_dapm_test_bits(dapm, reg, mask, val);
Jarkko Nikula18626c72014-06-09 14:20:29 +03003077 }
3078
3079 if (change || reg_change) {
3080 if (reg_change) {
3081 update.kcontrol = kcontrol;
3082 update.reg = reg;
3083 update.mask = mask;
3084 update.val = val;
3085 card->update = &update;
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003086 }
Jarkko Nikula18626c72014-06-09 14:20:29 +03003087 change |= reg_change;
Mark Brown97404f22010-12-14 16:13:57 +00003088
Nenghua Cao52765972013-12-13 20:13:49 +08003089 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
Mark Brown97404f22010-12-14 16:13:57 +00003090
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02003091 card->update = NULL;
Mark Brown283375c2009-12-07 18:09:03 +00003092 }
3093
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003094 mutex_unlock(&card->dapm_mutex);
Nenghua Cao52765972013-12-13 20:13:49 +08003095
3096 if (ret > 0)
3097 soc_dpcm_runtime_update(card);
3098
Lars-Peter Clausen56a67832013-07-24 15:27:35 +02003099 return change;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003100}
3101EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
3102
3103/**
3104 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
3105 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00003106 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02003107 *
3108 * Callback to get the value of a dapm enumerated double mixer control.
3109 *
3110 * Returns 0 for success.
3111 */
3112int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
3113 struct snd_ctl_elem_value *ucontrol)
3114{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003115 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
Charles Keepax561ed682015-05-01 12:37:26 +01003116 struct snd_soc_card *card = dapm->card;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003117 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003118 unsigned int reg_val, val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003119
Charles Keepax561ed682015-05-01 12:37:26 +01003120 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3121 if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003122 int ret = soc_dapm_read(dapm, e->reg, &reg_val);
Charles Keepax964a0b82015-05-08 10:50:10 +01003123 if (ret) {
3124 mutex_unlock(&card->dapm_mutex);
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003125 return ret;
Charles Keepax964a0b82015-05-08 10:50:10 +01003126 }
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003127 } else {
Lars-Peter Clausen236aaa62014-02-28 08:31:11 +01003128 reg_val = dapm_kcontrol_get_value(kcontrol);
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003129 }
Charles Keepax561ed682015-05-01 12:37:26 +01003130 mutex_unlock(&card->dapm_mutex);
Lars-Peter Clausen236aaa62014-02-28 08:31:11 +01003131
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003132 val = (reg_val >> e->shift_l) & e->mask;
3133 ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
3134 if (e->shift_l != e->shift_r) {
3135 val = (reg_val >> e->shift_r) & e->mask;
3136 val = snd_soc_enum_val_to_item(e, val);
3137 ucontrol->value.enumerated.item[1] = val;
3138 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02003139
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003140 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003141}
3142EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
3143
3144/**
3145 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
3146 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00003147 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02003148 *
3149 * Callback to set the value of a dapm enumerated double mixer control.
3150 *
3151 * Returns 0 for success.
3152 */
3153int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
3154 struct snd_ctl_elem_value *ucontrol)
3155{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003156 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3157 struct snd_soc_card *card = dapm->card;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003158 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003159 unsigned int *item = ucontrol->value.enumerated.item;
Charles Keepax561ed682015-05-01 12:37:26 +01003160 unsigned int val, change, reg_change = 0;
Lars-Peter Clausen86767b72012-09-14 13:57:27 +02003161 unsigned int mask;
Mark Brown97404f22010-12-14 16:13:57 +00003162 struct snd_soc_dapm_update update;
Nenghua Cao52765972013-12-13 20:13:49 +08003163 int ret = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003164
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003165 if (item[0] >= e->items)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003166 return -EINVAL;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003167
3168 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
Lars-Peter Clausen86767b72012-09-14 13:57:27 +02003169 mask = e->mask << e->shift_l;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003170 if (e->shift_l != e->shift_r) {
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003171 if (item[1] > e->items)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003172 return -EINVAL;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003173 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_l;
Lars-Peter Clausen86767b72012-09-14 13:57:27 +02003174 mask |= e->mask << e->shift_r;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003175 }
3176
Liam Girdwood3cd04342012-03-09 12:02:08 +00003177 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Stephen Warrenfafd2172011-04-28 17:38:00 -06003178
Charles Keepax561ed682015-05-01 12:37:26 +01003179 change = dapm_kcontrol_set_value(kcontrol, val);
Mark Brown97404f22010-12-14 16:13:57 +00003180
Charles Keepax561ed682015-05-01 12:37:26 +01003181 if (e->reg != SND_SOC_NOPM)
3182 reg_change = soc_dapm_test_bits(dapm, e->reg, mask, val);
3183
3184 if (change || reg_change) {
3185 if (reg_change) {
Lars-Peter Clausen236aaa62014-02-28 08:31:11 +01003186 update.kcontrol = kcontrol;
3187 update.reg = e->reg;
3188 update.mask = mask;
3189 update.val = val;
3190 card->update = &update;
3191 }
Charles Keepax561ed682015-05-01 12:37:26 +01003192 change |= reg_change;
Mark Brown3a655772009-10-05 17:23:30 +01003193
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003194 ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
Mark Brown1642e3d2009-10-05 16:24:26 +01003195
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02003196 card->update = NULL;
Stephen Warrenfafd2172011-04-28 17:38:00 -06003197 }
3198
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003199 mutex_unlock(&card->dapm_mutex);
Nenghua Cao52765972013-12-13 20:13:49 +08003200
3201 if (ret > 0)
3202 soc_dpcm_runtime_update(card);
3203
Mark Brown97404f22010-12-14 16:13:57 +00003204 return change;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003205}
3206EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
3207
3208/**
Mark Brown8b37dbd2009-02-28 21:14:20 +00003209 * snd_soc_dapm_info_pin_switch - Info for a pin switch
3210 *
3211 * @kcontrol: mixer control
3212 * @uinfo: control element information
3213 *
3214 * Callback to provide information about a pin switch control.
3215 */
3216int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
3217 struct snd_ctl_elem_info *uinfo)
3218{
3219 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3220 uinfo->count = 1;
3221 uinfo->value.integer.min = 0;
3222 uinfo->value.integer.max = 1;
3223
3224 return 0;
3225}
3226EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
3227
3228/**
3229 * snd_soc_dapm_get_pin_switch - Get information for a pin switch
3230 *
3231 * @kcontrol: mixer control
3232 * @ucontrol: Value
3233 */
3234int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
3235 struct snd_ctl_elem_value *ucontrol)
3236{
Mark Brown48a8c392012-02-14 17:11:15 -08003237 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003238 const char *pin = (const char *)kcontrol->private_value;
3239
Liam Girdwood3cd04342012-03-09 12:02:08 +00003240 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003241
3242 ucontrol->value.integer.value[0] =
Mark Brown48a8c392012-02-14 17:11:15 -08003243 snd_soc_dapm_get_pin_status(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003244
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003245 mutex_unlock(&card->dapm_mutex);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003246
3247 return 0;
3248}
3249EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
3250
3251/**
3252 * snd_soc_dapm_put_pin_switch - Set information for a pin switch
3253 *
3254 * @kcontrol: mixer control
3255 * @ucontrol: Value
3256 */
3257int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
3258 struct snd_ctl_elem_value *ucontrol)
3259{
Mark Brown48a8c392012-02-14 17:11:15 -08003260 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003261 const char *pin = (const char *)kcontrol->private_value;
3262
Mark Brown8b37dbd2009-02-28 21:14:20 +00003263 if (ucontrol->value.integer.value[0])
Mark Brown48a8c392012-02-14 17:11:15 -08003264 snd_soc_dapm_enable_pin(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003265 else
Mark Brown48a8c392012-02-14 17:11:15 -08003266 snd_soc_dapm_disable_pin(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003267
Mark Brown48a8c392012-02-14 17:11:15 -08003268 snd_soc_dapm_sync(&card->dapm);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003269 return 0;
3270}
3271EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
3272
Liam Girdwoodcc76e7d2015-06-04 15:13:09 +01003273struct snd_soc_dapm_widget *
Mark Brown5ba06fc2012-02-16 11:07:13 -08003274snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003275 const struct snd_soc_dapm_widget *widget)
3276{
3277 struct snd_soc_dapm_widget *w;
3278
3279 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3280 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3281 if (!w)
3282 dev_err(dapm->dev,
3283 "ASoC: Failed to create DAPM control %s\n",
3284 widget->name);
3285
3286 mutex_unlock(&dapm->card->dapm_mutex);
3287 return w;
3288}
3289
3290struct snd_soc_dapm_widget *
3291snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
Mark Brown5ba06fc2012-02-16 11:07:13 -08003292 const struct snd_soc_dapm_widget *widget)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003293{
3294 struct snd_soc_dapm_widget *w;
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02003295 const char *prefix;
Mark Brown62ea8742012-01-21 21:14:48 +00003296 int ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003297
3298 if ((w = dapm_cnew_widget(widget)) == NULL)
Mark Brown5ba06fc2012-02-16 11:07:13 -08003299 return NULL;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003300
Mark Brown62ea8742012-01-21 21:14:48 +00003301 switch (w->id) {
3302 case snd_soc_dapm_regulator_supply:
Liam Girdwooda3cc0562012-03-09 17:20:16 +00003303 w->regulator = devm_regulator_get(dapm->dev, w->name);
3304 if (IS_ERR(w->regulator)) {
3305 ret = PTR_ERR(w->regulator);
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003306 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
Mark Brown62ea8742012-01-21 21:14:48 +00003307 w->name, ret);
Mark Brown5ba06fc2012-02-16 11:07:13 -08003308 return NULL;
Mark Brown62ea8742012-01-21 21:14:48 +00003309 }
Mark Brown8784c772013-01-10 19:33:47 +00003310
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02003311 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
Mark Brown8784c772013-01-10 19:33:47 +00003312 ret = regulator_allow_bypass(w->regulator, true);
3313 if (ret != 0)
3314 dev_warn(w->dapm->dev,
Charles Keepax30686c32014-02-18 16:05:27 +00003315 "ASoC: Failed to bypass %s: %d\n",
Mark Brown8784c772013-01-10 19:33:47 +00003316 w->name, ret);
3317 }
Mark Brown62ea8742012-01-21 21:14:48 +00003318 break;
Ola Liljad7e7eb92012-05-24 15:26:25 +02003319 case snd_soc_dapm_clock_supply:
Mark Brown165961e2012-06-05 10:44:23 +01003320#ifdef CONFIG_CLKDEV_LOOKUP
Mark Brown695594f12012-06-04 08:14:13 +01003321 w->clk = devm_clk_get(dapm->dev, w->name);
Ola Liljad7e7eb92012-05-24 15:26:25 +02003322 if (IS_ERR(w->clk)) {
3323 ret = PTR_ERR(w->clk);
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003324 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
Ola Liljad7e7eb92012-05-24 15:26:25 +02003325 w->name, ret);
3326 return NULL;
3327 }
Mark Brownec029952012-06-04 08:16:20 +01003328#else
3329 return NULL;
3330#endif
Ola Liljad7e7eb92012-05-24 15:26:25 +02003331 break;
Mark Brown62ea8742012-01-21 21:14:48 +00003332 default:
3333 break;
3334 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02003335
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02003336 prefix = soc_dapm_prefix(dapm);
3337 if (prefix)
3338 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, widget->name);
Lars-Peter Clausen2b581072013-05-14 11:05:32 +02003339 else
3340 w->name = kasprintf(GFP_KERNEL, "%s", widget->name);
3341
Jarkko Nikulaead9b912010-11-13 20:40:44 +02003342 if (w->name == NULL) {
3343 kfree(w);
Mark Brown5ba06fc2012-02-16 11:07:13 -08003344 return NULL;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02003345 }
Jarkko Nikulaead9b912010-11-13 20:40:44 +02003346
Mark Brown7ca3a182011-10-08 14:04:50 +01003347 switch (w->id) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003348 case snd_soc_dapm_mic:
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003349 w->is_source = 1;
3350 w->power_check = dapm_generic_check_power;
3351 break;
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01003352 case snd_soc_dapm_input:
3353 if (!dapm->card->fully_routed)
3354 w->is_source = 1;
3355 w->power_check = dapm_generic_check_power;
3356 break;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003357 case snd_soc_dapm_spk:
3358 case snd_soc_dapm_hp:
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003359 w->is_sink = 1;
3360 w->power_check = dapm_generic_check_power;
3361 break;
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01003362 case snd_soc_dapm_output:
3363 if (!dapm->card->fully_routed)
3364 w->is_sink = 1;
3365 w->power_check = dapm_generic_check_power;
3366 break;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003367 case snd_soc_dapm_vmid:
3368 case snd_soc_dapm_siggen:
3369 w->is_source = 1;
3370 w->power_check = dapm_always_on_check_power;
3371 break;
3372 case snd_soc_dapm_mux:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02003373 case snd_soc_dapm_demux:
Mark Brown7ca3a182011-10-08 14:04:50 +01003374 case snd_soc_dapm_switch:
3375 case snd_soc_dapm_mixer:
3376 case snd_soc_dapm_mixer_named_ctl:
Mark Brown63c69a62013-07-18 22:03:01 +01003377 case snd_soc_dapm_adc:
3378 case snd_soc_dapm_aif_out:
3379 case snd_soc_dapm_dac:
3380 case snd_soc_dapm_aif_in:
Mark Brown7ca3a182011-10-08 14:04:50 +01003381 case snd_soc_dapm_pga:
3382 case snd_soc_dapm_out_drv:
Mark Brown7ca3a182011-10-08 14:04:50 +01003383 case snd_soc_dapm_micbias:
Mark Brown7ca3a182011-10-08 14:04:50 +01003384 case snd_soc_dapm_line:
Mark Brownc74184e2012-04-04 22:12:09 +01003385 case snd_soc_dapm_dai_link:
Lars-Peter Clausencdef2ad2014-10-20 19:36:38 +02003386 case snd_soc_dapm_dai_out:
3387 case snd_soc_dapm_dai_in:
Mark Brown7ca3a182011-10-08 14:04:50 +01003388 w->power_check = dapm_generic_check_power;
3389 break;
3390 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00003391 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02003392 case snd_soc_dapm_clock_supply:
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003393 case snd_soc_dapm_kcontrol:
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003394 w->is_supply = 1;
Mark Brown7ca3a182011-10-08 14:04:50 +01003395 w->power_check = dapm_supply_check_power;
3396 break;
3397 default:
3398 w->power_check = dapm_always_on_check_power;
3399 break;
3400 }
3401
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003402 w->dapm = dapm;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003403 INIT_LIST_HEAD(&w->sources);
3404 INIT_LIST_HEAD(&w->sinks);
3405 INIT_LIST_HEAD(&w->list);
Mark Browndb432b42011-10-03 21:06:40 +01003406 INIT_LIST_HEAD(&w->dirty);
Lars-Peter Clausen92fa1242015-05-01 18:02:42 +02003407 list_add_tail(&w->list, &dapm->card->widgets);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003408
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02003409 w->inputs = -1;
3410 w->outputs = -1;
3411
Richard Purdie2b97eab2006-10-06 18:32:18 +02003412 /* machine layer set ups unconnected pins and insertions */
3413 w->connected = 1;
Mark Brown5ba06fc2012-02-16 11:07:13 -08003414 return w;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003415}
Richard Purdie2b97eab2006-10-06 18:32:18 +02003416
3417/**
Mark Brown4ba13272008-05-13 14:51:19 +02003418 * snd_soc_dapm_new_controls - create new dapm controls
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003419 * @dapm: DAPM context
Mark Brown4ba13272008-05-13 14:51:19 +02003420 * @widget: widget array
3421 * @num: number of widgets
3422 *
3423 * Creates new DAPM controls based upon the templates.
3424 *
3425 * Returns 0 for success else error.
3426 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003427int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
Mark Brown4ba13272008-05-13 14:51:19 +02003428 const struct snd_soc_dapm_widget *widget,
3429 int num)
3430{
Mark Brown5ba06fc2012-02-16 11:07:13 -08003431 struct snd_soc_dapm_widget *w;
3432 int i;
Dan Carpenter60884c22012-04-13 22:25:43 +03003433 int ret = 0;
Mark Brown4ba13272008-05-13 14:51:19 +02003434
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003435 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brown4ba13272008-05-13 14:51:19 +02003436 for (i = 0; i < num; i++) {
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003437 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
Mark Brown5ba06fc2012-02-16 11:07:13 -08003438 if (!w) {
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02003439 dev_err(dapm->dev,
Mark Brown5ba06fc2012-02-16 11:07:13 -08003440 "ASoC: Failed to create DAPM control %s\n",
3441 widget->name);
Dan Carpenter60884c22012-04-13 22:25:43 +03003442 ret = -ENOMEM;
3443 break;
Mark Brownb8b33cb2008-12-18 11:19:30 +00003444 }
Mark Brown4ba13272008-05-13 14:51:19 +02003445 widget++;
3446 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003447 mutex_unlock(&dapm->card->dapm_mutex);
Dan Carpenter60884c22012-04-13 22:25:43 +03003448 return ret;
Mark Brown4ba13272008-05-13 14:51:19 +02003449}
3450EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
3451
Mark Brownc74184e2012-04-04 22:12:09 +01003452static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
3453 struct snd_kcontrol *kcontrol, int event)
3454{
3455 struct snd_soc_dapm_path *source_p, *sink_p;
3456 struct snd_soc_dai *source, *sink;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003457 const struct snd_soc_pcm_stream *config = w->params + w->params_select;
Mark Brownc74184e2012-04-04 22:12:09 +01003458 struct snd_pcm_substream substream;
Mark Brown9747cec2012-04-26 19:12:21 +01003459 struct snd_pcm_hw_params *params = NULL;
Mark Brownc74184e2012-04-04 22:12:09 +01003460 u64 fmt;
3461 int ret;
3462
Takashi Iwaibf4edea2013-11-07 18:38:47 +01003463 if (WARN_ON(!config) ||
3464 WARN_ON(list_empty(&w->sources) || list_empty(&w->sinks)))
3465 return -EINVAL;
Mark Brownc74184e2012-04-04 22:12:09 +01003466
3467 /* We only support a single source and sink, pick the first */
3468 source_p = list_first_entry(&w->sources, struct snd_soc_dapm_path,
3469 list_sink);
3470 sink_p = list_first_entry(&w->sinks, struct snd_soc_dapm_path,
3471 list_source);
3472
Takashi Iwaibf4edea2013-11-07 18:38:47 +01003473 if (WARN_ON(!source_p || !sink_p) ||
3474 WARN_ON(!sink_p->source || !source_p->sink) ||
3475 WARN_ON(!source_p->source || !sink_p->sink))
3476 return -EINVAL;
Mark Brownc74184e2012-04-04 22:12:09 +01003477
3478 source = source_p->source->priv;
3479 sink = sink_p->sink->priv;
3480
3481 /* Be a little careful as we don't want to overflow the mask array */
3482 if (config->formats) {
3483 fmt = ffs(config->formats) - 1;
3484 } else {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003485 dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n",
Mark Brownc74184e2012-04-04 22:12:09 +01003486 config->formats);
3487 fmt = 0;
3488 }
3489
3490 /* Currently very limited parameter selection */
Mark Brown9747cec2012-04-26 19:12:21 +01003491 params = kzalloc(sizeof(*params), GFP_KERNEL);
3492 if (!params) {
3493 ret = -ENOMEM;
3494 goto out;
3495 }
3496 snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
Mark Brownc74184e2012-04-04 22:12:09 +01003497
Mark Brown9747cec2012-04-26 19:12:21 +01003498 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
Mark Brownc74184e2012-04-04 22:12:09 +01003499 config->rate_min;
Mark Brown9747cec2012-04-26 19:12:21 +01003500 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
Mark Brownc74184e2012-04-04 22:12:09 +01003501 config->rate_max;
3502
Mark Brown9747cec2012-04-26 19:12:21 +01003503 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
Mark Brownc74184e2012-04-04 22:12:09 +01003504 = config->channels_min;
Mark Brown9747cec2012-04-26 19:12:21 +01003505 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
Mark Brownc74184e2012-04-04 22:12:09 +01003506 = config->channels_max;
3507
3508 memset(&substream, 0, sizeof(substream));
3509
3510 switch (event) {
3511 case SND_SOC_DAPM_PRE_PMU:
Benoit Cousson93e69582014-07-08 23:19:38 +02003512 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3513 ret = soc_dai_hw_params(&substream, params, source);
3514 if (ret < 0)
3515 goto out;
Mark Brownc74184e2012-04-04 22:12:09 +01003516
Benoit Cousson93e69582014-07-08 23:19:38 +02003517 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
3518 ret = soc_dai_hw_params(&substream, params, sink);
3519 if (ret < 0)
3520 goto out;
Mark Brownc74184e2012-04-04 22:12:09 +01003521 break;
3522
3523 case SND_SOC_DAPM_POST_PMU:
Mark Brownda183962013-02-06 15:44:07 +00003524 ret = snd_soc_dai_digital_mute(sink, 0,
3525 SNDRV_PCM_STREAM_PLAYBACK);
Mark Brownc74184e2012-04-04 22:12:09 +01003526 if (ret != 0 && ret != -ENOTSUPP)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003527 dev_warn(sink->dev, "ASoC: Failed to unmute: %d\n", ret);
Mark Brown9747cec2012-04-26 19:12:21 +01003528 ret = 0;
Mark Brownc74184e2012-04-04 22:12:09 +01003529 break;
3530
3531 case SND_SOC_DAPM_PRE_PMD:
Mark Brownda183962013-02-06 15:44:07 +00003532 ret = snd_soc_dai_digital_mute(sink, 1,
3533 SNDRV_PCM_STREAM_PLAYBACK);
Mark Brownc74184e2012-04-04 22:12:09 +01003534 if (ret != 0 && ret != -ENOTSUPP)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003535 dev_warn(sink->dev, "ASoC: Failed to mute: %d\n", ret);
Mark Brown9747cec2012-04-26 19:12:21 +01003536 ret = 0;
Mark Brownc74184e2012-04-04 22:12:09 +01003537 break;
3538
3539 default:
Takashi Iwaia6ed0602013-11-06 11:07:19 +01003540 WARN(1, "Unknown event %d\n", event);
Mark Brownc74184e2012-04-04 22:12:09 +01003541 return -EINVAL;
3542 }
3543
Mark Brown9747cec2012-04-26 19:12:21 +01003544out:
3545 kfree(params);
3546 return ret;
Mark Brownc74184e2012-04-04 22:12:09 +01003547}
3548
Nikesh Oswalc6615082015-02-02 17:06:44 +00003549static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
3550 struct snd_ctl_elem_value *ucontrol)
3551{
3552 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3553
3554 ucontrol->value.integer.value[0] = w->params_select;
3555
3556 return 0;
3557}
3558
3559static int snd_soc_dapm_dai_link_put(struct snd_kcontrol *kcontrol,
3560 struct snd_ctl_elem_value *ucontrol)
3561{
3562 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3563
3564 /* Can't change the config when widget is already powered */
3565 if (w->power)
3566 return -EBUSY;
3567
3568 if (ucontrol->value.integer.value[0] == w->params_select)
3569 return 0;
3570
3571 if (ucontrol->value.integer.value[0] >= w->num_params)
3572 return -EINVAL;
3573
3574 w->params_select = ucontrol->value.integer.value[0];
3575
3576 return 0;
3577}
3578
Mark Brownc74184e2012-04-04 22:12:09 +01003579int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
3580 const struct snd_soc_pcm_stream *params,
Nikesh Oswalc6615082015-02-02 17:06:44 +00003581 unsigned int num_params,
Mark Brownc74184e2012-04-04 22:12:09 +01003582 struct snd_soc_dapm_widget *source,
3583 struct snd_soc_dapm_widget *sink)
3584{
Mark Brownc74184e2012-04-04 22:12:09 +01003585 struct snd_soc_dapm_widget template;
3586 struct snd_soc_dapm_widget *w;
Mark Brownc74184e2012-04-04 22:12:09 +01003587 char *link_name;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003588 int ret, count;
3589 unsigned long private_value;
3590 const char **w_param_text;
3591 struct soc_enum w_param_enum[] = {
3592 SOC_ENUM_SINGLE(0, 0, 0, NULL),
3593 };
3594 struct snd_kcontrol_new kcontrol_dai_link[] = {
3595 SOC_ENUM_EXT(NULL, w_param_enum[0],
3596 snd_soc_dapm_dai_link_get,
3597 snd_soc_dapm_dai_link_put),
3598 };
3599 const struct snd_soc_pcm_stream *config = params;
Mark Brownc74184e2012-04-04 22:12:09 +01003600
Nikesh Oswalc6615082015-02-02 17:06:44 +00003601 w_param_text = devm_kcalloc(card->dev, num_params,
3602 sizeof(char *), GFP_KERNEL);
3603 if (!w_param_text)
Mark Brownc74184e2012-04-04 22:12:09 +01003604 return -ENOMEM;
Mark Brownc74184e2012-04-04 22:12:09 +01003605
Charles Keepax46172b62015-03-25 11:22:35 +00003606 link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
3607 source->name, sink->name);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003608 if (!link_name) {
3609 ret = -ENOMEM;
3610 goto outfree_w_param;
3611 }
Mark Brownc74184e2012-04-04 22:12:09 +01003612
Nikesh Oswalc6615082015-02-02 17:06:44 +00003613 for (count = 0 ; count < num_params; count++) {
3614 if (!config->stream_name) {
3615 dev_warn(card->dapm.dev,
3616 "ASoC: anonymous config %d for dai link %s\n",
3617 count, link_name);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003618 w_param_text[count] =
Charles Keepax46172b62015-03-25 11:22:35 +00003619 devm_kasprintf(card->dev, GFP_KERNEL,
3620 "Anonymous Configuration %d",
3621 count);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003622 if (!w_param_text[count]) {
3623 ret = -ENOMEM;
3624 goto outfree_link_name;
3625 }
Nikesh Oswalc6615082015-02-02 17:06:44 +00003626 } else {
3627 w_param_text[count] = devm_kmemdup(card->dev,
3628 config->stream_name,
3629 strlen(config->stream_name) + 1,
3630 GFP_KERNEL);
3631 if (!w_param_text[count]) {
3632 ret = -ENOMEM;
3633 goto outfree_link_name;
3634 }
3635 }
3636 config++;
3637 }
3638 w_param_enum[0].items = num_params;
3639 w_param_enum[0].texts = w_param_text;
Mark Brownc74184e2012-04-04 22:12:09 +01003640
3641 memset(&template, 0, sizeof(template));
3642 template.reg = SND_SOC_NOPM;
3643 template.id = snd_soc_dapm_dai_link;
3644 template.name = link_name;
3645 template.event = snd_soc_dai_link_event;
3646 template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
3647 SND_SOC_DAPM_PRE_PMD;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003648 template.num_kcontrols = 1;
3649 /* duplicate w_param_enum on heap so that memory persists */
3650 private_value =
3651 (unsigned long) devm_kmemdup(card->dev,
3652 (void *)(kcontrol_dai_link[0].private_value),
3653 sizeof(struct soc_enum), GFP_KERNEL);
3654 if (!private_value) {
3655 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3656 link_name);
3657 ret = -ENOMEM;
3658 goto outfree_link_name;
3659 }
3660 kcontrol_dai_link[0].private_value = private_value;
3661 /* duplicate kcontrol_dai_link on heap so that memory persists */
3662 template.kcontrol_news =
3663 devm_kmemdup(card->dev, &kcontrol_dai_link[0],
3664 sizeof(struct snd_kcontrol_new),
3665 GFP_KERNEL);
3666 if (!template.kcontrol_news) {
3667 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3668 link_name);
3669 ret = -ENOMEM;
3670 goto outfree_private_value;
3671 }
Mark Brownc74184e2012-04-04 22:12:09 +01003672
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003673 dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
Mark Brownc74184e2012-04-04 22:12:09 +01003674
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003675 w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
Mark Brownc74184e2012-04-04 22:12:09 +01003676 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003677 dev_err(card->dev, "ASoC: Failed to create %s widget\n",
Mark Brownc74184e2012-04-04 22:12:09 +01003678 link_name);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003679 ret = -ENOMEM;
3680 goto outfree_kcontrol_news;
Mark Brownc74184e2012-04-04 22:12:09 +01003681 }
3682
3683 w->params = params;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003684 w->num_params = num_params;
Mark Brownc74184e2012-04-04 22:12:09 +01003685
Lars-Peter Clausenfe838972014-05-07 16:20:27 +02003686 ret = snd_soc_dapm_add_path(&card->dapm, source, w, NULL, NULL);
3687 if (ret)
Nikesh Oswalc6615082015-02-02 17:06:44 +00003688 goto outfree_w;
Lars-Peter Clausenfe838972014-05-07 16:20:27 +02003689 return snd_soc_dapm_add_path(&card->dapm, w, sink, NULL, NULL);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003690
3691outfree_w:
3692 devm_kfree(card->dev, w);
3693outfree_kcontrol_news:
3694 devm_kfree(card->dev, (void *)template.kcontrol_news);
3695outfree_private_value:
3696 devm_kfree(card->dev, (void *)private_value);
3697outfree_link_name:
3698 devm_kfree(card->dev, link_name);
3699outfree_w_param:
3700 for (count = 0 ; count < num_params; count++)
3701 devm_kfree(card->dev, (void *)w_param_text[count]);
3702 devm_kfree(card->dev, w_param_text);
3703
3704 return ret;
Mark Brownc74184e2012-04-04 22:12:09 +01003705}
3706
Mark Brown888df392012-02-16 19:37:51 -08003707int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
3708 struct snd_soc_dai *dai)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003709{
Mark Brown888df392012-02-16 19:37:51 -08003710 struct snd_soc_dapm_widget template;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003711 struct snd_soc_dapm_widget *w;
3712
Mark Brown888df392012-02-16 19:37:51 -08003713 WARN_ON(dapm->dev != dai->dev);
3714
3715 memset(&template, 0, sizeof(template));
3716 template.reg = SND_SOC_NOPM;
3717
3718 if (dai->driver->playback.stream_name) {
Mark Brown46162742013-06-05 19:36:11 +01003719 template.id = snd_soc_dapm_dai_in;
Mark Brown888df392012-02-16 19:37:51 -08003720 template.name = dai->driver->playback.stream_name;
3721 template.sname = dai->driver->playback.stream_name;
3722
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003723 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003724 template.name);
3725
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003726 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
Mark Brown888df392012-02-16 19:37:51 -08003727 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003728 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003729 dai->driver->playback.stream_name);
Takashi Iwai298402a2013-10-28 14:21:50 +01003730 return -ENOMEM;
Mark Brown888df392012-02-16 19:37:51 -08003731 }
3732
3733 w->priv = dai;
3734 dai->playback_widget = w;
3735 }
3736
3737 if (dai->driver->capture.stream_name) {
Mark Brown46162742013-06-05 19:36:11 +01003738 template.id = snd_soc_dapm_dai_out;
Mark Brown888df392012-02-16 19:37:51 -08003739 template.name = dai->driver->capture.stream_name;
3740 template.sname = dai->driver->capture.stream_name;
3741
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003742 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003743 template.name);
3744
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003745 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
Mark Brown888df392012-02-16 19:37:51 -08003746 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003747 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003748 dai->driver->capture.stream_name);
Takashi Iwai298402a2013-10-28 14:21:50 +01003749 return -ENOMEM;
Mark Brown888df392012-02-16 19:37:51 -08003750 }
3751
3752 w->priv = dai;
3753 dai->capture_widget = w;
3754 }
3755
3756 return 0;
3757}
3758
3759int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
3760{
3761 struct snd_soc_dapm_widget *dai_w, *w;
Lars-Peter Clausen0f9bd7b2014-05-07 16:20:28 +02003762 struct snd_soc_dapm_widget *src, *sink;
Mark Brown888df392012-02-16 19:37:51 -08003763 struct snd_soc_dai *dai;
Mark Brown888df392012-02-16 19:37:51 -08003764
3765 /* For each DAI widget... */
3766 list_for_each_entry(dai_w, &card->widgets, list) {
Mark Brown46162742013-06-05 19:36:11 +01003767 switch (dai_w->id) {
3768 case snd_soc_dapm_dai_in:
3769 case snd_soc_dapm_dai_out:
3770 break;
3771 default:
Richard Purdie2b97eab2006-10-06 18:32:18 +02003772 continue;
Mark Brown46162742013-06-05 19:36:11 +01003773 }
Mark Brown888df392012-02-16 19:37:51 -08003774
3775 dai = dai_w->priv;
3776
3777 /* ...find all widgets with the same stream and link them */
3778 list_for_each_entry(w, &card->widgets, list) {
3779 if (w->dapm != dai_w->dapm)
3780 continue;
3781
Mark Brown46162742013-06-05 19:36:11 +01003782 switch (w->id) {
3783 case snd_soc_dapm_dai_in:
3784 case snd_soc_dapm_dai_out:
Mark Brown888df392012-02-16 19:37:51 -08003785 continue;
Mark Brown46162742013-06-05 19:36:11 +01003786 default:
3787 break;
3788 }
Mark Brown888df392012-02-16 19:37:51 -08003789
Russell King19c2c5f2013-08-04 20:24:03 +01003790 if (!w->sname || !strstr(w->sname, dai_w->name))
Mark Brown888df392012-02-16 19:37:51 -08003791 continue;
3792
Lars-Peter Clausen0f9bd7b2014-05-07 16:20:28 +02003793 if (dai_w->id == snd_soc_dapm_dai_in) {
3794 src = dai_w;
3795 sink = w;
3796 } else {
3797 src = w;
3798 sink = dai_w;
Mark Brown888df392012-02-16 19:37:51 -08003799 }
Lars-Peter Clausen0f9bd7b2014-05-07 16:20:28 +02003800 dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
3801 snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003802 }
3803 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02003804
Mark Brown888df392012-02-16 19:37:51 -08003805 return 0;
3806}
Liam Girdwood64a648c2011-07-25 11:15:15 +01003807
Benoit Cousson44ba2642014-07-08 23:19:36 +02003808static void dapm_connect_dai_link_widgets(struct snd_soc_card *card,
3809 struct snd_soc_pcm_runtime *rtd)
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003810{
Benoit Cousson44ba2642014-07-08 23:19:36 +02003811 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003812 struct snd_soc_dapm_widget *sink, *source;
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003813 int i;
3814
Benoit Cousson44ba2642014-07-08 23:19:36 +02003815 for (i = 0; i < rtd->num_codecs; i++) {
3816 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003817
3818 /* there is no point in connecting BE DAI links with dummies */
3819 if (snd_soc_dai_is_dummy(codec_dai) ||
3820 snd_soc_dai_is_dummy(cpu_dai))
3821 continue;
3822
3823 /* connect BE DAI playback if widgets are valid */
3824 if (codec_dai->playback_widget && cpu_dai->playback_widget) {
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003825 source = cpu_dai->playback_widget;
3826 sink = codec_dai->playback_widget;
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003827 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003828 cpu_dai->component->name, source->name,
3829 codec_dai->component->name, sink->name);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003830
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003831 snd_soc_dapm_add_path(&card->dapm, source, sink,
3832 NULL, NULL);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003833 }
3834
3835 /* connect BE DAI capture if widgets are valid */
3836 if (codec_dai->capture_widget && cpu_dai->capture_widget) {
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003837 source = codec_dai->capture_widget;
3838 sink = cpu_dai->capture_widget;
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003839 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003840 codec_dai->component->name, source->name,
3841 cpu_dai->component->name, sink->name);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003842
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003843 snd_soc_dapm_add_path(&card->dapm, source, sink,
3844 NULL, NULL);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003845 }
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003846 }
3847}
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003848
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003849static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
3850 int event)
3851{
3852 struct snd_soc_dapm_widget *w;
3853
3854 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
3855 w = dai->playback_widget;
3856 else
3857 w = dai->capture_widget;
3858
3859 if (w) {
3860 dapm_mark_dirty(w, "stream event");
3861
3862 switch (event) {
3863 case SND_SOC_DAPM_STREAM_START:
3864 w->active = 1;
3865 break;
3866 case SND_SOC_DAPM_STREAM_STOP:
3867 w->active = 0;
3868 break;
3869 case SND_SOC_DAPM_STREAM_SUSPEND:
3870 case SND_SOC_DAPM_STREAM_RESUME:
3871 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
3872 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
3873 break;
3874 }
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003875
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02003876 if (w->id == snd_soc_dapm_dai_in) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003877 w->is_source = w->active;
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02003878 dapm_widget_invalidate_input_paths(w);
3879 } else {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003880 w->is_sink = w->active;
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02003881 dapm_widget_invalidate_output_paths(w);
3882 }
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003883 }
3884}
3885
Benoit Cousson44ba2642014-07-08 23:19:36 +02003886void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
3887{
3888 struct snd_soc_pcm_runtime *rtd = card->rtd;
3889 int i;
3890
3891 /* for each BE DAI link... */
3892 for (i = 0; i < card->num_rtd; i++) {
3893 rtd = &card->rtd[i];
3894
3895 /*
3896 * dynamic FE links have no fixed DAI mapping.
3897 * CODEC<->CODEC links have no direct connection.
3898 */
3899 if (rtd->dai_link->dynamic || rtd->dai_link->params)
3900 continue;
3901
3902 dapm_connect_dai_link_widgets(card, rtd);
3903 }
3904}
3905
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003906static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3907 int event)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003908{
Benoit Cousson44ba2642014-07-08 23:19:36 +02003909 int i;
3910
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003911 soc_dapm_dai_stream_event(rtd->cpu_dai, stream, event);
Benoit Cousson44ba2642014-07-08 23:19:36 +02003912 for (i = 0; i < rtd->num_codecs; i++)
3913 soc_dapm_dai_stream_event(rtd->codec_dais[i], stream, event);
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003914
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02003915 dapm_power_widgets(rtd->card, event);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003916}
3917
3918/**
3919 * snd_soc_dapm_stream_event - send a stream event to the dapm core
3920 * @rtd: PCM runtime data
3921 * @stream: stream name
3922 * @event: stream event
3923 *
3924 * Sends a stream event to the dapm core. The core then makes any
3925 * necessary widget power changes.
3926 *
3927 * Returns 0 for success else error.
3928 */
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003929void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3930 int event)
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003931{
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003932 struct snd_soc_card *card = rtd->card;
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003933
Liam Girdwood3cd04342012-03-09 12:02:08 +00003934 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003935 soc_dapm_stream_event(rtd, stream, event);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003936 mutex_unlock(&card->dapm_mutex);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003937}
Richard Purdie2b97eab2006-10-06 18:32:18 +02003938
3939/**
Charles Keepax11391102014-02-18 15:22:14 +00003940 * snd_soc_dapm_enable_pin_unlocked - enable pin.
3941 * @dapm: DAPM context
3942 * @pin: pin name
3943 *
3944 * Enables input/output pin and its parents or children widgets iff there is
3945 * a valid audio route and active audio stream.
3946 *
3947 * Requires external locking.
3948 *
3949 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3950 * do any widget power switching.
3951 */
3952int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
3953 const char *pin)
3954{
3955 return snd_soc_dapm_set_pin(dapm, pin, 1);
3956}
3957EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
3958
3959/**
Liam Girdwooda5302182008-07-07 13:35:17 +01003960 * snd_soc_dapm_enable_pin - enable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003961 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01003962 * @pin: pin name
Richard Purdie2b97eab2006-10-06 18:32:18 +02003963 *
Mark Brown74b8f952009-06-06 11:26:15 +01003964 * Enables input/output pin and its parents or children widgets iff there is
Liam Girdwooda5302182008-07-07 13:35:17 +01003965 * a valid audio route and active audio stream.
Charles Keepax11391102014-02-18 15:22:14 +00003966 *
Liam Girdwooda5302182008-07-07 13:35:17 +01003967 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3968 * do any widget power switching.
Richard Purdie2b97eab2006-10-06 18:32:18 +02003969 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003970int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003971{
Charles Keepax11391102014-02-18 15:22:14 +00003972 int ret;
3973
3974 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3975
3976 ret = snd_soc_dapm_set_pin(dapm, pin, 1);
3977
3978 mutex_unlock(&dapm->card->dapm_mutex);
3979
3980 return ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003981}
Liam Girdwooda5302182008-07-07 13:35:17 +01003982EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003983
3984/**
Charles Keepax11391102014-02-18 15:22:14 +00003985 * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
3986 * @dapm: DAPM context
3987 * @pin: pin name
3988 *
3989 * Enables input/output pin regardless of any other state. This is
3990 * intended for use with microphone bias supplies used in microphone
3991 * jack detection.
3992 *
3993 * Requires external locking.
3994 *
3995 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3996 * do any widget power switching.
3997 */
3998int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
3999 const char *pin)
4000{
4001 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4002
4003 if (!w) {
4004 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4005 return -EINVAL;
4006 }
4007
4008 dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02004009 if (!w->connected) {
4010 /*
4011 * w->force does not affect the number of input or output paths,
4012 * so we only have to recheck if w->connected is changed
4013 */
4014 dapm_widget_invalidate_input_paths(w);
4015 dapm_widget_invalidate_output_paths(w);
4016 w->connected = 1;
4017 }
Charles Keepax11391102014-02-18 15:22:14 +00004018 w->force = 1;
4019 dapm_mark_dirty(w, "force enable");
4020
4021 return 0;
4022}
4023EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
4024
4025/**
Mark Brownda341832010-03-15 19:23:37 +00004026 * snd_soc_dapm_force_enable_pin - force a pin to be enabled
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004027 * @dapm: DAPM context
Mark Brownda341832010-03-15 19:23:37 +00004028 * @pin: pin name
4029 *
4030 * Enables input/output pin regardless of any other state. This is
4031 * intended for use with microphone bias supplies used in microphone
4032 * jack detection.
4033 *
4034 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4035 * do any widget power switching.
4036 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004037int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
4038 const char *pin)
Mark Brownda341832010-03-15 19:23:37 +00004039{
Charles Keepax11391102014-02-18 15:22:14 +00004040 int ret;
Mark Brownda341832010-03-15 19:23:37 +00004041
Charles Keepax11391102014-02-18 15:22:14 +00004042 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Mark Brownda341832010-03-15 19:23:37 +00004043
Charles Keepax11391102014-02-18 15:22:14 +00004044 ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
Mark Brown0d867332011-04-06 11:38:14 +09004045
Charles Keepax11391102014-02-18 15:22:14 +00004046 mutex_unlock(&dapm->card->dapm_mutex);
4047
4048 return ret;
Mark Brownda341832010-03-15 19:23:37 +00004049}
4050EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
4051
4052/**
Charles Keepax11391102014-02-18 15:22:14 +00004053 * snd_soc_dapm_disable_pin_unlocked - disable pin.
4054 * @dapm: DAPM context
4055 * @pin: pin name
4056 *
4057 * Disables input/output pin and its parents or children widgets.
4058 *
4059 * Requires external locking.
4060 *
4061 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4062 * do any widget power switching.
4063 */
4064int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4065 const char *pin)
4066{
4067 return snd_soc_dapm_set_pin(dapm, pin, 0);
4068}
4069EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
4070
4071/**
Liam Girdwooda5302182008-07-07 13:35:17 +01004072 * snd_soc_dapm_disable_pin - disable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004073 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01004074 * @pin: pin name
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004075 *
Mark Brown74b8f952009-06-06 11:26:15 +01004076 * Disables input/output pin and its parents or children widgets.
Charles Keepax11391102014-02-18 15:22:14 +00004077 *
Liam Girdwooda5302182008-07-07 13:35:17 +01004078 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4079 * do any widget power switching.
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004080 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004081int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
4082 const char *pin)
Liam Girdwooda5302182008-07-07 13:35:17 +01004083{
Charles Keepax11391102014-02-18 15:22:14 +00004084 int ret;
4085
4086 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4087
4088 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4089
4090 mutex_unlock(&dapm->card->dapm_mutex);
4091
4092 return ret;
Liam Girdwooda5302182008-07-07 13:35:17 +01004093}
4094EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
4095
4096/**
Charles Keepax11391102014-02-18 15:22:14 +00004097 * snd_soc_dapm_nc_pin_unlocked - permanently disable pin.
4098 * @dapm: DAPM context
4099 * @pin: pin name
4100 *
4101 * Marks the specified pin as being not connected, disabling it along
4102 * any parent or child widgets. At present this is identical to
4103 * snd_soc_dapm_disable_pin() but in future it will be extended to do
4104 * additional things such as disabling controls which only affect
4105 * paths through the pin.
4106 *
4107 * Requires external locking.
4108 *
4109 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4110 * do any widget power switching.
4111 */
4112int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
4113 const char *pin)
4114{
4115 return snd_soc_dapm_set_pin(dapm, pin, 0);
4116}
4117EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
4118
4119/**
Mark Brown5817b522008-09-24 11:23:11 +01004120 * snd_soc_dapm_nc_pin - permanently disable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004121 * @dapm: DAPM context
Mark Brown5817b522008-09-24 11:23:11 +01004122 * @pin: pin name
4123 *
4124 * Marks the specified pin as being not connected, disabling it along
4125 * any parent or child widgets. At present this is identical to
4126 * snd_soc_dapm_disable_pin() but in future it will be extended to do
4127 * additional things such as disabling controls which only affect
4128 * paths through the pin.
4129 *
4130 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4131 * do any widget power switching.
4132 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004133int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
Mark Brown5817b522008-09-24 11:23:11 +01004134{
Charles Keepax11391102014-02-18 15:22:14 +00004135 int ret;
4136
4137 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4138
4139 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4140
4141 mutex_unlock(&dapm->card->dapm_mutex);
4142
4143 return ret;
Mark Brown5817b522008-09-24 11:23:11 +01004144}
4145EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
4146
4147/**
Liam Girdwooda5302182008-07-07 13:35:17 +01004148 * snd_soc_dapm_get_pin_status - get audio pin status
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004149 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01004150 * @pin: audio signal pin endpoint (or start point)
4151 *
4152 * Get audio pin status - connected or disconnected.
4153 *
4154 * Returns 1 for connected otherwise 0.
4155 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004156int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
4157 const char *pin)
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004158{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004159 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004160
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004161 if (w)
4162 return w->connected;
Stephen Warrena68b38a2011-04-19 15:25:11 -06004163
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004164 return 0;
4165}
Liam Girdwooda5302182008-07-07 13:35:17 +01004166EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004167
4168/**
Mark Brown1547aba2010-05-07 21:11:40 +01004169 * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004170 * @dapm: DAPM context
Mark Brown1547aba2010-05-07 21:11:40 +01004171 * @pin: audio signal pin endpoint (or start point)
4172 *
4173 * Mark the given endpoint or pin as ignoring suspend. When the
4174 * system is disabled a path between two endpoints flagged as ignoring
4175 * suspend will not be disabled. The path must already be enabled via
4176 * normal means at suspend time, it will not be turned on if it was not
4177 * already enabled.
4178 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004179int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
4180 const char *pin)
Mark Brown1547aba2010-05-07 21:11:40 +01004181{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004182 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
Mark Brown1547aba2010-05-07 21:11:40 +01004183
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004184 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00004185 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004186 return -EINVAL;
Mark Brown1547aba2010-05-07 21:11:40 +01004187 }
4188
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004189 w->ignore_suspend = 1;
4190
4191 return 0;
Mark Brown1547aba2010-05-07 21:11:40 +01004192}
4193EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
4194
Lars-Peter Clausencdc45082014-10-20 19:36:33 +02004195/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02004196 * snd_soc_dapm_free - free dapm resources
Peter Ujfalusi728a5222011-08-26 16:33:52 +03004197 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02004198 *
4199 * Free all dapm widgets and resources.
4200 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004201void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02004202{
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02004203 dapm_debugfs_cleanup(dapm);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004204 dapm_free_widgets(dapm);
Jarkko Nikula7be31be82010-12-14 12:18:32 +02004205 list_del(&dapm->list);
Richard Purdie2b97eab2006-10-06 18:32:18 +02004206}
4207EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
4208
Xiang Xiao57996352014-03-02 00:04:02 +08004209static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
Mark Brown51737472009-06-22 13:16:51 +01004210{
Liam Girdwood01005a72012-07-06 16:57:05 +01004211 struct snd_soc_card *card = dapm->card;
Mark Brown51737472009-06-22 13:16:51 +01004212 struct snd_soc_dapm_widget *w;
4213 LIST_HEAD(down_list);
4214 int powerdown = 0;
4215
Liam Girdwood01005a72012-07-06 16:57:05 +01004216 mutex_lock(&card->dapm_mutex);
4217
Jarkko Nikula97c866d2010-12-14 12:18:31 +02004218 list_for_each_entry(w, &dapm->card->widgets, list) {
4219 if (w->dapm != dapm)
4220 continue;
Mark Brown51737472009-06-22 13:16:51 +01004221 if (w->power) {
Mark Brown828a8422011-01-15 13:14:30 +00004222 dapm_seq_insert(w, &down_list, false);
Mark Brownc2caa4d2009-06-26 15:36:56 +01004223 w->power = 0;
Mark Brown51737472009-06-22 13:16:51 +01004224 powerdown = 1;
4225 }
4226 }
4227
4228 /* If there were no widgets to power down we're already in
4229 * standby.
4230 */
4231 if (powerdown) {
Mark Brown7679e422012-02-22 15:52:56 +00004232 if (dapm->bias_level == SND_SOC_BIAS_ON)
4233 snd_soc_dapm_set_bias_level(dapm,
4234 SND_SOC_BIAS_PREPARE);
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02004235 dapm_seq_run(card, &down_list, 0, false);
Mark Brown7679e422012-02-22 15:52:56 +00004236 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
4237 snd_soc_dapm_set_bias_level(dapm,
4238 SND_SOC_BIAS_STANDBY);
Mark Brown51737472009-06-22 13:16:51 +01004239 }
Liam Girdwood01005a72012-07-06 16:57:05 +01004240
4241 mutex_unlock(&card->dapm_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00004242}
Mark Brown51737472009-06-22 13:16:51 +01004243
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00004244/*
4245 * snd_soc_dapm_shutdown - callback for system shutdown
4246 */
4247void snd_soc_dapm_shutdown(struct snd_soc_card *card)
4248{
Xiang Xiao57996352014-03-02 00:04:02 +08004249 struct snd_soc_dapm_context *dapm;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00004250
Xiang Xiao57996352014-03-02 00:04:02 +08004251 list_for_each_entry(dapm, &card->dapm_list, list) {
Xiang Xiao17282ba2014-03-02 00:04:03 +08004252 if (dapm != &card->dapm) {
4253 soc_dapm_shutdown_dapm(dapm);
4254 if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
4255 snd_soc_dapm_set_bias_level(dapm,
4256 SND_SOC_BIAS_OFF);
4257 }
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004258 }
Xiang Xiao17282ba2014-03-02 00:04:03 +08004259
4260 soc_dapm_shutdown_dapm(&card->dapm);
4261 if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
4262 snd_soc_dapm_set_bias_level(&card->dapm,
4263 SND_SOC_BIAS_OFF);
Mark Brown51737472009-06-22 13:16:51 +01004264}
4265
Richard Purdie2b97eab2006-10-06 18:32:18 +02004266/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01004267MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Richard Purdie2b97eab2006-10-06 18:32:18 +02004268MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
4269MODULE_LICENSE("GPL");