blob: f132f97a682a46779971bb7011dffcbb57c6e72c [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 Clausena3423b02015-08-11 21:38:00 +020050#define SND_SOC_DAPM_DIR_REVERSE(x) ((x == SND_SOC_DAPM_DIR_IN) ? \
51 SND_SOC_DAPM_DIR_OUT : SND_SOC_DAPM_DIR_IN)
52
53#define snd_soc_dapm_for_each_direction(dir) \
54 for ((dir) = SND_SOC_DAPM_DIR_IN; (dir) <= SND_SOC_DAPM_DIR_OUT; \
55 (dir)++)
56
Lars-Peter Clausen57295072013-08-05 11:27:31 +020057static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
58 struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
59 const char *control,
60 int (*connected)(struct snd_soc_dapm_widget *source,
61 struct snd_soc_dapm_widget *sink));
Vladimir Zapolskiy5353f652015-06-02 00:57:53 +030062
Liam Girdwoodcc76e7d2015-06-04 15:13:09 +010063struct snd_soc_dapm_widget *
Lars-Peter Clausen57295072013-08-05 11:27:31 +020064snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
65 const struct snd_soc_dapm_widget *widget);
66
Liam Girdwood02aa78a2015-05-25 18:21:17 +010067struct snd_soc_dapm_widget *
68snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
Richard Purdie2b97eab2006-10-06 18:32:18 +020069 const struct snd_soc_dapm_widget *widget);
70
Richard Purdie2b97eab2006-10-06 18:32:18 +020071/* dapm power sequences - make this per codec in the future */
72static int dapm_up_seq[] = {
Mark Brown38357ab2009-06-06 19:03:23 +010073 [snd_soc_dapm_pre] = 0,
Mark Brown62ea8742012-01-21 21:14:48 +000074 [snd_soc_dapm_regulator_supply] = 1,
Ola Liljad7e7eb92012-05-24 15:26:25 +020075 [snd_soc_dapm_clock_supply] = 1,
Mark Brown1dd275b2013-10-09 13:56:37 +010076 [snd_soc_dapm_supply] = 2,
77 [snd_soc_dapm_micbias] = 3,
Mark Brownc74184e2012-04-04 22:12:09 +010078 [snd_soc_dapm_dai_link] = 2,
Mark Brown1dd275b2013-10-09 13:56:37 +010079 [snd_soc_dapm_dai_in] = 4,
80 [snd_soc_dapm_dai_out] = 4,
81 [snd_soc_dapm_aif_in] = 4,
82 [snd_soc_dapm_aif_out] = 4,
83 [snd_soc_dapm_mic] = 5,
84 [snd_soc_dapm_mux] = 6,
Lars-Peter Clausend714f972015-05-01 18:02:43 +020085 [snd_soc_dapm_demux] = 6,
Mark Brown1dd275b2013-10-09 13:56:37 +010086 [snd_soc_dapm_dac] = 7,
87 [snd_soc_dapm_switch] = 8,
88 [snd_soc_dapm_mixer] = 8,
89 [snd_soc_dapm_mixer_named_ctl] = 8,
90 [snd_soc_dapm_pga] = 9,
91 [snd_soc_dapm_adc] = 10,
92 [snd_soc_dapm_out_drv] = 11,
93 [snd_soc_dapm_hp] = 11,
94 [snd_soc_dapm_spk] = 11,
95 [snd_soc_dapm_line] = 11,
96 [snd_soc_dapm_kcontrol] = 12,
97 [snd_soc_dapm_post] = 13,
Richard Purdie2b97eab2006-10-06 18:32:18 +020098};
Ian Moltonca9c1aa2009-01-06 20:11:51 +000099
Richard Purdie2b97eab2006-10-06 18:32:18 +0200100static int dapm_down_seq[] = {
Mark Brown38357ab2009-06-06 19:03:23 +0100101 [snd_soc_dapm_pre] = 0,
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200102 [snd_soc_dapm_kcontrol] = 1,
103 [snd_soc_dapm_adc] = 2,
104 [snd_soc_dapm_hp] = 3,
105 [snd_soc_dapm_spk] = 3,
106 [snd_soc_dapm_line] = 3,
107 [snd_soc_dapm_out_drv] = 3,
Mark Brown38357ab2009-06-06 19:03:23 +0100108 [snd_soc_dapm_pga] = 4,
Lars-Peter Clausenefc77e32013-06-14 13:16:50 +0200109 [snd_soc_dapm_switch] = 5,
Mark Brown38357ab2009-06-06 19:03:23 +0100110 [snd_soc_dapm_mixer_named_ctl] = 5,
Mark Browne3d4dab2009-06-07 13:08:45 +0100111 [snd_soc_dapm_mixer] = 5,
112 [snd_soc_dapm_dac] = 6,
113 [snd_soc_dapm_mic] = 7,
114 [snd_soc_dapm_micbias] = 8,
115 [snd_soc_dapm_mux] = 9,
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200116 [snd_soc_dapm_demux] = 9,
Mark Brown010ff262009-08-17 17:39:22 +0100117 [snd_soc_dapm_aif_in] = 10,
118 [snd_soc_dapm_aif_out] = 10,
Mark Brown46162742013-06-05 19:36:11 +0100119 [snd_soc_dapm_dai_in] = 10,
120 [snd_soc_dapm_dai_out] = 10,
Mark Brownc74184e2012-04-04 22:12:09 +0100121 [snd_soc_dapm_dai_link] = 11,
Mark Brownc74184e2012-04-04 22:12:09 +0100122 [snd_soc_dapm_supply] = 12,
Mark Brown1dd275b2013-10-09 13:56:37 +0100123 [snd_soc_dapm_clock_supply] = 13,
124 [snd_soc_dapm_regulator_supply] = 13,
125 [snd_soc_dapm_post] = 14,
Richard Purdie2b97eab2006-10-06 18:32:18 +0200126};
127
Mark Brownf9fa2b12014-03-06 16:49:11 +0800128static void dapm_assert_locked(struct snd_soc_dapm_context *dapm)
129{
130 if (dapm->card && dapm->card->instantiated)
131 lockdep_assert_held(&dapm->card->dapm_mutex);
132}
133
Troy Kisky12ef1932008-10-13 17:42:14 -0700134static void pop_wait(u32 pop_time)
Mark Brown15e4c722008-07-02 11:51:20 +0100135{
136 if (pop_time)
137 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
138}
139
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200140static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
Mark Brown15e4c722008-07-02 11:51:20 +0100141{
142 va_list args;
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200143 char *buf;
144
145 if (!pop_time)
146 return;
147
148 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
149 if (buf == NULL)
150 return;
Mark Brown15e4c722008-07-02 11:51:20 +0100151
152 va_start(args, fmt);
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200153 vsnprintf(buf, PAGE_SIZE, fmt, args);
Takashi Iwai9d01df02010-12-22 14:08:40 +0100154 dev_info(dev, "%s", buf);
Mark Brown15e4c722008-07-02 11:51:20 +0100155 va_end(args);
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200156
157 kfree(buf);
Mark Brown15e4c722008-07-02 11:51:20 +0100158}
159
Mark Browndb432b42011-10-03 21:06:40 +0100160static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
161{
162 return !list_empty(&w->dirty);
163}
164
Mark Brown492c0a12014-03-06 16:15:48 +0800165static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
Mark Browndb432b42011-10-03 21:06:40 +0100166{
Mark Brownf9fa2b12014-03-06 16:49:11 +0800167 dapm_assert_locked(w->dapm);
168
Mark Brown75c1f892011-10-04 22:28:08 +0100169 if (!dapm_dirty_widget(w)) {
170 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
171 w->name, reason);
Mark Browndb432b42011-10-03 21:06:40 +0100172 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
Mark Brown75c1f892011-10-04 22:28:08 +0100173 }
Mark Browndb432b42011-10-03 21:06:40 +0100174}
175
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200176/*
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200177 * Common implementation for dapm_widget_invalidate_input_paths() and
178 * dapm_widget_invalidate_output_paths(). The function is inlined since the
179 * combined size of the two specialized functions is only marginally larger then
180 * the size of the generic function and at the same time the fast path of the
181 * specialized functions is significantly smaller than the generic function.
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200182 */
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200183static __always_inline void dapm_widget_invalidate_paths(
184 struct snd_soc_dapm_widget *w, enum snd_soc_dapm_direction dir)
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200185{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200186 enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
187 struct snd_soc_dapm_widget *node;
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200188 struct snd_soc_dapm_path *p;
189 LIST_HEAD(list);
190
191 dapm_assert_locked(w->dapm);
192
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200193 if (w->endpoints[dir] == -1)
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200194 return;
195
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200196 list_add_tail(&w->work_list, &list);
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200197 w->endpoints[dir] = -1;
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200198
199 list_for_each_entry(w, &list, work_list) {
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200200 snd_soc_dapm_widget_for_each_path(w, dir, p) {
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200201 if (p->is_supply || p->weak || !p->connect)
202 continue;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200203 node = p->node[rdir];
204 if (node->endpoints[dir] != -1) {
205 node->endpoints[dir] = -1;
206 list_add_tail(&node->work_list, &list);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200207 }
208 }
209 }
210}
211
212/*
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200213 * dapm_widget_invalidate_input_paths() - Invalidate the cached number of
214 * input paths
215 * @w: The widget for which to invalidate the cached number of input paths
216 *
217 * Resets the cached number of inputs for the specified widget and all widgets
218 * that can be reached via outcoming paths from the widget.
219 *
220 * This function must be called if the number of output paths for a widget might
221 * have changed. E.g. if the source state of a widget changes or a path is added
222 * or activated with the widget as the sink.
223 */
224static void dapm_widget_invalidate_input_paths(struct snd_soc_dapm_widget *w)
225{
226 dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_IN);
227}
228
229/*
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200230 * dapm_widget_invalidate_output_paths() - Invalidate the cached number of
231 * output paths
232 * @w: The widget for which to invalidate the cached number of output paths
233 *
234 * Resets the cached number of outputs for the specified widget and all widgets
235 * that can be reached via incoming paths from the widget.
236 *
237 * This function must be called if the number of output paths for a widget might
238 * have changed. E.g. if the sink state of a widget changes or a path is added
239 * or activated with the widget as the source.
240 */
241static void dapm_widget_invalidate_output_paths(struct snd_soc_dapm_widget *w)
242{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200243 dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_OUT);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200244}
245
246/*
247 * dapm_path_invalidate() - Invalidates the cached number of inputs and outputs
248 * for the widgets connected to a path
249 * @p: The path to invalidate
250 *
251 * Resets the cached number of inputs for the sink of the path and the cached
252 * number of outputs for the source of the path.
253 *
254 * This function must be called when a path is added, removed or the connected
255 * state changes.
256 */
257static void dapm_path_invalidate(struct snd_soc_dapm_path *p)
258{
259 /*
260 * Weak paths or supply paths do not influence the number of input or
261 * output paths of their neighbors.
262 */
263 if (p->weak || p->is_supply)
264 return;
265
266 /*
267 * The number of connected endpoints is the sum of the number of
268 * connected endpoints of all neighbors. If a node with 0 connected
269 * endpoints is either connected or disconnected that sum won't change,
270 * so there is no need to re-check the path.
271 */
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200272 if (p->source->endpoints[SND_SOC_DAPM_DIR_IN] != 0)
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200273 dapm_widget_invalidate_input_paths(p->sink);
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200274 if (p->sink->endpoints[SND_SOC_DAPM_DIR_OUT] != 0)
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200275 dapm_widget_invalidate_output_paths(p->source);
276}
277
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200278void dapm_mark_endpoints_dirty(struct snd_soc_card *card)
Mark Browne2d32ff2012-08-31 17:38:32 -0700279{
Mark Browne2d32ff2012-08-31 17:38:32 -0700280 struct snd_soc_dapm_widget *w;
281
282 mutex_lock(&card->dapm_mutex);
283
284 list_for_each_entry(w, &card->widgets, list) {
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200285 if (w->is_ep) {
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200286 dapm_mark_dirty(w, "Rechecking endpoints");
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200287 if (w->is_ep & SND_SOC_DAPM_EP_SINK)
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200288 dapm_widget_invalidate_output_paths(w);
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200289 if (w->is_ep & SND_SOC_DAPM_EP_SOURCE)
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +0200290 dapm_widget_invalidate_input_paths(w);
291 }
Mark Browne2d32ff2012-08-31 17:38:32 -0700292 }
293
294 mutex_unlock(&card->dapm_mutex);
295}
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200296EXPORT_SYMBOL_GPL(dapm_mark_endpoints_dirty);
Mark Browne2d32ff2012-08-31 17:38:32 -0700297
Richard Purdie2b97eab2006-10-06 18:32:18 +0200298/* create a new dapm widget */
Takashi Iwai88cb4292007-02-05 14:56:20 +0100299static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
Richard Purdie2b97eab2006-10-06 18:32:18 +0200300 const struct snd_soc_dapm_widget *_widget)
301{
Takashi Iwai88cb4292007-02-05 14:56:20 +0100302 return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200303}
304
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200305struct dapm_kcontrol_data {
Lars-Peter Clausencf7c1de2013-07-29 17:13:59 +0200306 unsigned int value;
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200307 struct snd_soc_dapm_widget *widget;
Lars-Peter Clausen5106b922013-07-29 17:14:00 +0200308 struct list_head paths;
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200309 struct snd_soc_dapm_widget_list *wlist;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200310};
311
312static int dapm_kcontrol_data_alloc(struct snd_soc_dapm_widget *widget,
Lars-Peter Clausen41d80022016-02-03 21:59:50 +0100313 struct snd_kcontrol *kcontrol, const char *ctrl_name)
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200314{
315 struct dapm_kcontrol_data *data;
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200316 struct soc_mixer_control *mc;
Charles Keepax561ed682015-05-01 12:37:26 +0100317 struct soc_enum *e;
Charles Keepax773da9b2015-05-01 12:37:25 +0100318 const char *name;
319 int ret;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200320
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200321 data = kzalloc(sizeof(*data), GFP_KERNEL);
Charles Keepax40b7bea2015-05-01 12:37:24 +0100322 if (!data)
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200323 return -ENOMEM;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200324
Lars-Peter Clausen5106b922013-07-29 17:14:00 +0200325 INIT_LIST_HEAD(&data->paths);
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200326
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200327 switch (widget->id) {
328 case snd_soc_dapm_switch:
329 case snd_soc_dapm_mixer:
330 case snd_soc_dapm_mixer_named_ctl:
331 mc = (struct soc_mixer_control *)kcontrol->private_value;
332
333 if (mc->autodisable) {
334 struct snd_soc_dapm_widget template;
335
Lars-Peter Clausen41d80022016-02-03 21:59:50 +0100336 name = kasprintf(GFP_KERNEL, "%s %s", ctrl_name,
Charles Keepax773da9b2015-05-01 12:37:25 +0100337 "Autodisable");
338 if (!name) {
339 ret = -ENOMEM;
340 goto err_data;
341 }
342
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200343 memset(&template, 0, sizeof(template));
344 template.reg = mc->reg;
345 template.mask = (1 << fls(mc->max)) - 1;
346 template.shift = mc->shift;
347 if (mc->invert)
348 template.off_val = mc->max;
349 else
350 template.off_val = 0;
351 template.on_val = template.off_val;
352 template.id = snd_soc_dapm_kcontrol;
Charles Keepax773da9b2015-05-01 12:37:25 +0100353 template.name = name;
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200354
Lars-Peter Clausen2daabd72013-08-30 17:39:33 +0200355 data->value = template.on_val;
356
Liam Girdwood02aa78a2015-05-25 18:21:17 +0100357 data->widget =
358 snd_soc_dapm_new_control_unlocked(widget->dapm,
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200359 &template);
Lars-Peter Clausene18077b2015-07-08 21:59:59 +0200360 kfree(name);
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200361 if (!data->widget) {
Charles Keepax773da9b2015-05-01 12:37:25 +0100362 ret = -ENOMEM;
Lars-Peter Clausene18077b2015-07-08 21:59:59 +0200363 goto err_data;
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
Lars-Peter Clausen41d80022016-02-03 21:59:50 +0100374 name = kasprintf(GFP_KERNEL, "%s %s", ctrl_name,
Charles Keepax561ed682015-05-01 12:37:26 +0100375 "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;
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200389
390 data->value = template.on_val;
391
Charles Keepaxffacb482015-06-26 10:39:43 +0100392 data->widget = snd_soc_dapm_new_control_unlocked(
393 widget->dapm, &template);
Lars-Peter Clausene18077b2015-07-08 21:59:59 +0200394 kfree(name);
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200395 if (!data->widget) {
Charles Keepax561ed682015-05-01 12:37:26 +0100396 ret = -ENOMEM;
Lars-Peter Clausene18077b2015-07-08 21:59:59 +0200397 goto err_data;
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200398 }
Charles Keepax561ed682015-05-01 12:37:26 +0100399
400 snd_soc_dapm_add_path(widget->dapm, data->widget,
401 widget, NULL, NULL);
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200402 }
403 break;
404 default:
405 break;
406 }
407
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200408 kcontrol->private_data = data;
409
410 return 0;
Charles Keepax773da9b2015-05-01 12:37:25 +0100411
Charles Keepax773da9b2015-05-01 12:37:25 +0100412err_data:
413 kfree(data);
414 return ret;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200415}
416
417static void dapm_kcontrol_free(struct snd_kcontrol *kctl)
418{
419 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kctl);
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200420 kfree(data->wlist);
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200421 kfree(data);
422}
423
424static struct snd_soc_dapm_widget_list *dapm_kcontrol_get_wlist(
425 const struct snd_kcontrol *kcontrol)
426{
427 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
428
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200429 return data->wlist;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200430}
431
432static int dapm_kcontrol_add_widget(struct snd_kcontrol *kcontrol,
433 struct snd_soc_dapm_widget *widget)
434{
435 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200436 struct snd_soc_dapm_widget_list *new_wlist;
437 unsigned int n;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200438
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200439 if (data->wlist)
440 n = data->wlist->num_widgets + 1;
441 else
442 n = 1;
443
444 new_wlist = krealloc(data->wlist,
445 sizeof(*new_wlist) + sizeof(widget) * n, GFP_KERNEL);
446 if (!new_wlist)
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200447 return -ENOMEM;
448
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200449 new_wlist->widgets[n - 1] = widget;
450 new_wlist->num_widgets = n;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200451
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200452 data->wlist = new_wlist;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200453
454 return 0;
455}
456
Lars-Peter Clausen5106b922013-07-29 17:14:00 +0200457static void dapm_kcontrol_add_path(const struct snd_kcontrol *kcontrol,
458 struct snd_soc_dapm_path *path)
459{
460 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
461
462 list_add_tail(&path->list_kcontrol, &data->paths);
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200463}
464
465static bool dapm_kcontrol_is_powered(const struct snd_kcontrol *kcontrol)
466{
467 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
468
469 if (!data->widget)
470 return true;
471
472 return data->widget->power;
Lars-Peter Clausen5106b922013-07-29 17:14:00 +0200473}
474
475static struct list_head *dapm_kcontrol_get_path_list(
476 const struct snd_kcontrol *kcontrol)
477{
478 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
479
480 return &data->paths;
481}
482
483#define dapm_kcontrol_for_each_path(path, kcontrol) \
484 list_for_each_entry(path, dapm_kcontrol_get_path_list(kcontrol), \
485 list_kcontrol)
486
Subhransu S. Prusty5dc0158a2014-09-19 16:46:05 +0530487unsigned int dapm_kcontrol_get_value(const struct snd_kcontrol *kcontrol)
Lars-Peter Clausencf7c1de2013-07-29 17:13:59 +0200488{
489 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
490
491 return data->value;
492}
Subhransu S. Prusty5dc0158a2014-09-19 16:46:05 +0530493EXPORT_SYMBOL_GPL(dapm_kcontrol_get_value);
Lars-Peter Clausencf7c1de2013-07-29 17:13:59 +0200494
495static bool dapm_kcontrol_set_value(const struct snd_kcontrol *kcontrol,
496 unsigned int value)
497{
498 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
499
500 if (data->value == value)
501 return false;
502
Lars-Peter Clausen57295072013-08-05 11:27:31 +0200503 if (data->widget)
504 data->widget->on_val = value;
505
Lars-Peter Clausencf7c1de2013-07-29 17:13:59 +0200506 data->value = value;
507
508 return true;
509}
510
Lars-Peter Clauseneee5d7f2013-07-29 17:13:57 +0200511/**
Mythri P K93e39a12015-10-20 22:30:08 +0530512 * snd_soc_dapm_kcontrol_widget() - Returns the widget associated to a
513 * kcontrol
514 * @kcontrol: The kcontrol
515 */
516struct snd_soc_dapm_widget *snd_soc_dapm_kcontrol_widget(
517 struct snd_kcontrol *kcontrol)
518{
519 return dapm_kcontrol_get_wlist(kcontrol)->widgets[0];
520}
521EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_widget);
522
523/**
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200524 * snd_soc_dapm_kcontrol_dapm() - Returns the dapm context associated to a
525 * kcontrol
526 * @kcontrol: The kcontrol
527 *
528 * Note: This function must only be used on kcontrols that are known to have
529 * been registered for a CODEC. Otherwise the behaviour is undefined.
530 */
531struct snd_soc_dapm_context *snd_soc_dapm_kcontrol_dapm(
532 struct snd_kcontrol *kcontrol)
533{
534 return dapm_kcontrol_get_wlist(kcontrol)->widgets[0]->dapm;
535}
536EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_dapm);
537
Liam Girdwood6c120e12012-02-15 15:15:34 +0000538static void dapm_reset(struct snd_soc_card *card)
539{
540 struct snd_soc_dapm_widget *w;
541
Mark Brownf9fa2b12014-03-06 16:49:11 +0800542 lockdep_assert_held(&card->dapm_mutex);
543
Liam Girdwood6c120e12012-02-15 15:15:34 +0000544 memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
545
546 list_for_each_entry(w, &card->widgets, list) {
Lars-Peter Clausen39eb5fd2013-07-29 17:14:03 +0200547 w->new_power = w->power;
Liam Girdwood6c120e12012-02-15 15:15:34 +0000548 w->power_checked = false;
Liam Girdwood6c120e12012-02-15 15:15:34 +0000549 }
550}
551
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +0200552static const char *soc_dapm_prefix(struct snd_soc_dapm_context *dapm)
553{
554 if (!dapm->component)
555 return NULL;
556 return dapm->component->name_prefix;
557}
558
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200559static int soc_dapm_read(struct snd_soc_dapm_context *dapm, int reg,
Arun Shamanna Lakshmif7d3c172014-01-14 15:31:54 -0800560 unsigned int *value)
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100561{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200562 if (!dapm->component)
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +0200563 return -EIO;
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200564 return snd_soc_component_read(dapm->component, reg, value);
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100565}
566
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200567static int soc_dapm_update_bits(struct snd_soc_dapm_context *dapm,
Bard Liao34775012014-04-17 20:12:56 +0800568 int reg, unsigned int mask, unsigned int value)
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100569{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200570 if (!dapm->component)
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +0200571 return -EIO;
Mark Brownfcf6c5e2014-12-15 13:08:48 +0000572 return snd_soc_component_update_bits(dapm->component, reg,
573 mask, value);
Liam Girdwood49575fb52012-03-06 18:16:19 +0000574}
575
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200576static int soc_dapm_test_bits(struct snd_soc_dapm_context *dapm,
577 int reg, unsigned int mask, unsigned int value)
578{
579 if (!dapm->component)
580 return -EIO;
581 return snd_soc_component_test_bits(dapm->component, reg, mask, value);
582}
583
Mark Browneb270e92013-10-09 13:52:52 +0100584static void soc_dapm_async_complete(struct snd_soc_dapm_context *dapm)
585{
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +0200586 if (dapm->component)
587 snd_soc_component_async_complete(dapm->component);
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100588}
589
Charles Keepax45a110a2015-05-11 13:50:30 +0100590static struct snd_soc_dapm_widget *
591dapm_wcache_lookup(struct snd_soc_dapm_wcache *wcache, const char *name)
592{
593 struct snd_soc_dapm_widget *w = wcache->widget;
594 struct list_head *wlist;
595 const int depth = 2;
596 int i = 0;
597
598 if (w) {
599 wlist = &w->dapm->card->widgets;
600
601 list_for_each_entry_from(w, wlist, list) {
602 if (!strcmp(name, w->name))
603 return w;
604
605 if (++i == depth)
606 break;
607 }
608 }
609
610 return NULL;
611}
612
613static inline void dapm_wcache_update(struct snd_soc_dapm_wcache *wcache,
614 struct snd_soc_dapm_widget *w)
615{
616 wcache->widget = w;
617}
618
Mark Brown452c5ea2009-05-17 21:41:23 +0100619/**
Lars-Peter Clausenfa880772015-04-27 22:13:23 +0200620 * snd_soc_dapm_force_bias_level() - Sets the DAPM bias level
621 * @dapm: The DAPM context for which to set the level
622 * @level: The level to set
623 *
624 * Forces the DAPM bias level to a specific state. It will call the bias level
625 * callback of DAPM context with the specified level. This will even happen if
626 * the context is already at the same level. Furthermore it will not go through
627 * the normal bias level sequencing, meaning any intermediate states between the
628 * current and the target state will not be entered.
629 *
630 * Note that the change in bias level is only temporary and the next time
631 * snd_soc_dapm_sync() is called the state will be set to the level as
632 * determined by the DAPM core. The function is mainly intended to be used to
633 * used during probe or resume from suspend to power up the device so
634 * initialization can be done, before the DAPM core takes over.
635 */
636int snd_soc_dapm_force_bias_level(struct snd_soc_dapm_context *dapm,
637 enum snd_soc_bias_level level)
638{
639 int ret = 0;
640
641 if (dapm->set_bias_level)
642 ret = dapm->set_bias_level(dapm, level);
643
Lars-Peter Clausenf4bf8d72015-04-27 22:13:25 +0200644 if (ret == 0)
645 dapm->bias_level = level;
646
Lars-Peter Clausenfa880772015-04-27 22:13:23 +0200647 return ret;
648}
649EXPORT_SYMBOL_GPL(snd_soc_dapm_force_bias_level);
650
Mark Brown452c5ea2009-05-17 21:41:23 +0100651/**
652 * snd_soc_dapm_set_bias_level - set the bias level for the system
Mark Browned5a4c42011-02-18 11:12:42 -0800653 * @dapm: DAPM context
Mark Brown452c5ea2009-05-17 21:41:23 +0100654 * @level: level to configure
655 *
656 * Configure the bias (power) levels for the SoC audio device.
657 *
658 * Returns 0 for success else error.
659 */
Mark Browned5a4c42011-02-18 11:12:42 -0800660static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200661 enum snd_soc_bias_level level)
Mark Brown452c5ea2009-05-17 21:41:23 +0100662{
Mark Browned5a4c42011-02-18 11:12:42 -0800663 struct snd_soc_card *card = dapm->card;
Mark Brown452c5ea2009-05-17 21:41:23 +0100664 int ret = 0;
665
Mark Brown84e90932010-11-04 00:07:02 -0400666 trace_snd_soc_bias_level_start(card, level);
667
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000668 if (card && card->set_bias_level)
Mark Brownd4c60052011-06-06 19:13:23 +0100669 ret = card->set_bias_level(card, dapm, level);
Mark Brown171ec6b2011-06-06 18:15:19 +0100670 if (ret != 0)
671 goto out;
Mark Brown452c5ea2009-05-17 21:41:23 +0100672
Lars-Peter Clausenfa880772015-04-27 22:13:23 +0200673 if (!card || dapm != &card->dapm)
674 ret = snd_soc_dapm_force_bias_level(dapm, level);
Liam Girdwood41231282012-07-06 16:56:16 +0100675
Mark Brown171ec6b2011-06-06 18:15:19 +0100676 if (ret != 0)
677 goto out;
678
679 if (card && card->set_bias_level_post)
Mark Brownd4c60052011-06-06 19:13:23 +0100680 ret = card->set_bias_level_post(card, dapm, level);
Mark Brown171ec6b2011-06-06 18:15:19 +0100681out:
Mark Brown84e90932010-11-04 00:07:02 -0400682 trace_snd_soc_bias_level_done(card, level);
683
Mark Brown452c5ea2009-05-17 21:41:23 +0100684 return ret;
685}
686
Mark Brown74b8f952009-06-06 11:26:15 +0100687/* connect mux widget to its interconnecting audio paths */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200688static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200689 struct snd_soc_dapm_path *path, const char *control_name,
690 struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200691{
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200692 const struct snd_kcontrol_new *kcontrol = &w->kcontrol_news[0];
Richard Purdie2b97eab2006-10-06 18:32:18 +0200693 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100694 unsigned int val, item;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200695 int i;
696
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100697 if (e->reg != SND_SOC_NOPM) {
Lars-Peter Clausence0fc932014-06-16 18:13:06 +0200698 soc_dapm_read(dapm, e->reg, &val);
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100699 val = (val >> e->shift_l) & e->mask;
700 item = snd_soc_enum_val_to_item(e, val);
701 } else {
702 /* since a virtual mux has no backing registers to
703 * decide which path to connect, it will try to match
704 * with the first enumeration. This is to ensure
705 * that the default mux choice (the first) will be
706 * correctly powered up during initialization.
707 */
708 item = 0;
709 }
710
Takashi Iwai9a8d38d2014-02-18 08:11:42 +0100711 for (i = 0; i < e->items; i++) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200712 if (!(strcmp(control_name, e->texts[i]))) {
Rasmus Villemoes98ad73c2014-10-21 17:01:15 +0200713 path->name = e->texts[i];
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100714 if (i == item)
715 path->connect = 1;
716 else
717 path->connect = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200718 return 0;
719 }
720 }
721
722 return -ENODEV;
723}
724
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100725/* set up initial codec paths */
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +0200726static void dapm_set_mixer_path_status(struct snd_soc_dapm_path *p, int i)
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100727{
728 struct soc_mixer_control *mc = (struct soc_mixer_control *)
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +0200729 p->sink->kcontrol_news[i].private_value;
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100730 unsigned int reg = mc->reg;
731 unsigned int shift = mc->shift;
732 unsigned int max = mc->max;
733 unsigned int mask = (1 << fls(max)) - 1;
734 unsigned int invert = mc->invert;
735 unsigned int val;
736
737 if (reg != SND_SOC_NOPM) {
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +0200738 soc_dapm_read(p->sink->dapm, reg, &val);
Lars-Peter Clausen234c0b82014-02-28 08:31:12 +0100739 val = (val >> shift) & mask;
740 if (invert)
741 val = max - val;
742 p->connect = !!val;
743 } else {
744 p->connect = 0;
745 }
746}
747
Mark Brown74b8f952009-06-06 11:26:15 +0100748/* connect mixer widget to its interconnecting audio paths */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200749static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
Richard Purdie2b97eab2006-10-06 18:32:18 +0200750 struct snd_soc_dapm_path *path, const char *control_name)
751{
752 int i;
753
754 /* search for mixer kcontrol */
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +0200755 for (i = 0; i < path->sink->num_kcontrols; i++) {
756 if (!strcmp(control_name, path->sink->kcontrol_news[i].name)) {
757 path->name = path->sink->kcontrol_news[i].name;
758 dapm_set_mixer_path_status(path, i);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200759 return 0;
760 }
761 }
762 return -ENODEV;
763}
764
Stephen Warrenaf468002011-04-28 17:38:01 -0600765static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
Stephen Warren1007da02011-05-26 09:57:33 -0600766 struct snd_soc_dapm_widget *kcontrolw,
Stephen Warrenaf468002011-04-28 17:38:01 -0600767 const struct snd_kcontrol_new *kcontrol_new,
768 struct snd_kcontrol **kcontrol)
769{
770 struct snd_soc_dapm_widget *w;
771 int i;
772
773 *kcontrol = NULL;
774
775 list_for_each_entry(w, &dapm->card->widgets, list) {
Stephen Warren1007da02011-05-26 09:57:33 -0600776 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
777 continue;
Stephen Warrenaf468002011-04-28 17:38:01 -0600778 for (i = 0; i < w->num_kcontrols; i++) {
779 if (&w->kcontrol_news[i] == kcontrol_new) {
780 if (w->kcontrols)
781 *kcontrol = w->kcontrols[i];
782 return 1;
783 }
784 }
785 }
786
787 return 0;
788}
789
Stephen Warren85762e72013-03-29 15:40:10 -0600790/*
791 * Determine if a kcontrol is shared. If it is, look it up. If it isn't,
792 * create it. Either way, add the widget into the control's widget list
793 */
Jeeja KP19a2557b2015-10-20 22:30:06 +0530794static int dapm_create_or_share_kcontrol(struct snd_soc_dapm_widget *w,
Mark Brown946d92a2013-08-12 23:28:42 +0100795 int kci)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200796{
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200797 struct snd_soc_dapm_context *dapm = w->dapm;
Mark Brown12ea2c72011-03-02 18:17:32 +0000798 struct snd_card *card = dapm->card->snd_card;
Mark Brownefb7ac32011-03-08 17:23:24 +0000799 const char *prefix;
Stephen Warren85762e72013-03-29 15:40:10 -0600800 size_t prefix_len;
801 int shared;
802 struct snd_kcontrol *kcontrol;
Stephen Warren85762e72013-03-29 15:40:10 -0600803 bool wname_in_long_name, kcname_in_long_name;
Daniel Macke5092c92014-10-07 13:41:24 +0200804 char *long_name = NULL;
Stephen Warren85762e72013-03-29 15:40:10 -0600805 const char *name;
Daniel Macke5092c92014-10-07 13:41:24 +0200806 int ret = 0;
Mark Brownefb7ac32011-03-08 17:23:24 +0000807
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +0200808 prefix = soc_dapm_prefix(dapm);
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000809 if (prefix)
810 prefix_len = strlen(prefix) + 1;
811 else
812 prefix_len = 0;
813
Stephen Warren85762e72013-03-29 15:40:10 -0600814 shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],
815 &kcontrol);
816
Stephen Warren85762e72013-03-29 15:40:10 -0600817 if (!kcontrol) {
818 if (shared) {
819 wname_in_long_name = false;
820 kcname_in_long_name = true;
821 } else {
822 switch (w->id) {
823 case snd_soc_dapm_switch:
824 case snd_soc_dapm_mixer:
Jeeja KP19a2557b2015-10-20 22:30:06 +0530825 case snd_soc_dapm_pga:
Chen-Yu Tsaia3930ed2016-08-27 19:28:00 +0800826 case snd_soc_dapm_out_drv:
Stephen Warren85762e72013-03-29 15:40:10 -0600827 wname_in_long_name = true;
828 kcname_in_long_name = true;
829 break;
830 case snd_soc_dapm_mixer_named_ctl:
831 wname_in_long_name = false;
832 kcname_in_long_name = true;
833 break;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200834 case snd_soc_dapm_demux:
Stephen Warren85762e72013-03-29 15:40:10 -0600835 case snd_soc_dapm_mux:
Stephen Warren85762e72013-03-29 15:40:10 -0600836 wname_in_long_name = true;
837 kcname_in_long_name = false;
838 break;
839 default:
Stephen Warren85762e72013-03-29 15:40:10 -0600840 return -EINVAL;
841 }
842 }
843
844 if (wname_in_long_name && kcname_in_long_name) {
Stephen Warren85762e72013-03-29 15:40:10 -0600845 /*
846 * The control will get a prefix from the control
847 * creation process but we're also using the same
848 * prefix for widgets so cut the prefix off the
849 * front of the widget name.
850 */
Lars-Peter Clausen2b581072013-05-14 11:05:32 +0200851 long_name = kasprintf(GFP_KERNEL, "%s %s",
Stephen Warren85762e72013-03-29 15:40:10 -0600852 w->name + prefix_len,
853 w->kcontrol_news[kci].name);
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200854 if (long_name == NULL)
Lars-Peter Clausen2b581072013-05-14 11:05:32 +0200855 return -ENOMEM;
Stephen Warren85762e72013-03-29 15:40:10 -0600856
857 name = long_name;
858 } else if (wname_in_long_name) {
859 long_name = NULL;
860 name = w->name + prefix_len;
861 } else {
862 long_name = NULL;
863 name = w->kcontrol_news[kci].name;
864 }
865
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200866 kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,
Stephen Warren85762e72013-03-29 15:40:10 -0600867 prefix);
Daniel Macke5092c92014-10-07 13:41:24 +0200868 if (!kcontrol) {
869 ret = -ENOMEM;
870 goto exit_free;
871 }
872
Lars-Peter Clausen9356e9d2013-08-01 14:08:06 +0200873 kcontrol->private_free = dapm_kcontrol_free;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200874
Lars-Peter Clausen41d80022016-02-03 21:59:50 +0100875 ret = dapm_kcontrol_data_alloc(w, kcontrol, name);
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200876 if (ret) {
877 snd_ctl_free_one(kcontrol);
Daniel Macke5092c92014-10-07 13:41:24 +0200878 goto exit_free;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200879 }
880
Stephen Warren85762e72013-03-29 15:40:10 -0600881 ret = snd_ctl_add(card, kcontrol);
882 if (ret < 0) {
883 dev_err(dapm->dev,
884 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
885 w->name, name, ret);
Daniel Macke5092c92014-10-07 13:41:24 +0200886 goto exit_free;
Stephen Warren85762e72013-03-29 15:40:10 -0600887 }
Stephen Warren85762e72013-03-29 15:40:10 -0600888 }
889
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200890 ret = dapm_kcontrol_add_widget(kcontrol, w);
Daniel Macke5092c92014-10-07 13:41:24 +0200891 if (ret == 0)
892 w->kcontrols[kci] = kcontrol;
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200893
Daniel Macke5092c92014-10-07 13:41:24 +0200894exit_free:
895 kfree(long_name);
Stephen Warren85762e72013-03-29 15:40:10 -0600896
Daniel Macke5092c92014-10-07 13:41:24 +0200897 return ret;
Stephen Warren85762e72013-03-29 15:40:10 -0600898}
899
900/* create new dapm mixer control */
901static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
902{
903 int i, ret;
904 struct snd_soc_dapm_path *path;
Charles Keepax561ed682015-05-01 12:37:26 +0100905 struct dapm_kcontrol_data *data;
Stephen Warren85762e72013-03-29 15:40:10 -0600906
Richard Purdie2b97eab2006-10-06 18:32:18 +0200907 /* add kcontrol */
908 for (i = 0; i < w->num_kcontrols; i++) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200909 /* match name */
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +0200910 snd_soc_dapm_widget_for_each_source_path(w, path) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200911 /* mixer/mux paths name must match control name */
Stephen Warren82cfecd2011-04-28 17:37:58 -0600912 if (path->name != (char *)w->kcontrol_news[i].name)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200913 continue;
914
Charles Keepax561ed682015-05-01 12:37:26 +0100915 if (!w->kcontrols[i]) {
Jeeja KP19a2557b2015-10-20 22:30:06 +0530916 ret = dapm_create_or_share_kcontrol(w, i);
Charles Keepax561ed682015-05-01 12:37:26 +0100917 if (ret < 0)
918 return ret;
Lars-Peter Clausen82cd8762011-08-15 20:15:21 +0200919 }
920
Mark Brown946d92a2013-08-12 23:28:42 +0100921 dapm_kcontrol_add_path(w->kcontrols[i], path);
Charles Keepax561ed682015-05-01 12:37:26 +0100922
923 data = snd_kcontrol_chip(w->kcontrols[i]);
924 if (data->widget)
925 snd_soc_dapm_add_path(data->widget->dapm,
926 data->widget,
927 path->source,
928 NULL, NULL);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200929 }
930 }
Stephen Warren85762e72013-03-29 15:40:10 -0600931
932 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200933}
934
935/* create new dapm mux control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200936static int dapm_new_mux(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200937{
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200938 struct snd_soc_dapm_context *dapm = w->dapm;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200939 enum snd_soc_dapm_direction dir;
Stephen Warren85762e72013-03-29 15:40:10 -0600940 struct snd_soc_dapm_path *path;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200941 const char *type;
Stephen Warrenaf468002011-04-28 17:38:01 -0600942 int ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200943
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200944 switch (w->id) {
945 case snd_soc_dapm_mux:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200946 dir = SND_SOC_DAPM_DIR_OUT;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200947 type = "mux";
948 break;
949 case snd_soc_dapm_demux:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200950 dir = SND_SOC_DAPM_DIR_IN;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200951 type = "demux";
952 break;
953 default:
954 return -EINVAL;
955 }
956
Stephen Warrenaf468002011-04-28 17:38:01 -0600957 if (w->num_kcontrols != 1) {
958 dev_err(dapm->dev,
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200959 "ASoC: %s %s has incorrect number of controls\n", type,
Stephen Warrenaf468002011-04-28 17:38:01 -0600960 w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200961 return -EINVAL;
962 }
963
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200964 if (list_empty(&w->edges[dir])) {
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200965 dev_err(dapm->dev, "ASoC: %s %s has no paths\n", type, w->name);
Stephen Warren85762e72013-03-29 15:40:10 -0600966 return -EINVAL;
Stephen Warrenaf468002011-04-28 17:38:01 -0600967 }
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200968
Jeeja KP19a2557b2015-10-20 22:30:06 +0530969 ret = dapm_create_or_share_kcontrol(w, 0);
Stephen Warren85762e72013-03-29 15:40:10 -0600970 if (ret < 0)
971 return ret;
Stephen Warrenfad59882011-04-28 17:37:59 -0600972
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200973 snd_soc_dapm_widget_for_each_path(w, dir, path) {
974 if (path->name)
975 dapm_kcontrol_add_path(w->kcontrols[0], path);
Lars-Peter Clausen98407ef2014-10-25 17:41:57 +0200976 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200977
Stephen Warrenaf468002011-04-28 17:38:01 -0600978 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200979}
980
981/* create new dapm volume control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200982static int dapm_new_pga(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200983{
Jeeja KP19a2557b2015-10-20 22:30:06 +0530984 int i, ret;
985
986 for (i = 0; i < w->num_kcontrols; i++) {
987 ret = dapm_create_or_share_kcontrol(w, i);
988 if (ret < 0)
989 return ret;
990 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200991
Mark Browna6c65732010-03-03 17:45:21 +0000992 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200993}
994
Nikesh Oswalc6615082015-02-02 17:06:44 +0000995/* create new dapm dai link control */
996static int dapm_new_dai_link(struct snd_soc_dapm_widget *w)
997{
998 int i, ret;
999 struct snd_kcontrol *kcontrol;
1000 struct snd_soc_dapm_context *dapm = w->dapm;
1001 struct snd_card *card = dapm->card->snd_card;
1002
1003 /* create control for links with > 1 config */
1004 if (w->num_params <= 1)
1005 return 0;
1006
1007 /* add kcontrol */
1008 for (i = 0; i < w->num_kcontrols; i++) {
1009 kcontrol = snd_soc_cnew(&w->kcontrol_news[i], w,
1010 w->name, NULL);
1011 ret = snd_ctl_add(card, kcontrol);
1012 if (ret < 0) {
1013 dev_err(dapm->dev,
1014 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
1015 w->name, w->kcontrol_news[i].name, ret);
1016 return ret;
1017 }
1018 kcontrol->private_data = w;
1019 w->kcontrols[i] = kcontrol;
1020 }
1021
1022 return 0;
1023}
1024
Mark Brown99497882010-05-07 20:24:05 +01001025/* We implement power down on suspend by checking the power state of
1026 * the ALSA card - when we are suspending the ALSA state for the card
1027 * is set to D3.
1028 */
1029static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
1030{
Mark Brown12ea2c72011-03-02 18:17:32 +00001031 int level = snd_power_get_state(widget->dapm->card->snd_card);
Mark Brown99497882010-05-07 20:24:05 +01001032
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001033 switch (level) {
Mark Brown99497882010-05-07 20:24:05 +01001034 case SNDRV_CTL_POWER_D3hot:
1035 case SNDRV_CTL_POWER_D3cold:
Mark Brown1547aba2010-05-07 21:11:40 +01001036 if (widget->ignore_suspend)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001037 dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02001038 widget->name);
Mark Brown1547aba2010-05-07 21:11:40 +01001039 return widget->ignore_suspend;
Mark Brown99497882010-05-07 20:24:05 +01001040 default:
1041 return 1;
1042 }
1043}
1044
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001045static int dapm_widget_list_create(struct snd_soc_dapm_widget_list **list,
1046 struct list_head *widgets)
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001047{
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001048 struct snd_soc_dapm_widget *w;
1049 struct list_head *it;
1050 unsigned int size = 0;
1051 unsigned int i = 0;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001052
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001053 list_for_each(it, widgets)
1054 size++;
1055
1056 *list = kzalloc(sizeof(**list) + size * sizeof(*w), GFP_KERNEL);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001057 if (*list == NULL)
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001058 return -ENOMEM;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001059
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001060 list_for_each_entry(w, widgets, work_list)
1061 (*list)->widgets[i++] = w;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001062
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001063 (*list)->num_widgets = i;
1064
1065 return 0;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001066}
1067
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001068/*
1069 * Common implementation for is_connected_output_ep() and
1070 * is_connected_input_ep(). The function is inlined since the combined size of
1071 * the two specialized functions is only marginally larger then the size of the
1072 * generic function and at the same time the fast path of the specialized
1073 * functions is significantly smaller than the generic function.
1074 */
1075static __always_inline int is_connected_ep(struct snd_soc_dapm_widget *widget,
1076 struct list_head *list, enum snd_soc_dapm_direction dir,
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001077 int (*fn)(struct snd_soc_dapm_widget *, struct list_head *,
1078 bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
1079 enum snd_soc_dapm_direction)),
1080 bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
1081 enum snd_soc_dapm_direction))
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001082{
1083 enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001084 struct snd_soc_dapm_path *path;
1085 int con = 0;
1086
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001087 if (widget->endpoints[dir] >= 0)
1088 return widget->endpoints[dir];
Mark Brown024dc072011-10-09 11:52:05 +01001089
Mark Brownde02d072011-09-20 21:43:24 +01001090 DAPM_UPDATE_STAT(widget, path_checks);
1091
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001092 /* do we need to add this widget to the list ? */
1093 if (list)
1094 list_add_tail(&widget->work_list, list);
1095
Jeeja KP09464972016-06-15 11:16:55 +05301096 if (custom_stop_condition && custom_stop_condition(widget, dir)) {
1097 widget->endpoints[dir] = 1;
1098 return widget->endpoints[dir];
1099 }
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001100
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001101 if ((widget->is_ep & SND_SOC_DAPM_DIR_TO_EP(dir)) && widget->connected) {
1102 widget->endpoints[dir] = snd_soc_dapm_suspend_check(widget);
1103 return widget->endpoints[dir];
Richard Purdie2b97eab2006-10-06 18:32:18 +02001104 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02001105
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001106 snd_soc_dapm_widget_for_each_path(widget, rdir, path) {
Mark Browne56235e2011-09-21 18:19:14 +01001107 DAPM_UPDATE_STAT(widget, neighbour_checks);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001108
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02001109 if (path->weak || path->is_supply)
Mark Brownbf3a9e12011-06-13 16:42:29 +01001110 continue;
1111
Mark Brown8af294b2013-02-22 17:48:15 +00001112 if (path->walking)
1113 return 1;
1114
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001115 trace_snd_soc_dapm_path(widget, dir, path);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001116
Lars-Peter Clausen7ddd4cd2014-10-20 19:36:34 +02001117 if (path->connect) {
Mark Brown8af294b2013-02-22 17:48:15 +00001118 path->walking = 1;
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001119 con += fn(path->node[dir], list, custom_stop_condition);
Mark Brown8af294b2013-02-22 17:48:15 +00001120 path->walking = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001121 }
1122 }
1123
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001124 widget->endpoints[dir] = con;
Mark Brown024dc072011-10-09 11:52:05 +01001125
Richard Purdie2b97eab2006-10-06 18:32:18 +02001126 return con;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001127}
1128
1129/*
1130 * Recursively check for a completed path to an active or physically connected
1131 * output widget. Returns number of complete paths.
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001132 *
1133 * Optionally, can be supplied with a function acting as a stopping condition.
1134 * This function takes the dapm widget currently being examined and the walk
1135 * direction as an arguments, it should return true if the walk should be
1136 * stopped and false otherwise.
Richard Purdie2b97eab2006-10-06 18:32:18 +02001137 */
1138static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001139 struct list_head *list,
1140 bool (*custom_stop_condition)(struct snd_soc_dapm_widget *i,
1141 enum snd_soc_dapm_direction))
Richard Purdie2b97eab2006-10-06 18:32:18 +02001142{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001143 return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_OUT,
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001144 is_connected_output_ep, custom_stop_condition);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001145}
1146
1147/*
1148 * Recursively check for a completed path to an active or physically connected
1149 * input widget. Returns number of complete paths.
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001150 *
1151 * Optionally, can be supplied with a function acting as a stopping condition.
1152 * This function takes the dapm widget currently being examined and the walk
1153 * direction as an arguments, it should return true if the walk should be
1154 * stopped and false otherwise.
Richard Purdie2b97eab2006-10-06 18:32:18 +02001155 */
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001156static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001157 struct list_head *list,
1158 bool (*custom_stop_condition)(struct snd_soc_dapm_widget *i,
1159 enum snd_soc_dapm_direction))
Richard Purdie2b97eab2006-10-06 18:32:18 +02001160{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001161 return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_IN,
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001162 is_connected_input_ep, custom_stop_condition);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001163}
1164
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001165/**
1166 * snd_soc_dapm_get_connected_widgets - query audio path and it's widgets.
1167 * @dai: the soc DAI.
1168 * @stream: stream direction.
1169 * @list: list of active widgets for this stream.
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001170 * @custom_stop_condition: (optional) a function meant to stop the widget graph
1171 * walk based on custom logic.
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001172 *
Peter Meerwald-Stadlerc8046002016-08-16 16:56:17 +02001173 * Queries DAPM graph as to whether a valid audio stream path exists for
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001174 * the initial stream specified by name. This takes into account
1175 * current mixer and mux kcontrol settings. Creates list of valid widgets.
1176 *
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001177 * Optionally, can be supplied with a function acting as a stopping condition.
1178 * This function takes the dapm widget currently being examined and the walk
1179 * direction as an arguments, it should return true if the walk should be
1180 * stopped and false otherwise.
1181 *
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001182 * Returns the number of valid paths or negative error.
1183 */
1184int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001185 struct snd_soc_dapm_widget_list **list,
1186 bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
1187 enum snd_soc_dapm_direction))
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001188{
Lars-Peter Clausen313665b2014-11-04 11:30:58 +01001189 struct snd_soc_card *card = dai->component->card;
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02001190 struct snd_soc_dapm_widget *w;
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001191 LIST_HEAD(widgets);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001192 int paths;
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001193 int ret;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001194
1195 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02001196
1197 /*
1198 * For is_connected_{output,input}_ep fully discover the graph we need
1199 * to reset the cached number of inputs and outputs.
1200 */
1201 list_for_each_entry(w, &card->widgets, list) {
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001202 w->endpoints[SND_SOC_DAPM_DIR_IN] = -1;
1203 w->endpoints[SND_SOC_DAPM_DIR_OUT] = -1;
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02001204 }
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001205
Lars-Peter Clausen130897a2014-10-20 19:36:39 +02001206 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001207 paths = is_connected_output_ep(dai->playback_widget, &widgets,
1208 custom_stop_condition);
Lars-Peter Clausen130897a2014-10-20 19:36:39 +02001209 else
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001210 paths = is_connected_input_ep(dai->capture_widget, &widgets,
1211 custom_stop_condition);
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001212
1213 /* Drop starting point */
1214 list_del(widgets.next);
1215
1216 ret = dapm_widget_list_create(list, &widgets);
1217 if (ret)
Lars-Peter Clausen30abbe72015-08-11 21:37:59 +02001218 paths = ret;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001219
1220 trace_snd_soc_dapm_connected(paths, stream);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001221 mutex_unlock(&card->dapm_mutex);
1222
1223 return paths;
1224}
1225
Richard Purdie2b97eab2006-10-06 18:32:18 +02001226/*
Mark Brown62ea8742012-01-21 21:14:48 +00001227 * Handler for regulator supply widget.
1228 */
1229int dapm_regulator_event(struct snd_soc_dapm_widget *w,
1230 struct snd_kcontrol *kcontrol, int event)
1231{
Mark Brownc05b84d2012-09-07 12:57:11 +08001232 int ret;
1233
Mark Browneb270e92013-10-09 13:52:52 +01001234 soc_dapm_async_complete(w->dapm);
1235
Mark Brownc05b84d2012-09-07 12:57:11 +08001236 if (SND_SOC_DAPM_EVENT_ON(event)) {
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001237 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
Mark Brown8784c772013-01-10 19:33:47 +00001238 ret = regulator_allow_bypass(w->regulator, false);
Mark Brownc05b84d2012-09-07 12:57:11 +08001239 if (ret != 0)
1240 dev_warn(w->dapm->dev,
Charles Keepax30686c32014-02-18 16:05:27 +00001241 "ASoC: Failed to unbypass %s: %d\n",
Mark Brownc05b84d2012-09-07 12:57:11 +08001242 w->name, ret);
1243 }
1244
Liam Girdwooda3cc0562012-03-09 17:20:16 +00001245 return regulator_enable(w->regulator);
Mark Brownc05b84d2012-09-07 12:57:11 +08001246 } else {
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001247 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
Mark Brown8784c772013-01-10 19:33:47 +00001248 ret = regulator_allow_bypass(w->regulator, true);
Mark Brownc05b84d2012-09-07 12:57:11 +08001249 if (ret != 0)
1250 dev_warn(w->dapm->dev,
Charles Keepax30686c32014-02-18 16:05:27 +00001251 "ASoC: Failed to bypass %s: %d\n",
Mark Brownc05b84d2012-09-07 12:57:11 +08001252 w->name, ret);
1253 }
1254
Liam Girdwooda3cc0562012-03-09 17:20:16 +00001255 return regulator_disable_deferred(w->regulator, w->shift);
Mark Brownc05b84d2012-09-07 12:57:11 +08001256 }
Mark Brown62ea8742012-01-21 21:14:48 +00001257}
1258EXPORT_SYMBOL_GPL(dapm_regulator_event);
1259
Ola Liljad7e7eb92012-05-24 15:26:25 +02001260/*
1261 * Handler for clock supply widget.
1262 */
1263int dapm_clock_event(struct snd_soc_dapm_widget *w,
1264 struct snd_kcontrol *kcontrol, int event)
1265{
1266 if (!w->clk)
1267 return -EIO;
1268
Mark Browneb270e92013-10-09 13:52:52 +01001269 soc_dapm_async_complete(w->dapm);
1270
Mark Brownec029952012-06-04 08:16:20 +01001271#ifdef CONFIG_HAVE_CLK
Ola Liljad7e7eb92012-05-24 15:26:25 +02001272 if (SND_SOC_DAPM_EVENT_ON(event)) {
Fabio Baltieri37c1b922013-04-30 16:09:52 +02001273 return clk_prepare_enable(w->clk);
Ola Liljad7e7eb92012-05-24 15:26:25 +02001274 } else {
Fabio Baltieri37c1b922013-04-30 16:09:52 +02001275 clk_disable_unprepare(w->clk);
Ola Liljad7e7eb92012-05-24 15:26:25 +02001276 return 0;
1277 }
Mark Brownec029952012-06-04 08:16:20 +01001278#endif
Marek Belisko98b3cf12012-07-12 23:00:16 +02001279 return 0;
Ola Liljad7e7eb92012-05-24 15:26:25 +02001280}
1281EXPORT_SYMBOL_GPL(dapm_clock_event);
1282
Mark Brownd8050022011-09-28 18:28:23 +01001283static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1284{
Mark Brown9b8a83b2011-10-04 22:15:59 +01001285 if (w->power_checked)
1286 return w->new_power;
1287
Mark Brownd8050022011-09-28 18:28:23 +01001288 if (w->force)
Mark Brown9b8a83b2011-10-04 22:15:59 +01001289 w->new_power = 1;
Mark Brownd8050022011-09-28 18:28:23 +01001290 else
Mark Brown9b8a83b2011-10-04 22:15:59 +01001291 w->new_power = w->power_check(w);
1292
1293 w->power_checked = true;
1294
1295 return w->new_power;
Mark Brownd8050022011-09-28 18:28:23 +01001296}
1297
Peter Meerwald-Stadlerc8046002016-08-16 16:56:17 +02001298/* Generic check to see if a widget should be powered. */
Mark Browncd0f2d42009-04-20 16:56:59 +01001299static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1300{
1301 int in, out;
1302
Mark Brownde02d072011-09-20 21:43:24 +01001303 DAPM_UPDATE_STAT(w, power_checks);
1304
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001305 in = is_connected_input_ep(w, NULL, NULL);
1306 out = is_connected_output_ep(w, NULL, NULL);
Mark Browncd0f2d42009-04-20 16:56:59 +01001307 return out != 0 && in != 0;
1308}
1309
Mark Brown246d0a12009-04-22 18:24:55 +01001310/* Check to see if a power supply is needed */
1311static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1312{
1313 struct snd_soc_dapm_path *path;
Mark Brown246d0a12009-04-22 18:24:55 +01001314
Mark Brownde02d072011-09-20 21:43:24 +01001315 DAPM_UPDATE_STAT(w, power_checks);
1316
Mark Brown246d0a12009-04-22 18:24:55 +01001317 /* Check if one of our outputs is connected */
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02001318 snd_soc_dapm_widget_for_each_sink_path(w, path) {
Mark Browna8fdac82011-09-28 18:20:26 +01001319 DAPM_UPDATE_STAT(w, neighbour_checks);
1320
Mark Brownbf3a9e12011-06-13 16:42:29 +01001321 if (path->weak)
1322 continue;
1323
Mark Brown215edda2009-09-08 18:59:05 +01001324 if (path->connected &&
1325 !path->connected(path->source, path->sink))
1326 continue;
1327
Mark Brownf68d7e12011-10-04 22:57:50 +01001328 if (dapm_widget_power_check(path->sink))
1329 return 1;
Mark Brown246d0a12009-04-22 18:24:55 +01001330 }
1331
Mark Brownf68d7e12011-10-04 22:57:50 +01001332 return 0;
Mark Brown246d0a12009-04-22 18:24:55 +01001333}
1334
Mark Brown35c64bc2011-09-28 18:23:53 +01001335static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1336{
Charles Keepax20bb0182015-12-02 10:22:16 +00001337 return w->connected;
Mark Brown35c64bc2011-09-28 18:23:53 +01001338}
1339
Mark Brown38357ab2009-06-06 19:03:23 +01001340static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
1341 struct snd_soc_dapm_widget *b,
Mark Brown828a8422011-01-15 13:14:30 +00001342 bool power_up)
Mark Brown42aa3412009-03-01 19:21:10 +00001343{
Mark Brown828a8422011-01-15 13:14:30 +00001344 int *sort;
1345
1346 if (power_up)
1347 sort = dapm_up_seq;
1348 else
1349 sort = dapm_down_seq;
1350
Mark Brown38357ab2009-06-06 19:03:23 +01001351 if (sort[a->id] != sort[b->id])
1352 return sort[a->id] - sort[b->id];
Mark Brown20e48592011-01-15 13:40:50 +00001353 if (a->subseq != b->subseq) {
1354 if (power_up)
1355 return a->subseq - b->subseq;
1356 else
1357 return b->subseq - a->subseq;
1358 }
Mark Brownb22ead22009-06-07 12:51:26 +01001359 if (a->reg != b->reg)
1360 return a->reg - b->reg;
Mark Brown84dab562010-11-12 15:28:42 +00001361 if (a->dapm != b->dapm)
1362 return (unsigned long)a->dapm - (unsigned long)b->dapm;
Mark Brown42aa3412009-03-01 19:21:10 +00001363
Mark Brown38357ab2009-06-06 19:03:23 +01001364 return 0;
1365}
Mark Brown42aa3412009-03-01 19:21:10 +00001366
Mark Brown38357ab2009-06-06 19:03:23 +01001367/* Insert a widget in order into a DAPM power sequence. */
1368static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
1369 struct list_head *list,
Mark Brown828a8422011-01-15 13:14:30 +00001370 bool power_up)
Mark Brown38357ab2009-06-06 19:03:23 +01001371{
1372 struct snd_soc_dapm_widget *w;
1373
1374 list_for_each_entry(w, list, power_list)
Mark Brown828a8422011-01-15 13:14:30 +00001375 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
Mark Brown38357ab2009-06-06 19:03:23 +01001376 list_add_tail(&new_widget->power_list, &w->power_list);
1377 return;
Mark Brown42aa3412009-03-01 19:21:10 +00001378 }
Mark Brown6ea31b92009-04-20 17:15:41 +01001379
Mark Brown38357ab2009-06-06 19:03:23 +01001380 list_add_tail(&new_widget->power_list, list);
1381}
Mark Brown42aa3412009-03-01 19:21:10 +00001382
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001383static void dapm_seq_check_event(struct snd_soc_card *card,
Mark Brown68f89ad2010-11-03 23:51:49 -04001384 struct snd_soc_dapm_widget *w, int event)
1385{
Mark Brown68f89ad2010-11-03 23:51:49 -04001386 const char *ev_name;
1387 int power, ret;
1388
1389 switch (event) {
1390 case SND_SOC_DAPM_PRE_PMU:
1391 ev_name = "PRE_PMU";
1392 power = 1;
1393 break;
1394 case SND_SOC_DAPM_POST_PMU:
1395 ev_name = "POST_PMU";
1396 power = 1;
1397 break;
1398 case SND_SOC_DAPM_PRE_PMD:
1399 ev_name = "PRE_PMD";
1400 power = 0;
1401 break;
1402 case SND_SOC_DAPM_POST_PMD:
1403 ev_name = "POST_PMD";
1404 power = 0;
1405 break;
Mark Brown80114122013-02-25 15:14:19 +00001406 case SND_SOC_DAPM_WILL_PMU:
1407 ev_name = "WILL_PMU";
1408 power = 1;
1409 break;
1410 case SND_SOC_DAPM_WILL_PMD:
1411 ev_name = "WILL_PMD";
1412 power = 0;
1413 break;
Mark Brown68f89ad2010-11-03 23:51:49 -04001414 default:
Takashi Iwaia6ed0602013-11-06 11:07:19 +01001415 WARN(1, "Unknown event %d\n", event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001416 return;
1417 }
1418
Lars-Peter Clausen39eb5fd2013-07-29 17:14:03 +02001419 if (w->new_power != power)
Mark Brown68f89ad2010-11-03 23:51:49 -04001420 return;
1421
1422 if (w->event && (w->event_flags & event)) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001423 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
Mark Brown68f89ad2010-11-03 23:51:49 -04001424 w->name, ev_name);
Mark Browneb270e92013-10-09 13:52:52 +01001425 soc_dapm_async_complete(w->dapm);
Mark Brown84e90932010-11-04 00:07:02 -04001426 trace_snd_soc_dapm_widget_event_start(w, event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001427 ret = w->event(w, NULL, event);
Mark Brown84e90932010-11-04 00:07:02 -04001428 trace_snd_soc_dapm_widget_event_done(w, event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001429 if (ret < 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001430 dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
Mark Brown68f89ad2010-11-03 23:51:49 -04001431 ev_name, w->name, ret);
1432 }
1433}
1434
Mark Brownb22ead22009-06-07 12:51:26 +01001435/* Apply the coalesced changes from a DAPM sequence */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001436static void dapm_seq_run_coalesced(struct snd_soc_card *card,
Mark Brownb22ead22009-06-07 12:51:26 +01001437 struct list_head *pending)
Mark Brown163cac02009-06-07 10:12:52 +01001438{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001439 struct snd_soc_dapm_context *dapm;
Mark Brown68f89ad2010-11-03 23:51:49 -04001440 struct snd_soc_dapm_widget *w;
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001441 int reg;
Mark Brownb22ead22009-06-07 12:51:26 +01001442 unsigned int value = 0;
1443 unsigned int mask = 0;
Mark Brownb22ead22009-06-07 12:51:26 +01001444
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001445 w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
1446 reg = w->reg;
1447 dapm = w->dapm;
Mark Brownb22ead22009-06-07 12:51:26 +01001448
1449 list_for_each_entry(w, pending, power_list) {
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001450 WARN_ON(reg != w->reg || dapm != w->dapm);
Lars-Peter Clausen39eb5fd2013-07-29 17:14:03 +02001451 w->power = w->new_power;
Mark Brownb22ead22009-06-07 12:51:26 +01001452
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001453 mask |= w->mask << w->shift;
1454 if (w->power)
1455 value |= w->on_val << w->shift;
Mark Brownb22ead22009-06-07 12:51:26 +01001456 else
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001457 value |= w->off_val << w->shift;
Mark Brownb22ead22009-06-07 12:51:26 +01001458
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001459 pop_dbg(dapm->dev, card->pop_time,
Mark Brownb22ead22009-06-07 12:51:26 +01001460 "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1461 w->name, reg, value, mask);
Mark Brown81628102009-06-07 13:21:24 +01001462
Mark Brown68f89ad2010-11-03 23:51:49 -04001463 /* Check for events */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001464 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
1465 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
Mark Brownb22ead22009-06-07 12:51:26 +01001466 }
1467
Mark Brown81628102009-06-07 13:21:24 +01001468 if (reg >= 0) {
Mark Brown29376bc2011-06-19 13:49:28 +01001469 /* Any widget will do, they should all be updating the
1470 * same register.
1471 */
Mark Brown29376bc2011-06-19 13:49:28 +01001472
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001473 pop_dbg(dapm->dev, card->pop_time,
Mark Brown81628102009-06-07 13:21:24 +01001474 "pop test : Applying 0x%x/0x%x to %x in %dms\n",
Jarkko Nikula3a45b862010-11-05 20:35:21 +02001475 value, mask, reg, card->pop_time);
1476 pop_wait(card->pop_time);
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001477 soc_dapm_update_bits(dapm, reg, mask, value);
Mark Brown81628102009-06-07 13:21:24 +01001478 }
1479
1480 list_for_each_entry(w, pending, power_list) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001481 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
1482 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
Mark Brown42aa3412009-03-01 19:21:10 +00001483 }
Mark Brown42aa3412009-03-01 19:21:10 +00001484}
1485
Mark Brownb22ead22009-06-07 12:51:26 +01001486/* Apply a DAPM power sequence.
1487 *
1488 * We walk over a pre-sorted list of widgets to apply power to. In
1489 * order to minimise the number of writes to the device required
1490 * multiple widgets will be updated in a single write where possible.
1491 * Currently anything that requires more than a single write is not
1492 * handled.
1493 */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001494static void dapm_seq_run(struct snd_soc_card *card,
1495 struct list_head *list, int event, bool power_up)
Mark Brownb22ead22009-06-07 12:51:26 +01001496{
1497 struct snd_soc_dapm_widget *w, *n;
Mark Browneb270e92013-10-09 13:52:52 +01001498 struct snd_soc_dapm_context *d;
Mark Brownb22ead22009-06-07 12:51:26 +01001499 LIST_HEAD(pending);
1500 int cur_sort = -1;
Mark Brown20e48592011-01-15 13:40:50 +00001501 int cur_subseq = -1;
Mark Brownb22ead22009-06-07 12:51:26 +01001502 int cur_reg = SND_SOC_NOPM;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001503 struct snd_soc_dapm_context *cur_dapm = NULL;
Mark Brown474b62d2011-01-18 16:14:44 +00001504 int ret, i;
Mark Brown828a8422011-01-15 13:14:30 +00001505 int *sort;
1506
1507 if (power_up)
1508 sort = dapm_up_seq;
1509 else
1510 sort = dapm_down_seq;
Mark Brown163cac02009-06-07 10:12:52 +01001511
Mark Brownb22ead22009-06-07 12:51:26 +01001512 list_for_each_entry_safe(w, n, list, power_list) {
1513 ret = 0;
1514
1515 /* Do we need to apply any queued changes? */
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001516 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
Mark Brown20e48592011-01-15 13:40:50 +00001517 w->dapm != cur_dapm || w->subseq != cur_subseq) {
Banajit Goswami853ed7c2015-04-10 16:50:43 -07001518 if (cur_dapm && !list_empty(&pending))
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001519 dapm_seq_run_coalesced(card, &pending);
Mark Brownb22ead22009-06-07 12:51:26 +01001520
Mark Brown474b62d2011-01-18 16:14:44 +00001521 if (cur_dapm && cur_dapm->seq_notifier) {
1522 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1523 if (sort[i] == cur_sort)
1524 cur_dapm->seq_notifier(cur_dapm,
Mark Brownf85a9e02011-01-26 21:41:28 +00001525 i,
1526 cur_subseq);
Mark Brown474b62d2011-01-18 16:14:44 +00001527 }
1528
Mark Browneb270e92013-10-09 13:52:52 +01001529 if (cur_dapm && w->dapm != cur_dapm)
1530 soc_dapm_async_complete(cur_dapm);
1531
Mark Brownb22ead22009-06-07 12:51:26 +01001532 INIT_LIST_HEAD(&pending);
1533 cur_sort = -1;
Mark Brownb0b3e6f2011-07-16 10:55:08 +09001534 cur_subseq = INT_MIN;
Mark Brownb22ead22009-06-07 12:51:26 +01001535 cur_reg = SND_SOC_NOPM;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001536 cur_dapm = NULL;
Mark Brownb22ead22009-06-07 12:51:26 +01001537 }
1538
Mark Brown163cac02009-06-07 10:12:52 +01001539 switch (w->id) {
1540 case snd_soc_dapm_pre:
1541 if (!w->event)
Mark Brownb22ead22009-06-07 12:51:26 +01001542 list_for_each_entry_safe_continue(w, n, list,
1543 power_list);
Mark Brown163cac02009-06-07 10:12:52 +01001544
Mark Brownb22ead22009-06-07 12:51:26 +01001545 if (event == SND_SOC_DAPM_STREAM_START)
Mark Brown163cac02009-06-07 10:12:52 +01001546 ret = w->event(w,
1547 NULL, SND_SOC_DAPM_PRE_PMU);
Mark Brownb22ead22009-06-07 12:51:26 +01001548 else if (event == SND_SOC_DAPM_STREAM_STOP)
Mark Brown163cac02009-06-07 10:12:52 +01001549 ret = w->event(w,
1550 NULL, SND_SOC_DAPM_PRE_PMD);
Mark Brown163cac02009-06-07 10:12:52 +01001551 break;
1552
1553 case snd_soc_dapm_post:
1554 if (!w->event)
Mark Brownb22ead22009-06-07 12:51:26 +01001555 list_for_each_entry_safe_continue(w, n, list,
1556 power_list);
Mark Brown163cac02009-06-07 10:12:52 +01001557
Mark Brownb22ead22009-06-07 12:51:26 +01001558 if (event == SND_SOC_DAPM_STREAM_START)
Mark Brown163cac02009-06-07 10:12:52 +01001559 ret = w->event(w,
1560 NULL, SND_SOC_DAPM_POST_PMU);
Mark Brownb22ead22009-06-07 12:51:26 +01001561 else if (event == SND_SOC_DAPM_STREAM_STOP)
Mark Brown163cac02009-06-07 10:12:52 +01001562 ret = w->event(w,
1563 NULL, SND_SOC_DAPM_POST_PMD);
Mark Brownb22ead22009-06-07 12:51:26 +01001564 break;
1565
Mark Brown163cac02009-06-07 10:12:52 +01001566 default:
Mark Brown81628102009-06-07 13:21:24 +01001567 /* Queue it up for application */
1568 cur_sort = sort[w->id];
Mark Brown20e48592011-01-15 13:40:50 +00001569 cur_subseq = w->subseq;
Mark Brown81628102009-06-07 13:21:24 +01001570 cur_reg = w->reg;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001571 cur_dapm = w->dapm;
Mark Brown81628102009-06-07 13:21:24 +01001572 list_move(&w->power_list, &pending);
1573 break;
Mark Brown163cac02009-06-07 10:12:52 +01001574 }
Mark Brownb22ead22009-06-07 12:51:26 +01001575
Banajit Goswamib2fac522013-10-10 18:17:43 -07001576 /*
1577 * Add this debug log to keep track of widgets being
1578 * powered-up and powered-down.
1579 */
1580 dev_dbg(w->dapm->dev, "dapm: powering %s widget %s\n",
1581 power_up ? "up" : "down", w->name);
1582
Mark Brownb22ead22009-06-07 12:51:26 +01001583 if (ret < 0)
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02001584 dev_err(w->dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001585 "ASoC: Failed to apply widget power: %d\n", ret);
Mark Brown163cac02009-06-07 10:12:52 +01001586 }
Mark Brownb22ead22009-06-07 12:51:26 +01001587
Banajit Goswami853ed7c2015-04-10 16:50:43 -07001588 if (cur_dapm && !list_empty(&pending))
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001589 dapm_seq_run_coalesced(card, &pending);
Mark Brown474b62d2011-01-18 16:14:44 +00001590
1591 if (cur_dapm && cur_dapm->seq_notifier) {
1592 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1593 if (sort[i] == cur_sort)
1594 cur_dapm->seq_notifier(cur_dapm,
Mark Brownf85a9e02011-01-26 21:41:28 +00001595 i, cur_subseq);
Mark Brown474b62d2011-01-18 16:14:44 +00001596 }
Mark Browneb270e92013-10-09 13:52:52 +01001597
1598 list_for_each_entry(d, &card->dapm_list, list) {
1599 soc_dapm_async_complete(d);
1600 }
Mark Brown163cac02009-06-07 10:12:52 +01001601}
1602
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001603static void dapm_widget_update(struct snd_soc_card *card)
Mark Brown97404f22010-12-14 16:13:57 +00001604{
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001605 struct snd_soc_dapm_update *update = card->update;
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001606 struct snd_soc_dapm_widget_list *wlist;
1607 struct snd_soc_dapm_widget *w = NULL;
1608 unsigned int wi;
Mark Brown97404f22010-12-14 16:13:57 +00001609 int ret;
1610
Lars-Peter Clausen57295072013-08-05 11:27:31 +02001611 if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
Mark Brown97404f22010-12-14 16:13:57 +00001612 return;
1613
Lars-Peter Clausene84357f2013-07-29 17:13:58 +02001614 wlist = dapm_kcontrol_get_wlist(update->kcontrol);
Mark Brown97404f22010-12-14 16:13:57 +00001615
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001616 for (wi = 0; wi < wlist->num_widgets; wi++) {
1617 w = wlist->widgets[wi];
1618
1619 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1620 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1621 if (ret != 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001622 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001623 w->name, ret);
1624 }
Mark Brown97404f22010-12-14 16:13:57 +00001625 }
1626
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001627 if (!w)
1628 return;
1629
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001630 ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
1631 update->val);
Mark Brown97404f22010-12-14 16:13:57 +00001632 if (ret < 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001633 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001634 w->name, ret);
Mark Brown97404f22010-12-14 16:13:57 +00001635
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001636 for (wi = 0; wi < wlist->num_widgets; wi++) {
1637 w = wlist->widgets[wi];
1638
1639 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1640 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1641 if (ret != 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001642 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001643 w->name, ret);
1644 }
Mark Brown97404f22010-12-14 16:13:57 +00001645 }
1646}
1647
Mark Brown9d0624a2011-02-18 11:49:43 -08001648/* Async callback run prior to DAPM sequences - brings to _PREPARE if
1649 * they're changing state.
1650 */
1651static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1652{
1653 struct snd_soc_dapm_context *d = data;
1654 int ret;
Mark Brown97404f22010-12-14 16:13:57 +00001655
Peter Meerwald-Stadlerc8046002016-08-16 16:56:17 +02001656 /* If we're off and we're not supposed to go into STANDBY */
Mark Brown56fba412011-06-04 11:25:10 +01001657 if (d->bias_level == SND_SOC_BIAS_OFF &&
1658 d->target_bias_level != SND_SOC_BIAS_OFF) {
Mark Brownf1aac482011-12-05 15:17:06 +00001659 if (d->dev)
1660 pm_runtime_get_sync(d->dev);
1661
Mark Brown9d0624a2011-02-18 11:49:43 -08001662 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1663 if (ret != 0)
1664 dev_err(d->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001665 "ASoC: Failed to turn on bias: %d\n", ret);
Mark Brown9d0624a2011-02-18 11:49:43 -08001666 }
1667
Lars-Peter Clausence85a4d2014-05-06 10:32:15 +02001668 /* Prepare for a transition to ON or away from ON */
1669 if ((d->target_bias_level == SND_SOC_BIAS_ON &&
1670 d->bias_level != SND_SOC_BIAS_ON) ||
1671 (d->target_bias_level != SND_SOC_BIAS_ON &&
1672 d->bias_level == SND_SOC_BIAS_ON)) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001673 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1674 if (ret != 0)
1675 dev_err(d->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001676 "ASoC: Failed to prepare bias: %d\n", ret);
Mark Brown9d0624a2011-02-18 11:49:43 -08001677 }
1678}
1679
1680/* Async callback run prior to DAPM sequences - brings to their final
1681 * state.
1682 */
1683static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1684{
1685 struct snd_soc_dapm_context *d = data;
1686 int ret;
1687
1688 /* If we just powered the last thing off drop to standby bias */
Mark Brown56fba412011-06-04 11:25:10 +01001689 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1690 (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1691 d->target_bias_level == SND_SOC_BIAS_OFF)) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001692 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1693 if (ret != 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001694 dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
Mark Brown9d0624a2011-02-18 11:49:43 -08001695 ret);
1696 }
1697
1698 /* If we're in standby and can support bias off then do that */
Mark Brown56fba412011-06-04 11:25:10 +01001699 if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1700 d->target_bias_level == SND_SOC_BIAS_OFF) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001701 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1702 if (ret != 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001703 dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
1704 ret);
Mark Brownf1aac482011-12-05 15:17:06 +00001705
1706 if (d->dev)
Mark Brownfb644e92012-01-25 19:53:58 +00001707 pm_runtime_put(d->dev);
Mark Brown9d0624a2011-02-18 11:49:43 -08001708 }
1709
1710 /* If we just powered up then move to active bias */
Mark Brown56fba412011-06-04 11:25:10 +01001711 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1712 d->target_bias_level == SND_SOC_BIAS_ON) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001713 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1714 if (ret != 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001715 dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
Mark Brown9d0624a2011-02-18 11:49:43 -08001716 ret);
1717 }
1718}
Mark Brown97404f22010-12-14 16:13:57 +00001719
Mark Brownfe4fda52011-10-03 22:36:57 +01001720static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
1721 bool power, bool connect)
1722{
1723 /* If a connection is being made or broken then that update
1724 * will have marked the peer dirty, otherwise the widgets are
1725 * not connected and this update has no impact. */
1726 if (!connect)
1727 return;
1728
1729 /* If the peer is already in the state we're moving to then we
1730 * won't have an impact on it. */
1731 if (power != peer->power)
Mark Brown75c1f892011-10-04 22:28:08 +01001732 dapm_mark_dirty(peer, "peer state change");
Mark Brownfe4fda52011-10-03 22:36:57 +01001733}
1734
Mark Brown05623c42011-09-28 17:02:31 +01001735static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
1736 struct list_head *up_list,
1737 struct list_head *down_list)
1738{
Mark Browndb432b42011-10-03 21:06:40 +01001739 struct snd_soc_dapm_path *path;
1740
Mark Brown05623c42011-09-28 17:02:31 +01001741 if (w->power == power)
1742 return;
1743
1744 trace_snd_soc_dapm_widget_power(w, power);
1745
Mark Browndb432b42011-10-03 21:06:40 +01001746 /* If we changed our power state perhaps our neigbours changed
Mark Brownfe4fda52011-10-03 22:36:57 +01001747 * also.
Mark Browndb432b42011-10-03 21:06:40 +01001748 */
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02001749 snd_soc_dapm_widget_for_each_source_path(w, path)
Lars-Peter Clausen7ddd4cd2014-10-20 19:36:34 +02001750 dapm_widget_set_peer_power(path->source, power, path->connect);
1751
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02001752 /* Supplies can't affect their outputs, only their inputs */
1753 if (!w->is_supply) {
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02001754 snd_soc_dapm_widget_for_each_sink_path(w, path)
Lars-Peter Clausen7ddd4cd2014-10-20 19:36:34 +02001755 dapm_widget_set_peer_power(path->sink, power,
1756 path->connect);
Mark Browndb432b42011-10-03 21:06:40 +01001757 }
1758
Mark Brown05623c42011-09-28 17:02:31 +01001759 if (power)
1760 dapm_seq_insert(w, up_list, true);
1761 else
1762 dapm_seq_insert(w, down_list, false);
Mark Brown05623c42011-09-28 17:02:31 +01001763}
1764
Mark Brown7c81beb2011-09-20 22:22:32 +01001765static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1766 struct list_head *up_list,
1767 struct list_head *down_list)
1768{
Mark Brown7c81beb2011-09-20 22:22:32 +01001769 int power;
1770
1771 switch (w->id) {
1772 case snd_soc_dapm_pre:
1773 dapm_seq_insert(w, down_list, false);
1774 break;
1775 case snd_soc_dapm_post:
1776 dapm_seq_insert(w, up_list, true);
1777 break;
1778
1779 default:
Mark Brownd8050022011-09-28 18:28:23 +01001780 power = dapm_widget_power_check(w);
Mark Brown7c81beb2011-09-20 22:22:32 +01001781
Mark Brown05623c42011-09-28 17:02:31 +01001782 dapm_widget_set_power(w, power, up_list, down_list);
Mark Brown7c81beb2011-09-20 22:22:32 +01001783 break;
1784 }
1785}
1786
Lars-Peter Clausen86dbf2a2014-09-04 19:44:06 +02001787static bool dapm_idle_bias_off(struct snd_soc_dapm_context *dapm)
1788{
1789 if (dapm->idle_bias_off)
1790 return true;
1791
1792 switch (snd_power_get_state(dapm->card->snd_card)) {
1793 case SNDRV_CTL_POWER_D3hot:
1794 case SNDRV_CTL_POWER_D3cold:
1795 return dapm->suspend_bias_off;
1796 default:
1797 break;
1798 }
1799
1800 return false;
1801}
1802
Mark Brown42aa3412009-03-01 19:21:10 +00001803/*
Richard Purdie2b97eab2006-10-06 18:32:18 +02001804 * Scan each dapm widget for complete audio path.
1805 * A complete path is a route that has valid endpoints i.e.:-
1806 *
1807 * o DAC to output pin.
Peter Meerwald-Stadlerc8046002016-08-16 16:56:17 +02001808 * o Input pin to ADC.
Richard Purdie2b97eab2006-10-06 18:32:18 +02001809 * o Input pin to Output pin (bypass, sidetone)
1810 * o DAC to ADC (loopback).
1811 */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001812static int dapm_power_widgets(struct snd_soc_card *card, int event)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001813{
1814 struct snd_soc_dapm_widget *w;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001815 struct snd_soc_dapm_context *d;
Mark Brown291f3bb2009-06-07 13:57:17 +01001816 LIST_HEAD(up_list);
1817 LIST_HEAD(down_list);
Dan Williams2955b472012-07-09 19:33:25 -07001818 ASYNC_DOMAIN_EXCLUSIVE(async_domain);
Mark Brown56fba412011-06-04 11:25:10 +01001819 enum snd_soc_bias_level bias;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001820
Mark Brownf9fa2b12014-03-06 16:49:11 +08001821 lockdep_assert_held(&card->dapm_mutex);
1822
Mark Brown84e90932010-11-04 00:07:02 -04001823 trace_snd_soc_dapm_start(card);
Banajit Goswami853ed7c2015-04-10 16:50:43 -07001824 mutex_lock(&card->dapm_power_mutex);
Mark Brown84e90932010-11-04 00:07:02 -04001825
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);
Banajit Goswami853ed7c2015-04-10 16:50:43 -07001943 mutex_unlock(&card->dapm_power_mutex);
Mark Browncb507e72009-07-08 18:54:57 +01001944
Mark Brown84e90932010-11-04 00:07:02 -04001945 trace_snd_soc_dapm_done(card);
1946
Mark Brown42aa3412009-03-01 19:21:10 +00001947 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001948}
1949
Mark Brown79fb9382009-08-21 16:38:13 +01001950#ifdef CONFIG_DEBUG_FS
Mark Brown79fb9382009-08-21 16:38:13 +01001951static ssize_t dapm_widget_power_read_file(struct file *file,
1952 char __user *user_buf,
1953 size_t count, loff_t *ppos)
1954{
1955 struct snd_soc_dapm_widget *w = file->private_data;
Lars-Peter Clausene50b1e02015-07-06 17:01:24 +02001956 struct snd_soc_card *card = w->dapm->card;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001957 enum snd_soc_dapm_direction dir, rdir;
Mark Brown79fb9382009-08-21 16:38:13 +01001958 char *buf;
1959 int in, out;
1960 ssize_t ret;
1961 struct snd_soc_dapm_path *p = NULL;
1962
1963 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1964 if (!buf)
1965 return -ENOMEM;
1966
Lars-Peter Clausene50b1e02015-07-06 17:01:24 +02001967 mutex_lock(&card->dapm_mutex);
1968
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02001969 /* Supply widgets are not handled by is_connected_{input,output}_ep() */
1970 if (w->is_supply) {
1971 in = 0;
1972 out = 0;
1973 } else {
Piotr Stankiewicz67420642016-05-13 17:03:55 +01001974 in = is_connected_input_ep(w, NULL, NULL);
1975 out = is_connected_output_ep(w, NULL, NULL);
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02001976 }
Mark Brown79fb9382009-08-21 16:38:13 +01001977
Mark Brownf13ebad2012-03-03 18:01:01 +00001978 ret = snprintf(buf, PAGE_SIZE, "%s: %s%s in %d out %d",
1979 w->name, w->power ? "On" : "Off",
1980 w->force ? " (forced)" : "", in, out);
Mark Brown79fb9382009-08-21 16:38:13 +01001981
Mark Brownd033c362009-12-04 15:25:56 +00001982 if (w->reg >= 0)
1983 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001984 " - R%d(0x%x) mask 0x%x",
1985 w->reg, w->reg, w->mask << w->shift);
Mark Brownd033c362009-12-04 15:25:56 +00001986
1987 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1988
Mark Brown3eef08b2009-09-14 16:49:00 +01001989 if (w->sname)
1990 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1991 w->sname,
1992 w->active ? "active" : "inactive");
Mark Brown79fb9382009-08-21 16:38:13 +01001993
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001994 snd_soc_dapm_for_each_direction(dir) {
1995 rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
1996 snd_soc_dapm_widget_for_each_path(w, dir, p) {
1997 if (p->connected && !p->connected(w, p->node[rdir]))
1998 continue;
Mark Brown215edda2009-09-08 18:59:05 +01001999
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002000 if (!p->connect)
2001 continue;
Mark Brown215edda2009-09-08 18:59:05 +01002002
Mark Brown79fb9382009-08-21 16:38:13 +01002003 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002004 " %s \"%s\" \"%s\"\n",
2005 (rdir == SND_SOC_DAPM_DIR_IN) ? "in" : "out",
Mark Brown79fb9382009-08-21 16:38:13 +01002006 p->name ? p->name : "static",
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002007 p->node[rdir]->name);
2008 }
Mark Brown79fb9382009-08-21 16:38:13 +01002009 }
2010
Lars-Peter Clausene50b1e02015-07-06 17:01:24 +02002011 mutex_unlock(&card->dapm_mutex);
2012
Mark Brown79fb9382009-08-21 16:38:13 +01002013 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
2014
2015 kfree(buf);
2016 return ret;
2017}
2018
2019static const struct file_operations dapm_widget_power_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -07002020 .open = simple_open,
Mark Brown79fb9382009-08-21 16:38:13 +01002021 .read = dapm_widget_power_read_file,
Arnd Bergmann6038f372010-08-15 18:52:59 +02002022 .llseek = default_llseek,
Mark Brown79fb9382009-08-21 16:38:13 +01002023};
2024
Mark Brownef49e4f2011-04-04 20:48:13 +09002025static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
2026 size_t count, loff_t *ppos)
2027{
2028 struct snd_soc_dapm_context *dapm = file->private_data;
2029 char *level;
2030
2031 switch (dapm->bias_level) {
2032 case SND_SOC_BIAS_ON:
2033 level = "On\n";
2034 break;
2035 case SND_SOC_BIAS_PREPARE:
2036 level = "Prepare\n";
2037 break;
2038 case SND_SOC_BIAS_STANDBY:
2039 level = "Standby\n";
2040 break;
2041 case SND_SOC_BIAS_OFF:
2042 level = "Off\n";
2043 break;
2044 default:
Takashi Iwaia6ed0602013-11-06 11:07:19 +01002045 WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
Mark Brownef49e4f2011-04-04 20:48:13 +09002046 level = "Unknown\n";
2047 break;
2048 }
2049
2050 return simple_read_from_buffer(user_buf, count, ppos, level,
2051 strlen(level));
2052}
2053
2054static const struct file_operations dapm_bias_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -07002055 .open = simple_open,
Mark Brownef49e4f2011-04-04 20:48:13 +09002056 .read = dapm_bias_read_file,
2057 .llseek = default_llseek,
2058};
2059
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002060void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2061 struct dentry *parent)
Mark Brown79fb9382009-08-21 16:38:13 +01002062{
Mark Brown79fb9382009-08-21 16:38:13 +01002063 struct dentry *d;
2064
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +02002065 if (!parent)
2066 return;
2067
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002068 dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
2069
2070 if (!dapm->debugfs_dapm) {
Liam Girdwoodf1e90af2012-03-06 18:13:25 +00002071 dev_warn(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002072 "ASoC: Failed to create DAPM debugfs directory\n");
Mark Brown79fb9382009-08-21 16:38:13 +01002073 return;
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002074 }
Mark Brown79fb9382009-08-21 16:38:13 +01002075
Mark Brownef49e4f2011-04-04 20:48:13 +09002076 d = debugfs_create_file("bias_level", 0444,
2077 dapm->debugfs_dapm, dapm,
2078 &dapm_bias_fops);
2079 if (!d)
2080 dev_warn(dapm->dev,
2081 "ASoC: Failed to create bias level debugfs file\n");
Mark Brown79fb9382009-08-21 16:38:13 +01002082}
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002083
2084static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2085{
2086 struct snd_soc_dapm_context *dapm = w->dapm;
2087 struct dentry *d;
2088
2089 if (!dapm->debugfs_dapm || !w->name)
2090 return;
2091
2092 d = debugfs_create_file(w->name, 0444,
2093 dapm->debugfs_dapm, w,
2094 &dapm_widget_power_fops);
2095 if (!d)
2096 dev_warn(w->dapm->dev,
2097 "ASoC: Failed to create %s debugfs file\n",
2098 w->name);
2099}
2100
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02002101static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2102{
2103 debugfs_remove_recursive(dapm->debugfs_dapm);
2104}
2105
Mark Brown79fb9382009-08-21 16:38:13 +01002106#else
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002107void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2108 struct dentry *parent)
Mark Brown79fb9382009-08-21 16:38:13 +01002109{
2110}
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002111
2112static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2113{
2114}
2115
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02002116static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2117{
2118}
2119
Mark Brown79fb9382009-08-21 16:38:13 +01002120#endif
2121
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002122/*
2123 * soc_dapm_connect_path() - Connects or disconnects a path
2124 * @path: The path to update
2125 * @connect: The new connect state of the path. True if the path is connected,
Peter Meerwald-Stadlerc8046002016-08-16 16:56:17 +02002126 * false if it is disconnected.
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002127 * @reason: The reason why the path changed (for debugging only)
2128 */
2129static void soc_dapm_connect_path(struct snd_soc_dapm_path *path,
2130 bool connect, const char *reason)
2131{
2132 if (path->connect == connect)
2133 return;
2134
2135 path->connect = connect;
2136 dapm_mark_dirty(path->source, reason);
2137 dapm_mark_dirty(path->sink, reason);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002138 dapm_path_invalidate(path);
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002139}
2140
Richard Purdie2b97eab2006-10-06 18:32:18 +02002141/* test and update the power status of a mux widget */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002142static int soc_dapm_mux_update_power(struct snd_soc_card *card,
Liam Girdwood40f02cd2012-02-06 16:05:14 +00002143 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002144{
2145 struct snd_soc_dapm_path *path;
2146 int found = 0;
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002147 bool connect;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002148
Mark Brownf9fa2b12014-03-06 16:49:11 +08002149 lockdep_assert_held(&card->dapm_mutex);
2150
Richard Purdie2b97eab2006-10-06 18:32:18 +02002151 /* find dapm widget path assoc with kcontrol */
Lars-Peter Clausen5106b922013-07-29 17:14:00 +02002152 dapm_kcontrol_for_each_path(path, kcontrol) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002153 found = 1;
2154 /* we now need to match the string in the enum to the path */
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002155 if (!(strcmp(path->name, e->texts[mux])))
2156 connect = true;
2157 else
2158 connect = false;
2159
2160 soc_dapm_connect_path(path, connect, "mux update");
Richard Purdie2b97eab2006-10-06 18:32:18 +02002161 }
2162
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002163 if (found)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002164 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002165
Liam Girdwood618dae12012-04-25 12:12:51 +01002166 return found;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002167}
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002168
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002169int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausen6b3fc032013-07-24 15:27:38 +02002170 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
2171 struct snd_soc_dapm_update *update)
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002172{
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002173 struct snd_soc_card *card = dapm->card;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002174 int ret;
2175
Liam Girdwood3cd04342012-03-09 12:02:08 +00002176 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002177 card->update = update;
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002178 ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002179 card->update = NULL;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002180 mutex_unlock(&card->dapm_mutex);
Liam Girdwood618dae12012-04-25 12:12:51 +01002181 if (ret > 0)
Lars-Peter Clausenc3f48ae2013-07-24 15:27:36 +02002182 soc_dpcm_runtime_update(card);
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002183 return ret;
2184}
Liam Girdwood40f02cd2012-02-06 16:05:14 +00002185EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002186
Milan plzik1b075e32008-01-10 14:39:46 +01002187/* test and update the power status of a mixer or switch widget */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002188static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
Mark Brown283375c2009-12-07 18:09:03 +00002189 struct snd_kcontrol *kcontrol, int connect)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002190{
2191 struct snd_soc_dapm_path *path;
2192 int found = 0;
2193
Mark Brownf9fa2b12014-03-06 16:49:11 +08002194 lockdep_assert_held(&card->dapm_mutex);
2195
Richard Purdie2b97eab2006-10-06 18:32:18 +02002196 /* find dapm widget path assoc with kcontrol */
Lars-Peter Clausen5106b922013-07-29 17:14:00 +02002197 dapm_kcontrol_for_each_path(path, kcontrol) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002198 found = 1;
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002199 soc_dapm_connect_path(path, connect, "mixer update");
Richard Purdie2b97eab2006-10-06 18:32:18 +02002200 }
2201
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002202 if (found)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002203 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002204
Liam Girdwood618dae12012-04-25 12:12:51 +01002205 return found;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002206}
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002207
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002208int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausen6b3fc032013-07-24 15:27:38 +02002209 struct snd_kcontrol *kcontrol, int connect,
2210 struct snd_soc_dapm_update *update)
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002211{
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002212 struct snd_soc_card *card = dapm->card;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002213 int ret;
2214
Liam Girdwood3cd04342012-03-09 12:02:08 +00002215 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002216 card->update = update;
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002217 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002218 card->update = NULL;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002219 mutex_unlock(&card->dapm_mutex);
Liam Girdwood618dae12012-04-25 12:12:51 +01002220 if (ret > 0)
Lars-Peter Clausenc3f48ae2013-07-24 15:27:36 +02002221 soc_dpcm_runtime_update(card);
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002222 return ret;
2223}
Liam Girdwood40f02cd2012-02-06 16:05:14 +00002224EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002225
Lars-Peter Clausenb3c25fb2015-07-06 15:38:10 +02002226static ssize_t dapm_widget_show_component(struct snd_soc_component *cmpnt,
2227 char *buf)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002228{
Lars-Peter Clausenb3c25fb2015-07-06 15:38:10 +02002229 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002230 struct snd_soc_dapm_widget *w;
2231 int count = 0;
2232 char *state = "not set";
2233
Mark Brown47325072016-03-18 12:04:23 +00002234 /* card won't be set for the dummy component, as a spot fix
2235 * we're checking for that case specifically here but in future
2236 * we will ensure that the dummy component looks like others.
2237 */
2238 if (!cmpnt->card)
2239 return 0;
2240
Lars-Peter Clausenb3c25fb2015-07-06 15:38:10 +02002241 list_for_each_entry(w, &cmpnt->card->widgets, list) {
2242 if (w->dapm != dapm)
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002243 continue;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002244
Peter Meerwald-Stadlerc8046002016-08-16 16:56:17 +02002245 /* only display widgets that burn power */
Richard Purdie2b97eab2006-10-06 18:32:18 +02002246 switch (w->id) {
2247 case snd_soc_dapm_hp:
2248 case snd_soc_dapm_mic:
2249 case snd_soc_dapm_spk:
2250 case snd_soc_dapm_line:
2251 case snd_soc_dapm_micbias:
2252 case snd_soc_dapm_dac:
2253 case snd_soc_dapm_adc:
2254 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06002255 case snd_soc_dapm_out_drv:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002256 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00002257 case snd_soc_dapm_mixer_named_ctl:
Mark Brown246d0a12009-04-22 18:24:55 +01002258 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00002259 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02002260 case snd_soc_dapm_clock_supply:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002261 if (w->name)
2262 count += sprintf(buf + count, "%s: %s\n",
2263 w->name, w->power ? "On":"Off");
2264 break;
2265 default:
2266 break;
2267 }
2268 }
2269
Lars-Peter Clausenb3c25fb2015-07-06 15:38:10 +02002270 switch (snd_soc_dapm_get_bias_level(dapm)) {
Mark Brown0be98982008-05-19 12:31:28 +02002271 case SND_SOC_BIAS_ON:
2272 state = "On";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002273 break;
Mark Brown0be98982008-05-19 12:31:28 +02002274 case SND_SOC_BIAS_PREPARE:
2275 state = "Prepare";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002276 break;
Mark Brown0be98982008-05-19 12:31:28 +02002277 case SND_SOC_BIAS_STANDBY:
2278 state = "Standby";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002279 break;
Mark Brown0be98982008-05-19 12:31:28 +02002280 case SND_SOC_BIAS_OFF:
2281 state = "Off";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002282 break;
2283 }
2284 count += sprintf(buf + count, "PM State: %s\n", state);
2285
2286 return count;
2287}
2288
Benoit Cousson44ba2642014-07-08 23:19:36 +02002289/* show dapm widget status in sys fs */
2290static ssize_t dapm_widget_show(struct device *dev,
2291 struct device_attribute *attr, char *buf)
2292{
2293 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
2294 int i, count = 0;
2295
Lars-Peter Clausene50b1e02015-07-06 17:01:24 +02002296 mutex_lock(&rtd->card->dapm_mutex);
2297
Benoit Cousson44ba2642014-07-08 23:19:36 +02002298 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausenb3c25fb2015-07-06 15:38:10 +02002299 struct snd_soc_component *cmpnt = rtd->codec_dais[i]->component;
2300
2301 count += dapm_widget_show_component(cmpnt, buf + count);
Benoit Cousson44ba2642014-07-08 23:19:36 +02002302 }
2303
Lars-Peter Clausene50b1e02015-07-06 17:01:24 +02002304 mutex_unlock(&rtd->card->dapm_mutex);
2305
Benoit Cousson44ba2642014-07-08 23:19:36 +02002306 return count;
2307}
2308
Richard Purdie2b97eab2006-10-06 18:32:18 +02002309static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
2310
Takashi Iwaid29697d2015-01-30 20:16:37 +01002311struct attribute *soc_dapm_dev_attrs[] = {
2312 &dev_attr_dapm_widget.attr,
2313 NULL
2314};
Richard Purdie2b97eab2006-10-06 18:32:18 +02002315
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002316static void dapm_free_path(struct snd_soc_dapm_path *path)
2317{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002318 list_del(&path->list_node[SND_SOC_DAPM_DIR_IN]);
2319 list_del(&path->list_node[SND_SOC_DAPM_DIR_OUT]);
Lars-Peter Clausen5106b922013-07-29 17:14:00 +02002320 list_del(&path->list_kcontrol);
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002321 list_del(&path->list);
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002322 kfree(path);
2323}
2324
Lars-Peter Clausenb97e2692015-07-21 18:11:07 +02002325void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w)
2326{
2327 struct snd_soc_dapm_path *p, *next_p;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002328 enum snd_soc_dapm_direction dir;
Lars-Peter Clausenb97e2692015-07-21 18:11:07 +02002329
2330 list_del(&w->list);
2331 /*
2332 * remove source and sink paths associated to this widget.
2333 * While removing the path, remove reference to it from both
2334 * source and sink widgets so that path is removed only once.
2335 */
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002336 snd_soc_dapm_for_each_direction(dir) {
2337 snd_soc_dapm_widget_for_each_path_safe(w, dir, p, next_p)
2338 dapm_free_path(p);
2339 }
Lars-Peter Clausenb97e2692015-07-21 18:11:07 +02002340
2341 kfree(w->kcontrols);
Lars-Peter Clausen48068962015-07-21 18:11:08 +02002342 kfree_const(w->name);
Lars-Peter Clausenb97e2692015-07-21 18:11:07 +02002343 kfree(w);
2344}
2345
Jyri Sarhafd589a12015-11-10 18:12:42 +02002346void snd_soc_dapm_reset_cache(struct snd_soc_dapm_context *dapm)
2347{
2348 dapm->path_sink_cache.widget = NULL;
2349 dapm->path_source_cache.widget = NULL;
2350}
2351
Richard Purdie2b97eab2006-10-06 18:32:18 +02002352/* free all dapm widgets and resources */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002353static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002354{
2355 struct snd_soc_dapm_widget *w, *next_w;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002356
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002357 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
2358 if (w->dapm != dapm)
2359 continue;
Lars-Peter Clausenb97e2692015-07-21 18:11:07 +02002360 snd_soc_dapm_free_widget(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002361 }
Jyri Sarhafd589a12015-11-10 18:12:42 +02002362 snd_soc_dapm_reset_cache(dapm);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002363}
2364
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002365static struct snd_soc_dapm_widget *dapm_find_widget(
2366 struct snd_soc_dapm_context *dapm, const char *pin,
2367 bool search_other_contexts)
2368{
2369 struct snd_soc_dapm_widget *w;
2370 struct snd_soc_dapm_widget *fallback = NULL;
2371
2372 list_for_each_entry(w, &dapm->card->widgets, list) {
2373 if (!strcmp(w->name, pin)) {
2374 if (w->dapm == dapm)
2375 return w;
2376 else
2377 fallback = w;
2378 }
2379 }
2380
2381 if (search_other_contexts)
2382 return fallback;
2383
2384 return NULL;
2385}
2386
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002387static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
Mark Brown16499232009-01-07 18:25:13 +00002388 const char *pin, int status)
Liam Girdwooda5302182008-07-07 13:35:17 +01002389{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002390 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Liam Girdwooda5302182008-07-07 13:35:17 +01002391
Mark Brownf9fa2b12014-03-06 16:49:11 +08002392 dapm_assert_locked(dapm);
2393
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002394 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002395 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002396 return -EINVAL;
Liam Girdwooda5302182008-07-07 13:35:17 +01002397 }
2398
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002399 if (w->connected != status) {
Mark Brown1a8b2d92012-02-16 11:50:07 -08002400 dapm_mark_dirty(w, "pin configuration");
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002401 dapm_widget_invalidate_input_paths(w);
2402 dapm_widget_invalidate_output_paths(w);
2403 }
Mark Brown1a8b2d92012-02-16 11:50:07 -08002404
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002405 w->connected = status;
2406 if (status == 0)
2407 w->force = 0;
Mark Brown0d867332011-04-06 11:38:14 +09002408
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002409 return 0;
Liam Girdwooda5302182008-07-07 13:35:17 +01002410}
2411
Richard Purdie2b97eab2006-10-06 18:32:18 +02002412/**
Charles Keepax3eb29df2014-02-18 15:22:15 +00002413 * snd_soc_dapm_sync_unlocked - scan and power dapm paths
2414 * @dapm: DAPM context
2415 *
2416 * Walks all dapm audio paths and powers widgets according to their
2417 * stream or path usage.
2418 *
2419 * Requires external locking.
2420 *
2421 * Returns 0 for success.
2422 */
2423int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
2424{
2425 /*
2426 * Suppress early reports (eg, jacks syncing their state) to avoid
2427 * silly DAPM runs during card startup.
2428 */
2429 if (!dapm->card || !dapm->card->instantiated)
2430 return 0;
2431
2432 return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
2433}
2434EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked);
2435
2436/**
Liam Girdwooda5302182008-07-07 13:35:17 +01002437 * snd_soc_dapm_sync - scan and power dapm paths
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002438 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02002439 *
2440 * Walks all dapm audio paths and powers widgets according to their
2441 * stream or path usage.
2442 *
2443 * Returns 0 for success.
2444 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002445int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002446{
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002447 int ret;
2448
Liam Girdwood3cd04342012-03-09 12:02:08 +00002449 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Charles Keepax3eb29df2014-02-18 15:22:15 +00002450 ret = snd_soc_dapm_sync_unlocked(dapm);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002451 mutex_unlock(&dapm->card->dapm_mutex);
2452 return ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002453}
Liam Girdwooda5302182008-07-07 13:35:17 +01002454EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002455
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002456/*
2457 * dapm_update_widget_flags() - Re-compute widget sink and source flags
2458 * @w: The widget for which to update the flags
2459 *
2460 * Some widgets have a dynamic category which depends on which neighbors they
2461 * are connected to. This function update the category for these widgets.
2462 *
2463 * This function must be called whenever a path is added or removed to a widget.
2464 */
2465static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
2466{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002467 enum snd_soc_dapm_direction dir;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002468 struct snd_soc_dapm_path *p;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002469 unsigned int ep;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002470
2471 switch (w->id) {
2472 case snd_soc_dapm_input:
Peter Meerwald-Stadlerc8046002016-08-16 16:56:17 +02002473 /* On a fully routed card an input is never a source */
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01002474 if (w->dapm->card->fully_routed)
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002475 return;
2476 ep = SND_SOC_DAPM_EP_SOURCE;
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02002477 snd_soc_dapm_widget_for_each_source_path(w, p) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002478 if (p->source->id == snd_soc_dapm_micbias ||
2479 p->source->id == snd_soc_dapm_mic ||
2480 p->source->id == snd_soc_dapm_line ||
2481 p->source->id == snd_soc_dapm_output) {
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002482 ep = 0;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002483 break;
2484 }
2485 }
2486 break;
2487 case snd_soc_dapm_output:
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01002488 /* On a fully routed card a output is never a sink */
2489 if (w->dapm->card->fully_routed)
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002490 return;
2491 ep = SND_SOC_DAPM_EP_SINK;
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02002492 snd_soc_dapm_widget_for_each_sink_path(w, p) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002493 if (p->sink->id == snd_soc_dapm_spk ||
2494 p->sink->id == snd_soc_dapm_hp ||
2495 p->sink->id == snd_soc_dapm_line ||
2496 p->sink->id == snd_soc_dapm_input) {
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002497 ep = 0;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002498 break;
2499 }
2500 }
2501 break;
2502 case snd_soc_dapm_line:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002503 ep = 0;
2504 snd_soc_dapm_for_each_direction(dir) {
2505 if (!list_empty(&w->edges[dir]))
2506 ep |= SND_SOC_DAPM_DIR_TO_EP(dir);
2507 }
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002508 break;
2509 default:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002510 return;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002511 }
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002512
2513 w->is_ep = ep;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002514}
2515
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002516static int snd_soc_dapm_check_dynamic_path(struct snd_soc_dapm_context *dapm,
2517 struct snd_soc_dapm_widget *source, struct snd_soc_dapm_widget *sink,
2518 const char *control)
2519{
2520 bool dynamic_source = false;
2521 bool dynamic_sink = false;
2522
2523 if (!control)
2524 return 0;
2525
2526 switch (source->id) {
2527 case snd_soc_dapm_demux:
2528 dynamic_source = true;
2529 break;
2530 default:
2531 break;
2532 }
2533
2534 switch (sink->id) {
2535 case snd_soc_dapm_mux:
2536 case snd_soc_dapm_switch:
2537 case snd_soc_dapm_mixer:
2538 case snd_soc_dapm_mixer_named_ctl:
2539 dynamic_sink = true;
2540 break;
2541 default:
2542 break;
2543 }
2544
2545 if (dynamic_source && dynamic_sink) {
2546 dev_err(dapm->dev,
2547 "Direct connection between demux and mixer/mux not supported for path %s -> [%s] -> %s\n",
2548 source->name, control, sink->name);
2549 return -EINVAL;
2550 } else if (!dynamic_source && !dynamic_sink) {
2551 dev_err(dapm->dev,
2552 "Control not supported for path %s -> [%s] -> %s\n",
2553 source->name, control, sink->name);
2554 return -EINVAL;
2555 }
2556
2557 return 0;
2558}
2559
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002560static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
2561 struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
2562 const char *control,
2563 int (*connected)(struct snd_soc_dapm_widget *source,
2564 struct snd_soc_dapm_widget *sink))
Richard Purdie2b97eab2006-10-06 18:32:18 +02002565{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002566 struct snd_soc_dapm_widget *widgets[2];
2567 enum snd_soc_dapm_direction dir;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002568 struct snd_soc_dapm_path *path;
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002569 int ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002570
Lars-Peter Clausene409dfb2014-10-25 17:42:02 +02002571 if (wsink->is_supply && !wsource->is_supply) {
2572 dev_err(dapm->dev,
2573 "Connecting non-supply widget to supply widget is not supported (%s -> %s)\n",
2574 wsource->name, wsink->name);
2575 return -EINVAL;
2576 }
2577
2578 if (connected && !wsource->is_supply) {
2579 dev_err(dapm->dev,
2580 "connected() callback only supported for supply widgets (%s -> %s)\n",
2581 wsource->name, wsink->name);
2582 return -EINVAL;
2583 }
2584
2585 if (wsource->is_supply && control) {
2586 dev_err(dapm->dev,
2587 "Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
2588 wsource->name, control, wsink->name);
2589 return -EINVAL;
2590 }
2591
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002592 ret = snd_soc_dapm_check_dynamic_path(dapm, wsource, wsink, control);
2593 if (ret)
2594 return ret;
2595
Richard Purdie2b97eab2006-10-06 18:32:18 +02002596 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
2597 if (!path)
2598 return -ENOMEM;
2599
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002600 path->node[SND_SOC_DAPM_DIR_IN] = wsource;
2601 path->node[SND_SOC_DAPM_DIR_OUT] = wsink;
2602 widgets[SND_SOC_DAPM_DIR_IN] = wsource;
2603 widgets[SND_SOC_DAPM_DIR_OUT] = wsink;
2604
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002605 path->connected = connected;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002606 INIT_LIST_HEAD(&path->list);
Mark Brown69c2d342013-08-13 00:20:36 +01002607 INIT_LIST_HEAD(&path->list_kcontrol);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002608
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02002609 if (wsource->is_supply || wsink->is_supply)
2610 path->is_supply = 1;
2611
Richard Purdie2b97eab2006-10-06 18:32:18 +02002612 /* connect static paths */
2613 if (control == NULL) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002614 path->connect = 1;
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002615 } else {
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002616 switch (wsource->id) {
2617 case snd_soc_dapm_demux:
2618 ret = dapm_connect_mux(dapm, path, control, wsource);
2619 if (ret)
2620 goto err;
2621 break;
2622 default:
2623 break;
2624 }
2625
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002626 switch (wsink->id) {
2627 case snd_soc_dapm_mux:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002628 ret = dapm_connect_mux(dapm, path, control, wsink);
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002629 if (ret != 0)
2630 goto err;
2631 break;
2632 case snd_soc_dapm_switch:
2633 case snd_soc_dapm_mixer:
2634 case snd_soc_dapm_mixer_named_ctl:
2635 ret = dapm_connect_mixer(dapm, path, control);
2636 if (ret != 0)
2637 goto err;
2638 break;
2639 default:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002640 break;
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002641 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02002642 }
2643
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002644 list_add(&path->list, &dapm->card->paths);
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002645 snd_soc_dapm_for_each_direction(dir)
2646 list_add(&path->list_node[dir], &widgets[dir]->edges[dir]);
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002647
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002648 snd_soc_dapm_for_each_direction(dir) {
2649 dapm_update_widget_flags(widgets[dir]);
2650 dapm_mark_dirty(widgets[dir], "Route added");
2651 }
Mark Brownfabd0382012-07-05 17:20:06 +01002652
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002653 if (dapm->card->instantiated && path->connect)
2654 dapm_path_invalidate(path);
2655
Richard Purdie2b97eab2006-10-06 18:32:18 +02002656 return 0;
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002657err:
2658 kfree(path);
2659 return ret;
2660}
Richard Purdie2b97eab2006-10-06 18:32:18 +02002661
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002662static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausena4e91542014-05-07 16:20:25 +02002663 const struct snd_soc_dapm_route *route)
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002664{
2665 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
2666 struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
2667 const char *sink;
2668 const char *source;
2669 char prefixed_sink[80];
2670 char prefixed_source[80];
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002671 const char *prefix;
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002672 int ret;
2673
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002674 prefix = soc_dapm_prefix(dapm);
2675 if (prefix) {
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002676 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002677 prefix, route->sink);
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002678 sink = prefixed_sink;
2679 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002680 prefix, route->source);
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002681 source = prefixed_source;
2682 } else {
2683 sink = route->sink;
2684 source = route->source;
2685 }
2686
Charles Keepax45a110a2015-05-11 13:50:30 +01002687 wsource = dapm_wcache_lookup(&dapm->path_source_cache, source);
2688 wsink = dapm_wcache_lookup(&dapm->path_sink_cache, sink);
2689
2690 if (wsink && wsource)
2691 goto skip_search;
2692
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002693 /*
2694 * find src and dest widgets over all widgets but favor a widget from
2695 * current DAPM context
2696 */
2697 list_for_each_entry(w, &dapm->card->widgets, list) {
2698 if (!wsink && !(strcmp(w->name, sink))) {
2699 wtsink = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002700 if (w->dapm == dapm) {
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002701 wsink = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002702 if (wsource)
2703 break;
2704 }
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002705 continue;
2706 }
2707 if (!wsource && !(strcmp(w->name, source))) {
2708 wtsource = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002709 if (w->dapm == dapm) {
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002710 wsource = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002711 if (wsink)
2712 break;
2713 }
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002714 }
2715 }
2716 /* use widget from another DAPM context if not found from this */
2717 if (!wsink)
2718 wsink = wtsink;
2719 if (!wsource)
2720 wsource = wtsource;
2721
2722 if (wsource == NULL) {
2723 dev_err(dapm->dev, "ASoC: no source widget found for %s\n",
2724 route->source);
2725 return -ENODEV;
2726 }
2727 if (wsink == NULL) {
2728 dev_err(dapm->dev, "ASoC: no sink widget found for %s\n",
2729 route->sink);
2730 return -ENODEV;
2731 }
2732
Charles Keepax45a110a2015-05-11 13:50:30 +01002733skip_search:
2734 dapm_wcache_update(&dapm->path_sink_cache, wsink);
2735 dapm_wcache_update(&dapm->path_source_cache, wsource);
2736
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002737 ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,
2738 route->connected);
2739 if (ret)
2740 goto err;
2741
2742 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002743err:
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002744 dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n",
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002745 source, route->control, sink);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002746 return ret;
2747}
Mark Brown105f1c22008-05-13 14:52:19 +02002748
Mark Brownefcc3c62012-07-05 17:24:19 +01002749static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
2750 const struct snd_soc_dapm_route *route)
2751{
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002752 struct snd_soc_dapm_widget *wsource, *wsink;
Mark Brownefcc3c62012-07-05 17:24:19 +01002753 struct snd_soc_dapm_path *path, *p;
2754 const char *sink;
2755 const char *source;
2756 char prefixed_sink[80];
2757 char prefixed_source[80];
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002758 const char *prefix;
Mark Brownefcc3c62012-07-05 17:24:19 +01002759
2760 if (route->control) {
2761 dev_err(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002762 "ASoC: Removal of routes with controls not supported\n");
Mark Brownefcc3c62012-07-05 17:24:19 +01002763 return -EINVAL;
2764 }
2765
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002766 prefix = soc_dapm_prefix(dapm);
2767 if (prefix) {
Mark Brownefcc3c62012-07-05 17:24:19 +01002768 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002769 prefix, route->sink);
Mark Brownefcc3c62012-07-05 17:24:19 +01002770 sink = prefixed_sink;
2771 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002772 prefix, route->source);
Mark Brownefcc3c62012-07-05 17:24:19 +01002773 source = prefixed_source;
2774 } else {
2775 sink = route->sink;
2776 source = route->source;
2777 }
2778
2779 path = NULL;
2780 list_for_each_entry(p, &dapm->card->paths, list) {
2781 if (strcmp(p->source->name, source) != 0)
2782 continue;
2783 if (strcmp(p->sink->name, sink) != 0)
2784 continue;
2785 path = p;
2786 break;
2787 }
2788
2789 if (path) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002790 wsource = path->source;
2791 wsink = path->sink;
2792
2793 dapm_mark_dirty(wsource, "Route removed");
2794 dapm_mark_dirty(wsink, "Route removed");
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002795 if (path->connect)
2796 dapm_path_invalidate(path);
Mark Brownefcc3c62012-07-05 17:24:19 +01002797
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002798 dapm_free_path(path);
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002799
2800 /* Update any path related flags */
2801 dapm_update_widget_flags(wsource);
2802 dapm_update_widget_flags(wsink);
Mark Brownefcc3c62012-07-05 17:24:19 +01002803 } else {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002804 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
Mark Brownefcc3c62012-07-05 17:24:19 +01002805 source, sink);
2806 }
2807
2808 return 0;
2809}
2810
Mark Brown105f1c22008-05-13 14:52:19 +02002811/**
Mark Brown105f1c22008-05-13 14:52:19 +02002812 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002813 * @dapm: DAPM context
Mark Brown105f1c22008-05-13 14:52:19 +02002814 * @route: audio routes
2815 * @num: number of routes
2816 *
2817 * Connects 2 dapm widgets together via a named audio path. The sink is
2818 * the widget receiving the audio signal, whilst the source is the sender
2819 * of the audio signal.
2820 *
2821 * Returns 0 for success else error. On error all resources can be freed
2822 * with a call to snd_soc_card_free().
2823 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002824int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
Mark Brown105f1c22008-05-13 14:52:19 +02002825 const struct snd_soc_dapm_route *route, int num)
2826{
Mark Brown62d4a4b2012-06-22 12:21:49 +01002827 int i, r, ret = 0;
Mark Brown105f1c22008-05-13 14:52:19 +02002828
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002829 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brown105f1c22008-05-13 14:52:19 +02002830 for (i = 0; i < num; i++) {
Lars-Peter Clausena4e91542014-05-07 16:20:25 +02002831 r = snd_soc_dapm_add_route(dapm, route);
Mark Brown62d4a4b2012-06-22 12:21:49 +01002832 if (r < 0) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002833 dev_err(dapm->dev, "ASoC: Failed to add route %s -> %s -> %s\n",
2834 route->source,
2835 route->control ? route->control : "direct",
2836 route->sink);
Mark Brown62d4a4b2012-06-22 12:21:49 +01002837 ret = r;
Mark Brown105f1c22008-05-13 14:52:19 +02002838 }
2839 route++;
2840 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002841 mutex_unlock(&dapm->card->dapm_mutex);
Mark Brown105f1c22008-05-13 14:52:19 +02002842
Dan Carpenter60884c22012-04-13 22:25:43 +03002843 return ret;
Mark Brown105f1c22008-05-13 14:52:19 +02002844}
2845EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
2846
Mark Brownefcc3c62012-07-05 17:24:19 +01002847/**
2848 * snd_soc_dapm_del_routes - Remove routes between DAPM widgets
2849 * @dapm: DAPM context
2850 * @route: audio routes
2851 * @num: number of routes
2852 *
2853 * Removes routes from the DAPM context.
2854 */
2855int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm,
2856 const struct snd_soc_dapm_route *route, int num)
2857{
Rajan Vajae066ea22016-02-11 11:23:35 +05302858 int i;
Mark Brownefcc3c62012-07-05 17:24:19 +01002859
2860 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2861 for (i = 0; i < num; i++) {
2862 snd_soc_dapm_del_route(dapm, route);
2863 route++;
2864 }
2865 mutex_unlock(&dapm->card->dapm_mutex);
2866
Rajan Vajae066ea22016-02-11 11:23:35 +05302867 return 0;
Mark Brownefcc3c62012-07-05 17:24:19 +01002868}
2869EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes);
2870
Mark Brownbf3a9e12011-06-13 16:42:29 +01002871static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
2872 const struct snd_soc_dapm_route *route)
2873{
2874 struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
2875 route->source,
2876 true);
2877 struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
2878 route->sink,
2879 true);
2880 struct snd_soc_dapm_path *path;
2881 int count = 0;
2882
2883 if (!source) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002884 dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002885 route->source);
2886 return -ENODEV;
2887 }
2888
2889 if (!sink) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002890 dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002891 route->sink);
2892 return -ENODEV;
2893 }
2894
2895 if (route->control || route->connected)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002896 dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002897 route->source, route->sink);
2898
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02002899 snd_soc_dapm_widget_for_each_sink_path(source, path) {
Mark Brownbf3a9e12011-06-13 16:42:29 +01002900 if (path->sink == sink) {
2901 path->weak = 1;
2902 count++;
2903 }
2904 }
2905
2906 if (count == 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002907 dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002908 route->source, route->sink);
2909 if (count > 1)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002910 dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002911 count, route->source, route->sink);
2912
2913 return 0;
2914}
2915
2916/**
2917 * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
2918 * @dapm: DAPM context
2919 * @route: audio routes
2920 * @num: number of routes
2921 *
2922 * Mark existing routes matching those specified in the passed array
2923 * as being weak, meaning that they are ignored for the purpose of
2924 * power decisions. The main intended use case is for sidetone paths
2925 * which couple audio between other independent paths if they are both
2926 * active in order to make the combination work better at the user
2927 * level but which aren't intended to be "used".
2928 *
2929 * Note that CODEC drivers should not use this as sidetone type paths
2930 * can frequently also be used as bypass paths.
2931 */
2932int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
2933 const struct snd_soc_dapm_route *route, int num)
2934{
2935 int i, err;
2936 int ret = 0;
2937
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002938 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brownbf3a9e12011-06-13 16:42:29 +01002939 for (i = 0; i < num; i++) {
2940 err = snd_soc_dapm_weak_route(dapm, route);
2941 if (err)
2942 ret = err;
2943 route++;
2944 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002945 mutex_unlock(&dapm->card->dapm_mutex);
Mark Brownbf3a9e12011-06-13 16:42:29 +01002946
2947 return ret;
2948}
2949EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2950
Mark Brown105f1c22008-05-13 14:52:19 +02002951/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02002952 * snd_soc_dapm_new_widgets - add new dapm widgets
Jonathan Corbet628536e2015-08-25 01:14:48 -06002953 * @card: card to be checked for new dapm widgets
Richard Purdie2b97eab2006-10-06 18:32:18 +02002954 *
2955 * Checks the codec for any new dapm widgets and creates them if found.
2956 *
2957 * Returns 0 for success.
2958 */
Lars-Peter Clausen824ef822013-08-27 15:51:01 +02002959int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002960{
2961 struct snd_soc_dapm_widget *w;
Mark Brownb66a70d2011-02-09 18:04:11 +00002962 unsigned int val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002963
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002964 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002965
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002966 list_for_each_entry(w, &card->widgets, list)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002967 {
2968 if (w->new)
2969 continue;
2970
Stephen Warrenfad59882011-04-28 17:37:59 -06002971 if (w->num_kcontrols) {
2972 w->kcontrols = kzalloc(w->num_kcontrols *
2973 sizeof(struct snd_kcontrol *),
2974 GFP_KERNEL);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002975 if (!w->kcontrols) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002976 mutex_unlock(&card->dapm_mutex);
Stephen Warrenfad59882011-04-28 17:37:59 -06002977 return -ENOMEM;
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002978 }
Stephen Warrenfad59882011-04-28 17:37:59 -06002979 }
2980
Richard Purdie2b97eab2006-10-06 18:32:18 +02002981 switch(w->id) {
2982 case snd_soc_dapm_switch:
2983 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00002984 case snd_soc_dapm_mixer_named_ctl:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002985 dapm_new_mixer(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002986 break;
2987 case snd_soc_dapm_mux:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002988 case snd_soc_dapm_demux:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002989 dapm_new_mux(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002990 break;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002991 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06002992 case snd_soc_dapm_out_drv:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002993 dapm_new_pga(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002994 break;
Nikesh Oswalc6615082015-02-02 17:06:44 +00002995 case snd_soc_dapm_dai_link:
2996 dapm_new_dai_link(w);
2997 break;
Mark Brown7ca3a182011-10-08 14:04:50 +01002998 default:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002999 break;
3000 }
Mark Brownb66a70d2011-02-09 18:04:11 +00003001
3002 /* Read the initial power state from the device */
3003 if (w->reg >= 0) {
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003004 soc_dapm_read(w->dapm, w->reg, &val);
Arun Shamanna Lakshmif7d3c172014-01-14 15:31:54 -08003005 val = val >> w->shift;
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02003006 val &= w->mask;
3007 if (val == w->on_val)
Mark Brownb66a70d2011-02-09 18:04:11 +00003008 w->power = 1;
3009 }
3010
Richard Purdie2b97eab2006-10-06 18:32:18 +02003011 w->new = 1;
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02003012
Mark Brown7508b122011-10-05 12:09:12 +01003013 dapm_mark_dirty(w, "new widget");
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02003014 dapm_debugfs_add_widget(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003015 }
3016
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02003017 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
3018 mutex_unlock(&card->dapm_mutex);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003019 return 0;
3020}
3021EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
3022
3023/**
3024 * snd_soc_dapm_get_volsw - dapm mixer get callback
3025 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00003026 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02003027 *
3028 * Callback to get the value of a dapm mixer control.
3029 *
3030 * Returns 0 for success.
3031 */
3032int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
3033 struct snd_ctl_elem_value *ucontrol)
3034{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003035 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3036 struct snd_soc_card *card = dapm->card;
Jon Smirl4eaa9812008-07-29 11:42:26 +01003037 struct soc_mixer_control *mc =
3038 (struct soc_mixer_control *)kcontrol->private_value;
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003039 int reg = mc->reg;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003040 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01003041 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003042 unsigned int mask = (1 << fls(max)) - 1;
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003043 unsigned int invert = mc->invert;
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003044 unsigned int val;
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003045 int ret = 0;
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003046
3047 if (snd_soc_volsw_is_stereo(mc))
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003048 dev_warn(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003049 "ASoC: Control '%s' is stereo, which is not supported\n",
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003050 kcontrol->id.name);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003051
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003052 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003053 if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
3054 ret = soc_dapm_read(dapm, reg, &val);
3055 val = (val >> shift) & mask;
3056 } else {
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003057 val = dapm_kcontrol_get_value(kcontrol);
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003058 }
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003059 mutex_unlock(&card->dapm_mutex);
3060
Chen-Yu Tsai01ad5e72016-08-27 19:27:58 +08003061 if (ret)
3062 return ret;
3063
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003064 if (invert)
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003065 ucontrol->value.integer.value[0] = max - val;
3066 else
3067 ucontrol->value.integer.value[0] = val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003068
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003069 return ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003070}
3071EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
3072
3073/**
3074 * snd_soc_dapm_put_volsw - dapm mixer set callback
3075 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00003076 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02003077 *
3078 * Callback to set the value of a dapm mixer control.
3079 *
3080 * Returns 0 for success.
3081 */
3082int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
3083 struct snd_ctl_elem_value *ucontrol)
3084{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003085 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3086 struct snd_soc_card *card = dapm->card;
Jon Smirl4eaa9812008-07-29 11:42:26 +01003087 struct soc_mixer_control *mc =
3088 (struct soc_mixer_control *)kcontrol->private_value;
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003089 int reg = mc->reg;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003090 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01003091 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003092 unsigned int mask = (1 << fls(max)) - 1;
3093 unsigned int invert = mc->invert;
Stephen Warrene9cf7042011-01-27 14:54:05 -07003094 unsigned int val;
Jarkko Nikula18626c72014-06-09 14:20:29 +03003095 int connect, change, reg_change = 0;
Mark Brown97404f22010-12-14 16:13:57 +00003096 struct snd_soc_dapm_update update;
Nenghua Cao52765972013-12-13 20:13:49 +08003097 int ret = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003098
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003099 if (snd_soc_volsw_is_stereo(mc))
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003100 dev_warn(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003101 "ASoC: Control '%s' is stereo, which is not supported\n",
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003102 kcontrol->id.name);
3103
Richard Purdie2b97eab2006-10-06 18:32:18 +02003104 val = (ucontrol->value.integer.value[0] & mask);
Benoît Thébaudeau8a720712012-06-18 22:41:28 +02003105 connect = !!val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003106
3107 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01003108 val = max - val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003109
Liam Girdwood3cd04342012-03-09 12:02:08 +00003110 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003111
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003112 change = dapm_kcontrol_set_value(kcontrol, val);
Mark Brown283375c2009-12-07 18:09:03 +00003113
Jarkko Nikula18626c72014-06-09 14:20:29 +03003114 if (reg != SND_SOC_NOPM) {
3115 mask = mask << shift;
3116 val = val << shift;
Lars-Peter Clausenc9e065c2014-05-04 19:17:05 +02003117
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003118 reg_change = soc_dapm_test_bits(dapm, reg, mask, val);
Jarkko Nikula18626c72014-06-09 14:20:29 +03003119 }
3120
3121 if (change || reg_change) {
3122 if (reg_change) {
3123 update.kcontrol = kcontrol;
3124 update.reg = reg;
3125 update.mask = mask;
3126 update.val = val;
3127 card->update = &update;
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003128 }
Jarkko Nikula18626c72014-06-09 14:20:29 +03003129 change |= reg_change;
Mark Brown97404f22010-12-14 16:13:57 +00003130
Nenghua Cao52765972013-12-13 20:13:49 +08003131 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
Mark Brown97404f22010-12-14 16:13:57 +00003132
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02003133 card->update = NULL;
Mark Brown283375c2009-12-07 18:09:03 +00003134 }
3135
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003136 mutex_unlock(&card->dapm_mutex);
Nenghua Cao52765972013-12-13 20:13:49 +08003137
3138 if (ret > 0)
3139 soc_dpcm_runtime_update(card);
3140
Lars-Peter Clausen56a67832013-07-24 15:27:35 +02003141 return change;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003142}
3143EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
3144
3145/**
3146 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
3147 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00003148 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02003149 *
3150 * Callback to get the value of a dapm enumerated double mixer control.
3151 *
3152 * Returns 0 for success.
3153 */
3154int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
3155 struct snd_ctl_elem_value *ucontrol)
3156{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003157 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
Charles Keepax561ed682015-05-01 12:37:26 +01003158 struct snd_soc_card *card = dapm->card;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003159 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003160 unsigned int reg_val, val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003161
Charles Keepax561ed682015-05-01 12:37:26 +01003162 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3163 if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003164 int ret = soc_dapm_read(dapm, e->reg, &reg_val);
Charles Keepax964a0b82015-05-08 10:50:10 +01003165 if (ret) {
3166 mutex_unlock(&card->dapm_mutex);
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003167 return ret;
Charles Keepax964a0b82015-05-08 10:50:10 +01003168 }
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003169 } else {
Lars-Peter Clausen236aaa62014-02-28 08:31:11 +01003170 reg_val = dapm_kcontrol_get_value(kcontrol);
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003171 }
Charles Keepax561ed682015-05-01 12:37:26 +01003172 mutex_unlock(&card->dapm_mutex);
Lars-Peter Clausen236aaa62014-02-28 08:31:11 +01003173
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003174 val = (reg_val >> e->shift_l) & e->mask;
3175 ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
3176 if (e->shift_l != e->shift_r) {
3177 val = (reg_val >> e->shift_r) & e->mask;
3178 val = snd_soc_enum_val_to_item(e, val);
3179 ucontrol->value.enumerated.item[1] = val;
3180 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02003181
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003182 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003183}
3184EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
3185
3186/**
3187 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
3188 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00003189 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02003190 *
3191 * Callback to set the value of a dapm enumerated double mixer control.
3192 *
3193 * Returns 0 for success.
3194 */
3195int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
3196 struct snd_ctl_elem_value *ucontrol)
3197{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003198 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3199 struct snd_soc_card *card = dapm->card;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003200 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003201 unsigned int *item = ucontrol->value.enumerated.item;
Charles Keepax561ed682015-05-01 12:37:26 +01003202 unsigned int val, change, reg_change = 0;
Lars-Peter Clausen86767b72012-09-14 13:57:27 +02003203 unsigned int mask;
Mark Brown97404f22010-12-14 16:13:57 +00003204 struct snd_soc_dapm_update update;
Nenghua Cao52765972013-12-13 20:13:49 +08003205 int ret = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003206
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003207 if (item[0] >= e->items)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003208 return -EINVAL;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003209
3210 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
Lars-Peter Clausen86767b72012-09-14 13:57:27 +02003211 mask = e->mask << e->shift_l;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003212 if (e->shift_l != e->shift_r) {
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003213 if (item[1] > e->items)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003214 return -EINVAL;
Chen-Yu Tsai071133a2016-08-27 19:27:59 +08003215 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r;
Lars-Peter Clausen86767b72012-09-14 13:57:27 +02003216 mask |= e->mask << e->shift_r;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003217 }
3218
Liam Girdwood3cd04342012-03-09 12:02:08 +00003219 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Stephen Warrenfafd2172011-04-28 17:38:00 -06003220
Charles Keepax561ed682015-05-01 12:37:26 +01003221 change = dapm_kcontrol_set_value(kcontrol, val);
Mark Brown97404f22010-12-14 16:13:57 +00003222
Charles Keepax561ed682015-05-01 12:37:26 +01003223 if (e->reg != SND_SOC_NOPM)
3224 reg_change = soc_dapm_test_bits(dapm, e->reg, mask, val);
3225
3226 if (change || reg_change) {
3227 if (reg_change) {
Lars-Peter Clausen236aaa62014-02-28 08:31:11 +01003228 update.kcontrol = kcontrol;
3229 update.reg = e->reg;
3230 update.mask = mask;
3231 update.val = val;
3232 card->update = &update;
3233 }
Charles Keepax561ed682015-05-01 12:37:26 +01003234 change |= reg_change;
Mark Brown3a655772009-10-05 17:23:30 +01003235
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003236 ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
Mark Brown1642e3d2009-10-05 16:24:26 +01003237
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02003238 card->update = NULL;
Stephen Warrenfafd2172011-04-28 17:38:00 -06003239 }
3240
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003241 mutex_unlock(&card->dapm_mutex);
Nenghua Cao52765972013-12-13 20:13:49 +08003242
3243 if (ret > 0)
3244 soc_dpcm_runtime_update(card);
3245
Mark Brown97404f22010-12-14 16:13:57 +00003246 return change;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003247}
3248EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
3249
3250/**
Mark Brown8b37dbd2009-02-28 21:14:20 +00003251 * snd_soc_dapm_info_pin_switch - Info for a pin switch
3252 *
3253 * @kcontrol: mixer control
3254 * @uinfo: control element information
3255 *
3256 * Callback to provide information about a pin switch control.
3257 */
3258int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
3259 struct snd_ctl_elem_info *uinfo)
3260{
3261 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3262 uinfo->count = 1;
3263 uinfo->value.integer.min = 0;
3264 uinfo->value.integer.max = 1;
3265
3266 return 0;
3267}
3268EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
3269
3270/**
3271 * snd_soc_dapm_get_pin_switch - Get information for a pin switch
3272 *
3273 * @kcontrol: mixer control
3274 * @ucontrol: Value
3275 */
3276int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
3277 struct snd_ctl_elem_value *ucontrol)
3278{
Mark Brown48a8c392012-02-14 17:11:15 -08003279 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003280 const char *pin = (const char *)kcontrol->private_value;
3281
Liam Girdwood3cd04342012-03-09 12:02:08 +00003282 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003283
3284 ucontrol->value.integer.value[0] =
Mark Brown48a8c392012-02-14 17:11:15 -08003285 snd_soc_dapm_get_pin_status(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003286
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003287 mutex_unlock(&card->dapm_mutex);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003288
3289 return 0;
3290}
3291EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
3292
3293/**
3294 * snd_soc_dapm_put_pin_switch - Set information for a pin switch
3295 *
3296 * @kcontrol: mixer control
3297 * @ucontrol: Value
3298 */
3299int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
3300 struct snd_ctl_elem_value *ucontrol)
3301{
Mark Brown48a8c392012-02-14 17:11:15 -08003302 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003303 const char *pin = (const char *)kcontrol->private_value;
3304
Mark Brown8b37dbd2009-02-28 21:14:20 +00003305 if (ucontrol->value.integer.value[0])
Mark Brown48a8c392012-02-14 17:11:15 -08003306 snd_soc_dapm_enable_pin(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003307 else
Mark Brown48a8c392012-02-14 17:11:15 -08003308 snd_soc_dapm_disable_pin(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003309
Mark Brown48a8c392012-02-14 17:11:15 -08003310 snd_soc_dapm_sync(&card->dapm);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003311 return 0;
3312}
3313EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
3314
Liam Girdwoodcc76e7d2015-06-04 15:13:09 +01003315struct snd_soc_dapm_widget *
Mark Brown5ba06fc2012-02-16 11:07:13 -08003316snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003317 const struct snd_soc_dapm_widget *widget)
3318{
3319 struct snd_soc_dapm_widget *w;
3320
3321 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3322 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3323 if (!w)
3324 dev_err(dapm->dev,
3325 "ASoC: Failed to create DAPM control %s\n",
3326 widget->name);
3327
3328 mutex_unlock(&dapm->card->dapm_mutex);
3329 return w;
3330}
Subhransu S. Prustya5d56392016-06-27 09:18:03 +05303331EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003332
3333struct snd_soc_dapm_widget *
3334snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
Mark Brown5ba06fc2012-02-16 11:07:13 -08003335 const struct snd_soc_dapm_widget *widget)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003336{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003337 enum snd_soc_dapm_direction dir;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003338 struct snd_soc_dapm_widget *w;
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02003339 const char *prefix;
Mark Brown62ea8742012-01-21 21:14:48 +00003340 int ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003341
3342 if ((w = dapm_cnew_widget(widget)) == NULL)
Mark Brown5ba06fc2012-02-16 11:07:13 -08003343 return NULL;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003344
Mark Brown62ea8742012-01-21 21:14:48 +00003345 switch (w->id) {
3346 case snd_soc_dapm_regulator_supply:
Liam Girdwooda3cc0562012-03-09 17:20:16 +00003347 w->regulator = devm_regulator_get(dapm->dev, w->name);
3348 if (IS_ERR(w->regulator)) {
3349 ret = PTR_ERR(w->regulator);
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003350 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
Mark Brown62ea8742012-01-21 21:14:48 +00003351 w->name, ret);
Mark Brown5ba06fc2012-02-16 11:07:13 -08003352 return NULL;
Mark Brown62ea8742012-01-21 21:14:48 +00003353 }
Mark Brown8784c772013-01-10 19:33:47 +00003354
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02003355 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
Mark Brown8784c772013-01-10 19:33:47 +00003356 ret = regulator_allow_bypass(w->regulator, true);
3357 if (ret != 0)
3358 dev_warn(w->dapm->dev,
Charles Keepax30686c32014-02-18 16:05:27 +00003359 "ASoC: Failed to bypass %s: %d\n",
Mark Brown8784c772013-01-10 19:33:47 +00003360 w->name, ret);
3361 }
Mark Brown62ea8742012-01-21 21:14:48 +00003362 break;
Ola Liljad7e7eb92012-05-24 15:26:25 +02003363 case snd_soc_dapm_clock_supply:
Mark Brown165961e2012-06-05 10:44:23 +01003364#ifdef CONFIG_CLKDEV_LOOKUP
Mark Brown695594f12012-06-04 08:14:13 +01003365 w->clk = devm_clk_get(dapm->dev, w->name);
Ola Liljad7e7eb92012-05-24 15:26:25 +02003366 if (IS_ERR(w->clk)) {
3367 ret = PTR_ERR(w->clk);
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003368 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
Ola Liljad7e7eb92012-05-24 15:26:25 +02003369 w->name, ret);
3370 return NULL;
3371 }
Mark Brownec029952012-06-04 08:16:20 +01003372#else
3373 return NULL;
3374#endif
Ola Liljad7e7eb92012-05-24 15:26:25 +02003375 break;
Mark Brown62ea8742012-01-21 21:14:48 +00003376 default:
3377 break;
3378 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02003379
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02003380 prefix = soc_dapm_prefix(dapm);
Lars-Peter Clausena798c242015-07-21 11:51:35 +02003381 if (prefix)
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02003382 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, widget->name);
Lars-Peter Clausena798c242015-07-21 11:51:35 +02003383 else
Lars-Peter Clausen48068962015-07-21 18:11:08 +02003384 w->name = kstrdup_const(widget->name, GFP_KERNEL);
Jarkko Nikulaead9b912010-11-13 20:40:44 +02003385 if (w->name == NULL) {
3386 kfree(w);
Mark Brown5ba06fc2012-02-16 11:07:13 -08003387 return NULL;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02003388 }
Jarkko Nikulaead9b912010-11-13 20:40:44 +02003389
Mark Brown7ca3a182011-10-08 14:04:50 +01003390 switch (w->id) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003391 case snd_soc_dapm_mic:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003392 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003393 w->power_check = dapm_generic_check_power;
3394 break;
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01003395 case snd_soc_dapm_input:
3396 if (!dapm->card->fully_routed)
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003397 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01003398 w->power_check = dapm_generic_check_power;
3399 break;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003400 case snd_soc_dapm_spk:
3401 case snd_soc_dapm_hp:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003402 w->is_ep = SND_SOC_DAPM_EP_SINK;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003403 w->power_check = dapm_generic_check_power;
3404 break;
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01003405 case snd_soc_dapm_output:
3406 if (!dapm->card->fully_routed)
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003407 w->is_ep = SND_SOC_DAPM_EP_SINK;
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01003408 w->power_check = dapm_generic_check_power;
3409 break;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003410 case snd_soc_dapm_vmid:
3411 case snd_soc_dapm_siggen:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003412 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003413 w->power_check = dapm_always_on_check_power;
3414 break;
Vinod Koul56b44372015-11-23 21:22:30 +05303415 case snd_soc_dapm_sink:
3416 w->is_ep = SND_SOC_DAPM_EP_SINK;
3417 w->power_check = dapm_always_on_check_power;
3418 break;
3419
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003420 case snd_soc_dapm_mux:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02003421 case snd_soc_dapm_demux:
Mark Brown7ca3a182011-10-08 14:04:50 +01003422 case snd_soc_dapm_switch:
3423 case snd_soc_dapm_mixer:
3424 case snd_soc_dapm_mixer_named_ctl:
Mark Brown63c69a62013-07-18 22:03:01 +01003425 case snd_soc_dapm_adc:
3426 case snd_soc_dapm_aif_out:
3427 case snd_soc_dapm_dac:
3428 case snd_soc_dapm_aif_in:
Mark Brown7ca3a182011-10-08 14:04:50 +01003429 case snd_soc_dapm_pga:
3430 case snd_soc_dapm_out_drv:
Mark Brown7ca3a182011-10-08 14:04:50 +01003431 case snd_soc_dapm_micbias:
Mark Brown7ca3a182011-10-08 14:04:50 +01003432 case snd_soc_dapm_line:
Mark Brownc74184e2012-04-04 22:12:09 +01003433 case snd_soc_dapm_dai_link:
Lars-Peter Clausencdef2ad2014-10-20 19:36:38 +02003434 case snd_soc_dapm_dai_out:
3435 case snd_soc_dapm_dai_in:
Mark Brown7ca3a182011-10-08 14:04:50 +01003436 w->power_check = dapm_generic_check_power;
3437 break;
3438 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00003439 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02003440 case snd_soc_dapm_clock_supply:
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003441 case snd_soc_dapm_kcontrol:
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003442 w->is_supply = 1;
Mark Brown7ca3a182011-10-08 14:04:50 +01003443 w->power_check = dapm_supply_check_power;
3444 break;
3445 default:
3446 w->power_check = dapm_always_on_check_power;
3447 break;
3448 }
3449
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003450 w->dapm = dapm;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003451 INIT_LIST_HEAD(&w->list);
Mark Browndb432b42011-10-03 21:06:40 +01003452 INIT_LIST_HEAD(&w->dirty);
Lars-Peter Clausen92fa1242015-05-01 18:02:42 +02003453 list_add_tail(&w->list, &dapm->card->widgets);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003454
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003455 snd_soc_dapm_for_each_direction(dir) {
3456 INIT_LIST_HEAD(&w->edges[dir]);
3457 w->endpoints[dir] = -1;
3458 }
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02003459
Peter Meerwald-Stadlerc8046002016-08-16 16:56:17 +02003460 /* machine layer sets up unconnected pins and insertions */
Richard Purdie2b97eab2006-10-06 18:32:18 +02003461 w->connected = 1;
Mark Brown5ba06fc2012-02-16 11:07:13 -08003462 return w;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003463}
Richard Purdie2b97eab2006-10-06 18:32:18 +02003464
3465/**
Mark Brown4ba13272008-05-13 14:51:19 +02003466 * snd_soc_dapm_new_controls - create new dapm controls
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003467 * @dapm: DAPM context
Mark Brown4ba13272008-05-13 14:51:19 +02003468 * @widget: widget array
3469 * @num: number of widgets
3470 *
3471 * Creates new DAPM controls based upon the templates.
3472 *
3473 * Returns 0 for success else error.
3474 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003475int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
Mark Brown4ba13272008-05-13 14:51:19 +02003476 const struct snd_soc_dapm_widget *widget,
3477 int num)
3478{
Mark Brown5ba06fc2012-02-16 11:07:13 -08003479 struct snd_soc_dapm_widget *w;
3480 int i;
Dan Carpenter60884c22012-04-13 22:25:43 +03003481 int ret = 0;
Mark Brown4ba13272008-05-13 14:51:19 +02003482
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003483 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brown4ba13272008-05-13 14:51:19 +02003484 for (i = 0; i < num; i++) {
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003485 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
Mark Brown5ba06fc2012-02-16 11:07:13 -08003486 if (!w) {
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02003487 dev_err(dapm->dev,
Mark Brown5ba06fc2012-02-16 11:07:13 -08003488 "ASoC: Failed to create DAPM control %s\n",
3489 widget->name);
Dan Carpenter60884c22012-04-13 22:25:43 +03003490 ret = -ENOMEM;
3491 break;
Mark Brownb8b33cb2008-12-18 11:19:30 +00003492 }
Mark Brown4ba13272008-05-13 14:51:19 +02003493 widget++;
3494 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003495 mutex_unlock(&dapm->card->dapm_mutex);
Dan Carpenter60884c22012-04-13 22:25:43 +03003496 return ret;
Mark Brown4ba13272008-05-13 14:51:19 +02003497}
3498EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
3499
Mark Brownc74184e2012-04-04 22:12:09 +01003500static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
3501 struct snd_kcontrol *kcontrol, int event)
3502{
3503 struct snd_soc_dapm_path *source_p, *sink_p;
3504 struct snd_soc_dai *source, *sink;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003505 const struct snd_soc_pcm_stream *config = w->params + w->params_select;
Mark Brownc74184e2012-04-04 22:12:09 +01003506 struct snd_pcm_substream substream;
Mark Brown9747cec2012-04-26 19:12:21 +01003507 struct snd_pcm_hw_params *params = NULL;
Nicolin Chen8053f212016-07-26 14:55:51 -07003508 struct snd_pcm_runtime *runtime = NULL;
Mark Brownc74184e2012-04-04 22:12:09 +01003509 u64 fmt;
3510 int ret;
3511
Takashi Iwaibf4edea2013-11-07 18:38:47 +01003512 if (WARN_ON(!config) ||
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003513 WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
3514 list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
Takashi Iwaibf4edea2013-11-07 18:38:47 +01003515 return -EINVAL;
Mark Brownc74184e2012-04-04 22:12:09 +01003516
3517 /* We only support a single source and sink, pick the first */
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003518 source_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_OUT],
3519 struct snd_soc_dapm_path,
3520 list_node[SND_SOC_DAPM_DIR_OUT]);
3521 sink_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_IN],
3522 struct snd_soc_dapm_path,
3523 list_node[SND_SOC_DAPM_DIR_IN]);
Mark Brownc74184e2012-04-04 22:12:09 +01003524
3525 source = source_p->source->priv;
3526 sink = sink_p->sink->priv;
3527
3528 /* Be a little careful as we don't want to overflow the mask array */
3529 if (config->formats) {
3530 fmt = ffs(config->formats) - 1;
3531 } else {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003532 dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n",
Mark Brownc74184e2012-04-04 22:12:09 +01003533 config->formats);
3534 fmt = 0;
3535 }
3536
3537 /* Currently very limited parameter selection */
Mark Brown9747cec2012-04-26 19:12:21 +01003538 params = kzalloc(sizeof(*params), GFP_KERNEL);
3539 if (!params) {
3540 ret = -ENOMEM;
3541 goto out;
3542 }
3543 snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
Mark Brownc74184e2012-04-04 22:12:09 +01003544
Mark Brown9747cec2012-04-26 19:12:21 +01003545 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
Mark Brownc74184e2012-04-04 22:12:09 +01003546 config->rate_min;
Mark Brown9747cec2012-04-26 19:12:21 +01003547 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
Mark Brownc74184e2012-04-04 22:12:09 +01003548 config->rate_max;
3549
Mark Brown9747cec2012-04-26 19:12:21 +01003550 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
Mark Brownc74184e2012-04-04 22:12:09 +01003551 = config->channels_min;
Mark Brown9747cec2012-04-26 19:12:21 +01003552 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
Mark Brownc74184e2012-04-04 22:12:09 +01003553 = config->channels_max;
3554
3555 memset(&substream, 0, sizeof(substream));
3556
Nicolin Chen8053f212016-07-26 14:55:51 -07003557 /* Allocate a dummy snd_pcm_runtime for startup() and other ops() */
3558 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
3559 if (!runtime) {
3560 ret = -ENOMEM;
3561 goto out;
3562 }
3563 substream.runtime = runtime;
3564
Mark Brownc74184e2012-04-04 22:12:09 +01003565 switch (event) {
3566 case SND_SOC_DAPM_PRE_PMU:
Benoit Cousson93e69582014-07-08 23:19:38 +02003567 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
Jeeja KP9b8ef9f2015-10-20 22:30:07 +05303568 if (source->driver->ops && source->driver->ops->startup) {
3569 ret = source->driver->ops->startup(&substream, source);
3570 if (ret < 0) {
3571 dev_err(source->dev,
3572 "ASoC: startup() failed: %d\n", ret);
3573 goto out;
3574 }
3575 source->active++;
3576 }
Benoit Cousson93e69582014-07-08 23:19:38 +02003577 ret = soc_dai_hw_params(&substream, params, source);
3578 if (ret < 0)
3579 goto out;
Mark Brownc74184e2012-04-04 22:12:09 +01003580
Benoit Cousson93e69582014-07-08 23:19:38 +02003581 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
Jeeja KP9b8ef9f2015-10-20 22:30:07 +05303582 if (sink->driver->ops && sink->driver->ops->startup) {
3583 ret = sink->driver->ops->startup(&substream, sink);
3584 if (ret < 0) {
3585 dev_err(sink->dev,
3586 "ASoC: startup() failed: %d\n", ret);
3587 goto out;
3588 }
3589 sink->active++;
3590 }
Benoit Cousson93e69582014-07-08 23:19:38 +02003591 ret = soc_dai_hw_params(&substream, params, sink);
3592 if (ret < 0)
3593 goto out;
Mark Brownc74184e2012-04-04 22:12:09 +01003594 break;
3595
3596 case SND_SOC_DAPM_POST_PMU:
Mark Brownda183962013-02-06 15:44:07 +00003597 ret = snd_soc_dai_digital_mute(sink, 0,
3598 SNDRV_PCM_STREAM_PLAYBACK);
Mark Brownc74184e2012-04-04 22:12:09 +01003599 if (ret != 0 && ret != -ENOTSUPP)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003600 dev_warn(sink->dev, "ASoC: Failed to unmute: %d\n", ret);
Mark Brown9747cec2012-04-26 19:12:21 +01003601 ret = 0;
Mark Brownc74184e2012-04-04 22:12:09 +01003602 break;
3603
3604 case SND_SOC_DAPM_PRE_PMD:
Mark Brownda183962013-02-06 15:44:07 +00003605 ret = snd_soc_dai_digital_mute(sink, 1,
3606 SNDRV_PCM_STREAM_PLAYBACK);
Mark Brownc74184e2012-04-04 22:12:09 +01003607 if (ret != 0 && ret != -ENOTSUPP)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003608 dev_warn(sink->dev, "ASoC: Failed to mute: %d\n", ret);
Mark Brown9747cec2012-04-26 19:12:21 +01003609 ret = 0;
Jeeja KP9b8ef9f2015-10-20 22:30:07 +05303610
3611 source->active--;
3612 if (source->driver->ops && source->driver->ops->shutdown) {
3613 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3614 source->driver->ops->shutdown(&substream, source);
3615 }
3616
3617 sink->active--;
3618 if (sink->driver->ops && sink->driver->ops->shutdown) {
3619 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
3620 sink->driver->ops->shutdown(&substream, sink);
3621 }
Mark Brownc74184e2012-04-04 22:12:09 +01003622 break;
3623
3624 default:
Takashi Iwaia6ed0602013-11-06 11:07:19 +01003625 WARN(1, "Unknown event %d\n", event);
Sudip Mukherjee75881df2015-09-10 18:01:44 +05303626 ret = -EINVAL;
Mark Brownc74184e2012-04-04 22:12:09 +01003627 }
3628
Mark Brown9747cec2012-04-26 19:12:21 +01003629out:
Nicolin Chen8053f212016-07-26 14:55:51 -07003630 kfree(runtime);
Mark Brown9747cec2012-04-26 19:12:21 +01003631 kfree(params);
3632 return ret;
Mark Brownc74184e2012-04-04 22:12:09 +01003633}
3634
Nikesh Oswalc6615082015-02-02 17:06:44 +00003635static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
3636 struct snd_ctl_elem_value *ucontrol)
3637{
3638 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3639
Takashi Iwai741338f2016-02-29 17:20:48 +01003640 ucontrol->value.enumerated.item[0] = w->params_select;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003641
3642 return 0;
3643}
3644
3645static int snd_soc_dapm_dai_link_put(struct snd_kcontrol *kcontrol,
3646 struct snd_ctl_elem_value *ucontrol)
3647{
3648 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3649
3650 /* Can't change the config when widget is already powered */
3651 if (w->power)
3652 return -EBUSY;
3653
Takashi Iwai741338f2016-02-29 17:20:48 +01003654 if (ucontrol->value.enumerated.item[0] == w->params_select)
Nikesh Oswalc6615082015-02-02 17:06:44 +00003655 return 0;
3656
Takashi Iwai741338f2016-02-29 17:20:48 +01003657 if (ucontrol->value.enumerated.item[0] >= w->num_params)
Nikesh Oswalc6615082015-02-02 17:06:44 +00003658 return -EINVAL;
3659
Takashi Iwai741338f2016-02-29 17:20:48 +01003660 w->params_select = ucontrol->value.enumerated.item[0];
Nikesh Oswalc6615082015-02-02 17:06:44 +00003661
3662 return 0;
3663}
3664
Mark Brownc74184e2012-04-04 22:12:09 +01003665int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
3666 const struct snd_soc_pcm_stream *params,
Nikesh Oswalc6615082015-02-02 17:06:44 +00003667 unsigned int num_params,
Mark Brownc74184e2012-04-04 22:12:09 +01003668 struct snd_soc_dapm_widget *source,
3669 struct snd_soc_dapm_widget *sink)
3670{
Mark Brownc74184e2012-04-04 22:12:09 +01003671 struct snd_soc_dapm_widget template;
3672 struct snd_soc_dapm_widget *w;
Mark Brownc74184e2012-04-04 22:12:09 +01003673 char *link_name;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003674 int ret, count;
3675 unsigned long private_value;
3676 const char **w_param_text;
3677 struct soc_enum w_param_enum[] = {
3678 SOC_ENUM_SINGLE(0, 0, 0, NULL),
3679 };
3680 struct snd_kcontrol_new kcontrol_dai_link[] = {
3681 SOC_ENUM_EXT(NULL, w_param_enum[0],
3682 snd_soc_dapm_dai_link_get,
3683 snd_soc_dapm_dai_link_put),
3684 };
3685 const struct snd_soc_pcm_stream *config = params;
Mark Brownc74184e2012-04-04 22:12:09 +01003686
Nikesh Oswalc6615082015-02-02 17:06:44 +00003687 w_param_text = devm_kcalloc(card->dev, num_params,
3688 sizeof(char *), GFP_KERNEL);
3689 if (!w_param_text)
Mark Brownc74184e2012-04-04 22:12:09 +01003690 return -ENOMEM;
Mark Brownc74184e2012-04-04 22:12:09 +01003691
Charles Keepax46172b62015-03-25 11:22:35 +00003692 link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
3693 source->name, sink->name);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003694 if (!link_name) {
3695 ret = -ENOMEM;
3696 goto outfree_w_param;
3697 }
Mark Brownc74184e2012-04-04 22:12:09 +01003698
Nikesh Oswalc6615082015-02-02 17:06:44 +00003699 for (count = 0 ; count < num_params; count++) {
3700 if (!config->stream_name) {
3701 dev_warn(card->dapm.dev,
3702 "ASoC: anonymous config %d for dai link %s\n",
3703 count, link_name);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003704 w_param_text[count] =
Charles Keepax46172b62015-03-25 11:22:35 +00003705 devm_kasprintf(card->dev, GFP_KERNEL,
3706 "Anonymous Configuration %d",
3707 count);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003708 if (!w_param_text[count]) {
3709 ret = -ENOMEM;
3710 goto outfree_link_name;
3711 }
Nikesh Oswalc6615082015-02-02 17:06:44 +00003712 } else {
3713 w_param_text[count] = devm_kmemdup(card->dev,
3714 config->stream_name,
3715 strlen(config->stream_name) + 1,
3716 GFP_KERNEL);
3717 if (!w_param_text[count]) {
3718 ret = -ENOMEM;
3719 goto outfree_link_name;
3720 }
3721 }
3722 config++;
3723 }
3724 w_param_enum[0].items = num_params;
3725 w_param_enum[0].texts = w_param_text;
Mark Brownc74184e2012-04-04 22:12:09 +01003726
3727 memset(&template, 0, sizeof(template));
3728 template.reg = SND_SOC_NOPM;
3729 template.id = snd_soc_dapm_dai_link;
3730 template.name = link_name;
3731 template.event = snd_soc_dai_link_event;
3732 template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
3733 SND_SOC_DAPM_PRE_PMD;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003734 template.num_kcontrols = 1;
3735 /* duplicate w_param_enum on heap so that memory persists */
3736 private_value =
3737 (unsigned long) devm_kmemdup(card->dev,
3738 (void *)(kcontrol_dai_link[0].private_value),
3739 sizeof(struct soc_enum), GFP_KERNEL);
3740 if (!private_value) {
3741 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3742 link_name);
3743 ret = -ENOMEM;
3744 goto outfree_link_name;
3745 }
3746 kcontrol_dai_link[0].private_value = private_value;
3747 /* duplicate kcontrol_dai_link on heap so that memory persists */
3748 template.kcontrol_news =
3749 devm_kmemdup(card->dev, &kcontrol_dai_link[0],
3750 sizeof(struct snd_kcontrol_new),
3751 GFP_KERNEL);
3752 if (!template.kcontrol_news) {
3753 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3754 link_name);
3755 ret = -ENOMEM;
3756 goto outfree_private_value;
3757 }
Mark Brownc74184e2012-04-04 22:12:09 +01003758
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003759 dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
Mark Brownc74184e2012-04-04 22:12:09 +01003760
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003761 w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
Mark Brownc74184e2012-04-04 22:12:09 +01003762 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003763 dev_err(card->dev, "ASoC: Failed to create %s widget\n",
Mark Brownc74184e2012-04-04 22:12:09 +01003764 link_name);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003765 ret = -ENOMEM;
3766 goto outfree_kcontrol_news;
Mark Brownc74184e2012-04-04 22:12:09 +01003767 }
3768
3769 w->params = params;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003770 w->num_params = num_params;
Mark Brownc74184e2012-04-04 22:12:09 +01003771
Lars-Peter Clausenfe838972014-05-07 16:20:27 +02003772 ret = snd_soc_dapm_add_path(&card->dapm, source, w, NULL, NULL);
3773 if (ret)
Nikesh Oswalc6615082015-02-02 17:06:44 +00003774 goto outfree_w;
Lars-Peter Clausenfe838972014-05-07 16:20:27 +02003775 return snd_soc_dapm_add_path(&card->dapm, w, sink, NULL, NULL);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003776
3777outfree_w:
3778 devm_kfree(card->dev, w);
3779outfree_kcontrol_news:
3780 devm_kfree(card->dev, (void *)template.kcontrol_news);
3781outfree_private_value:
3782 devm_kfree(card->dev, (void *)private_value);
3783outfree_link_name:
3784 devm_kfree(card->dev, link_name);
3785outfree_w_param:
3786 for (count = 0 ; count < num_params; count++)
3787 devm_kfree(card->dev, (void *)w_param_text[count]);
3788 devm_kfree(card->dev, w_param_text);
3789
3790 return ret;
Mark Brownc74184e2012-04-04 22:12:09 +01003791}
3792
Mark Brown888df392012-02-16 19:37:51 -08003793int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
3794 struct snd_soc_dai *dai)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003795{
Mark Brown888df392012-02-16 19:37:51 -08003796 struct snd_soc_dapm_widget template;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003797 struct snd_soc_dapm_widget *w;
3798
Mark Brown888df392012-02-16 19:37:51 -08003799 WARN_ON(dapm->dev != dai->dev);
3800
3801 memset(&template, 0, sizeof(template));
3802 template.reg = SND_SOC_NOPM;
3803
3804 if (dai->driver->playback.stream_name) {
Mark Brown46162742013-06-05 19:36:11 +01003805 template.id = snd_soc_dapm_dai_in;
Mark Brown888df392012-02-16 19:37:51 -08003806 template.name = dai->driver->playback.stream_name;
3807 template.sname = dai->driver->playback.stream_name;
3808
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003809 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003810 template.name);
3811
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003812 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
Mark Brown888df392012-02-16 19:37:51 -08003813 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003814 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003815 dai->driver->playback.stream_name);
Takashi Iwai298402a2013-10-28 14:21:50 +01003816 return -ENOMEM;
Mark Brown888df392012-02-16 19:37:51 -08003817 }
3818
3819 w->priv = dai;
3820 dai->playback_widget = w;
3821 }
3822
3823 if (dai->driver->capture.stream_name) {
Mark Brown46162742013-06-05 19:36:11 +01003824 template.id = snd_soc_dapm_dai_out;
Mark Brown888df392012-02-16 19:37:51 -08003825 template.name = dai->driver->capture.stream_name;
3826 template.sname = dai->driver->capture.stream_name;
3827
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003828 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003829 template.name);
3830
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003831 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
Mark Brown888df392012-02-16 19:37:51 -08003832 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003833 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003834 dai->driver->capture.stream_name);
Takashi Iwai298402a2013-10-28 14:21:50 +01003835 return -ENOMEM;
Mark Brown888df392012-02-16 19:37:51 -08003836 }
3837
3838 w->priv = dai;
3839 dai->capture_widget = w;
3840 }
3841
3842 return 0;
3843}
3844
3845int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
3846{
3847 struct snd_soc_dapm_widget *dai_w, *w;
Lars-Peter Clausen0f9bd7b2014-05-07 16:20:28 +02003848 struct snd_soc_dapm_widget *src, *sink;
Mark Brown888df392012-02-16 19:37:51 -08003849 struct snd_soc_dai *dai;
Mark Brown888df392012-02-16 19:37:51 -08003850
3851 /* For each DAI widget... */
3852 list_for_each_entry(dai_w, &card->widgets, list) {
Mark Brown46162742013-06-05 19:36:11 +01003853 switch (dai_w->id) {
3854 case snd_soc_dapm_dai_in:
3855 case snd_soc_dapm_dai_out:
3856 break;
3857 default:
Richard Purdie2b97eab2006-10-06 18:32:18 +02003858 continue;
Mark Brown46162742013-06-05 19:36:11 +01003859 }
Mark Brown888df392012-02-16 19:37:51 -08003860
3861 dai = dai_w->priv;
3862
3863 /* ...find all widgets with the same stream and link them */
3864 list_for_each_entry(w, &card->widgets, list) {
3865 if (w->dapm != dai_w->dapm)
3866 continue;
3867
Mark Brown46162742013-06-05 19:36:11 +01003868 switch (w->id) {
3869 case snd_soc_dapm_dai_in:
3870 case snd_soc_dapm_dai_out:
Mark Brown888df392012-02-16 19:37:51 -08003871 continue;
Mark Brown46162742013-06-05 19:36:11 +01003872 default:
3873 break;
3874 }
Mark Brown888df392012-02-16 19:37:51 -08003875
Lars-Peter Clausena798c242015-07-21 11:51:35 +02003876 if (!w->sname || !strstr(w->sname, dai_w->sname))
Mark Brown888df392012-02-16 19:37:51 -08003877 continue;
3878
Lars-Peter Clausen0f9bd7b2014-05-07 16:20:28 +02003879 if (dai_w->id == snd_soc_dapm_dai_in) {
3880 src = dai_w;
3881 sink = w;
3882 } else {
3883 src = w;
3884 sink = dai_w;
Mark Brown888df392012-02-16 19:37:51 -08003885 }
Lars-Peter Clausen0f9bd7b2014-05-07 16:20:28 +02003886 dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
3887 snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003888 }
3889 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02003890
Mark Brown888df392012-02-16 19:37:51 -08003891 return 0;
3892}
Liam Girdwood64a648c2011-07-25 11:15:15 +01003893
Benoit Cousson44ba2642014-07-08 23:19:36 +02003894static void dapm_connect_dai_link_widgets(struct snd_soc_card *card,
3895 struct snd_soc_pcm_runtime *rtd)
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003896{
Benoit Cousson44ba2642014-07-08 23:19:36 +02003897 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003898 struct snd_soc_dapm_widget *sink, *source;
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003899 int i;
3900
Benoit Cousson44ba2642014-07-08 23:19:36 +02003901 for (i = 0; i < rtd->num_codecs; i++) {
3902 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003903
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003904 /* connect BE DAI playback if widgets are valid */
3905 if (codec_dai->playback_widget && cpu_dai->playback_widget) {
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003906 source = cpu_dai->playback_widget;
3907 sink = codec_dai->playback_widget;
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003908 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003909 cpu_dai->component->name, source->name,
3910 codec_dai->component->name, sink->name);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003911
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003912 snd_soc_dapm_add_path(&card->dapm, source, sink,
3913 NULL, NULL);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003914 }
3915
3916 /* connect BE DAI capture if widgets are valid */
3917 if (codec_dai->capture_widget && cpu_dai->capture_widget) {
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003918 source = codec_dai->capture_widget;
3919 sink = cpu_dai->capture_widget;
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003920 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003921 codec_dai->component->name, source->name,
3922 cpu_dai->component->name, sink->name);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003923
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003924 snd_soc_dapm_add_path(&card->dapm, source, sink,
3925 NULL, NULL);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003926 }
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003927 }
3928}
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003929
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003930static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
3931 int event)
3932{
3933 struct snd_soc_dapm_widget *w;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003934 unsigned int ep;
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003935
3936 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
3937 w = dai->playback_widget;
3938 else
3939 w = dai->capture_widget;
3940
3941 if (w) {
3942 dapm_mark_dirty(w, "stream event");
3943
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003944 if (w->id == snd_soc_dapm_dai_in) {
3945 ep = SND_SOC_DAPM_EP_SOURCE;
3946 dapm_widget_invalidate_input_paths(w);
3947 } else {
3948 ep = SND_SOC_DAPM_EP_SINK;
3949 dapm_widget_invalidate_output_paths(w);
3950 }
3951
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003952 switch (event) {
3953 case SND_SOC_DAPM_STREAM_START:
3954 w->active = 1;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003955 w->is_ep = ep;
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003956 break;
3957 case SND_SOC_DAPM_STREAM_STOP:
3958 w->active = 0;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003959 w->is_ep = 0;
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003960 break;
3961 case SND_SOC_DAPM_STREAM_SUSPEND:
3962 case SND_SOC_DAPM_STREAM_RESUME:
3963 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
3964 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
3965 break;
3966 }
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003967 }
3968}
3969
Benoit Cousson44ba2642014-07-08 23:19:36 +02003970void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
3971{
Mengdong Lin1a497982015-11-18 02:34:11 -05003972 struct snd_soc_pcm_runtime *rtd;
Benoit Cousson44ba2642014-07-08 23:19:36 +02003973
3974 /* for each BE DAI link... */
Mengdong Lin1a497982015-11-18 02:34:11 -05003975 list_for_each_entry(rtd, &card->rtd_list, list) {
Benoit Cousson44ba2642014-07-08 23:19:36 +02003976 /*
3977 * dynamic FE links have no fixed DAI mapping.
3978 * CODEC<->CODEC links have no direct connection.
3979 */
3980 if (rtd->dai_link->dynamic || rtd->dai_link->params)
3981 continue;
3982
3983 dapm_connect_dai_link_widgets(card, rtd);
3984 }
3985}
3986
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003987static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3988 int event)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003989{
Benoit Cousson44ba2642014-07-08 23:19:36 +02003990 int i;
3991
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003992 soc_dapm_dai_stream_event(rtd->cpu_dai, stream, event);
Benoit Cousson44ba2642014-07-08 23:19:36 +02003993 for (i = 0; i < rtd->num_codecs; i++)
3994 soc_dapm_dai_stream_event(rtd->codec_dais[i], stream, event);
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003995
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02003996 dapm_power_widgets(rtd->card, event);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003997}
3998
3999/**
4000 * snd_soc_dapm_stream_event - send a stream event to the dapm core
4001 * @rtd: PCM runtime data
4002 * @stream: stream name
4003 * @event: stream event
4004 *
4005 * Sends a stream event to the dapm core. The core then makes any
4006 * necessary widget power changes.
4007 *
4008 * Returns 0 for success else error.
4009 */
Liam Girdwoodd9b09512012-03-07 16:32:59 +00004010void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
4011 int event)
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004012{
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00004013 struct snd_soc_card *card = rtd->card;
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004014
Liam Girdwood3cd04342012-03-09 12:02:08 +00004015 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Liam Girdwoodd9b09512012-03-07 16:32:59 +00004016 soc_dapm_stream_event(rtd, stream, event);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00004017 mutex_unlock(&card->dapm_mutex);
Richard Purdie2b97eab2006-10-06 18:32:18 +02004018}
Richard Purdie2b97eab2006-10-06 18:32:18 +02004019
4020/**
Charles Keepax11391102014-02-18 15:22:14 +00004021 * snd_soc_dapm_enable_pin_unlocked - enable pin.
4022 * @dapm: DAPM context
4023 * @pin: pin name
4024 *
4025 * Enables input/output pin and its parents or children widgets iff there is
4026 * a valid audio route and active audio stream.
4027 *
4028 * Requires external locking.
4029 *
4030 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4031 * do any widget power switching.
4032 */
4033int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4034 const char *pin)
4035{
4036 return snd_soc_dapm_set_pin(dapm, pin, 1);
4037}
4038EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
4039
4040/**
Liam Girdwooda5302182008-07-07 13:35:17 +01004041 * snd_soc_dapm_enable_pin - enable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004042 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01004043 * @pin: pin name
Richard Purdie2b97eab2006-10-06 18:32:18 +02004044 *
Mark Brown74b8f952009-06-06 11:26:15 +01004045 * Enables input/output pin and its parents or children widgets iff there is
Liam Girdwooda5302182008-07-07 13:35:17 +01004046 * a valid audio route and active audio stream.
Charles Keepax11391102014-02-18 15:22:14 +00004047 *
Liam Girdwooda5302182008-07-07 13:35:17 +01004048 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4049 * do any widget power switching.
Richard Purdie2b97eab2006-10-06 18:32:18 +02004050 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004051int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
Richard Purdie2b97eab2006-10-06 18:32:18 +02004052{
Charles Keepax11391102014-02-18 15:22:14 +00004053 int ret;
4054
4055 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4056
4057 ret = snd_soc_dapm_set_pin(dapm, pin, 1);
4058
4059 mutex_unlock(&dapm->card->dapm_mutex);
4060
4061 return ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02004062}
Liam Girdwooda5302182008-07-07 13:35:17 +01004063EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
Richard Purdie2b97eab2006-10-06 18:32:18 +02004064
4065/**
Charles Keepax11391102014-02-18 15:22:14 +00004066 * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
4067 * @dapm: DAPM context
4068 * @pin: pin name
4069 *
4070 * Enables input/output pin regardless of any other state. This is
4071 * intended for use with microphone bias supplies used in microphone
4072 * jack detection.
4073 *
4074 * Requires external locking.
4075 *
4076 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4077 * do any widget power switching.
4078 */
4079int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4080 const char *pin)
4081{
4082 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4083
4084 if (!w) {
4085 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4086 return -EINVAL;
4087 }
4088
4089 dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02004090 if (!w->connected) {
4091 /*
4092 * w->force does not affect the number of input or output paths,
4093 * so we only have to recheck if w->connected is changed
4094 */
4095 dapm_widget_invalidate_input_paths(w);
4096 dapm_widget_invalidate_output_paths(w);
4097 w->connected = 1;
4098 }
Charles Keepax11391102014-02-18 15:22:14 +00004099 w->force = 1;
4100 dapm_mark_dirty(w, "force enable");
4101
4102 return 0;
4103}
4104EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
4105
4106/**
Mark Brownda341832010-03-15 19:23:37 +00004107 * snd_soc_dapm_force_enable_pin - force a pin to be enabled
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004108 * @dapm: DAPM context
Mark Brownda341832010-03-15 19:23:37 +00004109 * @pin: pin name
4110 *
4111 * Enables input/output pin regardless of any other state. This is
4112 * intended for use with microphone bias supplies used in microphone
4113 * jack detection.
4114 *
4115 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4116 * do any widget power switching.
4117 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004118int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
4119 const char *pin)
Mark Brownda341832010-03-15 19:23:37 +00004120{
Charles Keepax11391102014-02-18 15:22:14 +00004121 int ret;
Mark Brownda341832010-03-15 19:23:37 +00004122
Charles Keepax11391102014-02-18 15:22:14 +00004123 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Mark Brownda341832010-03-15 19:23:37 +00004124
Charles Keepax11391102014-02-18 15:22:14 +00004125 ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
Mark Brown0d867332011-04-06 11:38:14 +09004126
Charles Keepax11391102014-02-18 15:22:14 +00004127 mutex_unlock(&dapm->card->dapm_mutex);
4128
4129 return ret;
Mark Brownda341832010-03-15 19:23:37 +00004130}
4131EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
4132
4133/**
Charles Keepax11391102014-02-18 15:22:14 +00004134 * snd_soc_dapm_disable_pin_unlocked - disable pin.
4135 * @dapm: DAPM context
4136 * @pin: pin name
4137 *
4138 * Disables input/output pin and its parents or children widgets.
4139 *
4140 * Requires external locking.
4141 *
4142 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4143 * do any widget power switching.
4144 */
4145int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4146 const char *pin)
4147{
4148 return snd_soc_dapm_set_pin(dapm, pin, 0);
4149}
4150EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
4151
4152/**
Liam Girdwooda5302182008-07-07 13:35:17 +01004153 * snd_soc_dapm_disable_pin - disable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004154 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01004155 * @pin: pin name
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004156 *
Mark Brown74b8f952009-06-06 11:26:15 +01004157 * Disables input/output pin and its parents or children widgets.
Charles Keepax11391102014-02-18 15:22:14 +00004158 *
Liam Girdwooda5302182008-07-07 13:35:17 +01004159 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4160 * do any widget power switching.
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004161 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004162int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
4163 const char *pin)
Liam Girdwooda5302182008-07-07 13:35:17 +01004164{
Charles Keepax11391102014-02-18 15:22:14 +00004165 int ret;
4166
4167 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4168
4169 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4170
4171 mutex_unlock(&dapm->card->dapm_mutex);
4172
4173 return ret;
Liam Girdwooda5302182008-07-07 13:35:17 +01004174}
4175EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
4176
4177/**
Charles Keepax11391102014-02-18 15:22:14 +00004178 * snd_soc_dapm_nc_pin_unlocked - permanently disable pin.
4179 * @dapm: DAPM context
4180 * @pin: pin name
4181 *
4182 * Marks the specified pin as being not connected, disabling it along
4183 * any parent or child widgets. At present this is identical to
4184 * snd_soc_dapm_disable_pin() but in future it will be extended to do
4185 * additional things such as disabling controls which only affect
4186 * paths through the pin.
4187 *
4188 * Requires external locking.
4189 *
4190 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4191 * do any widget power switching.
4192 */
4193int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
4194 const char *pin)
4195{
4196 return snd_soc_dapm_set_pin(dapm, pin, 0);
4197}
4198EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
4199
4200/**
Mark Brown5817b522008-09-24 11:23:11 +01004201 * snd_soc_dapm_nc_pin - permanently disable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004202 * @dapm: DAPM context
Mark Brown5817b522008-09-24 11:23:11 +01004203 * @pin: pin name
4204 *
4205 * Marks the specified pin as being not connected, disabling it along
4206 * any parent or child widgets. At present this is identical to
4207 * snd_soc_dapm_disable_pin() but in future it will be extended to do
4208 * additional things such as disabling controls which only affect
4209 * paths through the pin.
4210 *
4211 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4212 * do any widget power switching.
4213 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004214int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
Mark Brown5817b522008-09-24 11:23:11 +01004215{
Charles Keepax11391102014-02-18 15:22:14 +00004216 int ret;
4217
4218 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4219
4220 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4221
4222 mutex_unlock(&dapm->card->dapm_mutex);
4223
4224 return ret;
Mark Brown5817b522008-09-24 11:23:11 +01004225}
4226EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
4227
4228/**
Liam Girdwooda5302182008-07-07 13:35:17 +01004229 * snd_soc_dapm_get_pin_status - get audio pin status
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004230 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01004231 * @pin: audio signal pin endpoint (or start point)
4232 *
4233 * Get audio pin status - connected or disconnected.
4234 *
4235 * Returns 1 for connected otherwise 0.
4236 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004237int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
4238 const char *pin)
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004239{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004240 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004241
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004242 if (w)
4243 return w->connected;
Stephen Warrena68b38a2011-04-19 15:25:11 -06004244
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004245 return 0;
4246}
Liam Girdwooda5302182008-07-07 13:35:17 +01004247EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004248
4249/**
Mark Brown1547aba2010-05-07 21:11:40 +01004250 * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004251 * @dapm: DAPM context
Mark Brown1547aba2010-05-07 21:11:40 +01004252 * @pin: audio signal pin endpoint (or start point)
4253 *
4254 * Mark the given endpoint or pin as ignoring suspend. When the
4255 * system is disabled a path between two endpoints flagged as ignoring
4256 * suspend will not be disabled. The path must already be enabled via
4257 * normal means at suspend time, it will not be turned on if it was not
4258 * already enabled.
4259 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004260int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
4261 const char *pin)
Mark Brown1547aba2010-05-07 21:11:40 +01004262{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004263 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
Mark Brown1547aba2010-05-07 21:11:40 +01004264
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004265 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00004266 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004267 return -EINVAL;
Mark Brown1547aba2010-05-07 21:11:40 +01004268 }
4269
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004270 w->ignore_suspend = 1;
4271
4272 return 0;
Mark Brown1547aba2010-05-07 21:11:40 +01004273}
4274EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
4275
Lars-Peter Clausencdc45082014-10-20 19:36:33 +02004276/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02004277 * snd_soc_dapm_free - free dapm resources
Peter Ujfalusi728a5222011-08-26 16:33:52 +03004278 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02004279 *
4280 * Free all dapm widgets and resources.
4281 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004282void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02004283{
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02004284 dapm_debugfs_cleanup(dapm);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004285 dapm_free_widgets(dapm);
Jarkko Nikula7be31be82010-12-14 12:18:32 +02004286 list_del(&dapm->list);
Richard Purdie2b97eab2006-10-06 18:32:18 +02004287}
4288EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
4289
Xiang Xiao57996352014-03-02 00:04:02 +08004290static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
Mark Brown51737472009-06-22 13:16:51 +01004291{
Liam Girdwood01005a72012-07-06 16:57:05 +01004292 struct snd_soc_card *card = dapm->card;
Mark Brown51737472009-06-22 13:16:51 +01004293 struct snd_soc_dapm_widget *w;
4294 LIST_HEAD(down_list);
4295 int powerdown = 0;
4296
Liam Girdwood01005a72012-07-06 16:57:05 +01004297 mutex_lock(&card->dapm_mutex);
4298
Jarkko Nikula97c866d2010-12-14 12:18:31 +02004299 list_for_each_entry(w, &dapm->card->widgets, list) {
4300 if (w->dapm != dapm)
4301 continue;
Mark Brown51737472009-06-22 13:16:51 +01004302 if (w->power) {
Mark Brown828a8422011-01-15 13:14:30 +00004303 dapm_seq_insert(w, &down_list, false);
Mark Brownc2caa4d2009-06-26 15:36:56 +01004304 w->power = 0;
Mark Brown51737472009-06-22 13:16:51 +01004305 powerdown = 1;
4306 }
4307 }
4308
4309 /* If there were no widgets to power down we're already in
4310 * standby.
4311 */
4312 if (powerdown) {
Mark Brown7679e422012-02-22 15:52:56 +00004313 if (dapm->bias_level == SND_SOC_BIAS_ON)
4314 snd_soc_dapm_set_bias_level(dapm,
4315 SND_SOC_BIAS_PREPARE);
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02004316 dapm_seq_run(card, &down_list, 0, false);
Mark Brown7679e422012-02-22 15:52:56 +00004317 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
4318 snd_soc_dapm_set_bias_level(dapm,
4319 SND_SOC_BIAS_STANDBY);
Mark Brown51737472009-06-22 13:16:51 +01004320 }
Liam Girdwood01005a72012-07-06 16:57:05 +01004321
4322 mutex_unlock(&card->dapm_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00004323}
Mark Brown51737472009-06-22 13:16:51 +01004324
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00004325/*
4326 * snd_soc_dapm_shutdown - callback for system shutdown
4327 */
4328void snd_soc_dapm_shutdown(struct snd_soc_card *card)
4329{
Xiang Xiao57996352014-03-02 00:04:02 +08004330 struct snd_soc_dapm_context *dapm;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00004331
Xiang Xiao57996352014-03-02 00:04:02 +08004332 list_for_each_entry(dapm, &card->dapm_list, list) {
Xiang Xiao17282ba2014-03-02 00:04:03 +08004333 if (dapm != &card->dapm) {
4334 soc_dapm_shutdown_dapm(dapm);
4335 if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
4336 snd_soc_dapm_set_bias_level(dapm,
4337 SND_SOC_BIAS_OFF);
4338 }
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004339 }
Xiang Xiao17282ba2014-03-02 00:04:03 +08004340
4341 soc_dapm_shutdown_dapm(&card->dapm);
4342 if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
4343 snd_soc_dapm_set_bias_level(&card->dapm,
4344 SND_SOC_BIAS_OFF);
Mark Brown51737472009-06-22 13:16:51 +01004345}
4346
Richard Purdie2b97eab2006-10-06 18:32:18 +02004347/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01004348MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Richard Purdie2b97eab2006-10-06 18:32:18 +02004349MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
4350MODULE_LICENSE("GPL");