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

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

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

~ [ 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