blob: c4464858bf0160397c3dcbf484a4bd6e3897c2bb [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:
Stephen Warren85762e72013-03-29 15:40:10 -0600826 wname_in_long_name = true;
827 kcname_in_long_name = true;
828 break;
829 case snd_soc_dapm_mixer_named_ctl:
830 wname_in_long_name = false;
831 kcname_in_long_name = true;
832 break;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200833 case snd_soc_dapm_demux:
Stephen Warren85762e72013-03-29 15:40:10 -0600834 case snd_soc_dapm_mux:
Stephen Warren85762e72013-03-29 15:40:10 -0600835 wname_in_long_name = true;
836 kcname_in_long_name = false;
837 break;
838 default:
Stephen Warren85762e72013-03-29 15:40:10 -0600839 return -EINVAL;
840 }
841 }
842
843 if (wname_in_long_name && kcname_in_long_name) {
Stephen Warren85762e72013-03-29 15:40:10 -0600844 /*
845 * The control will get a prefix from the control
846 * creation process but we're also using the same
847 * prefix for widgets so cut the prefix off the
848 * front of the widget name.
849 */
Lars-Peter Clausen2b581072013-05-14 11:05:32 +0200850 long_name = kasprintf(GFP_KERNEL, "%s %s",
Stephen Warren85762e72013-03-29 15:40:10 -0600851 w->name + prefix_len,
852 w->kcontrol_news[kci].name);
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200853 if (long_name == NULL)
Lars-Peter Clausen2b581072013-05-14 11:05:32 +0200854 return -ENOMEM;
Stephen Warren85762e72013-03-29 15:40:10 -0600855
856 name = long_name;
857 } else if (wname_in_long_name) {
858 long_name = NULL;
859 name = w->name + prefix_len;
860 } else {
861 long_name = NULL;
862 name = w->kcontrol_news[kci].name;
863 }
864
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200865 kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,
Stephen Warren85762e72013-03-29 15:40:10 -0600866 prefix);
Daniel Macke5092c92014-10-07 13:41:24 +0200867 if (!kcontrol) {
868 ret = -ENOMEM;
869 goto exit_free;
870 }
871
Lars-Peter Clausen9356e9d2013-08-01 14:08:06 +0200872 kcontrol->private_free = dapm_kcontrol_free;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200873
Lars-Peter Clausen41d80022016-02-03 21:59:50 +0100874 ret = dapm_kcontrol_data_alloc(w, kcontrol, name);
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200875 if (ret) {
876 snd_ctl_free_one(kcontrol);
Daniel Macke5092c92014-10-07 13:41:24 +0200877 goto exit_free;
Lars-Peter Clausene84357f2013-07-29 17:13:58 +0200878 }
879
Stephen Warren85762e72013-03-29 15:40:10 -0600880 ret = snd_ctl_add(card, kcontrol);
881 if (ret < 0) {
882 dev_err(dapm->dev,
883 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
884 w->name, name, ret);
Daniel Macke5092c92014-10-07 13:41:24 +0200885 goto exit_free;
Stephen Warren85762e72013-03-29 15:40:10 -0600886 }
Stephen Warren85762e72013-03-29 15:40:10 -0600887 }
888
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200889 ret = dapm_kcontrol_add_widget(kcontrol, w);
Daniel Macke5092c92014-10-07 13:41:24 +0200890 if (ret == 0)
891 w->kcontrols[kci] = kcontrol;
Lars-Peter Clausen2c75bdf2013-08-01 14:08:07 +0200892
Daniel Macke5092c92014-10-07 13:41:24 +0200893exit_free:
894 kfree(long_name);
Stephen Warren85762e72013-03-29 15:40:10 -0600895
Daniel Macke5092c92014-10-07 13:41:24 +0200896 return ret;
Stephen Warren85762e72013-03-29 15:40:10 -0600897}
898
899/* create new dapm mixer control */
900static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
901{
902 int i, ret;
903 struct snd_soc_dapm_path *path;
Charles Keepax561ed682015-05-01 12:37:26 +0100904 struct dapm_kcontrol_data *data;
Stephen Warren85762e72013-03-29 15:40:10 -0600905
Richard Purdie2b97eab2006-10-06 18:32:18 +0200906 /* add kcontrol */
907 for (i = 0; i < w->num_kcontrols; i++) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200908 /* match name */
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +0200909 snd_soc_dapm_widget_for_each_source_path(w, path) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200910 /* mixer/mux paths name must match control name */
Stephen Warren82cfecd2011-04-28 17:37:58 -0600911 if (path->name != (char *)w->kcontrol_news[i].name)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200912 continue;
913
Charles Keepax561ed682015-05-01 12:37:26 +0100914 if (!w->kcontrols[i]) {
Jeeja KP19a2557b2015-10-20 22:30:06 +0530915 ret = dapm_create_or_share_kcontrol(w, i);
Charles Keepax561ed682015-05-01 12:37:26 +0100916 if (ret < 0)
917 return ret;
Lars-Peter Clausen82cd8762011-08-15 20:15:21 +0200918 }
919
Mark Brown946d92a2013-08-12 23:28:42 +0100920 dapm_kcontrol_add_path(w->kcontrols[i], path);
Charles Keepax561ed682015-05-01 12:37:26 +0100921
922 data = snd_kcontrol_chip(w->kcontrols[i]);
923 if (data->widget)
924 snd_soc_dapm_add_path(data->widget->dapm,
925 data->widget,
926 path->source,
927 NULL, NULL);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200928 }
929 }
Stephen Warren85762e72013-03-29 15:40:10 -0600930
931 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200932}
933
934/* create new dapm mux control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200935static int dapm_new_mux(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200936{
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200937 struct snd_soc_dapm_context *dapm = w->dapm;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200938 enum snd_soc_dapm_direction dir;
Stephen Warren85762e72013-03-29 15:40:10 -0600939 struct snd_soc_dapm_path *path;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200940 const char *type;
Stephen Warrenaf468002011-04-28 17:38:01 -0600941 int ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200942
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200943 switch (w->id) {
944 case snd_soc_dapm_mux:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200945 dir = SND_SOC_DAPM_DIR_OUT;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200946 type = "mux";
947 break;
948 case snd_soc_dapm_demux:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200949 dir = SND_SOC_DAPM_DIR_IN;
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200950 type = "demux";
951 break;
952 default:
953 return -EINVAL;
954 }
955
Stephen Warrenaf468002011-04-28 17:38:01 -0600956 if (w->num_kcontrols != 1) {
957 dev_err(dapm->dev,
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200958 "ASoC: %s %s has incorrect number of controls\n", type,
Stephen Warrenaf468002011-04-28 17:38:01 -0600959 w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200960 return -EINVAL;
961 }
962
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200963 if (list_empty(&w->edges[dir])) {
Lars-Peter Clausend714f972015-05-01 18:02:43 +0200964 dev_err(dapm->dev, "ASoC: %s %s has no paths\n", type, w->name);
Stephen Warren85762e72013-03-29 15:40:10 -0600965 return -EINVAL;
Stephen Warrenaf468002011-04-28 17:38:01 -0600966 }
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200967
Jeeja KP19a2557b2015-10-20 22:30:06 +0530968 ret = dapm_create_or_share_kcontrol(w, 0);
Stephen Warren85762e72013-03-29 15:40:10 -0600969 if (ret < 0)
970 return ret;
Stephen Warrenfad59882011-04-28 17:37:59 -0600971
Lars-Peter Clausena3423b02015-08-11 21:38:00 +0200972 snd_soc_dapm_widget_for_each_path(w, dir, path) {
973 if (path->name)
974 dapm_kcontrol_add_path(w->kcontrols[0], path);
Lars-Peter Clausen98407ef2014-10-25 17:41:57 +0200975 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200976
Stephen Warrenaf468002011-04-28 17:38:01 -0600977 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200978}
979
980/* create new dapm volume control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200981static int dapm_new_pga(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200982{
Jeeja KP19a2557b2015-10-20 22:30:06 +0530983 int i, ret;
984
985 for (i = 0; i < w->num_kcontrols; i++) {
986 ret = dapm_create_or_share_kcontrol(w, i);
987 if (ret < 0)
988 return ret;
989 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200990
Mark Browna6c65732010-03-03 17:45:21 +0000991 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200992}
993
Nikesh Oswalc6615082015-02-02 17:06:44 +0000994/* create new dapm dai link control */
995static int dapm_new_dai_link(struct snd_soc_dapm_widget *w)
996{
997 int i, ret;
998 struct snd_kcontrol *kcontrol;
999 struct snd_soc_dapm_context *dapm = w->dapm;
1000 struct snd_card *card = dapm->card->snd_card;
1001
1002 /* create control for links with > 1 config */
1003 if (w->num_params <= 1)
1004 return 0;
1005
1006 /* add kcontrol */
1007 for (i = 0; i < w->num_kcontrols; i++) {
1008 kcontrol = snd_soc_cnew(&w->kcontrol_news[i], w,
1009 w->name, NULL);
1010 ret = snd_ctl_add(card, kcontrol);
1011 if (ret < 0) {
1012 dev_err(dapm->dev,
1013 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
1014 w->name, w->kcontrol_news[i].name, ret);
1015 return ret;
1016 }
1017 kcontrol->private_data = w;
1018 w->kcontrols[i] = kcontrol;
1019 }
1020
1021 return 0;
1022}
1023
Mark Brown99497882010-05-07 20:24:05 +01001024/* We implement power down on suspend by checking the power state of
1025 * the ALSA card - when we are suspending the ALSA state for the card
1026 * is set to D3.
1027 */
1028static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
1029{
Mark Brown12ea2c72011-03-02 18:17:32 +00001030 int level = snd_power_get_state(widget->dapm->card->snd_card);
Mark Brown99497882010-05-07 20:24:05 +01001031
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001032 switch (level) {
Mark Brown99497882010-05-07 20:24:05 +01001033 case SNDRV_CTL_POWER_D3hot:
1034 case SNDRV_CTL_POWER_D3cold:
Mark Brown1547aba2010-05-07 21:11:40 +01001035 if (widget->ignore_suspend)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001036 dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02001037 widget->name);
Mark Brown1547aba2010-05-07 21:11:40 +01001038 return widget->ignore_suspend;
Mark Brown99497882010-05-07 20:24:05 +01001039 default:
1040 return 1;
1041 }
1042}
1043
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001044static int dapm_widget_list_create(struct snd_soc_dapm_widget_list **list,
1045 struct list_head *widgets)
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001046{
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001047 struct snd_soc_dapm_widget *w;
1048 struct list_head *it;
1049 unsigned int size = 0;
1050 unsigned int i = 0;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001051
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001052 list_for_each(it, widgets)
1053 size++;
1054
1055 *list = kzalloc(sizeof(**list) + size * sizeof(*w), GFP_KERNEL);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001056 if (*list == NULL)
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001057 return -ENOMEM;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001058
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001059 list_for_each_entry(w, widgets, work_list)
1060 (*list)->widgets[i++] = w;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001061
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001062 (*list)->num_widgets = i;
1063
1064 return 0;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001065}
1066
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001067/*
1068 * Common implementation for is_connected_output_ep() and
1069 * is_connected_input_ep(). The function is inlined since the combined size of
1070 * the two specialized functions is only marginally larger then the size of the
1071 * generic function and at the same time the fast path of the specialized
1072 * functions is significantly smaller than the generic function.
1073 */
1074static __always_inline int is_connected_ep(struct snd_soc_dapm_widget *widget,
1075 struct list_head *list, enum snd_soc_dapm_direction dir,
1076 int (*fn)(struct snd_soc_dapm_widget *, struct list_head *))
1077{
1078 enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001079 struct snd_soc_dapm_path *path;
1080 int con = 0;
1081
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001082 if (widget->endpoints[dir] >= 0)
1083 return widget->endpoints[dir];
Mark Brown024dc072011-10-09 11:52:05 +01001084
Mark Brownde02d072011-09-20 21:43:24 +01001085 DAPM_UPDATE_STAT(widget, path_checks);
1086
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001087 /* do we need to add this widget to the list ? */
1088 if (list)
1089 list_add_tail(&widget->work_list, list);
1090
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001091 if ((widget->is_ep & SND_SOC_DAPM_DIR_TO_EP(dir)) && widget->connected) {
1092 widget->endpoints[dir] = snd_soc_dapm_suspend_check(widget);
1093 return widget->endpoints[dir];
Richard Purdie2b97eab2006-10-06 18:32:18 +02001094 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02001095
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001096 snd_soc_dapm_widget_for_each_path(widget, rdir, path) {
Mark Browne56235e2011-09-21 18:19:14 +01001097 DAPM_UPDATE_STAT(widget, neighbour_checks);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001098
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02001099 if (path->weak || path->is_supply)
Mark Brownbf3a9e12011-06-13 16:42:29 +01001100 continue;
1101
Mark Brown8af294b2013-02-22 17:48:15 +00001102 if (path->walking)
1103 return 1;
1104
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001105 trace_snd_soc_dapm_path(widget, dir, path);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001106
Lars-Peter Clausen7ddd4cd2014-10-20 19:36:34 +02001107 if (path->connect) {
Mark Brown8af294b2013-02-22 17:48:15 +00001108 path->walking = 1;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001109 con += fn(path->node[dir], list);
Mark Brown8af294b2013-02-22 17:48:15 +00001110 path->walking = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001111 }
1112 }
1113
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001114 widget->endpoints[dir] = con;
Mark Brown024dc072011-10-09 11:52:05 +01001115
Richard Purdie2b97eab2006-10-06 18:32:18 +02001116 return con;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001117}
1118
1119/*
1120 * Recursively check for a completed path to an active or physically connected
1121 * output widget. Returns number of complete paths.
1122 */
1123static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001124 struct list_head *list)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001125{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001126 return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_OUT,
1127 is_connected_output_ep);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001128}
1129
1130/*
1131 * Recursively check for a completed path to an active or physically connected
1132 * input widget. Returns number of complete paths.
1133 */
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001134static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001135 struct list_head *list)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001136{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001137 return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_IN,
1138 is_connected_input_ep);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001139}
1140
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001141/**
1142 * snd_soc_dapm_get_connected_widgets - query audio path and it's widgets.
1143 * @dai: the soc DAI.
1144 * @stream: stream direction.
1145 * @list: list of active widgets for this stream.
1146 *
1147 * Queries DAPM graph as to whether an valid audio stream path exists for
1148 * the initial stream specified by name. This takes into account
1149 * current mixer and mux kcontrol settings. Creates list of valid widgets.
1150 *
1151 * Returns the number of valid paths or negative error.
1152 */
1153int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
1154 struct snd_soc_dapm_widget_list **list)
1155{
Lars-Peter Clausen313665b2014-11-04 11:30:58 +01001156 struct snd_soc_card *card = dai->component->card;
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02001157 struct snd_soc_dapm_widget *w;
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001158 LIST_HEAD(widgets);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001159 int paths;
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001160 int ret;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001161
1162 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02001163
1164 /*
1165 * For is_connected_{output,input}_ep fully discover the graph we need
1166 * to reset the cached number of inputs and outputs.
1167 */
1168 list_for_each_entry(w, &card->widgets, list) {
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001169 w->endpoints[SND_SOC_DAPM_DIR_IN] = -1;
1170 w->endpoints[SND_SOC_DAPM_DIR_OUT] = -1;
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02001171 }
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001172
Lars-Peter Clausen130897a2014-10-20 19:36:39 +02001173 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001174 paths = is_connected_output_ep(dai->playback_widget, &widgets);
Lars-Peter Clausen130897a2014-10-20 19:36:39 +02001175 else
Lars-Peter Clausen1ce43ac2015-07-26 19:04:59 +02001176 paths = is_connected_input_ep(dai->capture_widget, &widgets);
1177
1178 /* Drop starting point */
1179 list_del(widgets.next);
1180
1181 ret = dapm_widget_list_create(list, &widgets);
1182 if (ret)
Lars-Peter Clausen30abbe72015-08-11 21:37:59 +02001183 paths = ret;
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001184
1185 trace_snd_soc_dapm_connected(paths, stream);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001186 mutex_unlock(&card->dapm_mutex);
1187
1188 return paths;
1189}
1190
Richard Purdie2b97eab2006-10-06 18:32:18 +02001191/*
Mark Brown62ea8742012-01-21 21:14:48 +00001192 * Handler for regulator supply widget.
1193 */
1194int dapm_regulator_event(struct snd_soc_dapm_widget *w,
1195 struct snd_kcontrol *kcontrol, int event)
1196{
Mark Brownc05b84d2012-09-07 12:57:11 +08001197 int ret;
1198
Mark Browneb270e92013-10-09 13:52:52 +01001199 soc_dapm_async_complete(w->dapm);
1200
Mark Brownc05b84d2012-09-07 12:57:11 +08001201 if (SND_SOC_DAPM_EVENT_ON(event)) {
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001202 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
Mark Brown8784c772013-01-10 19:33:47 +00001203 ret = regulator_allow_bypass(w->regulator, false);
Mark Brownc05b84d2012-09-07 12:57:11 +08001204 if (ret != 0)
1205 dev_warn(w->dapm->dev,
Charles Keepax30686c32014-02-18 16:05:27 +00001206 "ASoC: Failed to unbypass %s: %d\n",
Mark Brownc05b84d2012-09-07 12:57:11 +08001207 w->name, ret);
1208 }
1209
Liam Girdwooda3cc0562012-03-09 17:20:16 +00001210 return regulator_enable(w->regulator);
Mark Brownc05b84d2012-09-07 12:57:11 +08001211 } else {
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001212 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
Mark Brown8784c772013-01-10 19:33:47 +00001213 ret = regulator_allow_bypass(w->regulator, true);
Mark Brownc05b84d2012-09-07 12:57:11 +08001214 if (ret != 0)
1215 dev_warn(w->dapm->dev,
Charles Keepax30686c32014-02-18 16:05:27 +00001216 "ASoC: Failed to bypass %s: %d\n",
Mark Brownc05b84d2012-09-07 12:57:11 +08001217 w->name, ret);
1218 }
1219
Liam Girdwooda3cc0562012-03-09 17:20:16 +00001220 return regulator_disable_deferred(w->regulator, w->shift);
Mark Brownc05b84d2012-09-07 12:57:11 +08001221 }
Mark Brown62ea8742012-01-21 21:14:48 +00001222}
1223EXPORT_SYMBOL_GPL(dapm_regulator_event);
1224
Ola Liljad7e7eb92012-05-24 15:26:25 +02001225/*
1226 * Handler for clock supply widget.
1227 */
1228int dapm_clock_event(struct snd_soc_dapm_widget *w,
1229 struct snd_kcontrol *kcontrol, int event)
1230{
1231 if (!w->clk)
1232 return -EIO;
1233
Mark Browneb270e92013-10-09 13:52:52 +01001234 soc_dapm_async_complete(w->dapm);
1235
Mark Brownec029952012-06-04 08:16:20 +01001236#ifdef CONFIG_HAVE_CLK
Ola Liljad7e7eb92012-05-24 15:26:25 +02001237 if (SND_SOC_DAPM_EVENT_ON(event)) {
Fabio Baltieri37c1b922013-04-30 16:09:52 +02001238 return clk_prepare_enable(w->clk);
Ola Liljad7e7eb92012-05-24 15:26:25 +02001239 } else {
Fabio Baltieri37c1b922013-04-30 16:09:52 +02001240 clk_disable_unprepare(w->clk);
Ola Liljad7e7eb92012-05-24 15:26:25 +02001241 return 0;
1242 }
Mark Brownec029952012-06-04 08:16:20 +01001243#endif
Marek Belisko98b3cf12012-07-12 23:00:16 +02001244 return 0;
Ola Liljad7e7eb92012-05-24 15:26:25 +02001245}
1246EXPORT_SYMBOL_GPL(dapm_clock_event);
1247
Mark Brownd8050022011-09-28 18:28:23 +01001248static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1249{
Mark Brown9b8a83b2011-10-04 22:15:59 +01001250 if (w->power_checked)
1251 return w->new_power;
1252
Mark Brownd8050022011-09-28 18:28:23 +01001253 if (w->force)
Mark Brown9b8a83b2011-10-04 22:15:59 +01001254 w->new_power = 1;
Mark Brownd8050022011-09-28 18:28:23 +01001255 else
Mark Brown9b8a83b2011-10-04 22:15:59 +01001256 w->new_power = w->power_check(w);
1257
1258 w->power_checked = true;
1259
1260 return w->new_power;
Mark Brownd8050022011-09-28 18:28:23 +01001261}
1262
Mark Browncd0f2d42009-04-20 16:56:59 +01001263/* Generic check to see if a widget should be powered.
1264 */
1265static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1266{
1267 int in, out;
1268
Mark Brownde02d072011-09-20 21:43:24 +01001269 DAPM_UPDATE_STAT(w, power_checks);
1270
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001271 in = is_connected_input_ep(w, NULL);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001272 out = is_connected_output_ep(w, NULL);
Mark Browncd0f2d42009-04-20 16:56:59 +01001273 return out != 0 && in != 0;
1274}
1275
Mark Brown246d0a12009-04-22 18:24:55 +01001276/* Check to see if a power supply is needed */
1277static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1278{
1279 struct snd_soc_dapm_path *path;
Mark Brown246d0a12009-04-22 18:24:55 +01001280
Mark Brownde02d072011-09-20 21:43:24 +01001281 DAPM_UPDATE_STAT(w, power_checks);
1282
Mark Brown246d0a12009-04-22 18:24:55 +01001283 /* Check if one of our outputs is connected */
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02001284 snd_soc_dapm_widget_for_each_sink_path(w, path) {
Mark Browna8fdac82011-09-28 18:20:26 +01001285 DAPM_UPDATE_STAT(w, neighbour_checks);
1286
Mark Brownbf3a9e12011-06-13 16:42:29 +01001287 if (path->weak)
1288 continue;
1289
Mark Brown215edda2009-09-08 18:59:05 +01001290 if (path->connected &&
1291 !path->connected(path->source, path->sink))
1292 continue;
1293
Mark Brownf68d7e12011-10-04 22:57:50 +01001294 if (dapm_widget_power_check(path->sink))
1295 return 1;
Mark Brown246d0a12009-04-22 18:24:55 +01001296 }
1297
Mark Brownf68d7e12011-10-04 22:57:50 +01001298 return 0;
Mark Brown246d0a12009-04-22 18:24:55 +01001299}
1300
Mark Brown35c64bc2011-09-28 18:23:53 +01001301static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1302{
Charles Keepax20bb0182015-12-02 10:22:16 +00001303 return w->connected;
Mark Brown35c64bc2011-09-28 18:23:53 +01001304}
1305
Mark Brown38357ab2009-06-06 19:03:23 +01001306static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
1307 struct snd_soc_dapm_widget *b,
Mark Brown828a8422011-01-15 13:14:30 +00001308 bool power_up)
Mark Brown42aa3412009-03-01 19:21:10 +00001309{
Mark Brown828a8422011-01-15 13:14:30 +00001310 int *sort;
1311
1312 if (power_up)
1313 sort = dapm_up_seq;
1314 else
1315 sort = dapm_down_seq;
1316
Mark Brown38357ab2009-06-06 19:03:23 +01001317 if (sort[a->id] != sort[b->id])
1318 return sort[a->id] - sort[b->id];
Mark Brown20e48592011-01-15 13:40:50 +00001319 if (a->subseq != b->subseq) {
1320 if (power_up)
1321 return a->subseq - b->subseq;
1322 else
1323 return b->subseq - a->subseq;
1324 }
Mark Brownb22ead22009-06-07 12:51:26 +01001325 if (a->reg != b->reg)
1326 return a->reg - b->reg;
Mark Brown84dab562010-11-12 15:28:42 +00001327 if (a->dapm != b->dapm)
1328 return (unsigned long)a->dapm - (unsigned long)b->dapm;
Mark Brown42aa3412009-03-01 19:21:10 +00001329
Mark Brown38357ab2009-06-06 19:03:23 +01001330 return 0;
1331}
Mark Brown42aa3412009-03-01 19:21:10 +00001332
Mark Brown38357ab2009-06-06 19:03:23 +01001333/* Insert a widget in order into a DAPM power sequence. */
1334static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
1335 struct list_head *list,
Mark Brown828a8422011-01-15 13:14:30 +00001336 bool power_up)
Mark Brown38357ab2009-06-06 19:03:23 +01001337{
1338 struct snd_soc_dapm_widget *w;
1339
1340 list_for_each_entry(w, list, power_list)
Mark Brown828a8422011-01-15 13:14:30 +00001341 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
Mark Brown38357ab2009-06-06 19:03:23 +01001342 list_add_tail(&new_widget->power_list, &w->power_list);
1343 return;
Mark Brown42aa3412009-03-01 19:21:10 +00001344 }
Mark Brown6ea31b92009-04-20 17:15:41 +01001345
Mark Brown38357ab2009-06-06 19:03:23 +01001346 list_add_tail(&new_widget->power_list, list);
1347}
Mark Brown42aa3412009-03-01 19:21:10 +00001348
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001349static void dapm_seq_check_event(struct snd_soc_card *card,
Mark Brown68f89ad2010-11-03 23:51:49 -04001350 struct snd_soc_dapm_widget *w, int event)
1351{
Mark Brown68f89ad2010-11-03 23:51:49 -04001352 const char *ev_name;
1353 int power, ret;
1354
1355 switch (event) {
1356 case SND_SOC_DAPM_PRE_PMU:
1357 ev_name = "PRE_PMU";
1358 power = 1;
1359 break;
1360 case SND_SOC_DAPM_POST_PMU:
1361 ev_name = "POST_PMU";
1362 power = 1;
1363 break;
1364 case SND_SOC_DAPM_PRE_PMD:
1365 ev_name = "PRE_PMD";
1366 power = 0;
1367 break;
1368 case SND_SOC_DAPM_POST_PMD:
1369 ev_name = "POST_PMD";
1370 power = 0;
1371 break;
Mark Brown80114122013-02-25 15:14:19 +00001372 case SND_SOC_DAPM_WILL_PMU:
1373 ev_name = "WILL_PMU";
1374 power = 1;
1375 break;
1376 case SND_SOC_DAPM_WILL_PMD:
1377 ev_name = "WILL_PMD";
1378 power = 0;
1379 break;
Mark Brown68f89ad2010-11-03 23:51:49 -04001380 default:
Takashi Iwaia6ed0602013-11-06 11:07:19 +01001381 WARN(1, "Unknown event %d\n", event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001382 return;
1383 }
1384
Lars-Peter Clausen39eb5fd2013-07-29 17:14:03 +02001385 if (w->new_power != power)
Mark Brown68f89ad2010-11-03 23:51:49 -04001386 return;
1387
1388 if (w->event && (w->event_flags & event)) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001389 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
Mark Brown68f89ad2010-11-03 23:51:49 -04001390 w->name, ev_name);
Mark Browneb270e92013-10-09 13:52:52 +01001391 soc_dapm_async_complete(w->dapm);
Mark Brown84e90932010-11-04 00:07:02 -04001392 trace_snd_soc_dapm_widget_event_start(w, event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001393 ret = w->event(w, NULL, event);
Mark Brown84e90932010-11-04 00:07:02 -04001394 trace_snd_soc_dapm_widget_event_done(w, event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001395 if (ret < 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001396 dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
Mark Brown68f89ad2010-11-03 23:51:49 -04001397 ev_name, w->name, ret);
1398 }
1399}
1400
Mark Brownb22ead22009-06-07 12:51:26 +01001401/* Apply the coalesced changes from a DAPM sequence */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001402static void dapm_seq_run_coalesced(struct snd_soc_card *card,
Mark Brownb22ead22009-06-07 12:51:26 +01001403 struct list_head *pending)
Mark Brown163cac02009-06-07 10:12:52 +01001404{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001405 struct snd_soc_dapm_context *dapm;
Mark Brown68f89ad2010-11-03 23:51:49 -04001406 struct snd_soc_dapm_widget *w;
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001407 int reg;
Mark Brownb22ead22009-06-07 12:51:26 +01001408 unsigned int value = 0;
1409 unsigned int mask = 0;
Mark Brownb22ead22009-06-07 12:51:26 +01001410
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001411 w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
1412 reg = w->reg;
1413 dapm = w->dapm;
Mark Brownb22ead22009-06-07 12:51:26 +01001414
1415 list_for_each_entry(w, pending, power_list) {
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001416 WARN_ON(reg != w->reg || dapm != w->dapm);
Lars-Peter Clausen39eb5fd2013-07-29 17:14:03 +02001417 w->power = w->new_power;
Mark Brownb22ead22009-06-07 12:51:26 +01001418
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001419 mask |= w->mask << w->shift;
1420 if (w->power)
1421 value |= w->on_val << w->shift;
Mark Brownb22ead22009-06-07 12:51:26 +01001422 else
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001423 value |= w->off_val << w->shift;
Mark Brownb22ead22009-06-07 12:51:26 +01001424
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001425 pop_dbg(dapm->dev, card->pop_time,
Mark Brownb22ead22009-06-07 12:51:26 +01001426 "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1427 w->name, reg, value, mask);
Mark Brown81628102009-06-07 13:21:24 +01001428
Mark Brown68f89ad2010-11-03 23:51:49 -04001429 /* Check for events */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001430 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
1431 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
Mark Brownb22ead22009-06-07 12:51:26 +01001432 }
1433
Mark Brown81628102009-06-07 13:21:24 +01001434 if (reg >= 0) {
Mark Brown29376bc2011-06-19 13:49:28 +01001435 /* Any widget will do, they should all be updating the
1436 * same register.
1437 */
Mark Brown29376bc2011-06-19 13:49:28 +01001438
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001439 pop_dbg(dapm->dev, card->pop_time,
Mark Brown81628102009-06-07 13:21:24 +01001440 "pop test : Applying 0x%x/0x%x to %x in %dms\n",
Jarkko Nikula3a45b862010-11-05 20:35:21 +02001441 value, mask, reg, card->pop_time);
1442 pop_wait(card->pop_time);
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001443 soc_dapm_update_bits(dapm, reg, mask, value);
Mark Brown81628102009-06-07 13:21:24 +01001444 }
1445
1446 list_for_each_entry(w, pending, power_list) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001447 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
1448 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
Mark Brown42aa3412009-03-01 19:21:10 +00001449 }
Mark Brown42aa3412009-03-01 19:21:10 +00001450}
1451
Mark Brownb22ead22009-06-07 12:51:26 +01001452/* Apply a DAPM power sequence.
1453 *
1454 * We walk over a pre-sorted list of widgets to apply power to. In
1455 * order to minimise the number of writes to the device required
1456 * multiple widgets will be updated in a single write where possible.
1457 * Currently anything that requires more than a single write is not
1458 * handled.
1459 */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001460static void dapm_seq_run(struct snd_soc_card *card,
1461 struct list_head *list, int event, bool power_up)
Mark Brownb22ead22009-06-07 12:51:26 +01001462{
1463 struct snd_soc_dapm_widget *w, *n;
Mark Browneb270e92013-10-09 13:52:52 +01001464 struct snd_soc_dapm_context *d;
Mark Brownb22ead22009-06-07 12:51:26 +01001465 LIST_HEAD(pending);
1466 int cur_sort = -1;
Mark Brown20e48592011-01-15 13:40:50 +00001467 int cur_subseq = -1;
Mark Brownb22ead22009-06-07 12:51:26 +01001468 int cur_reg = SND_SOC_NOPM;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001469 struct snd_soc_dapm_context *cur_dapm = NULL;
Mark Brown474b62d2011-01-18 16:14:44 +00001470 int ret, i;
Mark Brown828a8422011-01-15 13:14:30 +00001471 int *sort;
1472
1473 if (power_up)
1474 sort = dapm_up_seq;
1475 else
1476 sort = dapm_down_seq;
Mark Brown163cac02009-06-07 10:12:52 +01001477
Mark Brownb22ead22009-06-07 12:51:26 +01001478 list_for_each_entry_safe(w, n, list, power_list) {
1479 ret = 0;
1480
1481 /* Do we need to apply any queued changes? */
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001482 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
Mark Brown20e48592011-01-15 13:40:50 +00001483 w->dapm != cur_dapm || w->subseq != cur_subseq) {
Mark Brownb22ead22009-06-07 12:51:26 +01001484 if (!list_empty(&pending))
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001485 dapm_seq_run_coalesced(card, &pending);
Mark Brownb22ead22009-06-07 12:51:26 +01001486
Mark Brown474b62d2011-01-18 16:14:44 +00001487 if (cur_dapm && cur_dapm->seq_notifier) {
1488 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1489 if (sort[i] == cur_sort)
1490 cur_dapm->seq_notifier(cur_dapm,
Mark Brownf85a9e02011-01-26 21:41:28 +00001491 i,
1492 cur_subseq);
Mark Brown474b62d2011-01-18 16:14:44 +00001493 }
1494
Mark Browneb270e92013-10-09 13:52:52 +01001495 if (cur_dapm && w->dapm != cur_dapm)
1496 soc_dapm_async_complete(cur_dapm);
1497
Mark Brownb22ead22009-06-07 12:51:26 +01001498 INIT_LIST_HEAD(&pending);
1499 cur_sort = -1;
Mark Brownb0b3e6f2011-07-16 10:55:08 +09001500 cur_subseq = INT_MIN;
Mark Brownb22ead22009-06-07 12:51:26 +01001501 cur_reg = SND_SOC_NOPM;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001502 cur_dapm = NULL;
Mark Brownb22ead22009-06-07 12:51:26 +01001503 }
1504
Mark Brown163cac02009-06-07 10:12:52 +01001505 switch (w->id) {
1506 case snd_soc_dapm_pre:
1507 if (!w->event)
Mark Brownb22ead22009-06-07 12:51:26 +01001508 list_for_each_entry_safe_continue(w, n, list,
1509 power_list);
Mark Brown163cac02009-06-07 10:12:52 +01001510
Mark Brownb22ead22009-06-07 12:51:26 +01001511 if (event == SND_SOC_DAPM_STREAM_START)
Mark Brown163cac02009-06-07 10:12:52 +01001512 ret = w->event(w,
1513 NULL, SND_SOC_DAPM_PRE_PMU);
Mark Brownb22ead22009-06-07 12:51:26 +01001514 else if (event == SND_SOC_DAPM_STREAM_STOP)
Mark Brown163cac02009-06-07 10:12:52 +01001515 ret = w->event(w,
1516 NULL, SND_SOC_DAPM_PRE_PMD);
Mark Brown163cac02009-06-07 10:12:52 +01001517 break;
1518
1519 case snd_soc_dapm_post:
1520 if (!w->event)
Mark Brownb22ead22009-06-07 12:51:26 +01001521 list_for_each_entry_safe_continue(w, n, list,
1522 power_list);
Mark Brown163cac02009-06-07 10:12:52 +01001523
Mark Brownb22ead22009-06-07 12:51:26 +01001524 if (event == SND_SOC_DAPM_STREAM_START)
Mark Brown163cac02009-06-07 10:12:52 +01001525 ret = w->event(w,
1526 NULL, SND_SOC_DAPM_POST_PMU);
Mark Brownb22ead22009-06-07 12:51:26 +01001527 else if (event == SND_SOC_DAPM_STREAM_STOP)
Mark Brown163cac02009-06-07 10:12:52 +01001528 ret = w->event(w,
1529 NULL, SND_SOC_DAPM_POST_PMD);
Mark Brownb22ead22009-06-07 12:51:26 +01001530 break;
1531
Mark Brown163cac02009-06-07 10:12:52 +01001532 default:
Mark Brown81628102009-06-07 13:21:24 +01001533 /* Queue it up for application */
1534 cur_sort = sort[w->id];
Mark Brown20e48592011-01-15 13:40:50 +00001535 cur_subseq = w->subseq;
Mark Brown81628102009-06-07 13:21:24 +01001536 cur_reg = w->reg;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001537 cur_dapm = w->dapm;
Mark Brown81628102009-06-07 13:21:24 +01001538 list_move(&w->power_list, &pending);
1539 break;
Mark Brown163cac02009-06-07 10:12:52 +01001540 }
Mark Brownb22ead22009-06-07 12:51:26 +01001541
1542 if (ret < 0)
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02001543 dev_err(w->dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001544 "ASoC: Failed to apply widget power: %d\n", ret);
Mark Brown163cac02009-06-07 10:12:52 +01001545 }
Mark Brownb22ead22009-06-07 12:51:26 +01001546
1547 if (!list_empty(&pending))
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001548 dapm_seq_run_coalesced(card, &pending);
Mark Brown474b62d2011-01-18 16:14:44 +00001549
1550 if (cur_dapm && cur_dapm->seq_notifier) {
1551 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1552 if (sort[i] == cur_sort)
1553 cur_dapm->seq_notifier(cur_dapm,
Mark Brownf85a9e02011-01-26 21:41:28 +00001554 i, cur_subseq);
Mark Brown474b62d2011-01-18 16:14:44 +00001555 }
Mark Browneb270e92013-10-09 13:52:52 +01001556
1557 list_for_each_entry(d, &card->dapm_list, list) {
1558 soc_dapm_async_complete(d);
1559 }
Mark Brown163cac02009-06-07 10:12:52 +01001560}
1561
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001562static void dapm_widget_update(struct snd_soc_card *card)
Mark Brown97404f22010-12-14 16:13:57 +00001563{
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001564 struct snd_soc_dapm_update *update = card->update;
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001565 struct snd_soc_dapm_widget_list *wlist;
1566 struct snd_soc_dapm_widget *w = NULL;
1567 unsigned int wi;
Mark Brown97404f22010-12-14 16:13:57 +00001568 int ret;
1569
Lars-Peter Clausen57295072013-08-05 11:27:31 +02001570 if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
Mark Brown97404f22010-12-14 16:13:57 +00001571 return;
1572
Lars-Peter Clausene84357f2013-07-29 17:13:58 +02001573 wlist = dapm_kcontrol_get_wlist(update->kcontrol);
Mark Brown97404f22010-12-14 16:13:57 +00001574
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001575 for (wi = 0; wi < wlist->num_widgets; wi++) {
1576 w = wlist->widgets[wi];
1577
1578 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1579 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1580 if (ret != 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001581 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001582 w->name, ret);
1583 }
Mark Brown97404f22010-12-14 16:13:57 +00001584 }
1585
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001586 if (!w)
1587 return;
1588
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02001589 ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
1590 update->val);
Mark Brown97404f22010-12-14 16:13:57 +00001591 if (ret < 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001592 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001593 w->name, ret);
Mark Brown97404f22010-12-14 16:13:57 +00001594
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001595 for (wi = 0; wi < wlist->num_widgets; wi++) {
1596 w = wlist->widgets[wi];
1597
1598 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1599 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1600 if (ret != 0)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001601 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02001602 w->name, ret);
1603 }
Mark Brown97404f22010-12-14 16:13:57 +00001604 }
1605}
1606
Mark Brown9d0624a2011-02-18 11:49:43 -08001607/* Async callback run prior to DAPM sequences - brings to _PREPARE if
1608 * they're changing state.
1609 */
1610static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1611{
1612 struct snd_soc_dapm_context *d = data;
1613 int ret;
Mark Brown97404f22010-12-14 16:13:57 +00001614
Mark Brown56fba412011-06-04 11:25:10 +01001615 /* If we're off and we're not supposed to be go into STANDBY */
1616 if (d->bias_level == SND_SOC_BIAS_OFF &&
1617 d->target_bias_level != SND_SOC_BIAS_OFF) {
Mark Brownf1aac482011-12-05 15:17:06 +00001618 if (d->dev)
1619 pm_runtime_get_sync(d->dev);
1620
Mark Brown9d0624a2011-02-18 11:49:43 -08001621 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1622 if (ret != 0)
1623 dev_err(d->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001624 "ASoC: Failed to turn on bias: %d\n", ret);
Mark Brown9d0624a2011-02-18 11:49:43 -08001625 }
1626
Lars-Peter Clausence85a4d2014-05-06 10:32:15 +02001627 /* Prepare for a transition to ON or away from ON */
1628 if ((d->target_bias_level == SND_SOC_BIAS_ON &&
1629 d->bias_level != SND_SOC_BIAS_ON) ||
1630 (d->target_bias_level != SND_SOC_BIAS_ON &&
1631 d->bias_level == SND_SOC_BIAS_ON)) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001632 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1633 if (ret != 0)
1634 dev_err(d->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001635 "ASoC: Failed to prepare bias: %d\n", ret);
Mark Brown9d0624a2011-02-18 11:49:43 -08001636 }
1637}
1638
1639/* Async callback run prior to DAPM sequences - brings to their final
1640 * state.
1641 */
1642static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1643{
1644 struct snd_soc_dapm_context *d = data;
1645 int ret;
1646
1647 /* If we just powered the last thing off drop to standby bias */
Mark Brown56fba412011-06-04 11:25:10 +01001648 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1649 (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1650 d->target_bias_level == SND_SOC_BIAS_OFF)) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001651 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1652 if (ret != 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001653 dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
Mark Brown9d0624a2011-02-18 11:49:43 -08001654 ret);
1655 }
1656
1657 /* If we're in standby and can support bias off then do that */
Mark Brown56fba412011-06-04 11:25:10 +01001658 if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1659 d->target_bias_level == SND_SOC_BIAS_OFF) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001660 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1661 if (ret != 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001662 dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
1663 ret);
Mark Brownf1aac482011-12-05 15:17:06 +00001664
1665 if (d->dev)
Mark Brownfb644e92012-01-25 19:53:58 +00001666 pm_runtime_put(d->dev);
Mark Brown9d0624a2011-02-18 11:49:43 -08001667 }
1668
1669 /* If we just powered up then move to active bias */
Mark Brown56fba412011-06-04 11:25:10 +01001670 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1671 d->target_bias_level == SND_SOC_BIAS_ON) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001672 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1673 if (ret != 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00001674 dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
Mark Brown9d0624a2011-02-18 11:49:43 -08001675 ret);
1676 }
1677}
Mark Brown97404f22010-12-14 16:13:57 +00001678
Mark Brownfe4fda52011-10-03 22:36:57 +01001679static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
1680 bool power, bool connect)
1681{
1682 /* If a connection is being made or broken then that update
1683 * will have marked the peer dirty, otherwise the widgets are
1684 * not connected and this update has no impact. */
1685 if (!connect)
1686 return;
1687
1688 /* If the peer is already in the state we're moving to then we
1689 * won't have an impact on it. */
1690 if (power != peer->power)
Mark Brown75c1f892011-10-04 22:28:08 +01001691 dapm_mark_dirty(peer, "peer state change");
Mark Brownfe4fda52011-10-03 22:36:57 +01001692}
1693
Mark Brown05623c42011-09-28 17:02:31 +01001694static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
1695 struct list_head *up_list,
1696 struct list_head *down_list)
1697{
Mark Browndb432b42011-10-03 21:06:40 +01001698 struct snd_soc_dapm_path *path;
1699
Mark Brown05623c42011-09-28 17:02:31 +01001700 if (w->power == power)
1701 return;
1702
1703 trace_snd_soc_dapm_widget_power(w, power);
1704
Mark Browndb432b42011-10-03 21:06:40 +01001705 /* If we changed our power state perhaps our neigbours changed
Mark Brownfe4fda52011-10-03 22:36:57 +01001706 * also.
Mark Browndb432b42011-10-03 21:06:40 +01001707 */
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02001708 snd_soc_dapm_widget_for_each_source_path(w, path)
Lars-Peter Clausen7ddd4cd2014-10-20 19:36:34 +02001709 dapm_widget_set_peer_power(path->source, power, path->connect);
1710
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02001711 /* Supplies can't affect their outputs, only their inputs */
1712 if (!w->is_supply) {
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02001713 snd_soc_dapm_widget_for_each_sink_path(w, path)
Lars-Peter Clausen7ddd4cd2014-10-20 19:36:34 +02001714 dapm_widget_set_peer_power(path->sink, power,
1715 path->connect);
Mark Browndb432b42011-10-03 21:06:40 +01001716 }
1717
Mark Brown05623c42011-09-28 17:02:31 +01001718 if (power)
1719 dapm_seq_insert(w, up_list, true);
1720 else
1721 dapm_seq_insert(w, down_list, false);
Mark Brown05623c42011-09-28 17:02:31 +01001722}
1723
Mark Brown7c81beb2011-09-20 22:22:32 +01001724static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1725 struct list_head *up_list,
1726 struct list_head *down_list)
1727{
Mark Brown7c81beb2011-09-20 22:22:32 +01001728 int power;
1729
1730 switch (w->id) {
1731 case snd_soc_dapm_pre:
1732 dapm_seq_insert(w, down_list, false);
1733 break;
1734 case snd_soc_dapm_post:
1735 dapm_seq_insert(w, up_list, true);
1736 break;
1737
1738 default:
Mark Brownd8050022011-09-28 18:28:23 +01001739 power = dapm_widget_power_check(w);
Mark Brown7c81beb2011-09-20 22:22:32 +01001740
Mark Brown05623c42011-09-28 17:02:31 +01001741 dapm_widget_set_power(w, power, up_list, down_list);
Mark Brown7c81beb2011-09-20 22:22:32 +01001742 break;
1743 }
1744}
1745
Lars-Peter Clausen86dbf2a2014-09-04 19:44:06 +02001746static bool dapm_idle_bias_off(struct snd_soc_dapm_context *dapm)
1747{
1748 if (dapm->idle_bias_off)
1749 return true;
1750
1751 switch (snd_power_get_state(dapm->card->snd_card)) {
1752 case SNDRV_CTL_POWER_D3hot:
1753 case SNDRV_CTL_POWER_D3cold:
1754 return dapm->suspend_bias_off;
1755 default:
1756 break;
1757 }
1758
1759 return false;
1760}
1761
Mark Brown42aa3412009-03-01 19:21:10 +00001762/*
Richard Purdie2b97eab2006-10-06 18:32:18 +02001763 * Scan each dapm widget for complete audio path.
1764 * A complete path is a route that has valid endpoints i.e.:-
1765 *
1766 * o DAC to output pin.
1767 * o Input Pin to ADC.
1768 * o Input pin to Output pin (bypass, sidetone)
1769 * o DAC to ADC (loopback).
1770 */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001771static int dapm_power_widgets(struct snd_soc_card *card, int event)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001772{
1773 struct snd_soc_dapm_widget *w;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001774 struct snd_soc_dapm_context *d;
Mark Brown291f3bb2009-06-07 13:57:17 +01001775 LIST_HEAD(up_list);
1776 LIST_HEAD(down_list);
Dan Williams2955b472012-07-09 19:33:25 -07001777 ASYNC_DOMAIN_EXCLUSIVE(async_domain);
Mark Brown56fba412011-06-04 11:25:10 +01001778 enum snd_soc_bias_level bias;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001779
Mark Brownf9fa2b12014-03-06 16:49:11 +08001780 lockdep_assert_held(&card->dapm_mutex);
1781
Mark Brown84e90932010-11-04 00:07:02 -04001782 trace_snd_soc_dapm_start(card);
1783
Mark Brown56fba412011-06-04 11:25:10 +01001784 list_for_each_entry(d, &card->dapm_list, list) {
Lars-Peter Clausen86dbf2a2014-09-04 19:44:06 +02001785 if (dapm_idle_bias_off(d))
Mark Brown497098be2012-03-08 15:06:09 +00001786 d->target_bias_level = SND_SOC_BIAS_OFF;
1787 else
1788 d->target_bias_level = SND_SOC_BIAS_STANDBY;
Mark Brown56fba412011-06-04 11:25:10 +01001789 }
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001790
Liam Girdwood6c120e12012-02-15 15:15:34 +00001791 dapm_reset(card);
Mark Brown9b8a83b2011-10-04 22:15:59 +01001792
Mark Brown6d3ddc82009-05-16 17:47:29 +01001793 /* Check which widgets we need to power and store them in
Mark Browndb432b42011-10-03 21:06:40 +01001794 * lists indicating if they should be powered up or down. We
1795 * only check widgets that have been flagged as dirty but note
1796 * that new widgets may be added to the dirty list while we
1797 * iterate.
Mark Brown6d3ddc82009-05-16 17:47:29 +01001798 */
Mark Browndb432b42011-10-03 21:06:40 +01001799 list_for_each_entry(w, &card->dapm_dirty, dirty) {
Mark Brown7c81beb2011-09-20 22:22:32 +01001800 dapm_power_one_widget(w, &up_list, &down_list);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001801 }
1802
Mark Brownf9de6d72011-09-28 17:19:47 +01001803 list_for_each_entry(w, &card->widgets, list) {
Mark Brown0ff97eb2012-07-20 17:29:34 +01001804 switch (w->id) {
1805 case snd_soc_dapm_pre:
1806 case snd_soc_dapm_post:
1807 /* These widgets always need to be powered */
1808 break;
1809 default:
1810 list_del_init(&w->dirty);
1811 break;
1812 }
Mark Browndb432b42011-10-03 21:06:40 +01001813
Lars-Peter Clausen39eb5fd2013-07-29 17:14:03 +02001814 if (w->new_power) {
Mark Brownf9de6d72011-09-28 17:19:47 +01001815 d = w->dapm;
1816
1817 /* Supplies and micbiases only bring the
1818 * context up to STANDBY as unless something
1819 * else is active and passing audio they
Mark Brownafe62362012-01-25 19:55:22 +00001820 * generally don't require full power. Signal
1821 * generators are virtual pins and have no
1822 * power impact themselves.
Mark Brownf9de6d72011-09-28 17:19:47 +01001823 */
1824 switch (w->id) {
Mark Brownafe62362012-01-25 19:55:22 +00001825 case snd_soc_dapm_siggen:
Lars-Peter Clausenda83fea2013-10-05 19:26:17 +02001826 case snd_soc_dapm_vmid:
Mark Brownafe62362012-01-25 19:55:22 +00001827 break;
Mark Brownf9de6d72011-09-28 17:19:47 +01001828 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00001829 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02001830 case snd_soc_dapm_clock_supply:
Mark Brownf9de6d72011-09-28 17:19:47 +01001831 case snd_soc_dapm_micbias:
1832 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
1833 d->target_bias_level = SND_SOC_BIAS_STANDBY;
1834 break;
1835 default:
1836 d->target_bias_level = SND_SOC_BIAS_ON;
1837 break;
1838 }
1839 }
1840
1841 }
1842
Mark Brown85a843c2011-09-21 21:29:47 +01001843 /* Force all contexts in the card to the same bias state if
1844 * they're not ground referenced.
1845 */
Mark Brown56fba412011-06-04 11:25:10 +01001846 bias = SND_SOC_BIAS_OFF;
Mark Brown52ba67b2011-04-04 21:05:11 +09001847 list_for_each_entry(d, &card->dapm_list, list)
Mark Brown56fba412011-06-04 11:25:10 +01001848 if (d->target_bias_level > bias)
1849 bias = d->target_bias_level;
Mark Brown52ba67b2011-04-04 21:05:11 +09001850 list_for_each_entry(d, &card->dapm_list, list)
Lars-Peter Clausen86dbf2a2014-09-04 19:44:06 +02001851 if (!dapm_idle_bias_off(d))
Mark Brown85a843c2011-09-21 21:29:47 +01001852 d->target_bias_level = bias;
Mark Brown52ba67b2011-04-04 21:05:11 +09001853
Mark Brownde02d072011-09-20 21:43:24 +01001854 trace_snd_soc_dapm_walk_done(card);
Mark Brown52ba67b2011-04-04 21:05:11 +09001855
Xiang Xiao17282ba2014-03-02 00:04:03 +08001856 /* Run card bias changes at first */
1857 dapm_pre_sequence_async(&card->dapm, 0);
1858 /* Run other bias changes in parallel */
1859 list_for_each_entry(d, &card->dapm_list, list) {
1860 if (d != &card->dapm)
1861 async_schedule_domain(dapm_pre_sequence_async, d,
1862 &async_domain);
1863 }
Mark Brown9d0624a2011-02-18 11:49:43 -08001864 async_synchronize_full_domain(&async_domain);
Mark Brown452c5ea2009-05-17 21:41:23 +01001865
Lars-Peter Clausencf1f7c62013-05-23 00:12:53 +02001866 list_for_each_entry(w, &down_list, power_list) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001867 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
Mark Brown80114122013-02-25 15:14:19 +00001868 }
1869
Lars-Peter Clausencf1f7c62013-05-23 00:12:53 +02001870 list_for_each_entry(w, &up_list, power_list) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001871 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
Mark Brown80114122013-02-25 15:14:19 +00001872 }
1873
Mark Brown6d3ddc82009-05-16 17:47:29 +01001874 /* Power down widgets first; try to avoid amplifying pops. */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001875 dapm_seq_run(card, &down_list, event, false);
Mark Brown6d3ddc82009-05-16 17:47:29 +01001876
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001877 dapm_widget_update(card);
Mark Brown97404f22010-12-14 16:13:57 +00001878
Mark Brown6d3ddc82009-05-16 17:47:29 +01001879 /* Now power up. */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001880 dapm_seq_run(card, &up_list, event, true);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001881
Mark Brown9d0624a2011-02-18 11:49:43 -08001882 /* Run all the bias changes in parallel */
Xiang Xiao17282ba2014-03-02 00:04:03 +08001883 list_for_each_entry(d, &card->dapm_list, list) {
1884 if (d != &card->dapm)
1885 async_schedule_domain(dapm_post_sequence_async, d,
1886 &async_domain);
1887 }
Mark Brown9d0624a2011-02-18 11:49:43 -08001888 async_synchronize_full_domain(&async_domain);
Xiang Xiao17282ba2014-03-02 00:04:03 +08001889 /* Run card bias changes at last */
1890 dapm_post_sequence_async(&card->dapm, 0);
Mark Brown452c5ea2009-05-17 21:41:23 +01001891
Liam Girdwood8078d872012-02-15 15:15:35 +00001892 /* do we need to notify any clients that DAPM event is complete */
1893 list_for_each_entry(d, &card->dapm_list, list) {
1894 if (d->stream_event)
1895 d->stream_event(d, event);
1896 }
1897
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02001898 pop_dbg(card->dev, card->pop_time,
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +02001899 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
Jarkko Nikula3a45b862010-11-05 20:35:21 +02001900 pop_wait(card->pop_time);
Mark Browncb507e72009-07-08 18:54:57 +01001901
Mark Brown84e90932010-11-04 00:07:02 -04001902 trace_snd_soc_dapm_done(card);
1903
Mark Brown42aa3412009-03-01 19:21:10 +00001904 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001905}
1906
Mark Brown79fb9382009-08-21 16:38:13 +01001907#ifdef CONFIG_DEBUG_FS
Mark Brown79fb9382009-08-21 16:38:13 +01001908static ssize_t dapm_widget_power_read_file(struct file *file,
1909 char __user *user_buf,
1910 size_t count, loff_t *ppos)
1911{
1912 struct snd_soc_dapm_widget *w = file->private_data;
Lars-Peter Clausene50b1e02015-07-06 17:01:24 +02001913 struct snd_soc_card *card = w->dapm->card;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001914 enum snd_soc_dapm_direction dir, rdir;
Mark Brown79fb9382009-08-21 16:38:13 +01001915 char *buf;
1916 int in, out;
1917 ssize_t ret;
1918 struct snd_soc_dapm_path *p = NULL;
1919
1920 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1921 if (!buf)
1922 return -ENOMEM;
1923
Lars-Peter Clausene50b1e02015-07-06 17:01:24 +02001924 mutex_lock(&card->dapm_mutex);
1925
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02001926 /* Supply widgets are not handled by is_connected_{input,output}_ep() */
1927 if (w->is_supply) {
1928 in = 0;
1929 out = 0;
1930 } else {
1931 in = is_connected_input_ep(w, NULL);
1932 out = is_connected_output_ep(w, NULL);
1933 }
Mark Brown79fb9382009-08-21 16:38:13 +01001934
Mark Brownf13ebad2012-03-03 18:01:01 +00001935 ret = snprintf(buf, PAGE_SIZE, "%s: %s%s in %d out %d",
1936 w->name, w->power ? "On" : "Off",
1937 w->force ? " (forced)" : "", in, out);
Mark Brown79fb9382009-08-21 16:38:13 +01001938
Mark Brownd033c362009-12-04 15:25:56 +00001939 if (w->reg >= 0)
1940 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02001941 " - R%d(0x%x) mask 0x%x",
1942 w->reg, w->reg, w->mask << w->shift);
Mark Brownd033c362009-12-04 15:25:56 +00001943
1944 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1945
Mark Brown3eef08b2009-09-14 16:49:00 +01001946 if (w->sname)
1947 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1948 w->sname,
1949 w->active ? "active" : "inactive");
Mark Brown79fb9382009-08-21 16:38:13 +01001950
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001951 snd_soc_dapm_for_each_direction(dir) {
1952 rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
1953 snd_soc_dapm_widget_for_each_path(w, dir, p) {
1954 if (p->connected && !p->connected(w, p->node[rdir]))
1955 continue;
Mark Brown215edda2009-09-08 18:59:05 +01001956
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001957 if (!p->connect)
1958 continue;
Mark Brown215edda2009-09-08 18:59:05 +01001959
Mark Brown79fb9382009-08-21 16:38:13 +01001960 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001961 " %s \"%s\" \"%s\"\n",
1962 (rdir == SND_SOC_DAPM_DIR_IN) ? "in" : "out",
Mark Brown79fb9382009-08-21 16:38:13 +01001963 p->name ? p->name : "static",
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02001964 p->node[rdir]->name);
1965 }
Mark Brown79fb9382009-08-21 16:38:13 +01001966 }
1967
Lars-Peter Clausene50b1e02015-07-06 17:01:24 +02001968 mutex_unlock(&card->dapm_mutex);
1969
Mark Brown79fb9382009-08-21 16:38:13 +01001970 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1971
1972 kfree(buf);
1973 return ret;
1974}
1975
1976static const struct file_operations dapm_widget_power_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -07001977 .open = simple_open,
Mark Brown79fb9382009-08-21 16:38:13 +01001978 .read = dapm_widget_power_read_file,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001979 .llseek = default_llseek,
Mark Brown79fb9382009-08-21 16:38:13 +01001980};
1981
Mark Brownef49e4f2011-04-04 20:48:13 +09001982static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
1983 size_t count, loff_t *ppos)
1984{
1985 struct snd_soc_dapm_context *dapm = file->private_data;
1986 char *level;
1987
1988 switch (dapm->bias_level) {
1989 case SND_SOC_BIAS_ON:
1990 level = "On\n";
1991 break;
1992 case SND_SOC_BIAS_PREPARE:
1993 level = "Prepare\n";
1994 break;
1995 case SND_SOC_BIAS_STANDBY:
1996 level = "Standby\n";
1997 break;
1998 case SND_SOC_BIAS_OFF:
1999 level = "Off\n";
2000 break;
2001 default:
Takashi Iwaia6ed0602013-11-06 11:07:19 +01002002 WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
Mark Brownef49e4f2011-04-04 20:48:13 +09002003 level = "Unknown\n";
2004 break;
2005 }
2006
2007 return simple_read_from_buffer(user_buf, count, ppos, level,
2008 strlen(level));
2009}
2010
2011static const struct file_operations dapm_bias_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -07002012 .open = simple_open,
Mark Brownef49e4f2011-04-04 20:48:13 +09002013 .read = dapm_bias_read_file,
2014 .llseek = default_llseek,
2015};
2016
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002017void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2018 struct dentry *parent)
Mark Brown79fb9382009-08-21 16:38:13 +01002019{
Mark Brown79fb9382009-08-21 16:38:13 +01002020 struct dentry *d;
2021
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +02002022 if (!parent)
2023 return;
2024
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002025 dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
2026
2027 if (!dapm->debugfs_dapm) {
Liam Girdwoodf1e90af2012-03-06 18:13:25 +00002028 dev_warn(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002029 "ASoC: Failed to create DAPM debugfs directory\n");
Mark Brown79fb9382009-08-21 16:38:13 +01002030 return;
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002031 }
Mark Brown79fb9382009-08-21 16:38:13 +01002032
Mark Brownef49e4f2011-04-04 20:48:13 +09002033 d = debugfs_create_file("bias_level", 0444,
2034 dapm->debugfs_dapm, dapm,
2035 &dapm_bias_fops);
2036 if (!d)
2037 dev_warn(dapm->dev,
2038 "ASoC: Failed to create bias level debugfs file\n");
Mark Brown79fb9382009-08-21 16:38:13 +01002039}
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002040
2041static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2042{
2043 struct snd_soc_dapm_context *dapm = w->dapm;
2044 struct dentry *d;
2045
2046 if (!dapm->debugfs_dapm || !w->name)
2047 return;
2048
2049 d = debugfs_create_file(w->name, 0444,
2050 dapm->debugfs_dapm, w,
2051 &dapm_widget_power_fops);
2052 if (!d)
2053 dev_warn(w->dapm->dev,
2054 "ASoC: Failed to create %s debugfs file\n",
2055 w->name);
2056}
2057
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02002058static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2059{
2060 debugfs_remove_recursive(dapm->debugfs_dapm);
2061}
2062
Mark Brown79fb9382009-08-21 16:38:13 +01002063#else
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02002064void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2065 struct dentry *parent)
Mark Brown79fb9382009-08-21 16:38:13 +01002066{
2067}
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002068
2069static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2070{
2071}
2072
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02002073static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2074{
2075}
2076
Mark Brown79fb9382009-08-21 16:38:13 +01002077#endif
2078
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002079/*
2080 * soc_dapm_connect_path() - Connects or disconnects a path
2081 * @path: The path to update
2082 * @connect: The new connect state of the path. True if the path is connected,
2083 * false if it is disconneted.
2084 * @reason: The reason why the path changed (for debugging only)
2085 */
2086static void soc_dapm_connect_path(struct snd_soc_dapm_path *path,
2087 bool connect, const char *reason)
2088{
2089 if (path->connect == connect)
2090 return;
2091
2092 path->connect = connect;
2093 dapm_mark_dirty(path->source, reason);
2094 dapm_mark_dirty(path->sink, reason);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002095 dapm_path_invalidate(path);
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002096}
2097
Richard Purdie2b97eab2006-10-06 18:32:18 +02002098/* test and update the power status of a mux widget */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002099static int soc_dapm_mux_update_power(struct snd_soc_card *card,
Liam Girdwood40f02cd2012-02-06 16:05:14 +00002100 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002101{
2102 struct snd_soc_dapm_path *path;
2103 int found = 0;
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002104 bool connect;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002105
Mark Brownf9fa2b12014-03-06 16:49:11 +08002106 lockdep_assert_held(&card->dapm_mutex);
2107
Richard Purdie2b97eab2006-10-06 18:32:18 +02002108 /* find dapm widget path assoc with kcontrol */
Lars-Peter Clausen5106b922013-07-29 17:14:00 +02002109 dapm_kcontrol_for_each_path(path, kcontrol) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002110 found = 1;
2111 /* we now need to match the string in the enum to the path */
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002112 if (!(strcmp(path->name, e->texts[mux])))
2113 connect = true;
2114 else
2115 connect = false;
2116
2117 soc_dapm_connect_path(path, connect, "mux update");
Richard Purdie2b97eab2006-10-06 18:32:18 +02002118 }
2119
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002120 if (found)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002121 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002122
Liam Girdwood618dae12012-04-25 12:12:51 +01002123 return found;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002124}
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002125
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002126int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausen6b3fc032013-07-24 15:27:38 +02002127 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
2128 struct snd_soc_dapm_update *update)
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002129{
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002130 struct snd_soc_card *card = dapm->card;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002131 int ret;
2132
Liam Girdwood3cd04342012-03-09 12:02:08 +00002133 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002134 card->update = update;
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002135 ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002136 card->update = NULL;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002137 mutex_unlock(&card->dapm_mutex);
Liam Girdwood618dae12012-04-25 12:12:51 +01002138 if (ret > 0)
Lars-Peter Clausenc3f48ae2013-07-24 15:27:36 +02002139 soc_dpcm_runtime_update(card);
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002140 return ret;
2141}
Liam Girdwood40f02cd2012-02-06 16:05:14 +00002142EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002143
Milan plzik1b075e32008-01-10 14:39:46 +01002144/* test and update the power status of a mixer or switch widget */
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002145static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
Mark Brown283375c2009-12-07 18:09:03 +00002146 struct snd_kcontrol *kcontrol, int connect)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002147{
2148 struct snd_soc_dapm_path *path;
2149 int found = 0;
2150
Mark Brownf9fa2b12014-03-06 16:49:11 +08002151 lockdep_assert_held(&card->dapm_mutex);
2152
Richard Purdie2b97eab2006-10-06 18:32:18 +02002153 /* find dapm widget path assoc with kcontrol */
Lars-Peter Clausen5106b922013-07-29 17:14:00 +02002154 dapm_kcontrol_for_each_path(path, kcontrol) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002155 found = 1;
Lars-Peter Clausen4a201942014-10-25 17:41:56 +02002156 soc_dapm_connect_path(path, connect, "mixer update");
Richard Purdie2b97eab2006-10-06 18:32:18 +02002157 }
2158
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002159 if (found)
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002160 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002161
Liam Girdwood618dae12012-04-25 12:12:51 +01002162 return found;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002163}
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002164
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002165int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausen6b3fc032013-07-24 15:27:38 +02002166 struct snd_kcontrol *kcontrol, int connect,
2167 struct snd_soc_dapm_update *update)
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002168{
Lars-Peter Clausence6cfaf2013-07-24 15:27:37 +02002169 struct snd_soc_card *card = dapm->card;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002170 int ret;
2171
Liam Girdwood3cd04342012-03-09 12:02:08 +00002172 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002173 card->update = update;
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002174 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02002175 card->update = NULL;
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002176 mutex_unlock(&card->dapm_mutex);
Liam Girdwood618dae12012-04-25 12:12:51 +01002177 if (ret > 0)
Lars-Peter Clausenc3f48ae2013-07-24 15:27:36 +02002178 soc_dpcm_runtime_update(card);
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002179 return ret;
2180}
Liam Girdwood40f02cd2012-02-06 16:05:14 +00002181EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002182
Lars-Peter Clausenb3c25fb2015-07-06 15:38:10 +02002183static ssize_t dapm_widget_show_component(struct snd_soc_component *cmpnt,
2184 char *buf)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002185{
Lars-Peter Clausenb3c25fb2015-07-06 15:38:10 +02002186 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002187 struct snd_soc_dapm_widget *w;
2188 int count = 0;
2189 char *state = "not set";
2190
Mark Brown47325072016-03-18 12:04:23 +00002191 /* card won't be set for the dummy component, as a spot fix
2192 * we're checking for that case specifically here but in future
2193 * we will ensure that the dummy component looks like others.
2194 */
2195 if (!cmpnt->card)
2196 return 0;
2197
Lars-Peter Clausenb3c25fb2015-07-06 15:38:10 +02002198 list_for_each_entry(w, &cmpnt->card->widgets, list) {
2199 if (w->dapm != dapm)
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002200 continue;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002201
2202 /* only display widgets that burnm power */
2203 switch (w->id) {
2204 case snd_soc_dapm_hp:
2205 case snd_soc_dapm_mic:
2206 case snd_soc_dapm_spk:
2207 case snd_soc_dapm_line:
2208 case snd_soc_dapm_micbias:
2209 case snd_soc_dapm_dac:
2210 case snd_soc_dapm_adc:
2211 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06002212 case snd_soc_dapm_out_drv:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002213 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00002214 case snd_soc_dapm_mixer_named_ctl:
Mark Brown246d0a12009-04-22 18:24:55 +01002215 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00002216 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02002217 case snd_soc_dapm_clock_supply:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002218 if (w->name)
2219 count += sprintf(buf + count, "%s: %s\n",
2220 w->name, w->power ? "On":"Off");
2221 break;
2222 default:
2223 break;
2224 }
2225 }
2226
Lars-Peter Clausenb3c25fb2015-07-06 15:38:10 +02002227 switch (snd_soc_dapm_get_bias_level(dapm)) {
Mark Brown0be98982008-05-19 12:31:28 +02002228 case SND_SOC_BIAS_ON:
2229 state = "On";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002230 break;
Mark Brown0be98982008-05-19 12:31:28 +02002231 case SND_SOC_BIAS_PREPARE:
2232 state = "Prepare";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002233 break;
Mark Brown0be98982008-05-19 12:31:28 +02002234 case SND_SOC_BIAS_STANDBY:
2235 state = "Standby";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002236 break;
Mark Brown0be98982008-05-19 12:31:28 +02002237 case SND_SOC_BIAS_OFF:
2238 state = "Off";
Richard Purdie2b97eab2006-10-06 18:32:18 +02002239 break;
2240 }
2241 count += sprintf(buf + count, "PM State: %s\n", state);
2242
2243 return count;
2244}
2245
Benoit Cousson44ba2642014-07-08 23:19:36 +02002246/* show dapm widget status in sys fs */
2247static ssize_t dapm_widget_show(struct device *dev,
2248 struct device_attribute *attr, char *buf)
2249{
2250 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
2251 int i, count = 0;
2252
Lars-Peter Clausene50b1e02015-07-06 17:01:24 +02002253 mutex_lock(&rtd->card->dapm_mutex);
2254
Benoit Cousson44ba2642014-07-08 23:19:36 +02002255 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausenb3c25fb2015-07-06 15:38:10 +02002256 struct snd_soc_component *cmpnt = rtd->codec_dais[i]->component;
2257
2258 count += dapm_widget_show_component(cmpnt, buf + count);
Benoit Cousson44ba2642014-07-08 23:19:36 +02002259 }
2260
Lars-Peter Clausene50b1e02015-07-06 17:01:24 +02002261 mutex_unlock(&rtd->card->dapm_mutex);
2262
Benoit Cousson44ba2642014-07-08 23:19:36 +02002263 return count;
2264}
2265
Richard Purdie2b97eab2006-10-06 18:32:18 +02002266static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
2267
Takashi Iwaid29697d2015-01-30 20:16:37 +01002268struct attribute *soc_dapm_dev_attrs[] = {
2269 &dev_attr_dapm_widget.attr,
2270 NULL
2271};
Richard Purdie2b97eab2006-10-06 18:32:18 +02002272
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002273static void dapm_free_path(struct snd_soc_dapm_path *path)
2274{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002275 list_del(&path->list_node[SND_SOC_DAPM_DIR_IN]);
2276 list_del(&path->list_node[SND_SOC_DAPM_DIR_OUT]);
Lars-Peter Clausen5106b922013-07-29 17:14:00 +02002277 list_del(&path->list_kcontrol);
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002278 list_del(&path->list);
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002279 kfree(path);
2280}
2281
Lars-Peter Clausenb97e2692015-07-21 18:11:07 +02002282void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w)
2283{
2284 struct snd_soc_dapm_path *p, *next_p;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002285 enum snd_soc_dapm_direction dir;
Lars-Peter Clausenb97e2692015-07-21 18:11:07 +02002286
2287 list_del(&w->list);
2288 /*
2289 * remove source and sink paths associated to this widget.
2290 * While removing the path, remove reference to it from both
2291 * source and sink widgets so that path is removed only once.
2292 */
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002293 snd_soc_dapm_for_each_direction(dir) {
2294 snd_soc_dapm_widget_for_each_path_safe(w, dir, p, next_p)
2295 dapm_free_path(p);
2296 }
Lars-Peter Clausenb97e2692015-07-21 18:11:07 +02002297
2298 kfree(w->kcontrols);
Lars-Peter Clausen48068962015-07-21 18:11:08 +02002299 kfree_const(w->name);
Lars-Peter Clausenb97e2692015-07-21 18:11:07 +02002300 kfree(w);
2301}
2302
Jyri Sarhafd589a12015-11-10 18:12:42 +02002303void snd_soc_dapm_reset_cache(struct snd_soc_dapm_context *dapm)
2304{
2305 dapm->path_sink_cache.widget = NULL;
2306 dapm->path_source_cache.widget = NULL;
2307}
2308
Richard Purdie2b97eab2006-10-06 18:32:18 +02002309/* free all dapm widgets and resources */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002310static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002311{
2312 struct snd_soc_dapm_widget *w, *next_w;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002313
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002314 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
2315 if (w->dapm != dapm)
2316 continue;
Lars-Peter Clausenb97e2692015-07-21 18:11:07 +02002317 snd_soc_dapm_free_widget(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002318 }
Jyri Sarhafd589a12015-11-10 18:12:42 +02002319 snd_soc_dapm_reset_cache(dapm);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002320}
2321
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002322static struct snd_soc_dapm_widget *dapm_find_widget(
2323 struct snd_soc_dapm_context *dapm, const char *pin,
2324 bool search_other_contexts)
2325{
2326 struct snd_soc_dapm_widget *w;
2327 struct snd_soc_dapm_widget *fallback = NULL;
2328
2329 list_for_each_entry(w, &dapm->card->widgets, list) {
2330 if (!strcmp(w->name, pin)) {
2331 if (w->dapm == dapm)
2332 return w;
2333 else
2334 fallback = w;
2335 }
2336 }
2337
2338 if (search_other_contexts)
2339 return fallback;
2340
2341 return NULL;
2342}
2343
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002344static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
Mark Brown16499232009-01-07 18:25:13 +00002345 const char *pin, int status)
Liam Girdwooda5302182008-07-07 13:35:17 +01002346{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002347 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Liam Girdwooda5302182008-07-07 13:35:17 +01002348
Mark Brownf9fa2b12014-03-06 16:49:11 +08002349 dapm_assert_locked(dapm);
2350
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002351 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002352 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002353 return -EINVAL;
Liam Girdwooda5302182008-07-07 13:35:17 +01002354 }
2355
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002356 if (w->connected != status) {
Mark Brown1a8b2d92012-02-16 11:50:07 -08002357 dapm_mark_dirty(w, "pin configuration");
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002358 dapm_widget_invalidate_input_paths(w);
2359 dapm_widget_invalidate_output_paths(w);
2360 }
Mark Brown1a8b2d92012-02-16 11:50:07 -08002361
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002362 w->connected = status;
2363 if (status == 0)
2364 w->force = 0;
Mark Brown0d867332011-04-06 11:38:14 +09002365
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002366 return 0;
Liam Girdwooda5302182008-07-07 13:35:17 +01002367}
2368
Richard Purdie2b97eab2006-10-06 18:32:18 +02002369/**
Charles Keepax3eb29df2014-02-18 15:22:15 +00002370 * snd_soc_dapm_sync_unlocked - scan and power dapm paths
2371 * @dapm: DAPM context
2372 *
2373 * Walks all dapm audio paths and powers widgets according to their
2374 * stream or path usage.
2375 *
2376 * Requires external locking.
2377 *
2378 * Returns 0 for success.
2379 */
2380int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
2381{
2382 /*
2383 * Suppress early reports (eg, jacks syncing their state) to avoid
2384 * silly DAPM runs during card startup.
2385 */
2386 if (!dapm->card || !dapm->card->instantiated)
2387 return 0;
2388
2389 return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
2390}
2391EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked);
2392
2393/**
Liam Girdwooda5302182008-07-07 13:35:17 +01002394 * snd_soc_dapm_sync - scan and power dapm paths
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002395 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02002396 *
2397 * Walks all dapm audio paths and powers widgets according to their
2398 * stream or path usage.
2399 *
2400 * Returns 0 for success.
2401 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002402int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002403{
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002404 int ret;
2405
Liam Girdwood3cd04342012-03-09 12:02:08 +00002406 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Charles Keepax3eb29df2014-02-18 15:22:15 +00002407 ret = snd_soc_dapm_sync_unlocked(dapm);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002408 mutex_unlock(&dapm->card->dapm_mutex);
2409 return ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002410}
Liam Girdwooda5302182008-07-07 13:35:17 +01002411EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002412
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002413/*
2414 * dapm_update_widget_flags() - Re-compute widget sink and source flags
2415 * @w: The widget for which to update the flags
2416 *
2417 * Some widgets have a dynamic category which depends on which neighbors they
2418 * are connected to. This function update the category for these widgets.
2419 *
2420 * This function must be called whenever a path is added or removed to a widget.
2421 */
2422static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
2423{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002424 enum snd_soc_dapm_direction dir;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002425 struct snd_soc_dapm_path *p;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002426 unsigned int ep;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002427
2428 switch (w->id) {
2429 case snd_soc_dapm_input:
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01002430 /* On a fully routed card a input is never a source */
2431 if (w->dapm->card->fully_routed)
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002432 return;
2433 ep = SND_SOC_DAPM_EP_SOURCE;
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02002434 snd_soc_dapm_widget_for_each_source_path(w, p) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002435 if (p->source->id == snd_soc_dapm_micbias ||
2436 p->source->id == snd_soc_dapm_mic ||
2437 p->source->id == snd_soc_dapm_line ||
2438 p->source->id == snd_soc_dapm_output) {
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002439 ep = 0;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002440 break;
2441 }
2442 }
2443 break;
2444 case snd_soc_dapm_output:
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01002445 /* On a fully routed card a output is never a sink */
2446 if (w->dapm->card->fully_routed)
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002447 return;
2448 ep = SND_SOC_DAPM_EP_SINK;
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02002449 snd_soc_dapm_widget_for_each_sink_path(w, p) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002450 if (p->sink->id == snd_soc_dapm_spk ||
2451 p->sink->id == snd_soc_dapm_hp ||
2452 p->sink->id == snd_soc_dapm_line ||
2453 p->sink->id == snd_soc_dapm_input) {
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002454 ep = 0;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002455 break;
2456 }
2457 }
2458 break;
2459 case snd_soc_dapm_line:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002460 ep = 0;
2461 snd_soc_dapm_for_each_direction(dir) {
2462 if (!list_empty(&w->edges[dir]))
2463 ep |= SND_SOC_DAPM_DIR_TO_EP(dir);
2464 }
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002465 break;
2466 default:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002467 return;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002468 }
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002469
2470 w->is_ep = ep;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002471}
2472
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002473static int snd_soc_dapm_check_dynamic_path(struct snd_soc_dapm_context *dapm,
2474 struct snd_soc_dapm_widget *source, struct snd_soc_dapm_widget *sink,
2475 const char *control)
2476{
2477 bool dynamic_source = false;
2478 bool dynamic_sink = false;
2479
2480 if (!control)
2481 return 0;
2482
2483 switch (source->id) {
2484 case snd_soc_dapm_demux:
2485 dynamic_source = true;
2486 break;
2487 default:
2488 break;
2489 }
2490
2491 switch (sink->id) {
2492 case snd_soc_dapm_mux:
2493 case snd_soc_dapm_switch:
2494 case snd_soc_dapm_mixer:
2495 case snd_soc_dapm_mixer_named_ctl:
2496 dynamic_sink = true;
2497 break;
2498 default:
2499 break;
2500 }
2501
2502 if (dynamic_source && dynamic_sink) {
2503 dev_err(dapm->dev,
2504 "Direct connection between demux and mixer/mux not supported for path %s -> [%s] -> %s\n",
2505 source->name, control, sink->name);
2506 return -EINVAL;
2507 } else if (!dynamic_source && !dynamic_sink) {
2508 dev_err(dapm->dev,
2509 "Control not supported for path %s -> [%s] -> %s\n",
2510 source->name, control, sink->name);
2511 return -EINVAL;
2512 }
2513
2514 return 0;
2515}
2516
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002517static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
2518 struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
2519 const char *control,
2520 int (*connected)(struct snd_soc_dapm_widget *source,
2521 struct snd_soc_dapm_widget *sink))
Richard Purdie2b97eab2006-10-06 18:32:18 +02002522{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002523 struct snd_soc_dapm_widget *widgets[2];
2524 enum snd_soc_dapm_direction dir;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002525 struct snd_soc_dapm_path *path;
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002526 int ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002527
Lars-Peter Clausene409dfb2014-10-25 17:42:02 +02002528 if (wsink->is_supply && !wsource->is_supply) {
2529 dev_err(dapm->dev,
2530 "Connecting non-supply widget to supply widget is not supported (%s -> %s)\n",
2531 wsource->name, wsink->name);
2532 return -EINVAL;
2533 }
2534
2535 if (connected && !wsource->is_supply) {
2536 dev_err(dapm->dev,
2537 "connected() callback only supported for supply widgets (%s -> %s)\n",
2538 wsource->name, wsink->name);
2539 return -EINVAL;
2540 }
2541
2542 if (wsource->is_supply && control) {
2543 dev_err(dapm->dev,
2544 "Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
2545 wsource->name, control, wsink->name);
2546 return -EINVAL;
2547 }
2548
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002549 ret = snd_soc_dapm_check_dynamic_path(dapm, wsource, wsink, control);
2550 if (ret)
2551 return ret;
2552
Richard Purdie2b97eab2006-10-06 18:32:18 +02002553 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
2554 if (!path)
2555 return -ENOMEM;
2556
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002557 path->node[SND_SOC_DAPM_DIR_IN] = wsource;
2558 path->node[SND_SOC_DAPM_DIR_OUT] = wsink;
2559 widgets[SND_SOC_DAPM_DIR_IN] = wsource;
2560 widgets[SND_SOC_DAPM_DIR_OUT] = wsink;
2561
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002562 path->connected = connected;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002563 INIT_LIST_HEAD(&path->list);
Mark Brown69c2d342013-08-13 00:20:36 +01002564 INIT_LIST_HEAD(&path->list_kcontrol);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002565
Lars-Peter Clausenc1862c82014-10-25 17:42:00 +02002566 if (wsource->is_supply || wsink->is_supply)
2567 path->is_supply = 1;
2568
Richard Purdie2b97eab2006-10-06 18:32:18 +02002569 /* connect static paths */
2570 if (control == NULL) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002571 path->connect = 1;
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002572 } else {
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002573 switch (wsource->id) {
2574 case snd_soc_dapm_demux:
2575 ret = dapm_connect_mux(dapm, path, control, wsource);
2576 if (ret)
2577 goto err;
2578 break;
2579 default:
2580 break;
2581 }
2582
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002583 switch (wsink->id) {
2584 case snd_soc_dapm_mux:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002585 ret = dapm_connect_mux(dapm, path, control, wsink);
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002586 if (ret != 0)
2587 goto err;
2588 break;
2589 case snd_soc_dapm_switch:
2590 case snd_soc_dapm_mixer:
2591 case snd_soc_dapm_mixer_named_ctl:
2592 ret = dapm_connect_mixer(dapm, path, control);
2593 if (ret != 0)
2594 goto err;
2595 break;
2596 default:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002597 break;
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002598 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02002599 }
2600
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002601 list_add(&path->list, &dapm->card->paths);
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002602 snd_soc_dapm_for_each_direction(dir)
2603 list_add(&path->list_node[dir], &widgets[dir]->edges[dir]);
Lars-Peter Clausen5fe5b762014-10-25 17:41:58 +02002604
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02002605 snd_soc_dapm_for_each_direction(dir) {
2606 dapm_update_widget_flags(widgets[dir]);
2607 dapm_mark_dirty(widgets[dir], "Route added");
2608 }
Mark Brownfabd0382012-07-05 17:20:06 +01002609
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002610 if (dapm->card->instantiated && path->connect)
2611 dapm_path_invalidate(path);
2612
Richard Purdie2b97eab2006-10-06 18:32:18 +02002613 return 0;
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002614err:
2615 kfree(path);
2616 return ret;
2617}
Richard Purdie2b97eab2006-10-06 18:32:18 +02002618
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002619static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
Lars-Peter Clausena4e91542014-05-07 16:20:25 +02002620 const struct snd_soc_dapm_route *route)
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002621{
2622 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
2623 struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
2624 const char *sink;
2625 const char *source;
2626 char prefixed_sink[80];
2627 char prefixed_source[80];
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002628 const char *prefix;
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002629 int ret;
2630
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002631 prefix = soc_dapm_prefix(dapm);
2632 if (prefix) {
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002633 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002634 prefix, route->sink);
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002635 sink = prefixed_sink;
2636 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002637 prefix, route->source);
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002638 source = prefixed_source;
2639 } else {
2640 sink = route->sink;
2641 source = route->source;
2642 }
2643
Charles Keepax45a110a2015-05-11 13:50:30 +01002644 wsource = dapm_wcache_lookup(&dapm->path_source_cache, source);
2645 wsink = dapm_wcache_lookup(&dapm->path_sink_cache, sink);
2646
2647 if (wsink && wsource)
2648 goto skip_search;
2649
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002650 /*
2651 * find src and dest widgets over all widgets but favor a widget from
2652 * current DAPM context
2653 */
2654 list_for_each_entry(w, &dapm->card->widgets, list) {
2655 if (!wsink && !(strcmp(w->name, sink))) {
2656 wtsink = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002657 if (w->dapm == dapm) {
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002658 wsink = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002659 if (wsource)
2660 break;
2661 }
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002662 continue;
2663 }
2664 if (!wsource && !(strcmp(w->name, source))) {
2665 wtsource = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002666 if (w->dapm == dapm) {
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002667 wsource = w;
Charles Keepax70c75102015-05-07 11:33:58 +01002668 if (wsink)
2669 break;
2670 }
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002671 }
2672 }
2673 /* use widget from another DAPM context if not found from this */
2674 if (!wsink)
2675 wsink = wtsink;
2676 if (!wsource)
2677 wsource = wtsource;
2678
2679 if (wsource == NULL) {
2680 dev_err(dapm->dev, "ASoC: no source widget found for %s\n",
2681 route->source);
2682 return -ENODEV;
2683 }
2684 if (wsink == NULL) {
2685 dev_err(dapm->dev, "ASoC: no sink widget found for %s\n",
2686 route->sink);
2687 return -ENODEV;
2688 }
2689
Charles Keepax45a110a2015-05-11 13:50:30 +01002690skip_search:
2691 dapm_wcache_update(&dapm->path_sink_cache, wsink);
2692 dapm_wcache_update(&dapm->path_source_cache, wsource);
2693
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002694 ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,
2695 route->connected);
2696 if (ret)
2697 goto err;
2698
2699 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002700err:
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002701 dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n",
Lars-Peter Clausen25536282013-07-29 17:14:02 +02002702 source, route->control, sink);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002703 return ret;
2704}
Mark Brown105f1c22008-05-13 14:52:19 +02002705
Mark Brownefcc3c62012-07-05 17:24:19 +01002706static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
2707 const struct snd_soc_dapm_route *route)
2708{
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002709 struct snd_soc_dapm_widget *wsource, *wsink;
Mark Brownefcc3c62012-07-05 17:24:19 +01002710 struct snd_soc_dapm_path *path, *p;
2711 const char *sink;
2712 const char *source;
2713 char prefixed_sink[80];
2714 char prefixed_source[80];
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002715 const char *prefix;
Mark Brownefcc3c62012-07-05 17:24:19 +01002716
2717 if (route->control) {
2718 dev_err(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002719 "ASoC: Removal of routes with controls not supported\n");
Mark Brownefcc3c62012-07-05 17:24:19 +01002720 return -EINVAL;
2721 }
2722
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002723 prefix = soc_dapm_prefix(dapm);
2724 if (prefix) {
Mark Brownefcc3c62012-07-05 17:24:19 +01002725 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002726 prefix, route->sink);
Mark Brownefcc3c62012-07-05 17:24:19 +01002727 sink = prefixed_sink;
2728 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02002729 prefix, route->source);
Mark Brownefcc3c62012-07-05 17:24:19 +01002730 source = prefixed_source;
2731 } else {
2732 sink = route->sink;
2733 source = route->source;
2734 }
2735
2736 path = NULL;
2737 list_for_each_entry(p, &dapm->card->paths, list) {
2738 if (strcmp(p->source->name, source) != 0)
2739 continue;
2740 if (strcmp(p->sink->name, sink) != 0)
2741 continue;
2742 path = p;
2743 break;
2744 }
2745
2746 if (path) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002747 wsource = path->source;
2748 wsink = path->sink;
2749
2750 dapm_mark_dirty(wsource, "Route removed");
2751 dapm_mark_dirty(wsink, "Route removed");
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02002752 if (path->connect)
2753 dapm_path_invalidate(path);
Mark Brownefcc3c62012-07-05 17:24:19 +01002754
Lars-Peter Clausen88722932013-06-14 13:16:53 +02002755 dapm_free_path(path);
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02002756
2757 /* Update any path related flags */
2758 dapm_update_widget_flags(wsource);
2759 dapm_update_widget_flags(wsink);
Mark Brownefcc3c62012-07-05 17:24:19 +01002760 } else {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002761 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
Mark Brownefcc3c62012-07-05 17:24:19 +01002762 source, sink);
2763 }
2764
2765 return 0;
2766}
2767
Mark Brown105f1c22008-05-13 14:52:19 +02002768/**
Mark Brown105f1c22008-05-13 14:52:19 +02002769 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002770 * @dapm: DAPM context
Mark Brown105f1c22008-05-13 14:52:19 +02002771 * @route: audio routes
2772 * @num: number of routes
2773 *
2774 * Connects 2 dapm widgets together via a named audio path. The sink is
2775 * the widget receiving the audio signal, whilst the source is the sender
2776 * of the audio signal.
2777 *
2778 * Returns 0 for success else error. On error all resources can be freed
2779 * with a call to snd_soc_card_free().
2780 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002781int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
Mark Brown105f1c22008-05-13 14:52:19 +02002782 const struct snd_soc_dapm_route *route, int num)
2783{
Mark Brown62d4a4b2012-06-22 12:21:49 +01002784 int i, r, ret = 0;
Mark Brown105f1c22008-05-13 14:52:19 +02002785
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002786 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brown105f1c22008-05-13 14:52:19 +02002787 for (i = 0; i < num; i++) {
Lars-Peter Clausena4e91542014-05-07 16:20:25 +02002788 r = snd_soc_dapm_add_route(dapm, route);
Mark Brown62d4a4b2012-06-22 12:21:49 +01002789 if (r < 0) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002790 dev_err(dapm->dev, "ASoC: Failed to add route %s -> %s -> %s\n",
2791 route->source,
2792 route->control ? route->control : "direct",
2793 route->sink);
Mark Brown62d4a4b2012-06-22 12:21:49 +01002794 ret = r;
Mark Brown105f1c22008-05-13 14:52:19 +02002795 }
2796 route++;
2797 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002798 mutex_unlock(&dapm->card->dapm_mutex);
Mark Brown105f1c22008-05-13 14:52:19 +02002799
Dan Carpenter60884c22012-04-13 22:25:43 +03002800 return ret;
Mark Brown105f1c22008-05-13 14:52:19 +02002801}
2802EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
2803
Mark Brownefcc3c62012-07-05 17:24:19 +01002804/**
2805 * snd_soc_dapm_del_routes - Remove routes between DAPM widgets
2806 * @dapm: DAPM context
2807 * @route: audio routes
2808 * @num: number of routes
2809 *
2810 * Removes routes from the DAPM context.
2811 */
2812int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm,
2813 const struct snd_soc_dapm_route *route, int num)
2814{
Rajan Vajae066ea22016-02-11 11:23:35 +05302815 int i;
Mark Brownefcc3c62012-07-05 17:24:19 +01002816
2817 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2818 for (i = 0; i < num; i++) {
2819 snd_soc_dapm_del_route(dapm, route);
2820 route++;
2821 }
2822 mutex_unlock(&dapm->card->dapm_mutex);
2823
Rajan Vajae066ea22016-02-11 11:23:35 +05302824 return 0;
Mark Brownefcc3c62012-07-05 17:24:19 +01002825}
2826EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes);
2827
Mark Brownbf3a9e12011-06-13 16:42:29 +01002828static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
2829 const struct snd_soc_dapm_route *route)
2830{
2831 struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
2832 route->source,
2833 true);
2834 struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
2835 route->sink,
2836 true);
2837 struct snd_soc_dapm_path *path;
2838 int count = 0;
2839
2840 if (!source) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002841 dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002842 route->source);
2843 return -ENODEV;
2844 }
2845
2846 if (!sink) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002847 dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002848 route->sink);
2849 return -ENODEV;
2850 }
2851
2852 if (route->control || route->connected)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002853 dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002854 route->source, route->sink);
2855
Lars-Peter Clausene63bfd42015-07-26 19:05:00 +02002856 snd_soc_dapm_widget_for_each_sink_path(source, path) {
Mark Brownbf3a9e12011-06-13 16:42:29 +01002857 if (path->sink == sink) {
2858 path->weak = 1;
2859 count++;
2860 }
2861 }
2862
2863 if (count == 0)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002864 dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002865 route->source, route->sink);
2866 if (count > 1)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00002867 dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
Mark Brownbf3a9e12011-06-13 16:42:29 +01002868 count, route->source, route->sink);
2869
2870 return 0;
2871}
2872
2873/**
2874 * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
2875 * @dapm: DAPM context
2876 * @route: audio routes
2877 * @num: number of routes
2878 *
2879 * Mark existing routes matching those specified in the passed array
2880 * as being weak, meaning that they are ignored for the purpose of
2881 * power decisions. The main intended use case is for sidetone paths
2882 * which couple audio between other independent paths if they are both
2883 * active in order to make the combination work better at the user
2884 * level but which aren't intended to be "used".
2885 *
2886 * Note that CODEC drivers should not use this as sidetone type paths
2887 * can frequently also be used as bypass paths.
2888 */
2889int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
2890 const struct snd_soc_dapm_route *route, int num)
2891{
2892 int i, err;
2893 int ret = 0;
2894
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002895 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brownbf3a9e12011-06-13 16:42:29 +01002896 for (i = 0; i < num; i++) {
2897 err = snd_soc_dapm_weak_route(dapm, route);
2898 if (err)
2899 ret = err;
2900 route++;
2901 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002902 mutex_unlock(&dapm->card->dapm_mutex);
Mark Brownbf3a9e12011-06-13 16:42:29 +01002903
2904 return ret;
2905}
2906EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2907
Mark Brown105f1c22008-05-13 14:52:19 +02002908/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02002909 * snd_soc_dapm_new_widgets - add new dapm widgets
Jonathan Corbet628536e2015-08-25 01:14:48 -06002910 * @card: card to be checked for new dapm widgets
Richard Purdie2b97eab2006-10-06 18:32:18 +02002911 *
2912 * Checks the codec for any new dapm widgets and creates them if found.
2913 *
2914 * Returns 0 for success.
2915 */
Lars-Peter Clausen824ef822013-08-27 15:51:01 +02002916int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002917{
2918 struct snd_soc_dapm_widget *w;
Mark Brownb66a70d2011-02-09 18:04:11 +00002919 unsigned int val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002920
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002921 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002922
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002923 list_for_each_entry(w, &card->widgets, list)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002924 {
2925 if (w->new)
2926 continue;
2927
Stephen Warrenfad59882011-04-28 17:37:59 -06002928 if (w->num_kcontrols) {
2929 w->kcontrols = kzalloc(w->num_kcontrols *
2930 sizeof(struct snd_kcontrol *),
2931 GFP_KERNEL);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002932 if (!w->kcontrols) {
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002933 mutex_unlock(&card->dapm_mutex);
Stephen Warrenfad59882011-04-28 17:37:59 -06002934 return -ENOMEM;
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002935 }
Stephen Warrenfad59882011-04-28 17:37:59 -06002936 }
2937
Richard Purdie2b97eab2006-10-06 18:32:18 +02002938 switch(w->id) {
2939 case snd_soc_dapm_switch:
2940 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00002941 case snd_soc_dapm_mixer_named_ctl:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002942 dapm_new_mixer(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002943 break;
2944 case snd_soc_dapm_mux:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02002945 case snd_soc_dapm_demux:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002946 dapm_new_mux(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002947 break;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002948 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06002949 case snd_soc_dapm_out_drv:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002950 dapm_new_pga(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002951 break;
Nikesh Oswalc6615082015-02-02 17:06:44 +00002952 case snd_soc_dapm_dai_link:
2953 dapm_new_dai_link(w);
2954 break;
Mark Brown7ca3a182011-10-08 14:04:50 +01002955 default:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002956 break;
2957 }
Mark Brownb66a70d2011-02-09 18:04:11 +00002958
2959 /* Read the initial power state from the device */
2960 if (w->reg >= 0) {
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002961 soc_dapm_read(w->dapm, w->reg, &val);
Arun Shamanna Lakshmif7d3c172014-01-14 15:31:54 -08002962 val = val >> w->shift;
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02002963 val &= w->mask;
2964 if (val == w->on_val)
Mark Brownb66a70d2011-02-09 18:04:11 +00002965 w->power = 1;
2966 }
2967
Richard Purdie2b97eab2006-10-06 18:32:18 +02002968 w->new = 1;
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002969
Mark Brown7508b122011-10-05 12:09:12 +01002970 dapm_mark_dirty(w, "new widget");
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002971 dapm_debugfs_add_widget(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002972 }
2973
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02002974 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2975 mutex_unlock(&card->dapm_mutex);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002976 return 0;
2977}
2978EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
2979
2980/**
2981 * snd_soc_dapm_get_volsw - dapm mixer get callback
2982 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002983 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02002984 *
2985 * Callback to get the value of a dapm mixer control.
2986 *
2987 * Returns 0 for success.
2988 */
2989int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
2990 struct snd_ctl_elem_value *ucontrol)
2991{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002992 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
2993 struct snd_soc_card *card = dapm->card;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002994 struct soc_mixer_control *mc =
2995 (struct soc_mixer_control *)kcontrol->private_value;
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02002996 int reg = mc->reg;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002997 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002998 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002999 unsigned int mask = (1 << fls(max)) - 1;
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003000 unsigned int invert = mc->invert;
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003001 unsigned int val;
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003002 int ret = 0;
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003003
3004 if (snd_soc_volsw_is_stereo(mc))
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003005 dev_warn(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003006 "ASoC: Control '%s' is stereo, which is not supported\n",
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003007 kcontrol->id.name);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003008
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003009 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003010 if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
3011 ret = soc_dapm_read(dapm, reg, &val);
3012 val = (val >> shift) & mask;
3013 } else {
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003014 val = dapm_kcontrol_get_value(kcontrol);
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003015 }
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003016 mutex_unlock(&card->dapm_mutex);
3017
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003018 if (invert)
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003019 ucontrol->value.integer.value[0] = max - val;
3020 else
3021 ucontrol->value.integer.value[0] = val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003022
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003023 return ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003024}
3025EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
3026
3027/**
3028 * snd_soc_dapm_put_volsw - dapm mixer set callback
3029 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00003030 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02003031 *
3032 * Callback to set the value of a dapm mixer control.
3033 *
3034 * Returns 0 for success.
3035 */
3036int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
3037 struct snd_ctl_elem_value *ucontrol)
3038{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003039 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3040 struct snd_soc_card *card = dapm->card;
Jon Smirl4eaa9812008-07-29 11:42:26 +01003041 struct soc_mixer_control *mc =
3042 (struct soc_mixer_control *)kcontrol->private_value;
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003043 int reg = mc->reg;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003044 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01003045 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003046 unsigned int mask = (1 << fls(max)) - 1;
3047 unsigned int invert = mc->invert;
Stephen Warrene9cf7042011-01-27 14:54:05 -07003048 unsigned int val;
Jarkko Nikula18626c72014-06-09 14:20:29 +03003049 int connect, change, reg_change = 0;
Mark Brown97404f22010-12-14 16:13:57 +00003050 struct snd_soc_dapm_update update;
Nenghua Cao52765972013-12-13 20:13:49 +08003051 int ret = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003052
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003053 if (snd_soc_volsw_is_stereo(mc))
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003054 dev_warn(dapm->dev,
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003055 "ASoC: Control '%s' is stereo, which is not supported\n",
Benoît Thébaudeauda602ab2012-07-03 20:18:17 +02003056 kcontrol->id.name);
3057
Richard Purdie2b97eab2006-10-06 18:32:18 +02003058 val = (ucontrol->value.integer.value[0] & mask);
Benoît Thébaudeau8a720712012-06-18 22:41:28 +02003059 connect = !!val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003060
3061 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01003062 val = max - val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003063
Liam Girdwood3cd04342012-03-09 12:02:08 +00003064 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003065
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003066 change = dapm_kcontrol_set_value(kcontrol, val);
Mark Brown283375c2009-12-07 18:09:03 +00003067
Jarkko Nikula18626c72014-06-09 14:20:29 +03003068 if (reg != SND_SOC_NOPM) {
3069 mask = mask << shift;
3070 val = val << shift;
Lars-Peter Clausenc9e065c2014-05-04 19:17:05 +02003071
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003072 reg_change = soc_dapm_test_bits(dapm, reg, mask, val);
Jarkko Nikula18626c72014-06-09 14:20:29 +03003073 }
3074
3075 if (change || reg_change) {
3076 if (reg_change) {
3077 update.kcontrol = kcontrol;
3078 update.reg = reg;
3079 update.mask = mask;
3080 update.val = val;
3081 card->update = &update;
Lars-Peter Clausen249ce132013-10-06 13:43:49 +02003082 }
Jarkko Nikula18626c72014-06-09 14:20:29 +03003083 change |= reg_change;
Mark Brown97404f22010-12-14 16:13:57 +00003084
Nenghua Cao52765972013-12-13 20:13:49 +08003085 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
Mark Brown97404f22010-12-14 16:13:57 +00003086
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02003087 card->update = NULL;
Mark Brown283375c2009-12-07 18:09:03 +00003088 }
3089
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003090 mutex_unlock(&card->dapm_mutex);
Nenghua Cao52765972013-12-13 20:13:49 +08003091
3092 if (ret > 0)
3093 soc_dpcm_runtime_update(card);
3094
Lars-Peter Clausen56a67832013-07-24 15:27:35 +02003095 return change;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003096}
3097EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
3098
3099/**
3100 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
3101 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00003102 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02003103 *
3104 * Callback to get the value of a dapm enumerated double mixer control.
3105 *
3106 * Returns 0 for success.
3107 */
3108int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
3109 struct snd_ctl_elem_value *ucontrol)
3110{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003111 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
Charles Keepax561ed682015-05-01 12:37:26 +01003112 struct snd_soc_card *card = dapm->card;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003113 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003114 unsigned int reg_val, val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003115
Charles Keepax561ed682015-05-01 12:37:26 +01003116 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3117 if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003118 int ret = soc_dapm_read(dapm, e->reg, &reg_val);
Charles Keepax964a0b82015-05-08 10:50:10 +01003119 if (ret) {
3120 mutex_unlock(&card->dapm_mutex);
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003121 return ret;
Charles Keepax964a0b82015-05-08 10:50:10 +01003122 }
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003123 } else {
Lars-Peter Clausen236aaa62014-02-28 08:31:11 +01003124 reg_val = dapm_kcontrol_get_value(kcontrol);
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003125 }
Charles Keepax561ed682015-05-01 12:37:26 +01003126 mutex_unlock(&card->dapm_mutex);
Lars-Peter Clausen236aaa62014-02-28 08:31:11 +01003127
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003128 val = (reg_val >> e->shift_l) & e->mask;
3129 ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
3130 if (e->shift_l != e->shift_r) {
3131 val = (reg_val >> e->shift_r) & e->mask;
3132 val = snd_soc_enum_val_to_item(e, val);
3133 ucontrol->value.enumerated.item[1] = val;
3134 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02003135
Geert Uytterhoeven69128312014-08-08 17:29:35 +02003136 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003137}
3138EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
3139
3140/**
3141 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
3142 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00003143 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02003144 *
3145 * Callback to set the value of a dapm enumerated double mixer control.
3146 *
3147 * Returns 0 for success.
3148 */
3149int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
3150 struct snd_ctl_elem_value *ucontrol)
3151{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003152 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3153 struct snd_soc_card *card = dapm->card;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003154 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003155 unsigned int *item = ucontrol->value.enumerated.item;
Charles Keepax561ed682015-05-01 12:37:26 +01003156 unsigned int val, change, reg_change = 0;
Lars-Peter Clausen86767b72012-09-14 13:57:27 +02003157 unsigned int mask;
Mark Brown97404f22010-12-14 16:13:57 +00003158 struct snd_soc_dapm_update update;
Nenghua Cao52765972013-12-13 20:13:49 +08003159 int ret = 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003160
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003161 if (item[0] >= e->items)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003162 return -EINVAL;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003163
3164 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
Lars-Peter Clausen86767b72012-09-14 13:57:27 +02003165 mask = e->mask << e->shift_l;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003166 if (e->shift_l != e->shift_r) {
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003167 if (item[1] > e->items)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003168 return -EINVAL;
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003169 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_l;
Lars-Peter Clausen86767b72012-09-14 13:57:27 +02003170 mask |= e->mask << e->shift_r;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003171 }
3172
Liam Girdwood3cd04342012-03-09 12:02:08 +00003173 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Stephen Warrenfafd2172011-04-28 17:38:00 -06003174
Charles Keepax561ed682015-05-01 12:37:26 +01003175 change = dapm_kcontrol_set_value(kcontrol, val);
Mark Brown97404f22010-12-14 16:13:57 +00003176
Charles Keepax561ed682015-05-01 12:37:26 +01003177 if (e->reg != SND_SOC_NOPM)
3178 reg_change = soc_dapm_test_bits(dapm, e->reg, mask, val);
3179
3180 if (change || reg_change) {
3181 if (reg_change) {
Lars-Peter Clausen236aaa62014-02-28 08:31:11 +01003182 update.kcontrol = kcontrol;
3183 update.reg = e->reg;
3184 update.mask = mask;
3185 update.val = val;
3186 card->update = &update;
3187 }
Charles Keepax561ed682015-05-01 12:37:26 +01003188 change |= reg_change;
Mark Brown3a655772009-10-05 17:23:30 +01003189
Lars-Peter Clausen3727b492014-02-28 08:31:04 +01003190 ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
Mark Brown1642e3d2009-10-05 16:24:26 +01003191
Lars-Peter Clausen564c65042013-07-29 17:13:55 +02003192 card->update = NULL;
Stephen Warrenfafd2172011-04-28 17:38:00 -06003193 }
3194
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003195 mutex_unlock(&card->dapm_mutex);
Nenghua Cao52765972013-12-13 20:13:49 +08003196
3197 if (ret > 0)
3198 soc_dpcm_runtime_update(card);
3199
Mark Brown97404f22010-12-14 16:13:57 +00003200 return change;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003201}
3202EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
3203
3204/**
Mark Brown8b37dbd2009-02-28 21:14:20 +00003205 * snd_soc_dapm_info_pin_switch - Info for a pin switch
3206 *
3207 * @kcontrol: mixer control
3208 * @uinfo: control element information
3209 *
3210 * Callback to provide information about a pin switch control.
3211 */
3212int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
3213 struct snd_ctl_elem_info *uinfo)
3214{
3215 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3216 uinfo->count = 1;
3217 uinfo->value.integer.min = 0;
3218 uinfo->value.integer.max = 1;
3219
3220 return 0;
3221}
3222EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
3223
3224/**
3225 * snd_soc_dapm_get_pin_switch - Get information for a pin switch
3226 *
3227 * @kcontrol: mixer control
3228 * @ucontrol: Value
3229 */
3230int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
3231 struct snd_ctl_elem_value *ucontrol)
3232{
Mark Brown48a8c392012-02-14 17:11:15 -08003233 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003234 const char *pin = (const char *)kcontrol->private_value;
3235
Liam Girdwood3cd04342012-03-09 12:02:08 +00003236 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003237
3238 ucontrol->value.integer.value[0] =
Mark Brown48a8c392012-02-14 17:11:15 -08003239 snd_soc_dapm_get_pin_status(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003240
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003241 mutex_unlock(&card->dapm_mutex);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003242
3243 return 0;
3244}
3245EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
3246
3247/**
3248 * snd_soc_dapm_put_pin_switch - Set information for a pin switch
3249 *
3250 * @kcontrol: mixer control
3251 * @ucontrol: Value
3252 */
3253int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
3254 struct snd_ctl_elem_value *ucontrol)
3255{
Mark Brown48a8c392012-02-14 17:11:15 -08003256 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003257 const char *pin = (const char *)kcontrol->private_value;
3258
Mark Brown8b37dbd2009-02-28 21:14:20 +00003259 if (ucontrol->value.integer.value[0])
Mark Brown48a8c392012-02-14 17:11:15 -08003260 snd_soc_dapm_enable_pin(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003261 else
Mark Brown48a8c392012-02-14 17:11:15 -08003262 snd_soc_dapm_disable_pin(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003263
Mark Brown48a8c392012-02-14 17:11:15 -08003264 snd_soc_dapm_sync(&card->dapm);
Mark Brown8b37dbd2009-02-28 21:14:20 +00003265 return 0;
3266}
3267EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
3268
Liam Girdwoodcc76e7d2015-06-04 15:13:09 +01003269struct snd_soc_dapm_widget *
Mark Brown5ba06fc2012-02-16 11:07:13 -08003270snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003271 const struct snd_soc_dapm_widget *widget)
3272{
3273 struct snd_soc_dapm_widget *w;
3274
3275 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3276 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3277 if (!w)
3278 dev_err(dapm->dev,
3279 "ASoC: Failed to create DAPM control %s\n",
3280 widget->name);
3281
3282 mutex_unlock(&dapm->card->dapm_mutex);
3283 return w;
3284}
3285
3286struct snd_soc_dapm_widget *
3287snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
Mark Brown5ba06fc2012-02-16 11:07:13 -08003288 const struct snd_soc_dapm_widget *widget)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003289{
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003290 enum snd_soc_dapm_direction dir;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003291 struct snd_soc_dapm_widget *w;
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02003292 const char *prefix;
Mark Brown62ea8742012-01-21 21:14:48 +00003293 int ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003294
3295 if ((w = dapm_cnew_widget(widget)) == NULL)
Mark Brown5ba06fc2012-02-16 11:07:13 -08003296 return NULL;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003297
Mark Brown62ea8742012-01-21 21:14:48 +00003298 switch (w->id) {
3299 case snd_soc_dapm_regulator_supply:
Liam Girdwooda3cc0562012-03-09 17:20:16 +00003300 w->regulator = devm_regulator_get(dapm->dev, w->name);
3301 if (IS_ERR(w->regulator)) {
3302 ret = PTR_ERR(w->regulator);
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003303 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
Mark Brown62ea8742012-01-21 21:14:48 +00003304 w->name, ret);
Mark Brown5ba06fc2012-02-16 11:07:13 -08003305 return NULL;
Mark Brown62ea8742012-01-21 21:14:48 +00003306 }
Mark Brown8784c772013-01-10 19:33:47 +00003307
Lars-Peter Clausende9ba982013-07-29 17:14:01 +02003308 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
Mark Brown8784c772013-01-10 19:33:47 +00003309 ret = regulator_allow_bypass(w->regulator, true);
3310 if (ret != 0)
3311 dev_warn(w->dapm->dev,
Charles Keepax30686c32014-02-18 16:05:27 +00003312 "ASoC: Failed to bypass %s: %d\n",
Mark Brown8784c772013-01-10 19:33:47 +00003313 w->name, ret);
3314 }
Mark Brown62ea8742012-01-21 21:14:48 +00003315 break;
Ola Liljad7e7eb92012-05-24 15:26:25 +02003316 case snd_soc_dapm_clock_supply:
Mark Brown165961e2012-06-05 10:44:23 +01003317#ifdef CONFIG_CLKDEV_LOOKUP
Mark Brown695594f12012-06-04 08:14:13 +01003318 w->clk = devm_clk_get(dapm->dev, w->name);
Ola Liljad7e7eb92012-05-24 15:26:25 +02003319 if (IS_ERR(w->clk)) {
3320 ret = PTR_ERR(w->clk);
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003321 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
Ola Liljad7e7eb92012-05-24 15:26:25 +02003322 w->name, ret);
3323 return NULL;
3324 }
Mark Brownec029952012-06-04 08:16:20 +01003325#else
3326 return NULL;
3327#endif
Ola Liljad7e7eb92012-05-24 15:26:25 +02003328 break;
Mark Brown62ea8742012-01-21 21:14:48 +00003329 default:
3330 break;
3331 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02003332
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02003333 prefix = soc_dapm_prefix(dapm);
Lars-Peter Clausena798c242015-07-21 11:51:35 +02003334 if (prefix)
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02003335 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, widget->name);
Lars-Peter Clausena798c242015-07-21 11:51:35 +02003336 else
Lars-Peter Clausen48068962015-07-21 18:11:08 +02003337 w->name = kstrdup_const(widget->name, GFP_KERNEL);
Jarkko Nikulaead9b912010-11-13 20:40:44 +02003338 if (w->name == NULL) {
3339 kfree(w);
Mark Brown5ba06fc2012-02-16 11:07:13 -08003340 return NULL;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02003341 }
Jarkko Nikulaead9b912010-11-13 20:40:44 +02003342
Mark Brown7ca3a182011-10-08 14:04:50 +01003343 switch (w->id) {
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003344 case snd_soc_dapm_mic:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003345 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003346 w->power_check = dapm_generic_check_power;
3347 break;
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01003348 case snd_soc_dapm_input:
3349 if (!dapm->card->fully_routed)
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003350 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01003351 w->power_check = dapm_generic_check_power;
3352 break;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003353 case snd_soc_dapm_spk:
3354 case snd_soc_dapm_hp:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003355 w->is_ep = SND_SOC_DAPM_EP_SINK;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003356 w->power_check = dapm_generic_check_power;
3357 break;
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01003358 case snd_soc_dapm_output:
3359 if (!dapm->card->fully_routed)
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003360 w->is_ep = SND_SOC_DAPM_EP_SINK;
Lars-Peter Clausen86d75002014-12-21 11:05:44 +01003361 w->power_check = dapm_generic_check_power;
3362 break;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003363 case snd_soc_dapm_vmid:
3364 case snd_soc_dapm_siggen:
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003365 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003366 w->power_check = dapm_always_on_check_power;
3367 break;
Vinod Koul56b44372015-11-23 21:22:30 +05303368 case snd_soc_dapm_sink:
3369 w->is_ep = SND_SOC_DAPM_EP_SINK;
3370 w->power_check = dapm_always_on_check_power;
3371 break;
3372
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003373 case snd_soc_dapm_mux:
Lars-Peter Clausend714f972015-05-01 18:02:43 +02003374 case snd_soc_dapm_demux:
Mark Brown7ca3a182011-10-08 14:04:50 +01003375 case snd_soc_dapm_switch:
3376 case snd_soc_dapm_mixer:
3377 case snd_soc_dapm_mixer_named_ctl:
Mark Brown63c69a62013-07-18 22:03:01 +01003378 case snd_soc_dapm_adc:
3379 case snd_soc_dapm_aif_out:
3380 case snd_soc_dapm_dac:
3381 case snd_soc_dapm_aif_in:
Mark Brown7ca3a182011-10-08 14:04:50 +01003382 case snd_soc_dapm_pga:
3383 case snd_soc_dapm_out_drv:
Mark Brown7ca3a182011-10-08 14:04:50 +01003384 case snd_soc_dapm_micbias:
Mark Brown7ca3a182011-10-08 14:04:50 +01003385 case snd_soc_dapm_line:
Mark Brownc74184e2012-04-04 22:12:09 +01003386 case snd_soc_dapm_dai_link:
Lars-Peter Clausencdef2ad2014-10-20 19:36:38 +02003387 case snd_soc_dapm_dai_out:
3388 case snd_soc_dapm_dai_in:
Mark Brown7ca3a182011-10-08 14:04:50 +01003389 w->power_check = dapm_generic_check_power;
3390 break;
3391 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00003392 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02003393 case snd_soc_dapm_clock_supply:
Lars-Peter Clausen57295072013-08-05 11:27:31 +02003394 case snd_soc_dapm_kcontrol:
Lars-Peter Clausen6dd98b02014-10-25 17:41:59 +02003395 w->is_supply = 1;
Mark Brown7ca3a182011-10-08 14:04:50 +01003396 w->power_check = dapm_supply_check_power;
3397 break;
3398 default:
3399 w->power_check = dapm_always_on_check_power;
3400 break;
3401 }
3402
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003403 w->dapm = dapm;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003404 INIT_LIST_HEAD(&w->list);
Mark Browndb432b42011-10-03 21:06:40 +01003405 INIT_LIST_HEAD(&w->dirty);
Lars-Peter Clausen92fa1242015-05-01 18:02:42 +02003406 list_add_tail(&w->list, &dapm->card->widgets);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003407
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003408 snd_soc_dapm_for_each_direction(dir) {
3409 INIT_LIST_HEAD(&w->edges[dir]);
3410 w->endpoints[dir] = -1;
3411 }
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02003412
Richard Purdie2b97eab2006-10-06 18:32:18 +02003413 /* machine layer set ups unconnected pins and insertions */
3414 w->connected = 1;
Mark Brown5ba06fc2012-02-16 11:07:13 -08003415 return w;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003416}
Richard Purdie2b97eab2006-10-06 18:32:18 +02003417
3418/**
Mark Brown4ba13272008-05-13 14:51:19 +02003419 * snd_soc_dapm_new_controls - create new dapm controls
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003420 * @dapm: DAPM context
Mark Brown4ba13272008-05-13 14:51:19 +02003421 * @widget: widget array
3422 * @num: number of widgets
3423 *
3424 * Creates new DAPM controls based upon the templates.
3425 *
3426 * Returns 0 for success else error.
3427 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003428int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
Mark Brown4ba13272008-05-13 14:51:19 +02003429 const struct snd_soc_dapm_widget *widget,
3430 int num)
3431{
Mark Brown5ba06fc2012-02-16 11:07:13 -08003432 struct snd_soc_dapm_widget *w;
3433 int i;
Dan Carpenter60884c22012-04-13 22:25:43 +03003434 int ret = 0;
Mark Brown4ba13272008-05-13 14:51:19 +02003435
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003436 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brown4ba13272008-05-13 14:51:19 +02003437 for (i = 0; i < num; i++) {
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003438 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
Mark Brown5ba06fc2012-02-16 11:07:13 -08003439 if (!w) {
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02003440 dev_err(dapm->dev,
Mark Brown5ba06fc2012-02-16 11:07:13 -08003441 "ASoC: Failed to create DAPM control %s\n",
3442 widget->name);
Dan Carpenter60884c22012-04-13 22:25:43 +03003443 ret = -ENOMEM;
3444 break;
Mark Brownb8b33cb2008-12-18 11:19:30 +00003445 }
Mark Brown4ba13272008-05-13 14:51:19 +02003446 widget++;
3447 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003448 mutex_unlock(&dapm->card->dapm_mutex);
Dan Carpenter60884c22012-04-13 22:25:43 +03003449 return ret;
Mark Brown4ba13272008-05-13 14:51:19 +02003450}
3451EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
3452
Mark Brownc74184e2012-04-04 22:12:09 +01003453static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
3454 struct snd_kcontrol *kcontrol, int event)
3455{
3456 struct snd_soc_dapm_path *source_p, *sink_p;
3457 struct snd_soc_dai *source, *sink;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003458 const struct snd_soc_pcm_stream *config = w->params + w->params_select;
Mark Brownc74184e2012-04-04 22:12:09 +01003459 struct snd_pcm_substream substream;
Mark Brown9747cec2012-04-26 19:12:21 +01003460 struct snd_pcm_hw_params *params = NULL;
Mark Brownc74184e2012-04-04 22:12:09 +01003461 u64 fmt;
3462 int ret;
3463
Takashi Iwaibf4edea2013-11-07 18:38:47 +01003464 if (WARN_ON(!config) ||
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003465 WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
3466 list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
Takashi Iwaibf4edea2013-11-07 18:38:47 +01003467 return -EINVAL;
Mark Brownc74184e2012-04-04 22:12:09 +01003468
3469 /* We only support a single source and sink, pick the first */
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003470 source_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_OUT],
3471 struct snd_soc_dapm_path,
3472 list_node[SND_SOC_DAPM_DIR_OUT]);
3473 sink_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_IN],
3474 struct snd_soc_dapm_path,
3475 list_node[SND_SOC_DAPM_DIR_IN]);
Mark Brownc74184e2012-04-04 22:12:09 +01003476
3477 source = source_p->source->priv;
3478 sink = sink_p->sink->priv;
3479
3480 /* Be a little careful as we don't want to overflow the mask array */
3481 if (config->formats) {
3482 fmt = ffs(config->formats) - 1;
3483 } else {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003484 dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n",
Mark Brownc74184e2012-04-04 22:12:09 +01003485 config->formats);
3486 fmt = 0;
3487 }
3488
3489 /* Currently very limited parameter selection */
Mark Brown9747cec2012-04-26 19:12:21 +01003490 params = kzalloc(sizeof(*params), GFP_KERNEL);
3491 if (!params) {
3492 ret = -ENOMEM;
3493 goto out;
3494 }
3495 snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
Mark Brownc74184e2012-04-04 22:12:09 +01003496
Mark Brown9747cec2012-04-26 19:12:21 +01003497 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
Mark Brownc74184e2012-04-04 22:12:09 +01003498 config->rate_min;
Mark Brown9747cec2012-04-26 19:12:21 +01003499 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
Mark Brownc74184e2012-04-04 22:12:09 +01003500 config->rate_max;
3501
Mark Brown9747cec2012-04-26 19:12:21 +01003502 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
Mark Brownc74184e2012-04-04 22:12:09 +01003503 = config->channels_min;
Mark Brown9747cec2012-04-26 19:12:21 +01003504 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
Mark Brownc74184e2012-04-04 22:12:09 +01003505 = config->channels_max;
3506
3507 memset(&substream, 0, sizeof(substream));
3508
3509 switch (event) {
3510 case SND_SOC_DAPM_PRE_PMU:
Benoit Cousson93e69582014-07-08 23:19:38 +02003511 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
Jeeja KP9b8ef9f2015-10-20 22:30:07 +05303512 if (source->driver->ops && source->driver->ops->startup) {
3513 ret = source->driver->ops->startup(&substream, source);
3514 if (ret < 0) {
3515 dev_err(source->dev,
3516 "ASoC: startup() failed: %d\n", ret);
3517 goto out;
3518 }
3519 source->active++;
3520 }
Benoit Cousson93e69582014-07-08 23:19:38 +02003521 ret = soc_dai_hw_params(&substream, params, source);
3522 if (ret < 0)
3523 goto out;
Mark Brownc74184e2012-04-04 22:12:09 +01003524
Benoit Cousson93e69582014-07-08 23:19:38 +02003525 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
Jeeja KP9b8ef9f2015-10-20 22:30:07 +05303526 if (sink->driver->ops && sink->driver->ops->startup) {
3527 ret = sink->driver->ops->startup(&substream, sink);
3528 if (ret < 0) {
3529 dev_err(sink->dev,
3530 "ASoC: startup() failed: %d\n", ret);
3531 goto out;
3532 }
3533 sink->active++;
3534 }
Benoit Cousson93e69582014-07-08 23:19:38 +02003535 ret = soc_dai_hw_params(&substream, params, sink);
3536 if (ret < 0)
3537 goto out;
Mark Brownc74184e2012-04-04 22:12:09 +01003538 break;
3539
3540 case SND_SOC_DAPM_POST_PMU:
Mark Brownda183962013-02-06 15:44:07 +00003541 ret = snd_soc_dai_digital_mute(sink, 0,
3542 SNDRV_PCM_STREAM_PLAYBACK);
Mark Brownc74184e2012-04-04 22:12:09 +01003543 if (ret != 0 && ret != -ENOTSUPP)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003544 dev_warn(sink->dev, "ASoC: Failed to unmute: %d\n", ret);
Mark Brown9747cec2012-04-26 19:12:21 +01003545 ret = 0;
Mark Brownc74184e2012-04-04 22:12:09 +01003546 break;
3547
3548 case SND_SOC_DAPM_PRE_PMD:
Mark Brownda183962013-02-06 15:44:07 +00003549 ret = snd_soc_dai_digital_mute(sink, 1,
3550 SNDRV_PCM_STREAM_PLAYBACK);
Mark Brownc74184e2012-04-04 22:12:09 +01003551 if (ret != 0 && ret != -ENOTSUPP)
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003552 dev_warn(sink->dev, "ASoC: Failed to mute: %d\n", ret);
Mark Brown9747cec2012-04-26 19:12:21 +01003553 ret = 0;
Jeeja KP9b8ef9f2015-10-20 22:30:07 +05303554
3555 source->active--;
3556 if (source->driver->ops && source->driver->ops->shutdown) {
3557 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3558 source->driver->ops->shutdown(&substream, source);
3559 }
3560
3561 sink->active--;
3562 if (sink->driver->ops && sink->driver->ops->shutdown) {
3563 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
3564 sink->driver->ops->shutdown(&substream, sink);
3565 }
Mark Brownc74184e2012-04-04 22:12:09 +01003566 break;
3567
3568 default:
Takashi Iwaia6ed0602013-11-06 11:07:19 +01003569 WARN(1, "Unknown event %d\n", event);
Sudip Mukherjee75881df2015-09-10 18:01:44 +05303570 ret = -EINVAL;
Mark Brownc74184e2012-04-04 22:12:09 +01003571 }
3572
Mark Brown9747cec2012-04-26 19:12:21 +01003573out:
3574 kfree(params);
3575 return ret;
Mark Brownc74184e2012-04-04 22:12:09 +01003576}
3577
Nikesh Oswalc6615082015-02-02 17:06:44 +00003578static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
3579 struct snd_ctl_elem_value *ucontrol)
3580{
3581 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3582
Takashi Iwai741338f2016-02-29 17:20:48 +01003583 ucontrol->value.enumerated.item[0] = w->params_select;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003584
3585 return 0;
3586}
3587
3588static int snd_soc_dapm_dai_link_put(struct snd_kcontrol *kcontrol,
3589 struct snd_ctl_elem_value *ucontrol)
3590{
3591 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3592
3593 /* Can't change the config when widget is already powered */
3594 if (w->power)
3595 return -EBUSY;
3596
Takashi Iwai741338f2016-02-29 17:20:48 +01003597 if (ucontrol->value.enumerated.item[0] == w->params_select)
Nikesh Oswalc6615082015-02-02 17:06:44 +00003598 return 0;
3599
Takashi Iwai741338f2016-02-29 17:20:48 +01003600 if (ucontrol->value.enumerated.item[0] >= w->num_params)
Nikesh Oswalc6615082015-02-02 17:06:44 +00003601 return -EINVAL;
3602
Takashi Iwai741338f2016-02-29 17:20:48 +01003603 w->params_select = ucontrol->value.enumerated.item[0];
Nikesh Oswalc6615082015-02-02 17:06:44 +00003604
3605 return 0;
3606}
3607
Mark Brownc74184e2012-04-04 22:12:09 +01003608int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
3609 const struct snd_soc_pcm_stream *params,
Nikesh Oswalc6615082015-02-02 17:06:44 +00003610 unsigned int num_params,
Mark Brownc74184e2012-04-04 22:12:09 +01003611 struct snd_soc_dapm_widget *source,
3612 struct snd_soc_dapm_widget *sink)
3613{
Mark Brownc74184e2012-04-04 22:12:09 +01003614 struct snd_soc_dapm_widget template;
3615 struct snd_soc_dapm_widget *w;
Mark Brownc74184e2012-04-04 22:12:09 +01003616 char *link_name;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003617 int ret, count;
3618 unsigned long private_value;
3619 const char **w_param_text;
3620 struct soc_enum w_param_enum[] = {
3621 SOC_ENUM_SINGLE(0, 0, 0, NULL),
3622 };
3623 struct snd_kcontrol_new kcontrol_dai_link[] = {
3624 SOC_ENUM_EXT(NULL, w_param_enum[0],
3625 snd_soc_dapm_dai_link_get,
3626 snd_soc_dapm_dai_link_put),
3627 };
3628 const struct snd_soc_pcm_stream *config = params;
Mark Brownc74184e2012-04-04 22:12:09 +01003629
Nikesh Oswalc6615082015-02-02 17:06:44 +00003630 w_param_text = devm_kcalloc(card->dev, num_params,
3631 sizeof(char *), GFP_KERNEL);
3632 if (!w_param_text)
Mark Brownc74184e2012-04-04 22:12:09 +01003633 return -ENOMEM;
Mark Brownc74184e2012-04-04 22:12:09 +01003634
Charles Keepax46172b62015-03-25 11:22:35 +00003635 link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
3636 source->name, sink->name);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003637 if (!link_name) {
3638 ret = -ENOMEM;
3639 goto outfree_w_param;
3640 }
Mark Brownc74184e2012-04-04 22:12:09 +01003641
Nikesh Oswalc6615082015-02-02 17:06:44 +00003642 for (count = 0 ; count < num_params; count++) {
3643 if (!config->stream_name) {
3644 dev_warn(card->dapm.dev,
3645 "ASoC: anonymous config %d for dai link %s\n",
3646 count, link_name);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003647 w_param_text[count] =
Charles Keepax46172b62015-03-25 11:22:35 +00003648 devm_kasprintf(card->dev, GFP_KERNEL,
3649 "Anonymous Configuration %d",
3650 count);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003651 if (!w_param_text[count]) {
3652 ret = -ENOMEM;
3653 goto outfree_link_name;
3654 }
Nikesh Oswalc6615082015-02-02 17:06:44 +00003655 } else {
3656 w_param_text[count] = devm_kmemdup(card->dev,
3657 config->stream_name,
3658 strlen(config->stream_name) + 1,
3659 GFP_KERNEL);
3660 if (!w_param_text[count]) {
3661 ret = -ENOMEM;
3662 goto outfree_link_name;
3663 }
3664 }
3665 config++;
3666 }
3667 w_param_enum[0].items = num_params;
3668 w_param_enum[0].texts = w_param_text;
Mark Brownc74184e2012-04-04 22:12:09 +01003669
3670 memset(&template, 0, sizeof(template));
3671 template.reg = SND_SOC_NOPM;
3672 template.id = snd_soc_dapm_dai_link;
3673 template.name = link_name;
3674 template.event = snd_soc_dai_link_event;
3675 template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
3676 SND_SOC_DAPM_PRE_PMD;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003677 template.num_kcontrols = 1;
3678 /* duplicate w_param_enum on heap so that memory persists */
3679 private_value =
3680 (unsigned long) devm_kmemdup(card->dev,
3681 (void *)(kcontrol_dai_link[0].private_value),
3682 sizeof(struct soc_enum), GFP_KERNEL);
3683 if (!private_value) {
3684 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3685 link_name);
3686 ret = -ENOMEM;
3687 goto outfree_link_name;
3688 }
3689 kcontrol_dai_link[0].private_value = private_value;
3690 /* duplicate kcontrol_dai_link on heap so that memory persists */
3691 template.kcontrol_news =
3692 devm_kmemdup(card->dev, &kcontrol_dai_link[0],
3693 sizeof(struct snd_kcontrol_new),
3694 GFP_KERNEL);
3695 if (!template.kcontrol_news) {
3696 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3697 link_name);
3698 ret = -ENOMEM;
3699 goto outfree_private_value;
3700 }
Mark Brownc74184e2012-04-04 22:12:09 +01003701
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003702 dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
Mark Brownc74184e2012-04-04 22:12:09 +01003703
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003704 w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
Mark Brownc74184e2012-04-04 22:12:09 +01003705 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003706 dev_err(card->dev, "ASoC: Failed to create %s widget\n",
Mark Brownc74184e2012-04-04 22:12:09 +01003707 link_name);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003708 ret = -ENOMEM;
3709 goto outfree_kcontrol_news;
Mark Brownc74184e2012-04-04 22:12:09 +01003710 }
3711
3712 w->params = params;
Nikesh Oswalc6615082015-02-02 17:06:44 +00003713 w->num_params = num_params;
Mark Brownc74184e2012-04-04 22:12:09 +01003714
Lars-Peter Clausenfe838972014-05-07 16:20:27 +02003715 ret = snd_soc_dapm_add_path(&card->dapm, source, w, NULL, NULL);
3716 if (ret)
Nikesh Oswalc6615082015-02-02 17:06:44 +00003717 goto outfree_w;
Lars-Peter Clausenfe838972014-05-07 16:20:27 +02003718 return snd_soc_dapm_add_path(&card->dapm, w, sink, NULL, NULL);
Nikesh Oswalc6615082015-02-02 17:06:44 +00003719
3720outfree_w:
3721 devm_kfree(card->dev, w);
3722outfree_kcontrol_news:
3723 devm_kfree(card->dev, (void *)template.kcontrol_news);
3724outfree_private_value:
3725 devm_kfree(card->dev, (void *)private_value);
3726outfree_link_name:
3727 devm_kfree(card->dev, link_name);
3728outfree_w_param:
3729 for (count = 0 ; count < num_params; count++)
3730 devm_kfree(card->dev, (void *)w_param_text[count]);
3731 devm_kfree(card->dev, w_param_text);
3732
3733 return ret;
Mark Brownc74184e2012-04-04 22:12:09 +01003734}
3735
Mark Brown888df392012-02-16 19:37:51 -08003736int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
3737 struct snd_soc_dai *dai)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003738{
Mark Brown888df392012-02-16 19:37:51 -08003739 struct snd_soc_dapm_widget template;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003740 struct snd_soc_dapm_widget *w;
3741
Mark Brown888df392012-02-16 19:37:51 -08003742 WARN_ON(dapm->dev != dai->dev);
3743
3744 memset(&template, 0, sizeof(template));
3745 template.reg = SND_SOC_NOPM;
3746
3747 if (dai->driver->playback.stream_name) {
Mark Brown46162742013-06-05 19:36:11 +01003748 template.id = snd_soc_dapm_dai_in;
Mark Brown888df392012-02-16 19:37:51 -08003749 template.name = dai->driver->playback.stream_name;
3750 template.sname = dai->driver->playback.stream_name;
3751
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003752 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003753 template.name);
3754
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003755 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
Mark Brown888df392012-02-16 19:37:51 -08003756 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003757 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003758 dai->driver->playback.stream_name);
Takashi Iwai298402a2013-10-28 14:21:50 +01003759 return -ENOMEM;
Mark Brown888df392012-02-16 19:37:51 -08003760 }
3761
3762 w->priv = dai;
3763 dai->playback_widget = w;
3764 }
3765
3766 if (dai->driver->capture.stream_name) {
Mark Brown46162742013-06-05 19:36:11 +01003767 template.id = snd_soc_dapm_dai_out;
Mark Brown888df392012-02-16 19:37:51 -08003768 template.name = dai->driver->capture.stream_name;
3769 template.sname = dai->driver->capture.stream_name;
3770
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003771 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003772 template.name);
3773
Liam Girdwood02aa78a2015-05-25 18:21:17 +01003774 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
Mark Brown888df392012-02-16 19:37:51 -08003775 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00003776 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
Mark Brown888df392012-02-16 19:37:51 -08003777 dai->driver->capture.stream_name);
Takashi Iwai298402a2013-10-28 14:21:50 +01003778 return -ENOMEM;
Mark Brown888df392012-02-16 19:37:51 -08003779 }
3780
3781 w->priv = dai;
3782 dai->capture_widget = w;
3783 }
3784
3785 return 0;
3786}
3787
3788int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
3789{
3790 struct snd_soc_dapm_widget *dai_w, *w;
Lars-Peter Clausen0f9bd7b2014-05-07 16:20:28 +02003791 struct snd_soc_dapm_widget *src, *sink;
Mark Brown888df392012-02-16 19:37:51 -08003792 struct snd_soc_dai *dai;
Mark Brown888df392012-02-16 19:37:51 -08003793
3794 /* For each DAI widget... */
3795 list_for_each_entry(dai_w, &card->widgets, list) {
Mark Brown46162742013-06-05 19:36:11 +01003796 switch (dai_w->id) {
3797 case snd_soc_dapm_dai_in:
3798 case snd_soc_dapm_dai_out:
3799 break;
3800 default:
Richard Purdie2b97eab2006-10-06 18:32:18 +02003801 continue;
Mark Brown46162742013-06-05 19:36:11 +01003802 }
Mark Brown888df392012-02-16 19:37:51 -08003803
3804 dai = dai_w->priv;
3805
3806 /* ...find all widgets with the same stream and link them */
3807 list_for_each_entry(w, &card->widgets, list) {
3808 if (w->dapm != dai_w->dapm)
3809 continue;
3810
Mark Brown46162742013-06-05 19:36:11 +01003811 switch (w->id) {
3812 case snd_soc_dapm_dai_in:
3813 case snd_soc_dapm_dai_out:
Mark Brown888df392012-02-16 19:37:51 -08003814 continue;
Mark Brown46162742013-06-05 19:36:11 +01003815 default:
3816 break;
3817 }
Mark Brown888df392012-02-16 19:37:51 -08003818
Lars-Peter Clausena798c242015-07-21 11:51:35 +02003819 if (!w->sname || !strstr(w->sname, dai_w->sname))
Mark Brown888df392012-02-16 19:37:51 -08003820 continue;
3821
Lars-Peter Clausen0f9bd7b2014-05-07 16:20:28 +02003822 if (dai_w->id == snd_soc_dapm_dai_in) {
3823 src = dai_w;
3824 sink = w;
3825 } else {
3826 src = w;
3827 sink = dai_w;
Mark Brown888df392012-02-16 19:37:51 -08003828 }
Lars-Peter Clausen0f9bd7b2014-05-07 16:20:28 +02003829 dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
3830 snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003831 }
3832 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02003833
Mark Brown888df392012-02-16 19:37:51 -08003834 return 0;
3835}
Liam Girdwood64a648c2011-07-25 11:15:15 +01003836
Benoit Cousson44ba2642014-07-08 23:19:36 +02003837static void dapm_connect_dai_link_widgets(struct snd_soc_card *card,
3838 struct snd_soc_pcm_runtime *rtd)
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003839{
Benoit Cousson44ba2642014-07-08 23:19:36 +02003840 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003841 struct snd_soc_dapm_widget *sink, *source;
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003842 int i;
3843
Benoit Cousson44ba2642014-07-08 23:19:36 +02003844 for (i = 0; i < rtd->num_codecs; i++) {
3845 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003846
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003847 /* connect BE DAI playback if widgets are valid */
3848 if (codec_dai->playback_widget && cpu_dai->playback_widget) {
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003849 source = cpu_dai->playback_widget;
3850 sink = codec_dai->playback_widget;
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003851 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003852 cpu_dai->component->name, source->name,
3853 codec_dai->component->name, sink->name);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003854
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003855 snd_soc_dapm_add_path(&card->dapm, source, sink,
3856 NULL, NULL);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003857 }
3858
3859 /* connect BE DAI capture if widgets are valid */
3860 if (codec_dai->capture_widget && cpu_dai->capture_widget) {
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003861 source = codec_dai->capture_widget;
3862 sink = cpu_dai->capture_widget;
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003863 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003864 codec_dai->component->name, source->name,
3865 cpu_dai->component->name, sink->name);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003866
Lars-Peter Clausen9887c202014-05-07 16:20:26 +02003867 snd_soc_dapm_add_path(&card->dapm, source, sink,
3868 NULL, NULL);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003869 }
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003870 }
3871}
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003872
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003873static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
3874 int event)
3875{
3876 struct snd_soc_dapm_widget *w;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003877 unsigned int ep;
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003878
3879 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
3880 w = dai->playback_widget;
3881 else
3882 w = dai->capture_widget;
3883
3884 if (w) {
3885 dapm_mark_dirty(w, "stream event");
3886
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003887 if (w->id == snd_soc_dapm_dai_in) {
3888 ep = SND_SOC_DAPM_EP_SOURCE;
3889 dapm_widget_invalidate_input_paths(w);
3890 } else {
3891 ep = SND_SOC_DAPM_EP_SINK;
3892 dapm_widget_invalidate_output_paths(w);
3893 }
3894
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003895 switch (event) {
3896 case SND_SOC_DAPM_STREAM_START:
3897 w->active = 1;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003898 w->is_ep = ep;
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003899 break;
3900 case SND_SOC_DAPM_STREAM_STOP:
3901 w->active = 0;
Lars-Peter Clausena3423b02015-08-11 21:38:00 +02003902 w->is_ep = 0;
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003903 break;
3904 case SND_SOC_DAPM_STREAM_SUSPEND:
3905 case SND_SOC_DAPM_STREAM_RESUME:
3906 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
3907 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
3908 break;
3909 }
Liam Girdwoodb893ea52014-01-08 10:40:19 +00003910 }
3911}
3912
Benoit Cousson44ba2642014-07-08 23:19:36 +02003913void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
3914{
Mengdong Lin1a497982015-11-18 02:34:11 -05003915 struct snd_soc_pcm_runtime *rtd;
Benoit Cousson44ba2642014-07-08 23:19:36 +02003916
3917 /* for each BE DAI link... */
Mengdong Lin1a497982015-11-18 02:34:11 -05003918 list_for_each_entry(rtd, &card->rtd_list, list) {
Benoit Cousson44ba2642014-07-08 23:19:36 +02003919 /*
3920 * dynamic FE links have no fixed DAI mapping.
3921 * CODEC<->CODEC links have no direct connection.
3922 */
3923 if (rtd->dai_link->dynamic || rtd->dai_link->params)
3924 continue;
3925
3926 dapm_connect_dai_link_widgets(card, rtd);
3927 }
3928}
3929
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003930static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3931 int event)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003932{
Benoit Cousson44ba2642014-07-08 23:19:36 +02003933 int i;
3934
Lars-Peter Clausenc471fdd2014-04-29 14:51:22 +02003935 soc_dapm_dai_stream_event(rtd->cpu_dai, stream, event);
Benoit Cousson44ba2642014-07-08 23:19:36 +02003936 for (i = 0; i < rtd->num_codecs; i++)
3937 soc_dapm_dai_stream_event(rtd->codec_dais[i], stream, event);
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003938
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02003939 dapm_power_widgets(rtd->card, event);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003940}
3941
3942/**
3943 * snd_soc_dapm_stream_event - send a stream event to the dapm core
3944 * @rtd: PCM runtime data
3945 * @stream: stream name
3946 * @event: stream event
3947 *
3948 * Sends a stream event to the dapm core. The core then makes any
3949 * necessary widget power changes.
3950 *
3951 * Returns 0 for success else error.
3952 */
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003953void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3954 int event)
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003955{
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003956 struct snd_soc_card *card = rtd->card;
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003957
Liam Girdwood3cd04342012-03-09 12:02:08 +00003958 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003959 soc_dapm_stream_event(rtd, stream, event);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003960 mutex_unlock(&card->dapm_mutex);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003961}
Richard Purdie2b97eab2006-10-06 18:32:18 +02003962
3963/**
Charles Keepax11391102014-02-18 15:22:14 +00003964 * snd_soc_dapm_enable_pin_unlocked - enable pin.
3965 * @dapm: DAPM context
3966 * @pin: pin name
3967 *
3968 * Enables input/output pin and its parents or children widgets iff there is
3969 * a valid audio route and active audio stream.
3970 *
3971 * Requires external locking.
3972 *
3973 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3974 * do any widget power switching.
3975 */
3976int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
3977 const char *pin)
3978{
3979 return snd_soc_dapm_set_pin(dapm, pin, 1);
3980}
3981EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
3982
3983/**
Liam Girdwooda5302182008-07-07 13:35:17 +01003984 * snd_soc_dapm_enable_pin - enable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003985 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01003986 * @pin: pin name
Richard Purdie2b97eab2006-10-06 18:32:18 +02003987 *
Mark Brown74b8f952009-06-06 11:26:15 +01003988 * Enables input/output pin and its parents or children widgets iff there is
Liam Girdwooda5302182008-07-07 13:35:17 +01003989 * a valid audio route and active audio stream.
Charles Keepax11391102014-02-18 15:22:14 +00003990 *
Liam Girdwooda5302182008-07-07 13:35:17 +01003991 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3992 * do any widget power switching.
Richard Purdie2b97eab2006-10-06 18:32:18 +02003993 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003994int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003995{
Charles Keepax11391102014-02-18 15:22:14 +00003996 int ret;
3997
3998 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3999
4000 ret = snd_soc_dapm_set_pin(dapm, pin, 1);
4001
4002 mutex_unlock(&dapm->card->dapm_mutex);
4003
4004 return ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02004005}
Liam Girdwooda5302182008-07-07 13:35:17 +01004006EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
Richard Purdie2b97eab2006-10-06 18:32:18 +02004007
4008/**
Charles Keepax11391102014-02-18 15:22:14 +00004009 * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
4010 * @dapm: DAPM context
4011 * @pin: pin name
4012 *
4013 * Enables input/output pin regardless of any other state. This is
4014 * intended for use with microphone bias supplies used in microphone
4015 * jack detection.
4016 *
4017 * Requires external locking.
4018 *
4019 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4020 * do any widget power switching.
4021 */
4022int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4023 const char *pin)
4024{
4025 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4026
4027 if (!w) {
4028 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4029 return -EINVAL;
4030 }
4031
4032 dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
Lars-Peter Clausen92a99ea2014-10-25 17:42:03 +02004033 if (!w->connected) {
4034 /*
4035 * w->force does not affect the number of input or output paths,
4036 * so we only have to recheck if w->connected is changed
4037 */
4038 dapm_widget_invalidate_input_paths(w);
4039 dapm_widget_invalidate_output_paths(w);
4040 w->connected = 1;
4041 }
Charles Keepax11391102014-02-18 15:22:14 +00004042 w->force = 1;
4043 dapm_mark_dirty(w, "force enable");
4044
4045 return 0;
4046}
4047EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
4048
4049/**
Mark Brownda341832010-03-15 19:23:37 +00004050 * snd_soc_dapm_force_enable_pin - force a pin to be enabled
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004051 * @dapm: DAPM context
Mark Brownda341832010-03-15 19:23:37 +00004052 * @pin: pin name
4053 *
4054 * Enables input/output pin regardless of any other state. This is
4055 * intended for use with microphone bias supplies used in microphone
4056 * jack detection.
4057 *
4058 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4059 * do any widget power switching.
4060 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004061int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
4062 const char *pin)
Mark Brownda341832010-03-15 19:23:37 +00004063{
Charles Keepax11391102014-02-18 15:22:14 +00004064 int ret;
Mark Brownda341832010-03-15 19:23:37 +00004065
Charles Keepax11391102014-02-18 15:22:14 +00004066 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Mark Brownda341832010-03-15 19:23:37 +00004067
Charles Keepax11391102014-02-18 15:22:14 +00004068 ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
Mark Brown0d867332011-04-06 11:38:14 +09004069
Charles Keepax11391102014-02-18 15:22:14 +00004070 mutex_unlock(&dapm->card->dapm_mutex);
4071
4072 return ret;
Mark Brownda341832010-03-15 19:23:37 +00004073}
4074EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
4075
4076/**
Charles Keepax11391102014-02-18 15:22:14 +00004077 * snd_soc_dapm_disable_pin_unlocked - disable pin.
4078 * @dapm: DAPM context
4079 * @pin: pin name
4080 *
4081 * Disables input/output pin and its parents or children widgets.
4082 *
4083 * Requires external locking.
4084 *
4085 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4086 * do any widget power switching.
4087 */
4088int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4089 const char *pin)
4090{
4091 return snd_soc_dapm_set_pin(dapm, pin, 0);
4092}
4093EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
4094
4095/**
Liam Girdwooda5302182008-07-07 13:35:17 +01004096 * snd_soc_dapm_disable_pin - disable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004097 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01004098 * @pin: pin name
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004099 *
Mark Brown74b8f952009-06-06 11:26:15 +01004100 * Disables input/output pin and its parents or children widgets.
Charles Keepax11391102014-02-18 15:22:14 +00004101 *
Liam Girdwooda5302182008-07-07 13:35:17 +01004102 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4103 * do any widget power switching.
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004104 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004105int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
4106 const char *pin)
Liam Girdwooda5302182008-07-07 13:35:17 +01004107{
Charles Keepax11391102014-02-18 15:22:14 +00004108 int ret;
4109
4110 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4111
4112 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4113
4114 mutex_unlock(&dapm->card->dapm_mutex);
4115
4116 return ret;
Liam Girdwooda5302182008-07-07 13:35:17 +01004117}
4118EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
4119
4120/**
Charles Keepax11391102014-02-18 15:22:14 +00004121 * snd_soc_dapm_nc_pin_unlocked - permanently disable pin.
4122 * @dapm: DAPM context
4123 * @pin: pin name
4124 *
4125 * Marks the specified pin as being not connected, disabling it along
4126 * any parent or child widgets. At present this is identical to
4127 * snd_soc_dapm_disable_pin() but in future it will be extended to do
4128 * additional things such as disabling controls which only affect
4129 * paths through the pin.
4130 *
4131 * Requires external locking.
4132 *
4133 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4134 * do any widget power switching.
4135 */
4136int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
4137 const char *pin)
4138{
4139 return snd_soc_dapm_set_pin(dapm, pin, 0);
4140}
4141EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
4142
4143/**
Mark Brown5817b522008-09-24 11:23:11 +01004144 * snd_soc_dapm_nc_pin - permanently disable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004145 * @dapm: DAPM context
Mark Brown5817b522008-09-24 11:23:11 +01004146 * @pin: pin name
4147 *
4148 * Marks the specified pin as being not connected, disabling it along
4149 * any parent or child widgets. At present this is identical to
4150 * snd_soc_dapm_disable_pin() but in future it will be extended to do
4151 * additional things such as disabling controls which only affect
4152 * paths through the pin.
4153 *
4154 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4155 * do any widget power switching.
4156 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004157int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
Mark Brown5817b522008-09-24 11:23:11 +01004158{
Charles Keepax11391102014-02-18 15:22:14 +00004159 int ret;
4160
4161 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4162
4163 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4164
4165 mutex_unlock(&dapm->card->dapm_mutex);
4166
4167 return ret;
Mark Brown5817b522008-09-24 11:23:11 +01004168}
4169EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
4170
4171/**
Liam Girdwooda5302182008-07-07 13:35:17 +01004172 * snd_soc_dapm_get_pin_status - get audio pin status
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004173 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01004174 * @pin: audio signal pin endpoint (or start point)
4175 *
4176 * Get audio pin status - connected or disconnected.
4177 *
4178 * Returns 1 for connected otherwise 0.
4179 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004180int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
4181 const char *pin)
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004182{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004183 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004184
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004185 if (w)
4186 return w->connected;
Stephen Warrena68b38a2011-04-19 15:25:11 -06004187
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004188 return 0;
4189}
Liam Girdwooda5302182008-07-07 13:35:17 +01004190EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02004191
4192/**
Mark Brown1547aba2010-05-07 21:11:40 +01004193 * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004194 * @dapm: DAPM context
Mark Brown1547aba2010-05-07 21:11:40 +01004195 * @pin: audio signal pin endpoint (or start point)
4196 *
4197 * Mark the given endpoint or pin as ignoring suspend. When the
4198 * system is disabled a path between two endpoints flagged as ignoring
4199 * suspend will not be disabled. The path must already be enabled via
4200 * normal means at suspend time, it will not be turned on if it was not
4201 * already enabled.
4202 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004203int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
4204 const char *pin)
Mark Brown1547aba2010-05-07 21:11:40 +01004205{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004206 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
Mark Brown1547aba2010-05-07 21:11:40 +01004207
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004208 if (!w) {
Liam Girdwood30a6a1a2012-11-19 14:39:12 +00004209 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004210 return -EINVAL;
Mark Brown1547aba2010-05-07 21:11:40 +01004211 }
4212
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02004213 w->ignore_suspend = 1;
4214
4215 return 0;
Mark Brown1547aba2010-05-07 21:11:40 +01004216}
4217EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
4218
Lars-Peter Clausencdc45082014-10-20 19:36:33 +02004219/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02004220 * snd_soc_dapm_free - free dapm resources
Peter Ujfalusi728a5222011-08-26 16:33:52 +03004221 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02004222 *
4223 * Free all dapm widgets and resources.
4224 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004225void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02004226{
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02004227 dapm_debugfs_cleanup(dapm);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004228 dapm_free_widgets(dapm);
Jarkko Nikula7be31be82010-12-14 12:18:32 +02004229 list_del(&dapm->list);
Richard Purdie2b97eab2006-10-06 18:32:18 +02004230}
4231EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
4232
Xiang Xiao57996352014-03-02 00:04:02 +08004233static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
Mark Brown51737472009-06-22 13:16:51 +01004234{
Liam Girdwood01005a72012-07-06 16:57:05 +01004235 struct snd_soc_card *card = dapm->card;
Mark Brown51737472009-06-22 13:16:51 +01004236 struct snd_soc_dapm_widget *w;
4237 LIST_HEAD(down_list);
4238 int powerdown = 0;
4239
Liam Girdwood01005a72012-07-06 16:57:05 +01004240 mutex_lock(&card->dapm_mutex);
4241
Jarkko Nikula97c866d2010-12-14 12:18:31 +02004242 list_for_each_entry(w, &dapm->card->widgets, list) {
4243 if (w->dapm != dapm)
4244 continue;
Mark Brown51737472009-06-22 13:16:51 +01004245 if (w->power) {
Mark Brown828a8422011-01-15 13:14:30 +00004246 dapm_seq_insert(w, &down_list, false);
Mark Brownc2caa4d2009-06-26 15:36:56 +01004247 w->power = 0;
Mark Brown51737472009-06-22 13:16:51 +01004248 powerdown = 1;
4249 }
4250 }
4251
4252 /* If there were no widgets to power down we're already in
4253 * standby.
4254 */
4255 if (powerdown) {
Mark Brown7679e422012-02-22 15:52:56 +00004256 if (dapm->bias_level == SND_SOC_BIAS_ON)
4257 snd_soc_dapm_set_bias_level(dapm,
4258 SND_SOC_BIAS_PREPARE);
Lars-Peter Clausen95dd5cd2013-07-29 17:13:56 +02004259 dapm_seq_run(card, &down_list, 0, false);
Mark Brown7679e422012-02-22 15:52:56 +00004260 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
4261 snd_soc_dapm_set_bias_level(dapm,
4262 SND_SOC_BIAS_STANDBY);
Mark Brown51737472009-06-22 13:16:51 +01004263 }
Liam Girdwood01005a72012-07-06 16:57:05 +01004264
4265 mutex_unlock(&card->dapm_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00004266}
Mark Brown51737472009-06-22 13:16:51 +01004267
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00004268/*
4269 * snd_soc_dapm_shutdown - callback for system shutdown
4270 */
4271void snd_soc_dapm_shutdown(struct snd_soc_card *card)
4272{
Xiang Xiao57996352014-03-02 00:04:02 +08004273 struct snd_soc_dapm_context *dapm;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00004274
Xiang Xiao57996352014-03-02 00:04:02 +08004275 list_for_each_entry(dapm, &card->dapm_list, list) {
Xiang Xiao17282ba2014-03-02 00:04:03 +08004276 if (dapm != &card->dapm) {
4277 soc_dapm_shutdown_dapm(dapm);
4278 if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
4279 snd_soc_dapm_set_bias_level(dapm,
4280 SND_SOC_BIAS_OFF);
4281 }
Liam Girdwoodce6120c2010-11-05 15:53:46 +02004282 }
Xiang Xiao17282ba2014-03-02 00:04:03 +08004283
4284 soc_dapm_shutdown_dapm(&card->dapm);
4285 if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
4286 snd_soc_dapm_set_bias_level(&card->dapm,
4287 SND_SOC_BIAS_OFF);
Mark Brown51737472009-06-22 13:16:51 +01004288}
4289
Richard Purdie2b97eab2006-10-06 18:32:18 +02004290/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01004291MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Richard Purdie2b97eab2006-10-06 18:32:18 +02004292MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
4293MODULE_LICENSE("GPL");