blob: 2bde6b0c038b3529faafd46a0857f0b185b22c5c [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
17 * mic/meadphone insertion events.
18 * o Automatic Mic Bias support
19 * o Jack insertion power event initiation - e.g. hp insertion will enable
20 * sinks, dacs, etc
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +020021 * o Delayed powerdown of audio susbsystem to reduce pops between a quick
Richard Purdie2b97eab2006-10-06 18:32:18 +020022 * device reopen.
23 *
24 * Todo:
25 * o DAPM power change sequencing - allow for configurable per
26 * codec sequences.
27 * o Support for analogue bias optimisation.
28 * o Support for reduced codec oversampling rates.
29 * o Support for reduced codec bias currents.
30 */
31
32#include <linux/module.h>
33#include <linux/moduleparam.h>
34#include <linux/init.h>
Mark Brown9d0624a2011-02-18 11:49:43 -080035#include <linux/async.h>
Richard Purdie2b97eab2006-10-06 18:32:18 +020036#include <linux/delay.h>
37#include <linux/pm.h>
38#include <linux/bitops.h>
39#include <linux/platform_device.h>
40#include <linux/jiffies.h>
Takashi Iwai20496ff2009-08-24 09:40:34 +020041#include <linux/debugfs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090042#include <linux/slab.h>
Richard Purdie2b97eab2006-10-06 18:32:18 +020043#include <sound/core.h>
44#include <sound/pcm.h>
45#include <sound/pcm_params.h>
Liam Girdwoodce6120c2010-11-05 15:53:46 +020046#include <sound/soc.h>
Richard Purdie2b97eab2006-10-06 18:32:18 +020047#include <sound/initval.h>
48
Mark Brown84e90932010-11-04 00:07:02 -040049#include <trace/events/asoc.h>
50
Mark Brownde02d072011-09-20 21:43:24 +010051#define DAPM_UPDATE_STAT(widget, val) widget->dapm->card->dapm_stats.val++;
52
Richard Purdie2b97eab2006-10-06 18:32:18 +020053/* dapm power sequences - make this per codec in the future */
54static int dapm_up_seq[] = {
Mark Brown38357ab2009-06-06 19:03:23 +010055 [snd_soc_dapm_pre] = 0,
56 [snd_soc_dapm_supply] = 1,
57 [snd_soc_dapm_micbias] = 2,
Mark Brown010ff262009-08-17 17:39:22 +010058 [snd_soc_dapm_aif_in] = 3,
59 [snd_soc_dapm_aif_out] = 3,
60 [snd_soc_dapm_mic] = 4,
61 [snd_soc_dapm_mux] = 5,
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +000062 [snd_soc_dapm_virt_mux] = 5,
Mark Brown010ff262009-08-17 17:39:22 +010063 [snd_soc_dapm_value_mux] = 5,
64 [snd_soc_dapm_dac] = 6,
65 [snd_soc_dapm_mixer] = 7,
66 [snd_soc_dapm_mixer_named_ctl] = 7,
67 [snd_soc_dapm_pga] = 8,
68 [snd_soc_dapm_adc] = 9,
Olaya, Margaritad88429a2010-12-10 21:11:44 -060069 [snd_soc_dapm_out_drv] = 10,
Mark Brown010ff262009-08-17 17:39:22 +010070 [snd_soc_dapm_hp] = 10,
71 [snd_soc_dapm_spk] = 10,
72 [snd_soc_dapm_post] = 11,
Richard Purdie2b97eab2006-10-06 18:32:18 +020073};
Ian Moltonca9c1aa2009-01-06 20:11:51 +000074
Richard Purdie2b97eab2006-10-06 18:32:18 +020075static int dapm_down_seq[] = {
Mark Brown38357ab2009-06-06 19:03:23 +010076 [snd_soc_dapm_pre] = 0,
77 [snd_soc_dapm_adc] = 1,
78 [snd_soc_dapm_hp] = 2,
Mark Brown1ca04062009-08-17 16:26:59 +010079 [snd_soc_dapm_spk] = 2,
Olaya, Margaritad88429a2010-12-10 21:11:44 -060080 [snd_soc_dapm_out_drv] = 2,
Mark Brown38357ab2009-06-06 19:03:23 +010081 [snd_soc_dapm_pga] = 4,
82 [snd_soc_dapm_mixer_named_ctl] = 5,
Mark Browne3d4dab2009-06-07 13:08:45 +010083 [snd_soc_dapm_mixer] = 5,
84 [snd_soc_dapm_dac] = 6,
85 [snd_soc_dapm_mic] = 7,
86 [snd_soc_dapm_micbias] = 8,
87 [snd_soc_dapm_mux] = 9,
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +000088 [snd_soc_dapm_virt_mux] = 9,
Mark Browne3d4dab2009-06-07 13:08:45 +010089 [snd_soc_dapm_value_mux] = 9,
Mark Brown010ff262009-08-17 17:39:22 +010090 [snd_soc_dapm_aif_in] = 10,
91 [snd_soc_dapm_aif_out] = 10,
92 [snd_soc_dapm_supply] = 11,
93 [snd_soc_dapm_post] = 12,
Richard Purdie2b97eab2006-10-06 18:32:18 +020094};
95
Troy Kisky12ef1932008-10-13 17:42:14 -070096static void pop_wait(u32 pop_time)
Mark Brown15e4c722008-07-02 11:51:20 +010097{
98 if (pop_time)
99 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
100}
101
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200102static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
Mark Brown15e4c722008-07-02 11:51:20 +0100103{
104 va_list args;
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200105 char *buf;
106
107 if (!pop_time)
108 return;
109
110 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
111 if (buf == NULL)
112 return;
Mark Brown15e4c722008-07-02 11:51:20 +0100113
114 va_start(args, fmt);
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200115 vsnprintf(buf, PAGE_SIZE, fmt, args);
Takashi Iwai9d01df02010-12-22 14:08:40 +0100116 dev_info(dev, "%s", buf);
Mark Brown15e4c722008-07-02 11:51:20 +0100117 va_end(args);
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200118
119 kfree(buf);
Mark Brown15e4c722008-07-02 11:51:20 +0100120}
121
Richard Purdie2b97eab2006-10-06 18:32:18 +0200122/* create a new dapm widget */
Takashi Iwai88cb4292007-02-05 14:56:20 +0100123static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
Richard Purdie2b97eab2006-10-06 18:32:18 +0200124 const struct snd_soc_dapm_widget *_widget)
125{
Takashi Iwai88cb4292007-02-05 14:56:20 +0100126 return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200127}
128
Liam Girdwood48056082011-07-20 12:23:33 +0100129/* get snd_card from DAPM context */
130static inline struct snd_card *dapm_get_snd_card(
131 struct snd_soc_dapm_context *dapm)
132{
133 if (dapm->codec)
134 return dapm->codec->card->snd_card;
135 else if (dapm->platform)
136 return dapm->platform->card->snd_card;
137 else
138 BUG();
139
140 /* unreachable */
141 return NULL;
142}
143
144/* get soc_card from DAPM context */
145static inline struct snd_soc_card *dapm_get_soc_card(
146 struct snd_soc_dapm_context *dapm)
147{
148 if (dapm->codec)
149 return dapm->codec->card;
150 else if (dapm->platform)
151 return dapm->platform->card;
152 else
153 BUG();
154
155 /* unreachable */
156 return NULL;
157}
158
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100159static int soc_widget_read(struct snd_soc_dapm_widget *w, int reg)
160{
161 if (w->codec)
162 return snd_soc_read(w->codec, reg);
Liam Girdwoodb7950642011-07-04 22:10:52 +0100163 else if (w->platform)
164 return snd_soc_platform_read(w->platform, reg);
165
166 dev_err(w->dapm->dev, "no valid widget read method\n");
167 return -1;
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100168}
169
170static int soc_widget_write(struct snd_soc_dapm_widget *w, int reg, int val)
171{
172 if (w->codec)
173 return snd_soc_write(w->codec, reg, val);
Liam Girdwoodb7950642011-07-04 22:10:52 +0100174 else if (w->platform)
175 return snd_soc_platform_write(w->platform, reg, val);
176
177 dev_err(w->dapm->dev, "no valid widget write method\n");
178 return -1;
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100179}
180
181static int soc_widget_update_bits(struct snd_soc_dapm_widget *w,
182 unsigned short reg, unsigned int mask, unsigned int value)
183{
184 int change;
185 unsigned int old, new;
186 int ret;
187
188 ret = soc_widget_read(w, reg);
189 if (ret < 0)
190 return ret;
191
192 old = ret;
193 new = (old & ~mask) | (value & mask);
194 change = old != new;
195 if (change) {
196 ret = soc_widget_write(w, reg, new);
197 if (ret < 0)
198 return ret;
199 }
200
201 return change;
202}
203
Mark Brown452c5ea2009-05-17 21:41:23 +0100204/**
205 * snd_soc_dapm_set_bias_level - set the bias level for the system
Mark Browned5a4c42011-02-18 11:12:42 -0800206 * @dapm: DAPM context
Mark Brown452c5ea2009-05-17 21:41:23 +0100207 * @level: level to configure
208 *
209 * Configure the bias (power) levels for the SoC audio device.
210 *
211 * Returns 0 for success else error.
212 */
Mark Browned5a4c42011-02-18 11:12:42 -0800213static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200214 enum snd_soc_bias_level level)
Mark Brown452c5ea2009-05-17 21:41:23 +0100215{
Mark Browned5a4c42011-02-18 11:12:42 -0800216 struct snd_soc_card *card = dapm->card;
Mark Brown452c5ea2009-05-17 21:41:23 +0100217 int ret = 0;
218
Mark Brown84e90932010-11-04 00:07:02 -0400219 trace_snd_soc_bias_level_start(card, level);
220
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000221 if (card && card->set_bias_level)
Mark Brownd4c60052011-06-06 19:13:23 +0100222 ret = card->set_bias_level(card, dapm, level);
Mark Brown171ec6b2011-06-06 18:15:19 +0100223 if (ret != 0)
224 goto out;
Mark Brown452c5ea2009-05-17 21:41:23 +0100225
Mark Browncc4c6702011-06-06 19:03:34 +0100226 if (dapm->codec) {
227 if (dapm->codec->driver->set_bias_level)
228 ret = dapm->codec->driver->set_bias_level(dapm->codec,
229 level);
230 else
231 dapm->bias_level = level;
232 }
Mark Brown171ec6b2011-06-06 18:15:19 +0100233 if (ret != 0)
234 goto out;
235
236 if (card && card->set_bias_level_post)
Mark Brownd4c60052011-06-06 19:13:23 +0100237 ret = card->set_bias_level_post(card, dapm, level);
Mark Brown171ec6b2011-06-06 18:15:19 +0100238out:
Mark Brown84e90932010-11-04 00:07:02 -0400239 trace_snd_soc_bias_level_done(card, level);
240
Mark Brown452c5ea2009-05-17 21:41:23 +0100241 return ret;
242}
243
Richard Purdie2b97eab2006-10-06 18:32:18 +0200244/* set up initial codec paths */
245static void dapm_set_path_status(struct snd_soc_dapm_widget *w,
246 struct snd_soc_dapm_path *p, int i)
247{
248 switch (w->id) {
249 case snd_soc_dapm_switch:
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000250 case snd_soc_dapm_mixer:
251 case snd_soc_dapm_mixer_named_ctl: {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200252 int val;
Jon Smirl4eaa9812008-07-29 11:42:26 +0100253 struct soc_mixer_control *mc = (struct soc_mixer_control *)
Stephen Warren82cfecd2011-04-28 17:37:58 -0600254 w->kcontrol_news[i].private_value;
Jon Smirl815ecf8d2008-07-29 10:22:24 -0400255 unsigned int reg = mc->reg;
256 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +0100257 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -0400258 unsigned int mask = (1 << fls(max)) - 1;
259 unsigned int invert = mc->invert;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200260
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100261 val = soc_widget_read(w, reg);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200262 val = (val >> shift) & mask;
263
264 if ((invert && !val) || (!invert && val))
265 p->connect = 1;
266 else
267 p->connect = 0;
268 }
269 break;
270 case snd_soc_dapm_mux: {
Stephen Warren82cfecd2011-04-28 17:37:58 -0600271 struct soc_enum *e = (struct soc_enum *)
272 w->kcontrol_news[i].private_value;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200273 int val, item, bitmask;
274
Jon Smirlf8ba0b72008-07-29 11:42:27 +0100275 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Mark Brown88d96082011-06-06 16:16:34 +0100276 ;
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100277 val = soc_widget_read(w, e->reg);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200278 item = (val >> e->shift_l) & (bitmask - 1);
279
280 p->connect = 0;
Jon Smirlf8ba0b72008-07-29 11:42:27 +0100281 for (i = 0; i < e->max; i++) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200282 if (!(strcmp(p->name, e->texts[i])) && item == i)
283 p->connect = 1;
284 }
285 }
286 break;
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +0000287 case snd_soc_dapm_virt_mux: {
Stephen Warren82cfecd2011-04-28 17:37:58 -0600288 struct soc_enum *e = (struct soc_enum *)
289 w->kcontrol_news[i].private_value;
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +0000290
291 p->connect = 0;
292 /* since a virtual mux has no backing registers to
293 * decide which path to connect, it will try to match
294 * with the first enumeration. This is to ensure
295 * that the default mux choice (the first) will be
296 * correctly powered up during initialization.
297 */
298 if (!strcmp(p->name, e->texts[0]))
299 p->connect = 1;
300 }
301 break;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +0200302 case snd_soc_dapm_value_mux: {
Peter Ujfalusi74155552009-01-08 13:34:29 +0200303 struct soc_enum *e = (struct soc_enum *)
Stephen Warren82cfecd2011-04-28 17:37:58 -0600304 w->kcontrol_news[i].private_value;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +0200305 int val, item;
306
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100307 val = soc_widget_read(w, e->reg);
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +0200308 val = (val >> e->shift_l) & e->mask;
309 for (item = 0; item < e->max; item++) {
310 if (val == e->values[item])
311 break;
312 }
313
314 p->connect = 0;
315 for (i = 0; i < e->max; i++) {
316 if (!(strcmp(p->name, e->texts[i])) && item == i)
317 p->connect = 1;
318 }
319 }
320 break;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200321 /* does not effect routing - always connected */
322 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -0600323 case snd_soc_dapm_out_drv:
Richard Purdie2b97eab2006-10-06 18:32:18 +0200324 case snd_soc_dapm_output:
325 case snd_soc_dapm_adc:
326 case snd_soc_dapm_input:
327 case snd_soc_dapm_dac:
328 case snd_soc_dapm_micbias:
329 case snd_soc_dapm_vmid:
Mark Brown246d0a12009-04-22 18:24:55 +0100330 case snd_soc_dapm_supply:
Mark Brown010ff262009-08-17 17:39:22 +0100331 case snd_soc_dapm_aif_in:
332 case snd_soc_dapm_aif_out:
Richard Purdie2b97eab2006-10-06 18:32:18 +0200333 p->connect = 1;
334 break;
335 /* does effect routing - dynamically connected */
336 case snd_soc_dapm_hp:
337 case snd_soc_dapm_mic:
338 case snd_soc_dapm_spk:
339 case snd_soc_dapm_line:
340 case snd_soc_dapm_pre:
341 case snd_soc_dapm_post:
342 p->connect = 0;
343 break;
344 }
345}
346
Mark Brown74b8f952009-06-06 11:26:15 +0100347/* connect mux widget to its interconnecting audio paths */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200348static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
Richard Purdie2b97eab2006-10-06 18:32:18 +0200349 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
350 struct snd_soc_dapm_path *path, const char *control_name,
351 const struct snd_kcontrol_new *kcontrol)
352{
353 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
354 int i;
355
Jon Smirlf8ba0b72008-07-29 11:42:27 +0100356 for (i = 0; i < e->max; i++) {
Richard Purdie2b97eab2006-10-06 18:32:18 +0200357 if (!(strcmp(control_name, e->texts[i]))) {
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +0200358 list_add(&path->list, &dapm->card->paths);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200359 list_add(&path->list_sink, &dest->sources);
360 list_add(&path->list_source, &src->sinks);
361 path->name = (char*)e->texts[i];
362 dapm_set_path_status(dest, path, 0);
363 return 0;
364 }
365 }
366
367 return -ENODEV;
368}
369
Mark Brown74b8f952009-06-06 11:26:15 +0100370/* connect mixer widget to its interconnecting audio paths */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200371static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
Richard Purdie2b97eab2006-10-06 18:32:18 +0200372 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
373 struct snd_soc_dapm_path *path, const char *control_name)
374{
375 int i;
376
377 /* search for mixer kcontrol */
378 for (i = 0; i < dest->num_kcontrols; i++) {
Stephen Warren82cfecd2011-04-28 17:37:58 -0600379 if (!strcmp(control_name, dest->kcontrol_news[i].name)) {
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +0200380 list_add(&path->list, &dapm->card->paths);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200381 list_add(&path->list_sink, &dest->sources);
382 list_add(&path->list_source, &src->sinks);
Stephen Warren82cfecd2011-04-28 17:37:58 -0600383 path->name = dest->kcontrol_news[i].name;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200384 dapm_set_path_status(dest, path, i);
385 return 0;
386 }
387 }
388 return -ENODEV;
389}
390
Stephen Warrenaf468002011-04-28 17:38:01 -0600391static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
Stephen Warren1007da02011-05-26 09:57:33 -0600392 struct snd_soc_dapm_widget *kcontrolw,
Stephen Warrenaf468002011-04-28 17:38:01 -0600393 const struct snd_kcontrol_new *kcontrol_new,
394 struct snd_kcontrol **kcontrol)
395{
396 struct snd_soc_dapm_widget *w;
397 int i;
398
399 *kcontrol = NULL;
400
401 list_for_each_entry(w, &dapm->card->widgets, list) {
Stephen Warren1007da02011-05-26 09:57:33 -0600402 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
403 continue;
Stephen Warrenaf468002011-04-28 17:38:01 -0600404 for (i = 0; i < w->num_kcontrols; i++) {
405 if (&w->kcontrol_news[i] == kcontrol_new) {
406 if (w->kcontrols)
407 *kcontrol = w->kcontrols[i];
408 return 1;
409 }
410 }
411 }
412
413 return 0;
414}
415
Richard Purdie2b97eab2006-10-06 18:32:18 +0200416/* create new dapm mixer control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200417static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200418{
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200419 struct snd_soc_dapm_context *dapm = w->dapm;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200420 int i, ret = 0;
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000421 size_t name_len, prefix_len;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200422 struct snd_soc_dapm_path *path;
Mark Brown12ea2c72011-03-02 18:17:32 +0000423 struct snd_card *card = dapm->card->snd_card;
Mark Brownefb7ac32011-03-08 17:23:24 +0000424 const char *prefix;
Stephen Warrenfafd2172011-04-28 17:38:00 -0600425 struct snd_soc_dapm_widget_list *wlist;
426 size_t wlistsize;
Mark Brownefb7ac32011-03-08 17:23:24 +0000427
428 if (dapm->codec)
429 prefix = dapm->codec->name_prefix;
430 else
431 prefix = NULL;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200432
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000433 if (prefix)
434 prefix_len = strlen(prefix) + 1;
435 else
436 prefix_len = 0;
437
Richard Purdie2b97eab2006-10-06 18:32:18 +0200438 /* add kcontrol */
439 for (i = 0; i < w->num_kcontrols; i++) {
440
441 /* match name */
442 list_for_each_entry(path, &w->sources, list_sink) {
443
444 /* mixer/mux paths name must match control name */
Stephen Warren82cfecd2011-04-28 17:37:58 -0600445 if (path->name != (char *)w->kcontrol_news[i].name)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200446 continue;
447
Lars-Peter Clausen82cd8762011-08-15 20:15:21 +0200448 if (w->kcontrols[i]) {
449 path->kcontrol = w->kcontrols[i];
450 continue;
451 }
452
Stephen Warrenfafd2172011-04-28 17:38:00 -0600453 wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
454 sizeof(struct snd_soc_dapm_widget *),
455 wlist = kzalloc(wlistsize, GFP_KERNEL);
456 if (wlist == NULL) {
457 dev_err(dapm->dev,
458 "asoc: can't allocate widget list for %s\n",
459 w->name);
460 return -ENOMEM;
461 }
462 wlist->num_widgets = 1;
463 wlist->widgets[0] = w;
464
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000465 /* add dapm control with long name.
466 * for dapm_mixer this is the concatenation of the
467 * mixer and kcontrol name.
468 * for dapm_mixer_named_ctl this is simply the
469 * kcontrol name.
470 */
Stephen Warren82cfecd2011-04-28 17:37:58 -0600471 name_len = strlen(w->kcontrol_news[i].name) + 1;
Mark Brown07495f32009-03-05 17:06:23 +0000472 if (w->id != snd_soc_dapm_mixer_named_ctl)
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000473 name_len += 1 + strlen(w->name);
474
Mark Brown219b93f2008-10-28 13:02:31 +0000475 path->long_name = kmalloc(name_len, GFP_KERNEL);
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000476
Stephen Warrenfafd2172011-04-28 17:38:00 -0600477 if (path->long_name == NULL) {
478 kfree(wlist);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200479 return -ENOMEM;
Stephen Warrenfafd2172011-04-28 17:38:00 -0600480 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200481
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000482 switch (w->id) {
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000483 default:
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000484 /* The control will get a prefix from
485 * the control creation process but
486 * we're also using the same prefix
487 * for widgets so cut the prefix off
488 * the front of the widget name.
489 */
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000490 snprintf(path->long_name, name_len, "%s %s",
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000491 w->name + prefix_len,
Stephen Warren82cfecd2011-04-28 17:37:58 -0600492 w->kcontrol_news[i].name);
Mark Brown07495f32009-03-05 17:06:23 +0000493 break;
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000494 case snd_soc_dapm_mixer_named_ctl:
495 snprintf(path->long_name, name_len, "%s",
Stephen Warren82cfecd2011-04-28 17:37:58 -0600496 w->kcontrol_news[i].name);
Mark Brown07495f32009-03-05 17:06:23 +0000497 break;
Ian Moltonca9c1aa2009-01-06 20:11:51 +0000498 }
499
Mark Brown219b93f2008-10-28 13:02:31 +0000500 path->long_name[name_len - 1] = '\0';
501
Stephen Warrenfafd2172011-04-28 17:38:00 -0600502 path->kcontrol = snd_soc_cnew(&w->kcontrol_news[i],
503 wlist, path->long_name,
504 prefix);
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200505 ret = snd_ctl_add(card, path->kcontrol);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200506 if (ret < 0) {
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +0200507 dev_err(dapm->dev,
508 "asoc: failed to add dapm kcontrol %s: %d\n",
509 path->long_name, ret);
Stephen Warrenfafd2172011-04-28 17:38:00 -0600510 kfree(wlist);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200511 kfree(path->long_name);
512 path->long_name = NULL;
513 return ret;
514 }
Stephen Warrenfad59882011-04-28 17:37:59 -0600515 w->kcontrols[i] = path->kcontrol;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200516 }
517 }
518 return ret;
519}
520
521/* create new dapm mux control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200522static int dapm_new_mux(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200523{
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200524 struct snd_soc_dapm_context *dapm = w->dapm;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200525 struct snd_soc_dapm_path *path = NULL;
526 struct snd_kcontrol *kcontrol;
Mark Brown12ea2c72011-03-02 18:17:32 +0000527 struct snd_card *card = dapm->card->snd_card;
Mark Brownefb7ac32011-03-08 17:23:24 +0000528 const char *prefix;
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000529 size_t prefix_len;
Stephen Warrenaf468002011-04-28 17:38:01 -0600530 int ret;
Stephen Warrenfafd2172011-04-28 17:38:00 -0600531 struct snd_soc_dapm_widget_list *wlist;
Stephen Warrenaf468002011-04-28 17:38:01 -0600532 int shared, wlistentries;
Stephen Warrenfafd2172011-04-28 17:38:00 -0600533 size_t wlistsize;
Stephen Warrenaf468002011-04-28 17:38:01 -0600534 char *name;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200535
Stephen Warrenaf468002011-04-28 17:38:01 -0600536 if (w->num_kcontrols != 1) {
537 dev_err(dapm->dev,
538 "asoc: mux %s has incorrect number of controls\n",
539 w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200540 return -EINVAL;
541 }
542
Stephen Warren1007da02011-05-26 09:57:33 -0600543 shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[0],
Stephen Warrenaf468002011-04-28 17:38:01 -0600544 &kcontrol);
545 if (kcontrol) {
546 wlist = kcontrol->private_data;
547 wlistentries = wlist->num_widgets + 1;
548 } else {
549 wlist = NULL;
550 wlistentries = 1;
551 }
Stephen Warrenfafd2172011-04-28 17:38:00 -0600552 wlistsize = sizeof(struct snd_soc_dapm_widget_list) +
Stephen Warrenaf468002011-04-28 17:38:01 -0600553 wlistentries * sizeof(struct snd_soc_dapm_widget *),
554 wlist = krealloc(wlist, wlistsize, GFP_KERNEL);
Stephen Warrenfafd2172011-04-28 17:38:00 -0600555 if (wlist == NULL) {
556 dev_err(dapm->dev,
557 "asoc: can't allocate widget list for %s\n", w->name);
558 return -ENOMEM;
559 }
Stephen Warrenaf468002011-04-28 17:38:01 -0600560 wlist->num_widgets = wlistentries;
561 wlist->widgets[wlistentries - 1] = w;
Stephen Warrenfafd2172011-04-28 17:38:00 -0600562
Stephen Warrenaf468002011-04-28 17:38:01 -0600563 if (!kcontrol) {
564 if (dapm->codec)
565 prefix = dapm->codec->name_prefix;
566 else
567 prefix = NULL;
Mark Brownefb7ac32011-03-08 17:23:24 +0000568
Stephen Warrenaf468002011-04-28 17:38:01 -0600569 if (shared) {
570 name = w->kcontrol_news[0].name;
571 prefix_len = 0;
572 } else {
573 name = w->name;
574 if (prefix)
575 prefix_len = strlen(prefix) + 1;
576 else
577 prefix_len = 0;
578 }
Mark Brown3e5ff4d2011-03-09 11:33:09 +0000579
Stephen Warrenaf468002011-04-28 17:38:01 -0600580 /*
581 * The control will get a prefix from the control creation
582 * process but we're also using the same prefix for widgets so
583 * cut the prefix off the front of the widget name.
584 */
585 kcontrol = snd_soc_cnew(&w->kcontrol_news[0], wlist,
586 name + prefix_len, prefix);
587 ret = snd_ctl_add(card, kcontrol);
588 if (ret < 0) {
Mark Brown53daf202011-09-05 10:51:05 -0700589 dev_err(dapm->dev, "failed to add kcontrol %s: %d\n",
590 w->name, ret);
Stephen Warrenaf468002011-04-28 17:38:01 -0600591 kfree(wlist);
592 return ret;
593 }
594 }
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200595
Stephen Warrenaf468002011-04-28 17:38:01 -0600596 kcontrol->private_data = wlist;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200597
Stephen Warrenfad59882011-04-28 17:37:59 -0600598 w->kcontrols[0] = kcontrol;
599
Richard Purdie2b97eab2006-10-06 18:32:18 +0200600 list_for_each_entry(path, &w->sources, list_sink)
601 path->kcontrol = kcontrol;
602
Stephen Warrenaf468002011-04-28 17:38:01 -0600603 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200604}
605
606/* create new dapm volume control */
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +0200607static int dapm_new_pga(struct snd_soc_dapm_widget *w)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200608{
Mark Browna6c65732010-03-03 17:45:21 +0000609 if (w->num_kcontrols)
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +0200610 dev_err(w->dapm->dev,
611 "asoc: PGA controls not supported: '%s'\n", w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200612
Mark Browna6c65732010-03-03 17:45:21 +0000613 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +0200614}
615
616/* reset 'walked' bit for each dapm path */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200617static inline void dapm_clear_walk(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200618{
619 struct snd_soc_dapm_path *p;
620
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +0200621 list_for_each_entry(p, &dapm->card->paths, list)
Richard Purdie2b97eab2006-10-06 18:32:18 +0200622 p->walked = 0;
623}
624
Mark Brown99497882010-05-07 20:24:05 +0100625/* We implement power down on suspend by checking the power state of
626 * the ALSA card - when we are suspending the ALSA state for the card
627 * is set to D3.
628 */
629static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
630{
Mark Brown12ea2c72011-03-02 18:17:32 +0000631 int level = snd_power_get_state(widget->dapm->card->snd_card);
Mark Brown99497882010-05-07 20:24:05 +0100632
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000633 switch (level) {
Mark Brown99497882010-05-07 20:24:05 +0100634 case SNDRV_CTL_POWER_D3hot:
635 case SNDRV_CTL_POWER_D3cold:
Mark Brown1547aba2010-05-07 21:11:40 +0100636 if (widget->ignore_suspend)
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +0200637 dev_dbg(widget->dapm->dev, "%s ignoring suspend\n",
638 widget->name);
Mark Brown1547aba2010-05-07 21:11:40 +0100639 return widget->ignore_suspend;
Mark Brown99497882010-05-07 20:24:05 +0100640 default:
641 return 1;
642 }
643}
644
Richard Purdie2b97eab2006-10-06 18:32:18 +0200645/*
646 * Recursively check for a completed path to an active or physically connected
647 * output widget. Returns number of complete paths.
648 */
649static int is_connected_output_ep(struct snd_soc_dapm_widget *widget)
650{
651 struct snd_soc_dapm_path *path;
652 int con = 0;
653
Mark Brownde02d072011-09-20 21:43:24 +0100654 DAPM_UPDATE_STAT(widget, path_checks);
655
Mark Brown246d0a12009-04-22 18:24:55 +0100656 if (widget->id == snd_soc_dapm_supply)
657 return 0;
658
Mark Brown010ff262009-08-17 17:39:22 +0100659 switch (widget->id) {
660 case snd_soc_dapm_adc:
661 case snd_soc_dapm_aif_out:
662 if (widget->active)
Mark Brown99497882010-05-07 20:24:05 +0100663 return snd_soc_dapm_suspend_check(widget);
Mark Brown010ff262009-08-17 17:39:22 +0100664 default:
665 break;
666 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200667
668 if (widget->connected) {
669 /* connected pin ? */
670 if (widget->id == snd_soc_dapm_output && !widget->ext)
Mark Brown99497882010-05-07 20:24:05 +0100671 return snd_soc_dapm_suspend_check(widget);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200672
673 /* connected jack or spk ? */
674 if (widget->id == snd_soc_dapm_hp || widget->id == snd_soc_dapm_spk ||
Peter Ujfalusieaeae5d2009-09-30 09:27:24 +0300675 (widget->id == snd_soc_dapm_line && !list_empty(&widget->sources)))
Mark Brown99497882010-05-07 20:24:05 +0100676 return snd_soc_dapm_suspend_check(widget);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200677 }
678
679 list_for_each_entry(path, &widget->sinks, list_source) {
Mark Browne56235e2011-09-21 18:19:14 +0100680 DAPM_UPDATE_STAT(widget, neighbour_checks);
681
Mark Brownbf3a9e12011-06-13 16:42:29 +0100682 if (path->weak)
683 continue;
684
Richard Purdie2b97eab2006-10-06 18:32:18 +0200685 if (path->walked)
686 continue;
687
688 if (path->sink && path->connect) {
689 path->walked = 1;
690 con += is_connected_output_ep(path->sink);
691 }
692 }
693
694 return con;
695}
696
697/*
698 * Recursively check for a completed path to an active or physically connected
699 * input widget. Returns number of complete paths.
700 */
701static int is_connected_input_ep(struct snd_soc_dapm_widget *widget)
702{
703 struct snd_soc_dapm_path *path;
704 int con = 0;
705
Mark Brownde02d072011-09-20 21:43:24 +0100706 DAPM_UPDATE_STAT(widget, path_checks);
707
Mark Brown246d0a12009-04-22 18:24:55 +0100708 if (widget->id == snd_soc_dapm_supply)
709 return 0;
710
Richard Purdie2b97eab2006-10-06 18:32:18 +0200711 /* active stream ? */
Mark Brown010ff262009-08-17 17:39:22 +0100712 switch (widget->id) {
713 case snd_soc_dapm_dac:
714 case snd_soc_dapm_aif_in:
715 if (widget->active)
Mark Brown99497882010-05-07 20:24:05 +0100716 return snd_soc_dapm_suspend_check(widget);
Mark Brown010ff262009-08-17 17:39:22 +0100717 default:
718 break;
719 }
Richard Purdie2b97eab2006-10-06 18:32:18 +0200720
721 if (widget->connected) {
722 /* connected pin ? */
723 if (widget->id == snd_soc_dapm_input && !widget->ext)
Mark Brown99497882010-05-07 20:24:05 +0100724 return snd_soc_dapm_suspend_check(widget);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200725
726 /* connected VMID/Bias for lower pops */
727 if (widget->id == snd_soc_dapm_vmid)
Mark Brown99497882010-05-07 20:24:05 +0100728 return snd_soc_dapm_suspend_check(widget);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200729
730 /* connected jack ? */
Peter Ujfalusieaeae5d2009-09-30 09:27:24 +0300731 if (widget->id == snd_soc_dapm_mic ||
732 (widget->id == snd_soc_dapm_line && !list_empty(&widget->sinks)))
Mark Brown99497882010-05-07 20:24:05 +0100733 return snd_soc_dapm_suspend_check(widget);
Richard Purdie2b97eab2006-10-06 18:32:18 +0200734 }
735
736 list_for_each_entry(path, &widget->sources, list_sink) {
Mark Browne56235e2011-09-21 18:19:14 +0100737 DAPM_UPDATE_STAT(widget, neighbour_checks);
738
Mark Brownbf3a9e12011-06-13 16:42:29 +0100739 if (path->weak)
740 continue;
741
Richard Purdie2b97eab2006-10-06 18:32:18 +0200742 if (path->walked)
743 continue;
744
745 if (path->source && path->connect) {
746 path->walked = 1;
747 con += is_connected_input_ep(path->source);
748 }
749 }
750
751 return con;
752}
753
754/*
Jarkko Nikulae2be2cc2008-06-25 14:42:07 +0300755 * Handler for generic register modifier widget.
756 */
757int dapm_reg_event(struct snd_soc_dapm_widget *w,
758 struct snd_kcontrol *kcontrol, int event)
759{
760 unsigned int val;
761
762 if (SND_SOC_DAPM_EVENT_ON(event))
763 val = w->on_val;
764 else
765 val = w->off_val;
766
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100767 soc_widget_update_bits(w, -(w->reg + 1),
Jarkko Nikulae2be2cc2008-06-25 14:42:07 +0300768 w->mask << w->shift, val << w->shift);
769
770 return 0;
771}
Mark Brown11589412008-07-29 11:42:23 +0100772EXPORT_SYMBOL_GPL(dapm_reg_event);
Jarkko Nikulae2be2cc2008-06-25 14:42:07 +0300773
Mark Browncd0f2d42009-04-20 16:56:59 +0100774/* Generic check to see if a widget should be powered.
775 */
776static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
777{
778 int in, out;
779
Mark Brownde02d072011-09-20 21:43:24 +0100780 DAPM_UPDATE_STAT(w, power_checks);
781
Mark Browncd0f2d42009-04-20 16:56:59 +0100782 in = is_connected_input_ep(w);
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200783 dapm_clear_walk(w->dapm);
Mark Browncd0f2d42009-04-20 16:56:59 +0100784 out = is_connected_output_ep(w);
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200785 dapm_clear_walk(w->dapm);
Mark Browncd0f2d42009-04-20 16:56:59 +0100786 return out != 0 && in != 0;
787}
788
Mark Brown6ea31b92009-04-20 17:15:41 +0100789/* Check to see if an ADC has power */
790static int dapm_adc_check_power(struct snd_soc_dapm_widget *w)
791{
792 int in;
793
Mark Brownde02d072011-09-20 21:43:24 +0100794 DAPM_UPDATE_STAT(w, power_checks);
795
Mark Brown6ea31b92009-04-20 17:15:41 +0100796 if (w->active) {
797 in = is_connected_input_ep(w);
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200798 dapm_clear_walk(w->dapm);
Mark Brown6ea31b92009-04-20 17:15:41 +0100799 return in != 0;
800 } else {
801 return dapm_generic_check_power(w);
802 }
803}
804
805/* Check to see if a DAC has power */
806static int dapm_dac_check_power(struct snd_soc_dapm_widget *w)
807{
808 int out;
809
Mark Brownde02d072011-09-20 21:43:24 +0100810 DAPM_UPDATE_STAT(w, power_checks);
811
Mark Brown6ea31b92009-04-20 17:15:41 +0100812 if (w->active) {
813 out = is_connected_output_ep(w);
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200814 dapm_clear_walk(w->dapm);
Mark Brown6ea31b92009-04-20 17:15:41 +0100815 return out != 0;
816 } else {
817 return dapm_generic_check_power(w);
818 }
819}
820
Mark Brown246d0a12009-04-22 18:24:55 +0100821/* Check to see if a power supply is needed */
822static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
823{
824 struct snd_soc_dapm_path *path;
825 int power = 0;
826
Mark Brownde02d072011-09-20 21:43:24 +0100827 DAPM_UPDATE_STAT(w, power_checks);
828
Mark Brown246d0a12009-04-22 18:24:55 +0100829 /* Check if one of our outputs is connected */
830 list_for_each_entry(path, &w->sinks, list_source) {
Mark Brownbf3a9e12011-06-13 16:42:29 +0100831 if (path->weak)
832 continue;
833
Mark Brown215edda2009-09-08 18:59:05 +0100834 if (path->connected &&
835 !path->connected(path->source, path->sink))
836 continue;
837
Mark Brown30173582011-02-11 11:42:19 +0000838 if (!path->sink)
839 continue;
840
841 if (path->sink->force) {
842 power = 1;
843 break;
844 }
845
846 if (path->sink->power_check &&
Mark Brown246d0a12009-04-22 18:24:55 +0100847 path->sink->power_check(path->sink)) {
848 power = 1;
849 break;
850 }
851 }
852
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200853 dapm_clear_walk(w->dapm);
Mark Brown246d0a12009-04-22 18:24:55 +0100854
855 return power;
856}
857
Mark Brown38357ab2009-06-06 19:03:23 +0100858static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
859 struct snd_soc_dapm_widget *b,
Mark Brown828a8422011-01-15 13:14:30 +0000860 bool power_up)
Mark Brown42aa3412009-03-01 19:21:10 +0000861{
Mark Brown828a8422011-01-15 13:14:30 +0000862 int *sort;
863
864 if (power_up)
865 sort = dapm_up_seq;
866 else
867 sort = dapm_down_seq;
868
Mark Brown38357ab2009-06-06 19:03:23 +0100869 if (sort[a->id] != sort[b->id])
870 return sort[a->id] - sort[b->id];
Mark Brown20e48592011-01-15 13:40:50 +0000871 if (a->subseq != b->subseq) {
872 if (power_up)
873 return a->subseq - b->subseq;
874 else
875 return b->subseq - a->subseq;
876 }
Mark Brownb22ead22009-06-07 12:51:26 +0100877 if (a->reg != b->reg)
878 return a->reg - b->reg;
Mark Brown84dab562010-11-12 15:28:42 +0000879 if (a->dapm != b->dapm)
880 return (unsigned long)a->dapm - (unsigned long)b->dapm;
Mark Brown42aa3412009-03-01 19:21:10 +0000881
Mark Brown38357ab2009-06-06 19:03:23 +0100882 return 0;
883}
Mark Brown42aa3412009-03-01 19:21:10 +0000884
Mark Brown38357ab2009-06-06 19:03:23 +0100885/* Insert a widget in order into a DAPM power sequence. */
886static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
887 struct list_head *list,
Mark Brown828a8422011-01-15 13:14:30 +0000888 bool power_up)
Mark Brown38357ab2009-06-06 19:03:23 +0100889{
890 struct snd_soc_dapm_widget *w;
891
892 list_for_each_entry(w, list, power_list)
Mark Brown828a8422011-01-15 13:14:30 +0000893 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
Mark Brown38357ab2009-06-06 19:03:23 +0100894 list_add_tail(&new_widget->power_list, &w->power_list);
895 return;
Mark Brown42aa3412009-03-01 19:21:10 +0000896 }
Mark Brown6ea31b92009-04-20 17:15:41 +0100897
Mark Brown38357ab2009-06-06 19:03:23 +0100898 list_add_tail(&new_widget->power_list, list);
899}
Mark Brown42aa3412009-03-01 19:21:10 +0000900
Mark Brown68f89ad2010-11-03 23:51:49 -0400901static void dapm_seq_check_event(struct snd_soc_dapm_context *dapm,
902 struct snd_soc_dapm_widget *w, int event)
903{
904 struct snd_soc_card *card = dapm->card;
905 const char *ev_name;
906 int power, ret;
907
908 switch (event) {
909 case SND_SOC_DAPM_PRE_PMU:
910 ev_name = "PRE_PMU";
911 power = 1;
912 break;
913 case SND_SOC_DAPM_POST_PMU:
914 ev_name = "POST_PMU";
915 power = 1;
916 break;
917 case SND_SOC_DAPM_PRE_PMD:
918 ev_name = "PRE_PMD";
919 power = 0;
920 break;
921 case SND_SOC_DAPM_POST_PMD:
922 ev_name = "POST_PMD";
923 power = 0;
924 break;
925 default:
926 BUG();
927 return;
928 }
929
930 if (w->power != power)
931 return;
932
933 if (w->event && (w->event_flags & event)) {
934 pop_dbg(dapm->dev, card->pop_time, "pop test : %s %s\n",
935 w->name, ev_name);
Mark Brown84e90932010-11-04 00:07:02 -0400936 trace_snd_soc_dapm_widget_event_start(w, event);
Mark Brown68f89ad2010-11-03 23:51:49 -0400937 ret = w->event(w, NULL, event);
Mark Brown84e90932010-11-04 00:07:02 -0400938 trace_snd_soc_dapm_widget_event_done(w, event);
Mark Brown68f89ad2010-11-03 23:51:49 -0400939 if (ret < 0)
940 pr_err("%s: %s event failed: %d\n",
941 ev_name, w->name, ret);
942 }
943}
944
Mark Brownb22ead22009-06-07 12:51:26 +0100945/* Apply the coalesced changes from a DAPM sequence */
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200946static void dapm_seq_run_coalesced(struct snd_soc_dapm_context *dapm,
Mark Brownb22ead22009-06-07 12:51:26 +0100947 struct list_head *pending)
Mark Brown163cac02009-06-07 10:12:52 +0100948{
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200949 struct snd_soc_card *card = dapm->card;
Mark Brown68f89ad2010-11-03 23:51:49 -0400950 struct snd_soc_dapm_widget *w;
951 int reg, power;
Mark Brownb22ead22009-06-07 12:51:26 +0100952 unsigned int value = 0;
953 unsigned int mask = 0;
954 unsigned int cur_mask;
955
956 reg = list_first_entry(pending, struct snd_soc_dapm_widget,
957 power_list)->reg;
958
959 list_for_each_entry(w, pending, power_list) {
960 cur_mask = 1 << w->shift;
961 BUG_ON(reg != w->reg);
962
963 if (w->invert)
964 power = !w->power;
965 else
966 power = w->power;
967
968 mask |= cur_mask;
969 if (power)
970 value |= cur_mask;
971
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200972 pop_dbg(dapm->dev, card->pop_time,
Mark Brownb22ead22009-06-07 12:51:26 +0100973 "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
974 w->name, reg, value, mask);
Mark Brown81628102009-06-07 13:21:24 +0100975
Mark Brown68f89ad2010-11-03 23:51:49 -0400976 /* Check for events */
977 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_PRE_PMU);
978 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_PRE_PMD);
Mark Brownb22ead22009-06-07 12:51:26 +0100979 }
980
Mark Brown81628102009-06-07 13:21:24 +0100981 if (reg >= 0) {
Mark Brown29376bc2011-06-19 13:49:28 +0100982 /* Any widget will do, they should all be updating the
983 * same register.
984 */
985 w = list_first_entry(pending, struct snd_soc_dapm_widget,
986 power_list);
987
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +0200988 pop_dbg(dapm->dev, card->pop_time,
Mark Brown81628102009-06-07 13:21:24 +0100989 "pop test : Applying 0x%x/0x%x to %x in %dms\n",
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200990 value, mask, reg, card->pop_time);
991 pop_wait(card->pop_time);
Liam Girdwood0445bdf2011-06-13 19:37:36 +0100992 soc_widget_update_bits(w, reg, mask, value);
Mark Brown81628102009-06-07 13:21:24 +0100993 }
994
995 list_for_each_entry(w, pending, power_list) {
Mark Brown68f89ad2010-11-03 23:51:49 -0400996 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_POST_PMU);
997 dapm_seq_check_event(dapm, w, SND_SOC_DAPM_POST_PMD);
Mark Brown42aa3412009-03-01 19:21:10 +0000998 }
Mark Brown42aa3412009-03-01 19:21:10 +0000999}
1000
Mark Brownb22ead22009-06-07 12:51:26 +01001001/* Apply a DAPM power sequence.
1002 *
1003 * We walk over a pre-sorted list of widgets to apply power to. In
1004 * order to minimise the number of writes to the device required
1005 * multiple widgets will be updated in a single write where possible.
1006 * Currently anything that requires more than a single write is not
1007 * handled.
1008 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001009static void dapm_seq_run(struct snd_soc_dapm_context *dapm,
Mark Brown828a8422011-01-15 13:14:30 +00001010 struct list_head *list, int event, bool power_up)
Mark Brownb22ead22009-06-07 12:51:26 +01001011{
1012 struct snd_soc_dapm_widget *w, *n;
1013 LIST_HEAD(pending);
1014 int cur_sort = -1;
Mark Brown20e48592011-01-15 13:40:50 +00001015 int cur_subseq = -1;
Mark Brownb22ead22009-06-07 12:51:26 +01001016 int cur_reg = SND_SOC_NOPM;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001017 struct snd_soc_dapm_context *cur_dapm = NULL;
Mark Brown474b62d2011-01-18 16:14:44 +00001018 int ret, i;
Mark Brown828a8422011-01-15 13:14:30 +00001019 int *sort;
1020
1021 if (power_up)
1022 sort = dapm_up_seq;
1023 else
1024 sort = dapm_down_seq;
Mark Brown163cac02009-06-07 10:12:52 +01001025
Mark Brownb22ead22009-06-07 12:51:26 +01001026 list_for_each_entry_safe(w, n, list, power_list) {
1027 ret = 0;
1028
1029 /* Do we need to apply any queued changes? */
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001030 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
Mark Brown20e48592011-01-15 13:40:50 +00001031 w->dapm != cur_dapm || w->subseq != cur_subseq) {
Mark Brownb22ead22009-06-07 12:51:26 +01001032 if (!list_empty(&pending))
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001033 dapm_seq_run_coalesced(cur_dapm, &pending);
Mark Brownb22ead22009-06-07 12:51:26 +01001034
Mark Brown474b62d2011-01-18 16:14:44 +00001035 if (cur_dapm && cur_dapm->seq_notifier) {
1036 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1037 if (sort[i] == cur_sort)
1038 cur_dapm->seq_notifier(cur_dapm,
Mark Brownf85a9e02011-01-26 21:41:28 +00001039 i,
1040 cur_subseq);
Mark Brown474b62d2011-01-18 16:14:44 +00001041 }
1042
Mark Brownb22ead22009-06-07 12:51:26 +01001043 INIT_LIST_HEAD(&pending);
1044 cur_sort = -1;
Mark Brownb0b3e6f2011-07-16 10:55:08 +09001045 cur_subseq = INT_MIN;
Mark Brownb22ead22009-06-07 12:51:26 +01001046 cur_reg = SND_SOC_NOPM;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001047 cur_dapm = NULL;
Mark Brownb22ead22009-06-07 12:51:26 +01001048 }
1049
Mark Brown163cac02009-06-07 10:12:52 +01001050 switch (w->id) {
1051 case snd_soc_dapm_pre:
1052 if (!w->event)
Mark Brownb22ead22009-06-07 12:51:26 +01001053 list_for_each_entry_safe_continue(w, n, list,
1054 power_list);
Mark Brown163cac02009-06-07 10:12:52 +01001055
Mark Brownb22ead22009-06-07 12:51:26 +01001056 if (event == SND_SOC_DAPM_STREAM_START)
Mark Brown163cac02009-06-07 10:12:52 +01001057 ret = w->event(w,
1058 NULL, SND_SOC_DAPM_PRE_PMU);
Mark Brownb22ead22009-06-07 12:51:26 +01001059 else if (event == SND_SOC_DAPM_STREAM_STOP)
Mark Brown163cac02009-06-07 10:12:52 +01001060 ret = w->event(w,
1061 NULL, SND_SOC_DAPM_PRE_PMD);
Mark Brown163cac02009-06-07 10:12:52 +01001062 break;
1063
1064 case snd_soc_dapm_post:
1065 if (!w->event)
Mark Brownb22ead22009-06-07 12:51:26 +01001066 list_for_each_entry_safe_continue(w, n, list,
1067 power_list);
Mark Brown163cac02009-06-07 10:12:52 +01001068
Mark Brownb22ead22009-06-07 12:51:26 +01001069 if (event == SND_SOC_DAPM_STREAM_START)
Mark Brown163cac02009-06-07 10:12:52 +01001070 ret = w->event(w,
1071 NULL, SND_SOC_DAPM_POST_PMU);
Mark Brownb22ead22009-06-07 12:51:26 +01001072 else if (event == SND_SOC_DAPM_STREAM_STOP)
Mark Brown163cac02009-06-07 10:12:52 +01001073 ret = w->event(w,
1074 NULL, SND_SOC_DAPM_POST_PMD);
Mark Brownb22ead22009-06-07 12:51:26 +01001075 break;
1076
Mark Brown163cac02009-06-07 10:12:52 +01001077 default:
Mark Brown81628102009-06-07 13:21:24 +01001078 /* Queue it up for application */
1079 cur_sort = sort[w->id];
Mark Brown20e48592011-01-15 13:40:50 +00001080 cur_subseq = w->subseq;
Mark Brown81628102009-06-07 13:21:24 +01001081 cur_reg = w->reg;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001082 cur_dapm = w->dapm;
Mark Brown81628102009-06-07 13:21:24 +01001083 list_move(&w->power_list, &pending);
1084 break;
Mark Brown163cac02009-06-07 10:12:52 +01001085 }
Mark Brownb22ead22009-06-07 12:51:26 +01001086
1087 if (ret < 0)
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02001088 dev_err(w->dapm->dev,
1089 "Failed to apply widget power: %d\n", ret);
Mark Brown163cac02009-06-07 10:12:52 +01001090 }
Mark Brownb22ead22009-06-07 12:51:26 +01001091
1092 if (!list_empty(&pending))
Mark Brown28e86802011-03-08 19:29:53 +00001093 dapm_seq_run_coalesced(cur_dapm, &pending);
Mark Brown474b62d2011-01-18 16:14:44 +00001094
1095 if (cur_dapm && cur_dapm->seq_notifier) {
1096 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1097 if (sort[i] == cur_sort)
1098 cur_dapm->seq_notifier(cur_dapm,
Mark Brownf85a9e02011-01-26 21:41:28 +00001099 i, cur_subseq);
Mark Brown474b62d2011-01-18 16:14:44 +00001100 }
Mark Brown163cac02009-06-07 10:12:52 +01001101}
1102
Mark Brown97404f22010-12-14 16:13:57 +00001103static void dapm_widget_update(struct snd_soc_dapm_context *dapm)
1104{
1105 struct snd_soc_dapm_update *update = dapm->update;
1106 struct snd_soc_dapm_widget *w;
1107 int ret;
1108
1109 if (!update)
1110 return;
1111
1112 w = update->widget;
1113
1114 if (w->event &&
1115 (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1116 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1117 if (ret != 0)
1118 pr_err("%s DAPM pre-event failed: %d\n",
1119 w->name, ret);
1120 }
1121
1122 ret = snd_soc_update_bits(w->codec, update->reg, update->mask,
1123 update->val);
1124 if (ret < 0)
1125 pr_err("%s DAPM update failed: %d\n", w->name, ret);
1126
1127 if (w->event &&
1128 (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1129 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1130 if (ret != 0)
1131 pr_err("%s DAPM post-event failed: %d\n",
1132 w->name, ret);
1133 }
1134}
1135
Mark Brown9d0624a2011-02-18 11:49:43 -08001136/* Async callback run prior to DAPM sequences - brings to _PREPARE if
1137 * they're changing state.
1138 */
1139static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1140{
1141 struct snd_soc_dapm_context *d = data;
1142 int ret;
Mark Brown97404f22010-12-14 16:13:57 +00001143
Mark Brown56fba412011-06-04 11:25:10 +01001144 /* If we're off and we're not supposed to be go into STANDBY */
1145 if (d->bias_level == SND_SOC_BIAS_OFF &&
1146 d->target_bias_level != SND_SOC_BIAS_OFF) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001147 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1148 if (ret != 0)
1149 dev_err(d->dev,
1150 "Failed to turn on bias: %d\n", ret);
1151 }
1152
Mark Brown56fba412011-06-04 11:25:10 +01001153 /* Prepare for a STADDBY->ON or ON->STANDBY transition */
1154 if (d->bias_level != d->target_bias_level) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001155 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1156 if (ret != 0)
1157 dev_err(d->dev,
1158 "Failed to prepare bias: %d\n", ret);
1159 }
1160}
1161
1162/* Async callback run prior to DAPM sequences - brings to their final
1163 * state.
1164 */
1165static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1166{
1167 struct snd_soc_dapm_context *d = data;
1168 int ret;
1169
1170 /* If we just powered the last thing off drop to standby bias */
Mark Brown56fba412011-06-04 11:25:10 +01001171 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1172 (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1173 d->target_bias_level == SND_SOC_BIAS_OFF)) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001174 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1175 if (ret != 0)
1176 dev_err(d->dev, "Failed to apply standby bias: %d\n",
1177 ret);
1178 }
1179
1180 /* If we're in standby and can support bias off then do that */
Mark Brown56fba412011-06-04 11:25:10 +01001181 if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1182 d->target_bias_level == SND_SOC_BIAS_OFF) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001183 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1184 if (ret != 0)
1185 dev_err(d->dev, "Failed to turn off bias: %d\n", ret);
1186 }
1187
1188 /* If we just powered up then move to active bias */
Mark Brown56fba412011-06-04 11:25:10 +01001189 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1190 d->target_bias_level == SND_SOC_BIAS_ON) {
Mark Brown9d0624a2011-02-18 11:49:43 -08001191 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1192 if (ret != 0)
1193 dev_err(d->dev, "Failed to apply active bias: %d\n",
1194 ret);
1195 }
1196}
Mark Brown97404f22010-12-14 16:13:57 +00001197
Mark Brown7c81beb2011-09-20 22:22:32 +01001198static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1199 struct list_head *up_list,
1200 struct list_head *down_list)
1201{
1202 struct snd_soc_dapm_context *d;
1203 int power;
1204
1205 switch (w->id) {
1206 case snd_soc_dapm_pre:
1207 dapm_seq_insert(w, down_list, false);
1208 break;
1209 case snd_soc_dapm_post:
1210 dapm_seq_insert(w, up_list, true);
1211 break;
1212
1213 default:
1214 if (!w->power_check)
1215 break;
1216
1217 if (!w->force)
1218 power = w->power_check(w);
1219 else
1220 power = 1;
1221
1222 if (power) {
1223 d = w->dapm;
1224
1225 /* Supplies and micbiases only bring the
1226 * context up to STANDBY as unless something
1227 * else is active and passing audio they
1228 * generally don't require full power.
1229 */
1230 switch (w->id) {
1231 case snd_soc_dapm_supply:
1232 case snd_soc_dapm_micbias:
1233 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
1234 d->target_bias_level = SND_SOC_BIAS_STANDBY;
1235 break;
1236 default:
1237 d->target_bias_level = SND_SOC_BIAS_ON;
1238 break;
1239 }
1240 }
1241
1242 if (w->power == power)
1243 break;
1244
1245 trace_snd_soc_dapm_widget_power(w, power);
1246
1247 if (power)
1248 dapm_seq_insert(w, up_list, true);
1249 else
1250 dapm_seq_insert(w, down_list, false);
1251
1252 w->power = power;
1253 break;
1254 }
1255}
1256
Mark Brown42aa3412009-03-01 19:21:10 +00001257/*
Richard Purdie2b97eab2006-10-06 18:32:18 +02001258 * Scan each dapm widget for complete audio path.
1259 * A complete path is a route that has valid endpoints i.e.:-
1260 *
1261 * o DAC to output pin.
1262 * o Input Pin to ADC.
1263 * o Input pin to Output pin (bypass, sidetone)
1264 * o DAC to ADC (loopback).
1265 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001266static int dapm_power_widgets(struct snd_soc_dapm_context *dapm, int event)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001267{
Mark Brown12ea2c72011-03-02 18:17:32 +00001268 struct snd_soc_card *card = dapm->card;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001269 struct snd_soc_dapm_widget *w;
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001270 struct snd_soc_dapm_context *d;
Mark Brown291f3bb2009-06-07 13:57:17 +01001271 LIST_HEAD(up_list);
1272 LIST_HEAD(down_list);
Mark Brown9d0624a2011-02-18 11:49:43 -08001273 LIST_HEAD(async_domain);
Mark Brown56fba412011-06-04 11:25:10 +01001274 enum snd_soc_bias_level bias;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001275
Mark Brown84e90932010-11-04 00:07:02 -04001276 trace_snd_soc_dapm_start(card);
1277
Mark Brown56fba412011-06-04 11:25:10 +01001278 list_for_each_entry(d, &card->dapm_list, list) {
1279 if (d->n_widgets || d->codec == NULL) {
1280 if (d->idle_bias_off)
1281 d->target_bias_level = SND_SOC_BIAS_OFF;
1282 else
1283 d->target_bias_level = SND_SOC_BIAS_STANDBY;
1284 }
1285 }
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001286
Mark Brownde02d072011-09-20 21:43:24 +01001287 memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
1288
Mark Brown6d3ddc82009-05-16 17:47:29 +01001289 /* Check which widgets we need to power and store them in
1290 * lists indicating if they should be powered up or down.
1291 */
Jarkko Nikula97c866d2010-12-14 12:18:31 +02001292 list_for_each_entry(w, &card->widgets, list) {
Mark Brown7c81beb2011-09-20 22:22:32 +01001293 dapm_power_one_widget(w, &up_list, &down_list);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001294 }
1295
Mark Brownb14b76a2009-08-17 11:55:38 +01001296 /* If there are no DAPM widgets then try to figure out power from the
1297 * event type.
1298 */
Jarkko Nikula97c866d2010-12-14 12:18:31 +02001299 if (!dapm->n_widgets) {
Mark Brownb14b76a2009-08-17 11:55:38 +01001300 switch (event) {
1301 case SND_SOC_DAPM_STREAM_START:
1302 case SND_SOC_DAPM_STREAM_RESUME:
Mark Brown56fba412011-06-04 11:25:10 +01001303 dapm->target_bias_level = SND_SOC_BIAS_ON;
Mark Brownb14b76a2009-08-17 11:55:38 +01001304 break;
Jarkko Nikula862af8a2010-12-10 20:53:55 +02001305 case SND_SOC_DAPM_STREAM_STOP:
Mark Brown56fba412011-06-04 11:25:10 +01001306 if (dapm->codec->active)
1307 dapm->target_bias_level = SND_SOC_BIAS_ON;
1308 else
1309 dapm->target_bias_level = SND_SOC_BIAS_STANDBY;
Jarkko Nikula862af8a2010-12-10 20:53:55 +02001310 break;
Mark Brown50b6bce2009-11-23 13:11:53 +00001311 case SND_SOC_DAPM_STREAM_SUSPEND:
Mark Brown56fba412011-06-04 11:25:10 +01001312 dapm->target_bias_level = SND_SOC_BIAS_STANDBY;
Mark Brown50b6bce2009-11-23 13:11:53 +00001313 break;
Mark Brownb14b76a2009-08-17 11:55:38 +01001314 case SND_SOC_DAPM_STREAM_NOP:
Mark Brown56fba412011-06-04 11:25:10 +01001315 dapm->target_bias_level = dapm->bias_level;
Mark Brown50b6bce2009-11-23 13:11:53 +00001316 break;
Mark Brownb14b76a2009-08-17 11:55:38 +01001317 default:
1318 break;
1319 }
1320 }
1321
Mark Brown85a843c2011-09-21 21:29:47 +01001322 /* Force all contexts in the card to the same bias state if
1323 * they're not ground referenced.
1324 */
Mark Brown56fba412011-06-04 11:25:10 +01001325 bias = SND_SOC_BIAS_OFF;
Mark Brown52ba67b2011-04-04 21:05:11 +09001326 list_for_each_entry(d, &card->dapm_list, list)
Mark Brown56fba412011-06-04 11:25:10 +01001327 if (d->target_bias_level > bias)
1328 bias = d->target_bias_level;
Mark Brown52ba67b2011-04-04 21:05:11 +09001329 list_for_each_entry(d, &card->dapm_list, list)
Mark Brown85a843c2011-09-21 21:29:47 +01001330 if (!d->idle_bias_off)
1331 d->target_bias_level = bias;
Mark Brown52ba67b2011-04-04 21:05:11 +09001332
Mark Brownde02d072011-09-20 21:43:24 +01001333 trace_snd_soc_dapm_walk_done(card);
Mark Brown52ba67b2011-04-04 21:05:11 +09001334
Mark Brown9d0624a2011-02-18 11:49:43 -08001335 /* Run all the bias changes in parallel */
1336 list_for_each_entry(d, &dapm->card->dapm_list, list)
1337 async_schedule_domain(dapm_pre_sequence_async, d,
1338 &async_domain);
1339 async_synchronize_full_domain(&async_domain);
Mark Brown452c5ea2009-05-17 21:41:23 +01001340
Mark Brown6d3ddc82009-05-16 17:47:29 +01001341 /* Power down widgets first; try to avoid amplifying pops. */
Mark Brown828a8422011-01-15 13:14:30 +00001342 dapm_seq_run(dapm, &down_list, event, false);
Mark Brown6d3ddc82009-05-16 17:47:29 +01001343
Mark Brown97404f22010-12-14 16:13:57 +00001344 dapm_widget_update(dapm);
1345
Mark Brown6d3ddc82009-05-16 17:47:29 +01001346 /* Now power up. */
Mark Brown828a8422011-01-15 13:14:30 +00001347 dapm_seq_run(dapm, &up_list, event, true);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001348
Mark Brown9d0624a2011-02-18 11:49:43 -08001349 /* Run all the bias changes in parallel */
1350 list_for_each_entry(d, &dapm->card->dapm_list, list)
1351 async_schedule_domain(dapm_post_sequence_async, d,
1352 &async_domain);
1353 async_synchronize_full_domain(&async_domain);
Mark Brown452c5ea2009-05-17 21:41:23 +01001354
Jarkko Nikulafd8d3bc2010-11-09 14:40:28 +02001355 pop_dbg(dapm->dev, card->pop_time,
1356 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
Jarkko Nikula3a45b862010-11-05 20:35:21 +02001357 pop_wait(card->pop_time);
Mark Browncb507e72009-07-08 18:54:57 +01001358
Mark Brown84e90932010-11-04 00:07:02 -04001359 trace_snd_soc_dapm_done(card);
1360
Mark Brown42aa3412009-03-01 19:21:10 +00001361 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001362}
1363
Mark Brown79fb9382009-08-21 16:38:13 +01001364#ifdef CONFIG_DEBUG_FS
1365static int dapm_widget_power_open_file(struct inode *inode, struct file *file)
1366{
1367 file->private_data = inode->i_private;
1368 return 0;
1369}
1370
1371static ssize_t dapm_widget_power_read_file(struct file *file,
1372 char __user *user_buf,
1373 size_t count, loff_t *ppos)
1374{
1375 struct snd_soc_dapm_widget *w = file->private_data;
1376 char *buf;
1377 int in, out;
1378 ssize_t ret;
1379 struct snd_soc_dapm_path *p = NULL;
1380
1381 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1382 if (!buf)
1383 return -ENOMEM;
1384
1385 in = is_connected_input_ep(w);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001386 dapm_clear_walk(w->dapm);
Mark Brown79fb9382009-08-21 16:38:13 +01001387 out = is_connected_output_ep(w);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001388 dapm_clear_walk(w->dapm);
Mark Brown79fb9382009-08-21 16:38:13 +01001389
Mark Brownd033c362009-12-04 15:25:56 +00001390 ret = snprintf(buf, PAGE_SIZE, "%s: %s in %d out %d",
Mark Brown79fb9382009-08-21 16:38:13 +01001391 w->name, w->power ? "On" : "Off", in, out);
1392
Mark Brownd033c362009-12-04 15:25:56 +00001393 if (w->reg >= 0)
1394 ret += snprintf(buf + ret, PAGE_SIZE - ret,
1395 " - R%d(0x%x) bit %d",
1396 w->reg, w->reg, w->shift);
1397
1398 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1399
Mark Brown3eef08b2009-09-14 16:49:00 +01001400 if (w->sname)
1401 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1402 w->sname,
1403 w->active ? "active" : "inactive");
Mark Brown79fb9382009-08-21 16:38:13 +01001404
1405 list_for_each_entry(p, &w->sources, list_sink) {
Mark Brown215edda2009-09-08 18:59:05 +01001406 if (p->connected && !p->connected(w, p->sink))
1407 continue;
1408
Mark Brown79fb9382009-08-21 16:38:13 +01001409 if (p->connect)
1410 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Dimitris Papastamos67f5ed62011-02-24 17:09:32 +00001411 " in \"%s\" \"%s\"\n",
Mark Brown79fb9382009-08-21 16:38:13 +01001412 p->name ? p->name : "static",
1413 p->source->name);
1414 }
1415 list_for_each_entry(p, &w->sinks, list_source) {
Mark Brown215edda2009-09-08 18:59:05 +01001416 if (p->connected && !p->connected(w, p->sink))
1417 continue;
1418
Mark Brown79fb9382009-08-21 16:38:13 +01001419 if (p->connect)
1420 ret += snprintf(buf + ret, PAGE_SIZE - ret,
Dimitris Papastamos67f5ed62011-02-24 17:09:32 +00001421 " out \"%s\" \"%s\"\n",
Mark Brown79fb9382009-08-21 16:38:13 +01001422 p->name ? p->name : "static",
1423 p->sink->name);
1424 }
1425
1426 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
1427
1428 kfree(buf);
1429 return ret;
1430}
1431
1432static const struct file_operations dapm_widget_power_fops = {
1433 .open = dapm_widget_power_open_file,
1434 .read = dapm_widget_power_read_file,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001435 .llseek = default_llseek,
Mark Brown79fb9382009-08-21 16:38:13 +01001436};
1437
Mark Brownef49e4f2011-04-04 20:48:13 +09001438static int dapm_bias_open_file(struct inode *inode, struct file *file)
1439{
1440 file->private_data = inode->i_private;
1441 return 0;
1442}
1443
1444static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
1445 size_t count, loff_t *ppos)
1446{
1447 struct snd_soc_dapm_context *dapm = file->private_data;
1448 char *level;
1449
1450 switch (dapm->bias_level) {
1451 case SND_SOC_BIAS_ON:
1452 level = "On\n";
1453 break;
1454 case SND_SOC_BIAS_PREPARE:
1455 level = "Prepare\n";
1456 break;
1457 case SND_SOC_BIAS_STANDBY:
1458 level = "Standby\n";
1459 break;
1460 case SND_SOC_BIAS_OFF:
1461 level = "Off\n";
1462 break;
1463 default:
1464 BUG();
1465 level = "Unknown\n";
1466 break;
1467 }
1468
1469 return simple_read_from_buffer(user_buf, count, ppos, level,
1470 strlen(level));
1471}
1472
1473static const struct file_operations dapm_bias_fops = {
1474 .open = dapm_bias_open_file,
1475 .read = dapm_bias_read_file,
1476 .llseek = default_llseek,
1477};
1478
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02001479void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
1480 struct dentry *parent)
Mark Brown79fb9382009-08-21 16:38:13 +01001481{
Mark Brown79fb9382009-08-21 16:38:13 +01001482 struct dentry *d;
1483
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02001484 dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
1485
1486 if (!dapm->debugfs_dapm) {
1487 printk(KERN_WARNING
1488 "Failed to create DAPM debugfs directory\n");
Mark Brown79fb9382009-08-21 16:38:13 +01001489 return;
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02001490 }
Mark Brown79fb9382009-08-21 16:38:13 +01001491
Mark Brownef49e4f2011-04-04 20:48:13 +09001492 d = debugfs_create_file("bias_level", 0444,
1493 dapm->debugfs_dapm, dapm,
1494 &dapm_bias_fops);
1495 if (!d)
1496 dev_warn(dapm->dev,
1497 "ASoC: Failed to create bias level debugfs file\n");
Mark Brown79fb9382009-08-21 16:38:13 +01001498}
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001499
1500static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
1501{
1502 struct snd_soc_dapm_context *dapm = w->dapm;
1503 struct dentry *d;
1504
1505 if (!dapm->debugfs_dapm || !w->name)
1506 return;
1507
1508 d = debugfs_create_file(w->name, 0444,
1509 dapm->debugfs_dapm, w,
1510 &dapm_widget_power_fops);
1511 if (!d)
1512 dev_warn(w->dapm->dev,
1513 "ASoC: Failed to create %s debugfs file\n",
1514 w->name);
1515}
1516
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02001517static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
1518{
1519 debugfs_remove_recursive(dapm->debugfs_dapm);
1520}
1521
Mark Brown79fb9382009-08-21 16:38:13 +01001522#else
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +02001523void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
1524 struct dentry *parent)
Mark Brown79fb9382009-08-21 16:38:13 +01001525{
1526}
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001527
1528static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
1529{
1530}
1531
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02001532static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
1533{
1534}
1535
Mark Brown79fb9382009-08-21 16:38:13 +01001536#endif
1537
Richard Purdie2b97eab2006-10-06 18:32:18 +02001538/* test and update the power status of a mux widget */
Adrian Bunkd9c96cf2006-11-28 12:10:09 +01001539static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget,
Mark Brown3a655772009-10-05 17:23:30 +01001540 struct snd_kcontrol *kcontrol, int change,
1541 int mux, struct soc_enum *e)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001542{
1543 struct snd_soc_dapm_path *path;
1544 int found = 0;
1545
Peter Ujfalusieff317d2009-01-15 14:40:47 +02001546 if (widget->id != snd_soc_dapm_mux &&
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +00001547 widget->id != snd_soc_dapm_virt_mux &&
Peter Ujfalusieff317d2009-01-15 14:40:47 +02001548 widget->id != snd_soc_dapm_value_mux)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001549 return -ENODEV;
1550
Mark Brown3a655772009-10-05 17:23:30 +01001551 if (!change)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001552 return 0;
1553
1554 /* find dapm widget path assoc with kcontrol */
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02001555 list_for_each_entry(path, &widget->dapm->card->paths, list) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02001556 if (path->kcontrol != kcontrol)
1557 continue;
1558
Richard Zhaocb01e2b2008-10-07 08:05:20 +08001559 if (!path->name || !e->texts[mux])
Richard Purdie2b97eab2006-10-06 18:32:18 +02001560 continue;
1561
1562 found = 1;
1563 /* we now need to match the string in the enum to the path */
Richard Zhaocb01e2b2008-10-07 08:05:20 +08001564 if (!(strcmp(path->name, e->texts[mux])))
Richard Purdie2b97eab2006-10-06 18:32:18 +02001565 path->connect = 1; /* new connection */
1566 else
1567 path->connect = 0; /* old connection must be powered down */
1568 }
1569
Mark Brownb91b8fa2010-01-20 18:18:35 +00001570 if (found)
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001571 dapm_power_widgets(widget->dapm, SND_SOC_DAPM_STREAM_NOP);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001572
1573 return 0;
1574}
Richard Purdie2b97eab2006-10-06 18:32:18 +02001575
Milan plzik1b075e32008-01-10 14:39:46 +01001576/* test and update the power status of a mixer or switch widget */
Adrian Bunkd9c96cf2006-11-28 12:10:09 +01001577static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget,
Mark Brown283375c2009-12-07 18:09:03 +00001578 struct snd_kcontrol *kcontrol, int connect)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001579{
1580 struct snd_soc_dapm_path *path;
1581 int found = 0;
1582
Milan plzik1b075e32008-01-10 14:39:46 +01001583 if (widget->id != snd_soc_dapm_mixer &&
Ian Moltonca9c1aa2009-01-06 20:11:51 +00001584 widget->id != snd_soc_dapm_mixer_named_ctl &&
Milan plzik1b075e32008-01-10 14:39:46 +01001585 widget->id != snd_soc_dapm_switch)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001586 return -ENODEV;
1587
Richard Purdie2b97eab2006-10-06 18:32:18 +02001588 /* find dapm widget path assoc with kcontrol */
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02001589 list_for_each_entry(path, &widget->dapm->card->paths, list) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02001590 if (path->kcontrol != kcontrol)
1591 continue;
1592
1593 /* found, now check type */
1594 found = 1;
Mark Brown283375c2009-12-07 18:09:03 +00001595 path->connect = connect;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001596 }
1597
Mark Brownb91b8fa2010-01-20 18:18:35 +00001598 if (found)
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001599 dapm_power_widgets(widget->dapm, SND_SOC_DAPM_STREAM_NOP);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001600
1601 return 0;
1602}
Richard Purdie2b97eab2006-10-06 18:32:18 +02001603
1604/* show dapm widget status in sys fs */
1605static ssize_t dapm_widget_show(struct device *dev,
1606 struct device_attribute *attr, char *buf)
1607{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001608 struct snd_soc_pcm_runtime *rtd =
1609 container_of(dev, struct snd_soc_pcm_runtime, dev);
1610 struct snd_soc_codec *codec =rtd->codec;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001611 struct snd_soc_dapm_widget *w;
1612 int count = 0;
1613 char *state = "not set";
1614
Jarkko Nikula97c866d2010-12-14 12:18:31 +02001615 list_for_each_entry(w, &codec->card->widgets, list) {
1616 if (w->dapm != &codec->dapm)
1617 continue;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001618
1619 /* only display widgets that burnm power */
1620 switch (w->id) {
1621 case snd_soc_dapm_hp:
1622 case snd_soc_dapm_mic:
1623 case snd_soc_dapm_spk:
1624 case snd_soc_dapm_line:
1625 case snd_soc_dapm_micbias:
1626 case snd_soc_dapm_dac:
1627 case snd_soc_dapm_adc:
1628 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06001629 case snd_soc_dapm_out_drv:
Richard Purdie2b97eab2006-10-06 18:32:18 +02001630 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00001631 case snd_soc_dapm_mixer_named_ctl:
Mark Brown246d0a12009-04-22 18:24:55 +01001632 case snd_soc_dapm_supply:
Richard Purdie2b97eab2006-10-06 18:32:18 +02001633 if (w->name)
1634 count += sprintf(buf + count, "%s: %s\n",
1635 w->name, w->power ? "On":"Off");
1636 break;
1637 default:
1638 break;
1639 }
1640 }
1641
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001642 switch (codec->dapm.bias_level) {
Mark Brown0be98982008-05-19 12:31:28 +02001643 case SND_SOC_BIAS_ON:
1644 state = "On";
Richard Purdie2b97eab2006-10-06 18:32:18 +02001645 break;
Mark Brown0be98982008-05-19 12:31:28 +02001646 case SND_SOC_BIAS_PREPARE:
1647 state = "Prepare";
Richard Purdie2b97eab2006-10-06 18:32:18 +02001648 break;
Mark Brown0be98982008-05-19 12:31:28 +02001649 case SND_SOC_BIAS_STANDBY:
1650 state = "Standby";
Richard Purdie2b97eab2006-10-06 18:32:18 +02001651 break;
Mark Brown0be98982008-05-19 12:31:28 +02001652 case SND_SOC_BIAS_OFF:
1653 state = "Off";
Richard Purdie2b97eab2006-10-06 18:32:18 +02001654 break;
1655 }
1656 count += sprintf(buf + count, "PM State: %s\n", state);
1657
1658 return count;
1659}
1660
1661static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
1662
1663int snd_soc_dapm_sys_add(struct device *dev)
1664{
Troy Kisky12ef1932008-10-13 17:42:14 -07001665 return device_create_file(dev, &dev_attr_dapm_widget);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001666}
1667
1668static void snd_soc_dapm_sys_remove(struct device *dev)
1669{
Mark Brownaef90842009-05-16 17:53:16 +01001670 device_remove_file(dev, &dev_attr_dapm_widget);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001671}
1672
1673/* free all dapm widgets and resources */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001674static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001675{
1676 struct snd_soc_dapm_widget *w, *next_w;
1677 struct snd_soc_dapm_path *p, *next_p;
1678
Jarkko Nikula97c866d2010-12-14 12:18:31 +02001679 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
1680 if (w->dapm != dapm)
1681 continue;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001682 list_del(&w->list);
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02001683 /*
1684 * remove source and sink paths associated to this widget.
1685 * While removing the path, remove reference to it from both
1686 * source and sink widgets so that path is removed only once.
1687 */
1688 list_for_each_entry_safe(p, next_p, &w->sources, list_sink) {
1689 list_del(&p->list_sink);
1690 list_del(&p->list_source);
1691 list_del(&p->list);
1692 kfree(p->long_name);
1693 kfree(p);
1694 }
1695 list_for_each_entry_safe(p, next_p, &w->sinks, list_source) {
1696 list_del(&p->list_sink);
1697 list_del(&p->list_source);
1698 list_del(&p->list);
1699 kfree(p->long_name);
1700 kfree(p);
1701 }
Stephen Warrenfad59882011-04-28 17:37:59 -06001702 kfree(w->kcontrols);
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001703 kfree(w->name);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001704 kfree(w);
1705 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02001706}
1707
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02001708static struct snd_soc_dapm_widget *dapm_find_widget(
1709 struct snd_soc_dapm_context *dapm, const char *pin,
1710 bool search_other_contexts)
1711{
1712 struct snd_soc_dapm_widget *w;
1713 struct snd_soc_dapm_widget *fallback = NULL;
1714
1715 list_for_each_entry(w, &dapm->card->widgets, list) {
1716 if (!strcmp(w->name, pin)) {
1717 if (w->dapm == dapm)
1718 return w;
1719 else
1720 fallback = w;
1721 }
1722 }
1723
1724 if (search_other_contexts)
1725 return fallback;
1726
1727 return NULL;
1728}
1729
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001730static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
Mark Brown16499232009-01-07 18:25:13 +00001731 const char *pin, int status)
Liam Girdwooda5302182008-07-07 13:35:17 +01001732{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02001733 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Liam Girdwooda5302182008-07-07 13:35:17 +01001734
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02001735 if (!w) {
1736 dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
1737 return -EINVAL;
Liam Girdwooda5302182008-07-07 13:35:17 +01001738 }
1739
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02001740 w->connected = status;
1741 if (status == 0)
1742 w->force = 0;
Mark Brown0d867332011-04-06 11:38:14 +09001743
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02001744 return 0;
Liam Girdwooda5302182008-07-07 13:35:17 +01001745}
1746
Richard Purdie2b97eab2006-10-06 18:32:18 +02001747/**
Liam Girdwooda5302182008-07-07 13:35:17 +01001748 * snd_soc_dapm_sync - scan and power dapm paths
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001749 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02001750 *
1751 * Walks all dapm audio paths and powers widgets according to their
1752 * stream or path usage.
1753 *
1754 * Returns 0 for success.
1755 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001756int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001757{
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001758 return dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001759}
Liam Girdwooda5302182008-07-07 13:35:17 +01001760EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001761
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001762static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
Mark Brown215edda2009-09-08 18:59:05 +01001763 const struct snd_soc_dapm_route *route)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001764{
1765 struct snd_soc_dapm_path *path;
1766 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
Jarkko Nikula97c866d2010-12-14 12:18:31 +02001767 struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001768 const char *sink;
Mark Brown215edda2009-09-08 18:59:05 +01001769 const char *control = route->control;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001770 const char *source;
1771 char prefixed_sink[80];
1772 char prefixed_source[80];
Richard Purdie2b97eab2006-10-06 18:32:18 +02001773 int ret = 0;
1774
Mark Brown88e8b9a2011-03-02 18:18:24 +00001775 if (dapm->codec && dapm->codec->name_prefix) {
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001776 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
1777 dapm->codec->name_prefix, route->sink);
1778 sink = prefixed_sink;
1779 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
1780 dapm->codec->name_prefix, route->source);
1781 source = prefixed_source;
1782 } else {
1783 sink = route->sink;
1784 source = route->source;
1785 }
1786
Jarkko Nikula97c866d2010-12-14 12:18:31 +02001787 /*
1788 * find src and dest widgets over all widgets but favor a widget from
1789 * current DAPM context
1790 */
1791 list_for_each_entry(w, &dapm->card->widgets, list) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02001792 if (!wsink && !(strcmp(w->name, sink))) {
Jarkko Nikula97c866d2010-12-14 12:18:31 +02001793 wtsink = w;
1794 if (w->dapm == dapm)
1795 wsink = w;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001796 continue;
1797 }
1798 if (!wsource && !(strcmp(w->name, source))) {
Jarkko Nikula97c866d2010-12-14 12:18:31 +02001799 wtsource = w;
1800 if (w->dapm == dapm)
1801 wsource = w;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001802 }
1803 }
Jarkko Nikula97c866d2010-12-14 12:18:31 +02001804 /* use widget from another DAPM context if not found from this */
1805 if (!wsink)
1806 wsink = wtsink;
1807 if (!wsource)
1808 wsource = wtsource;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001809
1810 if (wsource == NULL || wsink == NULL)
1811 return -ENODEV;
1812
1813 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
1814 if (!path)
1815 return -ENOMEM;
1816
1817 path->source = wsource;
1818 path->sink = wsink;
Mark Brown215edda2009-09-08 18:59:05 +01001819 path->connected = route->connected;
Richard Purdie2b97eab2006-10-06 18:32:18 +02001820 INIT_LIST_HEAD(&path->list);
1821 INIT_LIST_HEAD(&path->list_source);
1822 INIT_LIST_HEAD(&path->list_sink);
1823
1824 /* check for external widgets */
1825 if (wsink->id == snd_soc_dapm_input) {
1826 if (wsource->id == snd_soc_dapm_micbias ||
1827 wsource->id == snd_soc_dapm_mic ||
Rongrong Cao087d53a2009-07-10 20:13:30 +01001828 wsource->id == snd_soc_dapm_line ||
1829 wsource->id == snd_soc_dapm_output)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001830 wsink->ext = 1;
1831 }
1832 if (wsource->id == snd_soc_dapm_output) {
1833 if (wsink->id == snd_soc_dapm_spk ||
1834 wsink->id == snd_soc_dapm_hp ||
Seth Forshee1e392212007-04-16 15:36:42 +02001835 wsink->id == snd_soc_dapm_line ||
1836 wsink->id == snd_soc_dapm_input)
Richard Purdie2b97eab2006-10-06 18:32:18 +02001837 wsource->ext = 1;
1838 }
1839
1840 /* connect static paths */
1841 if (control == NULL) {
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02001842 list_add(&path->list, &dapm->card->paths);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001843 list_add(&path->list_sink, &wsink->sources);
1844 list_add(&path->list_source, &wsource->sinks);
1845 path->connect = 1;
1846 return 0;
1847 }
1848
1849 /* connect dynamic paths */
Lu Guanqundc2bea62011-04-20 16:00:36 +08001850 switch (wsink->id) {
Richard Purdie2b97eab2006-10-06 18:32:18 +02001851 case snd_soc_dapm_adc:
1852 case snd_soc_dapm_dac:
1853 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06001854 case snd_soc_dapm_out_drv:
Richard Purdie2b97eab2006-10-06 18:32:18 +02001855 case snd_soc_dapm_input:
1856 case snd_soc_dapm_output:
1857 case snd_soc_dapm_micbias:
1858 case snd_soc_dapm_vmid:
1859 case snd_soc_dapm_pre:
1860 case snd_soc_dapm_post:
Mark Brown246d0a12009-04-22 18:24:55 +01001861 case snd_soc_dapm_supply:
Mark Brown010ff262009-08-17 17:39:22 +01001862 case snd_soc_dapm_aif_in:
1863 case snd_soc_dapm_aif_out:
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02001864 list_add(&path->list, &dapm->card->paths);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001865 list_add(&path->list_sink, &wsink->sources);
1866 list_add(&path->list_source, &wsource->sinks);
1867 path->connect = 1;
1868 return 0;
1869 case snd_soc_dapm_mux:
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +00001870 case snd_soc_dapm_virt_mux:
Peter Ujfalusi74155552009-01-08 13:34:29 +02001871 case snd_soc_dapm_value_mux:
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001872 ret = dapm_connect_mux(dapm, wsource, wsink, path, control,
Stephen Warren82cfecd2011-04-28 17:37:58 -06001873 &wsink->kcontrol_news[0]);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001874 if (ret != 0)
1875 goto err;
1876 break;
1877 case snd_soc_dapm_switch:
1878 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00001879 case snd_soc_dapm_mixer_named_ctl:
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001880 ret = dapm_connect_mixer(dapm, wsource, wsink, path, control);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001881 if (ret != 0)
1882 goto err;
1883 break;
1884 case snd_soc_dapm_hp:
1885 case snd_soc_dapm_mic:
1886 case snd_soc_dapm_line:
1887 case snd_soc_dapm_spk:
Jarkko Nikula8ddab3f2010-12-14 12:18:30 +02001888 list_add(&path->list, &dapm->card->paths);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001889 list_add(&path->list_sink, &wsink->sources);
1890 list_add(&path->list_source, &wsource->sinks);
1891 path->connect = 0;
1892 return 0;
1893 }
1894 return 0;
1895
1896err:
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02001897 dev_warn(dapm->dev, "asoc: no dapm match for %s --> %s --> %s\n",
1898 source, control, sink);
Richard Purdie2b97eab2006-10-06 18:32:18 +02001899 kfree(path);
1900 return ret;
1901}
Mark Brown105f1c22008-05-13 14:52:19 +02001902
1903/**
Mark Brown105f1c22008-05-13 14:52:19 +02001904 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001905 * @dapm: DAPM context
Mark Brown105f1c22008-05-13 14:52:19 +02001906 * @route: audio routes
1907 * @num: number of routes
1908 *
1909 * Connects 2 dapm widgets together via a named audio path. The sink is
1910 * the widget receiving the audio signal, whilst the source is the sender
1911 * of the audio signal.
1912 *
1913 * Returns 0 for success else error. On error all resources can be freed
1914 * with a call to snd_soc_card_free().
1915 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001916int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
Mark Brown105f1c22008-05-13 14:52:19 +02001917 const struct snd_soc_dapm_route *route, int num)
1918{
1919 int i, ret;
1920
1921 for (i = 0; i < num; i++) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001922 ret = snd_soc_dapm_add_route(dapm, route);
Mark Brown105f1c22008-05-13 14:52:19 +02001923 if (ret < 0) {
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02001924 dev_err(dapm->dev, "Failed to add route %s->%s\n",
1925 route->source, route->sink);
Mark Brown105f1c22008-05-13 14:52:19 +02001926 return ret;
1927 }
1928 route++;
1929 }
1930
1931 return 0;
1932}
1933EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
1934
Mark Brownbf3a9e12011-06-13 16:42:29 +01001935static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
1936 const struct snd_soc_dapm_route *route)
1937{
1938 struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
1939 route->source,
1940 true);
1941 struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
1942 route->sink,
1943 true);
1944 struct snd_soc_dapm_path *path;
1945 int count = 0;
1946
1947 if (!source) {
1948 dev_err(dapm->dev, "Unable to find source %s for weak route\n",
1949 route->source);
1950 return -ENODEV;
1951 }
1952
1953 if (!sink) {
1954 dev_err(dapm->dev, "Unable to find sink %s for weak route\n",
1955 route->sink);
1956 return -ENODEV;
1957 }
1958
1959 if (route->control || route->connected)
1960 dev_warn(dapm->dev, "Ignoring control for weak route %s->%s\n",
1961 route->source, route->sink);
1962
1963 list_for_each_entry(path, &source->sinks, list_source) {
1964 if (path->sink == sink) {
1965 path->weak = 1;
1966 count++;
1967 }
1968 }
1969
1970 if (count == 0)
1971 dev_err(dapm->dev, "No path found for weak route %s->%s\n",
1972 route->source, route->sink);
1973 if (count > 1)
1974 dev_warn(dapm->dev, "%d paths found for weak route %s->%s\n",
1975 count, route->source, route->sink);
1976
1977 return 0;
1978}
1979
1980/**
1981 * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
1982 * @dapm: DAPM context
1983 * @route: audio routes
1984 * @num: number of routes
1985 *
1986 * Mark existing routes matching those specified in the passed array
1987 * as being weak, meaning that they are ignored for the purpose of
1988 * power decisions. The main intended use case is for sidetone paths
1989 * which couple audio between other independent paths if they are both
1990 * active in order to make the combination work better at the user
1991 * level but which aren't intended to be "used".
1992 *
1993 * Note that CODEC drivers should not use this as sidetone type paths
1994 * can frequently also be used as bypass paths.
1995 */
1996int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
1997 const struct snd_soc_dapm_route *route, int num)
1998{
1999 int i, err;
2000 int ret = 0;
2001
2002 for (i = 0; i < num; i++) {
2003 err = snd_soc_dapm_weak_route(dapm, route);
2004 if (err)
2005 ret = err;
2006 route++;
2007 }
2008
2009 return ret;
2010}
2011EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2012
Mark Brown105f1c22008-05-13 14:52:19 +02002013/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02002014 * snd_soc_dapm_new_widgets - add new dapm widgets
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002015 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02002016 *
2017 * Checks the codec for any new dapm widgets and creates them if found.
2018 *
2019 * Returns 0 for success.
2020 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002021int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002022{
2023 struct snd_soc_dapm_widget *w;
Mark Brownb66a70d2011-02-09 18:04:11 +00002024 unsigned int val;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002025
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002026 list_for_each_entry(w, &dapm->card->widgets, list)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002027 {
2028 if (w->new)
2029 continue;
2030
Stephen Warrenfad59882011-04-28 17:37:59 -06002031 if (w->num_kcontrols) {
2032 w->kcontrols = kzalloc(w->num_kcontrols *
2033 sizeof(struct snd_kcontrol *),
2034 GFP_KERNEL);
2035 if (!w->kcontrols)
2036 return -ENOMEM;
2037 }
2038
Richard Purdie2b97eab2006-10-06 18:32:18 +02002039 switch(w->id) {
2040 case snd_soc_dapm_switch:
2041 case snd_soc_dapm_mixer:
Ian Moltonca9c1aa2009-01-06 20:11:51 +00002042 case snd_soc_dapm_mixer_named_ctl:
Mark Brownb75576d2009-04-20 17:56:13 +01002043 w->power_check = dapm_generic_check_power;
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002044 dapm_new_mixer(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002045 break;
2046 case snd_soc_dapm_mux:
Dimitris Papastamos24ff33a2010-12-16 15:53:39 +00002047 case snd_soc_dapm_virt_mux:
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002048 case snd_soc_dapm_value_mux:
Mark Brownb75576d2009-04-20 17:56:13 +01002049 w->power_check = dapm_generic_check_power;
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002050 dapm_new_mux(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002051 break;
2052 case snd_soc_dapm_adc:
Mark Brown010ff262009-08-17 17:39:22 +01002053 case snd_soc_dapm_aif_out:
Mark Brownb75576d2009-04-20 17:56:13 +01002054 w->power_check = dapm_adc_check_power;
2055 break;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002056 case snd_soc_dapm_dac:
Mark Brown010ff262009-08-17 17:39:22 +01002057 case snd_soc_dapm_aif_in:
Mark Brownb75576d2009-04-20 17:56:13 +01002058 w->power_check = dapm_dac_check_power;
2059 break;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002060 case snd_soc_dapm_pga:
Olaya, Margaritad88429a2010-12-10 21:11:44 -06002061 case snd_soc_dapm_out_drv:
Mark Brownb75576d2009-04-20 17:56:13 +01002062 w->power_check = dapm_generic_check_power;
Lars-Peter Clausen4b80b8c2011-06-09 13:22:36 +02002063 dapm_new_pga(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002064 break;
2065 case snd_soc_dapm_input:
2066 case snd_soc_dapm_output:
2067 case snd_soc_dapm_micbias:
2068 case snd_soc_dapm_spk:
2069 case snd_soc_dapm_hp:
2070 case snd_soc_dapm_mic:
2071 case snd_soc_dapm_line:
Mark Brownb75576d2009-04-20 17:56:13 +01002072 w->power_check = dapm_generic_check_power;
2073 break;
Mark Brown246d0a12009-04-22 18:24:55 +01002074 case snd_soc_dapm_supply:
2075 w->power_check = dapm_supply_check_power;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002076 case snd_soc_dapm_vmid:
2077 case snd_soc_dapm_pre:
2078 case snd_soc_dapm_post:
2079 break;
2080 }
Mark Brownb66a70d2011-02-09 18:04:11 +00002081
2082 /* Read the initial power state from the device */
2083 if (w->reg >= 0) {
Liam Girdwood0445bdf2011-06-13 19:37:36 +01002084 val = soc_widget_read(w, w->reg);
Mark Brownb66a70d2011-02-09 18:04:11 +00002085 val &= 1 << w->shift;
2086 if (w->invert)
2087 val = !val;
2088
2089 if (val)
2090 w->power = 1;
2091 }
2092
Richard Purdie2b97eab2006-10-06 18:32:18 +02002093 w->new = 1;
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02002094
2095 dapm_debugfs_add_widget(w);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002096 }
2097
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002098 dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002099 return 0;
2100}
2101EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
2102
2103/**
2104 * snd_soc_dapm_get_volsw - dapm mixer get callback
2105 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002106 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02002107 *
2108 * Callback to get the value of a dapm mixer control.
2109 *
2110 * Returns 0 for success.
2111 */
2112int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
2113 struct snd_ctl_elem_value *ucontrol)
2114{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002115 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2116 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
Jon Smirl4eaa9812008-07-29 11:42:26 +01002117 struct soc_mixer_control *mc =
2118 (struct soc_mixer_control *)kcontrol->private_value;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002119 unsigned int reg = mc->reg;
2120 unsigned int shift = mc->shift;
2121 unsigned int rshift = mc->rshift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002122 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002123 unsigned int invert = mc->invert;
2124 unsigned int mask = (1 << fls(max)) - 1;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002125
Richard Purdie2b97eab2006-10-06 18:32:18 +02002126 ucontrol->value.integer.value[0] =
2127 (snd_soc_read(widget->codec, reg) >> shift) & mask;
2128 if (shift != rshift)
2129 ucontrol->value.integer.value[1] =
2130 (snd_soc_read(widget->codec, reg) >> rshift) & mask;
2131 if (invert) {
2132 ucontrol->value.integer.value[0] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002133 max - ucontrol->value.integer.value[0];
Richard Purdie2b97eab2006-10-06 18:32:18 +02002134 if (shift != rshift)
2135 ucontrol->value.integer.value[1] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002136 max - ucontrol->value.integer.value[1];
Richard Purdie2b97eab2006-10-06 18:32:18 +02002137 }
2138
2139 return 0;
2140}
2141EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
2142
2143/**
2144 * snd_soc_dapm_put_volsw - dapm mixer set callback
2145 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002146 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02002147 *
2148 * Callback to set the value of a dapm mixer control.
2149 *
2150 * Returns 0 for success.
2151 */
2152int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
2153 struct snd_ctl_elem_value *ucontrol)
2154{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002155 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2156 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2157 struct snd_soc_codec *codec = widget->codec;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002158 struct soc_mixer_control *mc =
2159 (struct soc_mixer_control *)kcontrol->private_value;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002160 unsigned int reg = mc->reg;
2161 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002162 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002163 unsigned int mask = (1 << fls(max)) - 1;
2164 unsigned int invert = mc->invert;
Stephen Warrene9cf7042011-01-27 14:54:05 -07002165 unsigned int val;
Mark Brown97404f22010-12-14 16:13:57 +00002166 int connect, change;
2167 struct snd_soc_dapm_update update;
Stephen Warrenfafd2172011-04-28 17:38:00 -06002168 int wi;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002169
2170 val = (ucontrol->value.integer.value[0] & mask);
2171
2172 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002173 val = max - val;
Stephen Warrene9cf7042011-01-27 14:54:05 -07002174 mask = mask << shift;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002175 val = val << shift;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002176
Stephen Warrenfafd2172011-04-28 17:38:00 -06002177 if (val)
2178 /* new connection */
2179 connect = invert ? 0 : 1;
2180 else
2181 /* old connection must be powered down */
2182 connect = invert ? 1 : 0;
2183
2184 mutex_lock(&codec->mutex);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002185
Stephen Warrene9cf7042011-01-27 14:54:05 -07002186 change = snd_soc_test_bits(widget->codec, reg, mask, val);
Mark Brown97404f22010-12-14 16:13:57 +00002187 if (change) {
Stephen Warrenfafd2172011-04-28 17:38:00 -06002188 for (wi = 0; wi < wlist->num_widgets; wi++) {
2189 widget = wlist->widgets[wi];
Mark Brown283375c2009-12-07 18:09:03 +00002190
Stephen Warrenfafd2172011-04-28 17:38:00 -06002191 widget->value = val;
Mark Brown97404f22010-12-14 16:13:57 +00002192
Stephen Warrenfafd2172011-04-28 17:38:00 -06002193 update.kcontrol = kcontrol;
2194 update.widget = widget;
2195 update.reg = reg;
2196 update.mask = mask;
2197 update.val = val;
2198 widget->dapm->update = &update;
Mark Brown97404f22010-12-14 16:13:57 +00002199
Stephen Warrenfafd2172011-04-28 17:38:00 -06002200 dapm_mixer_update_power(widget, kcontrol, connect);
2201
2202 widget->dapm->update = NULL;
2203 }
Mark Brown283375c2009-12-07 18:09:03 +00002204 }
2205
Stephen Warrenfafd2172011-04-28 17:38:00 -06002206 mutex_unlock(&codec->mutex);
Mark Brown97404f22010-12-14 16:13:57 +00002207 return 0;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002208}
2209EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
2210
2211/**
2212 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
2213 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002214 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02002215 *
2216 * Callback to get the value of a dapm enumerated double mixer control.
2217 *
2218 * Returns 0 for success.
2219 */
2220int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
2221 struct snd_ctl_elem_value *ucontrol)
2222{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002223 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2224 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
Richard Purdie2b97eab2006-10-06 18:32:18 +02002225 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002226 unsigned int val, bitmask;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002227
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002228 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002229 ;
2230 val = snd_soc_read(widget->codec, e->reg);
2231 ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
2232 if (e->shift_l != e->shift_r)
2233 ucontrol->value.enumerated.item[1] =
2234 (val >> e->shift_r) & (bitmask - 1);
2235
2236 return 0;
2237}
2238EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
2239
2240/**
2241 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
2242 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002243 * @ucontrol: control element information
Richard Purdie2b97eab2006-10-06 18:32:18 +02002244 *
2245 * Callback to set the value of a dapm enumerated double mixer control.
2246 *
2247 * Returns 0 for success.
2248 */
2249int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
2250 struct snd_ctl_elem_value *ucontrol)
2251{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002252 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2253 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2254 struct snd_soc_codec *codec = widget->codec;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002255 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Mark Brown3a655772009-10-05 17:23:30 +01002256 unsigned int val, mux, change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002257 unsigned int mask, bitmask;
Mark Brown97404f22010-12-14 16:13:57 +00002258 struct snd_soc_dapm_update update;
Stephen Warrenfafd2172011-04-28 17:38:00 -06002259 int wi;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002260
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002261 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002262 ;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002263 if (ucontrol->value.enumerated.item[0] > e->max - 1)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002264 return -EINVAL;
2265 mux = ucontrol->value.enumerated.item[0];
2266 val = mux << e->shift_l;
2267 mask = (bitmask - 1) << e->shift_l;
2268 if (e->shift_l != e->shift_r) {
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002269 if (ucontrol->value.enumerated.item[1] > e->max - 1)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002270 return -EINVAL;
2271 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
2272 mask |= (bitmask - 1) << e->shift_r;
2273 }
2274
Stephen Warrenfafd2172011-04-28 17:38:00 -06002275 mutex_lock(&codec->mutex);
2276
Mark Brown3a655772009-10-05 17:23:30 +01002277 change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
Stephen Warrenfafd2172011-04-28 17:38:00 -06002278 if (change) {
2279 for (wi = 0; wi < wlist->num_widgets; wi++) {
2280 widget = wlist->widgets[wi];
Mark Brown97404f22010-12-14 16:13:57 +00002281
Stephen Warrenfafd2172011-04-28 17:38:00 -06002282 widget->value = val;
Mark Brown97404f22010-12-14 16:13:57 +00002283
Stephen Warrenfafd2172011-04-28 17:38:00 -06002284 update.kcontrol = kcontrol;
2285 update.widget = widget;
2286 update.reg = e->reg;
2287 update.mask = mask;
2288 update.val = val;
2289 widget->dapm->update = &update;
Mark Brown1642e3d2009-10-05 16:24:26 +01002290
Stephen Warrenfafd2172011-04-28 17:38:00 -06002291 dapm_mux_update_power(widget, kcontrol, change, mux, e);
Mark Brown1642e3d2009-10-05 16:24:26 +01002292
Stephen Warrenfafd2172011-04-28 17:38:00 -06002293 widget->dapm->update = NULL;
2294 }
2295 }
2296
2297 mutex_unlock(&codec->mutex);
Mark Brown97404f22010-12-14 16:13:57 +00002298 return change;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002299}
2300EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
2301
2302/**
Mark Brownd2b247a2009-10-06 15:21:04 +01002303 * snd_soc_dapm_get_enum_virt - Get virtual DAPM mux
2304 * @kcontrol: mixer control
2305 * @ucontrol: control element information
2306 *
2307 * Returns 0 for success.
2308 */
2309int snd_soc_dapm_get_enum_virt(struct snd_kcontrol *kcontrol,
2310 struct snd_ctl_elem_value *ucontrol)
2311{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002312 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2313 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
Mark Brownd2b247a2009-10-06 15:21:04 +01002314
2315 ucontrol->value.enumerated.item[0] = widget->value;
2316
2317 return 0;
2318}
2319EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_virt);
2320
2321/**
2322 * snd_soc_dapm_put_enum_virt - Set virtual DAPM mux
2323 * @kcontrol: mixer control
2324 * @ucontrol: control element information
2325 *
2326 * Returns 0 for success.
2327 */
2328int snd_soc_dapm_put_enum_virt(struct snd_kcontrol *kcontrol,
2329 struct snd_ctl_elem_value *ucontrol)
2330{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002331 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2332 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2333 struct snd_soc_codec *codec = widget->codec;
Mark Brownd2b247a2009-10-06 15:21:04 +01002334 struct soc_enum *e =
2335 (struct soc_enum *)kcontrol->private_value;
2336 int change;
2337 int ret = 0;
Stephen Warrenfafd2172011-04-28 17:38:00 -06002338 int wi;
Mark Brownd2b247a2009-10-06 15:21:04 +01002339
2340 if (ucontrol->value.enumerated.item[0] >= e->max)
2341 return -EINVAL;
2342
Stephen Warrenfafd2172011-04-28 17:38:00 -06002343 mutex_lock(&codec->mutex);
Mark Brownd2b247a2009-10-06 15:21:04 +01002344
2345 change = widget->value != ucontrol->value.enumerated.item[0];
Stephen Warrenfafd2172011-04-28 17:38:00 -06002346 if (change) {
2347 for (wi = 0; wi < wlist->num_widgets; wi++) {
2348 widget = wlist->widgets[wi];
Mark Brownd2b247a2009-10-06 15:21:04 +01002349
Stephen Warrenfafd2172011-04-28 17:38:00 -06002350 widget->value = ucontrol->value.enumerated.item[0];
2351
2352 dapm_mux_update_power(widget, kcontrol, change,
2353 widget->value, e);
2354 }
2355 }
2356
2357 mutex_unlock(&codec->mutex);
Mark Brownd2b247a2009-10-06 15:21:04 +01002358 return ret;
2359}
2360EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_virt);
2361
2362/**
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002363 * snd_soc_dapm_get_value_enum_double - dapm semi enumerated double mixer get
2364 * callback
2365 * @kcontrol: mixer control
2366 * @ucontrol: control element information
2367 *
2368 * Callback to get the value of a dapm semi enumerated double mixer control.
2369 *
2370 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2371 * used for handling bitfield coded enumeration for example.
2372 *
2373 * Returns 0 for success.
2374 */
2375int snd_soc_dapm_get_value_enum_double(struct snd_kcontrol *kcontrol,
2376 struct snd_ctl_elem_value *ucontrol)
2377{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002378 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2379 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
Peter Ujfalusi74155552009-01-08 13:34:29 +02002380 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002381 unsigned int reg_val, val, mux;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002382
2383 reg_val = snd_soc_read(widget->codec, e->reg);
2384 val = (reg_val >> e->shift_l) & e->mask;
2385 for (mux = 0; mux < e->max; mux++) {
2386 if (val == e->values[mux])
2387 break;
2388 }
2389 ucontrol->value.enumerated.item[0] = mux;
2390 if (e->shift_l != e->shift_r) {
2391 val = (reg_val >> e->shift_r) & e->mask;
2392 for (mux = 0; mux < e->max; mux++) {
2393 if (val == e->values[mux])
2394 break;
2395 }
2396 ucontrol->value.enumerated.item[1] = mux;
2397 }
2398
2399 return 0;
2400}
2401EXPORT_SYMBOL_GPL(snd_soc_dapm_get_value_enum_double);
2402
2403/**
2404 * snd_soc_dapm_put_value_enum_double - dapm semi enumerated double mixer set
2405 * callback
2406 * @kcontrol: mixer control
2407 * @ucontrol: control element information
2408 *
2409 * Callback to set the value of a dapm semi enumerated double mixer control.
2410 *
2411 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2412 * used for handling bitfield coded enumeration for example.
2413 *
2414 * Returns 0 for success.
2415 */
2416int snd_soc_dapm_put_value_enum_double(struct snd_kcontrol *kcontrol,
2417 struct snd_ctl_elem_value *ucontrol)
2418{
Stephen Warrenfafd2172011-04-28 17:38:00 -06002419 struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
2420 struct snd_soc_dapm_widget *widget = wlist->widgets[0];
2421 struct snd_soc_codec *codec = widget->codec;
Peter Ujfalusi74155552009-01-08 13:34:29 +02002422 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Mark Brown3a655772009-10-05 17:23:30 +01002423 unsigned int val, mux, change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002424 unsigned int mask;
Mark Brown97404f22010-12-14 16:13:57 +00002425 struct snd_soc_dapm_update update;
Stephen Warrenfafd2172011-04-28 17:38:00 -06002426 int wi;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002427
2428 if (ucontrol->value.enumerated.item[0] > e->max - 1)
2429 return -EINVAL;
2430 mux = ucontrol->value.enumerated.item[0];
2431 val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
2432 mask = e->mask << e->shift_l;
2433 if (e->shift_l != e->shift_r) {
2434 if (ucontrol->value.enumerated.item[1] > e->max - 1)
2435 return -EINVAL;
2436 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
2437 mask |= e->mask << e->shift_r;
2438 }
2439
Stephen Warrenfafd2172011-04-28 17:38:00 -06002440 mutex_lock(&codec->mutex);
2441
Mark Brown3a655772009-10-05 17:23:30 +01002442 change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
Stephen Warrenfafd2172011-04-28 17:38:00 -06002443 if (change) {
2444 for (wi = 0; wi < wlist->num_widgets; wi++) {
2445 widget = wlist->widgets[wi];
Mark Brown97404f22010-12-14 16:13:57 +00002446
Stephen Warrenfafd2172011-04-28 17:38:00 -06002447 widget->value = val;
Mark Brown97404f22010-12-14 16:13:57 +00002448
Stephen Warrenfafd2172011-04-28 17:38:00 -06002449 update.kcontrol = kcontrol;
2450 update.widget = widget;
2451 update.reg = e->reg;
2452 update.mask = mask;
2453 update.val = val;
2454 widget->dapm->update = &update;
Mark Brown1642e3d2009-10-05 16:24:26 +01002455
Stephen Warrenfafd2172011-04-28 17:38:00 -06002456 dapm_mux_update_power(widget, kcontrol, change, mux, e);
Mark Brown1642e3d2009-10-05 16:24:26 +01002457
Stephen Warrenfafd2172011-04-28 17:38:00 -06002458 widget->dapm->update = NULL;
2459 }
2460 }
2461
2462 mutex_unlock(&codec->mutex);
Mark Brown97404f22010-12-14 16:13:57 +00002463 return change;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002464}
2465EXPORT_SYMBOL_GPL(snd_soc_dapm_put_value_enum_double);
2466
2467/**
Mark Brown8b37dbd2009-02-28 21:14:20 +00002468 * snd_soc_dapm_info_pin_switch - Info for a pin switch
2469 *
2470 * @kcontrol: mixer control
2471 * @uinfo: control element information
2472 *
2473 * Callback to provide information about a pin switch control.
2474 */
2475int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
2476 struct snd_ctl_elem_info *uinfo)
2477{
2478 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2479 uinfo->count = 1;
2480 uinfo->value.integer.min = 0;
2481 uinfo->value.integer.max = 1;
2482
2483 return 0;
2484}
2485EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
2486
2487/**
2488 * snd_soc_dapm_get_pin_switch - Get information for a pin switch
2489 *
2490 * @kcontrol: mixer control
2491 * @ucontrol: Value
2492 */
2493int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
2494 struct snd_ctl_elem_value *ucontrol)
2495{
2496 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2497 const char *pin = (const char *)kcontrol->private_value;
2498
2499 mutex_lock(&codec->mutex);
2500
2501 ucontrol->value.integer.value[0] =
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002502 snd_soc_dapm_get_pin_status(&codec->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002503
2504 mutex_unlock(&codec->mutex);
2505
2506 return 0;
2507}
2508EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
2509
2510/**
2511 * snd_soc_dapm_put_pin_switch - Set information for a pin switch
2512 *
2513 * @kcontrol: mixer control
2514 * @ucontrol: Value
2515 */
2516int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
2517 struct snd_ctl_elem_value *ucontrol)
2518{
2519 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2520 const char *pin = (const char *)kcontrol->private_value;
2521
2522 mutex_lock(&codec->mutex);
2523
2524 if (ucontrol->value.integer.value[0])
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002525 snd_soc_dapm_enable_pin(&codec->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002526 else
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002527 snd_soc_dapm_disable_pin(&codec->dapm, pin);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002528
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002529 snd_soc_dapm_sync(&codec->dapm);
Mark Brown8b37dbd2009-02-28 21:14:20 +00002530
2531 mutex_unlock(&codec->mutex);
2532
2533 return 0;
2534}
2535EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
2536
2537/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02002538 * snd_soc_dapm_new_control - create new dapm control
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002539 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02002540 * @widget: widget template
2541 *
2542 * Creates a new dapm control based upon the template.
2543 *
2544 * Returns 0 for success else error.
2545 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002546int snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
Richard Purdie2b97eab2006-10-06 18:32:18 +02002547 const struct snd_soc_dapm_widget *widget)
2548{
2549 struct snd_soc_dapm_widget *w;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002550 size_t name_len;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002551
2552 if ((w = dapm_cnew_widget(widget)) == NULL)
2553 return -ENOMEM;
2554
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002555 name_len = strlen(widget->name) + 1;
Mark Brown88e8b9a2011-03-02 18:18:24 +00002556 if (dapm->codec && dapm->codec->name_prefix)
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002557 name_len += 1 + strlen(dapm->codec->name_prefix);
2558 w->name = kmalloc(name_len, GFP_KERNEL);
2559 if (w->name == NULL) {
2560 kfree(w);
2561 return -ENOMEM;
2562 }
Mark Brown88e8b9a2011-03-02 18:18:24 +00002563 if (dapm->codec && dapm->codec->name_prefix)
Jarkko Nikulaead9b912010-11-13 20:40:44 +02002564 snprintf(w->name, name_len, "%s %s",
2565 dapm->codec->name_prefix, widget->name);
2566 else
2567 snprintf(w->name, name_len, "%s", widget->name);
2568
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002569 dapm->n_widgets++;
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002570 w->dapm = dapm;
2571 w->codec = dapm->codec;
Liam Girdwoodb7950642011-07-04 22:10:52 +01002572 w->platform = dapm->platform;
Richard Purdie2b97eab2006-10-06 18:32:18 +02002573 INIT_LIST_HEAD(&w->sources);
2574 INIT_LIST_HEAD(&w->sinks);
2575 INIT_LIST_HEAD(&w->list);
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002576 list_add(&w->list, &dapm->card->widgets);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002577
2578 /* machine layer set ups unconnected pins and insertions */
2579 w->connected = 1;
2580 return 0;
2581}
2582EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
2583
2584/**
Mark Brown4ba13272008-05-13 14:51:19 +02002585 * snd_soc_dapm_new_controls - create new dapm controls
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002586 * @dapm: DAPM context
Mark Brown4ba13272008-05-13 14:51:19 +02002587 * @widget: widget array
2588 * @num: number of widgets
2589 *
2590 * Creates new DAPM controls based upon the templates.
2591 *
2592 * Returns 0 for success else error.
2593 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002594int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
Mark Brown4ba13272008-05-13 14:51:19 +02002595 const struct snd_soc_dapm_widget *widget,
2596 int num)
2597{
2598 int i, ret;
2599
2600 for (i = 0; i < num; i++) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002601 ret = snd_soc_dapm_new_control(dapm, widget);
Mark Brownb8b33cb2008-12-18 11:19:30 +00002602 if (ret < 0) {
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02002603 dev_err(dapm->dev,
2604 "ASoC: Failed to create DAPM control %s: %d\n",
2605 widget->name, ret);
Mark Brown4ba13272008-05-13 14:51:19 +02002606 return ret;
Mark Brownb8b33cb2008-12-18 11:19:30 +00002607 }
Mark Brown4ba13272008-05-13 14:51:19 +02002608 widget++;
2609 }
2610 return 0;
2611}
2612EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
2613
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002614static void soc_dapm_stream_event(struct snd_soc_dapm_context *dapm,
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002615 const char *stream, int event)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002616{
2617 struct snd_soc_dapm_widget *w;
2618
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002619 list_for_each_entry(w, &dapm->card->widgets, list)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002620 {
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002621 if (!w->sname || w->dapm != dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002622 continue;
Liam Girdwoodee47b362011-07-25 11:15:50 +01002623 dev_vdbg(w->dapm->dev, "widget %s\n %s stream %s event %d\n",
Jarkko Nikulaf7d41ae2010-11-09 14:40:27 +02002624 w->name, w->sname, stream, event);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002625 if (strstr(w->sname, stream)) {
2626 switch(event) {
2627 case SND_SOC_DAPM_STREAM_START:
2628 w->active = 1;
2629 break;
2630 case SND_SOC_DAPM_STREAM_STOP:
2631 w->active = 0;
2632 break;
2633 case SND_SOC_DAPM_STREAM_SUSPEND:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002634 case SND_SOC_DAPM_STREAM_RESUME:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002635 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
Richard Purdie2b97eab2006-10-06 18:32:18 +02002636 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
2637 break;
2638 }
2639 }
2640 }
Richard Purdie2b97eab2006-10-06 18:32:18 +02002641
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002642 dapm_power_widgets(dapm, event);
Liam Girdwood64a648c2011-07-25 11:15:15 +01002643
2644 /* do we need to notify any clients that DAPM stream is complete */
2645 if (dapm->stream_event)
2646 dapm->stream_event(dapm, event);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002647}
2648
2649/**
2650 * snd_soc_dapm_stream_event - send a stream event to the dapm core
2651 * @rtd: PCM runtime data
2652 * @stream: stream name
2653 * @event: stream event
2654 *
2655 * Sends a stream event to the dapm core. The core then makes any
2656 * necessary widget power changes.
2657 *
2658 * Returns 0 for success else error.
2659 */
2660int snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd,
2661 const char *stream, int event)
2662{
2663 struct snd_soc_codec *codec = rtd->codec;
2664
2665 if (stream == NULL)
2666 return 0;
2667
2668 mutex_lock(&codec->mutex);
2669 soc_dapm_stream_event(&codec->dapm, stream, event);
Eero Nurkkala8e8b2d62009-10-12 08:41:59 +03002670 mutex_unlock(&codec->mutex);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002671 return 0;
2672}
Richard Purdie2b97eab2006-10-06 18:32:18 +02002673
2674/**
Liam Girdwooda5302182008-07-07 13:35:17 +01002675 * snd_soc_dapm_enable_pin - enable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002676 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01002677 * @pin: pin name
Richard Purdie2b97eab2006-10-06 18:32:18 +02002678 *
Mark Brown74b8f952009-06-06 11:26:15 +01002679 * Enables input/output pin and its parents or children widgets iff there is
Liam Girdwooda5302182008-07-07 13:35:17 +01002680 * a valid audio route and active audio stream.
2681 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2682 * do any widget power switching.
Richard Purdie2b97eab2006-10-06 18:32:18 +02002683 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002684int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002685{
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002686 return snd_soc_dapm_set_pin(dapm, pin, 1);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002687}
Liam Girdwooda5302182008-07-07 13:35:17 +01002688EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002689
2690/**
Mark Brownda341832010-03-15 19:23:37 +00002691 * snd_soc_dapm_force_enable_pin - force a pin to be enabled
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002692 * @dapm: DAPM context
Mark Brownda341832010-03-15 19:23:37 +00002693 * @pin: pin name
2694 *
2695 * Enables input/output pin regardless of any other state. This is
2696 * intended for use with microphone bias supplies used in microphone
2697 * jack detection.
2698 *
2699 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2700 * do any widget power switching.
2701 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002702int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
2703 const char *pin)
Mark Brownda341832010-03-15 19:23:37 +00002704{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002705 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Mark Brownda341832010-03-15 19:23:37 +00002706
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002707 if (!w) {
2708 dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
2709 return -EINVAL;
Mark Brownda341832010-03-15 19:23:37 +00002710 }
2711
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002712 dev_dbg(w->dapm->dev, "dapm: force enable pin %s\n", pin);
2713 w->connected = 1;
2714 w->force = 1;
Mark Brown0d867332011-04-06 11:38:14 +09002715
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002716 return 0;
Mark Brownda341832010-03-15 19:23:37 +00002717}
2718EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
2719
2720/**
Liam Girdwooda5302182008-07-07 13:35:17 +01002721 * snd_soc_dapm_disable_pin - disable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002722 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01002723 * @pin: pin name
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02002724 *
Mark Brown74b8f952009-06-06 11:26:15 +01002725 * Disables input/output pin and its parents or children widgets.
Liam Girdwooda5302182008-07-07 13:35:17 +01002726 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2727 * do any widget power switching.
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02002728 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002729int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
2730 const char *pin)
Liam Girdwooda5302182008-07-07 13:35:17 +01002731{
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002732 return snd_soc_dapm_set_pin(dapm, pin, 0);
Liam Girdwooda5302182008-07-07 13:35:17 +01002733}
2734EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
2735
2736/**
Mark Brown5817b522008-09-24 11:23:11 +01002737 * snd_soc_dapm_nc_pin - permanently disable pin.
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002738 * @dapm: DAPM context
Mark Brown5817b522008-09-24 11:23:11 +01002739 * @pin: pin name
2740 *
2741 * Marks the specified pin as being not connected, disabling it along
2742 * any parent or child widgets. At present this is identical to
2743 * snd_soc_dapm_disable_pin() but in future it will be extended to do
2744 * additional things such as disabling controls which only affect
2745 * paths through the pin.
2746 *
2747 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2748 * do any widget power switching.
2749 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002750int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
Mark Brown5817b522008-09-24 11:23:11 +01002751{
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002752 return snd_soc_dapm_set_pin(dapm, pin, 0);
Mark Brown5817b522008-09-24 11:23:11 +01002753}
2754EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
2755
2756/**
Liam Girdwooda5302182008-07-07 13:35:17 +01002757 * snd_soc_dapm_get_pin_status - get audio pin status
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002758 * @dapm: DAPM context
Liam Girdwooda5302182008-07-07 13:35:17 +01002759 * @pin: audio signal pin endpoint (or start point)
2760 *
2761 * Get audio pin status - connected or disconnected.
2762 *
2763 * Returns 1 for connected otherwise 0.
2764 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002765int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
2766 const char *pin)
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02002767{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002768 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02002769
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002770 if (w)
2771 return w->connected;
Stephen Warrena68b38a2011-04-19 15:25:11 -06002772
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02002773 return 0;
2774}
Liam Girdwooda5302182008-07-07 13:35:17 +01002775EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
Graeme Gregoryeeec12b2008-04-30 19:27:40 +02002776
2777/**
Mark Brown1547aba2010-05-07 21:11:40 +01002778 * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002779 * @dapm: DAPM context
Mark Brown1547aba2010-05-07 21:11:40 +01002780 * @pin: audio signal pin endpoint (or start point)
2781 *
2782 * Mark the given endpoint or pin as ignoring suspend. When the
2783 * system is disabled a path between two endpoints flagged as ignoring
2784 * suspend will not be disabled. The path must already be enabled via
2785 * normal means at suspend time, it will not be turned on if it was not
2786 * already enabled.
2787 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002788int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
2789 const char *pin)
Mark Brown1547aba2010-05-07 21:11:40 +01002790{
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002791 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
Mark Brown1547aba2010-05-07 21:11:40 +01002792
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002793 if (!w) {
2794 dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
2795 return -EINVAL;
Mark Brown1547aba2010-05-07 21:11:40 +01002796 }
2797
Lars-Peter Clausen91a5fca2011-04-27 18:34:31 +02002798 w->ignore_suspend = 1;
2799
2800 return 0;
Mark Brown1547aba2010-05-07 21:11:40 +01002801}
2802EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
2803
2804/**
Richard Purdie2b97eab2006-10-06 18:32:18 +02002805 * snd_soc_dapm_free - free dapm resources
Peter Ujfalusi728a5222011-08-26 16:33:52 +03002806 * @dapm: DAPM context
Richard Purdie2b97eab2006-10-06 18:32:18 +02002807 *
2808 * Free all dapm widgets and resources.
2809 */
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002810void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
Richard Purdie2b97eab2006-10-06 18:32:18 +02002811{
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002812 snd_soc_dapm_sys_remove(dapm->dev);
Lars-Peter Clausen6c45e122011-04-30 19:45:50 +02002813 dapm_debugfs_cleanup(dapm);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002814 dapm_free_widgets(dapm);
Jarkko Nikula7be31be82010-12-14 12:18:32 +02002815 list_del(&dapm->list);
Richard Purdie2b97eab2006-10-06 18:32:18 +02002816}
2817EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
2818
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002819static void soc_dapm_shutdown_codec(struct snd_soc_dapm_context *dapm)
Mark Brown51737472009-06-22 13:16:51 +01002820{
Mark Brown51737472009-06-22 13:16:51 +01002821 struct snd_soc_dapm_widget *w;
2822 LIST_HEAD(down_list);
2823 int powerdown = 0;
2824
Jarkko Nikula97c866d2010-12-14 12:18:31 +02002825 list_for_each_entry(w, &dapm->card->widgets, list) {
2826 if (w->dapm != dapm)
2827 continue;
Mark Brown51737472009-06-22 13:16:51 +01002828 if (w->power) {
Mark Brown828a8422011-01-15 13:14:30 +00002829 dapm_seq_insert(w, &down_list, false);
Mark Brownc2caa4d2009-06-26 15:36:56 +01002830 w->power = 0;
Mark Brown51737472009-06-22 13:16:51 +01002831 powerdown = 1;
2832 }
2833 }
2834
2835 /* If there were no widgets to power down we're already in
2836 * standby.
2837 */
2838 if (powerdown) {
Mark Browned5a4c42011-02-18 11:12:42 -08002839 snd_soc_dapm_set_bias_level(dapm, SND_SOC_BIAS_PREPARE);
Mark Brown828a8422011-01-15 13:14:30 +00002840 dapm_seq_run(dapm, &down_list, 0, false);
Mark Browned5a4c42011-02-18 11:12:42 -08002841 snd_soc_dapm_set_bias_level(dapm, SND_SOC_BIAS_STANDBY);
Mark Brown51737472009-06-22 13:16:51 +01002842 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002843}
Mark Brown51737472009-06-22 13:16:51 +01002844
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002845/*
2846 * snd_soc_dapm_shutdown - callback for system shutdown
2847 */
2848void snd_soc_dapm_shutdown(struct snd_soc_card *card)
2849{
2850 struct snd_soc_codec *codec;
2851
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002852 list_for_each_entry(codec, &card->codec_dev_list, list) {
2853 soc_dapm_shutdown_codec(&codec->dapm);
Mark Browned5a4c42011-02-18 11:12:42 -08002854 snd_soc_dapm_set_bias_level(&codec->dapm, SND_SOC_BIAS_OFF);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02002855 }
Mark Brown51737472009-06-22 13:16:51 +01002856}
2857
Richard Purdie2b97eab2006-10-06 18:32:18 +02002858/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01002859MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Richard Purdie2b97eab2006-10-06 18:32:18 +02002860MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
2861MODULE_LICENSE("GPL");