blob: 7365fed1ba74802edff6884d7aaef524727919e3 [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
Richard Purdie2b97eab2006-10-06 18:32:18 +020050/* dapm power sequences - make this per codec in the future */
51static int dapm_up_seq[] = {
Mark Brown38357ab2009-06-06 19:03:23 +010052 [snd_soc_dapm_pre] = 0,
53 [snd_soc_dapm_supply] = 1,
Mark Brown62ea8742012-01-21 21:14:48 +000054 [snd_soc_dapm_regulator_supply] = 1,
Ola Liljad7e7eb92012-05-24 15:26:25 +020055 [snd_soc_dapm_clock_supply] = 1,
Mark Brown38357ab2009-06-06 19:03:23 +010056 [snd_soc_dapm_micbias] = 2,
Mark Brownc74184e2012-04-04 22:12:09 +010057 [snd_soc_dapm_dai_link] = 2,
Mark Brown888df392012-02-16 19:37:51 -080058 [snd_soc_dapm_dai] = 3,
Mark Brown010ff262009-08-17 17:39:22 +010059 [snd_soc_dapm_aif_in] = 3,
60 [snd_soc_dapm_aif_out] = 3,
61 [snd_soc_dapm_mic] = 4,
62 [snd_soc_dapm_mux] = 5,
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +000063 [snd_soc_dapm_virt_mux] = 5,
Mark Brown010ff262009-08-17 17:39:22 +010064 [snd_soc_dapm_value_mux] = 5,
65 [snd_soc_dapm_dac] = 6,
66 [snd_soc_dapm_mixer] = 7,
67 [snd_soc_dapm_mixer_named_ctl] = 7,
68 [snd_soc_dapm_pga] = 8,
69 [snd_soc_dapm_adc] = 9,
Olaya, Margaritad88429a2010-12-10 21:11:44 -060070 [snd_soc_dapm_out_drv] = 10,
Mark Brown010ff262009-08-17 17:39:22 +010071 [snd_soc_dapm_hp] = 10,
72 [snd_soc_dapm_spk] = 10,
Mark Brown7e1f7c82012-04-12 17:29:36 +010073 [snd_soc_dapm_line] = 10,
Mark Brown010ff262009-08-17 17:39:22 +010074 [snd_soc_dapm_post] = 11,
Richard Purdie2b97eab2006-10-06 18:32:18 +020075};
Ian Moltonca9c1aa2009-01-06 20:11:51 +000076
Richard Purdie2b97eab2006-10-06 18:32:18 +020077static int dapm_down_seq[] = {
Mark Brown38357ab2009-06-06 19:03:23 +010078 [snd_soc_dapm_pre] = 0,
79 [snd_soc_dapm_adc] = 1,
80 [snd_soc_dapm_hp] = 2,
Mark Brown1ca04062009-08-17 16:26:59 +010081 [snd_soc_dapm_spk] = 2,
Mark Brown7e1f7c82012-04-12 17:29:36 +010082 [snd_soc_dapm_line] = 2,
Olaya, Margaritad88429a2010-12-10 21:11:44 -060083 [snd_soc_dapm_out_drv] = 2,
Mark Brown38357ab2009-06-06 19:03:23 +010084 [snd_soc_dapm_pga] = 4,
85 [snd_soc_dapm_mixer_named_ctl] = 5,
Mark Browne3d4dab2009-06-07 13:08:45 +010086 [snd_soc_dapm_mixer] = 5,
87 [snd_soc_dapm_dac] = 6,
88 [snd_soc_dapm_mic] = 7,
89 [snd_soc_dapm_micbias] = 8,
90 [snd_soc_dapm_mux] = 9,
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +000091 [snd_soc_dapm_virt_mux] = 9,
Mark Browne3d4dab2009-06-07 13:08:45 +010092 [snd_soc_dapm_value_mux] = 9,
Mark Brown010ff262009-08-17 17:39:22 +010093 [snd_soc_dapm_aif_in] = 10,
94 [snd_soc_dapm_aif_out] = 10,
Mark Brown888df392012-02-16 19:37:51 -080095 [snd_soc_dapm_dai] = 10,
Mark Brownc74184e2012-04-04 22:12:09 +010096 [snd_soc_dapm_dai_link] = 11,
Ola Liljad7e7eb92012-05-24 15:26:25 +020097 [snd_soc_dapm_clock_supply] = 12,
Mark Brownc74184e2012-04-04 22:12:09 +010098 [snd_soc_dapm_regulator_supply] = 12,
99 [snd_soc_dapm_supply] = 12,
100 [snd_soc_dapm_post] = 13,
Richard Purdie2b97eab2006-10-06 18:32:18 +0200101};
102
Troy Kisky12ef1932008-10-13 17:42:14 -0700103static void pop_wait(u32 pop_time)
Mark Brown15e4c722008-07-02 11:51:20 +0100104{
105 if (pop_time)
106 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
107}
108
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200109static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
Mark Brown15e4c722008-07-02 11:51:20 +0100110{
111 va_list args;
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200112 char *buf;
113
114 if (!pop_time)
115 return;
116
117 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
118 if (buf == NULL)
119 return;
Mark Brown15e4c722008-07-02 11:51:20 +0100120
121 va_start(args, fmt);
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200122 vsnprintf(buf, PAGE_SIZE, fmt, args);
Takashi Iwai9d01df02010-12-22 14:08:40 +0100123 dev_info(dev, "%s", buf);
Mark Brown15e4c722008-07-02 11:51:20 +0100124 va_end(args);
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200125
126 kfree(buf);
Mark Brown15e4c722008-07-02 11:51:20 +0100127}
128
Mark Browndb432b42011-10-03 21:06:40 +0100129static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
130{
131 return !list_empty(&w->dirty);
132}
133
Mark Brown25c77c52011-10-08 13:36:03 +0100134void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
Mark Browndb432b42011-10-03 21:06:40 +0100135{
Mark Brown75c1f892011-10-04 22:28:08 +0100136 if (!dapm_dirty_widget(w)) {
137 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
138 w->name, reason);
Mark Browndb432b42011-10-03 21:06:40 +0100139 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
Mark Brown75c1f892011-10-04 22:28:08 +0100140 }
Mark Browndb432b42011-10-03 21:06:40 +0100141}
Mark Brown25c77c52011-10-08 13:36:03 +0100142EXPORT_SYMBOL_GPL(dapm_mark_dirty);
Mark Browndb432b42011-10-03 21:06:40 +0100143
Richard Purdie2b97eab2006-10-06 18:32:18 +0200144/* create a new dapm widget */
Takashi Iwai88cb4292007-02-05 14:56:20 +0100145static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
Richard Purdie2b97eab2006-10-06 18:32:18 +0200146 const struct snd_soc_dapm_widget *_widget)
147{
Takashi Iwai88cb4292007-02-05 14:56:20 +0100148 return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200149}
150
Liam Girdwood48056082011-07-20 12:23:33 +0100151/* get snd_card from DAPM context */
152static inline struct snd_card *dapm_get_snd_card(
153 struct snd_soc_dapm_context *dapm)
154{
155 if (dapm->codec)
156 return dapm->codec->card->snd_card;
157 else if (dapm->platform)
158 return dapm->platform->card->snd_card;
159 else
160 BUG();
161
162 /* unreachable */
163 return NULL;
164}
165
166/* get soc_card from DAPM context */
167static inline struct snd_soc_card *dapm_get_soc_card(
168 struct snd_soc_dapm_context *dapm)
169{
170 if (dapm->codec)
171 return dapm->codec->card;
172 else if (dapm->platform)
173 return dapm->platform->card;
174 else
175 BUG();
176
177 /* unreachable */
178 return NULL;
179}
180
Liam Girdwood6c120e12012-02-15 15:15:34 +0000181static void dapm_reset(struct snd_soc_card *card)
182{
183 struct snd_soc_dapm_widget *w;
184
185 memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
186
187 list_for_each_entry(w, &card->widgets, list) {
188 w->power_checked = false;
189 w->inputs = -1;
190 w->outputs = -1;
191 }
192}
193
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100194static int soc_widget_read(struct snd_soc_dapm_widget *w, int reg)
195{
196 if (w->codec)
197 return snd_soc_read(w->codec, reg);
Liam Girdwoodb7950642011-07-04 22:10:52 +0100198 else if (w->platform)
199 return snd_soc_platform_read(w->platform, reg);
200
201 dev_err(w->dapm->dev, "no valid widget read method\n");
202 return -1;
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100203}
204
205static int soc_widget_write(struct snd_soc_dapm_widget *w, int reg, int val)
206{
207 if (w->codec)
208 return snd_soc_write(w->codec, reg, val);
Liam Girdwoodb7950642011-07-04 22:10:52 +0100209 else if (w->platform)
210 return snd_soc_platform_write(w->platform, reg, val);
211
212 dev_err(w->dapm->dev, "no valid widget write method\n");
213 return -1;
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100214}
215
Liam Girdwood49575fb52012-03-06 18:16:19 +0000216static inline void soc_widget_lock(struct snd_soc_dapm_widget *w)
217{
Mark Browne06ab3b2012-03-06 23:58:22 +0000218 if (w->codec && !w->codec->using_regmap)
Liam Girdwood49575fb52012-03-06 18:16:19 +0000219 mutex_lock(&w->codec->mutex);
220 else if (w->platform)
221 mutex_lock(&w->platform->mutex);
222}
223
224static inline void soc_widget_unlock(struct snd_soc_dapm_widget *w)
225{
Mark Browne06ab3b2012-03-06 23:58:22 +0000226 if (w->codec && !w->codec->using_regmap)
Liam Girdwood49575fb52012-03-06 18:16:19 +0000227 mutex_unlock(&w->codec->mutex);
228 else if (w->platform)
229 mutex_unlock(&w->platform->mutex);
230}
231
232static int soc_widget_update_bits_locked(struct snd_soc_dapm_widget *w,
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100233 unsigned short reg, unsigned int mask, unsigned int value)
234{
Mark Brown8a713da2011-12-03 12:33:55 +0000235 bool change;
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100236 unsigned int old, new;
237 int ret;
238
Mark Brown8a713da2011-12-03 12:33:55 +0000239 if (w->codec && w->codec->using_regmap) {
240 ret = regmap_update_bits_check(w->codec->control_data,
241 reg, mask, value, &change);
242 if (ret != 0)
243 return ret;
244 } else {
Liam Girdwood49575fb52012-03-06 18:16:19 +0000245 soc_widget_lock(w);
Mark Brown8a713da2011-12-03 12:33:55 +0000246 ret = soc_widget_read(w, reg);
Liam Girdwood49575fb52012-03-06 18:16:19 +0000247 if (ret < 0) {
248 soc_widget_unlock(w);
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100249 return ret;
Liam Girdwood49575fb52012-03-06 18:16:19 +0000250 }
Mark Brown8a713da2011-12-03 12:33:55 +0000251
252 old = ret;
253 new = (old & ~mask) | (value & mask);
254 change = old != new;
255 if (change) {
256 ret = soc_widget_write(w, reg, new);
Liam Girdwood49575fb52012-03-06 18:16:19 +0000257 if (ret < 0) {
258 soc_widget_unlock(w);
Mark Brown8a713da2011-12-03 12:33:55 +0000259 return ret;
Liam Girdwood49575fb52012-03-06 18:16:19 +0000260 }
Mark Brown8a713da2011-12-03 12:33:55 +0000261 }
Liam Girdwood49575fb52012-03-06 18:16:19 +0000262 soc_widget_unlock(w);
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100263 }
264
265 return change;
266}
267
Mark Brown452c5ea2009-05-17 21:41:23 +0100268/**
269 * snd_soc_dapm_set_bias_level - set the bias level for the system
Mark Browned5a4c42011-02-18 11:12:42 -0800270 * @dapm: DAPM context
Mark Brown452c5ea2009-05-17 21:41:23 +0100271 * @level: level to configure
272 *
273 * Configure the bias (power) levels for the SoC audio device.
274 *
275 * Returns 0 for success else error.
276 */
Mark Browned5a4c42011-02-18 11:12:42 -0800277static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200278 enum snd_soc_bias_level level)
Mark Brown452c5ea2009-05-17 21:41:23 +0100279{
Mark Browned5a4c42011-02-18 11:12:42 -0800280 struct snd_soc_card *card = dapm->card;
Mark Brown452c5ea2009-05-17 21:41:23 +0100281 int ret = 0;
282
Mark Brown84e90932010-11-04 00:07:02 -0400283 trace_snd_soc_bias_level_start(card, level);
284
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000285 if (card && card->set_bias_level)
Mark Brownd4c60052011-06-06 19:13:23 +0100286 ret = card->set_bias_level(card, dapm, level);
Mark Brown171ec6b2011-06-06 18:15:19 +0100287 if (ret != 0)
288 goto out;
Mark Brown452c5ea2009-05-17 21:41:23 +0100289
Mark Browncc4c6702011-06-06 19:03:34 +0100290 if (dapm->codec) {
291 if (dapm->codec->driver->set_bias_level)
292 ret = dapm->codec->driver->set_bias_level(dapm->codec,
293 level);
294 else
295 dapm->bias_level = level;
296 }
Mark Brown171ec6b2011-06-06 18:15:19 +0100297 if (ret != 0)
298 goto out;
299
300 if (card && card->set_bias_level_post)
Mark Brownd4c60052011-06-06 19:13:23 +0100301 ret = card->set_bias_level_post(card, dapm, level);
Mark Brown171ec6b2011-06-06 18:15:19 +0100302out:
Mark Brown84e90932010-11-04 00:07:02 -0400303 trace_snd_soc_bias_level_done(card, level);
304
Mark Brown452c5ea2009-05-17 21:41:23 +0100305 return ret;
306}
307
Richard Purdie2b97eab2006-10-06 18:32:18 +0200308/* set up initial codec paths */
309static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
310 struct snd_soc_dapm_path *p, int i)
311{
312 switch (w->id) {
313 case snd_soc_dapm_switch:
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000314 case snd_soc_dapm_mixer:
315 case snd_soc_dapm_mixer_named_ctl: {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200316 int val;
Jon Smirl4eaa9812008-07-29 11:42:26 +0100317 struct soc_mixer_control *mc = (struct soc_mixer_control *)
Stephen Warren82cfecd2011-04-28 17:37:58 -0600318 w->kcontrol_news[i].private_value;
Jon Smirl815ecf8d2008-07-29 10:22:24 -0400319 unsigned int reg = mc->reg;
320 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +0100321 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -0400322 unsigned int mask = (1 << fls(max)) - 1;
323 unsigned int invert = mc->invert;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200324
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100325 val = soc_widget_read(w, reg);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200326 val = (val >> shift) & mask;
327
328 if ((invert && !val) || (!invert && val))
329 p->connect = 1;
330 else
331 p->connect = 0;
332 }
333 break;
334 case snd_soc_dapm_mux: {
Stephen Warren82cfecd2011-04-28 17:37:58 -0600335 struct soc_enum *e = (struct soc_enum *)
336 w->kcontrol_news[i].private_value;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200337 int val, item, bitmask;
338
Jon Smirlf8ba0b72008-07-29 11:42:27 +0100339 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Mark Brown88d96082011-06-06 16:16:34 +0100340 ;
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100341 val = soc_widget_read(w, e->reg);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200342 item = (val >> e->shift_l) & (bitmask - 1);
343
344 p->connect = 0;
Jon Smirlf8ba0b72008-07-29 11:42:27 +0100345 for (i = 0; i < e->max; i++) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200346 if (!(strcmp(p->name, e->texts[i])) && item == i)
347 p->connect = 1;
348 }
349 }
350 break;
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +0000351 case snd_soc_dapm_virt_mux: {
Stephen Warren82cfecd2011-04-28 17:37:58 -0600352 struct soc_enum *e = (struct soc_enum *)
353 w->kcontrol_news[i].private_value;
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +0000354
355 p->connect = 0;
356 /* since a virtual mux has no backing registers to
357 * decide which path to connect, it will try to match
358 * with the first enumeration. This is to ensure
359 * that the default mux choice (the first) will be
360 * correctly powered up during initialization.
361 */
362 if (!strcmp(p->name, e->texts[0]))
363 p->connect = 1;
364 }
365 break;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +0200366 case snd_soc_dapm_value_mux: {
Peter Ujfalusi74155552009-01-08 13:34:29 +0200367 struct soc_enum *e = (struct soc_enum *)
Stephen Warren82cfecd2011-04-28 17:37:58 -0600368 w->kcontrol_news[i].private_value;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +0200369 int val, item;
370
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100371 val = soc_widget_read(w, e->reg);
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +0200372 val = (val >> e->shift_l) & e->mask;
373 for (item = 0; item < e->max; item++) {
374 if (val == e->values[item])
375 break;
376 }
377
378 p->connect = 0;
379 for (i = 0; i < e->max; i++) {
380 if (!(strcmp(p->name, e->texts[i])) && item == i)
381 p->connect = 1;
382 }
383 }
384 break;
Mark Brown56563102011-10-03 22:41:09 +0100385 /* does not affect routing - always connected */
Richard Purdie2b97eab2006-10-06 18:32:18 +0200386 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -0600387 case snd_soc_dapm_out_drv:
Richard Purdie2b97eab2006-10-06 18:32:18 +0200388 case snd_soc_dapm_output:
389 case snd_soc_dapm_adc:
390 case snd_soc_dapm_input:
Mark Brown1ab97c82011-11-27 16:21:51 +0000391 case snd_soc_dapm_siggen:
Richard Purdie2b97eab2006-10-06 18:32:18 +0200392 case snd_soc_dapm_dac:
393 case snd_soc_dapm_micbias:
394 case snd_soc_dapm_vmid:
Mark Brown246d0a12009-04-22 18:24:55 +0100395 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +0000396 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +0200397 case snd_soc_dapm_clock_supply:
Mark Brown010ff262009-08-17 17:39:22 +0100398 case snd_soc_dapm_aif_in:
399 case snd_soc_dapm_aif_out:
Mark Brown888df392012-02-16 19:37:51 -0800400 case snd_soc_dapm_dai:
Richard Purdie2b97eab2006-10-06 18:32:18 +0200401 case snd_soc_dapm_hp:
402 case snd_soc_dapm_mic:
403 case snd_soc_dapm_spk:
404 case snd_soc_dapm_line:
Mark Brownc74184e2012-04-04 22:12:09 +0100405 case snd_soc_dapm_dai_link:
Mark Brown56563102011-10-03 22:41:09 +0100406 p->connect = 1;
407 break;
408 /* does affect routing - dynamically connected */
Richard Purdie2b97eab2006-10-06 18:32:18 +0200409 case snd_soc_dapm_pre:
410 case snd_soc_dapm_post:
411 p->connect = 0;
412 break;
413 }
414}
415
Mark Brown74b8f952009-06-06 11:26:15 +0100416/* connect mux widget to its interconnecting audio paths */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200417static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
Richard Purdie2b97eab2006-10-06 18:32:18 +0200418 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
419 struct snd_soc_dapm_path *path, const char *control_name,
420 const struct snd_kcontrol_new *kcontrol)
421{
422 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
423 int i;
424
Jon Smirlf8ba0b72008-07-29 11:42:27 +0100425 for (i = 0; i < e->max; i++) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200426 if (!(strcmp(control_name, e->texts[i]))) {
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +0200427 list_add(&path->list, &dapm->card->paths);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200428 list_add(&path->list_sink, &dest->sources);
429 list_add(&path->list_source, &src->sinks);
430 path->name = (char*)e->texts[i];
431 dapm_set_path_status(dest, path, 0);
432 return 0;
433 }
434 }
435
436 return -ENODEV;
437}
438
Mark Brown74b8f952009-06-06 11:26:15 +0100439/* connect mixer widget to its interconnecting audio paths */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200440static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
Richard Purdie2b97eab2006-10-06 18:32:18 +0200441 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
442 struct snd_soc_dapm_path *path, const char *control_name)
443{
444 int i;
445
446 /* search for mixer kcontrol */
447 for (i = 0; i < dest->num_kcontrols; i++) {
Stephen Warren82cfecd2011-04-28 17:37:58 -0600448 if (!strcmp(control_name, dest->kcontrol_news[i].name)) {
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +0200449 list_add(&path->list, &dapm->card->paths);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200450 list_add(&path->list_sink, &dest->sources);
451 list_add(&path->list_source, &src->sinks);
Stephen Warren82cfecd2011-04-28 17:37:58 -0600452 path->name = dest->kcontrol_news[i].name;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200453 dapm_set_path_status(dest, path, i);
454 return 0;
455 }
456 }
457 return -ENODEV;
458}
459
Stephen Warrenaf468002011-04-28 17:38:01 -0600460static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
Stephen Warren1007da02011-05-26 09:57:33 -0600461 struct snd_soc_dapm_widget *kcontrolw,
Stephen Warrenaf468002011-04-28 17:38:01 -0600462 const struct snd_kcontrol_new *kcontrol_new,
463 struct snd_kcontrol **kcontrol)
464{
465 struct snd_soc_dapm_widget *w;
466 int i;
467
468 *kcontrol = NULL;
469
470 list_for_each_entry(w, &dapm->card->widgets, list) {
Stephen Warren1007da02011-05-26 09:57:33 -0600471 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
472 continue;
Stephen Warrenaf468002011-04-28 17:38:01 -0600473 for (i = 0; i < w->num_kcontrols; i++) {
474 if (&w->kcontrol_news[i] == kcontrol_new) {
475 if (w->kcontrols)
476 *kcontrol = w->kcontrols[i];
477 return 1;
478 }
479 }
480 }
481
482 return 0;
483}
484
Richard Purdie2b97eab2006-10-06 18:32:18 +0200485/* create new dapm mixer control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200486static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200487{
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200488 struct snd_soc_dapm_context *dapm = w->dapm;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200489 int i, ret = 0;
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000490 size_t name_len, prefix_len;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200491 struct snd_soc_dapm_path *path;
Mark Brown12ea2c72011-03-02 18:17:32 +0000492 struct snd_card *card = dapm->card->snd_card;
Mark Brownefb7ac32011-03-08 17:23:24 +0000493 const char *prefix;
Stephen Warrenfafd2172011-04-28 17:38:00 -0600494 struct snd_soc_dapm_widget_list *wlist;
495 size_t wlistsize;
Mark Brownefb7ac32011-03-08 17:23:24 +0000496
497 if (dapm->codec)
498 prefix = dapm->codec->name_prefix;
499 else
500 prefix = NULL;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200501
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000502 if (prefix)
503 prefix_len = strlen(prefix) + 1;
504 else
505 prefix_len = 0;
506
Richard Purdie2b97eab2006-10-06 18:32:18 +0200507 /* add kcontrol */
508 for (i = 0; i < w->num_kcontrols; i++) {
509
510 /* match name */
511 list_for_each_entry(path, &w->sources, list_sink) {
512
513 /* mixer/mux paths name must match control name */
Stephen Warren82cfecd2011-04-28 17:37:58 -0600514 if (path->name != (char *)w->kcontrol_news[i].name)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200515 continue;
516
Lars-Peter Clausen82cd8762011-08-15 20:15:21 +0200517 if (w->kcontrols[i]) {
518 path->kcontrol = w->kcontrols[i];
519 continue;
520 }
521
Stephen Warrenfafd2172011-04-28 17:38:00 -0600522 wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
523 sizeof(struct snd_soc_dapm_widget *),
524 wlist = kzalloc(wlistsize, GFP_KERNEL);
525 if (wlist == NULL) {
526 dev_err(dapm->dev,
527 "asoc: can't allocate widget list for %s\n",
528 w->name);
529 return -ENOMEM;
530 }
531 wlist->num_widgets = 1;
532 wlist->widgets[0] = w;
533
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000534 /* add dapm control with long name.
535 * for dapm_mixer this is the concatenation of the
536 * mixer and kcontrol name.
537 * for dapm_mixer_named_ctl this is simply the
538 * kcontrol name.
539 */
Stephen Warren82cfecd2011-04-28 17:37:58 -0600540 name_len = strlen(w->kcontrol_news[i].name) + 1;
Mark Brown07495f32009-03-05 17:06:23 +0000541 if (w->id != snd_soc_dapm_mixer_named_ctl)
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000542 name_len += 1 + strlen(w->name);
543
Mark Brown219b93f2008-10-28 13:02:31 +0000544 path->long_name = kmalloc(name_len, GFP_KERNEL);
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000545
Stephen Warrenfafd2172011-04-28 17:38:00 -0600546 if (path->long_name == NULL) {
547 kfree(wlist);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200548 return -ENOMEM;
Stephen Warrenfafd2172011-04-28 17:38:00 -0600549 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200550
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000551 switch (w->id) {
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000552 default:
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000553 /* The control will get a prefix from
554 * the control creation process but
555 * we're also using the same prefix
556 * for widgets so cut the prefix off
557 * the front of the widget name.
558 */
Mark Brown888df392012-02-16 19:37:51 -0800559 snprintf((char *)path->long_name, name_len,
560 "%s %s", w->name + prefix_len,
Stephen Warren82cfecd2011-04-28 17:37:58 -0600561 w->kcontrol_news[i].name);
Mark Brown07495f32009-03-05 17:06:23 +0000562 break;
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000563 case snd_soc_dapm_mixer_named_ctl:
Mark Brown888df392012-02-16 19:37:51 -0800564 snprintf((char *)path->long_name, name_len,
565 "%s", w->kcontrol_news[i].name);
Mark Brown07495f32009-03-05 17:06:23 +0000566 break;
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000567 }
568
Mark Brown888df392012-02-16 19:37:51 -0800569 ((char *)path->long_name)[name_len - 1] = '\0';
Mark Brown219b93f2008-10-28 13:02:31 +0000570
Stephen Warrenfafd2172011-04-28 17:38:00 -0600571 path->kcontrol = snd_soc_cnew(&w->kcontrol_news[i],
572 wlist, path->long_name,
573 prefix);
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200574 ret = snd_ctl_add(card, path->kcontrol);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200575 if (ret < 0) {
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +0200576 dev_err(dapm->dev,
577 "asoc: failed to add dapm kcontrol %s: %d\n",
578 path->long_name, ret);
Stephen Warrenfafd2172011-04-28 17:38:00 -0600579 kfree(wlist);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200580 kfree(path->long_name);
581 path->long_name = NULL;
582 return ret;
583 }
Stephen Warrenfad59882011-04-28 17:37:59 -0600584 w->kcontrols[i] = path->kcontrol;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200585 }
586 }
587 return ret;
588}
589
590/* create new dapm mux control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200591static int dapm_new_mux(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200592{
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200593 struct snd_soc_dapm_context *dapm = w->dapm;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200594 struct snd_soc_dapm_path *path = NULL;
595 struct snd_kcontrol *kcontrol;
Mark Brown12ea2c72011-03-02 18:17:32 +0000596 struct snd_card *card = dapm->card->snd_card;
Mark Brownefb7ac32011-03-08 17:23:24 +0000597 const char *prefix;
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000598 size_t prefix_len;
Stephen Warrenaf468002011-04-28 17:38:01 -0600599 int ret;
Stephen Warrenfafd2172011-04-28 17:38:00 -0600600 struct snd_soc_dapm_widget_list *wlist;
Stephen Warrenaf468002011-04-28 17:38:01 -0600601 int shared, wlistentries;
Stephen Warrenfafd2172011-04-28 17:38:00 -0600602 size_t wlistsize;
Mark Brown888df392012-02-16 19:37:51 -0800603 const char *name;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200604
Stephen Warrenaf468002011-04-28 17:38:01 -0600605 if (w->num_kcontrols != 1) {
606 dev_err(dapm->dev,
607 "asoc: mux %s has incorrect number of controls\n",
608 w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200609 return -EINVAL;
610 }
611
Stephen Warren1007da02011-05-26 09:57:33 -0600612 shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[0],
Stephen Warrenaf468002011-04-28 17:38:01 -0600613 &kcontrol);
614 if (kcontrol) {
615 wlist = kcontrol->private_data;
616 wlistentries = wlist->num_widgets + 1;
617 } else {
618 wlist = NULL;
619 wlistentries = 1;
620 }
Stephen Warrenfafd2172011-04-28 17:38:00 -0600621 wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
Stephen Warrenaf468002011-04-28 17:38:01 -0600622 wlistentries * sizeof(struct snd_soc_dapm_widget *),
623 wlist = krealloc(wlist, wlistsize, GFP_KERNEL);
Stephen Warrenfafd2172011-04-28 17:38:00 -0600624 if (wlist == NULL) {
625 dev_err(dapm->dev,
626 "asoc: can't allocate widget list for %s\n", w->name);
627 return -ENOMEM;
628 }
Stephen Warrenaf468002011-04-28 17:38:01 -0600629 wlist->num_widgets = wlistentries;
630 wlist->widgets[wlistentries - 1] = w;
Stephen Warrenfafd2172011-04-28 17:38:00 -0600631
Stephen Warrenaf468002011-04-28 17:38:01 -0600632 if (!kcontrol) {
633 if (dapm->codec)
634 prefix = dapm->codec->name_prefix;
635 else
636 prefix = NULL;
Mark Brownefb7ac32011-03-08 17:23:24 +0000637
Stephen Warrenaf468002011-04-28 17:38:01 -0600638 if (shared) {
639 name = w->kcontrol_news[0].name;
640 prefix_len = 0;
641 } else {
642 name = w->name;
643 if (prefix)
644 prefix_len = strlen(prefix) + 1;
645 else
646 prefix_len = 0;
647 }
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000648
Stephen Warrenaf468002011-04-28 17:38:01 -0600649 /*
650 * The control will get a prefix from the control creation
651 * process but we're also using the same prefix for widgets so
652 * cut the prefix off the front of the widget name.
653 */
654 kcontrol = snd_soc_cnew(&w->kcontrol_news[0], wlist,
655 name + prefix_len, prefix);
656 ret = snd_ctl_add(card, kcontrol);
657 if (ret < 0) {
Mark Brown53daf202011-09-05 10:51:05 -0700658 dev_err(dapm->dev, "failed to add kcontrol %s: %d\n",
659 w->name, ret);
Stephen Warrenaf468002011-04-28 17:38:01 -0600660 kfree(wlist);
661 return ret;
662 }
663 }
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200664
Stephen Warrenaf468002011-04-28 17:38:01 -0600665 kcontrol->private_data = wlist;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200666
Stephen Warrenfad59882011-04-28 17:37:59 -0600667 w->kcontrols[0] = kcontrol;
668
Richard Purdie2b97eab2006-10-06 18:32:18 +0200669 list_for_each_entry(path, &w->sources, list_sink)
670 path->kcontrol = kcontrol;
671
Stephen Warrenaf468002011-04-28 17:38:01 -0600672 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200673}
674
675/* create new dapm volume control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200676static int dapm_new_pga(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200677{
Mark Browna6c65732010-03-03 17:45:21 +0000678 if (w->num_kcontrols)
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +0200679 dev_err(w->dapm->dev,
680 "asoc: PGA controls not supported: '%s'\n", w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200681
Mark Browna6c65732010-03-03 17:45:21 +0000682 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200683}
684
685/* reset 'walked' bit for each dapm path */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200686static inline void dapm_clear_walk(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200687{
688 struct snd_soc_dapm_path *p;
689
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +0200690 list_for_each_entry(p, &dapm->card->paths, list)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200691 p->walked = 0;
692}
693
Mark Brown99497882010-05-07 20:24:05 +0100694/* We implement power down on suspend by checking the power state of
695 * the ALSA card - when we are suspending the ALSA state for the card
696 * is set to D3.
697 */
698static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
699{
Mark Brown12ea2c72011-03-02 18:17:32 +0000700 int level = snd_power_get_state(widget->dapm->card->snd_card);
Mark Brown99497882010-05-07 20:24:05 +0100701
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000702 switch (level) {
Mark Brown99497882010-05-07 20:24:05 +0100703 case SNDRV_CTL_POWER_D3hot:
704 case SNDRV_CTL_POWER_D3cold:
Mark Brown1547aba2010-05-07 21:11:40 +0100705 if (widget->ignore_suspend)
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +0200706 dev_dbg(widget->dapm->dev, "%s ignoring suspend\n",
707 widget->name);
Mark Brown1547aba2010-05-07 21:11:40 +0100708 return widget->ignore_suspend;
Mark Brown99497882010-05-07 20:24:05 +0100709 default:
710 return 1;
711 }
712}
713
Liam Girdwoodec2e3032012-04-18 11:41:11 +0100714/* add widget to list if it's not already in the list */
715static int dapm_list_add_widget(struct snd_soc_dapm_widget_list **list,
716 struct snd_soc_dapm_widget *w)
717{
718 struct snd_soc_dapm_widget_list *wlist;
719 int wlistsize, wlistentries, i;
720
721 if (*list == NULL)
722 return -EINVAL;
723
724 wlist = *list;
725
726 /* is this widget already in the list */
727 for (i = 0; i < wlist->num_widgets; i++) {
728 if (wlist->widgets[i] == w)
729 return 0;
730 }
731
732 /* allocate some new space */
733 wlistentries = wlist->num_widgets + 1;
734 wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
735 wlistentries * sizeof(struct snd_soc_dapm_widget *);
736 *list = krealloc(wlist, wlistsize, GFP_KERNEL);
737 if (*list == NULL) {
738 dev_err(w->dapm->dev, "can't allocate widget list for %s\n",
739 w->name);
740 return -ENOMEM;
741 }
742 wlist = *list;
743
744 /* insert the widget */
745 dev_dbg(w->dapm->dev, "added %s in widget list pos %d\n",
746 w->name, wlist->num_widgets);
747
748 wlist->widgets[wlist->num_widgets] = w;
749 wlist->num_widgets++;
750 return 1;
751}
752
Richard Purdie2b97eab2006-10-06 18:32:18 +0200753/*
754 * Recursively check for a completed path to an active or physically connected
755 * output widget. Returns number of complete paths.
756 */
Liam Girdwoodec2e3032012-04-18 11:41:11 +0100757static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
758 struct snd_soc_dapm_widget_list **list)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200759{
760 struct snd_soc_dapm_path *path;
761 int con = 0;
762
Mark Brown024dc072011-10-09 11:52:05 +0100763 if (widget->outputs >= 0)
764 return widget->outputs;
765
Mark Brownde02d072011-09-20 21:43:24 +0100766 DAPM_UPDATE_STAT(widget, path_checks);
767
Mark Brown62ea8742012-01-21 21:14:48 +0000768 switch (widget->id) {
769 case snd_soc_dapm_supply:
770 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +0200771 case snd_soc_dapm_clock_supply:
Mark Brown246d0a12009-04-22 18:24:55 +0100772 return 0;
Mark Brown62ea8742012-01-21 21:14:48 +0000773 default:
774 break;
775 }
Mark Brown246d0a12009-04-22 18:24:55 +0100776
Mark Brown010ff262009-08-17 17:39:22 +0100777 switch (widget->id) {
778 case snd_soc_dapm_adc:
779 case snd_soc_dapm_aif_out:
Mark Brown888df392012-02-16 19:37:51 -0800780 case snd_soc_dapm_dai:
Mark Brown024dc072011-10-09 11:52:05 +0100781 if (widget->active) {
782 widget->outputs = snd_soc_dapm_suspend_check(widget);
783 return widget->outputs;
784 }
Mark Brown010ff262009-08-17 17:39:22 +0100785 default:
786 break;
787 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200788
789 if (widget->connected) {
790 /* connected pin ? */
Mark Brown024dc072011-10-09 11:52:05 +0100791 if (widget->id == snd_soc_dapm_output && !widget->ext) {
792 widget->outputs = snd_soc_dapm_suspend_check(widget);
793 return widget->outputs;
794 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200795
796 /* connected jack or spk ? */
Mark Brown024dc072011-10-09 11:52:05 +0100797 if (widget->id == snd_soc_dapm_hp ||
798 widget->id == snd_soc_dapm_spk ||
799 (widget->id == snd_soc_dapm_line &&
800 !list_empty(&widget->sources))) {
801 widget->outputs = snd_soc_dapm_suspend_check(widget);
802 return widget->outputs;
803 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200804 }
805
806 list_for_each_entry(path, &widget->sinks, list_source) {
Mark Browne56235e2011-09-21 18:19:14 +0100807 DAPM_UPDATE_STAT(widget, neighbour_checks);
808
Mark Brownbf3a9e12011-06-13 16:42:29 +0100809 if (path->weak)
810 continue;
811
Richard Purdie2b97eab2006-10-06 18:32:18 +0200812 if (path->walked)
813 continue;
814
Liam Girdwoodec2e3032012-04-18 11:41:11 +0100815 trace_snd_soc_dapm_output_path(widget, path);
816
Richard Purdie2b97eab2006-10-06 18:32:18 +0200817 if (path->sink && path->connect) {
818 path->walked = 1;
Liam Girdwoodec2e3032012-04-18 11:41:11 +0100819
820 /* do we need to add this widget to the list ? */
821 if (list) {
822 int err;
823 err = dapm_list_add_widget(list, path->sink);
824 if (err < 0) {
825 dev_err(widget->dapm->dev, "could not add widget %s\n",
826 widget->name);
827 return con;
828 }
829 }
830
831 con += is_connected_output_ep(path->sink, list);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200832 }
833 }
834
Mark Brown024dc072011-10-09 11:52:05 +0100835 widget->outputs = con;
836
Richard Purdie2b97eab2006-10-06 18:32:18 +0200837 return con;
838}
839
840/*
841 * Recursively check for a completed path to an active or physically connected
842 * input widget. Returns number of complete paths.
843 */
Liam Girdwoodec2e3032012-04-18 11:41:11 +0100844static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
845 struct snd_soc_dapm_widget_list **list)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200846{
847 struct snd_soc_dapm_path *path;
848 int con = 0;
849
Mark Brown024dc072011-10-09 11:52:05 +0100850 if (widget->inputs >= 0)
851 return widget->inputs;
852
Mark Brownde02d072011-09-20 21:43:24 +0100853 DAPM_UPDATE_STAT(widget, path_checks);
854
Mark Brown62ea8742012-01-21 21:14:48 +0000855 switch (widget->id) {
856 case snd_soc_dapm_supply:
857 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +0200858 case snd_soc_dapm_clock_supply:
Mark Brown246d0a12009-04-22 18:24:55 +0100859 return 0;
Mark Brown62ea8742012-01-21 21:14:48 +0000860 default:
861 break;
862 }
Mark Brown246d0a12009-04-22 18:24:55 +0100863
Richard Purdie2b97eab2006-10-06 18:32:18 +0200864 /* active stream ? */
Mark Brown010ff262009-08-17 17:39:22 +0100865 switch (widget->id) {
866 case snd_soc_dapm_dac:
867 case snd_soc_dapm_aif_in:
Mark Brown888df392012-02-16 19:37:51 -0800868 case snd_soc_dapm_dai:
Mark Brown024dc072011-10-09 11:52:05 +0100869 if (widget->active) {
870 widget->inputs = snd_soc_dapm_suspend_check(widget);
871 return widget->inputs;
872 }
Mark Brown010ff262009-08-17 17:39:22 +0100873 default:
874 break;
875 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200876
877 if (widget->connected) {
878 /* connected pin ? */
Mark Brown024dc072011-10-09 11:52:05 +0100879 if (widget->id == snd_soc_dapm_input && !widget->ext) {
880 widget->inputs = snd_soc_dapm_suspend_check(widget);
881 return widget->inputs;
882 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200883
884 /* connected VMID/Bias for lower pops */
Mark Brown024dc072011-10-09 11:52:05 +0100885 if (widget->id == snd_soc_dapm_vmid) {
886 widget->inputs = snd_soc_dapm_suspend_check(widget);
887 return widget->inputs;
888 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200889
890 /* connected jack ? */
Peter Ujfalusieaeae5d2009-09-30 09:27:24 +0300891 if (widget->id == snd_soc_dapm_mic ||
Mark Brown024dc072011-10-09 11:52:05 +0100892 (widget->id == snd_soc_dapm_line &&
893 !list_empty(&widget->sinks))) {
894 widget->inputs = snd_soc_dapm_suspend_check(widget);
895 return widget->inputs;
896 }
897
Mark Brown1ab97c82011-11-27 16:21:51 +0000898 /* signal generator */
899 if (widget->id == snd_soc_dapm_siggen) {
900 widget->inputs = snd_soc_dapm_suspend_check(widget);
901 return widget->inputs;
902 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200903 }
904
905 list_for_each_entry(path, &widget->sources, list_sink) {
Mark Browne56235e2011-09-21 18:19:14 +0100906 DAPM_UPDATE_STAT(widget, neighbour_checks);
907
Mark Brownbf3a9e12011-06-13 16:42:29 +0100908 if (path->weak)
909 continue;
910
Richard Purdie2b97eab2006-10-06 18:32:18 +0200911 if (path->walked)
912 continue;
913
Liam Girdwoodec2e3032012-04-18 11:41:11 +0100914 trace_snd_soc_dapm_input_path(widget, path);
915
Richard Purdie2b97eab2006-10-06 18:32:18 +0200916 if (path->source && path->connect) {
917 path->walked = 1;
Liam Girdwoodec2e3032012-04-18 11:41:11 +0100918
919 /* do we need to add this widget to the list ? */
920 if (list) {
921 int err;
922 err = dapm_list_add_widget(list, path->sink);
923 if (err < 0) {
924 dev_err(widget->dapm->dev, "could not add widget %s\n",
925 widget->name);
926 return con;
927 }
928 }
929
930 con += is_connected_input_ep(path->source, list);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200931 }
932 }
933
Mark Brown024dc072011-10-09 11:52:05 +0100934 widget->inputs = con;
935
Richard Purdie2b97eab2006-10-06 18:32:18 +0200936 return con;
937}
938
Liam Girdwoodec2e3032012-04-18 11:41:11 +0100939/**
940 * snd_soc_dapm_get_connected_widgets - query audio path and it's widgets.
941 * @dai: the soc DAI.
942 * @stream: stream direction.
943 * @list: list of active widgets for this stream.
944 *
945 * Queries DAPM graph as to whether an valid audio stream path exists for
946 * the initial stream specified by name. This takes into account
947 * current mixer and mux kcontrol settings. Creates list of valid widgets.
948 *
949 * Returns the number of valid paths or negative error.
950 */
951int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
952 struct snd_soc_dapm_widget_list **list)
953{
954 struct snd_soc_card *card = dai->card;
955 int paths;
956
957 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
958 dapm_reset(card);
959
960 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
961 paths = is_connected_output_ep(dai->playback_widget, list);
962 else
963 paths = is_connected_input_ep(dai->playback_widget, list);
964
965 trace_snd_soc_dapm_connected(paths, stream);
966 dapm_clear_walk(&card->dapm);
967 mutex_unlock(&card->dapm_mutex);
968
969 return paths;
970}
971
Richard Purdie2b97eab2006-10-06 18:32:18 +0200972/*
Jarkko Nikulae2be2cc2008-06-25 14:42:07 +0300973 * Handler for generic register modifier widget.
974 */
975int dapm_reg_event(struct snd_soc_dapm_widget *w,
976 struct snd_kcontrol *kcontrol, int event)
977{
978 unsigned int val;
979
980 if (SND_SOC_DAPM_EVENT_ON(event))
981 val = w->on_val;
982 else
983 val = w->off_val;
984
Liam Girdwood49575fb52012-03-06 18:16:19 +0000985 soc_widget_update_bits_locked(w, -(w->reg + 1),
Jarkko Nikulae2be2cc2008-06-25 14:42:07 +0300986 w->mask << w->shift, val << w->shift);
987
988 return 0;
989}
Mark Brown11589412008-07-29 11:42:23 +0100990EXPORT_SYMBOL_GPL(dapm_reg_event);
Jarkko Nikulae2be2cc2008-06-25 14:42:07 +0300991
Mark Brown62ea8742012-01-21 21:14:48 +0000992/*
993 * Handler for regulator supply widget.
994 */
995int dapm_regulator_event(struct snd_soc_dapm_widget *w,
996 struct snd_kcontrol *kcontrol, int event)
997{
998 if (SND_SOC_DAPM_EVENT_ON(event))
Liam Girdwooda3cc0562012-03-09 17:20:16 +0000999 return regulator_enable(w->regulator);
Mark Brown62ea8742012-01-21 21:14:48 +00001000 else
Liam Girdwooda3cc0562012-03-09 17:20:16 +00001001 return regulator_disable_deferred(w->regulator, w->shift);
Mark Brown62ea8742012-01-21 21:14:48 +00001002}
1003EXPORT_SYMBOL_GPL(dapm_regulator_event);
1004
Ola Liljad7e7eb92012-05-24 15:26:25 +02001005/*
1006 * Handler for clock supply widget.
1007 */
1008int dapm_clock_event(struct snd_soc_dapm_widget *w,
1009 struct snd_kcontrol *kcontrol, int event)
1010{
1011 if (!w->clk)
1012 return -EIO;
1013
Mark Brownec029952012-06-04 08:16:20 +01001014#ifdef CONFIG_HAVE_CLK
Ola Liljad7e7eb92012-05-24 15:26:25 +02001015 if (SND_SOC_DAPM_EVENT_ON(event)) {
1016 return clk_enable(w->clk);
1017 } else {
1018 clk_disable(w->clk);
1019 return 0;
1020 }
Mark Brownec029952012-06-04 08:16:20 +01001021#endif
Ola Liljad7e7eb92012-05-24 15:26:25 +02001022}
1023EXPORT_SYMBOL_GPL(dapm_clock_event);
1024
Mark Brownd8050022011-09-28 18:28:23 +01001025static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1026{
Mark Brown9b8a83b2011-10-04 22:15:59 +01001027 if (w->power_checked)
1028 return w->new_power;
1029
Mark Brownd8050022011-09-28 18:28:23 +01001030 if (w->force)
Mark Brown9b8a83b2011-10-04 22:15:59 +01001031 w->new_power = 1;
Mark Brownd8050022011-09-28 18:28:23 +01001032 else
Mark Brown9b8a83b2011-10-04 22:15:59 +01001033 w->new_power = w->power_check(w);
1034
1035 w->power_checked = true;
1036
1037 return w->new_power;
Mark Brownd8050022011-09-28 18:28:23 +01001038}
1039
Mark Browncd0f2d42009-04-20 16:56:59 +01001040/* Generic check to see if a widget should be powered.
1041 */
1042static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1043{
1044 int in, out;
1045
Mark Brownde02d072011-09-20 21:43:24 +01001046 DAPM_UPDATE_STAT(w, power_checks);
1047
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001048 in = is_connected_input_ep(w, NULL);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001049 dapm_clear_walk(w->dapm);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001050 out = is_connected_output_ep(w, NULL);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001051 dapm_clear_walk(w->dapm);
Mark Browncd0f2d42009-04-20 16:56:59 +01001052 return out != 0 && in != 0;
1053}
1054
Mark Brown888df392012-02-16 19:37:51 -08001055static int dapm_dai_check_power(struct snd_soc_dapm_widget *w)
1056{
1057 DAPM_UPDATE_STAT(w, power_checks);
1058
Mark Brown1eee1b32012-04-10 13:57:46 +01001059 if (w->active)
1060 return w->active;
1061
1062 return dapm_generic_check_power(w);
Mark Brown888df392012-02-16 19:37:51 -08001063}
1064
Mark Brown6ea31b92009-04-20 17:15:41 +01001065/* Check to see if an ADC has power */
1066static int dapm_adc_check_power(struct snd_soc_dapm_widget *w)
1067{
1068 int in;
1069
Mark Brownde02d072011-09-20 21:43:24 +01001070 DAPM_UPDATE_STAT(w, power_checks);
1071
Mark Brown6ea31b92009-04-20 17:15:41 +01001072 if (w->active) {
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001073 in = is_connected_input_ep(w, NULL);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001074 dapm_clear_walk(w->dapm);
Mark Brown6ea31b92009-04-20 17:15:41 +01001075 return in != 0;
1076 } else {
1077 return dapm_generic_check_power(w);
1078 }
1079}
1080
1081/* Check to see if a DAC has power */
1082static int dapm_dac_check_power(struct snd_soc_dapm_widget *w)
1083{
1084 int out;
1085
Mark Brownde02d072011-09-20 21:43:24 +01001086 DAPM_UPDATE_STAT(w, power_checks);
1087
Mark Brown6ea31b92009-04-20 17:15:41 +01001088 if (w->active) {
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001089 out = is_connected_output_ep(w, NULL);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001090 dapm_clear_walk(w->dapm);
Mark Brown6ea31b92009-04-20 17:15:41 +01001091 return out != 0;
1092 } else {
1093 return dapm_generic_check_power(w);
1094 }
1095}
1096
Mark Brown246d0a12009-04-22 18:24:55 +01001097/* Check to see if a power supply is needed */
1098static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1099{
1100 struct snd_soc_dapm_path *path;
Mark Brown246d0a12009-04-22 18:24:55 +01001101
Mark Brownde02d072011-09-20 21:43:24 +01001102 DAPM_UPDATE_STAT(w, power_checks);
1103
Mark Brown246d0a12009-04-22 18:24:55 +01001104 /* Check if one of our outputs is connected */
1105 list_for_each_entry(path, &w->sinks, list_source) {
Mark Browna8fdac82011-09-28 18:20:26 +01001106 DAPM_UPDATE_STAT(w, neighbour_checks);
1107
Mark Brownbf3a9e12011-06-13 16:42:29 +01001108 if (path->weak)
1109 continue;
1110
Mark Brown215edda2009-09-08 18:59:05 +01001111 if (path->connected &&
1112 !path->connected(path->source, path->sink))
1113 continue;
1114
Mark Brown30173582011-02-11 11:42:19 +00001115 if (!path->sink)
1116 continue;
1117
Mark Brownf68d7e12011-10-04 22:57:50 +01001118 if (dapm_widget_power_check(path->sink))
1119 return 1;
Mark Brown246d0a12009-04-22 18:24:55 +01001120 }
1121
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001122 dapm_clear_walk(w->dapm);
Mark Brown246d0a12009-04-22 18:24:55 +01001123
Mark Brownf68d7e12011-10-04 22:57:50 +01001124 return 0;
Mark Brown246d0a12009-04-22 18:24:55 +01001125}
1126
Mark Brown35c64bc2011-09-28 18:23:53 +01001127static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1128{
1129 return 1;
1130}
1131
Mark Brown38357ab2009-06-06 19:03:23 +01001132static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
1133 struct snd_soc_dapm_widget *b,
Mark Brown828a8422011-01-15 13:14:30 +00001134 bool power_up)
Mark Brown42aa3412009-03-01 19:21:10 +00001135{
Mark Brown828a8422011-01-15 13:14:30 +00001136 int *sort;
1137
1138 if (power_up)
1139 sort = dapm_up_seq;
1140 else
1141 sort = dapm_down_seq;
1142
Mark Brown38357ab2009-06-06 19:03:23 +01001143 if (sort[a->id] != sort[b->id])
1144 return sort[a->id] - sort[b->id];
Mark Brown20e48592011-01-15 13:40:50 +00001145 if (a->subseq != b->subseq) {
1146 if (power_up)
1147 return a->subseq - b->subseq;
1148 else
1149 return b->subseq - a->subseq;
1150 }
Mark Brownb22ead22009-06-07 12:51:26 +01001151 if (a->reg != b->reg)
1152 return a->reg - b->reg;
Mark Brown84dab562010-11-12 15:28:42 +00001153 if (a->dapm != b->dapm)
1154 return (unsigned long)a->dapm - (unsigned long)b->dapm;
Mark Brown42aa3412009-03-01 19:21:10 +00001155
Mark Brown38357ab2009-06-06 19:03:23 +01001156 return 0;
1157}
Mark Brown42aa3412009-03-01 19:21:10 +00001158
Mark Brown38357ab2009-06-06 19:03:23 +01001159/* Insert a widget in order into a DAPM power sequence. */
1160static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
1161 struct list_head *list,
Mark Brown828a8422011-01-15 13:14:30 +00001162 bool power_up)
Mark Brown38357ab2009-06-06 19:03:23 +01001163{
1164 struct snd_soc_dapm_widget *w;
1165
1166 list_for_each_entry(w, list, power_list)
Mark Brown828a8422011-01-15 13:14:30 +00001167 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
Mark Brown38357ab2009-06-06 19:03:23 +01001168 list_add_tail(&new_widget->power_list, &w->power_list);
1169 return;
Mark Brown42aa3412009-03-01 19:21:10 +00001170 }
Mark Brown6ea31b92009-04-20 17:15:41 +01001171
Mark Brown38357ab2009-06-06 19:03:23 +01001172 list_add_tail(&new_widget->power_list, list);
1173}
Mark Brown42aa3412009-03-01 19:21:10 +00001174
Mark Brown68f89ad2010-11-03 23:51:49 -04001175static void dapm_seq_check_event(struct snd_soc_dapm_context *dapm,
1176 struct snd_soc_dapm_widget *w, int event)
1177{
1178 struct snd_soc_card *card = dapm->card;
1179 const char *ev_name;
1180 int power, ret;
1181
1182 switch (event) {
1183 case SND_SOC_DAPM_PRE_PMU:
1184 ev_name = "PRE_PMU";
1185 power = 1;
1186 break;
1187 case SND_SOC_DAPM_POST_PMU:
1188 ev_name = "POST_PMU";
1189 power = 1;
1190 break;
1191 case SND_SOC_DAPM_PRE_PMD:
1192 ev_name = "PRE_PMD";
1193 power = 0;
1194 break;
1195 case SND_SOC_DAPM_POST_PMD:
1196 ev_name = "POST_PMD";
1197 power = 0;
1198 break;
1199 default:
1200 BUG();
1201 return;
1202 }
1203
1204 if (w->power != power)
1205 return;
1206
1207 if (w->event && (w->event_flags & event)) {
1208 pop_dbg(dapm->dev, card->pop_time, "pop test : %s %s\n",
1209 w->name, ev_name);
Mark Brown84e90932010-11-04 00:07:02 -04001210 trace_snd_soc_dapm_widget_event_start(w, event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001211 ret = w->event(w, NULL, event);
Mark Brown84e90932010-11-04 00:07:02 -04001212 trace_snd_soc_dapm_widget_event_done(w, event);
Mark Brown68f89ad2010-11-03 23:51:49 -04001213 if (ret < 0)
1214 pr_err("%s: %s event failed: %d\n",
1215 ev_name, w->name, ret);
1216 }
1217}
1218
Mark Brownb22ead22009-06-07 12:51:26 +01001219/* Apply the coalesced changes from a DAPM sequence */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001220static void dapm_seq_run_coalesced(struct snd_soc_dapm_context *dapm,
Mark Brownb22ead22009-06-07 12:51:26 +01001221 struct list_head *pending)
Mark Brown163cac02009-06-07 10:12:52 +01001222{
Jarkko Nikula3a45b862010-11-05 20:35:21 +02001223 struct snd_soc_card *card = dapm->card;
Mark Brown68f89ad2010-11-03 23:51:49 -04001224 struct snd_soc_dapm_widget *w;
1225 int reg, power;
Mark Brownb22ead22009-06-07 12:51:26 +01001226 unsigned int value = 0;
1227 unsigned int mask = 0;
1228 unsigned int cur_mask;
1229
1230 reg = list_first_entry(pending, struct snd_soc_dapm_widget,
1231 power_list)->reg;
1232
1233 list_for_each_entry(w, pending, power_list) {
1234 cur_mask = 1 << w->shift;
1235 BUG_ON(reg != w->reg);
1236
1237 if (w->invert)
1238 power = !w->power;
1239 else
1240 power = w->power;
1241
1242 mask |= cur_mask;
1243 if (power)
1244 value |= cur_mask;
1245
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +02001246 pop_dbg(dapm->dev, card->pop_time,
Mark Brownb22ead22009-06-07 12:51:26 +01001247 "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1248 w->name, reg, value, mask);
Mark Brown81628102009-06-07 13:21:24 +01001249
Mark Brown68f89ad2010-11-03 23:51:49 -04001250 /* Check for events */
1251 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_PRE_PMU);
1252 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_PRE_PMD);
Mark Brownb22ead22009-06-07 12:51:26 +01001253 }
1254
Mark Brown81628102009-06-07 13:21:24 +01001255 if (reg >= 0) {
Mark Brown29376bc2011-06-19 13:49:28 +01001256 /* Any widget will do, they should all be updating the
1257 * same register.
1258 */
1259 w = list_first_entry(pending, struct snd_soc_dapm_widget,
1260 power_list);
1261
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +02001262 pop_dbg(dapm->dev, card->pop_time,
Mark Brown81628102009-06-07 13:21:24 +01001263 "pop test : Applying 0x%x/0x%x to %x in %dms\n",
Jarkko Nikula3a45b862010-11-05 20:35:21 +02001264 value, mask, reg, card->pop_time);
1265 pop_wait(card->pop_time);
Liam Girdwood49575fb52012-03-06 18:16:19 +00001266 soc_widget_update_bits_locked(w, reg, mask, value);
Mark Brown81628102009-06-07 13:21:24 +01001267 }
1268
1269 list_for_each_entry(w, pending, power_list) {
Mark Brown68f89ad2010-11-03 23:51:49 -04001270 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_POST_PMU);
1271 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_POST_PMD);
Mark Brown42aa3412009-03-01 19:21:10 +00001272 }
Mark Brown42aa3412009-03-01 19:21:10 +00001273}
1274
Mark Brownb22ead22009-06-07 12:51:26 +01001275/* Apply a DAPM power sequence.
1276 *
1277 * We walk over a pre-sorted list of widgets to apply power to. In
1278 * order to minimise the number of writes to the device required
1279 * multiple widgets will be updated in a single write where possible.
1280 * Currently anything that requires more than a single write is not
1281 * handled.
1282 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001283static void dapm_seq_run(struct snd_soc_dapm_context *dapm,
Mark Brown828a8422011-01-15 13:14:30 +00001284 struct list_head *list, int event, bool power_up)
Mark Brownb22ead22009-06-07 12:51:26 +01001285{
1286 struct snd_soc_dapm_widget *w, *n;
1287 LIST_HEAD(pending);
1288 int cur_sort = -1;
Mark Brown20e48592011-01-15 13:40:50 +00001289 int cur_subseq = -1;
Mark Brownb22ead22009-06-07 12:51:26 +01001290 int cur_reg = SND_SOC_NOPM;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001291 struct snd_soc_dapm_context *cur_dapm = NULL;
Mark Brown474b62d2011-01-18 16:14:44 +00001292 int ret, i;
Mark Brown828a8422011-01-15 13:14:30 +00001293 int *sort;
1294
1295 if (power_up)
1296 sort = dapm_up_seq;
1297 else
1298 sort = dapm_down_seq;
Mark Brown163cac02009-06-07 10:12:52 +01001299
Mark Brownb22ead22009-06-07 12:51:26 +01001300 list_for_each_entry_safe(w, n, list, power_list) {
1301 ret = 0;
1302
1303 /* Do we need to apply any queued changes? */
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001304 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
Mark Brown20e48592011-01-15 13:40:50 +00001305 w->dapm != cur_dapm || w->subseq != cur_subseq) {
Mark Brownb22ead22009-06-07 12:51:26 +01001306 if (!list_empty(&pending))
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001307 dapm_seq_run_coalesced(cur_dapm, &pending);
Mark Brownb22ead22009-06-07 12:51:26 +01001308
Mark Brown474b62d2011-01-18 16:14:44 +00001309 if (cur_dapm && cur_dapm->seq_notifier) {
1310 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1311 if (sort[i] == cur_sort)
1312 cur_dapm->seq_notifier(cur_dapm,
Mark Brownf85a9e02011-01-26 21:41:28 +00001313 i,
1314 cur_subseq);
Mark Brown474b62d2011-01-18 16:14:44 +00001315 }
1316
Mark Brownb22ead22009-06-07 12:51:26 +01001317 INIT_LIST_HEAD(&pending);
1318 cur_sort = -1;
Mark Brownb0b3e6f2011-07-16 10:55:08 +09001319 cur_subseq = INT_MIN;
Mark Brownb22ead22009-06-07 12:51:26 +01001320 cur_reg = SND_SOC_NOPM;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001321 cur_dapm = NULL;
Mark Brownb22ead22009-06-07 12:51:26 +01001322 }
1323
Mark Brown163cac02009-06-07 10:12:52 +01001324 switch (w->id) {
1325 case snd_soc_dapm_pre:
1326 if (!w->event)
Mark Brownb22ead22009-06-07 12:51:26 +01001327 list_for_each_entry_safe_continue(w, n, list,
1328 power_list);
Mark Brown163cac02009-06-07 10:12:52 +01001329
Mark Brownb22ead22009-06-07 12:51:26 +01001330 if (event == SND_SOC_DAPM_STREAM_START)
Mark Brown163cac02009-06-07 10:12:52 +01001331 ret = w->event(w,
1332 NULL, SND_SOC_DAPM_PRE_PMU);
Mark Brownb22ead22009-06-07 12:51:26 +01001333 else if (event == SND_SOC_DAPM_STREAM_STOP)
Mark Brown163cac02009-06-07 10:12:52 +01001334 ret = w->event(w,
1335 NULL, SND_SOC_DAPM_PRE_PMD);
Mark Brown163cac02009-06-07 10:12:52 +01001336 break;
1337
1338 case snd_soc_dapm_post:
1339 if (!w->event)
Mark Brownb22ead22009-06-07 12:51:26 +01001340 list_for_each_entry_safe_continue(w, n, list,
1341 power_list);
Mark Brown163cac02009-06-07 10:12:52 +01001342
Mark Brownb22ead22009-06-07 12:51:26 +01001343 if (event == SND_SOC_DAPM_STREAM_START)
Mark Brown163cac02009-06-07 10:12:52 +01001344 ret = w->event(w,
1345 NULL, SND_SOC_DAPM_POST_PMU);
Mark Brownb22ead22009-06-07 12:51:26 +01001346 else if (event == SND_SOC_DAPM_STREAM_STOP)
Mark Brown163cac02009-06-07 10:12:52 +01001347 ret = w->event(w,
1348 NULL, SND_SOC_DAPM_POST_PMD);
Mark Brownb22ead22009-06-07 12:51:26 +01001349 break;
1350
Mark Brown163cac02009-06-07 10:12:52 +01001351 default:
Mark Brown81628102009-06-07 13:21:24 +01001352 /* Queue it up for application */
1353 cur_sort = sort[w->id];
Mark Brown20e48592011-01-15 13:40:50 +00001354 cur_subseq = w->subseq;
Mark Brown81628102009-06-07 13:21:24 +01001355 cur_reg = w->reg;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001356 cur_dapm = w->dapm;
Mark Brown81628102009-06-07 13:21:24 +01001357 list_move(&w->power_list, &pending);
1358 break;
Mark Brown163cac02009-06-07 10:12:52 +01001359 }
Mark Brownb22ead22009-06-07 12:51:26 +01001360
1361 if (ret < 0)
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02001362 dev_err(w->dapm->dev,
1363 "Failed to apply widget power: %d\n", ret);
Mark Brown163cac02009-06-07 10:12:52 +01001364 }
Mark Brownb22ead22009-06-07 12:51:26 +01001365
1366 if (!list_empty(&pending))
Mark Brown28e86802011-03-08 19:29:53 +00001367 dapm_seq_run_coalesced(cur_dapm, &pending);
Mark Brown474b62d2011-01-18 16:14:44 +00001368
1369 if (cur_dapm && cur_dapm->seq_notifier) {
1370 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1371 if (sort[i] == cur_sort)
1372 cur_dapm->seq_notifier(cur_dapm,
Mark Brownf85a9e02011-01-26 21:41:28 +00001373 i, cur_subseq);
Mark Brown474b62d2011-01-18 16:14:44 +00001374 }
Mark Brown163cac02009-06-07 10:12:52 +01001375}
1376
Mark Brown97404f22010-12-14 16:13:57 +00001377static void dapm_widget_update(struct snd_soc_dapm_context *dapm)
1378{
1379 struct snd_soc_dapm_update *update = dapm->update;
1380 struct snd_soc_dapm_widget *w;
1381 int ret;
1382
1383 if (!update)
1384 return;
1385
1386 w = update->widget;
1387
1388 if (w->event &&
1389 (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1390 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1391 if (ret != 0)
1392 pr_err("%s DAPM pre-event failed: %d\n",
1393 w->name, ret);
1394 }
1395
Liam Girdwood49575fb52012-03-06 18:16:19 +00001396 ret = soc_widget_update_bits_locked(w, update->reg, update->mask,
Mark Brown97404f22010-12-14 16:13:57 +00001397 update->val);
1398 if (ret < 0)
1399 pr_err("%s DAPM update failed: %d\n", w->name, ret);
1400
1401 if (w->event &&
1402 (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1403 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1404 if (ret != 0)
1405 pr_err("%s DAPM post-event failed: %d\n",
1406 w->name, ret);
1407 }
1408}
1409
Mark Brown9d0624a2011-02-18 11:49:43 -08001410/* Async callback run prior to DAPM sequences - brings to _PREPARE if
1411 * they're changing state.
1412 */
1413static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1414{
1415 struct snd_soc_dapm_context *d = data;
1416 int ret;
Mark Brown97404f22010-12-14 16:13:57 +00001417
Mark Brown56fba412011-06-04 11:25:10 +01001418 /* If we're off and we're not supposed to be go into STANDBY */
1419 if (d->bias_level == SND_SOC_BIAS_OFF &&
1420 d->target_bias_level != SND_SOC_BIAS_OFF) {
Mark Brownf1aac482011-12-05 15:17:06 +00001421 if (d->dev)
1422 pm_runtime_get_sync(d->dev);
1423
Mark Brown9d0624a2011-02-18 11:49:43 -08001424 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1425 if (ret != 0)
1426 dev_err(d->dev,
1427 "Failed to turn on bias: %d\n", ret);
1428 }
1429
Mark Brown56fba412011-06-04 11:25:10 +01001430 /* Prepare for a STADDBY->ON or ON->STANDBY transition */
1431 if (d->bias_level != d->target_bias_level) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001432 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1433 if (ret != 0)
1434 dev_err(d->dev,
1435 "Failed to prepare bias: %d\n", ret);
1436 }
1437}
1438
1439/* Async callback run prior to DAPM sequences - brings to their final
1440 * state.
1441 */
1442static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1443{
1444 struct snd_soc_dapm_context *d = data;
1445 int ret;
1446
1447 /* If we just powered the last thing off drop to standby bias */
Mark Brown56fba412011-06-04 11:25:10 +01001448 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1449 (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1450 d->target_bias_level == SND_SOC_BIAS_OFF)) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001451 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1452 if (ret != 0)
1453 dev_err(d->dev, "Failed to apply standby bias: %d\n",
1454 ret);
1455 }
1456
1457 /* If we're in standby and can support bias off then do that */
Mark Brown56fba412011-06-04 11:25:10 +01001458 if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1459 d->target_bias_level == SND_SOC_BIAS_OFF) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001460 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1461 if (ret != 0)
1462 dev_err(d->dev, "Failed to turn off bias: %d\n", ret);
Mark Brownf1aac482011-12-05 15:17:06 +00001463
1464 if (d->dev)
Mark Brownfb644e92012-01-25 19:53:58 +00001465 pm_runtime_put(d->dev);
Mark Brown9d0624a2011-02-18 11:49:43 -08001466 }
1467
1468 /* If we just powered up then move to active bias */
Mark Brown56fba412011-06-04 11:25:10 +01001469 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1470 d->target_bias_level == SND_SOC_BIAS_ON) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001471 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1472 if (ret != 0)
1473 dev_err(d->dev, "Failed to apply active bias: %d\n",
1474 ret);
1475 }
1476}
Mark Brown97404f22010-12-14 16:13:57 +00001477
Mark Brownfe4fda52011-10-03 22:36:57 +01001478static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
1479 bool power, bool connect)
1480{
1481 /* If a connection is being made or broken then that update
1482 * will have marked the peer dirty, otherwise the widgets are
1483 * not connected and this update has no impact. */
1484 if (!connect)
1485 return;
1486
1487 /* If the peer is already in the state we're moving to then we
1488 * won't have an impact on it. */
1489 if (power != peer->power)
Mark Brown75c1f892011-10-04 22:28:08 +01001490 dapm_mark_dirty(peer, "peer state change");
Mark Brownfe4fda52011-10-03 22:36:57 +01001491}
1492
Mark Brown05623c42011-09-28 17:02:31 +01001493static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
1494 struct list_head *up_list,
1495 struct list_head *down_list)
1496{
Mark Browndb432b42011-10-03 21:06:40 +01001497 struct snd_soc_dapm_path *path;
1498
Mark Brown05623c42011-09-28 17:02:31 +01001499 if (w->power == power)
1500 return;
1501
1502 trace_snd_soc_dapm_widget_power(w, power);
1503
Mark Browndb432b42011-10-03 21:06:40 +01001504 /* If we changed our power state perhaps our neigbours changed
Mark Brownfe4fda52011-10-03 22:36:57 +01001505 * also.
Mark Browndb432b42011-10-03 21:06:40 +01001506 */
1507 list_for_each_entry(path, &w->sources, list_sink) {
1508 if (path->source) {
Mark Brownfe4fda52011-10-03 22:36:57 +01001509 dapm_widget_set_peer_power(path->source, power,
1510 path->connect);
Mark Browndb432b42011-10-03 21:06:40 +01001511 }
1512 }
Mark Brownf3bf3e42011-10-04 22:43:31 +01001513 switch (w->id) {
1514 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00001515 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02001516 case snd_soc_dapm_clock_supply:
Mark Brownf3bf3e42011-10-04 22:43:31 +01001517 /* Supplies can't affect their outputs, only their inputs */
1518 break;
1519 default:
1520 list_for_each_entry(path, &w->sinks, list_source) {
1521 if (path->sink) {
1522 dapm_widget_set_peer_power(path->sink, power,
1523 path->connect);
1524 }
Mark Browndb432b42011-10-03 21:06:40 +01001525 }
Mark Brownf3bf3e42011-10-04 22:43:31 +01001526 break;
Mark Browndb432b42011-10-03 21:06:40 +01001527 }
1528
Mark Brown05623c42011-09-28 17:02:31 +01001529 if (power)
1530 dapm_seq_insert(w, up_list, true);
1531 else
1532 dapm_seq_insert(w, down_list, false);
1533
1534 w->power = power;
1535}
1536
Mark Brown7c81beb2011-09-20 22:22:32 +01001537static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1538 struct list_head *up_list,
1539 struct list_head *down_list)
1540{
Mark Brown7c81beb2011-09-20 22:22:32 +01001541 int power;
1542
1543 switch (w->id) {
1544 case snd_soc_dapm_pre:
1545 dapm_seq_insert(w, down_list, false);
1546 break;
1547 case snd_soc_dapm_post:
1548 dapm_seq_insert(w, up_list, true);
1549 break;
1550
1551 default:
Mark Brownd8050022011-09-28 18:28:23 +01001552 power = dapm_widget_power_check(w);
Mark Brown7c81beb2011-09-20 22:22:32 +01001553
Mark Brown05623c42011-09-28 17:02:31 +01001554 dapm_widget_set_power(w, power, up_list, down_list);
Mark Brown7c81beb2011-09-20 22:22:32 +01001555 break;
1556 }
1557}
1558
Mark Brown42aa3412009-03-01 19:21:10 +00001559/*
Richard Purdie2b97eab2006-10-06 18:32:18 +02001560 * Scan each dapm widget for complete audio path.
1561 * A complete path is a route that has valid endpoints i.e.:-
1562 *
1563 * o DAC to output pin.
1564 * o Input Pin to ADC.
1565 * o Input pin to Output pin (bypass, sidetone)
1566 * o DAC to ADC (loopback).
1567 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001568static int dapm_power_widgets(struct snd_soc_dapm_context *dapm, int event)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001569{
Mark Brown12ea2c72011-03-02 18:17:32 +00001570 struct snd_soc_card *card = dapm->card;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001571 struct snd_soc_dapm_widget *w;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001572 struct snd_soc_dapm_context *d;
Mark Brown291f3bb2009-06-07 13:57:17 +01001573 LIST_HEAD(up_list);
1574 LIST_HEAD(down_list);
Mark Brown9d0624a2011-02-18 11:49:43 -08001575 LIST_HEAD(async_domain);
Mark Brown56fba412011-06-04 11:25:10 +01001576 enum snd_soc_bias_level bias;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001577
Mark Brown84e90932010-11-04 00:07:02 -04001578 trace_snd_soc_dapm_start(card);
1579
Mark Brown56fba412011-06-04 11:25:10 +01001580 list_for_each_entry(d, &card->dapm_list, list) {
Mark Brown497098be2012-03-08 15:06:09 +00001581 if (d->idle_bias_off)
1582 d->target_bias_level = SND_SOC_BIAS_OFF;
1583 else
1584 d->target_bias_level = SND_SOC_BIAS_STANDBY;
Mark Brown56fba412011-06-04 11:25:10 +01001585 }
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001586
Liam Girdwood6c120e12012-02-15 15:15:34 +00001587 dapm_reset(card);
Mark Brown9b8a83b2011-10-04 22:15:59 +01001588
Mark Brown6d3ddc82009-05-16 17:47:29 +01001589 /* Check which widgets we need to power and store them in
Mark Browndb432b42011-10-03 21:06:40 +01001590 * lists indicating if they should be powered up or down. We
1591 * only check widgets that have been flagged as dirty but note
1592 * that new widgets may be added to the dirty list while we
1593 * iterate.
Mark Brown6d3ddc82009-05-16 17:47:29 +01001594 */
Mark Browndb432b42011-10-03 21:06:40 +01001595 list_for_each_entry(w, &card->dapm_dirty, dirty) {
Mark Brown7c81beb2011-09-20 22:22:32 +01001596 dapm_power_one_widget(w, &up_list, &down_list);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001597 }
1598
Mark Brownf9de6d72011-09-28 17:19:47 +01001599 list_for_each_entry(w, &card->widgets, list) {
Mark Browndb432b42011-10-03 21:06:40 +01001600 list_del_init(&w->dirty);
1601
Mark Brownf9de6d72011-09-28 17:19:47 +01001602 if (w->power) {
1603 d = w->dapm;
1604
1605 /* Supplies and micbiases only bring the
1606 * context up to STANDBY as unless something
1607 * else is active and passing audio they
Mark Brownafe62362012-01-25 19:55:22 +00001608 * generally don't require full power. Signal
1609 * generators are virtual pins and have no
1610 * power impact themselves.
Mark Brownf9de6d72011-09-28 17:19:47 +01001611 */
1612 switch (w->id) {
Mark Brownafe62362012-01-25 19:55:22 +00001613 case snd_soc_dapm_siggen:
1614 break;
Mark Brownf9de6d72011-09-28 17:19:47 +01001615 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00001616 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02001617 case snd_soc_dapm_clock_supply:
Mark Brownf9de6d72011-09-28 17:19:47 +01001618 case snd_soc_dapm_micbias:
1619 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
1620 d->target_bias_level = SND_SOC_BIAS_STANDBY;
1621 break;
1622 default:
1623 d->target_bias_level = SND_SOC_BIAS_ON;
1624 break;
1625 }
1626 }
1627
1628 }
1629
Mark Brown85a843c2011-09-21 21:29:47 +01001630 /* Force all contexts in the card to the same bias state if
1631 * they're not ground referenced.
1632 */
Mark Brown56fba412011-06-04 11:25:10 +01001633 bias = SND_SOC_BIAS_OFF;
Mark Brown52ba67b2011-04-04 21:05:11 +09001634 list_for_each_entry(d, &card->dapm_list, list)
Mark Brown56fba412011-06-04 11:25:10 +01001635 if (d->target_bias_level > bias)
1636 bias = d->target_bias_level;
Mark Brown52ba67b2011-04-04 21:05:11 +09001637 list_for_each_entry(d, &card->dapm_list, list)
Mark Brown85a843c2011-09-21 21:29:47 +01001638 if (!d->idle_bias_off)
1639 d->target_bias_level = bias;
Mark Brown52ba67b2011-04-04 21:05:11 +09001640
Mark Brownde02d072011-09-20 21:43:24 +01001641 trace_snd_soc_dapm_walk_done(card);
Mark Brown52ba67b2011-04-04 21:05:11 +09001642
Mark Brown9d0624a2011-02-18 11:49:43 -08001643 /* Run all the bias changes in parallel */
1644 list_for_each_entry(d, &dapm->card->dapm_list, list)
1645 async_schedule_domain(dapm_pre_sequence_async, d,
1646 &async_domain);
1647 async_synchronize_full_domain(&async_domain);
Mark Brown452c5ea2009-05-17 21:41:23 +01001648
Mark Brown6d3ddc82009-05-16 17:47:29 +01001649 /* Power down widgets first; try to avoid amplifying pops. */
Mark Brown828a8422011-01-15 13:14:30 +00001650 dapm_seq_run(dapm, &down_list, event, false);
Mark Brown6d3ddc82009-05-16 17:47:29 +01001651
Mark Brown97404f22010-12-14 16:13:57 +00001652 dapm_widget_update(dapm);
1653
Mark Brown6d3ddc82009-05-16 17:47:29 +01001654 /* Now power up. */
Mark Brown828a8422011-01-15 13:14:30 +00001655 dapm_seq_run(dapm, &up_list, event, true);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001656
Mark Brown9d0624a2011-02-18 11:49:43 -08001657 /* Run all the bias changes in parallel */
1658 list_for_each_entry(d, &dapm->card->dapm_list, list)
1659 async_schedule_domain(dapm_post_sequence_async, d,
1660 &async_domain);
1661 async_synchronize_full_domain(&async_domain);
Mark Brown452c5ea2009-05-17 21:41:23 +01001662
Liam Girdwood8078d872012-02-15 15:15:35 +00001663 /* do we need to notify any clients that DAPM event is complete */
1664 list_for_each_entry(d, &card->dapm_list, list) {
1665 if (d->stream_event)
1666 d->stream_event(d, event);
1667 }
1668
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +02001669 pop_dbg(dapm->dev, card->pop_time,
1670 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
Jarkko Nikula3a45b862010-11-05 20:35:21 +02001671 pop_wait(card->pop_time);
Mark Browncb507e72009-07-08 18:54:57 +01001672
Mark Brown84e90932010-11-04 00:07:02 -04001673 trace_snd_soc_dapm_done(card);
1674
Mark Brown42aa3412009-03-01 19:21:10 +00001675 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001676}
1677
Mark Brown79fb9382009-08-21 16:38:13 +01001678#ifdef CONFIG_DEBUG_FS
Mark Brown79fb9382009-08-21 16:38:13 +01001679static ssize_t dapm_widget_power_read_file(struct file *file,
1680 char __user *user_buf,
1681 size_t count, loff_t *ppos)
1682{
1683 struct snd_soc_dapm_widget *w = file->private_data;
1684 char *buf;
1685 int in, out;
1686 ssize_t ret;
1687 struct snd_soc_dapm_path *p = NULL;
1688
1689 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1690 if (!buf)
1691 return -ENOMEM;
1692
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001693 in = is_connected_input_ep(w, NULL);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001694 dapm_clear_walk(w->dapm);
Liam Girdwoodec2e3032012-04-18 11:41:11 +01001695 out = is_connected_output_ep(w, NULL);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001696 dapm_clear_walk(w->dapm);
Mark Brown79fb9382009-08-21 16:38:13 +01001697
Mark Brownf13ebad2012-03-03 18:01:01 +00001698 ret = snprintf(buf, PAGE_SIZE, "%s: %s%s in %d out %d",
1699 w->name, w->power ? "On" : "Off",
1700 w->force ? " (forced)" : "", in, out);
Mark Brown79fb9382009-08-21 16:38:13 +01001701
Mark Brownd033c362009-12-04 15:25:56 +00001702 if (w->reg >= 0)
1703 ret += snprintf(buf + ret, PAGE_SIZE - ret,
1704 " - R%d(0x%x) bit %d",
1705 w->reg, w->reg, w->shift);
1706
1707 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1708
Mark Brown3eef08b2009-09-14 16:49:00 +01001709 if (w->sname)
1710 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1711 w->sname,
1712 w->active ? "active" : "inactive");
Mark Brown79fb9382009-08-21 16:38:13 +01001713
1714 list_for_each_entry(p, &w->sources, list_sink) {
Mark Brown215edda2009-09-08 18:59:05 +01001715 if (p->connected && !p->connected(w, p->sink))
1716 continue;
1717
Mark Brown79fb9382009-08-21 16:38:13 +01001718 if (p->connect)
1719 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Dimitris Papastamos67f5ed62011-02-24 17:09:32 +00001720 " in \"%s\" \"%s\"\n",
Mark Brown79fb9382009-08-21 16:38:13 +01001721 p->name ? p->name : "static",
1722 p->source->name);
1723 }
1724 list_for_each_entry(p, &w->sinks, list_source) {
Mark Brown215edda2009-09-08 18:59:05 +01001725 if (p->connected && !p->connected(w, p->sink))
1726 continue;
1727
Mark Brown79fb9382009-08-21 16:38:13 +01001728 if (p->connect)
1729 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Dimitris Papastamos67f5ed62011-02-24 17:09:32 +00001730 " out \"%s\" \"%s\"\n",
Mark Brown79fb9382009-08-21 16:38:13 +01001731 p->name ? p->name : "static",
1732 p->sink->name);
1733 }
1734
1735 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1736
1737 kfree(buf);
1738 return ret;
1739}
1740
1741static const struct file_operations dapm_widget_power_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -07001742 .open = simple_open,
Mark Brown79fb9382009-08-21 16:38:13 +01001743 .read = dapm_widget_power_read_file,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001744 .llseek = default_llseek,
Mark Brown79fb9382009-08-21 16:38:13 +01001745};
1746
Mark Brownef49e4f2011-04-04 20:48:13 +09001747static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
1748 size_t count, loff_t *ppos)
1749{
1750 struct snd_soc_dapm_context *dapm = file->private_data;
1751 char *level;
1752
1753 switch (dapm->bias_level) {
1754 case SND_SOC_BIAS_ON:
1755 level = "On\n";
1756 break;
1757 case SND_SOC_BIAS_PREPARE:
1758 level = "Prepare\n";
1759 break;
1760 case SND_SOC_BIAS_STANDBY:
1761 level = "Standby\n";
1762 break;
1763 case SND_SOC_BIAS_OFF:
1764 level = "Off\n";
1765 break;
1766 default:
1767 BUG();
1768 level = "Unknown\n";
1769 break;
1770 }
1771
1772 return simple_read_from_buffer(user_buf, count, ppos, level,
1773 strlen(level));
1774}
1775
1776static const struct file_operations dapm_bias_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -07001777 .open = simple_open,
Mark Brownef49e4f2011-04-04 20:48:13 +09001778 .read = dapm_bias_read_file,
1779 .llseek = default_llseek,
1780};
1781
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02001782void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
1783 struct dentry *parent)
Mark Brown79fb9382009-08-21 16:38:13 +01001784{
Mark Brown79fb9382009-08-21 16:38:13 +01001785 struct dentry *d;
1786
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02001787 dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
1788
1789 if (!dapm->debugfs_dapm) {
Liam Girdwoodf1e90af2012-03-06 18:13:25 +00001790 dev_warn(dapm->dev,
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02001791 "Failed to create DAPM debugfs directory\n");
Mark Brown79fb9382009-08-21 16:38:13 +01001792 return;
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02001793 }
Mark Brown79fb9382009-08-21 16:38:13 +01001794
Mark Brownef49e4f2011-04-04 20:48:13 +09001795 d = debugfs_create_file("bias_level", 0444,
1796 dapm->debugfs_dapm, dapm,
1797 &dapm_bias_fops);
1798 if (!d)
1799 dev_warn(dapm->dev,
1800 "ASoC: Failed to create bias level debugfs file\n");
Mark Brown79fb9382009-08-21 16:38:13 +01001801}
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001802
1803static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
1804{
1805 struct snd_soc_dapm_context *dapm = w->dapm;
1806 struct dentry *d;
1807
1808 if (!dapm->debugfs_dapm || !w->name)
1809 return;
1810
1811 d = debugfs_create_file(w->name, 0444,
1812 dapm->debugfs_dapm, w,
1813 &dapm_widget_power_fops);
1814 if (!d)
1815 dev_warn(w->dapm->dev,
1816 "ASoC: Failed to create %s debugfs file\n",
1817 w->name);
1818}
1819
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02001820static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
1821{
1822 debugfs_remove_recursive(dapm->debugfs_dapm);
1823}
1824
Mark Brown79fb9382009-08-21 16:38:13 +01001825#else
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02001826void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
1827 struct dentry *parent)
Mark Brown79fb9382009-08-21 16:38:13 +01001828{
1829}
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001830
1831static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
1832{
1833}
1834
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02001835static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
1836{
1837}
1838
Mark Brown79fb9382009-08-21 16:38:13 +01001839#endif
1840
Richard Purdie2b97eab2006-10-06 18:32:18 +02001841/* test and update the power status of a mux widget */
Liam Girdwood4edbb3452012-03-07 10:38:27 +00001842static int soc_dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
Liam Girdwood40f02cd2012-02-06 16:05:14 +00001843 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001844{
1845 struct snd_soc_dapm_path *path;
1846 int found = 0;
1847
Peter Ujfalusieff317d2009-01-15 14:40:47 +02001848 if (widget->id != snd_soc_dapm_mux &&
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +00001849 widget->id != snd_soc_dapm_virt_mux &&
Peter Ujfalusieff317d2009-01-15 14:40:47 +02001850 widget->id != snd_soc_dapm_value_mux)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001851 return -ENODEV;
1852
Richard Purdie2b97eab2006-10-06 18:32:18 +02001853 /* find dapm widget path assoc with kcontrol */
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02001854 list_for_each_entry(path, &widget->dapm->card->paths, list) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02001855 if (path->kcontrol != kcontrol)
1856 continue;
1857
Richard Zhaocb01e2b2008-10-07 08:05:20 +08001858 if (!path->name || !e->texts[mux])
Richard Purdie2b97eab2006-10-06 18:32:18 +02001859 continue;
1860
1861 found = 1;
1862 /* we now need to match the string in the enum to the path */
Mark Browndb432b42011-10-03 21:06:40 +01001863 if (!(strcmp(path->name, e->texts[mux]))) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02001864 path->connect = 1; /* new connection */
Mark Brown75c1f892011-10-04 22:28:08 +01001865 dapm_mark_dirty(path->source, "mux connection");
Mark Browndb432b42011-10-03 21:06:40 +01001866 } else {
1867 if (path->connect)
Mark Brown75c1f892011-10-04 22:28:08 +01001868 dapm_mark_dirty(path->source,
1869 "mux disconnection");
Richard Purdie2b97eab2006-10-06 18:32:18 +02001870 path->connect = 0; /* old connection must be powered down */
Mark Browndb432b42011-10-03 21:06:40 +01001871 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02001872 }
1873
Mark Browndb432b42011-10-03 21:06:40 +01001874 if (found) {
Mark Brown75c1f892011-10-04 22:28:08 +01001875 dapm_mark_dirty(widget, "mux change");
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001876 dapm_power_widgets(widget->dapm, SND_SOC_DAPM_STREAM_NOP);
Mark Browndb432b42011-10-03 21:06:40 +01001877 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02001878
Liam Girdwood618dae12012-04-25 12:12:51 +01001879 return found;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001880}
Liam Girdwood4edbb3452012-03-07 10:38:27 +00001881
1882int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
1883 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
1884{
1885 struct snd_soc_card *card = widget->dapm->card;
1886 int ret;
1887
Liam Girdwood3cd04342012-03-09 12:02:08 +00001888 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Liam Girdwood4edbb3452012-03-07 10:38:27 +00001889 ret = soc_dapm_mux_update_power(widget, kcontrol, mux, e);
1890 mutex_unlock(&card->dapm_mutex);
Liam Girdwood618dae12012-04-25 12:12:51 +01001891 if (ret > 0)
1892 soc_dpcm_runtime_update(widget);
Liam Girdwood4edbb3452012-03-07 10:38:27 +00001893 return ret;
1894}
Liam Girdwood40f02cd2012-02-06 16:05:14 +00001895EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001896
Milan plzik1b075e32008-01-10 14:39:46 +01001897/* test and update the power status of a mixer or switch widget */
Liam Girdwood4edbb3452012-03-07 10:38:27 +00001898static int soc_dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
Mark Brown283375c2009-12-07 18:09:03 +00001899 struct snd_kcontrol *kcontrol, int connect)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001900{
1901 struct snd_soc_dapm_path *path;
1902 int found = 0;
1903
Milan plzik1b075e32008-01-10 14:39:46 +01001904 if (widget->id != snd_soc_dapm_mixer &&
Ian Moltonca9c1aa2009-01-06 20:11:51 +00001905 widget->id != snd_soc_dapm_mixer_named_ctl &&
Milan plzik1b075e32008-01-10 14:39:46 +01001906 widget->id != snd_soc_dapm_switch)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001907 return -ENODEV;
1908
Richard Purdie2b97eab2006-10-06 18:32:18 +02001909 /* find dapm widget path assoc with kcontrol */
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02001910 list_for_each_entry(path, &widget->dapm->card->paths, list) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02001911 if (path->kcontrol != kcontrol)
1912 continue;
1913
1914 /* found, now check type */
1915 found = 1;
Mark Brown283375c2009-12-07 18:09:03 +00001916 path->connect = connect;
Mark Brown75c1f892011-10-04 22:28:08 +01001917 dapm_mark_dirty(path->source, "mixer connection");
Richard Purdie2b97eab2006-10-06 18:32:18 +02001918 }
1919
Mark Browndb432b42011-10-03 21:06:40 +01001920 if (found) {
Mark Brown75c1f892011-10-04 22:28:08 +01001921 dapm_mark_dirty(widget, "mixer update");
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001922 dapm_power_widgets(widget->dapm, SND_SOC_DAPM_STREAM_NOP);
Mark Browndb432b42011-10-03 21:06:40 +01001923 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02001924
Liam Girdwood618dae12012-04-25 12:12:51 +01001925 return found;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001926}
Liam Girdwood4edbb3452012-03-07 10:38:27 +00001927
1928int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
1929 struct snd_kcontrol *kcontrol, int connect)
1930{
1931 struct snd_soc_card *card = widget->dapm->card;
1932 int ret;
1933
Liam Girdwood3cd04342012-03-09 12:02:08 +00001934 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Liam Girdwood4edbb3452012-03-07 10:38:27 +00001935 ret = soc_dapm_mixer_update_power(widget, kcontrol, connect);
1936 mutex_unlock(&card->dapm_mutex);
Liam Girdwood618dae12012-04-25 12:12:51 +01001937 if (ret > 0)
1938 soc_dpcm_runtime_update(widget);
Liam Girdwood4edbb3452012-03-07 10:38:27 +00001939 return ret;
1940}
Liam Girdwood40f02cd2012-02-06 16:05:14 +00001941EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001942
1943/* show dapm widget status in sys fs */
1944static ssize_t dapm_widget_show(struct device *dev,
1945 struct device_attribute *attr, char *buf)
1946{
Mark Brown36ae1a92012-01-06 17:12:45 -08001947 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001948 struct snd_soc_codec *codec =rtd->codec;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001949 struct snd_soc_dapm_widget *w;
1950 int count = 0;
1951 char *state = "not set";
1952
Jarkko Nikula97c866d2010-12-14 12:18:31 +02001953 list_for_each_entry(w, &codec->card->widgets, list) {
1954 if (w->dapm != &codec->dapm)
1955 continue;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001956
1957 /* only display widgets that burnm power */
1958 switch (w->id) {
1959 case snd_soc_dapm_hp:
1960 case snd_soc_dapm_mic:
1961 case snd_soc_dapm_spk:
1962 case snd_soc_dapm_line:
1963 case snd_soc_dapm_micbias:
1964 case snd_soc_dapm_dac:
1965 case snd_soc_dapm_adc:
1966 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06001967 case snd_soc_dapm_out_drv:
Richard Purdie2b97eab2006-10-06 18:32:18 +02001968 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00001969 case snd_soc_dapm_mixer_named_ctl:
Mark Brown246d0a12009-04-22 18:24:55 +01001970 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00001971 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02001972 case snd_soc_dapm_clock_supply:
Richard Purdie2b97eab2006-10-06 18:32:18 +02001973 if (w->name)
1974 count += sprintf(buf + count, "%s: %s\n",
1975 w->name, w->power ? "On":"Off");
1976 break;
1977 default:
1978 break;
1979 }
1980 }
1981
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001982 switch (codec->dapm.bias_level) {
Mark Brown0be98982008-05-19 12:31:28 +02001983 case SND_SOC_BIAS_ON:
1984 state = "On";
Richard Purdie2b97eab2006-10-06 18:32:18 +02001985 break;
Mark Brown0be98982008-05-19 12:31:28 +02001986 case SND_SOC_BIAS_PREPARE:
1987 state = "Prepare";
Richard Purdie2b97eab2006-10-06 18:32:18 +02001988 break;
Mark Brown0be98982008-05-19 12:31:28 +02001989 case SND_SOC_BIAS_STANDBY:
1990 state = "Standby";
Richard Purdie2b97eab2006-10-06 18:32:18 +02001991 break;
Mark Brown0be98982008-05-19 12:31:28 +02001992 case SND_SOC_BIAS_OFF:
1993 state = "Off";
Richard Purdie2b97eab2006-10-06 18:32:18 +02001994 break;
1995 }
1996 count += sprintf(buf + count, "PM State: %s\n", state);
1997
1998 return count;
1999}
2000
2001static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
2002
2003int snd_soc_dapm_sys_add(struct device *dev)
2004{
Troy Kisky12ef1932008-10-13 17:42:14 -07002005 return device_create_file(dev, &dev_attr_dapm_widget);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002006}
2007
2008static void snd_soc_dapm_sys_remove(struct device *dev)
2009{
Mark Brownaef90842009-05-16 17:53:16 +01002010 device_remove_file(dev, &dev_attr_dapm_widget);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002011}
2012
2013/* free all dapm widgets and resources */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002014static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002015{
2016 struct snd_soc_dapm_widget *w, *next_w;
2017 struct snd_soc_dapm_path *p, *next_p;
2018
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002019 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
2020 if (w->dapm != dapm)
2021 continue;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002022 list_del(&w->list);
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02002023 /*
2024 * remove source and sink paths associated to this widget.
2025 * While removing the path, remove reference to it from both
2026 * source and sink widgets so that path is removed only once.
2027 */
2028 list_for_each_entry_safe(p, next_p, &w->sources, list_sink) {
2029 list_del(&p->list_sink);
2030 list_del(&p->list_source);
2031 list_del(&p->list);
2032 kfree(p->long_name);
2033 kfree(p);
2034 }
2035 list_for_each_entry_safe(p, next_p, &w->sinks, list_source) {
2036 list_del(&p->list_sink);
2037 list_del(&p->list_source);
2038 list_del(&p->list);
2039 kfree(p->long_name);
2040 kfree(p);
2041 }
Stephen Warrenfad59882011-04-28 17:37:59 -06002042 kfree(w->kcontrols);
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002043 kfree(w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002044 kfree(w);
2045 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02002046}
2047
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002048static struct snd_soc_dapm_widget *dapm_find_widget(
2049 struct snd_soc_dapm_context *dapm, const char *pin,
2050 bool search_other_contexts)
2051{
2052 struct snd_soc_dapm_widget *w;
2053 struct snd_soc_dapm_widget *fallback = NULL;
2054
2055 list_for_each_entry(w, &dapm->card->widgets, list) {
2056 if (!strcmp(w->name, pin)) {
2057 if (w->dapm == dapm)
2058 return w;
2059 else
2060 fallback = w;
2061 }
2062 }
2063
2064 if (search_other_contexts)
2065 return fallback;
2066
2067 return NULL;
2068}
2069
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002070static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
Mark Brown16499232009-01-07 18:25:13 +00002071 const char *pin, int status)
Liam Girdwooda5302182008-07-07 13:35:17 +01002072{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002073 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Liam Girdwooda5302182008-07-07 13:35:17 +01002074
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002075 if (!w) {
2076 dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
2077 return -EINVAL;
Liam Girdwooda5302182008-07-07 13:35:17 +01002078 }
2079
Mark Brown1a8b2d92012-02-16 11:50:07 -08002080 if (w->connected != status)
2081 dapm_mark_dirty(w, "pin configuration");
2082
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002083 w->connected = status;
2084 if (status == 0)
2085 w->force = 0;
Mark Brown0d867332011-04-06 11:38:14 +09002086
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002087 return 0;
Liam Girdwooda5302182008-07-07 13:35:17 +01002088}
2089
Richard Purdie2b97eab2006-10-06 18:32:18 +02002090/**
Liam Girdwooda5302182008-07-07 13:35:17 +01002091 * snd_soc_dapm_sync - scan and power dapm paths
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002092 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02002093 *
2094 * Walks all dapm audio paths and powers widgets according to their
2095 * stream or path usage.
2096 *
2097 * Returns 0 for success.
2098 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002099int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002100{
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002101 int ret;
2102
Mark Brown4f4c0072011-10-07 14:29:19 +01002103 /*
2104 * Suppress early reports (eg, jacks syncing their state) to avoid
2105 * silly DAPM runs during card startup.
2106 */
2107 if (!dapm->card || !dapm->card->instantiated)
2108 return 0;
2109
Liam Girdwood3cd04342012-03-09 12:02:08 +00002110 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002111 ret = dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
2112 mutex_unlock(&dapm->card->dapm_mutex);
2113 return ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002114}
Liam Girdwooda5302182008-07-07 13:35:17 +01002115EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002116
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002117static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
Mark Brown215edda2009-09-08 18:59:05 +01002118 const struct snd_soc_dapm_route *route)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002119{
2120 struct snd_soc_dapm_path *path;
2121 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002122 struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002123 const char *sink;
Mark Brown215edda2009-09-08 18:59:05 +01002124 const char *control = route->control;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002125 const char *source;
2126 char prefixed_sink[80];
2127 char prefixed_source[80];
Richard Purdie2b97eab2006-10-06 18:32:18 +02002128 int ret = 0;
2129
Mark Brown88e8b9a2011-03-02 18:18:24 +00002130 if (dapm->codec && dapm->codec->name_prefix) {
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002131 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
2132 dapm->codec->name_prefix, route->sink);
2133 sink = prefixed_sink;
2134 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
2135 dapm->codec->name_prefix, route->source);
2136 source = prefixed_source;
2137 } else {
2138 sink = route->sink;
2139 source = route->source;
2140 }
2141
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002142 /*
2143 * find src and dest widgets over all widgets but favor a widget from
2144 * current DAPM context
2145 */
2146 list_for_each_entry(w, &dapm->card->widgets, list) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002147 if (!wsink && !(strcmp(w->name, sink))) {
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002148 wtsink = w;
2149 if (w->dapm == dapm)
2150 wsink = w;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002151 continue;
2152 }
2153 if (!wsource && !(strcmp(w->name, source))) {
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002154 wtsource = w;
2155 if (w->dapm == dapm)
2156 wsource = w;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002157 }
2158 }
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002159 /* use widget from another DAPM context if not found from this */
2160 if (!wsink)
2161 wsink = wtsink;
2162 if (!wsource)
2163 wsource = wtsource;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002164
2165 if (wsource == NULL || wsink == NULL)
2166 return -ENODEV;
2167
2168 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
2169 if (!path)
2170 return -ENOMEM;
2171
2172 path->source = wsource;
2173 path->sink = wsink;
Mark Brown215edda2009-09-08 18:59:05 +01002174 path->connected = route->connected;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002175 INIT_LIST_HEAD(&path->list);
2176 INIT_LIST_HEAD(&path->list_source);
2177 INIT_LIST_HEAD(&path->list_sink);
2178
2179 /* check for external widgets */
2180 if (wsink->id == snd_soc_dapm_input) {
2181 if (wsource->id == snd_soc_dapm_micbias ||
2182 wsource->id == snd_soc_dapm_mic ||
Rongrong Cao087d53a2009-07-10 20:13:30 +01002183 wsource->id == snd_soc_dapm_line ||
2184 wsource->id == snd_soc_dapm_output)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002185 wsink->ext = 1;
2186 }
2187 if (wsource->id == snd_soc_dapm_output) {
2188 if (wsink->id == snd_soc_dapm_spk ||
2189 wsink->id == snd_soc_dapm_hp ||
Seth Forshee1e392212007-04-16 15:36:42 +02002190 wsink->id == snd_soc_dapm_line ||
2191 wsink->id == snd_soc_dapm_input)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002192 wsource->ext = 1;
2193 }
2194
2195 /* connect static paths */
2196 if (control == NULL) {
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02002197 list_add(&path->list, &dapm->card->paths);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002198 list_add(&path->list_sink, &wsink->sources);
2199 list_add(&path->list_source, &wsource->sinks);
2200 path->connect = 1;
2201 return 0;
2202 }
2203
2204 /* connect dynamic paths */
Lu Guanqundc2bea62011-04-20 16:00:36 +08002205 switch (wsink->id) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02002206 case snd_soc_dapm_adc:
2207 case snd_soc_dapm_dac:
2208 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06002209 case snd_soc_dapm_out_drv:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002210 case snd_soc_dapm_input:
2211 case snd_soc_dapm_output:
Mark Brown1ab97c82011-11-27 16:21:51 +00002212 case snd_soc_dapm_siggen:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002213 case snd_soc_dapm_micbias:
2214 case snd_soc_dapm_vmid:
2215 case snd_soc_dapm_pre:
2216 case snd_soc_dapm_post:
Mark Brown246d0a12009-04-22 18:24:55 +01002217 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00002218 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02002219 case snd_soc_dapm_clock_supply:
Mark Brown010ff262009-08-17 17:39:22 +01002220 case snd_soc_dapm_aif_in:
2221 case snd_soc_dapm_aif_out:
Mark Brown888df392012-02-16 19:37:51 -08002222 case snd_soc_dapm_dai:
Mark Brownc74184e2012-04-04 22:12:09 +01002223 case snd_soc_dapm_dai_link:
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02002224 list_add(&path->list, &dapm->card->paths);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002225 list_add(&path->list_sink, &wsink->sources);
2226 list_add(&path->list_source, &wsource->sinks);
2227 path->connect = 1;
2228 return 0;
2229 case snd_soc_dapm_mux:
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +00002230 case snd_soc_dapm_virt_mux:
Peter Ujfalusi74155552009-01-08 13:34:29 +02002231 case snd_soc_dapm_value_mux:
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002232 ret = dapm_connect_mux(dapm, wsource, wsink, path, control,
Stephen Warren82cfecd2011-04-28 17:37:58 -06002233 &wsink->kcontrol_news[0]);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002234 if (ret != 0)
2235 goto err;
2236 break;
2237 case snd_soc_dapm_switch:
2238 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00002239 case snd_soc_dapm_mixer_named_ctl:
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002240 ret = dapm_connect_mixer(dapm, wsource, wsink, path, control);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002241 if (ret != 0)
2242 goto err;
2243 break;
2244 case snd_soc_dapm_hp:
2245 case snd_soc_dapm_mic:
2246 case snd_soc_dapm_line:
2247 case snd_soc_dapm_spk:
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02002248 list_add(&path->list, &dapm->card->paths);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002249 list_add(&path->list_sink, &wsink->sources);
2250 list_add(&path->list_source, &wsource->sinks);
2251 path->connect = 0;
2252 return 0;
2253 }
2254 return 0;
2255
2256err:
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02002257 dev_warn(dapm->dev, "asoc: no dapm match for %s --> %s --> %s\n",
2258 source, control, sink);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002259 kfree(path);
2260 return ret;
2261}
Mark Brown105f1c22008-05-13 14:52:19 +02002262
2263/**
Mark Brown105f1c22008-05-13 14:52:19 +02002264 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002265 * @dapm: DAPM context
Mark Brown105f1c22008-05-13 14:52:19 +02002266 * @route: audio routes
2267 * @num: number of routes
2268 *
2269 * Connects 2 dapm widgets together via a named audio path. The sink is
2270 * the widget receiving the audio signal, whilst the source is the sender
2271 * of the audio signal.
2272 *
2273 * Returns 0 for success else error. On error all resources can be freed
2274 * with a call to snd_soc_card_free().
2275 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002276int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
Mark Brown105f1c22008-05-13 14:52:19 +02002277 const struct snd_soc_dapm_route *route, int num)
2278{
Dan Carpenter60884c22012-04-13 22:25:43 +03002279 int i, ret = 0;
Mark Brown105f1c22008-05-13 14:52:19 +02002280
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002281 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brown105f1c22008-05-13 14:52:19 +02002282 for (i = 0; i < num; i++) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002283 ret = snd_soc_dapm_add_route(dapm, route);
Mark Brown105f1c22008-05-13 14:52:19 +02002284 if (ret < 0) {
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02002285 dev_err(dapm->dev, "Failed to add route %s->%s\n",
2286 route->source, route->sink);
Dan Carpenter60884c22012-04-13 22:25:43 +03002287 break;
Mark Brown105f1c22008-05-13 14:52:19 +02002288 }
2289 route++;
2290 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002291 mutex_unlock(&dapm->card->dapm_mutex);
Mark Brown105f1c22008-05-13 14:52:19 +02002292
Dan Carpenter60884c22012-04-13 22:25:43 +03002293 return ret;
Mark Brown105f1c22008-05-13 14:52:19 +02002294}
2295EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
2296
Mark Brownbf3a9e12011-06-13 16:42:29 +01002297static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
2298 const struct snd_soc_dapm_route *route)
2299{
2300 struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
2301 route->source,
2302 true);
2303 struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
2304 route->sink,
2305 true);
2306 struct snd_soc_dapm_path *path;
2307 int count = 0;
2308
2309 if (!source) {
2310 dev_err(dapm->dev, "Unable to find source %s for weak route\n",
2311 route->source);
2312 return -ENODEV;
2313 }
2314
2315 if (!sink) {
2316 dev_err(dapm->dev, "Unable to find sink %s for weak route\n",
2317 route->sink);
2318 return -ENODEV;
2319 }
2320
2321 if (route->control || route->connected)
2322 dev_warn(dapm->dev, "Ignoring control for weak route %s->%s\n",
2323 route->source, route->sink);
2324
2325 list_for_each_entry(path, &source->sinks, list_source) {
2326 if (path->sink == sink) {
2327 path->weak = 1;
2328 count++;
2329 }
2330 }
2331
2332 if (count == 0)
2333 dev_err(dapm->dev, "No path found for weak route %s->%s\n",
2334 route->source, route->sink);
2335 if (count > 1)
2336 dev_warn(dapm->dev, "%d paths found for weak route %s->%s\n",
2337 count, route->source, route->sink);
2338
2339 return 0;
2340}
2341
2342/**
2343 * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
2344 * @dapm: DAPM context
2345 * @route: audio routes
2346 * @num: number of routes
2347 *
2348 * Mark existing routes matching those specified in the passed array
2349 * as being weak, meaning that they are ignored for the purpose of
2350 * power decisions. The main intended use case is for sidetone paths
2351 * which couple audio between other independent paths if they are both
2352 * active in order to make the combination work better at the user
2353 * level but which aren't intended to be "used".
2354 *
2355 * Note that CODEC drivers should not use this as sidetone type paths
2356 * can frequently also be used as bypass paths.
2357 */
2358int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
2359 const struct snd_soc_dapm_route *route, int num)
2360{
2361 int i, err;
2362 int ret = 0;
2363
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002364 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brownbf3a9e12011-06-13 16:42:29 +01002365 for (i = 0; i < num; i++) {
2366 err = snd_soc_dapm_weak_route(dapm, route);
2367 if (err)
2368 ret = err;
2369 route++;
2370 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002371 mutex_unlock(&dapm->card->dapm_mutex);
Mark Brownbf3a9e12011-06-13 16:42:29 +01002372
2373 return ret;
2374}
2375EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2376
Mark Brown105f1c22008-05-13 14:52:19 +02002377/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02002378 * snd_soc_dapm_new_widgets - add new dapm widgets
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002379 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02002380 *
2381 * Checks the codec for any new dapm widgets and creates them if found.
2382 *
2383 * Returns 0 for success.
2384 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002385int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002386{
2387 struct snd_soc_dapm_widget *w;
Mark Brownb66a70d2011-02-09 18:04:11 +00002388 unsigned int val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002389
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002390 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2391
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002392 list_for_each_entry(w, &dapm->card->widgets, list)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002393 {
2394 if (w->new)
2395 continue;
2396
Stephen Warrenfad59882011-04-28 17:37:59 -06002397 if (w->num_kcontrols) {
2398 w->kcontrols = kzalloc(w->num_kcontrols *
2399 sizeof(struct snd_kcontrol *),
2400 GFP_KERNEL);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002401 if (!w->kcontrols) {
2402 mutex_unlock(&dapm->card->dapm_mutex);
Stephen Warrenfad59882011-04-28 17:37:59 -06002403 return -ENOMEM;
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002404 }
Stephen Warrenfad59882011-04-28 17:37:59 -06002405 }
2406
Richard Purdie2b97eab2006-10-06 18:32:18 +02002407 switch(w->id) {
2408 case snd_soc_dapm_switch:
2409 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00002410 case snd_soc_dapm_mixer_named_ctl:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002411 dapm_new_mixer(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002412 break;
2413 case snd_soc_dapm_mux:
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +00002414 case snd_soc_dapm_virt_mux:
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002415 case snd_soc_dapm_value_mux:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002416 dapm_new_mux(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002417 break;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002418 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06002419 case snd_soc_dapm_out_drv:
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002420 dapm_new_pga(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002421 break;
Mark Brown7ca3a182011-10-08 14:04:50 +01002422 default:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002423 break;
2424 }
Mark Brownb66a70d2011-02-09 18:04:11 +00002425
2426 /* Read the initial power state from the device */
2427 if (w->reg >= 0) {
Liam Girdwood0445bdf2011-06-13 19:37:36 +01002428 val = soc_widget_read(w, w->reg);
Mark Brownb66a70d2011-02-09 18:04:11 +00002429 val &= 1 << w->shift;
2430 if (w->invert)
2431 val = !val;
2432
2433 if (val)
2434 w->power = 1;
2435 }
2436
Richard Purdie2b97eab2006-10-06 18:32:18 +02002437 w->new = 1;
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002438
Mark Brown7508b122011-10-05 12:09:12 +01002439 dapm_mark_dirty(w, "new widget");
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002440 dapm_debugfs_add_widget(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002441 }
2442
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002443 dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002444 mutex_unlock(&dapm->card->dapm_mutex);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002445 return 0;
2446}
2447EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
2448
2449/**
2450 * snd_soc_dapm_get_volsw - dapm mixer get callback
2451 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002452 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02002453 *
2454 * Callback to get the value of a dapm mixer control.
2455 *
2456 * Returns 0 for success.
2457 */
2458int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
2459 struct snd_ctl_elem_value *ucontrol)
2460{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002461 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2462 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
Jon Smirl4eaa9812008-07-29 11:42:26 +01002463 struct soc_mixer_control *mc =
2464 (struct soc_mixer_control *)kcontrol->private_value;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002465 unsigned int reg = mc->reg;
2466 unsigned int shift = mc->shift;
2467 unsigned int rshift = mc->rshift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002468 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002469 unsigned int invert = mc->invert;
2470 unsigned int mask = (1 << fls(max)) - 1;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002471
Richard Purdie2b97eab2006-10-06 18:32:18 +02002472 ucontrol->value.integer.value[0] =
2473 (snd_soc_read(widget->codec, reg) >> shift) & mask;
2474 if (shift != rshift)
2475 ucontrol->value.integer.value[1] =
2476 (snd_soc_read(widget->codec, reg) >> rshift) & mask;
2477 if (invert) {
2478 ucontrol->value.integer.value[0] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002479 max - ucontrol->value.integer.value[0];
Richard Purdie2b97eab2006-10-06 18:32:18 +02002480 if (shift != rshift)
2481 ucontrol->value.integer.value[1] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002482 max - ucontrol->value.integer.value[1];
Richard Purdie2b97eab2006-10-06 18:32:18 +02002483 }
2484
2485 return 0;
2486}
2487EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
2488
2489/**
2490 * snd_soc_dapm_put_volsw - dapm mixer set callback
2491 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002492 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02002493 *
2494 * Callback to set the value of a dapm mixer control.
2495 *
2496 * Returns 0 for success.
2497 */
2498int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
2499 struct snd_ctl_elem_value *ucontrol)
2500{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002501 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2502 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2503 struct snd_soc_codec *codec = widget->codec;
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002504 struct snd_soc_card *card = codec->card;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002505 struct soc_mixer_control *mc =
2506 (struct soc_mixer_control *)kcontrol->private_value;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002507 unsigned int reg = mc->reg;
2508 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002509 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002510 unsigned int mask = (1 << fls(max)) - 1;
2511 unsigned int invert = mc->invert;
Stephen Warrene9cf7042011-01-27 14:54:05 -07002512 unsigned int val;
Mark Brown97404f22010-12-14 16:13:57 +00002513 int connect, change;
2514 struct snd_soc_dapm_update update;
Stephen Warrenfafd2172011-04-28 17:38:00 -06002515 int wi;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002516
2517 val = (ucontrol->value.integer.value[0] & mask);
2518
2519 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002520 val = max - val;
Stephen Warrene9cf7042011-01-27 14:54:05 -07002521 mask = mask << shift;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002522 val = val << shift;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002523
Stephen Warrenfafd2172011-04-28 17:38:00 -06002524 if (val)
2525 /* new connection */
2526 connect = invert ? 0 : 1;
2527 else
2528 /* old connection must be powered down */
2529 connect = invert ? 1 : 0;
2530
Liam Girdwood3cd04342012-03-09 12:02:08 +00002531 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002532
Stephen Warrene9cf7042011-01-27 14:54:05 -07002533 change = snd_soc_test_bits(widget->codec, reg, mask, val);
Mark Brown97404f22010-12-14 16:13:57 +00002534 if (change) {
Stephen Warrenfafd2172011-04-28 17:38:00 -06002535 for (wi = 0; wi < wlist->num_widgets; wi++) {
2536 widget = wlist->widgets[wi];
Mark Brown283375c2009-12-07 18:09:03 +00002537
Stephen Warrenfafd2172011-04-28 17:38:00 -06002538 widget->value = val;
Mark Brown97404f22010-12-14 16:13:57 +00002539
Stephen Warrenfafd2172011-04-28 17:38:00 -06002540 update.kcontrol = kcontrol;
2541 update.widget = widget;
2542 update.reg = reg;
2543 update.mask = mask;
2544 update.val = val;
2545 widget->dapm->update = &update;
Mark Brown97404f22010-12-14 16:13:57 +00002546
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002547 soc_dapm_mixer_update_power(widget, kcontrol, connect);
Stephen Warrenfafd2172011-04-28 17:38:00 -06002548
2549 widget->dapm->update = NULL;
2550 }
Mark Brown283375c2009-12-07 18:09:03 +00002551 }
2552
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002553 mutex_unlock(&card->dapm_mutex);
Mark Brown97404f22010-12-14 16:13:57 +00002554 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002555}
2556EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
2557
2558/**
2559 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
2560 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002561 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02002562 *
2563 * Callback to get the value of a dapm enumerated double mixer control.
2564 *
2565 * Returns 0 for success.
2566 */
2567int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
2568 struct snd_ctl_elem_value *ucontrol)
2569{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002570 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2571 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
Richard Purdie2b97eab2006-10-06 18:32:18 +02002572 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002573 unsigned int val, bitmask;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002574
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002575 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002576 ;
2577 val = snd_soc_read(widget->codec, e->reg);
2578 ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
2579 if (e->shift_l != e->shift_r)
2580 ucontrol->value.enumerated.item[1] =
2581 (val >> e->shift_r) & (bitmask - 1);
2582
2583 return 0;
2584}
2585EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
2586
2587/**
2588 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
2589 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002590 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02002591 *
2592 * Callback to set the value of a dapm enumerated double mixer control.
2593 *
2594 * Returns 0 for success.
2595 */
2596int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
2597 struct snd_ctl_elem_value *ucontrol)
2598{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002599 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2600 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2601 struct snd_soc_codec *codec = widget->codec;
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002602 struct snd_soc_card *card = codec->card;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002603 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Mark Brown3a655772009-10-05 17:23:30 +01002604 unsigned int val, mux, change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002605 unsigned int mask, bitmask;
Mark Brown97404f22010-12-14 16:13:57 +00002606 struct snd_soc_dapm_update update;
Stephen Warrenfafd2172011-04-28 17:38:00 -06002607 int wi;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002608
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002609 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002610 ;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002611 if (ucontrol->value.enumerated.item[0] > e->max - 1)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002612 return -EINVAL;
2613 mux = ucontrol->value.enumerated.item[0];
2614 val = mux << e->shift_l;
2615 mask = (bitmask - 1) << e->shift_l;
2616 if (e->shift_l != e->shift_r) {
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002617 if (ucontrol->value.enumerated.item[1] > e->max - 1)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002618 return -EINVAL;
2619 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
2620 mask |= (bitmask - 1) << e->shift_r;
2621 }
2622
Liam Girdwood3cd04342012-03-09 12:02:08 +00002623 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Stephen Warrenfafd2172011-04-28 17:38:00 -06002624
Mark Brown3a655772009-10-05 17:23:30 +01002625 change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
Stephen Warrenfafd2172011-04-28 17:38:00 -06002626 if (change) {
2627 for (wi = 0; wi < wlist->num_widgets; wi++) {
2628 widget = wlist->widgets[wi];
Mark Brown97404f22010-12-14 16:13:57 +00002629
Stephen Warrenfafd2172011-04-28 17:38:00 -06002630 widget->value = val;
Mark Brown97404f22010-12-14 16:13:57 +00002631
Stephen Warrenfafd2172011-04-28 17:38:00 -06002632 update.kcontrol = kcontrol;
2633 update.widget = widget;
2634 update.reg = e->reg;
2635 update.mask = mask;
2636 update.val = val;
2637 widget->dapm->update = &update;
Mark Brown1642e3d2009-10-05 16:24:26 +01002638
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002639 soc_dapm_mux_update_power(widget, kcontrol, mux, e);
Mark Brown1642e3d2009-10-05 16:24:26 +01002640
Stephen Warrenfafd2172011-04-28 17:38:00 -06002641 widget->dapm->update = NULL;
2642 }
2643 }
2644
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002645 mutex_unlock(&card->dapm_mutex);
Mark Brown97404f22010-12-14 16:13:57 +00002646 return change;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002647}
2648EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
2649
2650/**
Mark Brownd2b247a2009-10-06 15:21:04 +01002651 * snd_soc_dapm_get_enum_virt - Get virtual DAPM mux
2652 * @kcontrol: mixer control
2653 * @ucontrol: control element information
2654 *
2655 * Returns 0 for success.
2656 */
2657int snd_soc_dapm_get_enum_virt(struct snd_kcontrol *kcontrol,
2658 struct snd_ctl_elem_value *ucontrol)
2659{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002660 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2661 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
Mark Brownd2b247a2009-10-06 15:21:04 +01002662
2663 ucontrol->value.enumerated.item[0] = widget->value;
2664
2665 return 0;
2666}
2667EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_virt);
2668
2669/**
2670 * snd_soc_dapm_put_enum_virt - Set virtual DAPM mux
2671 * @kcontrol: mixer control
2672 * @ucontrol: control element information
2673 *
2674 * Returns 0 for success.
2675 */
2676int snd_soc_dapm_put_enum_virt(struct snd_kcontrol *kcontrol,
2677 struct snd_ctl_elem_value *ucontrol)
2678{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002679 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2680 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2681 struct snd_soc_codec *codec = widget->codec;
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002682 struct snd_soc_card *card = codec->card;
Mark Brownd2b247a2009-10-06 15:21:04 +01002683 struct soc_enum *e =
2684 (struct soc_enum *)kcontrol->private_value;
2685 int change;
2686 int ret = 0;
Stephen Warrenfafd2172011-04-28 17:38:00 -06002687 int wi;
Mark Brownd2b247a2009-10-06 15:21:04 +01002688
2689 if (ucontrol->value.enumerated.item[0] >= e->max)
2690 return -EINVAL;
2691
Liam Girdwood3cd04342012-03-09 12:02:08 +00002692 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Mark Brownd2b247a2009-10-06 15:21:04 +01002693
2694 change = widget->value != ucontrol->value.enumerated.item[0];
Stephen Warrenfafd2172011-04-28 17:38:00 -06002695 if (change) {
2696 for (wi = 0; wi < wlist->num_widgets; wi++) {
2697 widget = wlist->widgets[wi];
Mark Brownd2b247a2009-10-06 15:21:04 +01002698
Stephen Warrenfafd2172011-04-28 17:38:00 -06002699 widget->value = ucontrol->value.enumerated.item[0];
2700
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002701 soc_dapm_mux_update_power(widget, kcontrol, widget->value, e);
Stephen Warrenfafd2172011-04-28 17:38:00 -06002702 }
2703 }
2704
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002705 mutex_unlock(&card->dapm_mutex);
Mark Brownd2b247a2009-10-06 15:21:04 +01002706 return ret;
2707}
2708EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_virt);
2709
2710/**
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002711 * snd_soc_dapm_get_value_enum_double - dapm semi enumerated double mixer get
2712 * callback
2713 * @kcontrol: mixer control
2714 * @ucontrol: control element information
2715 *
2716 * Callback to get the value of a dapm semi enumerated double mixer control.
2717 *
2718 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2719 * used for handling bitfield coded enumeration for example.
2720 *
2721 * Returns 0 for success.
2722 */
2723int snd_soc_dapm_get_value_enum_double(struct snd_kcontrol *kcontrol,
2724 struct snd_ctl_elem_value *ucontrol)
2725{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002726 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2727 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
Peter Ujfalusi74155552009-01-08 13:34:29 +02002728 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002729 unsigned int reg_val, val, mux;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002730
2731 reg_val = snd_soc_read(widget->codec, e->reg);
2732 val = (reg_val >> e->shift_l) & e->mask;
2733 for (mux = 0; mux < e->max; mux++) {
2734 if (val == e->values[mux])
2735 break;
2736 }
2737 ucontrol->value.enumerated.item[0] = mux;
2738 if (e->shift_l != e->shift_r) {
2739 val = (reg_val >> e->shift_r) & e->mask;
2740 for (mux = 0; mux < e->max; mux++) {
2741 if (val == e->values[mux])
2742 break;
2743 }
2744 ucontrol->value.enumerated.item[1] = mux;
2745 }
2746
2747 return 0;
2748}
2749EXPORT_SYMBOL_GPL(snd_soc_dapm_get_value_enum_double);
2750
2751/**
2752 * snd_soc_dapm_put_value_enum_double - dapm semi enumerated double mixer set
2753 * callback
2754 * @kcontrol: mixer control
2755 * @ucontrol: control element information
2756 *
2757 * Callback to set the value of a dapm semi enumerated double mixer control.
2758 *
2759 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2760 * used for handling bitfield coded enumeration for example.
2761 *
2762 * Returns 0 for success.
2763 */
2764int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
2765 struct snd_ctl_elem_value *ucontrol)
2766{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002767 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2768 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2769 struct snd_soc_codec *codec = widget->codec;
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002770 struct snd_soc_card *card = codec->card;
Peter Ujfalusi74155552009-01-08 13:34:29 +02002771 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Mark Brown3a655772009-10-05 17:23:30 +01002772 unsigned int val, mux, change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002773 unsigned int mask;
Mark Brown97404f22010-12-14 16:13:57 +00002774 struct snd_soc_dapm_update update;
Stephen Warrenfafd2172011-04-28 17:38:00 -06002775 int wi;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002776
2777 if (ucontrol->value.enumerated.item[0] > e->max - 1)
2778 return -EINVAL;
2779 mux = ucontrol->value.enumerated.item[0];
2780 val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
2781 mask = e->mask << e->shift_l;
2782 if (e->shift_l != e->shift_r) {
2783 if (ucontrol->value.enumerated.item[1] > e->max - 1)
2784 return -EINVAL;
2785 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
2786 mask |= e->mask << e->shift_r;
2787 }
2788
Liam Girdwood3cd04342012-03-09 12:02:08 +00002789 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Stephen Warrenfafd2172011-04-28 17:38:00 -06002790
Mark Brown3a655772009-10-05 17:23:30 +01002791 change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
Stephen Warrenfafd2172011-04-28 17:38:00 -06002792 if (change) {
2793 for (wi = 0; wi < wlist->num_widgets; wi++) {
2794 widget = wlist->widgets[wi];
Mark Brown97404f22010-12-14 16:13:57 +00002795
Stephen Warrenfafd2172011-04-28 17:38:00 -06002796 widget->value = val;
Mark Brown97404f22010-12-14 16:13:57 +00002797
Stephen Warrenfafd2172011-04-28 17:38:00 -06002798 update.kcontrol = kcontrol;
2799 update.widget = widget;
2800 update.reg = e->reg;
2801 update.mask = mask;
2802 update.val = val;
2803 widget->dapm->update = &update;
Mark Brown1642e3d2009-10-05 16:24:26 +01002804
Liam Girdwood4edbb3452012-03-07 10:38:27 +00002805 soc_dapm_mux_update_power(widget, kcontrol, mux, e);
Mark Brown1642e3d2009-10-05 16:24:26 +01002806
Stephen Warrenfafd2172011-04-28 17:38:00 -06002807 widget->dapm->update = NULL;
2808 }
2809 }
2810
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002811 mutex_unlock(&card->dapm_mutex);
Mark Brown97404f22010-12-14 16:13:57 +00002812 return change;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002813}
2814EXPORT_SYMBOL_GPL(snd_soc_dapm_put_value_enum_double);
2815
2816/**
Mark Brown8b37dbd2009-02-28 21:14:20 +00002817 * snd_soc_dapm_info_pin_switch - Info for a pin switch
2818 *
2819 * @kcontrol: mixer control
2820 * @uinfo: control element information
2821 *
2822 * Callback to provide information about a pin switch control.
2823 */
2824int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
2825 struct snd_ctl_elem_info *uinfo)
2826{
2827 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2828 uinfo->count = 1;
2829 uinfo->value.integer.min = 0;
2830 uinfo->value.integer.max = 1;
2831
2832 return 0;
2833}
2834EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
2835
2836/**
2837 * snd_soc_dapm_get_pin_switch - Get information for a pin switch
2838 *
2839 * @kcontrol: mixer control
2840 * @ucontrol: Value
2841 */
2842int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
2843 struct snd_ctl_elem_value *ucontrol)
2844{
Mark Brown48a8c392012-02-14 17:11:15 -08002845 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002846 const char *pin = (const char *)kcontrol->private_value;
2847
Liam Girdwood3cd04342012-03-09 12:02:08 +00002848 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002849
2850 ucontrol->value.integer.value[0] =
Mark Brown48a8c392012-02-14 17:11:15 -08002851 snd_soc_dapm_get_pin_status(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002852
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002853 mutex_unlock(&card->dapm_mutex);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002854
2855 return 0;
2856}
2857EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
2858
2859/**
2860 * snd_soc_dapm_put_pin_switch - Set information for a pin switch
2861 *
2862 * @kcontrol: mixer control
2863 * @ucontrol: Value
2864 */
2865int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
2866 struct snd_ctl_elem_value *ucontrol)
2867{
Mark Brown48a8c392012-02-14 17:11:15 -08002868 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002869 const char *pin = (const char *)kcontrol->private_value;
2870
Liam Girdwood3cd04342012-03-09 12:02:08 +00002871 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002872
2873 if (ucontrol->value.integer.value[0])
Mark Brown48a8c392012-02-14 17:11:15 -08002874 snd_soc_dapm_enable_pin(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002875 else
Mark Brown48a8c392012-02-14 17:11:15 -08002876 snd_soc_dapm_disable_pin(&card->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002877
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002878 mutex_unlock(&card->dapm_mutex);
2879
Mark Brown48a8c392012-02-14 17:11:15 -08002880 snd_soc_dapm_sync(&card->dapm);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002881 return 0;
2882}
2883EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
2884
Mark Brown5ba06fc2012-02-16 11:07:13 -08002885static struct snd_soc_dapm_widget *
2886snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
2887 const struct snd_soc_dapm_widget *widget)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002888{
2889 struct snd_soc_dapm_widget *w;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002890 size_t name_len;
Mark Brown62ea8742012-01-21 21:14:48 +00002891 int ret;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002892
2893 if ((w = dapm_cnew_widget(widget)) == NULL)
Mark Brown5ba06fc2012-02-16 11:07:13 -08002894 return NULL;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002895
Mark Brown62ea8742012-01-21 21:14:48 +00002896 switch (w->id) {
2897 case snd_soc_dapm_regulator_supply:
Liam Girdwooda3cc0562012-03-09 17:20:16 +00002898 w->regulator = devm_regulator_get(dapm->dev, w->name);
2899 if (IS_ERR(w->regulator)) {
2900 ret = PTR_ERR(w->regulator);
Mark Brown62ea8742012-01-21 21:14:48 +00002901 dev_err(dapm->dev, "Failed to request %s: %d\n",
2902 w->name, ret);
Mark Brown5ba06fc2012-02-16 11:07:13 -08002903 return NULL;
Mark Brown62ea8742012-01-21 21:14:48 +00002904 }
2905 break;
Ola Liljad7e7eb92012-05-24 15:26:25 +02002906 case snd_soc_dapm_clock_supply:
Mark Brown165961e2012-06-05 10:44:23 +01002907#ifdef CONFIG_CLKDEV_LOOKUP
Mark Brown695594f12012-06-04 08:14:13 +01002908 w->clk = devm_clk_get(dapm->dev, w->name);
Ola Liljad7e7eb92012-05-24 15:26:25 +02002909 if (IS_ERR(w->clk)) {
2910 ret = PTR_ERR(w->clk);
2911 dev_err(dapm->dev, "Failed to request %s: %d\n",
2912 w->name, ret);
2913 return NULL;
2914 }
Mark Brownec029952012-06-04 08:16:20 +01002915#else
2916 return NULL;
2917#endif
Ola Liljad7e7eb92012-05-24 15:26:25 +02002918 break;
Mark Brown62ea8742012-01-21 21:14:48 +00002919 default:
2920 break;
2921 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02002922
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002923 name_len = strlen(widget->name) + 1;
Mark Brown88e8b9a2011-03-02 18:18:24 +00002924 if (dapm->codec && dapm->codec->name_prefix)
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002925 name_len += 1 + strlen(dapm->codec->name_prefix);
2926 w->name = kmalloc(name_len, GFP_KERNEL);
2927 if (w->name == NULL) {
2928 kfree(w);
Mark Brown5ba06fc2012-02-16 11:07:13 -08002929 return NULL;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002930 }
Mark Brown88e8b9a2011-03-02 18:18:24 +00002931 if (dapm->codec && dapm->codec->name_prefix)
Mark Brown888df392012-02-16 19:37:51 -08002932 snprintf((char *)w->name, name_len, "%s %s",
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002933 dapm->codec->name_prefix, widget->name);
2934 else
Mark Brown888df392012-02-16 19:37:51 -08002935 snprintf((char *)w->name, name_len, "%s", widget->name);
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002936
Mark Brown7ca3a182011-10-08 14:04:50 +01002937 switch (w->id) {
2938 case snd_soc_dapm_switch:
2939 case snd_soc_dapm_mixer:
2940 case snd_soc_dapm_mixer_named_ctl:
2941 w->power_check = dapm_generic_check_power;
2942 break;
2943 case snd_soc_dapm_mux:
2944 case snd_soc_dapm_virt_mux:
2945 case snd_soc_dapm_value_mux:
2946 w->power_check = dapm_generic_check_power;
2947 break;
2948 case snd_soc_dapm_adc:
2949 case snd_soc_dapm_aif_out:
2950 w->power_check = dapm_adc_check_power;
2951 break;
2952 case snd_soc_dapm_dac:
2953 case snd_soc_dapm_aif_in:
2954 w->power_check = dapm_dac_check_power;
2955 break;
2956 case snd_soc_dapm_pga:
2957 case snd_soc_dapm_out_drv:
2958 case snd_soc_dapm_input:
2959 case snd_soc_dapm_output:
2960 case snd_soc_dapm_micbias:
2961 case snd_soc_dapm_spk:
2962 case snd_soc_dapm_hp:
2963 case snd_soc_dapm_mic:
2964 case snd_soc_dapm_line:
Mark Brownc74184e2012-04-04 22:12:09 +01002965 case snd_soc_dapm_dai_link:
Mark Brown7ca3a182011-10-08 14:04:50 +01002966 w->power_check = dapm_generic_check_power;
2967 break;
2968 case snd_soc_dapm_supply:
Mark Brown62ea8742012-01-21 21:14:48 +00002969 case snd_soc_dapm_regulator_supply:
Ola Liljad7e7eb92012-05-24 15:26:25 +02002970 case snd_soc_dapm_clock_supply:
Mark Brown7ca3a182011-10-08 14:04:50 +01002971 w->power_check = dapm_supply_check_power;
2972 break;
Mark Brown888df392012-02-16 19:37:51 -08002973 case snd_soc_dapm_dai:
2974 w->power_check = dapm_dai_check_power;
2975 break;
Mark Brown7ca3a182011-10-08 14:04:50 +01002976 default:
2977 w->power_check = dapm_always_on_check_power;
2978 break;
2979 }
2980
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002981 dapm->n_widgets++;
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002982 w->dapm = dapm;
2983 w->codec = dapm->codec;
Liam Girdwoodb7950642011-07-04 22:10:52 +01002984 w->platform = dapm->platform;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002985 INIT_LIST_HEAD(&w->sources);
2986 INIT_LIST_HEAD(&w->sinks);
2987 INIT_LIST_HEAD(&w->list);
Mark Browndb432b42011-10-03 21:06:40 +01002988 INIT_LIST_HEAD(&w->dirty);
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002989 list_add(&w->list, &dapm->card->widgets);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002990
2991 /* machine layer set ups unconnected pins and insertions */
2992 w->connected = 1;
Mark Brown5ba06fc2012-02-16 11:07:13 -08002993 return w;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002994}
Richard Purdie2b97eab2006-10-06 18:32:18 +02002995
2996/**
Mark Brown4ba13272008-05-13 14:51:19 +02002997 * snd_soc_dapm_new_controls - create new dapm controls
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002998 * @dapm: DAPM context
Mark Brown4ba13272008-05-13 14:51:19 +02002999 * @widget: widget array
3000 * @num: number of widgets
3001 *
3002 * Creates new DAPM controls based upon the templates.
3003 *
3004 * Returns 0 for success else error.
3005 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003006int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
Mark Brown4ba13272008-05-13 14:51:19 +02003007 const struct snd_soc_dapm_widget *widget,
3008 int num)
3009{
Mark Brown5ba06fc2012-02-16 11:07:13 -08003010 struct snd_soc_dapm_widget *w;
3011 int i;
Dan Carpenter60884c22012-04-13 22:25:43 +03003012 int ret = 0;
Mark Brown4ba13272008-05-13 14:51:19 +02003013
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003014 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
Mark Brown4ba13272008-05-13 14:51:19 +02003015 for (i = 0; i < num; i++) {
Mark Brown5ba06fc2012-02-16 11:07:13 -08003016 w = snd_soc_dapm_new_control(dapm, widget);
3017 if (!w) {
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02003018 dev_err(dapm->dev,
Mark Brown5ba06fc2012-02-16 11:07:13 -08003019 "ASoC: Failed to create DAPM control %s\n",
3020 widget->name);
Dan Carpenter60884c22012-04-13 22:25:43 +03003021 ret = -ENOMEM;
3022 break;
Mark Brownb8b33cb2008-12-18 11:19:30 +00003023 }
Mark Brown4ba13272008-05-13 14:51:19 +02003024 widget++;
3025 }
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003026 mutex_unlock(&dapm->card->dapm_mutex);
Dan Carpenter60884c22012-04-13 22:25:43 +03003027 return ret;
Mark Brown4ba13272008-05-13 14:51:19 +02003028}
3029EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
3030
Mark Brownc74184e2012-04-04 22:12:09 +01003031static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
3032 struct snd_kcontrol *kcontrol, int event)
3033{
3034 struct snd_soc_dapm_path *source_p, *sink_p;
3035 struct snd_soc_dai *source, *sink;
3036 const struct snd_soc_pcm_stream *config = w->params;
3037 struct snd_pcm_substream substream;
Mark Brown9747cec2012-04-26 19:12:21 +01003038 struct snd_pcm_hw_params *params = NULL;
Mark Brownc74184e2012-04-04 22:12:09 +01003039 u64 fmt;
3040 int ret;
3041
3042 BUG_ON(!config);
3043 BUG_ON(list_empty(&w->sources) || list_empty(&w->sinks));
3044
3045 /* We only support a single source and sink, pick the first */
3046 source_p = list_first_entry(&w->sources, struct snd_soc_dapm_path,
3047 list_sink);
3048 sink_p = list_first_entry(&w->sinks, struct snd_soc_dapm_path,
3049 list_source);
3050
3051 BUG_ON(!source_p || !sink_p);
3052 BUG_ON(!sink_p->source || !source_p->sink);
3053 BUG_ON(!source_p->source || !sink_p->sink);
3054
3055 source = source_p->source->priv;
3056 sink = sink_p->sink->priv;
3057
3058 /* Be a little careful as we don't want to overflow the mask array */
3059 if (config->formats) {
3060 fmt = ffs(config->formats) - 1;
3061 } else {
Fabio Estevam516541a2012-04-16 10:53:09 -03003062 dev_warn(w->dapm->dev, "Invalid format %llx specified\n",
Mark Brownc74184e2012-04-04 22:12:09 +01003063 config->formats);
3064 fmt = 0;
3065 }
3066
3067 /* Currently very limited parameter selection */
Mark Brown9747cec2012-04-26 19:12:21 +01003068 params = kzalloc(sizeof(*params), GFP_KERNEL);
3069 if (!params) {
3070 ret = -ENOMEM;
3071 goto out;
3072 }
3073 snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
Mark Brownc74184e2012-04-04 22:12:09 +01003074
Mark Brown9747cec2012-04-26 19:12:21 +01003075 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
Mark Brownc74184e2012-04-04 22:12:09 +01003076 config->rate_min;
Mark Brown9747cec2012-04-26 19:12:21 +01003077 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
Mark Brownc74184e2012-04-04 22:12:09 +01003078 config->rate_max;
3079
Mark Brown9747cec2012-04-26 19:12:21 +01003080 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
Mark Brownc74184e2012-04-04 22:12:09 +01003081 = config->channels_min;
Mark Brown9747cec2012-04-26 19:12:21 +01003082 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
Mark Brownc74184e2012-04-04 22:12:09 +01003083 = config->channels_max;
3084
3085 memset(&substream, 0, sizeof(substream));
3086
3087 switch (event) {
3088 case SND_SOC_DAPM_PRE_PMU:
3089 if (source->driver->ops && source->driver->ops->hw_params) {
3090 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3091 ret = source->driver->ops->hw_params(&substream,
Mark Brown9747cec2012-04-26 19:12:21 +01003092 params, source);
Mark Brownc74184e2012-04-04 22:12:09 +01003093 if (ret != 0) {
3094 dev_err(source->dev,
3095 "hw_params() failed: %d\n", ret);
Mark Brown9747cec2012-04-26 19:12:21 +01003096 goto out;
Mark Brownc74184e2012-04-04 22:12:09 +01003097 }
3098 }
3099
3100 if (sink->driver->ops && sink->driver->ops->hw_params) {
3101 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
Mark Brown9747cec2012-04-26 19:12:21 +01003102 ret = sink->driver->ops->hw_params(&substream, params,
Mark Brownc74184e2012-04-04 22:12:09 +01003103 sink);
3104 if (ret != 0) {
3105 dev_err(sink->dev,
3106 "hw_params() failed: %d\n", ret);
Mark Brown9747cec2012-04-26 19:12:21 +01003107 goto out;
Mark Brownc74184e2012-04-04 22:12:09 +01003108 }
3109 }
3110 break;
3111
3112 case SND_SOC_DAPM_POST_PMU:
3113 ret = snd_soc_dai_digital_mute(sink, 0);
3114 if (ret != 0 && ret != -ENOTSUPP)
3115 dev_warn(sink->dev, "Failed to unmute: %d\n", ret);
Mark Brown9747cec2012-04-26 19:12:21 +01003116 ret = 0;
Mark Brownc74184e2012-04-04 22:12:09 +01003117 break;
3118
3119 case SND_SOC_DAPM_PRE_PMD:
3120 ret = snd_soc_dai_digital_mute(sink, 1);
3121 if (ret != 0 && ret != -ENOTSUPP)
3122 dev_warn(sink->dev, "Failed to mute: %d\n", ret);
Mark Brown9747cec2012-04-26 19:12:21 +01003123 ret = 0;
Mark Brownc74184e2012-04-04 22:12:09 +01003124 break;
3125
3126 default:
3127 BUG();
3128 return -EINVAL;
3129 }
3130
Mark Brown9747cec2012-04-26 19:12:21 +01003131out:
3132 kfree(params);
3133 return ret;
Mark Brownc74184e2012-04-04 22:12:09 +01003134}
3135
3136int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
3137 const struct snd_soc_pcm_stream *params,
3138 struct snd_soc_dapm_widget *source,
3139 struct snd_soc_dapm_widget *sink)
3140{
3141 struct snd_soc_dapm_route routes[2];
3142 struct snd_soc_dapm_widget template;
3143 struct snd_soc_dapm_widget *w;
3144 size_t len;
3145 char *link_name;
3146
3147 len = strlen(source->name) + strlen(sink->name) + 2;
3148 link_name = devm_kzalloc(card->dev, len, GFP_KERNEL);
3149 if (!link_name)
3150 return -ENOMEM;
3151 snprintf(link_name, len, "%s-%s", source->name, sink->name);
3152
3153 memset(&template, 0, sizeof(template));
3154 template.reg = SND_SOC_NOPM;
3155 template.id = snd_soc_dapm_dai_link;
3156 template.name = link_name;
3157 template.event = snd_soc_dai_link_event;
3158 template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
3159 SND_SOC_DAPM_PRE_PMD;
3160
3161 dev_dbg(card->dev, "adding %s widget\n", link_name);
3162
3163 w = snd_soc_dapm_new_control(&card->dapm, &template);
3164 if (!w) {
3165 dev_err(card->dev, "Failed to create %s widget\n",
3166 link_name);
3167 return -ENOMEM;
3168 }
3169
3170 w->params = params;
3171
3172 memset(&routes, 0, sizeof(routes));
3173
3174 routes[0].source = source->name;
3175 routes[0].sink = link_name;
3176 routes[1].source = link_name;
3177 routes[1].sink = sink->name;
3178
3179 return snd_soc_dapm_add_routes(&card->dapm, routes,
3180 ARRAY_SIZE(routes));
3181}
3182
Mark Brown888df392012-02-16 19:37:51 -08003183int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
3184 struct snd_soc_dai *dai)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003185{
Mark Brown888df392012-02-16 19:37:51 -08003186 struct snd_soc_dapm_widget template;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003187 struct snd_soc_dapm_widget *w;
3188
Mark Brown888df392012-02-16 19:37:51 -08003189 WARN_ON(dapm->dev != dai->dev);
3190
3191 memset(&template, 0, sizeof(template));
3192 template.reg = SND_SOC_NOPM;
3193
3194 if (dai->driver->playback.stream_name) {
3195 template.id = snd_soc_dapm_dai;
3196 template.name = dai->driver->playback.stream_name;
3197 template.sname = dai->driver->playback.stream_name;
3198
3199 dev_dbg(dai->dev, "adding %s widget\n",
3200 template.name);
3201
3202 w = snd_soc_dapm_new_control(dapm, &template);
3203 if (!w) {
3204 dev_err(dapm->dev, "Failed to create %s widget\n",
3205 dai->driver->playback.stream_name);
3206 }
3207
3208 w->priv = dai;
3209 dai->playback_widget = w;
3210 }
3211
3212 if (dai->driver->capture.stream_name) {
3213 template.id = snd_soc_dapm_dai;
3214 template.name = dai->driver->capture.stream_name;
3215 template.sname = dai->driver->capture.stream_name;
3216
3217 dev_dbg(dai->dev, "adding %s widget\n",
3218 template.name);
3219
3220 w = snd_soc_dapm_new_control(dapm, &template);
3221 if (!w) {
3222 dev_err(dapm->dev, "Failed to create %s widget\n",
3223 dai->driver->capture.stream_name);
3224 }
3225
3226 w->priv = dai;
3227 dai->capture_widget = w;
3228 }
3229
3230 return 0;
3231}
3232
3233int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
3234{
3235 struct snd_soc_dapm_widget *dai_w, *w;
3236 struct snd_soc_dai *dai;
3237 struct snd_soc_dapm_route r;
3238
3239 memset(&r, 0, sizeof(r));
3240
3241 /* For each DAI widget... */
3242 list_for_each_entry(dai_w, &card->widgets, list) {
3243 if (dai_w->id != snd_soc_dapm_dai)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003244 continue;
Mark Brown888df392012-02-16 19:37:51 -08003245
3246 dai = dai_w->priv;
3247
3248 /* ...find all widgets with the same stream and link them */
3249 list_for_each_entry(w, &card->widgets, list) {
3250 if (w->dapm != dai_w->dapm)
3251 continue;
3252
3253 if (w->id == snd_soc_dapm_dai)
3254 continue;
3255
3256 if (!w->sname)
3257 continue;
3258
3259 if (dai->driver->playback.stream_name &&
3260 strstr(w->sname,
3261 dai->driver->playback.stream_name)) {
3262 r.source = dai->playback_widget->name;
3263 r.sink = w->name;
3264 dev_dbg(dai->dev, "%s -> %s\n",
3265 r.source, r.sink);
3266
3267 snd_soc_dapm_add_route(w->dapm, &r);
3268 }
3269
3270 if (dai->driver->capture.stream_name &&
3271 strstr(w->sname,
3272 dai->driver->capture.stream_name)) {
3273 r.source = w->name;
3274 r.sink = dai->capture_widget->name;
3275 dev_dbg(dai->dev, "%s -> %s\n",
3276 r.source, r.sink);
3277
3278 snd_soc_dapm_add_route(w->dapm, &r);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003279 }
3280 }
3281 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02003282
Mark Brown888df392012-02-16 19:37:51 -08003283 return 0;
3284}
Liam Girdwood64a648c2011-07-25 11:15:15 +01003285
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003286static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3287 int event)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003288{
Mark Brown7bd3a6f2012-02-16 15:03:27 -08003289
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003290 struct snd_soc_dapm_widget *w_cpu, *w_codec;
3291 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
3292 struct snd_soc_dai *codec_dai = rtd->codec_dai;
Mark Brown7bd3a6f2012-02-16 15:03:27 -08003293
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003294 if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
3295 w_cpu = cpu_dai->playback_widget;
3296 w_codec = codec_dai->playback_widget;
3297 } else {
3298 w_cpu = cpu_dai->capture_widget;
3299 w_codec = codec_dai->capture_widget;
Richard Purdie2b97eab2006-10-06 18:32:18 +02003300 }
3301
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003302 if (w_cpu) {
3303
3304 dapm_mark_dirty(w_cpu, "stream event");
3305
3306 switch (event) {
3307 case SND_SOC_DAPM_STREAM_START:
3308 w_cpu->active = 1;
3309 break;
3310 case SND_SOC_DAPM_STREAM_STOP:
3311 w_cpu->active = 0;
3312 break;
3313 case SND_SOC_DAPM_STREAM_SUSPEND:
3314 case SND_SOC_DAPM_STREAM_RESUME:
3315 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
3316 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
3317 break;
3318 }
3319 }
3320
3321 if (w_codec) {
3322
3323 dapm_mark_dirty(w_codec, "stream event");
3324
3325 switch (event) {
3326 case SND_SOC_DAPM_STREAM_START:
3327 w_codec->active = 1;
3328 break;
3329 case SND_SOC_DAPM_STREAM_STOP:
3330 w_codec->active = 0;
3331 break;
3332 case SND_SOC_DAPM_STREAM_SUSPEND:
3333 case SND_SOC_DAPM_STREAM_RESUME:
3334 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
3335 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
3336 break;
3337 }
3338 }
3339
3340 dapm_power_widgets(&rtd->card->dapm, event);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003341}
3342
3343/**
3344 * snd_soc_dapm_stream_event - send a stream event to the dapm core
3345 * @rtd: PCM runtime data
3346 * @stream: stream name
3347 * @event: stream event
3348 *
3349 * Sends a stream event to the dapm core. The core then makes any
3350 * necessary widget power changes.
3351 *
3352 * Returns 0 for success else error.
3353 */
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003354void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3355 int event)
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003356{
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003357 struct snd_soc_card *card = rtd->card;
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003358
Liam Girdwood3cd04342012-03-09 12:02:08 +00003359 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
Liam Girdwoodd9b09512012-03-07 16:32:59 +00003360 soc_dapm_stream_event(rtd, stream, event);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00003361 mutex_unlock(&card->dapm_mutex);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003362}
Richard Purdie2b97eab2006-10-06 18:32:18 +02003363
3364/**
Liam Girdwooda5302182008-07-07 13:35:17 +01003365 * snd_soc_dapm_enable_pin - enable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003366 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01003367 * @pin: pin name
Richard Purdie2b97eab2006-10-06 18:32:18 +02003368 *
Mark Brown74b8f952009-06-06 11:26:15 +01003369 * Enables input/output pin and its parents or children widgets iff there is
Liam Girdwooda5302182008-07-07 13:35:17 +01003370 * a valid audio route and active audio stream.
3371 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3372 * do any widget power switching.
Richard Purdie2b97eab2006-10-06 18:32:18 +02003373 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003374int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003375{
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003376 return snd_soc_dapm_set_pin(dapm, pin, 1);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003377}
Liam Girdwooda5302182008-07-07 13:35:17 +01003378EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003379
3380/**
Mark Brownda341832010-03-15 19:23:37 +00003381 * snd_soc_dapm_force_enable_pin - force a pin to be enabled
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003382 * @dapm: DAPM context
Mark Brownda341832010-03-15 19:23:37 +00003383 * @pin: pin name
3384 *
3385 * Enables input/output pin regardless of any other state. This is
3386 * intended for use with microphone bias supplies used in microphone
3387 * jack detection.
3388 *
3389 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3390 * do any widget power switching.
3391 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003392int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
3393 const char *pin)
Mark Brownda341832010-03-15 19:23:37 +00003394{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02003395 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Mark Brownda341832010-03-15 19:23:37 +00003396
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02003397 if (!w) {
3398 dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
3399 return -EINVAL;
Mark Brownda341832010-03-15 19:23:37 +00003400 }
3401
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02003402 dev_dbg(w->dapm->dev, "dapm: force enable pin %s\n", pin);
3403 w->connected = 1;
3404 w->force = 1;
Mark Brown75c1f892011-10-04 22:28:08 +01003405 dapm_mark_dirty(w, "force enable");
Mark Brown0d867332011-04-06 11:38:14 +09003406
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02003407 return 0;
Mark Brownda341832010-03-15 19:23:37 +00003408}
3409EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
3410
3411/**
Liam Girdwooda5302182008-07-07 13:35:17 +01003412 * snd_soc_dapm_disable_pin - disable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003413 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01003414 * @pin: pin name
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02003415 *
Mark Brown74b8f952009-06-06 11:26:15 +01003416 * Disables input/output pin and its parents or children widgets.
Liam Girdwooda5302182008-07-07 13:35:17 +01003417 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3418 * do any widget power switching.
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02003419 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003420int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
3421 const char *pin)
Liam Girdwooda5302182008-07-07 13:35:17 +01003422{
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003423 return snd_soc_dapm_set_pin(dapm, pin, 0);
Liam Girdwooda5302182008-07-07 13:35:17 +01003424}
3425EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
3426
3427/**
Mark Brown5817b522008-09-24 11:23:11 +01003428 * snd_soc_dapm_nc_pin - permanently disable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003429 * @dapm: DAPM context
Mark Brown5817b522008-09-24 11:23:11 +01003430 * @pin: pin name
3431 *
3432 * Marks the specified pin as being not connected, disabling it along
3433 * any parent or child widgets. At present this is identical to
3434 * snd_soc_dapm_disable_pin() but in future it will be extended to do
3435 * additional things such as disabling controls which only affect
3436 * paths through the pin.
3437 *
3438 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
3439 * do any widget power switching.
3440 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003441int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
Mark Brown5817b522008-09-24 11:23:11 +01003442{
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003443 return snd_soc_dapm_set_pin(dapm, pin, 0);
Mark Brown5817b522008-09-24 11:23:11 +01003444}
3445EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
3446
3447/**
Liam Girdwooda5302182008-07-07 13:35:17 +01003448 * snd_soc_dapm_get_pin_status - get audio pin status
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003449 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01003450 * @pin: audio signal pin endpoint (or start point)
3451 *
3452 * Get audio pin status - connected or disconnected.
3453 *
3454 * Returns 1 for connected otherwise 0.
3455 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003456int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
3457 const char *pin)
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02003458{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02003459 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02003460
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02003461 if (w)
3462 return w->connected;
Stephen Warrena68b38a2011-04-19 15:25:11 -06003463
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02003464 return 0;
3465}
Liam Girdwooda5302182008-07-07 13:35:17 +01003466EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02003467
3468/**
Mark Brown1547aba2010-05-07 21:11:40 +01003469 * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003470 * @dapm: DAPM context
Mark Brown1547aba2010-05-07 21:11:40 +01003471 * @pin: audio signal pin endpoint (or start point)
3472 *
3473 * Mark the given endpoint or pin as ignoring suspend. When the
3474 * system is disabled a path between two endpoints flagged as ignoring
3475 * suspend will not be disabled. The path must already be enabled via
3476 * normal means at suspend time, it will not be turned on if it was not
3477 * already enabled.
3478 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003479int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
3480 const char *pin)
Mark Brown1547aba2010-05-07 21:11:40 +01003481{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02003482 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
Mark Brown1547aba2010-05-07 21:11:40 +01003483
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02003484 if (!w) {
3485 dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
3486 return -EINVAL;
Mark Brown1547aba2010-05-07 21:11:40 +01003487 }
3488
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02003489 w->ignore_suspend = 1;
3490
3491 return 0;
Mark Brown1547aba2010-05-07 21:11:40 +01003492}
3493EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
3494
Stephen Warren16332812011-11-23 12:42:04 -07003495static bool snd_soc_dapm_widget_in_card_paths(struct snd_soc_card *card,
3496 struct snd_soc_dapm_widget *w)
3497{
3498 struct snd_soc_dapm_path *p;
3499
3500 list_for_each_entry(p, &card->paths, list) {
3501 if ((p->source == w) || (p->sink == w)) {
3502 dev_dbg(card->dev,
3503 "... Path %s(id:%d dapm:%p) - %s(id:%d dapm:%p)\n",
3504 p->source->name, p->source->id, p->source->dapm,
3505 p->sink->name, p->sink->id, p->sink->dapm);
3506
3507 /* Connected to something other than the codec */
3508 if (p->source->dapm != p->sink->dapm)
3509 return true;
3510 /*
3511 * Loopback connection from codec external pin to
3512 * codec external pin
3513 */
3514 if (p->sink->id == snd_soc_dapm_input) {
3515 switch (p->source->id) {
3516 case snd_soc_dapm_output:
3517 case snd_soc_dapm_micbias:
3518 return true;
3519 default:
3520 break;
3521 }
3522 }
3523 }
3524 }
3525
3526 return false;
3527}
3528
3529/**
3530 * snd_soc_dapm_auto_nc_codec_pins - call snd_soc_dapm_nc_pin for unused pins
3531 * @codec: The codec whose pins should be processed
3532 *
3533 * Automatically call snd_soc_dapm_nc_pin() for any external pins in the codec
3534 * which are unused. Pins are used if they are connected externally to the
3535 * codec, whether that be to some other device, or a loop-back connection to
3536 * the codec itself.
3537 */
3538void snd_soc_dapm_auto_nc_codec_pins(struct snd_soc_codec *codec)
3539{
3540 struct snd_soc_card *card = codec->card;
3541 struct snd_soc_dapm_context *dapm = &codec->dapm;
3542 struct snd_soc_dapm_widget *w;
3543
Mark Browna094b802011-11-27 19:42:20 +00003544 dev_dbg(codec->dev, "Auto NC: DAPMs: card:%p codec:%p\n",
Stephen Warren16332812011-11-23 12:42:04 -07003545 &card->dapm, &codec->dapm);
3546
3547 list_for_each_entry(w, &card->widgets, list) {
3548 if (w->dapm != dapm)
3549 continue;
3550 switch (w->id) {
3551 case snd_soc_dapm_input:
3552 case snd_soc_dapm_output:
3553 case snd_soc_dapm_micbias:
Mark Browna094b802011-11-27 19:42:20 +00003554 dev_dbg(codec->dev, "Auto NC: Checking widget %s\n",
Stephen Warren16332812011-11-23 12:42:04 -07003555 w->name);
3556 if (!snd_soc_dapm_widget_in_card_paths(card, w)) {
Mark Browna094b802011-11-27 19:42:20 +00003557 dev_dbg(codec->dev,
Stephen Warren16332812011-11-23 12:42:04 -07003558 "... Not in map; disabling\n");
3559 snd_soc_dapm_nc_pin(dapm, w->name);
3560 }
3561 break;
3562 default:
3563 break;
3564 }
3565 }
3566}
3567
Mark Brown1547aba2010-05-07 21:11:40 +01003568/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02003569 * snd_soc_dapm_free - free dapm resources
Peter Ujfalusi728a5222011-08-26 16:33:52 +03003570 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02003571 *
3572 * Free all dapm widgets and resources.
3573 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003574void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02003575{
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003576 snd_soc_dapm_sys_remove(dapm->dev);
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02003577 dapm_debugfs_cleanup(dapm);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003578 dapm_free_widgets(dapm);
Jarkko Nikula7be31be82010-12-14 12:18:32 +02003579 list_del(&dapm->list);
Richard Purdie2b97eab2006-10-06 18:32:18 +02003580}
3581EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
3582
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003583static void soc_dapm_shutdown_codec(struct snd_soc_dapm_context *dapm)
Mark Brown51737472009-06-22 13:16:51 +01003584{
Mark Brown51737472009-06-22 13:16:51 +01003585 struct snd_soc_dapm_widget *w;
3586 LIST_HEAD(down_list);
3587 int powerdown = 0;
3588
Jarkko Nikula97c866d2010-12-14 12:18:31 +02003589 list_for_each_entry(w, &dapm->card->widgets, list) {
3590 if (w->dapm != dapm)
3591 continue;
Mark Brown51737472009-06-22 13:16:51 +01003592 if (w->power) {
Mark Brown828a8422011-01-15 13:14:30 +00003593 dapm_seq_insert(w, &down_list, false);
Mark Brownc2caa4d2009-06-26 15:36:56 +01003594 w->power = 0;
Mark Brown51737472009-06-22 13:16:51 +01003595 powerdown = 1;
3596 }
3597 }
3598
3599 /* If there were no widgets to power down we're already in
3600 * standby.
3601 */
3602 if (powerdown) {
Mark Brown7679e422012-02-22 15:52:56 +00003603 if (dapm->bias_level == SND_SOC_BIAS_ON)
3604 snd_soc_dapm_set_bias_level(dapm,
3605 SND_SOC_BIAS_PREPARE);
Mark Brown828a8422011-01-15 13:14:30 +00003606 dapm_seq_run(dapm, &down_list, 0, false);
Mark Brown7679e422012-02-22 15:52:56 +00003607 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
3608 snd_soc_dapm_set_bias_level(dapm,
3609 SND_SOC_BIAS_STANDBY);
Mark Brown51737472009-06-22 13:16:51 +01003610 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003611}
Mark Brown51737472009-06-22 13:16:51 +01003612
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003613/*
3614 * snd_soc_dapm_shutdown - callback for system shutdown
3615 */
3616void snd_soc_dapm_shutdown(struct snd_soc_card *card)
3617{
3618 struct snd_soc_codec *codec;
3619
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003620 list_for_each_entry(codec, &card->codec_dev_list, list) {
3621 soc_dapm_shutdown_codec(&codec->dapm);
Mark Brown7679e422012-02-22 15:52:56 +00003622 if (codec->dapm.bias_level == SND_SOC_BIAS_STANDBY)
3623 snd_soc_dapm_set_bias_level(&codec->dapm,
3624 SND_SOC_BIAS_OFF);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003625 }
Mark Brown51737472009-06-22 13:16:51 +01003626}
3627
Richard Purdie2b97eab2006-10-06 18:32:18 +02003628/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01003629MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Richard Purdie2b97eab2006-10-06 18:32:18 +02003630MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
3631MODULE_LICENSE("GPL");