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