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

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

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

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