~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/soc-dapm.c

Version: ~ [ linux-5.19-rc3 ] ~ [ linux-5.18.5 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.48 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.123 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.199 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.248 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.284 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.319 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * soc-dapm.c  --  ALSA SoC Dynamic Audio Power Management
  3  *
  4  * Copyright 2005 Wolfson Microelectronics PLC.
  5  * Author: Liam Girdwood <lrg@slimlogic.co.uk>
  6  *
  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  *
 12  *  Features:
 13  *    o Changes power status of internal codec blocks depending on the
 14  *      dynamic configuration of codec internal audio paths and active
 15  *      DACs/ADCs.
 16  *    o Platform power domain - can support external components i.e. amps and
 17  *      mic/headphone 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
 21  *    o Delayed power down of audio subsystem to reduce pops between a quick
 22  *      device reopen.
 23  *
 24  */
 25 
 26 #include <linux/module.h>
 27 #include <linux/moduleparam.h>
 28 #include <linux/init.h>
 29 #include <linux/async.h>
 30 #include <linux/delay.h>
 31 #include <linux/pm.h>
 32 #include <linux/bitops.h>
 33 #include <linux/platform_device.h>
 34 #include <linux/jiffies.h>
 35 #include <linux/debugfs.h>
 36 #include <linux/pm_runtime.h>
 37 #include <linux/regulator/consumer.h>
 38 #include <linux/clk.h>
 39 #include <linux/slab.h>
 40 #include <sound/core.h>
 41 #include <sound/pcm.h>
 42 #include <sound/pcm_params.h>
 43 #include <sound/soc.h>
 44 #include <sound/initval.h>
 45 
 46 #include <trace/events/asoc.h>
 47 
 48 #define DAPM_UPDATE_STAT(widget, val) widget->dapm->card->dapm_stats.val++;
 49 
 50 #define SND_SOC_DAPM_DIR_REVERSE(x) ((x == SND_SOC_DAPM_DIR_IN) ? \
 51         SND_SOC_DAPM_DIR_OUT : SND_SOC_DAPM_DIR_IN)
 52 
 53 #define snd_soc_dapm_for_each_direction(dir) \
 54         for ((dir) = SND_SOC_DAPM_DIR_IN; (dir) <= SND_SOC_DAPM_DIR_OUT; \
 55                 (dir)++)
 56 
 57 static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
 58         struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
 59         const char *control,
 60         int (*connected)(struct snd_soc_dapm_widget *source,
 61                          struct snd_soc_dapm_widget *sink));
 62 
 63 struct snd_soc_dapm_widget *
 64 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
 65                          const struct snd_soc_dapm_widget *widget);
 66 
 67 struct snd_soc_dapm_widget *
 68 snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
 69                          const struct snd_soc_dapm_widget *widget);
 70 
 71 /* dapm power sequences - make this per codec in the future */
 72 static int dapm_up_seq[] = {
 73         [snd_soc_dapm_pre] = 0,
 74         [snd_soc_dapm_regulator_supply] = 1,
 75         [snd_soc_dapm_clock_supply] = 1,
 76         [snd_soc_dapm_supply] = 2,
 77         [snd_soc_dapm_micbias] = 3,
 78         [snd_soc_dapm_dai_link] = 2,
 79         [snd_soc_dapm_dai_in] = 4,
 80         [snd_soc_dapm_dai_out] = 4,
 81         [snd_soc_dapm_aif_in] = 4,
 82         [snd_soc_dapm_aif_out] = 4,
 83         [snd_soc_dapm_mic] = 5,
 84         [snd_soc_dapm_mux] = 6,
 85         [snd_soc_dapm_demux] = 6,
 86         [snd_soc_dapm_dac] = 7,
 87         [snd_soc_dapm_switch] = 8,
 88         [snd_soc_dapm_mixer] = 8,
 89         [snd_soc_dapm_mixer_named_ctl] = 8,
 90         [snd_soc_dapm_pga] = 9,
 91         [snd_soc_dapm_adc] = 10,
 92         [snd_soc_dapm_out_drv] = 11,
 93         [snd_soc_dapm_hp] = 11,
 94         [snd_soc_dapm_spk] = 11,
 95         [snd_soc_dapm_line] = 11,
 96         [snd_soc_dapm_kcontrol] = 12,
 97         [snd_soc_dapm_post] = 13,
 98 };
 99 
100 static int dapm_down_seq[] = {
101         [snd_soc_dapm_pre] = 0,
102         [snd_soc_dapm_kcontrol] = 1,
103         [snd_soc_dapm_adc] = 2,
104         [snd_soc_dapm_hp] = 3,
105         [snd_soc_dapm_spk] = 3,
106         [snd_soc_dapm_line] = 3,
107         [snd_soc_dapm_out_drv] = 3,
108         [snd_soc_dapm_pga] = 4,
109         [snd_soc_dapm_switch] = 5,
110         [snd_soc_dapm_mixer_named_ctl] = 5,
111         [snd_soc_dapm_mixer] = 5,
112         [snd_soc_dapm_dac] = 6,
113         [snd_soc_dapm_mic] = 7,
114         [snd_soc_dapm_micbias] = 8,
115         [snd_soc_dapm_mux] = 9,
116         [snd_soc_dapm_demux] = 9,
117         [snd_soc_dapm_aif_in] = 10,
118         [snd_soc_dapm_aif_out] = 10,
119         [snd_soc_dapm_dai_in] = 10,
120         [snd_soc_dapm_dai_out] = 10,
121         [snd_soc_dapm_dai_link] = 11,
122         [snd_soc_dapm_supply] = 12,
123         [snd_soc_dapm_clock_supply] = 13,
124         [snd_soc_dapm_regulator_supply] = 13,
125         [snd_soc_dapm_post] = 14,
126 };
127 
128 static void dapm_assert_locked(struct snd_soc_dapm_context *dapm)
129 {
130         if (dapm->card && dapm->card->instantiated)
131                 lockdep_assert_held(&dapm->card->dapm_mutex);
132 }
133 
134 static void pop_wait(u32 pop_time)
135 {
136         if (pop_time)
137                 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
138 }
139 
140 static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
141 {
142         va_list args;
143         char *buf;
144 
145         if (!pop_time)
146                 return;
147 
148         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
149         if (buf == NULL)
150                 return;
151 
152         va_start(args, fmt);
153         vsnprintf(buf, PAGE_SIZE, fmt, args);
154         dev_info(dev, "%s", buf);
155         va_end(args);
156 
157         kfree(buf);
158 }
159 
160 static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w)
161 {
162         return !list_empty(&w->dirty);
163 }
164 
165 static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
166 {
167         dapm_assert_locked(w->dapm);
168 
169         if (!dapm_dirty_widget(w)) {
170                 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
171                          w->name, reason);
172                 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
173         }
174 }
175 
176 /*
177  * Common implementation for dapm_widget_invalidate_input_paths() and
178  * dapm_widget_invalidate_output_paths(). The function is inlined since the
179  * combined size of the two specialized functions is only marginally larger then
180  * the size of the generic function and at the same time the fast path of the
181  * specialized functions is significantly smaller than the generic function.
182  */
183 static __always_inline void dapm_widget_invalidate_paths(
184         struct snd_soc_dapm_widget *w, enum snd_soc_dapm_direction dir)
185 {
186         enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
187         struct snd_soc_dapm_widget *node;
188         struct snd_soc_dapm_path *p;
189         LIST_HEAD(list);
190 
191         dapm_assert_locked(w->dapm);
192 
193         if (w->endpoints[dir] == -1)
194                 return;
195 
196         list_add_tail(&w->work_list, &list);
197         w->endpoints[dir] = -1;
198 
199         list_for_each_entry(w, &list, work_list) {
200                 snd_soc_dapm_widget_for_each_path(w, dir, p) {
201                         if (p->is_supply || p->weak || !p->connect)
202                                 continue;
203                         node = p->node[rdir];
204                         if (node->endpoints[dir] != -1) {
205                                 node->endpoints[dir] = -1;
206                                 list_add_tail(&node->work_list, &list);
207                         }
208                 }
209         }
210 }
211 
212 /*
213  * dapm_widget_invalidate_input_paths() - Invalidate the cached number of
214  *  input paths
215  * @w: The widget for which to invalidate the cached number of input paths
216  *
217  * Resets the cached number of inputs for the specified widget and all widgets
218  * that can be reached via outcoming paths from the widget.
219  *
220  * This function must be called if the number of output paths for a widget might
221  * have changed. E.g. if the source state of a widget changes or a path is added
222  * or activated with the widget as the sink.
223  */
224 static void dapm_widget_invalidate_input_paths(struct snd_soc_dapm_widget *w)
225 {
226         dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_IN);
227 }
228 
229 /*
230  * dapm_widget_invalidate_output_paths() - Invalidate the cached number of
231  *  output paths
232  * @w: The widget for which to invalidate the cached number of output paths
233  *
234  * Resets the cached number of outputs for the specified widget and all widgets
235  * that can be reached via incoming paths from the widget.
236  *
237  * This function must be called if the number of output paths for a widget might
238  * have changed. E.g. if the sink state of a widget changes or a path is added
239  * or activated with the widget as the source.
240  */
241 static void dapm_widget_invalidate_output_paths(struct snd_soc_dapm_widget *w)
242 {
243         dapm_widget_invalidate_paths(w, SND_SOC_DAPM_DIR_OUT);
244 }
245 
246 /*
247  * dapm_path_invalidate() - Invalidates the cached number of inputs and outputs
248  *  for the widgets connected to a path
249  * @p: The path to invalidate
250  *
251  * Resets the cached number of inputs for the sink of the path and the cached
252  * number of outputs for the source of the path.
253  *
254  * This function must be called when a path is added, removed or the connected
255  * state changes.
256  */
257 static void dapm_path_invalidate(struct snd_soc_dapm_path *p)
258 {
259         /*
260          * Weak paths or supply paths do not influence the number of input or
261          * output paths of their neighbors.
262          */
263         if (p->weak || p->is_supply)
264                 return;
265 
266         /*
267          * The number of connected endpoints is the sum of the number of
268          * connected endpoints of all neighbors. If a node with 0 connected
269          * endpoints is either connected or disconnected that sum won't change,
270          * so there is no need to re-check the path.
271          */
272         if (p->source->endpoints[SND_SOC_DAPM_DIR_IN] != 0)
273                 dapm_widget_invalidate_input_paths(p->sink);
274         if (p->sink->endpoints[SND_SOC_DAPM_DIR_OUT] != 0)
275                 dapm_widget_invalidate_output_paths(p->source);
276 }
277 
278 void dapm_mark_endpoints_dirty(struct snd_soc_card *card)
279 {
280         struct snd_soc_dapm_widget *w;
281 
282         mutex_lock(&card->dapm_mutex);
283 
284         list_for_each_entry(w, &card->widgets, list) {
285                 if (w->is_ep) {
286                         dapm_mark_dirty(w, "Rechecking endpoints");
287                         if (w->is_ep & SND_SOC_DAPM_EP_SINK)
288                                 dapm_widget_invalidate_output_paths(w);
289                         if (w->is_ep & SND_SOC_DAPM_EP_SOURCE)
290                                 dapm_widget_invalidate_input_paths(w);
291                 }
292         }
293 
294         mutex_unlock(&card->dapm_mutex);
295 }
296 EXPORT_SYMBOL_GPL(dapm_mark_endpoints_dirty);
297 
298 /* create a new dapm widget */
299 static inline struct snd_soc_dapm_widget *dapm_cnew_widget(
300         const struct snd_soc_dapm_widget *_widget)
301 {
302         return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL);
303 }
304 
305 struct dapm_kcontrol_data {
306         unsigned int value;
307         struct snd_soc_dapm_widget *widget;
308         struct list_head paths;
309         struct snd_soc_dapm_widget_list *wlist;
310 };
311 
312 static int dapm_kcontrol_data_alloc(struct snd_soc_dapm_widget *widget,
313         struct snd_kcontrol *kcontrol, const char *ctrl_name)
314 {
315         struct dapm_kcontrol_data *data;
316         struct soc_mixer_control *mc;
317         struct soc_enum *e;
318         const char *name;
319         int ret;
320 
321         data = kzalloc(sizeof(*data), GFP_KERNEL);
322         if (!data)
323                 return -ENOMEM;
324 
325         INIT_LIST_HEAD(&data->paths);
326 
327         switch (widget->id) {
328         case snd_soc_dapm_switch:
329         case snd_soc_dapm_mixer:
330         case snd_soc_dapm_mixer_named_ctl:
331                 mc = (struct soc_mixer_control *)kcontrol->private_value;
332 
333                 if (mc->autodisable) {
334                         struct snd_soc_dapm_widget template;
335 
336                         name = kasprintf(GFP_KERNEL, "%s %s", ctrl_name,
337                                          "Autodisable");
338                         if (!name) {
339                                 ret = -ENOMEM;
340                                 goto err_data;
341                         }
342 
343                         memset(&template, 0, sizeof(template));
344                         template.reg = mc->reg;
345                         template.mask = (1 << fls(mc->max)) - 1;
346                         template.shift = mc->shift;
347                         if (mc->invert)
348                                 template.off_val = mc->max;
349                         else
350                                 template.off_val = 0;
351                         template.on_val = template.off_val;
352                         template.id = snd_soc_dapm_kcontrol;
353                         template.name = name;
354 
355                         data->value = template.on_val;
356 
357                         data->widget =
358                                 snd_soc_dapm_new_control_unlocked(widget->dapm,
359                                 &template);
360                         kfree(name);
361                         if (!data->widget) {
362                                 ret = -ENOMEM;
363                                 goto err_data;
364                         }
365                 }
366                 break;
367         case snd_soc_dapm_demux:
368         case snd_soc_dapm_mux:
369                 e = (struct soc_enum *)kcontrol->private_value;
370 
371                 if (e->autodisable) {
372                         struct snd_soc_dapm_widget template;
373 
374                         name = kasprintf(GFP_KERNEL, "%s %s", ctrl_name,
375                                          "Autodisable");
376                         if (!name) {
377                                 ret = -ENOMEM;
378                                 goto err_data;
379                         }
380 
381                         memset(&template, 0, sizeof(template));
382                         template.reg = e->reg;
383                         template.mask = e->mask << e->shift_l;
384                         template.shift = e->shift_l;
385                         template.off_val = snd_soc_enum_item_to_val(e, 0);
386                         template.on_val = template.off_val;
387                         template.id = snd_soc_dapm_kcontrol;
388                         template.name = name;
389 
390                         data->value = template.on_val;
391 
392                         data->widget = snd_soc_dapm_new_control_unlocked(
393                                                 widget->dapm, &template);
394                         kfree(name);
395                         if (!data->widget) {
396                                 ret = -ENOMEM;
397                                 goto err_data;
398                         }
399 
400                         snd_soc_dapm_add_path(widget->dapm, data->widget,
401                                               widget, NULL, NULL);
402                 }
403                 break;
404         default:
405                 break;
406         }
407 
408         kcontrol->private_data = data;
409 
410         return 0;
411 
412 err_data:
413         kfree(data);
414         return ret;
415 }
416 
417 static void dapm_kcontrol_free(struct snd_kcontrol *kctl)
418 {
419         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kctl);
420         kfree(data->wlist);
421         kfree(data);
422 }
423 
424 static struct snd_soc_dapm_widget_list *dapm_kcontrol_get_wlist(
425         const struct snd_kcontrol *kcontrol)
426 {
427         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
428 
429         return data->wlist;
430 }
431 
432 static int dapm_kcontrol_add_widget(struct snd_kcontrol *kcontrol,
433         struct snd_soc_dapm_widget *widget)
434 {
435         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
436         struct snd_soc_dapm_widget_list *new_wlist;
437         unsigned int n;
438 
439         if (data->wlist)
440                 n = data->wlist->num_widgets + 1;
441         else
442                 n = 1;
443 
444         new_wlist = krealloc(data->wlist,
445                         sizeof(*new_wlist) + sizeof(widget) * n, GFP_KERNEL);
446         if (!new_wlist)
447                 return -ENOMEM;
448 
449         new_wlist->widgets[n - 1] = widget;
450         new_wlist->num_widgets = n;
451 
452         data->wlist = new_wlist;
453 
454         return 0;
455 }
456 
457 static void dapm_kcontrol_add_path(const struct snd_kcontrol *kcontrol,
458         struct snd_soc_dapm_path *path)
459 {
460         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
461 
462         list_add_tail(&path->list_kcontrol, &data->paths);
463 }
464 
465 static bool dapm_kcontrol_is_powered(const struct snd_kcontrol *kcontrol)
466 {
467         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
468 
469         if (!data->widget)
470                 return true;
471 
472         return data->widget->power;
473 }
474 
475 static struct list_head *dapm_kcontrol_get_path_list(
476         const struct snd_kcontrol *kcontrol)
477 {
478         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
479 
480         return &data->paths;
481 }
482 
483 #define dapm_kcontrol_for_each_path(path, kcontrol) \
484         list_for_each_entry(path, dapm_kcontrol_get_path_list(kcontrol), \
485                 list_kcontrol)
486 
487 unsigned int dapm_kcontrol_get_value(const struct snd_kcontrol *kcontrol)
488 {
489         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
490 
491         return data->value;
492 }
493 EXPORT_SYMBOL_GPL(dapm_kcontrol_get_value);
494 
495 static bool dapm_kcontrol_set_value(const struct snd_kcontrol *kcontrol,
496         unsigned int value)
497 {
498         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);
499 
500         if (data->value == value)
501                 return false;
502 
503         if (data->widget)
504                 data->widget->on_val = value;
505 
506         data->value = value;
507 
508         return true;
509 }
510 
511 /**
512  * snd_soc_dapm_kcontrol_widget() - Returns the widget associated to a
513  *   kcontrol
514  * @kcontrol: The kcontrol
515  */
516 struct snd_soc_dapm_widget *snd_soc_dapm_kcontrol_widget(
517                                 struct snd_kcontrol *kcontrol)
518 {
519         return dapm_kcontrol_get_wlist(kcontrol)->widgets[0];
520 }
521 EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_widget);
522 
523 /**
524  * snd_soc_dapm_kcontrol_dapm() - Returns the dapm context associated to a
525  *  kcontrol
526  * @kcontrol: The kcontrol
527  *
528  * Note: This function must only be used on kcontrols that are known to have
529  * been registered for a CODEC. Otherwise the behaviour is undefined.
530  */
531 struct snd_soc_dapm_context *snd_soc_dapm_kcontrol_dapm(
532         struct snd_kcontrol *kcontrol)
533 {
534         return dapm_kcontrol_get_wlist(kcontrol)->widgets[0]->dapm;
535 }
536 EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_dapm);
537 
538 static void dapm_reset(struct snd_soc_card *card)
539 {
540         struct snd_soc_dapm_widget *w;
541 
542         lockdep_assert_held(&card->dapm_mutex);
543 
544         memset(&card->dapm_stats, 0, sizeof(card->dapm_stats));
545 
546         list_for_each_entry(w, &card->widgets, list) {
547                 w->new_power = w->power;
548                 w->power_checked = false;
549         }
550 }
551 
552 static const char *soc_dapm_prefix(struct snd_soc_dapm_context *dapm)
553 {
554         if (!dapm->component)
555                 return NULL;
556         return dapm->component->name_prefix;
557 }
558 
559 static int soc_dapm_read(struct snd_soc_dapm_context *dapm, int reg,
560         unsigned int *value)
561 {
562         if (!dapm->component)
563                 return -EIO;
564         return snd_soc_component_read(dapm->component, reg, value);
565 }
566 
567 static int soc_dapm_update_bits(struct snd_soc_dapm_context *dapm,
568         int reg, unsigned int mask, unsigned int value)
569 {
570         if (!dapm->component)
571                 return -EIO;
572         return snd_soc_component_update_bits(dapm->component, reg,
573                                              mask, value);
574 }
575 
576 static int soc_dapm_test_bits(struct snd_soc_dapm_context *dapm,
577         int reg, unsigned int mask, unsigned int value)
578 {
579         if (!dapm->component)
580                 return -EIO;
581         return snd_soc_component_test_bits(dapm->component, reg, mask, value);
582 }
583 
584 static void soc_dapm_async_complete(struct snd_soc_dapm_context *dapm)
585 {
586         if (dapm->component)
587                 snd_soc_component_async_complete(dapm->component);
588 }
589 
590 static struct snd_soc_dapm_widget *
591 dapm_wcache_lookup(struct snd_soc_dapm_wcache *wcache, const char *name)
592 {
593         struct snd_soc_dapm_widget *w = wcache->widget;
594         struct list_head *wlist;
595         const int depth = 2;
596         int i = 0;
597 
598         if (w) {
599                 wlist = &w->dapm->card->widgets;
600 
601                 list_for_each_entry_from(w, wlist, list) {
602                         if (!strcmp(name, w->name))
603                                 return w;
604 
605                         if (++i == depth)
606                                 break;
607                 }
608         }
609 
610         return NULL;
611 }
612 
613 static inline void dapm_wcache_update(struct snd_soc_dapm_wcache *wcache,
614                                       struct snd_soc_dapm_widget *w)
615 {
616         wcache->widget = w;
617 }
618 
619 /**
620  * snd_soc_dapm_force_bias_level() - Sets the DAPM bias level
621  * @dapm: The DAPM context for which to set the level
622  * @level: The level to set
623  *
624  * Forces the DAPM bias level to a specific state. It will call the bias level
625  * callback of DAPM context with the specified level. This will even happen if
626  * the context is already at the same level. Furthermore it will not go through
627  * the normal bias level sequencing, meaning any intermediate states between the
628  * current and the target state will not be entered.
629  *
630  * Note that the change in bias level is only temporary and the next time
631  * snd_soc_dapm_sync() is called the state will be set to the level as
632  * determined by the DAPM core. The function is mainly intended to be used to
633  * used during probe or resume from suspend to power up the device so
634  * initialization can be done, before the DAPM core takes over.
635  */
636 int snd_soc_dapm_force_bias_level(struct snd_soc_dapm_context *dapm,
637         enum snd_soc_bias_level level)
638 {
639         int ret = 0;
640 
641         if (dapm->set_bias_level)
642                 ret = dapm->set_bias_level(dapm, level);
643 
644         if (ret == 0)
645                 dapm->bias_level = level;
646 
647         return ret;
648 }
649 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_bias_level);
650 
651 /**
652  * snd_soc_dapm_set_bias_level - set the bias level for the system
653  * @dapm: DAPM context
654  * @level: level to configure
655  *
656  * Configure the bias (power) levels for the SoC audio device.
657  *
658  * Returns 0 for success else error.
659  */
660 static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
661                                        enum snd_soc_bias_level level)
662 {
663         struct snd_soc_card *card = dapm->card;
664         int ret = 0;
665 
666         trace_snd_soc_bias_level_start(card, level);
667 
668         if (card && card->set_bias_level)
669                 ret = card->set_bias_level(card, dapm, level);
670         if (ret != 0)
671                 goto out;
672 
673         if (!card || dapm != &card->dapm)
674                 ret = snd_soc_dapm_force_bias_level(dapm, level);
675 
676         if (ret != 0)
677                 goto out;
678 
679         if (card && card->set_bias_level_post)
680                 ret = card->set_bias_level_post(card, dapm, level);
681 out:
682         trace_snd_soc_bias_level_done(card, level);
683 
684         return ret;
685 }
686 
687 /* connect mux widget to its interconnecting audio paths */
688 static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
689         struct snd_soc_dapm_path *path, const char *control_name,
690         struct snd_soc_dapm_widget *w)
691 {
692         const struct snd_kcontrol_new *kcontrol = &w->kcontrol_news[0];
693         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
694         unsigned int val, item;
695         int i;
696 
697         if (e->reg != SND_SOC_NOPM) {
698                 soc_dapm_read(dapm, e->reg, &val);
699                 val = (val >> e->shift_l) & e->mask;
700                 item = snd_soc_enum_val_to_item(e, val);
701         } else {
702                 /* since a virtual mux has no backing registers to
703                  * decide which path to connect, it will try to match
704                  * with the first enumeration.  This is to ensure
705                  * that the default mux choice (the first) will be
706                  * correctly powered up during initialization.
707                  */
708                 item = 0;
709         }
710 
711         for (i = 0; i < e->items; i++) {
712                 if (!(strcmp(control_name, e->texts[i]))) {
713                         path->name = e->texts[i];
714                         if (i == item)
715                                 path->connect = 1;
716                         else
717                                 path->connect = 0;
718                         return 0;
719                 }
720         }
721 
722         return -ENODEV;
723 }
724 
725 /* set up initial codec paths */
726 static void dapm_set_mixer_path_status(struct snd_soc_dapm_path *p, int i)
727 {
728         struct soc_mixer_control *mc = (struct soc_mixer_control *)
729                 p->sink->kcontrol_news[i].private_value;
730         unsigned int reg = mc->reg;
731         unsigned int shift = mc->shift;
732         unsigned int max = mc->max;
733         unsigned int mask = (1 << fls(max)) - 1;
734         unsigned int invert = mc->invert;
735         unsigned int val;
736 
737         if (reg != SND_SOC_NOPM) {
738                 soc_dapm_read(p->sink->dapm, reg, &val);
739                 val = (val >> shift) & mask;
740                 if (invert)
741                         val = max - val;
742                 p->connect = !!val;
743         } else {
744                 p->connect = 0;
745         }
746 }
747 
748 /* connect mixer widget to its interconnecting audio paths */
749 static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
750         struct snd_soc_dapm_path *path, const char *control_name)
751 {
752         int i;
753 
754         /* search for mixer kcontrol */
755         for (i = 0; i < path->sink->num_kcontrols; i++) {
756                 if (!strcmp(control_name, path->sink->kcontrol_news[i].name)) {
757                         path->name = path->sink->kcontrol_news[i].name;
758                         dapm_set_mixer_path_status(path, i);
759                         return 0;
760                 }
761         }
762         return -ENODEV;
763 }
764 
765 static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm,
766         struct snd_soc_dapm_widget *kcontrolw,
767         const struct snd_kcontrol_new *kcontrol_new,
768         struct snd_kcontrol **kcontrol)
769 {
770         struct snd_soc_dapm_widget *w;
771         int i;
772 
773         *kcontrol = NULL;
774 
775         list_for_each_entry(w, &dapm->card->widgets, list) {
776                 if (w == kcontrolw || w->dapm != kcontrolw->dapm)
777                         continue;
778                 for (i = 0; i < w->num_kcontrols; i++) {
779                         if (&w->kcontrol_news[i] == kcontrol_new) {
780                                 if (w->kcontrols)
781                                         *kcontrol = w->kcontrols[i];
782                                 return 1;
783                         }
784                 }
785         }
786 
787         return 0;
788 }
789 
790 /*
791  * Determine if a kcontrol is shared. If it is, look it up. If it isn't,
792  * create it. Either way, add the widget into the control's widget list
793  */
794 static int dapm_create_or_share_kcontrol(struct snd_soc_dapm_widget *w,
795         int kci)
796 {
797         struct snd_soc_dapm_context *dapm = w->dapm;
798         struct snd_card *card = dapm->card->snd_card;
799         const char *prefix;
800         size_t prefix_len;
801         int shared;
802         struct snd_kcontrol *kcontrol;
803         bool wname_in_long_name, kcname_in_long_name;
804         char *long_name = NULL;
805         const char *name;
806         int ret = 0;
807 
808         prefix = soc_dapm_prefix(dapm);
809         if (prefix)
810                 prefix_len = strlen(prefix) + 1;
811         else
812                 prefix_len = 0;
813 
814         shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],
815                                          &kcontrol);
816 
817         if (!kcontrol) {
818                 if (shared) {
819                         wname_in_long_name = false;
820                         kcname_in_long_name = true;
821                 } else {
822                         switch (w->id) {
823                         case snd_soc_dapm_switch:
824                         case snd_soc_dapm_mixer:
825                         case snd_soc_dapm_pga:
826                         case snd_soc_dapm_out_drv:
827                                 wname_in_long_name = true;
828                                 kcname_in_long_name = true;
829                                 break;
830                         case snd_soc_dapm_mixer_named_ctl:
831                                 wname_in_long_name = false;
832                                 kcname_in_long_name = true;
833                                 break;
834                         case snd_soc_dapm_demux:
835                         case snd_soc_dapm_mux:
836                                 wname_in_long_name = true;
837                                 kcname_in_long_name = false;
838                                 break;
839                         default:
840                                 return -EINVAL;
841                         }
842                 }
843 
844                 if (wname_in_long_name && kcname_in_long_name) {
845                         /*
846                          * The control will get a prefix from the control
847                          * creation process but we're also using the same
848                          * prefix for widgets so cut the prefix off the
849                          * front of the widget name.
850                          */
851                         long_name = kasprintf(GFP_KERNEL, "%s %s",
852                                  w->name + prefix_len,
853                                  w->kcontrol_news[kci].name);
854                         if (long_name == NULL)
855                                 return -ENOMEM;
856 
857                         name = long_name;
858                 } else if (wname_in_long_name) {
859                         long_name = NULL;
860                         name = w->name + prefix_len;
861                 } else {
862                         long_name = NULL;
863                         name = w->kcontrol_news[kci].name;
864                 }
865 
866                 kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,
867                                         prefix);
868                 if (!kcontrol) {
869                         ret = -ENOMEM;
870                         goto exit_free;
871                 }
872 
873                 kcontrol->private_free = dapm_kcontrol_free;
874 
875                 ret = dapm_kcontrol_data_alloc(w, kcontrol, name);
876                 if (ret) {
877                         snd_ctl_free_one(kcontrol);
878                         goto exit_free;
879                 }
880 
881                 ret = snd_ctl_add(card, kcontrol);
882                 if (ret < 0) {
883                         dev_err(dapm->dev,
884                                 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
885                                 w->name, name, ret);
886                         goto exit_free;
887                 }
888         }
889 
890         ret = dapm_kcontrol_add_widget(kcontrol, w);
891         if (ret == 0)
892                 w->kcontrols[kci] = kcontrol;
893 
894 exit_free:
895         kfree(long_name);
896 
897         return ret;
898 }
899 
900 /* create new dapm mixer control */
901 static int dapm_new_mixer(struct snd_soc_dapm_widget *w)
902 {
903         int i, ret;
904         struct snd_soc_dapm_path *path;
905         struct dapm_kcontrol_data *data;
906 
907         /* add kcontrol */
908         for (i = 0; i < w->num_kcontrols; i++) {
909                 /* match name */
910                 snd_soc_dapm_widget_for_each_source_path(w, path) {
911                         /* mixer/mux paths name must match control name */
912                         if (path->name != (char *)w->kcontrol_news[i].name)
913                                 continue;
914 
915                         if (!w->kcontrols[i]) {
916                                 ret = dapm_create_or_share_kcontrol(w, i);
917                                 if (ret < 0)
918                                         return ret;
919                         }
920 
921                         dapm_kcontrol_add_path(w->kcontrols[i], path);
922 
923                         data = snd_kcontrol_chip(w->kcontrols[i]);
924                         if (data->widget)
925                                 snd_soc_dapm_add_path(data->widget->dapm,
926                                                       data->widget,
927                                                       path->source,
928                                                       NULL, NULL);
929                 }
930         }
931 
932         return 0;
933 }
934 
935 /* create new dapm mux control */
936 static int dapm_new_mux(struct snd_soc_dapm_widget *w)
937 {
938         struct snd_soc_dapm_context *dapm = w->dapm;
939         enum snd_soc_dapm_direction dir;
940         struct snd_soc_dapm_path *path;
941         const char *type;
942         int ret;
943 
944         switch (w->id) {
945         case snd_soc_dapm_mux:
946                 dir = SND_SOC_DAPM_DIR_OUT;
947                 type = "mux";
948                 break;
949         case snd_soc_dapm_demux:
950                 dir = SND_SOC_DAPM_DIR_IN;
951                 type = "demux";
952                 break;
953         default:
954                 return -EINVAL;
955         }
956 
957         if (w->num_kcontrols != 1) {
958                 dev_err(dapm->dev,
959                         "ASoC: %s %s has incorrect number of controls\n", type,
960                         w->name);
961                 return -EINVAL;
962         }
963 
964         if (list_empty(&w->edges[dir])) {
965                 dev_err(dapm->dev, "ASoC: %s %s has no paths\n", type, w->name);
966                 return -EINVAL;
967         }
968 
969         ret = dapm_create_or_share_kcontrol(w, 0);
970         if (ret < 0)
971                 return ret;
972 
973         snd_soc_dapm_widget_for_each_path(w, dir, path) {
974                 if (path->name)
975                         dapm_kcontrol_add_path(w->kcontrols[0], path);
976         }
977 
978         return 0;
979 }
980 
981 /* create new dapm volume control */
982 static int dapm_new_pga(struct snd_soc_dapm_widget *w)
983 {
984         int i, ret;
985 
986         for (i = 0; i < w->num_kcontrols; i++) {
987                 ret = dapm_create_or_share_kcontrol(w, i);
988                 if (ret < 0)
989                         return ret;
990         }
991 
992         return 0;
993 }
994 
995 /* create new dapm dai link control */
996 static int dapm_new_dai_link(struct snd_soc_dapm_widget *w)
997 {
998         int i, ret;
999         struct snd_kcontrol *kcontrol;
1000         struct snd_soc_dapm_context *dapm = w->dapm;
1001         struct snd_card *card = dapm->card->snd_card;
1002 
1003         /* create control for links with > 1 config */
1004         if (w->num_params <= 1)
1005                 return 0;
1006 
1007         /* add kcontrol */
1008         for (i = 0; i < w->num_kcontrols; i++) {
1009                 kcontrol = snd_soc_cnew(&w->kcontrol_news[i], w,
1010                                         w->name, NULL);
1011                 ret = snd_ctl_add(card, kcontrol);
1012                 if (ret < 0) {
1013                         dev_err(dapm->dev,
1014                                 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n",
1015                                 w->name, w->kcontrol_news[i].name, ret);
1016                         return ret;
1017                 }
1018                 kcontrol->private_data = w;
1019                 w->kcontrols[i] = kcontrol;
1020         }
1021 
1022         return 0;
1023 }
1024 
1025 /* We implement power down on suspend by checking the power state of
1026  * the ALSA card - when we are suspending the ALSA state for the card
1027  * is set to D3.
1028  */
1029 static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
1030 {
1031         int level = snd_power_get_state(widget->dapm->card->snd_card);
1032 
1033         switch (level) {
1034         case SNDRV_CTL_POWER_D3hot:
1035         case SNDRV_CTL_POWER_D3cold:
1036                 if (widget->ignore_suspend)
1037                         dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
1038                                 widget->name);
1039                 return widget->ignore_suspend;
1040         default:
1041                 return 1;
1042         }
1043 }
1044 
1045 static int dapm_widget_list_create(struct snd_soc_dapm_widget_list **list,
1046         struct list_head *widgets)
1047 {
1048         struct snd_soc_dapm_widget *w;
1049         struct list_head *it;
1050         unsigned int size = 0;
1051         unsigned int i = 0;
1052 
1053         list_for_each(it, widgets)
1054                 size++;
1055 
1056         *list = kzalloc(sizeof(**list) + size * sizeof(*w), GFP_KERNEL);
1057         if (*list == NULL)
1058                 return -ENOMEM;
1059 
1060         list_for_each_entry(w, widgets, work_list)
1061                 (*list)->widgets[i++] = w;
1062 
1063         (*list)->num_widgets = i;
1064 
1065         return 0;
1066 }
1067 
1068 /*
1069  * Common implementation for is_connected_output_ep() and
1070  * is_connected_input_ep(). The function is inlined since the combined size of
1071  * the two specialized functions is only marginally larger then the size of the
1072  * generic function and at the same time the fast path of the specialized
1073  * functions is significantly smaller than the generic function.
1074  */
1075 static __always_inline int is_connected_ep(struct snd_soc_dapm_widget *widget,
1076         struct list_head *list, enum snd_soc_dapm_direction dir,
1077         int (*fn)(struct snd_soc_dapm_widget *, struct list_head *,
1078                   bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
1079                                                 enum snd_soc_dapm_direction)),
1080         bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
1081                                       enum snd_soc_dapm_direction))
1082 {
1083         enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
1084         struct snd_soc_dapm_path *path;
1085         int con = 0;
1086 
1087         if (widget->endpoints[dir] >= 0)
1088                 return widget->endpoints[dir];
1089 
1090         DAPM_UPDATE_STAT(widget, path_checks);
1091 
1092         /* do we need to add this widget to the list ? */
1093         if (list)
1094                 list_add_tail(&widget->work_list, list);
1095 
1096         if (custom_stop_condition && custom_stop_condition(widget, dir)) {
1097                 widget->endpoints[dir] = 1;
1098                 return widget->endpoints[dir];
1099         }
1100 
1101         if ((widget->is_ep & SND_SOC_DAPM_DIR_TO_EP(dir)) && widget->connected) {
1102                 widget->endpoints[dir] = snd_soc_dapm_suspend_check(widget);
1103                 return widget->endpoints[dir];
1104         }
1105 
1106         snd_soc_dapm_widget_for_each_path(widget, rdir, path) {
1107                 DAPM_UPDATE_STAT(widget, neighbour_checks);
1108 
1109                 if (path->weak || path->is_supply)
1110                         continue;
1111 
1112                 if (path->walking)
1113                         return 1;
1114 
1115                 trace_snd_soc_dapm_path(widget, dir, path);
1116 
1117                 if (path->connect) {
1118                         path->walking = 1;
1119                         con += fn(path->node[dir], list, custom_stop_condition);
1120                         path->walking = 0;
1121                 }
1122         }
1123 
1124         widget->endpoints[dir] = con;
1125 
1126         return con;
1127 }
1128 
1129 /*
1130  * Recursively check for a completed path to an active or physically connected
1131  * output widget. Returns number of complete paths.
1132  *
1133  * Optionally, can be supplied with a function acting as a stopping condition.
1134  * This function takes the dapm widget currently being examined and the walk
1135  * direction as an arguments, it should return true if the walk should be
1136  * stopped and false otherwise.
1137  */
1138 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
1139         struct list_head *list,
1140         bool (*custom_stop_condition)(struct snd_soc_dapm_widget *i,
1141                                       enum snd_soc_dapm_direction))
1142 {
1143         return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_OUT,
1144                         is_connected_output_ep, custom_stop_condition);
1145 }
1146 
1147 /*
1148  * Recursively check for a completed path to an active or physically connected
1149  * input widget. Returns number of complete paths.
1150  *
1151  * Optionally, can be supplied with a function acting as a stopping condition.
1152  * This function takes the dapm widget currently being examined and the walk
1153  * direction as an arguments, it should return true if the walk should be
1154  * stopped and false otherwise.
1155  */
1156 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
1157         struct list_head *list,
1158         bool (*custom_stop_condition)(struct snd_soc_dapm_widget *i,
1159                                       enum snd_soc_dapm_direction))
1160 {
1161         return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_IN,
1162                         is_connected_input_ep, custom_stop_condition);
1163 }
1164 
1165 /**
1166  * snd_soc_dapm_get_connected_widgets - query audio path and it's widgets.
1167  * @dai: the soc DAI.
1168  * @stream: stream direction.
1169  * @list: list of active widgets for this stream.
1170  * @custom_stop_condition: (optional) a function meant to stop the widget graph
1171  *                         walk based on custom logic.
1172  *
1173  * Queries DAPM graph as to whether an valid audio stream path exists for
1174  * the initial stream specified by name. This takes into account
1175  * current mixer and mux kcontrol settings. Creates list of valid widgets.
1176  *
1177  * Optionally, can be supplied with a function acting as a stopping condition.
1178  * This function takes the dapm widget currently being examined and the walk
1179  * direction as an arguments, it should return true if the walk should be
1180  * stopped and false otherwise.
1181  *
1182  * Returns the number of valid paths or negative error.
1183  */
1184 int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream,
1185         struct snd_soc_dapm_widget_list **list,
1186         bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
1187                                       enum snd_soc_dapm_direction))
1188 {
1189         struct snd_soc_card *card = dai->component->card;
1190         struct snd_soc_dapm_widget *w;
1191         LIST_HEAD(widgets);
1192         int paths;
1193         int ret;
1194 
1195         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
1196 
1197         /*
1198          * For is_connected_{output,input}_ep fully discover the graph we need
1199          * to reset the cached number of inputs and outputs.
1200          */
1201         list_for_each_entry(w, &card->widgets, list) {
1202                 w->endpoints[SND_SOC_DAPM_DIR_IN] = -1;
1203                 w->endpoints[SND_SOC_DAPM_DIR_OUT] = -1;
1204         }
1205 
1206         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
1207                 paths = is_connected_output_ep(dai->playback_widget, &widgets,
1208                                 custom_stop_condition);
1209         else
1210                 paths = is_connected_input_ep(dai->capture_widget, &widgets,
1211                                 custom_stop_condition);
1212 
1213         /* Drop starting point */
1214         list_del(widgets.next);
1215 
1216         ret = dapm_widget_list_create(list, &widgets);
1217         if (ret)
1218                 paths = ret;
1219 
1220         trace_snd_soc_dapm_connected(paths, stream);
1221         mutex_unlock(&card->dapm_mutex);
1222 
1223         return paths;
1224 }
1225 
1226 /*
1227  * Handler for regulator supply widget.
1228  */
1229 int dapm_regulator_event(struct snd_soc_dapm_widget *w,
1230                    struct snd_kcontrol *kcontrol, int event)
1231 {
1232         int ret;
1233 
1234         soc_dapm_async_complete(w->dapm);
1235 
1236         if (SND_SOC_DAPM_EVENT_ON(event)) {
1237                 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1238                         ret = regulator_allow_bypass(w->regulator, false);
1239                         if (ret != 0)
1240                                 dev_warn(w->dapm->dev,
1241                                          "ASoC: Failed to unbypass %s: %d\n",
1242                                          w->name, ret);
1243                 }
1244 
1245                 return regulator_enable(w->regulator);
1246         } else {
1247                 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1248                         ret = regulator_allow_bypass(w->regulator, true);
1249                         if (ret != 0)
1250                                 dev_warn(w->dapm->dev,
1251                                          "ASoC: Failed to bypass %s: %d\n",
1252                                          w->name, ret);
1253                 }
1254 
1255                 return regulator_disable_deferred(w->regulator, w->shift);
1256         }
1257 }
1258 EXPORT_SYMBOL_GPL(dapm_regulator_event);
1259 
1260 /*
1261  * Handler for clock supply widget.
1262  */
1263 int dapm_clock_event(struct snd_soc_dapm_widget *w,
1264                    struct snd_kcontrol *kcontrol, int event)
1265 {
1266         if (!w->clk)
1267                 return -EIO;
1268 
1269         soc_dapm_async_complete(w->dapm);
1270 
1271 #ifdef CONFIG_HAVE_CLK
1272         if (SND_SOC_DAPM_EVENT_ON(event)) {
1273                 return clk_prepare_enable(w->clk);
1274         } else {
1275                 clk_disable_unprepare(w->clk);
1276                 return 0;
1277         }
1278 #endif
1279         return 0;
1280 }
1281 EXPORT_SYMBOL_GPL(dapm_clock_event);
1282 
1283 static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1284 {
1285         if (w->power_checked)
1286                 return w->new_power;
1287 
1288         if (w->force)
1289                 w->new_power = 1;
1290         else
1291                 w->new_power = w->power_check(w);
1292 
1293         w->power_checked = true;
1294 
1295         return w->new_power;
1296 }
1297 
1298 /* Generic check to see if a widget should be powered.
1299  */
1300 static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1301 {
1302         int in, out;
1303 
1304         DAPM_UPDATE_STAT(w, power_checks);
1305 
1306         in = is_connected_input_ep(w, NULL, NULL);
1307         out = is_connected_output_ep(w, NULL, NULL);
1308         return out != 0 && in != 0;
1309 }
1310 
1311 /* Check to see if a power supply is needed */
1312 static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1313 {
1314         struct snd_soc_dapm_path *path;
1315 
1316         DAPM_UPDATE_STAT(w, power_checks);
1317 
1318         /* Check if one of our outputs is connected */
1319         snd_soc_dapm_widget_for_each_sink_path(w, path) {
1320                 DAPM_UPDATE_STAT(w, neighbour_checks);
1321 
1322                 if (path->weak)
1323                         continue;
1324 
1325                 if (path->connected &&
1326                     !path->connected(path->source, path->sink))
1327                         continue;
1328 
1329                 if (dapm_widget_power_check(path->sink))
1330                         return 1;
1331         }
1332 
1333         return 0;
1334 }
1335 
1336 static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1337 {
1338         return w->connected;
1339 }
1340 
1341 static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
1342                             struct snd_soc_dapm_widget *b,
1343                             bool power_up)
1344 {
1345         int *sort;
1346 
1347         if (power_up)
1348                 sort = dapm_up_seq;
1349         else
1350                 sort = dapm_down_seq;
1351 
1352         if (sort[a->id] != sort[b->id])
1353                 return sort[a->id] - sort[b->id];
1354         if (a->subseq != b->subseq) {
1355                 if (power_up)
1356                         return a->subseq - b->subseq;
1357                 else
1358                         return b->subseq - a->subseq;
1359         }
1360         if (a->reg != b->reg)
1361                 return a->reg - b->reg;
1362         if (a->dapm != b->dapm)
1363                 return (unsigned long)a->dapm - (unsigned long)b->dapm;
1364 
1365         return 0;
1366 }
1367 
1368 /* Insert a widget in order into a DAPM power sequence. */
1369 static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
1370                             struct list_head *list,
1371                             bool power_up)
1372 {
1373         struct snd_soc_dapm_widget *w;
1374 
1375         list_for_each_entry(w, list, power_list)
1376                 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
1377                         list_add_tail(&new_widget->power_list, &w->power_list);
1378                         return;
1379                 }
1380 
1381         list_add_tail(&new_widget->power_list, list);
1382 }
1383 
1384 static void dapm_seq_check_event(struct snd_soc_card *card,
1385                                  struct snd_soc_dapm_widget *w, int event)
1386 {
1387         const char *ev_name;
1388         int power, ret;
1389 
1390         switch (event) {
1391         case SND_SOC_DAPM_PRE_PMU:
1392                 ev_name = "PRE_PMU";
1393                 power = 1;
1394                 break;
1395         case SND_SOC_DAPM_POST_PMU:
1396                 ev_name = "POST_PMU";
1397                 power = 1;
1398                 break;
1399         case SND_SOC_DAPM_PRE_PMD:
1400                 ev_name = "PRE_PMD";
1401                 power = 0;
1402                 break;
1403         case SND_SOC_DAPM_POST_PMD:
1404                 ev_name = "POST_PMD";
1405                 power = 0;
1406                 break;
1407         case SND_SOC_DAPM_WILL_PMU:
1408                 ev_name = "WILL_PMU";
1409                 power = 1;
1410                 break;
1411         case SND_SOC_DAPM_WILL_PMD:
1412                 ev_name = "WILL_PMD";
1413                 power = 0;
1414                 break;
1415         default:
1416                 WARN(1, "Unknown event %d\n", event);
1417                 return;
1418         }
1419 
1420         if (w->new_power != power)
1421                 return;
1422 
1423         if (w->event && (w->event_flags & event)) {
1424                 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
1425                         w->name, ev_name);
1426                 soc_dapm_async_complete(w->dapm);
1427                 trace_snd_soc_dapm_widget_event_start(w, event);
1428                 ret = w->event(w, NULL, event);
1429                 trace_snd_soc_dapm_widget_event_done(w, event);
1430                 if (ret < 0)
1431                         dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
1432                                ev_name, w->name, ret);
1433         }
1434 }
1435 
1436 /* Apply the coalesced changes from a DAPM sequence */
1437 static void dapm_seq_run_coalesced(struct snd_soc_card *card,
1438                                    struct list_head *pending)
1439 {
1440         struct snd_soc_dapm_context *dapm;
1441         struct snd_soc_dapm_widget *w;
1442         int reg;
1443         unsigned int value = 0;
1444         unsigned int mask = 0;
1445 
1446         w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
1447         reg = w->reg;
1448         dapm = w->dapm;
1449 
1450         list_for_each_entry(w, pending, power_list) {
1451                 WARN_ON(reg != w->reg || dapm != w->dapm);
1452                 w->power = w->new_power;
1453 
1454                 mask |= w->mask << w->shift;
1455                 if (w->power)
1456                         value |= w->on_val << w->shift;
1457                 else
1458                         value |= w->off_val << w->shift;
1459 
1460                 pop_dbg(dapm->dev, card->pop_time,
1461                         "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1462                         w->name, reg, value, mask);
1463 
1464                 /* Check for events */
1465                 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
1466                 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
1467         }
1468 
1469         if (reg >= 0) {
1470                 /* Any widget will do, they should all be updating the
1471                  * same register.
1472                  */
1473 
1474                 pop_dbg(dapm->dev, card->pop_time,
1475                         "pop test : Applying 0x%x/0x%x to %x in %dms\n",
1476                         value, mask, reg, card->pop_time);
1477                 pop_wait(card->pop_time);
1478                 soc_dapm_update_bits(dapm, reg, mask, value);
1479         }
1480 
1481         list_for_each_entry(w, pending, power_list) {
1482                 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
1483                 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
1484         }
1485 }
1486 
1487 /* Apply a DAPM power sequence.
1488  *
1489  * We walk over a pre-sorted list of widgets to apply power to.  In
1490  * order to minimise the number of writes to the device required
1491  * multiple widgets will be updated in a single write where possible.
1492  * Currently anything that requires more than a single write is not
1493  * handled.
1494  */
1495 static void dapm_seq_run(struct snd_soc_card *card,
1496         struct list_head *list, int event, bool power_up)
1497 {
1498         struct snd_soc_dapm_widget *w, *n;
1499         struct snd_soc_dapm_context *d;
1500         LIST_HEAD(pending);
1501         int cur_sort = -1;
1502         int cur_subseq = -1;
1503         int cur_reg = SND_SOC_NOPM;
1504         struct snd_soc_dapm_context *cur_dapm = NULL;
1505         int ret, i;
1506         int *sort;
1507 
1508         if (power_up)
1509                 sort = dapm_up_seq;
1510         else
1511                 sort = dapm_down_seq;
1512 
1513         list_for_each_entry_safe(w, n, list, power_list) {
1514                 ret = 0;
1515 
1516                 /* Do we need to apply any queued changes? */
1517                 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
1518                     w->dapm != cur_dapm || w->subseq != cur_subseq) {
1519                         if (!list_empty(&pending))
1520                                 dapm_seq_run_coalesced(card, &pending);
1521 
1522                         if (cur_dapm && cur_dapm->seq_notifier) {
1523                                 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1524                                         if (sort[i] == cur_sort)
1525                                                 cur_dapm->seq_notifier(cur_dapm,
1526                                                                        i,
1527                                                                        cur_subseq);
1528                         }
1529 
1530                         if (cur_dapm && w->dapm != cur_dapm)
1531                                 soc_dapm_async_complete(cur_dapm);
1532 
1533                         INIT_LIST_HEAD(&pending);
1534                         cur_sort = -1;
1535                         cur_subseq = INT_MIN;
1536                         cur_reg = SND_SOC_NOPM;
1537                         cur_dapm = NULL;
1538                 }
1539 
1540                 switch (w->id) {
1541                 case snd_soc_dapm_pre:
1542                         if (!w->event)
1543                                 list_for_each_entry_safe_continue(w, n, list,
1544                                                                   power_list);
1545 
1546                         if (event == SND_SOC_DAPM_STREAM_START)
1547                                 ret = w->event(w,
1548                                                NULL, SND_SOC_DAPM_PRE_PMU);
1549                         else if (event == SND_SOC_DAPM_STREAM_STOP)
1550                                 ret = w->event(w,
1551                                                NULL, SND_SOC_DAPM_PRE_PMD);
1552                         break;
1553 
1554                 case snd_soc_dapm_post:
1555                         if (!w->event)
1556                                 list_for_each_entry_safe_continue(w, n, list,
1557                                                                   power_list);
1558 
1559                         if (event == SND_SOC_DAPM_STREAM_START)
1560                                 ret = w->event(w,
1561                                                NULL, SND_SOC_DAPM_POST_PMU);
1562                         else if (event == SND_SOC_DAPM_STREAM_STOP)
1563                                 ret = w->event(w,
1564                                                NULL, SND_SOC_DAPM_POST_PMD);
1565                         break;
1566 
1567                 default:
1568                         /* Queue it up for application */
1569                         cur_sort = sort[w->id];
1570                         cur_subseq = w->subseq;
1571                         cur_reg = w->reg;
1572                         cur_dapm = w->dapm;
1573                         list_move(&w->power_list, &pending);
1574                         break;
1575                 }
1576 
1577                 if (ret < 0)
1578                         dev_err(w->dapm->dev,
1579                                 "ASoC: Failed to apply widget power: %d\n", ret);
1580         }
1581 
1582         if (!list_empty(&pending))
1583                 dapm_seq_run_coalesced(card, &pending);
1584 
1585         if (cur_dapm && cur_dapm->seq_notifier) {
1586                 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1587                         if (sort[i] == cur_sort)
1588                                 cur_dapm->seq_notifier(cur_dapm,
1589                                                        i, cur_subseq);
1590         }
1591 
1592         list_for_each_entry(d, &card->dapm_list, list) {
1593                 soc_dapm_async_complete(d);
1594         }
1595 }
1596 
1597 static void dapm_widget_update(struct snd_soc_card *card)
1598 {
1599         struct snd_soc_dapm_update *update = card->update;
1600         struct snd_soc_dapm_widget_list *wlist;
1601         struct snd_soc_dapm_widget *w = NULL;
1602         unsigned int wi;
1603         int ret;
1604 
1605         if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
1606                 return;
1607 
1608         wlist = dapm_kcontrol_get_wlist(update->kcontrol);
1609 
1610         for (wi = 0; wi < wlist->num_widgets; wi++) {
1611                 w = wlist->widgets[wi];
1612 
1613                 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1614                         ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1615                         if (ret != 0)
1616                                 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
1617                                            w->name, ret);
1618                 }
1619         }
1620 
1621         if (!w)
1622                 return;
1623 
1624         ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
1625                 update->val);
1626         if (ret < 0)
1627                 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
1628                         w->name, ret);
1629 
1630         for (wi = 0; wi < wlist->num_widgets; wi++) {
1631                 w = wlist->widgets[wi];
1632 
1633                 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1634                         ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1635                         if (ret != 0)
1636                                 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
1637                                            w->name, ret);
1638                 }
1639         }
1640 }
1641 
1642 /* Async callback run prior to DAPM sequences - brings to _PREPARE if
1643  * they're changing state.
1644  */
1645 static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1646 {
1647         struct snd_soc_dapm_context *d = data;
1648         int ret;
1649 
1650         /* If we're off and we're not supposed to be go into STANDBY */
1651         if (d->bias_level == SND_SOC_BIAS_OFF &&
1652             d->target_bias_level != SND_SOC_BIAS_OFF) {
1653                 if (d->dev)
1654                         pm_runtime_get_sync(d->dev);
1655 
1656                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1657                 if (ret != 0)
1658                         dev_err(d->dev,
1659                                 "ASoC: Failed to turn on bias: %d\n", ret);
1660         }
1661 
1662         /* Prepare for a transition to ON or away from ON */
1663         if ((d->target_bias_level == SND_SOC_BIAS_ON &&
1664              d->bias_level != SND_SOC_BIAS_ON) ||
1665             (d->target_bias_level != SND_SOC_BIAS_ON &&
1666              d->bias_level == SND_SOC_BIAS_ON)) {
1667                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1668                 if (ret != 0)
1669                         dev_err(d->dev,
1670                                 "ASoC: Failed to prepare bias: %d\n", ret);
1671         }
1672 }
1673 
1674 /* Async callback run prior to DAPM sequences - brings to their final
1675  * state.
1676  */
1677 static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1678 {
1679         struct snd_soc_dapm_context *d = data;
1680         int ret;
1681 
1682         /* If we just powered the last thing off drop to standby bias */
1683         if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1684             (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1685              d->target_bias_level == SND_SOC_BIAS_OFF)) {
1686                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1687                 if (ret != 0)
1688                         dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
1689                                 ret);
1690         }
1691 
1692         /* If we're in standby and can support bias off then do that */
1693         if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1694             d->target_bias_level == SND_SOC_BIAS_OFF) {
1695                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1696                 if (ret != 0)
1697                         dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
1698                                 ret);
1699 
1700                 if (d->dev)
1701                         pm_runtime_put(d->dev);
1702         }
1703 
1704         /* If we just powered up then move to active bias */
1705         if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1706             d->target_bias_level == SND_SOC_BIAS_ON) {
1707                 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1708                 if (ret != 0)
1709                         dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
1710                                 ret);
1711         }
1712 }
1713 
1714 static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
1715                                        bool power, bool connect)
1716 {
1717         /* If a connection is being made or broken then that update
1718          * will have marked the peer dirty, otherwise the widgets are
1719          * not connected and this update has no impact. */
1720         if (!connect)
1721                 return;
1722 
1723         /* If the peer is already in the state we're moving to then we
1724          * won't have an impact on it. */
1725         if (power != peer->power)
1726                 dapm_mark_dirty(peer, "peer state change");
1727 }
1728 
1729 static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
1730                                   struct list_head *up_list,
1731                                   struct list_head *down_list)
1732 {
1733         struct snd_soc_dapm_path *path;
1734 
1735         if (w->power == power)
1736                 return;
1737 
1738         trace_snd_soc_dapm_widget_power(w, power);
1739 
1740         /* If we changed our power state perhaps our neigbours changed
1741          * also.
1742          */
1743         snd_soc_dapm_widget_for_each_source_path(w, path)
1744                 dapm_widget_set_peer_power(path->source, power, path->connect);
1745 
1746         /* Supplies can't affect their outputs, only their inputs */
1747         if (!w->is_supply) {
1748                 snd_soc_dapm_widget_for_each_sink_path(w, path)
1749                         dapm_widget_set_peer_power(path->sink, power,
1750                                                    path->connect);
1751         }
1752 
1753         if (power)
1754                 dapm_seq_insert(w, up_list, true);
1755         else
1756                 dapm_seq_insert(w, down_list, false);
1757 }
1758 
1759 static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1760                                   struct list_head *up_list,
1761                                   struct list_head *down_list)
1762 {
1763         int power;
1764 
1765         switch (w->id) {
1766         case snd_soc_dapm_pre:
1767                 dapm_seq_insert(w, down_list, false);
1768                 break;
1769         case snd_soc_dapm_post:
1770                 dapm_seq_insert(w, up_list, true);
1771                 break;
1772 
1773         default:
1774                 power = dapm_widget_power_check(w);
1775 
1776                 dapm_widget_set_power(w, power, up_list, down_list);
1777                 break;
1778         }
1779 }
1780 
1781 static bool dapm_idle_bias_off(struct snd_soc_dapm_context *dapm)
1782 {
1783         if (dapm->idle_bias_off)
1784                 return true;
1785 
1786         switch (snd_power_get_state(dapm->card->snd_card)) {
1787         case SNDRV_CTL_POWER_D3hot:
1788         case SNDRV_CTL_POWER_D3cold:
1789                 return dapm->suspend_bias_off;
1790         default:
1791                 break;
1792         }
1793 
1794         return false;
1795 }
1796 
1797 /*
1798  * Scan each dapm widget for complete audio path.
1799  * A complete path is a route that has valid endpoints i.e.:-
1800  *
1801  *  o DAC to output pin.
1802  *  o Input Pin to ADC.
1803  *  o Input pin to Output pin (bypass, sidetone)
1804  *  o DAC to ADC (loopback).
1805  */
1806 static int dapm_power_widgets(struct snd_soc_card *card, int event)
1807 {
1808         struct snd_soc_dapm_widget *w;
1809         struct snd_soc_dapm_context *d;
1810         LIST_HEAD(up_list);
1811         LIST_HEAD(down_list);
1812         ASYNC_DOMAIN_EXCLUSIVE(async_domain);
1813         enum snd_soc_bias_level bias;
1814 
1815         lockdep_assert_held(&card->dapm_mutex);
1816 
1817         trace_snd_soc_dapm_start(card);
1818 
1819         list_for_each_entry(d, &card->dapm_list, list) {
1820                 if (dapm_idle_bias_off(d))
1821                         d->target_bias_level = SND_SOC_BIAS_OFF;
1822                 else
1823                         d->target_bias_level = SND_SOC_BIAS_STANDBY;
1824         }
1825 
1826         dapm_reset(card);
1827 
1828         /* Check which widgets we need to power and store them in
1829          * lists indicating if they should be powered up or down.  We
1830          * only check widgets that have been flagged as dirty but note
1831          * that new widgets may be added to the dirty list while we
1832          * iterate.
1833          */
1834         list_for_each_entry(w, &card->dapm_dirty, dirty) {
1835                 dapm_power_one_widget(w, &up_list, &down_list);
1836         }
1837 
1838         list_for_each_entry(w, &card->widgets, list) {
1839                 switch (w->id) {
1840                 case snd_soc_dapm_pre:
1841                 case snd_soc_dapm_post:
1842                         /* These widgets always need to be powered */
1843                         break;
1844                 default:
1845                         list_del_init(&w->dirty);
1846                         break;
1847                 }
1848 
1849                 if (w->new_power) {
1850                         d = w->dapm;
1851 
1852                         /* Supplies and micbiases only bring the
1853                          * context up to STANDBY as unless something
1854                          * else is active and passing audio they
1855                          * generally don't require full power.  Signal
1856                          * generators are virtual pins and have no
1857                          * power impact themselves.
1858                          */
1859                         switch (w->id) {
1860                         case snd_soc_dapm_siggen:
1861                         case snd_soc_dapm_vmid:
1862                                 break;
1863                         case snd_soc_dapm_supply:
1864                         case snd_soc_dapm_regulator_supply:
1865                         case snd_soc_dapm_clock_supply:
1866                         case snd_soc_dapm_micbias:
1867                                 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
1868                                         d->target_bias_level = SND_SOC_BIAS_STANDBY;
1869                                 break;
1870                         default:
1871                                 d->target_bias_level = SND_SOC_BIAS_ON;
1872                                 break;
1873                         }
1874                 }
1875 
1876         }
1877 
1878         /* Force all contexts in the card to the same bias state if
1879          * they're not ground referenced.
1880          */
1881         bias = SND_SOC_BIAS_OFF;
1882         list_for_each_entry(d, &card->dapm_list, list)
1883                 if (d->target_bias_level > bias)
1884                         bias = d->target_bias_level;
1885         list_for_each_entry(d, &card->dapm_list, list)
1886                 if (!dapm_idle_bias_off(d))
1887                         d->target_bias_level = bias;
1888 
1889         trace_snd_soc_dapm_walk_done(card);
1890 
1891         /* Run card bias changes at first */
1892         dapm_pre_sequence_async(&card->dapm, 0);
1893         /* Run other bias changes in parallel */
1894         list_for_each_entry(d, &card->dapm_list, list) {
1895                 if (d != &card->dapm)
1896                         async_schedule_domain(dapm_pre_sequence_async, d,
1897                                                 &async_domain);
1898         }
1899         async_synchronize_full_domain(&async_domain);
1900 
1901         list_for_each_entry(w, &down_list, power_list) {
1902                 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
1903         }
1904 
1905         list_for_each_entry(w, &up_list, power_list) {
1906                 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
1907         }
1908 
1909         /* Power down widgets first; try to avoid amplifying pops. */
1910         dapm_seq_run(card, &down_list, event, false);
1911 
1912         dapm_widget_update(card);
1913 
1914         /* Now power up. */
1915         dapm_seq_run(card, &up_list, event, true);
1916 
1917         /* Run all the bias changes in parallel */
1918         list_for_each_entry(d, &card->dapm_list, list) {
1919                 if (d != &card->dapm)
1920                         async_schedule_domain(dapm_post_sequence_async, d,
1921                                                 &async_domain);
1922         }
1923         async_synchronize_full_domain(&async_domain);
1924         /* Run card bias changes at last */
1925         dapm_post_sequence_async(&card->dapm, 0);
1926 
1927         /* do we need to notify any clients that DAPM event is complete */
1928         list_for_each_entry(d, &card->dapm_list, list) {
1929                 if (d->stream_event)
1930                         d->stream_event(d, event);
1931         }
1932 
1933         pop_dbg(card->dev, card->pop_time,
1934                 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
1935         pop_wait(card->pop_time);
1936 
1937         trace_snd_soc_dapm_done(card);
1938 
1939         return 0;
1940 }
1941 
1942 #ifdef CONFIG_DEBUG_FS
1943 static ssize_t dapm_widget_power_read_file(struct file *file,
1944                                            char __user *user_buf,
1945                                            size_t count, loff_t *ppos)
1946 {
1947         struct snd_soc_dapm_widget *w = file->private_data;
1948         struct snd_soc_card *card = w->dapm->card;
1949         enum snd_soc_dapm_direction dir, rdir;
1950         char *buf;
1951         int in, out;
1952         ssize_t ret;
1953         struct snd_soc_dapm_path *p = NULL;
1954 
1955         buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1956         if (!buf)
1957                 return -ENOMEM;
1958 
1959         mutex_lock(&card->dapm_mutex);
1960 
1961         /* Supply widgets are not handled by is_connected_{input,output}_ep() */
1962         if (w->is_supply) {
1963                 in = 0;
1964                 out = 0;
1965         } else {
1966                 in = is_connected_input_ep(w, NULL, NULL);
1967                 out = is_connected_output_ep(w, NULL, NULL);
1968         }
1969 
1970         ret = snprintf(buf, PAGE_SIZE, "%s: %s%s  in %d out %d",
1971                        w->name, w->power ? "On" : "Off",
1972                        w->force ? " (forced)" : "", in, out);
1973 
1974         if (w->reg >= 0)
1975                 ret += snprintf(buf + ret, PAGE_SIZE - ret,
1976                                 " - R%d(0x%x) mask 0x%x",
1977                                 w->reg, w->reg, w->mask << w->shift);
1978 
1979         ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n");
1980 
1981         if (w->sname)
1982                 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
1983                                 w->sname,
1984                                 w->active ? "active" : "inactive");
1985 
1986         snd_soc_dapm_for_each_direction(dir) {
1987                 rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
1988                 snd_soc_dapm_widget_for_each_path(w, dir, p) {
1989                         if (p->connected && !p->connected(w, p->node[rdir]))
1990                                 continue;
1991 
1992                         if (!p->connect)
1993                                 continue;
1994 
1995                         ret += snprintf(buf + ret, PAGE_SIZE - ret,
1996                                         " %s  \"%s\" \"%s\"\n",
1997                                         (rdir == SND_SOC_DAPM_DIR_IN) ? "in" : "out",
1998                                         p->name ? p->name : "static",
1999                                         p->node[rdir]->name);
2000                 }
2001         }
2002 
2003         mutex_unlock(&card->dapm_mutex);
2004 
2005         ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
2006 
2007         kfree(buf);
2008         return ret;
2009 }
2010 
2011 static const struct file_operations dapm_widget_power_fops = {
2012         .open = simple_open,
2013         .read = dapm_widget_power_read_file,
2014         .llseek = default_llseek,
2015 };
2016 
2017 static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
2018                                    size_t count, loff_t *ppos)
2019 {
2020         struct snd_soc_dapm_context *dapm = file->private_data;
2021         char *level;
2022 
2023         switch (dapm->bias_level) {
2024         case SND_SOC_BIAS_ON:
2025                 level = "On\n";
2026                 break;
2027         case SND_SOC_BIAS_PREPARE:
2028                 level = "Prepare\n";
2029                 break;
2030         case SND_SOC_BIAS_STANDBY:
2031                 level = "Standby\n";
2032                 break;
2033         case SND_SOC_BIAS_OFF:
2034                 level = "Off\n";
2035                 break;
2036         default:
2037                 WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
2038                 level = "Unknown\n";
2039                 break;
2040         }
2041 
2042         return simple_read_from_buffer(user_buf, count, ppos, level,
2043                                        strlen(level));
2044 }
2045 
2046 static const struct file_operations dapm_bias_fops = {
2047         .open = simple_open,
2048         .read = dapm_bias_read_file,
2049         .llseek = default_llseek,
2050 };
2051 
2052 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2053         struct dentry *parent)
2054 {
2055         struct dentry *d;
2056 
2057         if (!parent)
2058                 return;
2059 
2060         dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
2061 
2062         if (!dapm->debugfs_dapm) {
2063                 dev_warn(dapm->dev,
2064                        "ASoC: Failed to create DAPM debugfs directory\n");
2065                 return;
2066         }
2067 
2068         d = debugfs_create_file("bias_level", 0444,
2069                                 dapm->debugfs_dapm, dapm,
2070                                 &dapm_bias_fops);
2071         if (!d)
2072                 dev_warn(dapm->dev,
2073                          "ASoC: Failed to create bias level debugfs file\n");
2074 }
2075 
2076 static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2077 {
2078         struct snd_soc_dapm_context *dapm = w->dapm;
2079         struct dentry *d;
2080 
2081         if (!dapm->debugfs_dapm || !w->name)
2082                 return;
2083 
2084         d = debugfs_create_file(w->name, 0444,
2085                                 dapm->debugfs_dapm, w,
2086                                 &dapm_widget_power_fops);
2087         if (!d)
2088                 dev_warn(w->dapm->dev,
2089                         "ASoC: Failed to create %s debugfs file\n",
2090                         w->name);
2091 }
2092 
2093 static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2094 {
2095         debugfs_remove_recursive(dapm->debugfs_dapm);
2096 }
2097 
2098 #else
2099 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2100         struct dentry *parent)
2101 {
2102 }
2103 
2104 static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2105 {
2106 }
2107 
2108 static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2109 {
2110 }
2111 
2112 #endif
2113 
2114 /*
2115  * soc_dapm_connect_path() - Connects or disconnects a path
2116  * @path: The path to update
2117  * @connect: The new connect state of the path. True if the path is connected,
2118  *  false if it is disconneted.
2119  * @reason: The reason why the path changed (for debugging only)
2120  */
2121 static void soc_dapm_connect_path(struct snd_soc_dapm_path *path,
2122         bool connect, const char *reason)
2123 {
2124         if (path->connect == connect)
2125                 return;
2126 
2127         path->connect = connect;
2128         dapm_mark_dirty(path->source, reason);
2129         dapm_mark_dirty(path->sink, reason);
2130         dapm_path_invalidate(path);
2131 }
2132 
2133 /* test and update the power status of a mux widget */
2134 static int soc_dapm_mux_update_power(struct snd_soc_card *card,
2135                                  struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
2136 {
2137         struct snd_soc_dapm_path *path;
2138         int found = 0;
2139         bool connect;
2140 
2141         lockdep_assert_held(&card->dapm_mutex);
2142 
2143         /* find dapm widget path assoc with kcontrol */
2144         dapm_kcontrol_for_each_path(path, kcontrol) {
2145                 found = 1;
2146                 /* we now need to match the string in the enum to the path */
2147                 if (!(strcmp(path->name, e->texts[mux])))
2148                         connect = true;
2149                 else
2150                         connect = false;
2151 
2152                 soc_dapm_connect_path(path, connect, "mux update");
2153         }
2154 
2155         if (found)
2156                 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2157 
2158         return found;
2159 }
2160 
2161 int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
2162         struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
2163         struct snd_soc_dapm_update *update)
2164 {
2165         struct snd_soc_card *card = dapm->card;
2166         int ret;
2167 
2168         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2169         card->update = update;
2170         ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
2171         card->update = NULL;
2172         mutex_unlock(&card->dapm_mutex);
2173         if (ret > 0)
2174                 soc_dpcm_runtime_update(card);
2175         return ret;
2176 }
2177 EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
2178 
2179 /* test and update the power status of a mixer or switch widget */
2180 static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
2181                                    struct snd_kcontrol *kcontrol, int connect)
2182 {
2183         struct snd_soc_dapm_path *path;
2184         int found = 0;
2185 
2186         lockdep_assert_held(&card->dapm_mutex);
2187 
2188         /* find dapm widget path assoc with kcontrol */
2189         dapm_kcontrol_for_each_path(path, kcontrol) {
2190                 found = 1;
2191                 soc_dapm_connect_path(path, connect, "mixer update");
2192         }
2193 
2194         if (found)
2195                 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2196 
2197         return found;
2198 }
2199 
2200 int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
2201         struct snd_kcontrol *kcontrol, int connect,
2202         struct snd_soc_dapm_update *update)
2203 {
2204         struct snd_soc_card *card = dapm->card;
2205         int ret;
2206 
2207         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2208         card->update = update;
2209         ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
2210         card->update = NULL;
2211         mutex_unlock(&card->dapm_mutex);
2212         if (ret > 0)
2213                 soc_dpcm_runtime_update(card);
2214         return ret;
2215 }
2216 EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
2217 
2218 static ssize_t dapm_widget_show_component(struct snd_soc_component *cmpnt,
2219         char *buf)
2220 {
2221         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
2222         struct snd_soc_dapm_widget *w;
2223         int count = 0;
2224         char *state = "not set";
2225 
2226         /* card won't be set for the dummy component, as a spot fix
2227          * we're checking for that case specifically here but in future
2228          * we will ensure that the dummy component looks like others.
2229          */
2230         if (!cmpnt->card)
2231                 return 0;
2232 
2233         list_for_each_entry(w, &cmpnt->card->widgets, list) {
2234                 if (w->dapm != dapm)
2235                         continue;
2236 
2237                 /* only display widgets that burnm power */
2238                 switch (w->id) {
2239                 case snd_soc_dapm_hp:
2240                 case snd_soc_dapm_mic:
2241                 case snd_soc_dapm_spk:
2242                 case snd_soc_dapm_line:
2243                 case snd_soc_dapm_micbias:
2244                 case snd_soc_dapm_dac:
2245                 case snd_soc_dapm_adc:
2246                 case snd_soc_dapm_pga:
2247                 case snd_soc_dapm_out_drv:
2248                 case snd_soc_dapm_mixer:
2249                 case snd_soc_dapm_mixer_named_ctl:
2250                 case snd_soc_dapm_supply:
2251                 case snd_soc_dapm_regulator_supply:
2252                 case snd_soc_dapm_clock_supply:
2253                         if (w->name)
2254                                 count += sprintf(buf + count, "%s: %s\n",
2255                                         w->name, w->power ? "On":"Off");
2256                 break;
2257                 default:
2258                 break;
2259                 }
2260         }
2261 
2262         switch (snd_soc_dapm_get_bias_level(dapm)) {
2263         case SND_SOC_BIAS_ON:
2264                 state = "On";
2265                 break;
2266         case SND_SOC_BIAS_PREPARE:
2267                 state = "Prepare";
2268                 break;
2269         case SND_SOC_BIAS_STANDBY:
2270                 state = "Standby";
2271                 break;
2272         case SND_SOC_BIAS_OFF:
2273                 state = "Off";
2274                 break;
2275         }
2276         count += sprintf(buf + count, "PM State: %s\n", state);
2277 
2278         return count;
2279 }
2280 
2281 /* show dapm widget status in sys fs */
2282 static ssize_t dapm_widget_show(struct device *dev,
2283         struct device_attribute *attr, char *buf)
2284 {
2285         struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
2286         int i, count = 0;
2287 
2288         mutex_lock(&rtd->card->dapm_mutex);
2289 
2290         for (i = 0; i < rtd->num_codecs; i++) {
2291                 struct snd_soc_component *cmpnt = rtd->codec_dais[i]->component;
2292 
2293                 count += dapm_widget_show_component(cmpnt, buf + count);
2294         }
2295 
2296         mutex_unlock(&rtd->card->dapm_mutex);
2297 
2298         return count;
2299 }
2300 
2301 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
2302 
2303 struct attribute *soc_dapm_dev_attrs[] = {
2304         &dev_attr_dapm_widget.attr,
2305         NULL
2306 };
2307 
2308 static void dapm_free_path(struct snd_soc_dapm_path *path)
2309 {
2310         list_del(&path->list_node[SND_SOC_DAPM_DIR_IN]);
2311         list_del(&path->list_node[SND_SOC_DAPM_DIR_OUT]);
2312         list_del(&path->list_kcontrol);
2313         list_del(&path->list);
2314         kfree(path);
2315 }
2316 
2317 void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w)
2318 {
2319         struct snd_soc_dapm_path *p, *next_p;
2320         enum snd_soc_dapm_direction dir;
2321 
2322         list_del(&w->list);
2323         /*
2324          * remove source and sink paths associated to this widget.
2325          * While removing the path, remove reference to it from both
2326          * source and sink widgets so that path is removed only once.
2327          */
2328         snd_soc_dapm_for_each_direction(dir) {
2329                 snd_soc_dapm_widget_for_each_path_safe(w, dir, p, next_p)
2330                         dapm_free_path(p);
2331         }
2332 
2333         kfree(w->kcontrols);
2334         kfree_const(w->name);
2335         kfree(w);
2336 }
2337 
2338 void snd_soc_dapm_reset_cache(struct snd_soc_dapm_context *dapm)
2339 {
2340         dapm->path_sink_cache.widget = NULL;
2341         dapm->path_source_cache.widget = NULL;
2342 }
2343 
2344 /* free all dapm widgets and resources */
2345 static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
2346 {
2347         struct snd_soc_dapm_widget *w, *next_w;
2348 
2349         list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
2350                 if (w->dapm != dapm)
2351                         continue;
2352                 snd_soc_dapm_free_widget(w);
2353         }
2354         snd_soc_dapm_reset_cache(dapm);
2355 }
2356 
2357 static struct snd_soc_dapm_widget *dapm_find_widget(
2358                         struct snd_soc_dapm_context *dapm, const char *pin,
2359                         bool search_other_contexts)
2360 {
2361         struct snd_soc_dapm_widget *w;
2362         struct snd_soc_dapm_widget *fallback = NULL;
2363 
2364         list_for_each_entry(w, &dapm->card->widgets, list) {
2365                 if (!strcmp(w->name, pin)) {
2366                         if (w->dapm == dapm)
2367                                 return w;
2368                         else
2369                                 fallback = w;
2370                 }
2371         }
2372 
2373         if (search_other_contexts)
2374                 return fallback;
2375 
2376         return NULL;
2377 }
2378 
2379 static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
2380                                 const char *pin, int status)
2381 {
2382         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
2383 
2384         dapm_assert_locked(dapm);
2385 
2386         if (!w) {
2387                 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
2388                 return -EINVAL;
2389         }
2390 
2391         if (w->connected != status) {
2392                 dapm_mark_dirty(w, "pin configuration");
2393                 dapm_widget_invalidate_input_paths(w);
2394                 dapm_widget_invalidate_output_paths(w);
2395         }
2396 
2397         w->connected = status;
2398         if (status == 0)
2399                 w->force = 0;
2400 
2401         return 0;
2402 }
2403 
2404 /**
2405  * snd_soc_dapm_sync_unlocked - scan and power dapm paths
2406  * @dapm: DAPM context
2407  *
2408  * Walks all dapm audio paths and powers widgets according to their
2409  * stream or path usage.
2410  *
2411  * Requires external locking.
2412  *
2413  * Returns 0 for success.
2414  */
2415 int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
2416 {
2417         /*
2418          * Suppress early reports (eg, jacks syncing their state) to avoid
2419          * silly DAPM runs during card startup.
2420          */
2421         if (!dapm->card || !dapm->card->instantiated)
2422                 return 0;
2423 
2424         return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
2425 }
2426 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked);
2427 
2428 /**
2429  * snd_soc_dapm_sync - scan and power dapm paths
2430  * @dapm: DAPM context
2431  *
2432  * Walks all dapm audio paths and powers widgets according to their
2433  * stream or path usage.
2434  *
2435  * Returns 0 for success.
2436  */
2437 int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
2438 {
2439         int ret;
2440 
2441         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2442         ret = snd_soc_dapm_sync_unlocked(dapm);
2443         mutex_unlock(&dapm->card->dapm_mutex);
2444         return ret;
2445 }
2446 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
2447 
2448 /*
2449  * dapm_update_widget_flags() - Re-compute widget sink and source flags
2450  * @w: The widget for which to update the flags
2451  *
2452  * Some widgets have a dynamic category which depends on which neighbors they
2453  * are connected to. This function update the category for these widgets.
2454  *
2455  * This function must be called whenever a path is added or removed to a widget.
2456  */
2457 static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
2458 {
2459         enum snd_soc_dapm_direction dir;
2460         struct snd_soc_dapm_path *p;
2461         unsigned int ep;
2462 
2463         switch (w->id) {
2464         case snd_soc_dapm_input:
2465                 /* On a fully routed card a input is never a source */
2466                 if (w->dapm->card->fully_routed)
2467                         return;
2468                 ep = SND_SOC_DAPM_EP_SOURCE;
2469                 snd_soc_dapm_widget_for_each_source_path(w, p) {
2470                         if (p->source->id == snd_soc_dapm_micbias ||
2471                                 p->source->id == snd_soc_dapm_mic ||
2472                                 p->source->id == snd_soc_dapm_line ||
2473                                 p->source->id == snd_soc_dapm_output) {
2474                                         ep = 0;
2475                                         break;
2476                         }
2477                 }
2478                 break;
2479         case snd_soc_dapm_output:
2480                 /* On a fully routed card a output is never a sink */
2481                 if (w->dapm->card->fully_routed)
2482                         return;
2483                 ep = SND_SOC_DAPM_EP_SINK;
2484                 snd_soc_dapm_widget_for_each_sink_path(w, p) {
2485                         if (p->sink->id == snd_soc_dapm_spk ||
2486                                 p->sink->id == snd_soc_dapm_hp ||
2487                                 p->sink->id == snd_soc_dapm_line ||
2488                                 p->sink->id == snd_soc_dapm_input) {
2489                                         ep = 0;
2490                                         break;
2491                         }
2492                 }
2493                 break;
2494         case snd_soc_dapm_line:
2495                 ep = 0;
2496                 snd_soc_dapm_for_each_direction(dir) {
2497                         if (!list_empty(&w->edges[dir]))
2498                                 ep |= SND_SOC_DAPM_DIR_TO_EP(dir);
2499                 }
2500                 break;
2501         default:
2502                 return;
2503         }
2504 
2505         w->is_ep = ep;
2506 }
2507 
2508 static int snd_soc_dapm_check_dynamic_path(struct snd_soc_dapm_context *dapm,
2509         struct snd_soc_dapm_widget *source, struct snd_soc_dapm_widget *sink,
2510         const char *control)
2511 {
2512         bool dynamic_source = false;
2513         bool dynamic_sink = false;
2514 
2515         if (!control)
2516                 return 0;
2517 
2518         switch (source->id) {
2519         case snd_soc_dapm_demux:
2520                 dynamic_source = true;
2521                 break;
2522         default:
2523                 break;
2524         }
2525 
2526         switch (sink->id) {
2527         case snd_soc_dapm_mux:
2528         case snd_soc_dapm_switch:
2529         case snd_soc_dapm_mixer:
2530         case snd_soc_dapm_mixer_named_ctl:
2531                 dynamic_sink = true;
2532                 break;
2533         default:
2534                 break;
2535         }
2536 
2537         if (dynamic_source && dynamic_sink) {
2538                 dev_err(dapm->dev,
2539                         "Direct connection between demux and mixer/mux not supported for path %s -> [%s] -> %s\n",
2540                         source->name, control, sink->name);
2541                 return -EINVAL;
2542         } else if (!dynamic_source && !dynamic_sink) {
2543                 dev_err(dapm->dev,
2544                         "Control not supported for path %s -> [%s] -> %s\n",
2545                         source->name, control, sink->name);
2546                 return -EINVAL;
2547         }
2548 
2549         return 0;
2550 }
2551 
2552 static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
2553         struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
2554         const char *control,
2555         int (*connected)(struct snd_soc_dapm_widget *source,
2556                          struct snd_soc_dapm_widget *sink))
2557 {
2558         struct snd_soc_dapm_widget *widgets[2];
2559         enum snd_soc_dapm_direction dir;
2560         struct snd_soc_dapm_path *path;
2561         int ret;
2562 
2563         if (wsink->is_supply && !wsource->is_supply) {
2564                 dev_err(dapm->dev,
2565                         "Connecting non-supply widget to supply widget is not supported (%s -> %s)\n",
2566                         wsource->name, wsink->name);
2567                 return -EINVAL;
2568         }
2569 
2570         if (connected && !wsource->is_supply) {
2571                 dev_err(dapm->dev,
2572                         "connected() callback only supported for supply widgets (%s -> %s)\n",
2573                         wsource->name, wsink->name);
2574                 return -EINVAL;
2575         }
2576 
2577         if (wsource->is_supply && control) {
2578                 dev_err(dapm->dev,
2579                         "Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
2580                         wsource->name, control, wsink->name);
2581                 return -EINVAL;
2582         }
2583 
2584         ret = snd_soc_dapm_check_dynamic_path(dapm, wsource, wsink, control);
2585         if (ret)
2586                 return ret;
2587 
2588         path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
2589         if (!path)
2590                 return -ENOMEM;
2591 
2592         path->node[SND_SOC_DAPM_DIR_IN] = wsource;
2593         path->node[SND_SOC_DAPM_DIR_OUT] = wsink;
2594         widgets[SND_SOC_DAPM_DIR_IN] = wsource;
2595         widgets[SND_SOC_DAPM_DIR_OUT] = wsink;
2596 
2597         path->connected = connected;
2598         INIT_LIST_HEAD(&path->list);
2599         INIT_LIST_HEAD(&path->list_kcontrol);
2600 
2601         if (wsource->is_supply || wsink->is_supply)
2602                 path->is_supply = 1;
2603 
2604         /* connect static paths */
2605         if (control == NULL) {
2606                 path->connect = 1;
2607         } else {
2608                 switch (wsource->id) {
2609                 case snd_soc_dapm_demux:
2610                         ret = dapm_connect_mux(dapm, path, control, wsource);
2611                         if (ret)
2612                                 goto err;
2613                         break;
2614                 default:
2615                         break;
2616                 }
2617 
2618                 switch (wsink->id) {
2619                 case snd_soc_dapm_mux:
2620                         ret = dapm_connect_mux(dapm, path, control, wsink);
2621                         if (ret != 0)
2622                                 goto err;
2623                         break;
2624                 case snd_soc_dapm_switch:
2625                 case snd_soc_dapm_mixer:
2626                 case snd_soc_dapm_mixer_named_ctl:
2627                         ret = dapm_connect_mixer(dapm, path, control);
2628                         if (ret != 0)
2629                                 goto err;
2630                         break;
2631                 default:
2632                         break;
2633                 }
2634         }
2635 
2636         list_add(&path->list, &dapm->card->paths);
2637         snd_soc_dapm_for_each_direction(dir)
2638                 list_add(&path->list_node[dir], &widgets[dir]->edges[dir]);
2639 
2640         snd_soc_dapm_for_each_direction(dir) {
2641                 dapm_update_widget_flags(widgets[dir]);
2642                 dapm_mark_dirty(widgets[dir], "Route added");
2643         }
2644 
2645         if (dapm->card->instantiated && path->connect)
2646                 dapm_path_invalidate(path);
2647 
2648         return 0;
2649 err:
2650         kfree(path);
2651         return ret;
2652 }
2653 
2654 static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
2655                                   const struct snd_soc_dapm_route *route)
2656 {
2657         struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
2658         struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
2659         const char *sink;
2660         const char *source;
2661         char prefixed_sink[80];
2662         char prefixed_source[80];
2663         const char *prefix;
2664         int ret;
2665 
2666         prefix = soc_dapm_prefix(dapm);
2667         if (prefix) {
2668                 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
2669                          prefix, route->sink);
2670                 sink = prefixed_sink;
2671                 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
2672                          prefix, route->source);
2673                 source = prefixed_source;
2674         } else {
2675                 sink = route->sink;
2676                 source = route->source;
2677         }
2678 
2679         wsource = dapm_wcache_lookup(&dapm->path_source_cache, source);
2680         wsink = dapm_wcache_lookup(&dapm->path_sink_cache, sink);
2681 
2682         if (wsink && wsource)
2683                 goto skip_search;
2684 
2685         /*
2686          * find src and dest widgets over all widgets but favor a widget from
2687          * current DAPM context
2688          */
2689         list_for_each_entry(w, &dapm->card->widgets, list) {
2690                 if (!wsink && !(strcmp(w->name, sink))) {
2691                         wtsink = w;
2692                         if (w->dapm == dapm) {
2693                                 wsink = w;
2694                                 if (wsource)
2695                                         break;
2696                         }
2697                         continue;
2698                 }
2699                 if (!wsource && !(strcmp(w->name, source))) {
2700                         wtsource = w;
2701                         if (w->dapm == dapm) {
2702                                 wsource = w;
2703                                 if (wsink)
2704                                         break;
2705                         }
2706                 }
2707         }
2708         /* use widget from another DAPM context if not found from this */
2709         if (!wsink)
2710                 wsink = wtsink;
2711         if (!wsource)
2712                 wsource = wtsource;
2713 
2714         if (wsource == NULL) {
2715                 dev_err(dapm->dev, "ASoC: no source widget found for %s\n",
2716                         route->source);
2717                 return -ENODEV;
2718         }
2719         if (wsink == NULL) {
2720                 dev_err(dapm->dev, "ASoC: no sink widget found for %s\n",
2721                         route->sink);
2722                 return -ENODEV;
2723         }
2724 
2725 skip_search:
2726         dapm_wcache_update(&dapm->path_sink_cache, wsink);
2727         dapm_wcache_update(&dapm->path_source_cache, wsource);
2728 
2729         ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,
2730                 route->connected);
2731         if (ret)
2732                 goto err;
2733 
2734         return 0;
2735 err:
2736         dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n",
2737                  source, route->control, sink);
2738         return ret;
2739 }
2740 
2741 static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
2742                                   const struct snd_soc_dapm_route *route)
2743 {
2744         struct snd_soc_dapm_widget *wsource, *wsink;
2745         struct snd_soc_dapm_path *path, *p;
2746         const char *sink;
2747         const char *source;
2748         char prefixed_sink[80];
2749         char prefixed_source[80];
2750         const char *prefix;
2751 
2752         if (route->control) {
2753                 dev_err(dapm->dev,
2754                         "ASoC: Removal of routes with controls not supported\n");
2755                 return -EINVAL;
2756         }
2757 
2758         prefix = soc_dapm_prefix(dapm);
2759         if (prefix) {
2760                 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
2761                          prefix, route->sink);
2762                 sink = prefixed_sink;
2763                 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
2764                          prefix, route->source);
2765                 source = prefixed_source;
2766         } else {
2767                 sink = route->sink;
2768                 source = route->source;
2769         }
2770 
2771         path = NULL;
2772         list_for_each_entry(p, &dapm->card->paths, list) {
2773                 if (strcmp(p->source->name, source) != 0)
2774                         continue;
2775                 if (strcmp(p->sink->name, sink) != 0)
2776                         continue;
2777                 path = p;
2778                 break;
2779         }
2780 
2781         if (path) {
2782                 wsource = path->source;
2783                 wsink = path->sink;
2784 
2785                 dapm_mark_dirty(wsource, "Route removed");
2786                 dapm_mark_dirty(wsink, "Route removed");
2787                 if (path->connect)
2788                         dapm_path_invalidate(path);
2789 
2790                 dapm_free_path(path);
2791 
2792                 /* Update any path related flags */
2793                 dapm_update_widget_flags(wsource);
2794                 dapm_update_widget_flags(wsink);
2795         } else {
2796                 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
2797                          source, sink);
2798         }
2799 
2800         return 0;
2801 }
2802 
2803 /**
2804  * snd_soc_dapm_add_routes - Add routes between DAPM widgets
2805  * @dapm: DAPM context
2806  * @route: audio routes
2807  * @num: number of routes
2808  *
2809  * Connects 2 dapm widgets together via a named audio path. The sink is
2810  * the widget receiving the audio signal, whilst the source is the sender
2811  * of the audio signal.
2812  *
2813  * Returns 0 for success else error. On error all resources can be freed
2814  * with a call to snd_soc_card_free().
2815  */
2816 int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
2817                             const struct snd_soc_dapm_route *route, int num)
2818 {
2819         int i, r, ret = 0;
2820 
2821         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2822         for (i = 0; i < num; i++) {
2823                 r = snd_soc_dapm_add_route(dapm, route);
2824                 if (r < 0) {
2825                         dev_err(dapm->dev, "ASoC: Failed to add route %s -> %s -> %s\n",
2826                                 route->source,
2827                                 route->control ? route->control : "direct",
2828                                 route->sink);
2829                         ret = r;
2830                 }
2831                 route++;
2832         }
2833         mutex_unlock(&dapm->card->dapm_mutex);
2834 
2835         return ret;
2836 }
2837 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
2838 
2839 /**
2840  * snd_soc_dapm_del_routes - Remove routes between DAPM widgets
2841  * @dapm: DAPM context
2842  * @route: audio routes
2843  * @num: number of routes
2844  *
2845  * Removes routes from the DAPM context.
2846  */
2847 int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm,
2848                             const struct snd_soc_dapm_route *route, int num)
2849 {
2850         int i;
2851 
2852         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2853         for (i = 0; i < num; i++) {
2854                 snd_soc_dapm_del_route(dapm, route);
2855                 route++;
2856         }
2857         mutex_unlock(&dapm->card->dapm_mutex);
2858 
2859         return 0;
2860 }
2861 EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes);
2862 
2863 static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
2864                                    const struct snd_soc_dapm_route *route)
2865 {
2866         struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
2867                                                               route->source,
2868                                                               true);
2869         struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
2870                                                             route->sink,
2871                                                             true);
2872         struct snd_soc_dapm_path *path;
2873         int count = 0;
2874 
2875         if (!source) {
2876                 dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
2877                         route->source);
2878                 return -ENODEV;
2879         }
2880 
2881         if (!sink) {
2882                 dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
2883                         route->sink);
2884                 return -ENODEV;
2885         }
2886 
2887         if (route->control || route->connected)
2888                 dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
2889                          route->source, route->sink);
2890 
2891         snd_soc_dapm_widget_for_each_sink_path(source, path) {
2892                 if (path->sink == sink) {
2893                         path->weak = 1;
2894                         count++;
2895                 }
2896         }
2897 
2898         if (count == 0)
2899                 dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
2900                         route->source, route->sink);
2901         if (count > 1)
2902                 dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
2903                          count, route->source, route->sink);
2904 
2905         return 0;
2906 }
2907 
2908 /**
2909  * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak
2910  * @dapm: DAPM context
2911  * @route: audio routes
2912  * @num: number of routes
2913  *
2914  * Mark existing routes matching those specified in the passed array
2915  * as being weak, meaning that they are ignored for the purpose of
2916  * power decisions.  The main intended use case is for sidetone paths
2917  * which couple audio between other independent paths if they are both
2918  * active in order to make the combination work better at the user
2919  * level but which aren't intended to be "used".
2920  *
2921  * Note that CODEC drivers should not use this as sidetone type paths
2922  * can frequently also be used as bypass paths.
2923  */
2924 int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
2925                              const struct snd_soc_dapm_route *route, int num)
2926 {
2927         int i, err;
2928         int ret = 0;
2929 
2930         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2931         for (i = 0; i < num; i++) {
2932                 err = snd_soc_dapm_weak_route(dapm, route);
2933                 if (err)
2934                         ret = err;
2935                 route++;
2936         }
2937         mutex_unlock(&dapm->card->dapm_mutex);
2938 
2939         return ret;
2940 }
2941 EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
2942 
2943 /**
2944  * snd_soc_dapm_new_widgets - add new dapm widgets
2945  * @card: card to be checked for new dapm widgets
2946  *
2947  * Checks the codec for any new dapm widgets and creates them if found.
2948  *
2949  * Returns 0 for success.
2950  */
2951 int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
2952 {
2953         struct snd_soc_dapm_widget *w;
2954         unsigned int val;
2955 
2956         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
2957 
2958         list_for_each_entry(w, &card->widgets, list)
2959         {
2960                 if (w->new)
2961                         continue;
2962 
2963                 if (w->num_kcontrols) {
2964                         w->kcontrols = kzalloc(w->num_kcontrols *
2965                                                 sizeof(struct snd_kcontrol *),
2966                                                 GFP_KERNEL);
2967                         if (!w->kcontrols) {
2968                                 mutex_unlock(&card->dapm_mutex);
2969                                 return -ENOMEM;
2970                         }
2971                 }
2972 
2973                 switch(w->id) {
2974                 case snd_soc_dapm_switch:
2975                 case snd_soc_dapm_mixer:
2976                 case snd_soc_dapm_mixer_named_ctl:
2977                         dapm_new_mixer(w);
2978                         break;
2979                 case snd_soc_dapm_mux:
2980                 case snd_soc_dapm_demux:
2981                         dapm_new_mux(w);
2982                         break;
2983                 case snd_soc_dapm_pga:
2984                 case snd_soc_dapm_out_drv:
2985                         dapm_new_pga(w);
2986                         break;
2987                 case snd_soc_dapm_dai_link:
2988                         dapm_new_dai_link(w);
2989                         break;
2990                 default:
2991                         break;
2992                 }
2993 
2994                 /* Read the initial power state from the device */
2995                 if (w->reg >= 0) {
2996                         soc_dapm_read(w->dapm, w->reg, &val);
2997                         val = val >> w->shift;
2998                         val &= w->mask;
2999                         if (val == w->on_val)
3000                                 w->power = 1;
3001                 }
3002 
3003                 w->new = 1;
3004 
3005                 dapm_mark_dirty(w, "new widget");
3006                 dapm_debugfs_add_widget(w);
3007         }
3008 
3009         dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
3010         mutex_unlock(&card->dapm_mutex);
3011         return 0;
3012 }
3013 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
3014 
3015 /**
3016  * snd_soc_dapm_get_volsw - dapm mixer get callback
3017  * @kcontrol: mixer control
3018  * @ucontrol: control element information
3019  *
3020  * Callback to get the value of a dapm mixer control.
3021  *
3022  * Returns 0 for success.
3023  */
3024 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
3025         struct snd_ctl_elem_value *ucontrol)
3026 {
3027         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3028         struct snd_soc_card *card = dapm->card;
3029         struct soc_mixer_control *mc =
3030                 (struct soc_mixer_control *)kcontrol->private_value;
3031         int reg = mc->reg;
3032         unsigned int shift = mc->shift;
3033         int max = mc->max;
3034         unsigned int mask = (1 << fls(max)) - 1;
3035         unsigned int invert = mc->invert;
3036         unsigned int val;
3037         int ret = 0;
3038 
3039         if (snd_soc_volsw_is_stereo(mc))
3040                 dev_warn(dapm->dev,
3041                          "ASoC: Control '%s' is stereo, which is not supported\n",
3042                          kcontrol->id.name);
3043 
3044         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3045         if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
3046                 ret = soc_dapm_read(dapm, reg, &val);
3047                 val = (val >> shift) & mask;
3048         } else {
3049                 val = dapm_kcontrol_get_value(kcontrol);
3050         }
3051         mutex_unlock(&card->dapm_mutex);
3052 
3053         if (ret)
3054                 return ret;
3055 
3056         if (invert)
3057                 ucontrol->value.integer.value[0] = max - val;
3058         else
3059                 ucontrol->value.integer.value[0] = val;
3060 
3061         return ret;
3062 }
3063 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
3064 
3065 /**
3066  * snd_soc_dapm_put_volsw - dapm mixer set callback
3067  * @kcontrol: mixer control
3068  * @ucontrol: control element information
3069  *
3070  * Callback to set the value of a dapm mixer control.
3071  *
3072  * Returns 0 for success.
3073  */
3074 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
3075         struct snd_ctl_elem_value *ucontrol)
3076 {
3077         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3078         struct snd_soc_card *card = dapm->card;
3079         struct soc_mixer_control *mc =
3080                 (struct soc_mixer_control *)kcontrol->private_value;
3081         int reg = mc->reg;
3082         unsigned int shift = mc->shift;
3083         int max = mc->max;
3084         unsigned int mask = (1 << fls(max)) - 1;
3085         unsigned int invert = mc->invert;
3086         unsigned int val;
3087         int connect, change, reg_change = 0;
3088         struct snd_soc_dapm_update update;
3089         int ret = 0;
3090 
3091         if (snd_soc_volsw_is_stereo(mc))
3092                 dev_warn(dapm->dev,
3093                          "ASoC: Control '%s' is stereo, which is not supported\n",
3094                          kcontrol->id.name);
3095 
3096         val = (ucontrol->value.integer.value[0] & mask);
3097         connect = !!val;
3098 
3099         if (invert)
3100                 val = max - val;
3101 
3102         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3103 
3104         change = dapm_kcontrol_set_value(kcontrol, val);
3105 
3106         if (reg != SND_SOC_NOPM) {
3107                 mask = mask << shift;
3108                 val = val << shift;
3109 
3110                 reg_change = soc_dapm_test_bits(dapm, reg, mask, val);
3111         }
3112 
3113         if (change || reg_change) {
3114                 if (reg_change) {
3115                         update.kcontrol = kcontrol;
3116                         update.reg = reg;
3117                         update.mask = mask;
3118                         update.val = val;
3119                         card->update = &update;
3120                 }
3121                 change |= reg_change;
3122 
3123                 ret = soc_dapm_mixer_update_power(card, kcontrol, connect);
3124 
3125                 card->update = NULL;
3126         }
3127 
3128         mutex_unlock(&card->dapm_mutex);
3129 
3130         if (ret > 0)
3131                 soc_dpcm_runtime_update(card);
3132 
3133         return change;
3134 }
3135 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
3136 
3137 /**
3138  * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback
3139  * @kcontrol: mixer control
3140  * @ucontrol: control element information
3141  *
3142  * Callback to get the value of a dapm enumerated double mixer control.
3143  *
3144  * Returns 0 for success.
3145  */
3146 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
3147         struct snd_ctl_elem_value *ucontrol)
3148 {
3149         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3150         struct snd_soc_card *card = dapm->card;
3151         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3152         unsigned int reg_val, val;
3153 
3154         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3155         if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
3156                 int ret = soc_dapm_read(dapm, e->reg, &reg_val);
3157                 if (ret) {
3158                         mutex_unlock(&card->dapm_mutex);
3159                         return ret;
3160                 }
3161         } else {
3162                 reg_val = dapm_kcontrol_get_value(kcontrol);
3163         }
3164         mutex_unlock(&card->dapm_mutex);
3165 
3166         val = (reg_val >> e->shift_l) & e->mask;
3167         ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
3168         if (e->shift_l != e->shift_r) {
3169                 val = (reg_val >> e->shift_r) & e->mask;
3170                 val = snd_soc_enum_val_to_item(e, val);
3171                 ucontrol->value.enumerated.item[1] = val;
3172         }
3173 
3174         return 0;
3175 }
3176 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
3177 
3178 /**
3179  * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback
3180  * @kcontrol: mixer control
3181  * @ucontrol: control element information
3182  *
3183  * Callback to set the value of a dapm enumerated double mixer control.
3184  *
3185  * Returns 0 for success.
3186  */
3187 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
3188         struct snd_ctl_elem_value *ucontrol)
3189 {
3190         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3191         struct snd_soc_card *card = dapm->card;
3192         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3193         unsigned int *item = ucontrol->value.enumerated.item;
3194         unsigned int val, change, reg_change = 0;
3195         unsigned int mask;
3196         struct snd_soc_dapm_update update;
3197         int ret = 0;
3198 
3199         if (item[0] >= e->items)
3200                 return -EINVAL;
3201 
3202         val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
3203         mask = e->mask << e->shift_l;
3204         if (e->shift_l != e->shift_r) {
3205                 if (item[1] > e->items)
3206                         return -EINVAL;
3207                 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r;
3208                 mask |= e->mask << e->shift_r;
3209         }
3210 
3211         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3212 
3213         change = dapm_kcontrol_set_value(kcontrol, val);
3214 
3215         if (e->reg != SND_SOC_NOPM)
3216                 reg_change = soc_dapm_test_bits(dapm, e->reg, mask, val);
3217 
3218         if (change || reg_change) {
3219                 if (reg_change) {
3220                         update.kcontrol = kcontrol;
3221                         update.reg = e->reg;
3222                         update.mask = mask;
3223                         update.val = val;
3224                         card->update = &update;
3225                 }
3226                 change |= reg_change;
3227 
3228                 ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
3229 
3230                 card->update = NULL;
3231         }
3232 
3233         mutex_unlock(&card->dapm_mutex);
3234 
3235         if (ret > 0)
3236                 soc_dpcm_runtime_update(card);
3237 
3238         return change;
3239 }
3240 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
3241 
3242 /**
3243  * snd_soc_dapm_info_pin_switch - Info for a pin switch
3244  *
3245  * @kcontrol: mixer control
3246  * @uinfo: control element information
3247  *
3248  * Callback to provide information about a pin switch control.
3249  */
3250 int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
3251                                  struct snd_ctl_elem_info *uinfo)
3252 {
3253         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3254         uinfo->count = 1;
3255         uinfo->value.integer.min = 0;
3256         uinfo->value.integer.max = 1;
3257 
3258         return 0;
3259 }
3260 EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
3261 
3262 /**
3263  * snd_soc_dapm_get_pin_switch - Get information for a pin switch
3264  *
3265  * @kcontrol: mixer control
3266  * @ucontrol: Value
3267  */
3268 int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
3269                                 struct snd_ctl_elem_value *ucontrol)
3270 {
3271         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
3272         const char *pin = (const char *)kcontrol->private_value;
3273 
3274         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3275 
3276         ucontrol->value.integer.value[0] =
3277                 snd_soc_dapm_get_pin_status(&card->dapm, pin);
3278 
3279         mutex_unlock(&card->dapm_mutex);
3280 
3281         return 0;
3282 }
3283 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
3284 
3285 /**
3286  * snd_soc_dapm_put_pin_switch - Set information for a pin switch
3287  *
3288  * @kcontrol: mixer control
3289  * @ucontrol: Value
3290  */
3291 int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
3292                                 struct snd_ctl_elem_value *ucontrol)
3293 {
3294         struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
3295         const char *pin = (const char *)kcontrol->private_value;
3296 
3297         if (ucontrol->value.integer.value[0])
3298                 snd_soc_dapm_enable_pin(&card->dapm, pin);
3299         else
3300                 snd_soc_dapm_disable_pin(&card->dapm, pin);
3301 
3302         snd_soc_dapm_sync(&card->dapm);
3303         return 0;
3304 }
3305 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
3306 
3307 struct snd_soc_dapm_widget *
3308 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
3309         const struct snd_soc_dapm_widget *widget)
3310 {
3311         struct snd_soc_dapm_widget *w;
3312 
3313         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3314         w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3315         if (!w)
3316                 dev_err(dapm->dev,
3317                         "ASoC: Failed to create DAPM control %s\n",
3318                         widget->name);
3319 
3320         mutex_unlock(&dapm->card->dapm_mutex);
3321         return w;
3322 }
3323 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
3324 
3325 struct snd_soc_dapm_widget *
3326 snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
3327                          const struct snd_soc_dapm_widget *widget)
3328 {
3329         enum snd_soc_dapm_direction dir;
3330         struct snd_soc_dapm_widget *w;
3331         const char *prefix;
3332         int ret;
3333 
3334         if ((w = dapm_cnew_widget(widget)) == NULL)
3335                 return NULL;
3336 
3337         switch (w->id) {
3338         case snd_soc_dapm_regulator_supply:
3339                 w->regulator = devm_regulator_get(dapm->dev, w->name);
3340                 if (IS_ERR(w->regulator)) {
3341                         ret = PTR_ERR(w->regulator);
3342                         dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
3343                                 w->name, ret);
3344                         return NULL;
3345                 }
3346 
3347                 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
3348                         ret = regulator_allow_bypass(w->regulator, true);
3349                         if (ret != 0)
3350                                 dev_warn(w->dapm->dev,
3351                                          "ASoC: Failed to bypass %s: %d\n",
3352                                          w->name, ret);
3353                 }
3354                 break;
3355         case snd_soc_dapm_clock_supply:
3356 #ifdef CONFIG_CLKDEV_LOOKUP
3357                 w->clk = devm_clk_get(dapm->dev, w->name);
3358                 if (IS_ERR(w->clk)) {
3359                         ret = PTR_ERR(w->clk);
3360                         dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
3361                                 w->name, ret);
3362                         return NULL;
3363                 }
3364 #else
3365                 return NULL;
3366 #endif
3367                 break;
3368         default:
3369                 break;
3370         }
3371 
3372         prefix = soc_dapm_prefix(dapm);
3373         if (prefix)
3374                 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, widget->name);
3375         else
3376                 w->name = kstrdup_const(widget->name, GFP_KERNEL);
3377         if (w->name == NULL) {
3378                 kfree(w);
3379                 return NULL;
3380         }
3381 
3382         switch (w->id) {
3383         case snd_soc_dapm_mic:
3384                 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3385                 w->power_check = dapm_generic_check_power;
3386                 break;
3387         case snd_soc_dapm_input:
3388                 if (!dapm->card->fully_routed)
3389                         w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3390                 w->power_check = dapm_generic_check_power;
3391                 break;
3392         case snd_soc_dapm_spk:
3393         case snd_soc_dapm_hp:
3394                 w->is_ep = SND_SOC_DAPM_EP_SINK;
3395                 w->power_check = dapm_generic_check_power;
3396                 break;
3397         case snd_soc_dapm_output:
3398                 if (!dapm->card->fully_routed)
3399                         w->is_ep = SND_SOC_DAPM_EP_SINK;
3400                 w->power_check = dapm_generic_check_power;
3401                 break;
3402         case snd_soc_dapm_vmid:
3403         case snd_soc_dapm_siggen:
3404                 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3405                 w->power_check = dapm_always_on_check_power;
3406                 break;
3407         case snd_soc_dapm_sink:
3408                 w->is_ep = SND_SOC_DAPM_EP_SINK;
3409                 w->power_check = dapm_always_on_check_power;
3410                 break;
3411 
3412         case snd_soc_dapm_mux:
3413         case snd_soc_dapm_demux:
3414         case snd_soc_dapm_switch:
3415         case snd_soc_dapm_mixer:
3416         case snd_soc_dapm_mixer_named_ctl:
3417         case snd_soc_dapm_adc:
3418         case snd_soc_dapm_aif_out:
3419         case snd_soc_dapm_dac:
3420         case snd_soc_dapm_aif_in:
3421         case snd_soc_dapm_pga:
3422         case snd_soc_dapm_out_drv:
3423         case snd_soc_dapm_micbias:
3424         case snd_soc_dapm_line:
3425         case snd_soc_dapm_dai_link:
3426         case snd_soc_dapm_dai_out:
3427         case snd_soc_dapm_dai_in:
3428                 w->power_check = dapm_generic_check_power;
3429                 break;
3430         case snd_soc_dapm_supply:
3431         case snd_soc_dapm_regulator_supply:
3432         case snd_soc_dapm_clock_supply:
3433         case snd_soc_dapm_kcontrol:
3434                 w->is_supply = 1;
3435                 w->power_check = dapm_supply_check_power;
3436                 break;
3437         default:
3438                 w->power_check = dapm_always_on_check_power;
3439                 break;
3440         }
3441 
3442         w->dapm = dapm;
3443         INIT_LIST_HEAD(&w->list);
3444         INIT_LIST_HEAD(&w->dirty);
3445         list_add_tail(&w->list, &dapm->card->widgets);
3446 
3447         snd_soc_dapm_for_each_direction(dir) {
3448                 INIT_LIST_HEAD(&w->edges[dir]);
3449                 w->endpoints[dir] = -1;
3450         }
3451 
3452         /* machine layer set ups unconnected pins and insertions */
3453         w->connected = 1;
3454         return w;
3455 }
3456 
3457 /**
3458  * snd_soc_dapm_new_controls - create new dapm controls
3459  * @dapm: DAPM context
3460  * @widget: widget array
3461  * @num: number of widgets
3462  *
3463  * Creates new DAPM controls based upon the templates.
3464  *
3465  * Returns 0 for success else error.
3466  */
3467 int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
3468         const struct snd_soc_dapm_widget *widget,
3469         int num)
3470 {
3471         struct snd_soc_dapm_widget *w;
3472         int i;
3473         int ret = 0;
3474 
3475         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
3476         for (i = 0; i < num; i++) {
3477                 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3478                 if (!w) {
3479                         dev_err(dapm->dev,
3480                                 "ASoC: Failed to create DAPM control %s\n",
3481                                 widget->name);
3482                         ret = -ENOMEM;
3483                         break;
3484                 }
3485                 widget++;
3486         }
3487         mutex_unlock(&dapm->card->dapm_mutex);
3488         return ret;
3489 }
3490 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
3491 
3492 static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
3493                                   struct snd_kcontrol *kcontrol, int event)
3494 {
3495         struct snd_soc_dapm_path *source_p, *sink_p;
3496         struct snd_soc_dai *source, *sink;
3497         const struct snd_soc_pcm_stream *config = w->params + w->params_select;
3498         struct snd_pcm_substream substream;
3499         struct snd_pcm_hw_params *params = NULL;
3500         struct snd_pcm_runtime *runtime = NULL;
3501         u64 fmt;
3502         int ret;
3503 
3504         if (WARN_ON(!config) ||
3505             WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
3506                     list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
3507                 return -EINVAL;
3508 
3509         /* We only support a single source and sink, pick the first */
3510         source_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_OUT],
3511                                     struct snd_soc_dapm_path,
3512                                     list_node[SND_SOC_DAPM_DIR_OUT]);
3513         sink_p = list_first_entry(&w->edges[SND_SOC_DAPM_DIR_IN],
3514                                     struct snd_soc_dapm_path,
3515                                     list_node[SND_SOC_DAPM_DIR_IN]);
3516 
3517         source = source_p->source->priv;
3518         sink = sink_p->sink->priv;
3519 
3520         /* Be a little careful as we don't want to overflow the mask array */
3521         if (config->formats) {
3522                 fmt = ffs(config->formats) - 1;
3523         } else {
3524                 dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n",
3525                          config->formats);
3526                 fmt = 0;
3527         }
3528 
3529         /* Currently very limited parameter selection */
3530         params = kzalloc(sizeof(*params), GFP_KERNEL);
3531         if (!params) {
3532                 ret = -ENOMEM;
3533                 goto out;
3534         }
3535         snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
3536 
3537         hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
3538                 config->rate_min;
3539         hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
3540                 config->rate_max;
3541 
3542         hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
3543                 = config->channels_min;
3544         hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
3545                 = config->channels_max;
3546 
3547         memset(&substream, 0, sizeof(substream));
3548 
3549         /* Allocate a dummy snd_pcm_runtime for startup() and other ops() */
3550         runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
3551         if (!runtime) {
3552                 ret = -ENOMEM;
3553                 goto out;
3554         }
3555         substream.runtime = runtime;
3556 
3557         switch (event) {
3558         case SND_SOC_DAPM_PRE_PMU:
3559                 substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3560                 if (source->driver->ops && source->driver->ops->startup) {
3561                         ret = source->driver->ops->startup(&substream, source);
3562                         if (ret < 0) {
3563                                 dev_err(source->dev,
3564                                         "ASoC: startup() failed: %d\n", ret);
3565                                 goto out;
3566                         }
3567                         source->active++;
3568                 }
3569                 ret = soc_dai_hw_params(&substream, params, source);
3570                 if (ret < 0)
3571                         goto out;
3572 
3573                 substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
3574                 if (sink->driver->ops && sink->driver->ops->startup) {
3575                         ret = sink->driver->ops->startup(&substream, sink);
3576                         if (ret < 0) {
3577                                 dev_err(sink->dev,
3578                                         "ASoC: startup() failed: %d\n", ret);
3579                                 goto out;
3580                         }
3581                         sink->active++;
3582                 }
3583                 ret = soc_dai_hw_params(&substream, params, sink);
3584                 if (ret < 0)
3585                         goto out;
3586                 break;
3587 
3588         case SND_SOC_DAPM_POST_PMU:
3589                 ret = snd_soc_dai_digital_mute(sink, 0,
3590                                                SNDRV_PCM_STREAM_PLAYBACK);
3591                 if (ret != 0 && ret != -ENOTSUPP)
3592                         dev_warn(sink->dev, "ASoC: Failed to unmute: %d\n", ret);
3593                 ret = 0;
3594                 break;
3595 
3596         case SND_SOC_DAPM_PRE_PMD:
3597                 ret = snd_soc_dai_digital_mute(sink, 1,
3598                                                SNDRV_PCM_STREAM_PLAYBACK);
3599                 if (ret != 0 && ret != -ENOTSUPP)
3600                         dev_warn(sink->dev, "ASoC: Failed to mute: %d\n", ret);
3601                 ret = 0;
3602 
3603                 source->active--;
3604                 if (source->driver->ops && source->driver->ops->shutdown) {
3605                         substream.stream = SNDRV_PCM_STREAM_CAPTURE;
3606                         source->driver->ops->shutdown(&substream, source);
3607                 }
3608 
3609                 sink->active--;
3610                 if (sink->driver->ops && sink->driver->ops->shutdown) {
3611                         substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
3612                         sink->driver->ops->shutdown(&substream, sink);
3613                 }
3614                 break;
3615 
3616         default:
3617                 WARN(1, "Unknown event %d\n", event);
3618                 ret = -EINVAL;
3619         }
3620 
3621 out:
3622         kfree(runtime);
3623         kfree(params);
3624         return ret;
3625 }
3626 
3627 static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
3628                           struct snd_ctl_elem_value *ucontrol)
3629 {
3630         struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3631 
3632         ucontrol->value.enumerated.item[0] = w->params_select;
3633 
3634         return 0;
3635 }
3636 
3637 static int snd_soc_dapm_dai_link_put(struct snd_kcontrol *kcontrol,
3638                           struct snd_ctl_elem_value *ucontrol)
3639 {
3640         struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
3641 
3642         /* Can't change the config when widget is already powered */
3643         if (w->power)
3644                 return -EBUSY;
3645 
3646         if (ucontrol->value.enumerated.item[0] == w->params_select)
3647                 return 0;
3648 
3649         if (ucontrol->value.enumerated.item[0] >= w->num_params)
3650                 return -EINVAL;
3651 
3652         w->params_select = ucontrol->value.enumerated.item[0];
3653 
3654         return 0;
3655 }
3656 
3657 int snd_soc_dapm_new_pcm(struct snd_soc_card *card,
3658                          const struct snd_soc_pcm_stream *params,
3659                          unsigned int num_params,
3660                          struct snd_soc_dapm_widget *source,
3661                          struct snd_soc_dapm_widget *sink)
3662 {
3663         struct snd_soc_dapm_widget template;
3664         struct snd_soc_dapm_widget *w;
3665         char *link_name;
3666         int ret, count;
3667         unsigned long private_value;
3668         const char **w_param_text;
3669         struct soc_enum w_param_enum[] = {
3670                 SOC_ENUM_SINGLE(0, 0, 0, NULL),
3671         };
3672         struct snd_kcontrol_new kcontrol_dai_link[] = {
3673                 SOC_ENUM_EXT(NULL, w_param_enum[0],
3674                              snd_soc_dapm_dai_link_get,
3675                              snd_soc_dapm_dai_link_put),
3676         };
3677         const struct snd_soc_pcm_stream *config = params;
3678 
3679         w_param_text = devm_kcalloc(card->dev, num_params,
3680                                         sizeof(char *), GFP_KERNEL);
3681         if (!w_param_text)
3682                 return -ENOMEM;
3683 
3684         link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
3685                                    source->name, sink->name);
3686         if (!link_name) {
3687                 ret = -ENOMEM;
3688                 goto outfree_w_param;
3689         }
3690 
3691         for (count = 0 ; count < num_params; count++) {
3692                 if (!config->stream_name) {
3693                         dev_warn(card->dapm.dev,
3694                                 "ASoC: anonymous config %d for dai link %s\n",
3695                                 count, link_name);
3696                         w_param_text[count] =
3697                                 devm_kasprintf(card->dev, GFP_KERNEL,
3698                                                "Anonymous Configuration %d",
3699                                                count);
3700                         if (!w_param_text[count]) {
3701                                 ret = -ENOMEM;
3702                                 goto outfree_link_name;
3703                         }
3704                 } else {
3705                         w_param_text[count] = devm_kmemdup(card->dev,
3706                                                 config->stream_name,
3707                                                 strlen(config->stream_name) + 1,
3708                                                 GFP_KERNEL);
3709                         if (!w_param_text[count]) {
3710                                 ret = -ENOMEM;
3711                                 goto outfree_link_name;
3712                         }
3713                 }
3714                 config++;
3715         }
3716         w_param_enum[0].items = num_params;
3717         w_param_enum[0].texts = w_param_text;
3718 
3719         memset(&template, 0, sizeof(template));
3720         template.reg = SND_SOC_NOPM;
3721         template.id = snd_soc_dapm_dai_link;
3722         template.name = link_name;
3723         template.event = snd_soc_dai_link_event;
3724         template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
3725                 SND_SOC_DAPM_PRE_PMD;
3726         template.num_kcontrols = 1;
3727         /* duplicate w_param_enum on heap so that memory persists */
3728         private_value =
3729                 (unsigned long) devm_kmemdup(card->dev,
3730                         (void *)(kcontrol_dai_link[0].private_value),
3731                         sizeof(struct soc_enum), GFP_KERNEL);
3732         if (!private_value) {
3733                 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3734                         link_name);
3735                 ret = -ENOMEM;
3736                 goto outfree_link_name;
3737         }
3738         kcontrol_dai_link[0].private_value = private_value;
3739         /* duplicate kcontrol_dai_link on heap so that memory persists */
3740         template.kcontrol_news =
3741                                 devm_kmemdup(card->dev, &kcontrol_dai_link[0],
3742                                         sizeof(struct snd_kcontrol_new),
3743                                         GFP_KERNEL);
3744         if (!template.kcontrol_news) {
3745                 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
3746                         link_name);
3747                 ret = -ENOMEM;
3748                 goto outfree_private_value;
3749         }
3750 
3751         dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
3752 
3753         w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
3754         if (!w) {
3755                 dev_err(card->dev, "ASoC: Failed to create %s widget\n",
3756                         link_name);
3757                 ret = -ENOMEM;
3758                 goto outfree_kcontrol_news;
3759         }
3760 
3761         w->params = params;
3762         w->num_params = num_params;
3763 
3764         ret = snd_soc_dapm_add_path(&card->dapm, source, w, NULL, NULL);
3765         if (ret)
3766                 goto outfree_w;
3767         return snd_soc_dapm_add_path(&card->dapm, w, sink, NULL, NULL);
3768 
3769 outfree_w:
3770         devm_kfree(card->dev, w);
3771 outfree_kcontrol_news:
3772         devm_kfree(card->dev, (void *)template.kcontrol_news);
3773 outfree_private_value:
3774         devm_kfree(card->dev, (void *)private_value);
3775 outfree_link_name:
3776         devm_kfree(card->dev, link_name);
3777 outfree_w_param:
3778         for (count = 0 ; count < num_params; count++)
3779                 devm_kfree(card->dev, (void *)w_param_text[count]);
3780         devm_kfree(card->dev, w_param_text);
3781 
3782         return ret;
3783 }
3784 
3785 int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
3786                                  struct snd_soc_dai *dai)
3787 {
3788         struct snd_soc_dapm_widget template;
3789         struct snd_soc_dapm_widget *w;
3790 
3791         WARN_ON(dapm->dev != dai->dev);
3792 
3793         memset(&template, 0, sizeof(template));
3794         template.reg = SND_SOC_NOPM;
3795 
3796         if (dai->driver->playback.stream_name) {
3797                 template.id = snd_soc_dapm_dai_in;
3798                 template.name = dai->driver->playback.stream_name;
3799                 template.sname = dai->driver->playback.stream_name;
3800 
3801                 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
3802                         template.name);
3803 
3804                 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
3805                 if (!w) {
3806                         dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
3807                                 dai->driver->playback.stream_name);
3808                         return -ENOMEM;
3809                 }
3810 
3811                 w->priv = dai;
3812                 dai->playback_widget = w;
3813         }
3814 
3815         if (dai->driver->capture.stream_name) {
3816                 template.id = snd_soc_dapm_dai_out;
3817                 template.name = dai->driver->capture.stream_name;
3818                 template.sname = dai->driver->capture.stream_name;
3819 
3820                 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
3821                         template.name);
3822 
3823                 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
3824                 if (!w) {
3825                         dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
3826                                 dai->driver->capture.stream_name);
3827                         return -ENOMEM;
3828                 }
3829 
3830                 w->priv = dai;
3831                 dai->capture_widget = w;
3832         }
3833 
3834         return 0;
3835 }
3836 
3837 int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
3838 {
3839         struct snd_soc_dapm_widget *dai_w, *w;
3840         struct snd_soc_dapm_widget *src, *sink;
3841         struct snd_soc_dai *dai;
3842 
3843         /* For each DAI widget... */
3844         list_for_each_entry(dai_w, &card->widgets, list) {
3845                 switch (dai_w->id) {
3846                 case snd_soc_dapm_dai_in:
3847                 case snd_soc_dapm_dai_out:
3848                         break;
3849                 default:
3850                         continue;
3851                 }
3852 
3853                 dai = dai_w->priv;
3854 
3855                 /* ...find all widgets with the same stream and link them */
3856                 list_for_each_entry(w, &card->widgets, list) {
3857                         if (w->dapm != dai_w->dapm)
3858                                 continue;
3859 
3860                         switch (w->id) {
3861                         case snd_soc_dapm_dai_in:
3862                         case snd_soc_dapm_dai_out:
3863                                 continue;
3864                         default:
3865                                 break;
3866                         }
3867 
3868                         if (!w->sname || !strstr(w->sname, dai_w->sname))
3869                                 continue;
3870 
3871                         if (dai_w->id == snd_soc_dapm_dai_in) {
3872                                 src = dai_w;
3873                                 sink = w;
3874                         } else {
3875                                 src = w;
3876                                 sink = dai_w;
3877                         }
3878                         dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
3879                         snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
3880                 }
3881         }
3882 
3883         return 0;
3884 }
3885 
3886 static void dapm_connect_dai_link_widgets(struct snd_soc_card *card,
3887                                           struct snd_soc_pcm_runtime *rtd)
3888 {
3889         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
3890         struct snd_soc_dapm_widget *sink, *source;
3891         int i;
3892 
3893         for (i = 0; i < rtd->num_codecs; i++) {
3894                 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
3895 
3896                 /* connect BE DAI playback if widgets are valid */
3897                 if (codec_dai->playback_widget && cpu_dai->playback_widget) {
3898                         source = cpu_dai->playback_widget;
3899                         sink = codec_dai->playback_widget;
3900                         dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
3901                                 cpu_dai->component->name, source->name,
3902                                 codec_dai->component->name, sink->name);
3903 
3904                         snd_soc_dapm_add_path(&card->dapm, source, sink,
3905                                 NULL, NULL);
3906                 }
3907 
3908                 /* connect BE DAI capture if widgets are valid */
3909                 if (codec_dai->capture_widget && cpu_dai->capture_widget) {
3910                         source = codec_dai->capture_widget;
3911                         sink = cpu_dai->capture_widget;
3912                         dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n",
3913                                 codec_dai->component->name, source->name,
3914                                 cpu_dai->component->name, sink->name);
3915 
3916                         snd_soc_dapm_add_path(&card->dapm, source, sink,
3917                                 NULL, NULL);
3918                 }
3919         }
3920 }
3921 
3922 static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
3923         int event)
3924 {
3925         struct snd_soc_dapm_widget *w;
3926         unsigned int ep;
3927 
3928         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
3929                 w = dai->playback_widget;
3930         else
3931                 w = dai->capture_widget;
3932 
3933         if (w) {
3934                 dapm_mark_dirty(w, "stream event");
3935 
3936                 if (w->id == snd_soc_dapm_dai_in) {
3937                         ep = SND_SOC_DAPM_EP_SOURCE;
3938                         dapm_widget_invalidate_input_paths(w);
3939                 } else {
3940                         ep = SND_SOC_DAPM_EP_SINK;
3941                         dapm_widget_invalidate_output_paths(w);
3942                 }
3943 
3944                 switch (event) {
3945                 case SND_SOC_DAPM_STREAM_START:
3946                         w->active = 1;
3947                         w->is_ep = ep;
3948                         break;
3949                 case SND_SOC_DAPM_STREAM_STOP:
3950                         w->active = 0;
3951                         w->is_ep = 0;
3952                         break;
3953                 case SND_SOC_DAPM_STREAM_SUSPEND:
3954                 case SND_SOC_DAPM_STREAM_RESUME:
3955                 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
3956                 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
3957                         break;
3958                 }
3959         }
3960 }
3961 
3962 void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
3963 {
3964         struct snd_soc_pcm_runtime *rtd;
3965 
3966         /* for each BE DAI link... */
3967         list_for_each_entry(rtd, &card->rtd_list, list)  {
3968                 /*
3969                  * dynamic FE links have no fixed DAI mapping.
3970                  * CODEC<->CODEC links have no direct connection.
3971                  */
3972                 if (rtd->dai_link->dynamic || rtd->dai_link->params)
3973                         continue;
3974 
3975                 dapm_connect_dai_link_widgets(card, rtd);
3976         }
3977 }
3978 
3979 static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
3980         int event)
3981 {
3982         int i;
3983 
3984         soc_dapm_dai_stream_event(rtd->cpu_dai, stream, event);
3985         for (i = 0; i < rtd->num_codecs; i++)
3986                 soc_dapm_dai_stream_event(rtd->codec_dais[i], stream, event);
3987 
3988         dapm_power_widgets(rtd->card, event);
3989 }
3990 
3991 /**
3992  * snd_soc_dapm_stream_event - send a stream event to the dapm core
3993  * @rtd: PCM runtime data
3994  * @stream: stream name
3995  * @event: stream event
3996  *
3997  * Sends a stream event to the dapm core. The core then makes any
3998  * necessary widget power changes.
3999  *
4000  * Returns 0 for success else error.
4001  */
4002 void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
4003                               int event)
4004 {
4005         struct snd_soc_card *card = rtd->card;
4006 
4007         mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4008         soc_dapm_stream_event(rtd, stream, event);
4009         mutex_unlock(&card->dapm_mutex);
4010 }
4011 
4012 /**
4013  * snd_soc_dapm_enable_pin_unlocked - enable pin.
4014  * @dapm: DAPM context
4015  * @pin: pin name
4016  *
4017  * Enables input/output pin and its parents or children widgets iff there is
4018  * a valid audio route and active audio stream.
4019  *
4020  * Requires external locking.
4021  *
4022  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4023  * do any widget power switching.
4024  */
4025 int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4026                                    const char *pin)
4027 {
4028         return snd_soc_dapm_set_pin(dapm, pin, 1);
4029 }
4030 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
4031 
4032 /**
4033  * snd_soc_dapm_enable_pin - enable pin.
4034  * @dapm: DAPM context
4035  * @pin: pin name
4036  *
4037  * Enables input/output pin and its parents or children widgets iff there is
4038  * a valid audio route and active audio stream.
4039  *
4040  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4041  * do any widget power switching.
4042  */
4043 int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
4044 {
4045         int ret;
4046 
4047         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4048 
4049         ret = snd_soc_dapm_set_pin(dapm, pin, 1);
4050 
4051         mutex_unlock(&dapm->card->dapm_mutex);
4052 
4053         return ret;
4054 }
4055 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
4056 
4057 /**
4058  * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled
4059  * @dapm: DAPM context
4060  * @pin: pin name
4061  *
4062  * Enables input/output pin regardless of any other state.  This is
4063  * intended for use with microphone bias supplies used in microphone
4064  * jack detection.
4065  *
4066  * Requires external locking.
4067  *
4068  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4069  * do any widget power switching.
4070  */
4071 int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4072                                          const char *pin)
4073 {
4074         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4075 
4076         if (!w) {
4077                 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4078                 return -EINVAL;
4079         }
4080 
4081         dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
4082         if (!w->connected) {
4083                 /*
4084                  * w->force does not affect the number of input or output paths,
4085                  * so we only have to recheck if w->connected is changed
4086                  */
4087                 dapm_widget_invalidate_input_paths(w);
4088                 dapm_widget_invalidate_output_paths(w);
4089                 w->connected = 1;
4090         }
4091         w->force = 1;
4092         dapm_mark_dirty(w, "force enable");
4093 
4094         return 0;
4095 }
4096 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
4097 
4098 /**
4099  * snd_soc_dapm_force_enable_pin - force a pin to be enabled
4100  * @dapm: DAPM context
4101  * @pin: pin name
4102  *
4103  * Enables input/output pin regardless of any other state.  This is
4104  * intended for use with microphone bias supplies used in microphone
4105  * jack detection.
4106  *
4107  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4108  * do any widget power switching.
4109  */
4110 int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
4111                                   const char *pin)
4112 {
4113         int ret;
4114 
4115         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4116 
4117         ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
4118 
4119         mutex_unlock(&dapm->card->dapm_mutex);
4120 
4121         return ret;
4122 }
4123 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
4124 
4125 /**
4126  * snd_soc_dapm_disable_pin_unlocked - disable pin.
4127  * @dapm: DAPM context
4128  * @pin: pin name
4129  *
4130  * Disables input/output pin and its parents or children widgets.
4131  *
4132  * Requires external locking.
4133  *
4134  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4135  * do any widget power switching.
4136  */
4137 int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4138                                     const char *pin)
4139 {
4140         return snd_soc_dapm_set_pin(dapm, pin, 0);
4141 }
4142 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
4143 
4144 /**
4145  * snd_soc_dapm_disable_pin - disable pin.
4146  * @dapm: DAPM context
4147  * @pin: pin name
4148  *
4149  * Disables input/output pin and its parents or children widgets.
4150  *
4151  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4152  * do any widget power switching.
4153  */
4154 int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
4155                              const char *pin)
4156 {
4157         int ret;
4158 
4159         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4160 
4161         ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4162 
4163         mutex_unlock(&dapm->card->dapm_mutex);
4164 
4165         return ret;
4166 }
4167 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
4168 
4169 /**
4170  * snd_soc_dapm_nc_pin_unlocked - permanently disable pin.
4171  * @dapm: DAPM context
4172  * @pin: pin name
4173  *
4174  * Marks the specified pin as being not connected, disabling it along
4175  * any parent or child widgets.  At present this is identical to
4176  * snd_soc_dapm_disable_pin() but in future it will be extended to do
4177  * additional things such as disabling controls which only affect
4178  * paths through the pin.
4179  *
4180  * Requires external locking.
4181  *
4182  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4183  * do any widget power switching.
4184  */
4185 int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
4186                                const char *pin)
4187 {
4188         return snd_soc_dapm_set_pin(dapm, pin, 0);
4189 }
4190 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
4191 
4192 /**
4193  * snd_soc_dapm_nc_pin - permanently disable pin.
4194  * @dapm: DAPM context
4195  * @pin: pin name
4196  *
4197  * Marks the specified pin as being not connected, disabling it along
4198  * any parent or child widgets.  At present this is identical to
4199  * snd_soc_dapm_disable_pin() but in future it will be extended to do
4200  * additional things such as disabling controls which only affect
4201  * paths through the pin.
4202  *
4203  * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
4204  * do any widget power switching.
4205  */
4206 int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
4207 {
4208         int ret;
4209 
4210         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4211 
4212         ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4213 
4214         mutex_unlock(&dapm->card->dapm_mutex);
4215 
4216         return ret;
4217 }
4218 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
4219 
4220 /**
4221  * snd_soc_dapm_get_pin_status - get audio pin status
4222  * @dapm: DAPM context
4223  * @pin: audio signal pin endpoint (or start point)
4224  *
4225  * Get audio pin status - connected or disconnected.
4226  *
4227  * Returns 1 for connected otherwise 0.
4228  */
4229 int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
4230                                 const char *pin)
4231 {
4232         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4233 
4234         if (w)
4235                 return w->connected;
4236 
4237         return 0;
4238 }
4239 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
4240 
4241 /**
4242  * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
4243  * @dapm: DAPM context
4244  * @pin: audio signal pin endpoint (or start point)
4245  *
4246  * Mark the given endpoint or pin as ignoring suspend.  When the
4247  * system is disabled a path between two endpoints flagged as ignoring
4248  * suspend will not be disabled.  The path must already be enabled via
4249  * normal means at suspend time, it will not be turned on if it was not
4250  * already enabled.
4251  */
4252 int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
4253                                 const char *pin)
4254 {
4255         struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
4256 
4257         if (!w) {
4258                 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4259                 return -EINVAL;
4260         }
4261 
4262         w->ignore_suspend = 1;
4263 
4264         return 0;
4265 }
4266 EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
4267 
4268 /**
4269  * snd_soc_dapm_free - free dapm resources
4270  * @dapm: DAPM context
4271  *
4272  * Free all dapm widgets and resources.
4273  */
4274 void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
4275 {
4276         dapm_debugfs_cleanup(dapm);
4277         dapm_free_widgets(dapm);
4278         list_del(&dapm->list);
4279 }
4280 EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
4281 
4282 static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
4283 {
4284         struct snd_soc_card *card = dapm->card;
4285         struct snd_soc_dapm_widget *w;
4286         LIST_HEAD(down_list);
4287         int powerdown = 0;
4288 
4289         mutex_lock(&card->dapm_mutex);
4290 
4291         list_for_each_entry(w, &dapm->card->widgets, list) {
4292                 if (w->dapm != dapm)
4293                         continue;
4294                 if (w->power) {
4295                         dapm_seq_insert(w, &down_list, false);
4296                         w->power = 0;
4297                         powerdown = 1;
4298                 }
4299         }
4300 
4301         /* If there were no widgets to power down we're already in
4302          * standby.
4303          */
4304         if (powerdown) {
4305                 if (dapm->bias_level == SND_SOC_BIAS_ON)
4306                         snd_soc_dapm_set_bias_level(dapm,
4307                                                     SND_SOC_BIAS_PREPARE);
4308                 dapm_seq_run(card, &down_list, 0, false);
4309                 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
4310                         snd_soc_dapm_set_bias_level(dapm,
4311                                                     SND_SOC_BIAS_STANDBY);
4312         }
4313 
4314         mutex_unlock(&card->dapm_mutex);
4315 }
4316 
4317 /*
4318  * snd_soc_dapm_shutdown - callback for system shutdown
4319  */
4320 void snd_soc_dapm_shutdown(struct snd_soc_card *card)
4321 {
4322         struct snd_soc_dapm_context *dapm;
4323 
4324         list_for_each_entry(dapm, &card->dapm_list, list) {
4325                 if (dapm != &card->dapm) {
4326                         soc_dapm_shutdown_dapm(dapm);
4327                         if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
4328                                 snd_soc_dapm_set_bias_level(dapm,
4329                                                             SND_SOC_BIAS_OFF);
4330                 }
4331         }
4332 
4333         soc_dapm_shutdown_dapm(&card->dapm);
4334         if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
4335                 snd_soc_dapm_set_bias_level(&card->dapm,
4336                                             SND_SOC_BIAS_OFF);
4337 }
4338 
4339 /* Module information */
4340 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
4341 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
4342 MODULE_LICENSE("GPL");
4343 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp