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 struct list_head *wlist;
654 const int depth = 2;
655 int i = 0;
656
657 if (w) {
658 wlist = &w->dapm->card->widgets;
659
660 list_for_each_entry_from(w, wlist, list) {
661 if (!strcmp(name, w->name))
662 return w;
663
664 if (++i == depth)
665 break;
666 }
667 }
668
669 return NULL;
670}
671
672static inline void dapm_wcache_update(struct snd_soc_dapm_wcache *wcache,
673 struct snd_soc_dapm_widget *w)
674{
675 wcache->widget = w;
676}
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695int snd_soc_dapm_force_bias_level(struct snd_soc_dapm_context *dapm,
696 enum snd_soc_bias_level level)
697{
698 int ret = 0;
699
700 if (dapm->component)
701 ret = snd_soc_component_set_bias_level(dapm->component, level);
702
703 if (ret == 0)
704 dapm->bias_level = level;
705
706 return ret;
707}
708EXPORT_SYMBOL_GPL(snd_soc_dapm_force_bias_level);
709
710
711
712
713
714
715
716
717
718
719static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm,
720 enum snd_soc_bias_level level)
721{
722 struct snd_soc_card *card = dapm->card;
723 int ret = 0;
724
725 trace_snd_soc_bias_level_start(card, level);
726
727 ret = snd_soc_card_set_bias_level(card, dapm, level);
728 if (ret != 0)
729 goto out;
730
731 if (!card || dapm != &card->dapm)
732 ret = snd_soc_dapm_force_bias_level(dapm, level);
733
734 if (ret != 0)
735 goto out;
736
737 ret = snd_soc_card_set_bias_level_post(card, dapm, level);
738out:
739 trace_snd_soc_bias_level_done(card, level);
740
741 return ret;
742}
743
744
745static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
746 struct snd_soc_dapm_path *path, const char *control_name,
747 struct snd_soc_dapm_widget *w)
748{
749 const struct snd_kcontrol_new *kcontrol = &w->kcontrol_news[0];
750 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
751 unsigned int val, item;
752 int i;
753
754 if (e->reg != SND_SOC_NOPM) {
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 shift = mc->shift;
786 unsigned int max = mc->max;
787 unsigned int mask = (1 << fls(max)) - 1;
788 unsigned int invert = mc->invert;
789 unsigned int val;
790
791 if (reg != SND_SOC_NOPM) {
792 val = soc_dapm_read(p->sink->dapm, reg);
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, ret;
1064
1065 for (i = 0; i < w->num_kcontrols; i++) {
1066 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, ret;
1078 struct snd_kcontrol *kcontrol;
1079 struct snd_soc_dapm_context *dapm = w->dapm;
1080 struct snd_card *card = dapm->card->snd_card;
1081 struct snd_soc_pcm_runtime *rtd = w->priv;
1082
1083
1084 if (rtd->dai_link->num_params <= 1)
1085 return 0;
1086
1087
1088 for (i = 0; i < w->num_kcontrols; i++) {
1089 kcontrol = snd_soc_cnew(&w->kcontrol_news[i], w,
1090 w->name, NULL);
1091 ret = snd_ctl_add(card, kcontrol);
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}
1334
1335void snd_soc_dapm_dai_free_widgets(struct snd_soc_dapm_widget_list **list)
1336{
1337 dapm_widget_list_free(list);
1338}
1339
1340
1341
1342
1343int dapm_regulator_event(struct snd_soc_dapm_widget *w,
1344 struct snd_kcontrol *kcontrol, int event)
1345{
1346 int ret;
1347
1348 soc_dapm_async_complete(w->dapm);
1349
1350 if (SND_SOC_DAPM_EVENT_ON(event)) {
1351 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1352 ret = regulator_allow_bypass(w->regulator, false);
1353 if (ret != 0)
1354 dev_warn(w->dapm->dev,
1355 "ASoC: Failed to unbypass %s: %d\n",
1356 w->name, ret);
1357 }
1358
1359 return regulator_enable(w->regulator);
1360 } else {
1361 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
1362 ret = regulator_allow_bypass(w->regulator, true);
1363 if (ret != 0)
1364 dev_warn(w->dapm->dev,
1365 "ASoC: Failed to bypass %s: %d\n",
1366 w->name, ret);
1367 }
1368
1369 return regulator_disable_deferred(w->regulator, w->shift);
1370 }
1371}
1372EXPORT_SYMBOL_GPL(dapm_regulator_event);
1373
1374
1375
1376
1377int dapm_pinctrl_event(struct snd_soc_dapm_widget *w,
1378 struct snd_kcontrol *kcontrol, int event)
1379{
1380 struct snd_soc_dapm_pinctrl_priv *priv = w->priv;
1381 struct pinctrl *p = w->pinctrl;
1382 struct pinctrl_state *s;
1383
1384 if (!p || !priv)
1385 return -EIO;
1386
1387 if (SND_SOC_DAPM_EVENT_ON(event))
1388 s = pinctrl_lookup_state(p, priv->active_state);
1389 else
1390 s = pinctrl_lookup_state(p, priv->sleep_state);
1391
1392 if (IS_ERR(s))
1393 return PTR_ERR(s);
1394
1395 return pinctrl_select_state(p, s);
1396}
1397EXPORT_SYMBOL_GPL(dapm_pinctrl_event);
1398
1399
1400
1401
1402int dapm_clock_event(struct snd_soc_dapm_widget *w,
1403 struct snd_kcontrol *kcontrol, int event)
1404{
1405 if (!w->clk)
1406 return -EIO;
1407
1408 soc_dapm_async_complete(w->dapm);
1409
1410 if (SND_SOC_DAPM_EVENT_ON(event)) {
1411 return clk_prepare_enable(w->clk);
1412 } else {
1413 clk_disable_unprepare(w->clk);
1414 return 0;
1415 }
1416
1417 return 0;
1418}
1419EXPORT_SYMBOL_GPL(dapm_clock_event);
1420
1421static int dapm_widget_power_check(struct snd_soc_dapm_widget *w)
1422{
1423 if (w->power_checked)
1424 return w->new_power;
1425
1426 if (w->force)
1427 w->new_power = 1;
1428 else
1429 w->new_power = w->power_check(w);
1430
1431 w->power_checked = true;
1432
1433 return w->new_power;
1434}
1435
1436
1437static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
1438{
1439 int in, out;
1440
1441 DAPM_UPDATE_STAT(w, power_checks);
1442
1443 in = is_connected_input_ep(w, NULL, NULL);
1444 out = is_connected_output_ep(w, NULL, NULL);
1445 return out != 0 && in != 0;
1446}
1447
1448
1449static int dapm_supply_check_power(struct snd_soc_dapm_widget *w)
1450{
1451 struct snd_soc_dapm_path *path;
1452
1453 DAPM_UPDATE_STAT(w, power_checks);
1454
1455
1456 snd_soc_dapm_widget_for_each_sink_path(w, path) {
1457 DAPM_UPDATE_STAT(w, neighbour_checks);
1458
1459 if (path->weak)
1460 continue;
1461
1462 if (path->connected &&
1463 !path->connected(path->source, path->sink))
1464 continue;
1465
1466 if (dapm_widget_power_check(path->sink))
1467 return 1;
1468 }
1469
1470 return 0;
1471}
1472
1473static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w)
1474{
1475 return w->connected;
1476}
1477
1478static int dapm_seq_compare(struct snd_soc_dapm_widget *a,
1479 struct snd_soc_dapm_widget *b,
1480 bool power_up)
1481{
1482 int *sort;
1483
1484 BUILD_BUG_ON(ARRAY_SIZE(dapm_up_seq) != SND_SOC_DAPM_TYPE_COUNT);
1485 BUILD_BUG_ON(ARRAY_SIZE(dapm_down_seq) != SND_SOC_DAPM_TYPE_COUNT);
1486
1487 if (power_up)
1488 sort = dapm_up_seq;
1489 else
1490 sort = dapm_down_seq;
1491
1492 WARN_ONCE(sort[a->id] == 0, "offset a->id %d not initialized\n", a->id);
1493 WARN_ONCE(sort[b->id] == 0, "offset b->id %d not initialized\n", b->id);
1494
1495 if (sort[a->id] != sort[b->id])
1496 return sort[a->id] - sort[b->id];
1497 if (a->subseq != b->subseq) {
1498 if (power_up)
1499 return a->subseq - b->subseq;
1500 else
1501 return b->subseq - a->subseq;
1502 }
1503 if (a->reg != b->reg)
1504 return a->reg - b->reg;
1505 if (a->dapm != b->dapm)
1506 return (unsigned long)a->dapm - (unsigned long)b->dapm;
1507
1508 return 0;
1509}
1510
1511
1512static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
1513 struct list_head *list,
1514 bool power_up)
1515{
1516 struct snd_soc_dapm_widget *w;
1517
1518 list_for_each_entry(w, list, power_list)
1519 if (dapm_seq_compare(new_widget, w, power_up) < 0) {
1520 list_add_tail(&new_widget->power_list, &w->power_list);
1521 return;
1522 }
1523
1524 list_add_tail(&new_widget->power_list, list);
1525}
1526
1527static void dapm_seq_check_event(struct snd_soc_card *card,
1528 struct snd_soc_dapm_widget *w, int event)
1529{
1530 const char *ev_name;
1531 int power, ret;
1532
1533 switch (event) {
1534 case SND_SOC_DAPM_PRE_PMU:
1535 ev_name = "PRE_PMU";
1536 power = 1;
1537 break;
1538 case SND_SOC_DAPM_POST_PMU:
1539 ev_name = "POST_PMU";
1540 power = 1;
1541 break;
1542 case SND_SOC_DAPM_PRE_PMD:
1543 ev_name = "PRE_PMD";
1544 power = 0;
1545 break;
1546 case SND_SOC_DAPM_POST_PMD:
1547 ev_name = "POST_PMD";
1548 power = 0;
1549 break;
1550 case SND_SOC_DAPM_WILL_PMU:
1551 ev_name = "WILL_PMU";
1552 power = 1;
1553 break;
1554 case SND_SOC_DAPM_WILL_PMD:
1555 ev_name = "WILL_PMD";
1556 power = 0;
1557 break;
1558 default:
1559 WARN(1, "Unknown event %d\n", event);
1560 return;
1561 }
1562
1563 if (w->new_power != power)
1564 return;
1565
1566 if (w->event && (w->event_flags & event)) {
1567 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n",
1568 w->name, ev_name);
1569 soc_dapm_async_complete(w->dapm);
1570 trace_snd_soc_dapm_widget_event_start(w, event);
1571 ret = w->event(w, NULL, event);
1572 trace_snd_soc_dapm_widget_event_done(w, event);
1573 if (ret < 0)
1574 dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n",
1575 ev_name, w->name, ret);
1576 }
1577}
1578
1579
1580static void dapm_seq_run_coalesced(struct snd_soc_card *card,
1581 struct list_head *pending)
1582{
1583 struct snd_soc_dapm_context *dapm;
1584 struct snd_soc_dapm_widget *w;
1585 int reg;
1586 unsigned int value = 0;
1587 unsigned int mask = 0;
1588
1589 w = list_first_entry(pending, struct snd_soc_dapm_widget, power_list);
1590 reg = w->reg;
1591 dapm = w->dapm;
1592
1593 list_for_each_entry(w, pending, power_list) {
1594 WARN_ON(reg != w->reg || dapm != w->dapm);
1595 w->power = w->new_power;
1596
1597 mask |= w->mask << w->shift;
1598 if (w->power)
1599 value |= w->on_val << w->shift;
1600 else
1601 value |= w->off_val << w->shift;
1602
1603 pop_dbg(dapm->dev, card->pop_time,
1604 "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
1605 w->name, reg, value, mask);
1606
1607
1608 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU);
1609 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD);
1610 }
1611
1612 if (reg >= 0) {
1613
1614
1615
1616
1617 pop_dbg(dapm->dev, card->pop_time,
1618 "pop test : Applying 0x%x/0x%x to %x in %dms\n",
1619 value, mask, reg, card->pop_time);
1620 pop_wait(card->pop_time);
1621 soc_dapm_update_bits(dapm, reg, mask, value);
1622 }
1623
1624 list_for_each_entry(w, pending, power_list) {
1625 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU);
1626 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD);
1627 }
1628}
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638static void dapm_seq_run(struct snd_soc_card *card,
1639 struct list_head *list, int event, bool power_up)
1640{
1641 struct snd_soc_dapm_widget *w, *n;
1642 struct snd_soc_dapm_context *d;
1643 LIST_HEAD(pending);
1644 int cur_sort = -1;
1645 int cur_subseq = -1;
1646 int cur_reg = SND_SOC_NOPM;
1647 struct snd_soc_dapm_context *cur_dapm = NULL;
1648 int ret, i;
1649 int *sort;
1650
1651 if (power_up)
1652 sort = dapm_up_seq;
1653 else
1654 sort = dapm_down_seq;
1655
1656 list_for_each_entry_safe(w, n, list, power_list) {
1657 ret = 0;
1658
1659
1660 if (sort[w->id] != cur_sort || w->reg != cur_reg ||
1661 w->dapm != cur_dapm || w->subseq != cur_subseq) {
1662 if (!list_empty(&pending))
1663 dapm_seq_run_coalesced(card, &pending);
1664
1665 if (cur_dapm && cur_dapm->component) {
1666 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1667 if (sort[i] == cur_sort)
1668 snd_soc_component_seq_notifier(
1669 cur_dapm->component,
1670 i, cur_subseq);
1671 }
1672
1673 if (cur_dapm && w->dapm != cur_dapm)
1674 soc_dapm_async_complete(cur_dapm);
1675
1676 INIT_LIST_HEAD(&pending);
1677 cur_sort = -1;
1678 cur_subseq = INT_MIN;
1679 cur_reg = SND_SOC_NOPM;
1680 cur_dapm = NULL;
1681 }
1682
1683 switch (w->id) {
1684 case snd_soc_dapm_pre:
1685 if (!w->event)
1686 list_for_each_entry_safe_continue(w, n, list,
1687 power_list);
1688
1689 if (event == SND_SOC_DAPM_STREAM_START)
1690 ret = w->event(w,
1691 NULL, SND_SOC_DAPM_PRE_PMU);
1692 else if (event == SND_SOC_DAPM_STREAM_STOP)
1693 ret = w->event(w,
1694 NULL, SND_SOC_DAPM_PRE_PMD);
1695 break;
1696
1697 case snd_soc_dapm_post:
1698 if (!w->event)
1699 list_for_each_entry_safe_continue(w, n, list,
1700 power_list);
1701
1702 if (event == SND_SOC_DAPM_STREAM_START)
1703 ret = w->event(w,
1704 NULL, SND_SOC_DAPM_POST_PMU);
1705 else if (event == SND_SOC_DAPM_STREAM_STOP)
1706 ret = w->event(w,
1707 NULL, SND_SOC_DAPM_POST_PMD);
1708 break;
1709
1710 default:
1711
1712 cur_sort = sort[w->id];
1713 cur_subseq = w->subseq;
1714 cur_reg = w->reg;
1715 cur_dapm = w->dapm;
1716 list_move(&w->power_list, &pending);
1717 break;
1718 }
1719
1720 if (ret < 0)
1721 dev_err(w->dapm->dev,
1722 "ASoC: Failed to apply widget power: %d\n", ret);
1723 }
1724
1725 if (!list_empty(&pending))
1726 dapm_seq_run_coalesced(card, &pending);
1727
1728 if (cur_dapm && cur_dapm->component) {
1729 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
1730 if (sort[i] == cur_sort)
1731 snd_soc_component_seq_notifier(
1732 cur_dapm->component,
1733 i, cur_subseq);
1734 }
1735
1736 for_each_card_dapms(card, d)
1737 soc_dapm_async_complete(d);
1738}
1739
1740static void dapm_widget_update(struct snd_soc_card *card)
1741{
1742 struct snd_soc_dapm_update *update = card->update;
1743 struct snd_soc_dapm_widget_list *wlist;
1744 struct snd_soc_dapm_widget *w = NULL;
1745 unsigned int wi;
1746 int ret;
1747
1748 if (!update || !dapm_kcontrol_is_powered(update->kcontrol))
1749 return;
1750
1751 wlist = dapm_kcontrol_get_wlist(update->kcontrol);
1752
1753 for_each_dapm_widgets(wlist, wi, w) {
1754 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
1755 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
1756 if (ret != 0)
1757 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
1758 w->name, ret);
1759 }
1760 }
1761
1762 if (!w)
1763 return;
1764
1765 ret = soc_dapm_update_bits(w->dapm, update->reg, update->mask,
1766 update->val);
1767 if (ret < 0)
1768 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n",
1769 w->name, ret);
1770
1771 if (update->has_second_set) {
1772 ret = soc_dapm_update_bits(w->dapm, update->reg2,
1773 update->mask2, update->val2);
1774 if (ret < 0)
1775 dev_err(w->dapm->dev,
1776 "ASoC: %s DAPM update failed: %d\n",
1777 w->name, ret);
1778 }
1779
1780 for_each_dapm_widgets(wlist, wi, w) {
1781 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) {
1782 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
1783 if (ret != 0)
1784 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
1785 w->name, ret);
1786 }
1787 }
1788}
1789
1790
1791
1792
1793static void dapm_pre_sequence_async(void *data, async_cookie_t cookie)
1794{
1795 struct snd_soc_dapm_context *d = data;
1796 int ret;
1797
1798
1799 if (d->bias_level == SND_SOC_BIAS_OFF &&
1800 d->target_bias_level != SND_SOC_BIAS_OFF) {
1801 if (d->dev && cookie)
1802 pm_runtime_get_sync(d->dev);
1803
1804 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1805 if (ret != 0)
1806 dev_err(d->dev,
1807 "ASoC: Failed to turn on bias: %d\n", ret);
1808 }
1809
1810
1811 if ((d->target_bias_level == SND_SOC_BIAS_ON &&
1812 d->bias_level != SND_SOC_BIAS_ON) ||
1813 (d->target_bias_level != SND_SOC_BIAS_ON &&
1814 d->bias_level == SND_SOC_BIAS_ON)) {
1815 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
1816 if (ret != 0)
1817 dev_err(d->dev,
1818 "ASoC: Failed to prepare bias: %d\n", ret);
1819 }
1820}
1821
1822
1823
1824
1825static void dapm_post_sequence_async(void *data, async_cookie_t cookie)
1826{
1827 struct snd_soc_dapm_context *d = data;
1828 int ret;
1829
1830
1831 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1832 (d->target_bias_level == SND_SOC_BIAS_STANDBY ||
1833 d->target_bias_level == SND_SOC_BIAS_OFF)) {
1834 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
1835 if (ret != 0)
1836 dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
1837 ret);
1838 }
1839
1840
1841 if (d->bias_level == SND_SOC_BIAS_STANDBY &&
1842 d->target_bias_level == SND_SOC_BIAS_OFF) {
1843 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
1844 if (ret != 0)
1845 dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
1846 ret);
1847
1848 if (d->dev && cookie)
1849 pm_runtime_put(d->dev);
1850 }
1851
1852
1853 if (d->bias_level == SND_SOC_BIAS_PREPARE &&
1854 d->target_bias_level == SND_SOC_BIAS_ON) {
1855 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
1856 if (ret != 0)
1857 dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
1858 ret);
1859 }
1860}
1861
1862static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer,
1863 bool power, bool connect)
1864{
1865
1866
1867
1868 if (!connect)
1869 return;
1870
1871
1872
1873 if (power != peer->power)
1874 dapm_mark_dirty(peer, "peer state change");
1875}
1876
1877static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power,
1878 struct list_head *up_list,
1879 struct list_head *down_list)
1880{
1881 struct snd_soc_dapm_path *path;
1882
1883 if (w->power == power)
1884 return;
1885
1886 trace_snd_soc_dapm_widget_power(w, power);
1887
1888
1889
1890
1891 snd_soc_dapm_widget_for_each_source_path(w, path)
1892 dapm_widget_set_peer_power(path->source, power, path->connect);
1893
1894
1895 if (!w->is_supply) {
1896 snd_soc_dapm_widget_for_each_sink_path(w, path)
1897 dapm_widget_set_peer_power(path->sink, power,
1898 path->connect);
1899 }
1900
1901 if (power)
1902 dapm_seq_insert(w, up_list, true);
1903 else
1904 dapm_seq_insert(w, down_list, false);
1905}
1906
1907static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
1908 struct list_head *up_list,
1909 struct list_head *down_list)
1910{
1911 int power;
1912
1913 switch (w->id) {
1914 case snd_soc_dapm_pre:
1915 dapm_seq_insert(w, down_list, false);
1916 break;
1917 case snd_soc_dapm_post:
1918 dapm_seq_insert(w, up_list, true);
1919 break;
1920
1921 default:
1922 power = dapm_widget_power_check(w);
1923
1924 dapm_widget_set_power(w, power, up_list, down_list);
1925 break;
1926 }
1927}
1928
1929static bool dapm_idle_bias_off(struct snd_soc_dapm_context *dapm)
1930{
1931 if (dapm->idle_bias_off)
1932 return true;
1933
1934 switch (snd_power_get_state(dapm->card->snd_card)) {
1935 case SNDRV_CTL_POWER_D3hot:
1936 case SNDRV_CTL_POWER_D3cold:
1937 return dapm->suspend_bias_off;
1938 default:
1939 break;
1940 }
1941
1942 return false;
1943}
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954static int dapm_power_widgets(struct snd_soc_card *card, int event)
1955{
1956 struct snd_soc_dapm_widget *w;
1957 struct snd_soc_dapm_context *d;
1958 LIST_HEAD(up_list);
1959 LIST_HEAD(down_list);
1960 ASYNC_DOMAIN_EXCLUSIVE(async_domain);
1961 enum snd_soc_bias_level bias;
1962 int ret;
1963
1964 lockdep_assert_held(&card->dapm_mutex);
1965
1966 trace_snd_soc_dapm_start(card);
1967
1968 for_each_card_dapms(card, d) {
1969 if (dapm_idle_bias_off(d))
1970 d->target_bias_level = SND_SOC_BIAS_OFF;
1971 else
1972 d->target_bias_level = SND_SOC_BIAS_STANDBY;
1973 }
1974
1975 dapm_reset(card);
1976
1977
1978
1979
1980
1981
1982
1983 list_for_each_entry(w, &card->dapm_dirty, dirty) {
1984 dapm_power_one_widget(w, &up_list, &down_list);
1985 }
1986
1987 for_each_card_widgets(card, w) {
1988 switch (w->id) {
1989 case snd_soc_dapm_pre:
1990 case snd_soc_dapm_post:
1991
1992 break;
1993 default:
1994 list_del_init(&w->dirty);
1995 break;
1996 }
1997
1998 if (w->new_power) {
1999 d = w->dapm;
2000
2001
2002
2003
2004
2005
2006
2007
2008 switch (w->id) {
2009 case snd_soc_dapm_siggen:
2010 case snd_soc_dapm_vmid:
2011 break;
2012 case snd_soc_dapm_supply:
2013 case snd_soc_dapm_regulator_supply:
2014 case snd_soc_dapm_pinctrl:
2015 case snd_soc_dapm_clock_supply:
2016 case snd_soc_dapm_micbias:
2017 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
2018 d->target_bias_level = SND_SOC_BIAS_STANDBY;
2019 break;
2020 default:
2021 d->target_bias_level = SND_SOC_BIAS_ON;
2022 break;
2023 }
2024 }
2025
2026 }
2027
2028
2029
2030
2031 bias = SND_SOC_BIAS_OFF;
2032 for_each_card_dapms(card, d)
2033 if (d->target_bias_level > bias)
2034 bias = d->target_bias_level;
2035 for_each_card_dapms(card, d)
2036 if (!dapm_idle_bias_off(d))
2037 d->target_bias_level = bias;
2038
2039 trace_snd_soc_dapm_walk_done(card);
2040
2041
2042 dapm_pre_sequence_async(&card->dapm, 0);
2043
2044 for_each_card_dapms(card, d) {
2045 if (d != &card->dapm && d->bias_level != d->target_bias_level)
2046 async_schedule_domain(dapm_pre_sequence_async, d,
2047 &async_domain);
2048 }
2049 async_synchronize_full_domain(&async_domain);
2050
2051 list_for_each_entry(w, &down_list, power_list) {
2052 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
2053 }
2054
2055 list_for_each_entry(w, &up_list, power_list) {
2056 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
2057 }
2058
2059
2060 dapm_seq_run(card, &down_list, event, false);
2061
2062 dapm_widget_update(card);
2063
2064
2065 dapm_seq_run(card, &up_list, event, true);
2066
2067
2068 for_each_card_dapms(card, d) {
2069 if (d != &card->dapm && d->bias_level != d->target_bias_level)
2070 async_schedule_domain(dapm_post_sequence_async, d,
2071 &async_domain);
2072 }
2073 async_synchronize_full_domain(&async_domain);
2074
2075 dapm_post_sequence_async(&card->dapm, 0);
2076
2077
2078 for_each_card_dapms(card, d) {
2079 if (!d->component)
2080 continue;
2081
2082 ret = snd_soc_component_stream_event(d->component, event);
2083 if (ret < 0)
2084 return ret;
2085 }
2086
2087 pop_dbg(card->dev, card->pop_time,
2088 "DAPM sequencing finished, waiting %dms\n", card->pop_time);
2089 pop_wait(card->pop_time);
2090
2091 trace_snd_soc_dapm_done(card);
2092
2093 return 0;
2094}
2095
2096#ifdef CONFIG_DEBUG_FS
2097static ssize_t dapm_widget_power_read_file(struct file *file,
2098 char __user *user_buf,
2099 size_t count, loff_t *ppos)
2100{
2101 struct snd_soc_dapm_widget *w = file->private_data;
2102 struct snd_soc_card *card = w->dapm->card;
2103 enum snd_soc_dapm_direction dir, rdir;
2104 char *buf;
2105 int in, out;
2106 ssize_t ret;
2107 struct snd_soc_dapm_path *p = NULL;
2108
2109 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
2110 if (!buf)
2111 return -ENOMEM;
2112
2113 mutex_lock(&card->dapm_mutex);
2114
2115
2116 if (w->is_supply) {
2117 in = 0;
2118 out = 0;
2119 } else {
2120 in = is_connected_input_ep(w, NULL, NULL);
2121 out = is_connected_output_ep(w, NULL, NULL);
2122 }
2123
2124 ret = scnprintf(buf, PAGE_SIZE, "%s: %s%s in %d out %d",
2125 w->name, w->power ? "On" : "Off",
2126 w->force ? " (forced)" : "", in, out);
2127
2128 if (w->reg >= 0)
2129 ret += scnprintf(buf + ret, PAGE_SIZE - ret,
2130 " - R%d(0x%x) mask 0x%x",
2131 w->reg, w->reg, w->mask << w->shift);
2132
2133 ret += scnprintf(buf + ret, PAGE_SIZE - ret, "\n");
2134
2135 if (w->sname)
2136 ret += scnprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n",
2137 w->sname,
2138 w->active ? "active" : "inactive");
2139
2140 snd_soc_dapm_for_each_direction(dir) {
2141 rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
2142 snd_soc_dapm_widget_for_each_path(w, dir, p) {
2143 if (p->connected && !p->connected(p->source, p->sink))
2144 continue;
2145
2146 if (!p->connect)
2147 continue;
2148
2149 ret += scnprintf(buf + ret, PAGE_SIZE - ret,
2150 " %s \"%s\" \"%s\"\n",
2151 (rdir == SND_SOC_DAPM_DIR_IN) ? "in" : "out",
2152 p->name ? p->name : "static",
2153 p->node[rdir]->name);
2154 }
2155 }
2156
2157 mutex_unlock(&card->dapm_mutex);
2158
2159 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
2160
2161 kfree(buf);
2162 return ret;
2163}
2164
2165static const struct file_operations dapm_widget_power_fops = {
2166 .open = simple_open,
2167 .read = dapm_widget_power_read_file,
2168 .llseek = default_llseek,
2169};
2170
2171static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf,
2172 size_t count, loff_t *ppos)
2173{
2174 struct snd_soc_dapm_context *dapm = file->private_data;
2175 char *level;
2176
2177 switch (dapm->bias_level) {
2178 case SND_SOC_BIAS_ON:
2179 level = "On\n";
2180 break;
2181 case SND_SOC_BIAS_PREPARE:
2182 level = "Prepare\n";
2183 break;
2184 case SND_SOC_BIAS_STANDBY:
2185 level = "Standby\n";
2186 break;
2187 case SND_SOC_BIAS_OFF:
2188 level = "Off\n";
2189 break;
2190 default:
2191 WARN(1, "Unknown bias_level %d\n", dapm->bias_level);
2192 level = "Unknown\n";
2193 break;
2194 }
2195
2196 return simple_read_from_buffer(user_buf, count, ppos, level,
2197 strlen(level));
2198}
2199
2200static const struct file_operations dapm_bias_fops = {
2201 .open = simple_open,
2202 .read = dapm_bias_read_file,
2203 .llseek = default_llseek,
2204};
2205
2206void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2207 struct dentry *parent)
2208{
2209 if (!parent || IS_ERR(parent))
2210 return;
2211
2212 dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
2213
2214 debugfs_create_file("bias_level", 0444, dapm->debugfs_dapm, dapm,
2215 &dapm_bias_fops);
2216}
2217
2218static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2219{
2220 struct snd_soc_dapm_context *dapm = w->dapm;
2221
2222 if (!dapm->debugfs_dapm || !w->name)
2223 return;
2224
2225 debugfs_create_file(w->name, 0444, dapm->debugfs_dapm, w,
2226 &dapm_widget_power_fops);
2227}
2228
2229static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2230{
2231 debugfs_remove_recursive(dapm->debugfs_dapm);
2232 dapm->debugfs_dapm = NULL;
2233}
2234
2235#else
2236void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
2237 struct dentry *parent)
2238{
2239}
2240
2241static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w)
2242{
2243}
2244
2245static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm)
2246{
2247}
2248
2249#endif
2250
2251
2252
2253
2254
2255
2256
2257
2258static void soc_dapm_connect_path(struct snd_soc_dapm_path *path,
2259 bool connect, const char *reason)
2260{
2261 if (path->connect == connect)
2262 return;
2263
2264 path->connect = connect;
2265 dapm_mark_dirty(path->source, reason);
2266 dapm_mark_dirty(path->sink, reason);
2267 dapm_path_invalidate(path);
2268}
2269
2270
2271static int soc_dapm_mux_update_power(struct snd_soc_card *card,
2272 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e)
2273{
2274 struct snd_soc_dapm_path *path;
2275 int found = 0;
2276 bool connect;
2277
2278 lockdep_assert_held(&card->dapm_mutex);
2279
2280
2281 dapm_kcontrol_for_each_path(path, kcontrol) {
2282 found = 1;
2283
2284 if (e && !(strcmp(path->name, e->texts[mux])))
2285 connect = true;
2286 else
2287 connect = false;
2288
2289 soc_dapm_connect_path(path, connect, "mux update");
2290 }
2291
2292 if (found)
2293 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2294
2295 return found;
2296}
2297
2298int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm,
2299 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e,
2300 struct snd_soc_dapm_update *update)
2301{
2302 struct snd_soc_card *card = dapm->card;
2303 int ret;
2304
2305 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2306 card->update = update;
2307 ret = soc_dapm_mux_update_power(card, kcontrol, mux, e);
2308 card->update = NULL;
2309 mutex_unlock(&card->dapm_mutex);
2310 if (ret > 0)
2311 snd_soc_dpcm_runtime_update(card);
2312 return ret;
2313}
2314EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power);
2315
2316
2317static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
2318 struct snd_kcontrol *kcontrol,
2319 int connect, int rconnect)
2320{
2321 struct snd_soc_dapm_path *path;
2322 int found = 0;
2323
2324 lockdep_assert_held(&card->dapm_mutex);
2325
2326
2327 dapm_kcontrol_for_each_path(path, kcontrol) {
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350 if (found && rconnect >= 0)
2351 soc_dapm_connect_path(path, rconnect, "mixer update");
2352 else
2353 soc_dapm_connect_path(path, connect, "mixer update");
2354 found = 1;
2355 }
2356
2357 if (found)
2358 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
2359
2360 return found;
2361}
2362
2363int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm,
2364 struct snd_kcontrol *kcontrol, int connect,
2365 struct snd_soc_dapm_update *update)
2366{
2367 struct snd_soc_card *card = dapm->card;
2368 int ret;
2369
2370 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2371 card->update = update;
2372 ret = soc_dapm_mixer_update_power(card, kcontrol, connect, -1);
2373 card->update = NULL;
2374 mutex_unlock(&card->dapm_mutex);
2375 if (ret > 0)
2376 snd_soc_dpcm_runtime_update(card);
2377 return ret;
2378}
2379EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power);
2380
2381static ssize_t dapm_widget_show_component(struct snd_soc_component *cmpnt,
2382 char *buf)
2383{
2384 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
2385 struct snd_soc_dapm_widget *w;
2386 int count = 0;
2387 char *state = "not set";
2388
2389
2390
2391
2392
2393 if (!cmpnt->card)
2394 return 0;
2395
2396 for_each_card_widgets(cmpnt->card, w) {
2397 if (w->dapm != dapm)
2398 continue;
2399
2400
2401 switch (w->id) {
2402 case snd_soc_dapm_hp:
2403 case snd_soc_dapm_mic:
2404 case snd_soc_dapm_spk:
2405 case snd_soc_dapm_line:
2406 case snd_soc_dapm_micbias:
2407 case snd_soc_dapm_dac:
2408 case snd_soc_dapm_adc:
2409 case snd_soc_dapm_pga:
2410 case snd_soc_dapm_effect:
2411 case snd_soc_dapm_out_drv:
2412 case snd_soc_dapm_mixer:
2413 case snd_soc_dapm_mixer_named_ctl:
2414 case snd_soc_dapm_supply:
2415 case snd_soc_dapm_regulator_supply:
2416 case snd_soc_dapm_pinctrl:
2417 case snd_soc_dapm_clock_supply:
2418 if (w->name)
2419 count += sprintf(buf + count, "%s: %s\n",
2420 w->name, w->power ? "On":"Off");
2421 break;
2422 default:
2423 break;
2424 }
2425 }
2426
2427 switch (snd_soc_dapm_get_bias_level(dapm)) {
2428 case SND_SOC_BIAS_ON:
2429 state = "On";
2430 break;
2431 case SND_SOC_BIAS_PREPARE:
2432 state = "Prepare";
2433 break;
2434 case SND_SOC_BIAS_STANDBY:
2435 state = "Standby";
2436 break;
2437 case SND_SOC_BIAS_OFF:
2438 state = "Off";
2439 break;
2440 }
2441 count += sprintf(buf + count, "PM State: %s\n", state);
2442
2443 return count;
2444}
2445
2446
2447static ssize_t dapm_widget_show(struct device *dev,
2448 struct device_attribute *attr, char *buf)
2449{
2450 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
2451 struct snd_soc_dai *codec_dai;
2452 int i, count = 0;
2453
2454 mutex_lock(&rtd->card->dapm_mutex);
2455
2456 for_each_rtd_codec_dais(rtd, i, codec_dai) {
2457 struct snd_soc_component *cmpnt = codec_dai->component;
2458
2459 count += dapm_widget_show_component(cmpnt, buf + count);
2460 }
2461
2462 mutex_unlock(&rtd->card->dapm_mutex);
2463
2464 return count;
2465}
2466
2467static DEVICE_ATTR_RO(dapm_widget);
2468
2469struct attribute *soc_dapm_dev_attrs[] = {
2470 &dev_attr_dapm_widget.attr,
2471 NULL
2472};
2473
2474static void dapm_free_path(struct snd_soc_dapm_path *path)
2475{
2476 list_del(&path->list_node[SND_SOC_DAPM_DIR_IN]);
2477 list_del(&path->list_node[SND_SOC_DAPM_DIR_OUT]);
2478 list_del(&path->list_kcontrol);
2479 list_del(&path->list);
2480 kfree(path);
2481}
2482
2483void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w)
2484{
2485 struct snd_soc_dapm_path *p, *next_p;
2486 enum snd_soc_dapm_direction dir;
2487
2488 list_del(&w->list);
2489 list_del(&w->dirty);
2490
2491
2492
2493
2494
2495 snd_soc_dapm_for_each_direction(dir) {
2496 snd_soc_dapm_widget_for_each_path_safe(w, dir, p, next_p)
2497 dapm_free_path(p);
2498 }
2499
2500 kfree(w->kcontrols);
2501 kfree_const(w->name);
2502 kfree_const(w->sname);
2503 kfree(w);
2504}
2505
2506void snd_soc_dapm_reset_cache(struct snd_soc_dapm_context *dapm)
2507{
2508 dapm->path_sink_cache.widget = NULL;
2509 dapm->path_source_cache.widget = NULL;
2510}
2511
2512
2513static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
2514{
2515 struct snd_soc_dapm_widget *w, *next_w;
2516
2517 for_each_card_widgets_safe(dapm->card, w, next_w) {
2518 if (w->dapm != dapm)
2519 continue;
2520 snd_soc_dapm_free_widget(w);
2521 }
2522 snd_soc_dapm_reset_cache(dapm);
2523}
2524
2525static struct snd_soc_dapm_widget *dapm_find_widget(
2526 struct snd_soc_dapm_context *dapm, const char *pin,
2527 bool search_other_contexts)
2528{
2529 struct snd_soc_dapm_widget *w;
2530 struct snd_soc_dapm_widget *fallback = NULL;
2531
2532 for_each_card_widgets(dapm->card, w) {
2533 if (!strcmp(w->name, pin)) {
2534 if (w->dapm == dapm)
2535 return w;
2536 else
2537 fallback = w;
2538 }
2539 }
2540
2541 if (search_other_contexts)
2542 return fallback;
2543
2544 return NULL;
2545}
2546
2547static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
2548 const char *pin, int status)
2549{
2550 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
2551
2552 dapm_assert_locked(dapm);
2553
2554 if (!w) {
2555 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
2556 return -EINVAL;
2557 }
2558
2559 if (w->connected != status) {
2560 dapm_mark_dirty(w, "pin configuration");
2561 dapm_widget_invalidate_input_paths(w);
2562 dapm_widget_invalidate_output_paths(w);
2563 }
2564
2565 w->connected = status;
2566 if (status == 0)
2567 w->force = 0;
2568
2569 return 0;
2570}
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)
2584{
2585
2586
2587
2588
2589 if (!dapm->card || !dapm->card->instantiated)
2590 return 0;
2591
2592 return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP);
2593}
2594EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked);
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
2606{
2607 int ret;
2608
2609 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2610 ret = snd_soc_dapm_sync_unlocked(dapm);
2611 mutex_unlock(&dapm->card->dapm_mutex);
2612 return ret;
2613}
2614EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
2615
2616static int dapm_update_dai_chan(struct snd_soc_dapm_path *p,
2617 struct snd_soc_dapm_widget *w,
2618 int channels)
2619{
2620 switch (w->id) {
2621 case snd_soc_dapm_aif_out:
2622 case snd_soc_dapm_aif_in:
2623 break;
2624 default:
2625 return 0;
2626 }
2627
2628 dev_dbg(w->dapm->dev, "%s DAI route %s -> %s\n",
2629 w->channel < channels ? "Connecting" : "Disconnecting",
2630 p->source->name, p->sink->name);
2631
2632 if (w->channel < channels)
2633 soc_dapm_connect_path(p, true, "dai update");
2634 else
2635 soc_dapm_connect_path(p, false, "dai update");
2636
2637 return 0;
2638}
2639
2640static int dapm_update_dai_unlocked(struct snd_pcm_substream *substream,
2641 struct snd_pcm_hw_params *params,
2642 struct snd_soc_dai *dai)
2643{
2644 int dir = substream->stream;
2645 int channels = params_channels(params);
2646 struct snd_soc_dapm_path *p;
2647 struct snd_soc_dapm_widget *w;
2648 int ret;
2649
2650 w = snd_soc_dai_get_widget(dai, dir);
2651
2652 if (!w)
2653 return 0;
2654
2655 dev_dbg(dai->dev, "Update DAI routes for %s %s\n", dai->name,
2656 dir == SNDRV_PCM_STREAM_PLAYBACK ? "playback" : "capture");
2657
2658 snd_soc_dapm_widget_for_each_sink_path(w, p) {
2659 ret = dapm_update_dai_chan(p, p->sink, channels);
2660 if (ret < 0)
2661 return ret;
2662 }
2663
2664 snd_soc_dapm_widget_for_each_source_path(w, p) {
2665 ret = dapm_update_dai_chan(p, p->source, channels);
2666 if (ret < 0)
2667 return ret;
2668 }
2669
2670 return 0;
2671}
2672
2673int snd_soc_dapm_update_dai(struct snd_pcm_substream *substream,
2674 struct snd_pcm_hw_params *params,
2675 struct snd_soc_dai *dai)
2676{
2677 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
2678 int ret;
2679
2680 mutex_lock_nested(&rtd->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
2681 ret = dapm_update_dai_unlocked(substream, params, dai);
2682 mutex_unlock(&rtd->card->dapm_mutex);
2683
2684 return ret;
2685}
2686EXPORT_SYMBOL_GPL(snd_soc_dapm_update_dai);
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
2698{
2699 enum snd_soc_dapm_direction dir;
2700 struct snd_soc_dapm_path *p;
2701 unsigned int ep;
2702
2703 switch (w->id) {
2704 case snd_soc_dapm_input:
2705
2706 if (w->dapm->card->fully_routed)
2707 return;
2708 ep = SND_SOC_DAPM_EP_SOURCE;
2709 snd_soc_dapm_widget_for_each_source_path(w, p) {
2710 if (p->source->id == snd_soc_dapm_micbias ||
2711 p->source->id == snd_soc_dapm_mic ||
2712 p->source->id == snd_soc_dapm_line ||
2713 p->source->id == snd_soc_dapm_output) {
2714 ep = 0;
2715 break;
2716 }
2717 }
2718 break;
2719 case snd_soc_dapm_output:
2720
2721 if (w->dapm->card->fully_routed)
2722 return;
2723 ep = SND_SOC_DAPM_EP_SINK;
2724 snd_soc_dapm_widget_for_each_sink_path(w, p) {
2725 if (p->sink->id == snd_soc_dapm_spk ||
2726 p->sink->id == snd_soc_dapm_hp ||
2727 p->sink->id == snd_soc_dapm_line ||
2728 p->sink->id == snd_soc_dapm_input) {
2729 ep = 0;
2730 break;
2731 }
2732 }
2733 break;
2734 case snd_soc_dapm_line:
2735 ep = 0;
2736 snd_soc_dapm_for_each_direction(dir) {
2737 if (!list_empty(&w->edges[dir]))
2738 ep |= SND_SOC_DAPM_DIR_TO_EP(dir);
2739 }
2740 break;
2741 default:
2742 return;
2743 }
2744
2745 w->is_ep = ep;
2746}
2747
2748static int snd_soc_dapm_check_dynamic_path(struct snd_soc_dapm_context *dapm,
2749 struct snd_soc_dapm_widget *source, struct snd_soc_dapm_widget *sink,
2750 const char *control)
2751{
2752 bool dynamic_source = false;
2753 bool dynamic_sink = false;
2754
2755 if (!control)
2756 return 0;
2757
2758 switch (source->id) {
2759 case snd_soc_dapm_demux:
2760 dynamic_source = true;
2761 break;
2762 default:
2763 break;
2764 }
2765
2766 switch (sink->id) {
2767 case snd_soc_dapm_mux:
2768 case snd_soc_dapm_switch:
2769 case snd_soc_dapm_mixer:
2770 case snd_soc_dapm_mixer_named_ctl:
2771 dynamic_sink = true;
2772 break;
2773 default:
2774 break;
2775 }
2776
2777 if (dynamic_source && dynamic_sink) {
2778 dev_err(dapm->dev,
2779 "Direct connection between demux and mixer/mux not supported for path %s -> [%s] -> %s\n",
2780 source->name, control, sink->name);
2781 return -EINVAL;
2782 } else if (!dynamic_source && !dynamic_sink) {
2783 dev_err(dapm->dev,
2784 "Control not supported for path %s -> [%s] -> %s\n",
2785 source->name, control, sink->name);
2786 return -EINVAL;
2787 }
2788
2789 return 0;
2790}
2791
2792static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,
2793 struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,
2794 const char *control,
2795 int (*connected)(struct snd_soc_dapm_widget *source,
2796 struct snd_soc_dapm_widget *sink))
2797{
2798 struct snd_soc_dapm_widget *widgets[2];
2799 enum snd_soc_dapm_direction dir;
2800 struct snd_soc_dapm_path *path;
2801 int ret;
2802
2803 if (wsink->is_supply && !wsource->is_supply) {
2804 dev_err(dapm->dev,
2805 "Connecting non-supply widget to supply widget is not supported (%s -> %s)\n",
2806 wsource->name, wsink->name);
2807 return -EINVAL;
2808 }
2809
2810 if (connected && !wsource->is_supply) {
2811 dev_err(dapm->dev,
2812 "connected() callback only supported for supply widgets (%s -> %s)\n",
2813 wsource->name, wsink->name);
2814 return -EINVAL;
2815 }
2816
2817 if (wsource->is_supply && control) {
2818 dev_err(dapm->dev,
2819 "Conditional paths are not supported for supply widgets (%s -> [%s] -> %s)\n",
2820 wsource->name, control, wsink->name);
2821 return -EINVAL;
2822 }
2823
2824 ret = snd_soc_dapm_check_dynamic_path(dapm, wsource, wsink, control);
2825 if (ret)
2826 return ret;
2827
2828 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
2829 if (!path)
2830 return -ENOMEM;
2831
2832 path->node[SND_SOC_DAPM_DIR_IN] = wsource;
2833 path->node[SND_SOC_DAPM_DIR_OUT] = wsink;
2834 widgets[SND_SOC_DAPM_DIR_IN] = wsource;
2835 widgets[SND_SOC_DAPM_DIR_OUT] = wsink;
2836
2837 path->connected = connected;
2838 INIT_LIST_HEAD(&path->list);
2839 INIT_LIST_HEAD(&path->list_kcontrol);
2840
2841 if (wsource->is_supply || wsink->is_supply)
2842 path->is_supply = 1;
2843
2844
2845 if (control == NULL) {
2846 path->connect = 1;
2847 } else {
2848 switch (wsource->id) {
2849 case snd_soc_dapm_demux:
2850 ret = dapm_connect_mux(dapm, path, control, wsource);
2851 if (ret)
2852 goto err;
2853 break;
2854 default:
2855 break;
2856 }
2857
2858 switch (wsink->id) {
2859 case snd_soc_dapm_mux:
2860 ret = dapm_connect_mux(dapm, path, control, wsink);
2861 if (ret != 0)
2862 goto err;
2863 break;
2864 case snd_soc_dapm_switch:
2865 case snd_soc_dapm_mixer:
2866 case snd_soc_dapm_mixer_named_ctl:
2867 ret = dapm_connect_mixer(dapm, path, control);
2868 if (ret != 0)
2869 goto err;
2870 break;
2871 default:
2872 break;
2873 }
2874 }
2875
2876 list_add(&path->list, &dapm->card->paths);
2877 snd_soc_dapm_for_each_direction(dir)
2878 list_add(&path->list_node[dir], &widgets[dir]->edges[dir]);
2879
2880 snd_soc_dapm_for_each_direction(dir) {
2881 dapm_update_widget_flags(widgets[dir]);
2882 dapm_mark_dirty(widgets[dir], "Route added");
2883 }
2884
2885 if (dapm->card->instantiated && path->connect)
2886 dapm_path_invalidate(path);
2887
2888 return 0;
2889err:
2890 kfree(path);
2891 return ret;
2892}
2893
2894static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
2895 const struct snd_soc_dapm_route *route)
2896{
2897 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
2898 struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
2899 const char *sink;
2900 const char *source;
2901 char prefixed_sink[80];
2902 char prefixed_source[80];
2903 const char *prefix;
2904 unsigned int sink_ref = 0;
2905 unsigned int source_ref = 0;
2906 int ret;
2907
2908 prefix = soc_dapm_prefix(dapm);
2909 if (prefix) {
2910 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
2911 prefix, route->sink);
2912 sink = prefixed_sink;
2913 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
2914 prefix, route->source);
2915 source = prefixed_source;
2916 } else {
2917 sink = route->sink;
2918 source = route->source;
2919 }
2920
2921 wsource = dapm_wcache_lookup(&dapm->path_source_cache, source);
2922 wsink = dapm_wcache_lookup(&dapm->path_sink_cache, sink);
2923
2924 if (wsink && wsource)
2925 goto skip_search;
2926
2927
2928
2929
2930
2931 for_each_card_widgets(dapm->card, w) {
2932 if (!wsink && !(strcmp(w->name, sink))) {
2933 wtsink = w;
2934 if (w->dapm == dapm) {
2935 wsink = w;
2936 if (wsource)
2937 break;
2938 }
2939 sink_ref++;
2940 if (sink_ref > 1)
2941 dev_warn(dapm->dev,
2942 "ASoC: sink widget %s overwritten\n",
2943 w->name);
2944 continue;
2945 }
2946 if (!wsource && !(strcmp(w->name, source))) {
2947 wtsource = w;
2948 if (w->dapm == dapm) {
2949 wsource = w;
2950 if (wsink)
2951 break;
2952 }
2953 source_ref++;
2954 if (source_ref > 1)
2955 dev_warn(dapm->dev,
2956 "ASoC: source widget %s overwritten\n",
2957 w->name);
2958 }
2959 }
2960
2961 if (!wsink)
2962 wsink = wtsink;
2963 if (!wsource)
2964 wsource = wtsource;
2965
2966 if (wsource == NULL) {
2967 dev_err(dapm->dev, "ASoC: no source widget found for %s\n",
2968 route->source);
2969 return -ENODEV;
2970 }
2971 if (wsink == NULL) {
2972 dev_err(dapm->dev, "ASoC: no sink widget found for %s\n",
2973 route->sink);
2974 return -ENODEV;
2975 }
2976
2977skip_search:
2978 dapm_wcache_update(&dapm->path_sink_cache, wsink);
2979 dapm_wcache_update(&dapm->path_source_cache, wsource);
2980
2981 ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,
2982 route->connected);
2983 if (ret)
2984 goto err;
2985
2986 return 0;
2987err:
2988 dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n",
2989 source, route->control, sink);
2990 return ret;
2991}
2992
2993static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm,
2994 const struct snd_soc_dapm_route *route)
2995{
2996 struct snd_soc_dapm_widget *wsource, *wsink;
2997 struct snd_soc_dapm_path *path, *p;
2998 const char *sink;
2999 const char *source;
3000 char prefixed_sink[80];
3001 char prefixed_source[80];
3002 const char *prefix;
3003
3004 if (route->control) {
3005 dev_err(dapm->dev,
3006 "ASoC: Removal of routes with controls not supported\n");
3007 return -EINVAL;
3008 }
3009
3010 prefix = soc_dapm_prefix(dapm);
3011 if (prefix) {
3012 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
3013 prefix, route->sink);
3014 sink = prefixed_sink;
3015 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
3016 prefix, route->source);
3017 source = prefixed_source;
3018 } else {
3019 sink = route->sink;
3020 source = route->source;
3021 }
3022
3023 path = NULL;
3024 list_for_each_entry(p, &dapm->card->paths, list) {
3025 if (strcmp(p->source->name, source) != 0)
3026 continue;
3027 if (strcmp(p->sink->name, sink) != 0)
3028 continue;
3029 path = p;
3030 break;
3031 }
3032
3033 if (path) {
3034 wsource = path->source;
3035 wsink = path->sink;
3036
3037 dapm_mark_dirty(wsource, "Route removed");
3038 dapm_mark_dirty(wsink, "Route removed");
3039 if (path->connect)
3040 dapm_path_invalidate(path);
3041
3042 dapm_free_path(path);
3043
3044
3045 dapm_update_widget_flags(wsource);
3046 dapm_update_widget_flags(wsink);
3047 } else {
3048 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
3049 source, sink);
3050 }
3051
3052 return 0;
3053}
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
3069 const struct snd_soc_dapm_route *route, int num)
3070{
3071 int i, r, ret = 0;
3072
3073 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3074 for (i = 0; i < num; i++) {
3075 r = snd_soc_dapm_add_route(dapm, route);
3076 if (r < 0) {
3077 dev_err(dapm->dev, "ASoC: Failed to add route %s -> %s -> %s\n",
3078 route->source,
3079 route->control ? route->control : "direct",
3080 route->sink);
3081 ret = r;
3082 }
3083 route++;
3084 }
3085 mutex_unlock(&dapm->card->dapm_mutex);
3086
3087 return ret;
3088}
3089EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes);
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm,
3100 const struct snd_soc_dapm_route *route, int num)
3101{
3102 int i;
3103
3104 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3105 for (i = 0; i < num; i++) {
3106 snd_soc_dapm_del_route(dapm, route);
3107 route++;
3108 }
3109 mutex_unlock(&dapm->card->dapm_mutex);
3110
3111 return 0;
3112}
3113EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes);
3114
3115static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm,
3116 const struct snd_soc_dapm_route *route)
3117{
3118 struct snd_soc_dapm_widget *source = dapm_find_widget(dapm,
3119 route->source,
3120 true);
3121 struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm,
3122 route->sink,
3123 true);
3124 struct snd_soc_dapm_path *path;
3125 int count = 0;
3126
3127 if (!source) {
3128 dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
3129 route->source);
3130 return -ENODEV;
3131 }
3132
3133 if (!sink) {
3134 dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
3135 route->sink);
3136 return -ENODEV;
3137 }
3138
3139 if (route->control || route->connected)
3140 dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
3141 route->source, route->sink);
3142
3143 snd_soc_dapm_widget_for_each_sink_path(source, path) {
3144 if (path->sink == sink) {
3145 path->weak = 1;
3146 count++;
3147 }
3148 }
3149
3150 if (count == 0)
3151 dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
3152 route->source, route->sink);
3153 if (count > 1)
3154 dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
3155 count, route->source, route->sink);
3156
3157 return 0;
3158}
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm,
3177 const struct snd_soc_dapm_route *route, int num)
3178{
3179 int i, err;
3180 int ret = 0;
3181
3182 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
3183 for (i = 0; i < num; i++) {
3184 err = snd_soc_dapm_weak_route(dapm, route);
3185 if (err)
3186 ret = err;
3187 route++;
3188 }
3189 mutex_unlock(&dapm->card->dapm_mutex);
3190
3191 return ret;
3192}
3193EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes);
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203int snd_soc_dapm_new_widgets(struct snd_soc_card *card)
3204{
3205 struct snd_soc_dapm_widget *w;
3206 unsigned int val;
3207
3208 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
3209
3210 for_each_card_widgets(card, w)
3211 {
3212 if (w->new)
3213 continue;
3214
3215 if (w->num_kcontrols) {
3216 w->kcontrols = kcalloc(w->num_kcontrols,
3217 sizeof(struct snd_kcontrol *),
3218 GFP_KERNEL);
3219 if (!w->kcontrols) {
3220 mutex_unlock(&card->dapm_mutex);
3221 return -ENOMEM;
3222 }
3223 }
3224
3225 switch(w->id) {
3226 case snd_soc_dapm_switch:
3227 case snd_soc_dapm_mixer:
3228 case snd_soc_dapm_mixer_named_ctl:
3229 dapm_new_mixer(w);
3230 break;
3231 case snd_soc_dapm_mux:
3232 case snd_soc_dapm_demux:
3233 dapm_new_mux(w);
3234 break;
3235 case snd_soc_dapm_pga:
3236 case snd_soc_dapm_effect:
3237 case snd_soc_dapm_out_drv:
3238 dapm_new_pga(w);
3239 break;
3240 case snd_soc_dapm_dai_link:
3241 dapm_new_dai_link(w);
3242 break;
3243 default:
3244 break;
3245 }
3246
3247
3248 if (w->reg >= 0) {
3249 val = soc_dapm_read(w->dapm, w->reg);
3250 val = val >> w->shift;
3251 val &= w->mask;
3252 if (val == w->on_val)
3253 w->power = 1;
3254 }
3255
3256 w->new = 1;
3257
3258 dapm_mark_dirty(w, "new widget");
3259 dapm_debugfs_add_widget(w);
3260 }
3261
3262 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
3263 mutex_unlock(&card->dapm_mutex);
3264 return 0;
3265}
3266EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol,
3278 struct snd_ctl_elem_value *ucontrol)
3279{
3280 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3281 struct snd_soc_card *card = dapm->card;
3282 struct soc_mixer_control *mc =
3283 (struct soc_mixer_control *)kcontrol->private_value;
3284 int reg = mc->reg;
3285 unsigned int shift = mc->shift;
3286 int max = mc->max;
3287 unsigned int width = fls(max);
3288 unsigned int mask = (1 << fls(max)) - 1;
3289 unsigned int invert = mc->invert;
3290 unsigned int reg_val, val, rval = 0;
3291
3292 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3293 if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) {
3294 reg_val = soc_dapm_read(dapm, reg);
3295 val = (reg_val >> shift) & mask;
3296
3297 if (reg != mc->rreg)
3298 reg_val = soc_dapm_read(dapm, mc->rreg);
3299
3300 if (snd_soc_volsw_is_stereo(mc))
3301 rval = (reg_val >> mc->rshift) & mask;
3302 } else {
3303 reg_val = dapm_kcontrol_get_value(kcontrol);
3304 val = reg_val & mask;
3305
3306 if (snd_soc_volsw_is_stereo(mc))
3307 rval = (reg_val >> width) & mask;
3308 }
3309 mutex_unlock(&card->dapm_mutex);
3310
3311 if (invert)
3312 ucontrol->value.integer.value[0] = max - val;
3313 else
3314 ucontrol->value.integer.value[0] = val;
3315
3316 if (snd_soc_volsw_is_stereo(mc)) {
3317 if (invert)
3318 ucontrol->value.integer.value[1] = max - rval;
3319 else
3320 ucontrol->value.integer.value[1] = rval;
3321 }
3322
3323 return 0;
3324}
3325EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw);
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
3337 struct snd_ctl_elem_value *ucontrol)
3338{
3339 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3340 struct snd_soc_card *card = dapm->card;
3341 struct soc_mixer_control *mc =
3342 (struct soc_mixer_control *)kcontrol->private_value;
3343 int reg = mc->reg;
3344 unsigned int shift = mc->shift;
3345 int max = mc->max;
3346 unsigned int width = fls(max);
3347 unsigned int mask = (1 << width) - 1;
3348 unsigned int invert = mc->invert;
3349 unsigned int val, rval = 0;
3350 int connect, rconnect = -1, change, reg_change = 0;
3351 struct snd_soc_dapm_update update = {};
3352 int ret = 0;
3353
3354 val = (ucontrol->value.integer.value[0] & mask);
3355 connect = !!val;
3356
3357 if (invert)
3358 val = max - val;
3359
3360 if (snd_soc_volsw_is_stereo(mc)) {
3361 rval = (ucontrol->value.integer.value[1] & mask);
3362 rconnect = !!rval;
3363 if (invert)
3364 rval = max - rval;
3365 }
3366
3367 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3368
3369
3370 if (width > sizeof(unsigned int) * 8 / 2)
3371 dev_warn(dapm->dev,
3372 "ASoC: control %s field width limit exceeded\n",
3373 kcontrol->id.name);
3374 change = dapm_kcontrol_set_value(kcontrol, val | (rval << width));
3375
3376 if (reg != SND_SOC_NOPM) {
3377 val = val << shift;
3378 rval = rval << mc->rshift;
3379
3380 reg_change = soc_dapm_test_bits(dapm, reg, mask << shift, val);
3381
3382 if (snd_soc_volsw_is_stereo(mc))
3383 reg_change |= soc_dapm_test_bits(dapm, mc->rreg,
3384 mask << mc->rshift,
3385 rval);
3386 }
3387
3388 if (change || reg_change) {
3389 if (reg_change) {
3390 if (snd_soc_volsw_is_stereo(mc)) {
3391 update.has_second_set = true;
3392 update.reg2 = mc->rreg;
3393 update.mask2 = mask << mc->rshift;
3394 update.val2 = rval;
3395 }
3396 update.kcontrol = kcontrol;
3397 update.reg = reg;
3398 update.mask = mask << shift;
3399 update.val = val;
3400 card->update = &update;
3401 }
3402 change |= reg_change;
3403
3404 ret = soc_dapm_mixer_update_power(card, kcontrol, connect,
3405 rconnect);
3406
3407 card->update = NULL;
3408 }
3409
3410 mutex_unlock(&card->dapm_mutex);
3411
3412 if (ret > 0)
3413 snd_soc_dpcm_runtime_update(card);
3414
3415 return change;
3416}
3417EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol,
3429 struct snd_ctl_elem_value *ucontrol)
3430{
3431 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3432 struct snd_soc_card *card = dapm->card;
3433 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3434 unsigned int reg_val, val;
3435
3436 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3437 if (e->reg != SND_SOC_NOPM && dapm_kcontrol_is_powered(kcontrol)) {
3438 reg_val = soc_dapm_read(dapm, e->reg);
3439 } else {
3440 reg_val = dapm_kcontrol_get_value(kcontrol);
3441 }
3442 mutex_unlock(&card->dapm_mutex);
3443
3444 val = (reg_val >> e->shift_l) & e->mask;
3445 ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
3446 if (e->shift_l != e->shift_r) {
3447 val = (reg_val >> e->shift_r) & e->mask;
3448 val = snd_soc_enum_val_to_item(e, val);
3449 ucontrol->value.enumerated.item[1] = val;
3450 }
3451
3452 return 0;
3453}
3454EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double);
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464
3465int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol,
3466 struct snd_ctl_elem_value *ucontrol)
3467{
3468 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
3469 struct snd_soc_card *card = dapm->card;
3470 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
3471 unsigned int *item = ucontrol->value.enumerated.item;
3472 unsigned int val, change, reg_change = 0;
3473 unsigned int mask;
3474 struct snd_soc_dapm_update update = {};
3475 int ret = 0;
3476
3477 if (item[0] >= e->items)
3478 return -EINVAL;
3479
3480 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
3481 mask = e->mask << e->shift_l;
3482 if (e->shift_l != e->shift_r) {
3483 if (item[1] > e->items)
3484 return -EINVAL;
3485 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_r;
3486 mask |= e->mask << e->shift_r;
3487 }
3488
3489 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3490
3491 change = dapm_kcontrol_set_value(kcontrol, val);
3492
3493 if (e->reg != SND_SOC_NOPM)
3494 reg_change = soc_dapm_test_bits(dapm, e->reg, mask, val);
3495
3496 if (change || reg_change) {
3497 if (reg_change) {
3498 update.kcontrol = kcontrol;
3499 update.reg = e->reg;
3500 update.mask = mask;
3501 update.val = val;
3502 card->update = &update;
3503 }
3504 change |= reg_change;
3505
3506 ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e);
3507
3508 card->update = NULL;
3509 }
3510
3511 mutex_unlock(&card->dapm_mutex);
3512
3513 if (ret > 0)
3514 snd_soc_dpcm_runtime_update(card);
3515
3516 return change;
3517}
3518EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol,
3529 struct snd_ctl_elem_info *uinfo)
3530{
3531 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3532 uinfo->count = 1;
3533 uinfo->value.integer.min = 0;
3534 uinfo->value.integer.max = 1;
3535
3536 return 0;
3537}
3538EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch);
3539
3540
3541
3542
3543
3544
3545
3546int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol,
3547 struct snd_ctl_elem_value *ucontrol)
3548{
3549 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
3550 const char *pin = (const char *)kcontrol->private_value;
3551
3552 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3553
3554 ucontrol->value.integer.value[0] =
3555 snd_soc_dapm_get_pin_status(&card->dapm, pin);
3556
3557 mutex_unlock(&card->dapm_mutex);
3558
3559 return 0;
3560}
3561EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch);
3562
3563
3564
3565
3566
3567
3568
3569int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol,
3570 struct snd_ctl_elem_value *ucontrol)
3571{
3572 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
3573 const char *pin = (const char *)kcontrol->private_value;
3574
3575 if (ucontrol->value.integer.value[0])
3576 snd_soc_dapm_enable_pin(&card->dapm, pin);
3577 else
3578 snd_soc_dapm_disable_pin(&card->dapm, pin);
3579
3580 snd_soc_dapm_sync(&card->dapm);
3581 return 0;
3582}
3583EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch);
3584
3585struct snd_soc_dapm_widget *
3586snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
3587 const struct snd_soc_dapm_widget *widget)
3588{
3589 enum snd_soc_dapm_direction dir;
3590 struct snd_soc_dapm_widget *w;
3591 const char *prefix;
3592 int ret;
3593
3594 if ((w = dapm_cnew_widget(widget)) == NULL)
3595 return ERR_PTR(-ENOMEM);
3596
3597 switch (w->id) {
3598 case snd_soc_dapm_regulator_supply:
3599 w->regulator = devm_regulator_get(dapm->dev, w->name);
3600 if (IS_ERR(w->regulator)) {
3601 ret = PTR_ERR(w->regulator);
3602 goto request_failed;
3603 }
3604
3605 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {
3606 ret = regulator_allow_bypass(w->regulator, true);
3607 if (ret != 0)
3608 dev_warn(dapm->dev,
3609 "ASoC: Failed to bypass %s: %d\n",
3610 w->name, ret);
3611 }
3612 break;
3613 case snd_soc_dapm_pinctrl:
3614 w->pinctrl = devm_pinctrl_get(dapm->dev);
3615 if (IS_ERR(w->pinctrl)) {
3616 ret = PTR_ERR(w->pinctrl);
3617 goto request_failed;
3618 }
3619
3620
3621 dapm_pinctrl_event(w, NULL, SND_SOC_DAPM_POST_PMD);
3622 break;
3623 case snd_soc_dapm_clock_supply:
3624 w->clk = devm_clk_get(dapm->dev, w->name);
3625 if (IS_ERR(w->clk)) {
3626 ret = PTR_ERR(w->clk);
3627 goto request_failed;
3628 }
3629 break;
3630 default:
3631 break;
3632 }
3633
3634 prefix = soc_dapm_prefix(dapm);
3635 if (prefix)
3636 w->name = kasprintf(GFP_KERNEL, "%s %s", prefix, widget->name);
3637 else
3638 w->name = kstrdup_const(widget->name, GFP_KERNEL);
3639 if (w->name == NULL) {
3640 kfree_const(w->sname);
3641 kfree(w);
3642 return ERR_PTR(-ENOMEM);
3643 }
3644
3645 switch (w->id) {
3646 case snd_soc_dapm_mic:
3647 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3648 w->power_check = dapm_generic_check_power;
3649 break;
3650 case snd_soc_dapm_input:
3651 if (!dapm->card->fully_routed)
3652 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3653 w->power_check = dapm_generic_check_power;
3654 break;
3655 case snd_soc_dapm_spk:
3656 case snd_soc_dapm_hp:
3657 w->is_ep = SND_SOC_DAPM_EP_SINK;
3658 w->power_check = dapm_generic_check_power;
3659 break;
3660 case snd_soc_dapm_output:
3661 if (!dapm->card->fully_routed)
3662 w->is_ep = SND_SOC_DAPM_EP_SINK;
3663 w->power_check = dapm_generic_check_power;
3664 break;
3665 case snd_soc_dapm_vmid:
3666 case snd_soc_dapm_siggen:
3667 w->is_ep = SND_SOC_DAPM_EP_SOURCE;
3668 w->power_check = dapm_always_on_check_power;
3669 break;
3670 case snd_soc_dapm_sink:
3671 w->is_ep = SND_SOC_DAPM_EP_SINK;
3672 w->power_check = dapm_always_on_check_power;
3673 break;
3674
3675 case snd_soc_dapm_mux:
3676 case snd_soc_dapm_demux:
3677 case snd_soc_dapm_switch:
3678 case snd_soc_dapm_mixer:
3679 case snd_soc_dapm_mixer_named_ctl:
3680 case snd_soc_dapm_adc:
3681 case snd_soc_dapm_aif_out:
3682 case snd_soc_dapm_dac:
3683 case snd_soc_dapm_aif_in:
3684 case snd_soc_dapm_pga:
3685 case snd_soc_dapm_buffer:
3686 case snd_soc_dapm_scheduler:
3687 case snd_soc_dapm_effect:
3688 case snd_soc_dapm_src:
3689 case snd_soc_dapm_asrc:
3690 case snd_soc_dapm_encoder:
3691 case snd_soc_dapm_decoder:
3692 case snd_soc_dapm_out_drv:
3693 case snd_soc_dapm_micbias:
3694 case snd_soc_dapm_line:
3695 case snd_soc_dapm_dai_link:
3696 case snd_soc_dapm_dai_out:
3697 case snd_soc_dapm_dai_in:
3698 w->power_check = dapm_generic_check_power;
3699 break;
3700 case snd_soc_dapm_supply:
3701 case snd_soc_dapm_regulator_supply:
3702 case snd_soc_dapm_pinctrl:
3703 case snd_soc_dapm_clock_supply:
3704 case snd_soc_dapm_kcontrol:
3705 w->is_supply = 1;
3706 w->power_check = dapm_supply_check_power;
3707 break;
3708 default:
3709 w->power_check = dapm_always_on_check_power;
3710 break;
3711 }
3712
3713 w->dapm = dapm;
3714 INIT_LIST_HEAD(&w->list);
3715 INIT_LIST_HEAD(&w->dirty);
3716
3717 list_add_tail(&w->list, &dapm->card->widgets);
3718
3719 snd_soc_dapm_for_each_direction(dir) {
3720 INIT_LIST_HEAD(&w->edges[dir]);
3721 w->endpoints[dir] = -1;
3722 }
3723
3724
3725 w->connected = 1;
3726 return w;
3727
3728request_failed:
3729 if (ret != -EPROBE_DEFER)
3730 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
3731 w->name, ret);
3732
3733 kfree_const(w->sname);
3734 kfree(w);
3735 return ERR_PTR(ret);
3736}
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747struct snd_soc_dapm_widget *
3748snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
3749 const struct snd_soc_dapm_widget *widget)
3750{
3751 struct snd_soc_dapm_widget *w;
3752
3753 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
3754 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3755 mutex_unlock(&dapm->card->dapm_mutex);
3756
3757 return w;
3758}
3759EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control);
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
3772 const struct snd_soc_dapm_widget *widget,
3773 int num)
3774{
3775 struct snd_soc_dapm_widget *w;
3776 int i;
3777 int ret = 0;
3778
3779 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);
3780 for (i = 0; i < num; i++) {
3781 w = snd_soc_dapm_new_control_unlocked(dapm, widget);
3782 if (IS_ERR(w)) {
3783 ret = PTR_ERR(w);
3784 break;
3785 }
3786 widget++;
3787 }
3788 mutex_unlock(&dapm->card->dapm_mutex);
3789 return ret;
3790}
3791EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
3792
3793static int
3794snd_soc_dai_link_event_pre_pmu(struct snd_soc_dapm_widget *w,
3795 struct snd_pcm_substream *substream)
3796{
3797 struct snd_soc_dapm_path *path;
3798 struct snd_soc_dai *source, *sink;
3799 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
3800 struct snd_pcm_hw_params *params = NULL;
3801 const struct snd_soc_pcm_stream *config = NULL;
3802 struct snd_pcm_runtime *runtime = NULL;
3803 unsigned int fmt;
3804 int ret = 0;
3805
3806 params = kzalloc(sizeof(*params), GFP_KERNEL);
3807 if (!params)
3808 return -ENOMEM;
3809
3810 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);
3811 if (!runtime) {
3812 ret = -ENOMEM;
3813 goto out;
3814 }
3815
3816 substream->runtime = runtime;
3817
3818 substream->stream = SNDRV_PCM_STREAM_CAPTURE;
3819 snd_soc_dapm_widget_for_each_source_path(w, path) {
3820 source = path->source->priv;
3821
3822 ret = snd_soc_dai_startup(source, substream);
3823 if (ret < 0) {
3824 dev_err(source->dev,
3825 "ASoC: startup() failed: %d\n", ret);
3826 goto out;
3827 }
3828 snd_soc_dai_activate(source, substream->stream);
3829 }
3830
3831 substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
3832 snd_soc_dapm_widget_for_each_sink_path(w, path) {
3833 sink = path->sink->priv;
3834
3835 ret = snd_soc_dai_startup(sink, substream);
3836 if (ret < 0) {
3837 dev_err(sink->dev,
3838 "ASoC: startup() failed: %d\n", ret);
3839 goto out;
3840 }
3841 snd_soc_dai_activate(sink, substream->stream);
3842 }
3843
3844 substream->hw_opened = 1;
3845
3846
3847
3848
3849
3850
3851 config = rtd->dai_link->params + rtd->params_select;
3852 if (WARN_ON(!config)) {
3853 dev_err(w->dapm->dev, "ASoC: link config missing\n");
3854 ret = -EINVAL;
3855 goto out;
3856 }
3857
3858
3859 if (config->formats) {
3860 fmt = ffs(config->formats) - 1;
3861 } else {
3862 dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n",
3863 config->formats);
3864
3865 ret = -EINVAL;
3866 goto out;
3867 }
3868
3869 snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt);
3870 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min =
3871 config->rate_min;
3872 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max =
3873 config->rate_max;
3874 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min
3875 = config->channels_min;
3876 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max
3877 = config->channels_max;
3878
3879 substream->stream = SNDRV_PCM_STREAM_CAPTURE;
3880 snd_soc_dapm_widget_for_each_source_path(w, path) {
3881 source = path->source->priv;
3882
3883 ret = snd_soc_dai_hw_params(source, substream, params);
3884 if (ret < 0)
3885 goto out;
3886
3887 dapm_update_dai_unlocked(substream, params, source);
3888 }
3889
3890 substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
3891 snd_soc_dapm_widget_for_each_sink_path(w, path) {
3892 sink = path->sink->priv;
3893
3894 ret = snd_soc_dai_hw_params(sink, substream, params);
3895 if (ret < 0)
3896 goto out;
3897
3898 dapm_update_dai_unlocked(substream, params, sink);
3899 }
3900
3901 runtime->format = params_format(params);
3902 runtime->subformat = params_subformat(params);
3903 runtime->channels = params_channels(params);
3904 runtime->rate = params_rate(params);
3905
3906out:
3907 kfree(params);
3908 return ret;
3909}
3910
3911static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w,
3912 struct snd_kcontrol *kcontrol, int event)
3913{
3914 struct snd_soc_dapm_path *path;
3915 struct snd_soc_dai *source, *sink;
3916 struct snd_pcm_substream *substream = w->priv;
3917 int ret = 0, saved_stream = substream->stream;
3918
3919 if (WARN_ON(list_empty(&w->edges[SND_SOC_DAPM_DIR_OUT]) ||
3920 list_empty(&w->edges[SND_SOC_DAPM_DIR_IN])))
3921 return -EINVAL;
3922
3923 switch (event) {
3924 case SND_SOC_DAPM_PRE_PMU:
3925 ret = snd_soc_dai_link_event_pre_pmu(w, substream);
3926 if (ret < 0)
3927 goto out;
3928
3929 break;
3930
3931 case SND_SOC_DAPM_POST_PMU:
3932 snd_soc_dapm_widget_for_each_sink_path(w, path) {
3933 sink = path->sink->priv;
3934
3935 ret = snd_soc_dai_digital_mute(sink, 0,
3936 SNDRV_PCM_STREAM_PLAYBACK);
3937 if (ret != 0 && ret != -ENOTSUPP)
3938 dev_warn(sink->dev,
3939 "ASoC: Failed to unmute: %d\n", ret);
3940 ret = 0;
3941 }
3942 break;
3943
3944 case SND_SOC_DAPM_PRE_PMD:
3945 snd_soc_dapm_widget_for_each_sink_path(w, path) {
3946 sink = path->sink->priv;
3947
3948 ret = snd_soc_dai_digital_mute(sink, 1,
3949 SNDRV_PCM_STREAM_PLAYBACK);
3950 if (ret != 0 && ret != -ENOTSUPP)
3951 dev_warn(sink->dev,
3952 "ASoC: Failed to mute: %d\n", ret);
3953 ret = 0;
3954 }
3955
3956 substream->stream = SNDRV_PCM_STREAM_CAPTURE;
3957 snd_soc_dapm_widget_for_each_source_path(w, path) {
3958 source = path->source->priv;
3959 snd_soc_dai_hw_free(source, substream, 0);
3960 }
3961
3962 substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
3963 snd_soc_dapm_widget_for_each_sink_path(w, path) {
3964 sink = path->sink->priv;
3965 snd_soc_dai_hw_free(sink, substream, 0);
3966 }
3967
3968 substream->stream = SNDRV_PCM_STREAM_CAPTURE;
3969 snd_soc_dapm_widget_for_each_source_path(w, path) {
3970 source = path->source->priv;
3971 snd_soc_dai_deactivate(source, substream->stream);
3972 snd_soc_dai_shutdown(source, substream, 0);
3973 }
3974
3975 substream->stream = SNDRV_PCM_STREAM_PLAYBACK;
3976 snd_soc_dapm_widget_for_each_sink_path(w, path) {
3977 sink = path->sink->priv;
3978 snd_soc_dai_deactivate(sink, substream->stream);
3979 snd_soc_dai_shutdown(sink, substream, 0);
3980 }
3981 break;
3982
3983 case SND_SOC_DAPM_POST_PMD:
3984 kfree(substream->runtime);
3985 break;
3986
3987 default:
3988 WARN(1, "Unknown event %d\n", event);
3989 ret = -EINVAL;
3990 }
3991
3992out:
3993
3994 substream->stream = saved_stream;
3995 return ret;
3996}
3997
3998static int snd_soc_dapm_dai_link_get(struct snd_kcontrol *kcontrol,
3999 struct snd_ctl_elem_value *ucontrol)
4000{
4001 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
4002 struct snd_soc_pcm_runtime *rtd = w->priv;
4003
4004 ucontrol->value.enumerated.item[0] = rtd->params_select;
4005
4006 return 0;
4007}
4008
4009static int snd_soc_dapm_dai_link_put(struct snd_kcontrol *kcontrol,
4010 struct snd_ctl_elem_value *ucontrol)
4011{
4012 struct snd_soc_dapm_widget *w = snd_kcontrol_chip(kcontrol);
4013 struct snd_soc_pcm_runtime *rtd = w->priv;
4014
4015
4016 if (w->power)
4017 return -EBUSY;
4018
4019 if (ucontrol->value.enumerated.item[0] == rtd->params_select)
4020 return 0;
4021
4022 if (ucontrol->value.enumerated.item[0] >= rtd->dai_link->num_params)
4023 return -EINVAL;
4024
4025 rtd->params_select = ucontrol->value.enumerated.item[0];
4026
4027 return 0;
4028}
4029
4030static void
4031snd_soc_dapm_free_kcontrol(struct snd_soc_card *card,
4032 unsigned long *private_value,
4033 int num_params,
4034 const char **w_param_text)
4035{
4036 int count;
4037
4038 devm_kfree(card->dev, (void *)*private_value);
4039
4040 if (!w_param_text)
4041 return;
4042
4043 for (count = 0 ; count < num_params; count++)
4044 devm_kfree(card->dev, (void *)w_param_text[count]);
4045 devm_kfree(card->dev, w_param_text);
4046}
4047
4048static struct snd_kcontrol_new *
4049snd_soc_dapm_alloc_kcontrol(struct snd_soc_card *card,
4050 char *link_name,
4051 const struct snd_soc_pcm_stream *params,
4052 int num_params, const char **w_param_text,
4053 unsigned long *private_value)
4054{
4055 struct soc_enum w_param_enum[] = {
4056 SOC_ENUM_SINGLE(0, 0, 0, NULL),
4057 };
4058 struct snd_kcontrol_new kcontrol_dai_link[] = {
4059 SOC_ENUM_EXT(NULL, w_param_enum[0],
4060 snd_soc_dapm_dai_link_get,
4061 snd_soc_dapm_dai_link_put),
4062 };
4063 struct snd_kcontrol_new *kcontrol_news;
4064 const struct snd_soc_pcm_stream *config = params;
4065 int count;
4066
4067 for (count = 0 ; count < num_params; count++) {
4068 if (!config->stream_name) {
4069 dev_warn(card->dapm.dev,
4070 "ASoC: anonymous config %d for dai link %s\n",
4071 count, link_name);
4072 w_param_text[count] =
4073 devm_kasprintf(card->dev, GFP_KERNEL,
4074 "Anonymous Configuration %d",
4075 count);
4076 } else {
4077 w_param_text[count] = devm_kmemdup(card->dev,
4078 config->stream_name,
4079 strlen(config->stream_name) + 1,
4080 GFP_KERNEL);
4081 }
4082 if (!w_param_text[count])
4083 goto outfree_w_param;
4084 config++;
4085 }
4086
4087 w_param_enum[0].items = num_params;
4088 w_param_enum[0].texts = w_param_text;
4089
4090 *private_value =
4091 (unsigned long) devm_kmemdup(card->dev,
4092 (void *)(kcontrol_dai_link[0].private_value),
4093 sizeof(struct soc_enum), GFP_KERNEL);
4094 if (!*private_value) {
4095 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
4096 link_name);
4097 goto outfree_w_param;
4098 }
4099 kcontrol_dai_link[0].private_value = *private_value;
4100
4101 kcontrol_news = devm_kmemdup(card->dev, &kcontrol_dai_link[0],
4102 sizeof(struct snd_kcontrol_new),
4103 GFP_KERNEL);
4104 if (!kcontrol_news) {
4105 dev_err(card->dev, "ASoC: Failed to create control for %s widget\n",
4106 link_name);
4107 goto outfree_w_param;
4108 }
4109 return kcontrol_news;
4110
4111outfree_w_param:
4112 snd_soc_dapm_free_kcontrol(card, private_value, num_params, w_param_text);
4113 return NULL;
4114}
4115
4116static struct snd_soc_dapm_widget *
4117snd_soc_dapm_new_dai(struct snd_soc_card *card,
4118 struct snd_pcm_substream *substream,
4119 char *id)
4120{
4121 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
4122 struct snd_soc_dapm_widget template;
4123 struct snd_soc_dapm_widget *w;
4124 const char **w_param_text;
4125 unsigned long private_value = 0;
4126 char *link_name;
4127 int ret;
4128
4129 link_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s-%s",
4130 rtd->dai_link->name, id);
4131 if (!link_name)
4132 return ERR_PTR(-ENOMEM);
4133
4134 memset(&template, 0, sizeof(template));
4135 template.reg = SND_SOC_NOPM;
4136 template.id = snd_soc_dapm_dai_link;
4137 template.name = link_name;
4138 template.event = snd_soc_dai_link_event;
4139 template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
4140 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD;
4141 template.kcontrol_news = NULL;
4142
4143
4144 if (rtd->dai_link->num_params > 1) {
4145 w_param_text = devm_kcalloc(card->dev,
4146 rtd->dai_link->num_params,
4147 sizeof(char *), GFP_KERNEL);
4148 if (!w_param_text) {
4149 ret = -ENOMEM;
4150 goto param_fail;
4151 }
4152
4153 template.num_kcontrols = 1;
4154 template.kcontrol_news =
4155 snd_soc_dapm_alloc_kcontrol(card,
4156 link_name,
4157 rtd->dai_link->params,
4158 rtd->dai_link->num_params,
4159 w_param_text, &private_value);
4160 if (!template.kcontrol_news) {
4161 ret = -ENOMEM;
4162 goto param_fail;
4163 }
4164 } else {
4165 w_param_text = NULL;
4166 }
4167 dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
4168
4169 w = snd_soc_dapm_new_control_unlocked(&card->dapm, &template);
4170 if (IS_ERR(w)) {
4171 ret = PTR_ERR(w);
4172 dev_err(rtd->dev, "ASoC: Failed to create %s widget: %d\n",
4173 link_name, ret);
4174 goto outfree_kcontrol_news;
4175 }
4176
4177 w->priv = substream;
4178
4179 return w;
4180
4181outfree_kcontrol_news:
4182 devm_kfree(card->dev, (void *)template.kcontrol_news);
4183 snd_soc_dapm_free_kcontrol(card, &private_value,
4184 rtd->dai_link->num_params, w_param_text);
4185param_fail:
4186 devm_kfree(card->dev, link_name);
4187 return ERR_PTR(ret);
4188}
4189
4190int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,
4191 struct snd_soc_dai *dai)
4192{
4193 struct snd_soc_dapm_widget template;
4194 struct snd_soc_dapm_widget *w;
4195
4196 WARN_ON(dapm->dev != dai->dev);
4197
4198 memset(&template, 0, sizeof(template));
4199 template.reg = SND_SOC_NOPM;
4200
4201 if (dai->driver->playback.stream_name) {
4202 template.id = snd_soc_dapm_dai_in;
4203 template.name = dai->driver->playback.stream_name;
4204 template.sname = dai->driver->playback.stream_name;
4205
4206 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
4207 template.name);
4208
4209 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
4210 if (IS_ERR(w))
4211 return PTR_ERR(w);
4212
4213 w->priv = dai;
4214 dai->playback_widget = w;
4215 }
4216
4217 if (dai->driver->capture.stream_name) {
4218 template.id = snd_soc_dapm_dai_out;
4219 template.name = dai->driver->capture.stream_name;
4220 template.sname = dai->driver->capture.stream_name;
4221
4222 dev_dbg(dai->dev, "ASoC: adding %s widget\n",
4223 template.name);
4224
4225 w = snd_soc_dapm_new_control_unlocked(dapm, &template);
4226 if (IS_ERR(w))
4227 return PTR_ERR(w);
4228
4229 w->priv = dai;
4230 dai->capture_widget = w;
4231 }
4232
4233 return 0;
4234}
4235
4236int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card)
4237{
4238 struct snd_soc_dapm_widget *dai_w, *w;
4239 struct snd_soc_dapm_widget *src, *sink;
4240 struct snd_soc_dai *dai;
4241
4242
4243 for_each_card_widgets(card, dai_w) {
4244 switch (dai_w->id) {
4245 case snd_soc_dapm_dai_in:
4246 case snd_soc_dapm_dai_out:
4247 break;
4248 default:
4249 continue;
4250 }
4251
4252
4253 if (!dai_w->priv) {
4254 dev_dbg(card->dev, "dai widget %s has no DAI\n",
4255 dai_w->name);
4256 continue;
4257 }
4258
4259 dai = dai_w->priv;
4260
4261
4262 for_each_card_widgets(card, w) {
4263 if (w->dapm != dai_w->dapm)
4264 continue;
4265
4266 switch (w->id) {
4267 case snd_soc_dapm_dai_in:
4268 case snd_soc_dapm_dai_out:
4269 continue;
4270 default:
4271 break;
4272 }
4273
4274 if (!w->sname || !strstr(w->sname, dai_w->sname))
4275 continue;
4276
4277 if (dai_w->id == snd_soc_dapm_dai_in) {
4278 src = dai_w;
4279 sink = w;
4280 } else {
4281 src = w;
4282 sink = dai_w;
4283 }
4284 dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
4285 snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
4286 }
4287 }
4288
4289 return 0;
4290}
4291
4292static void dapm_connect_dai_routes(struct snd_soc_dapm_context *dapm,
4293 struct snd_soc_dai *src_dai,
4294 struct snd_soc_dapm_widget *src,
4295 struct snd_soc_dapm_widget *dai,
4296 struct snd_soc_dai *sink_dai,
4297 struct snd_soc_dapm_widget *sink)
4298{
4299 dev_dbg(dapm->dev, "connected DAI link %s:%s -> %s:%s\n",
4300 src_dai->component->name, src->name,
4301 sink_dai->component->name, sink->name);
4302
4303 if (dai) {
4304 snd_soc_dapm_add_path(dapm, src, dai, NULL, NULL);
4305 src = dai;
4306 }
4307
4308 snd_soc_dapm_add_path(dapm, src, sink, NULL, NULL);
4309}
4310
4311static void dapm_connect_dai_pair(struct snd_soc_card *card,
4312 struct snd_soc_pcm_runtime *rtd,
4313 struct snd_soc_dai *codec_dai,
4314 struct snd_soc_dai *cpu_dai)
4315{
4316 struct snd_soc_dai_link *dai_link = rtd->dai_link;
4317 struct snd_soc_dapm_widget *dai, *codec, *playback_cpu, *capture_cpu;
4318 struct snd_pcm_substream *substream;
4319 struct snd_pcm_str *streams = rtd->pcm->streams;
4320
4321 if (dai_link->params) {
4322 playback_cpu = cpu_dai->capture_widget;
4323 capture_cpu = cpu_dai->playback_widget;
4324 } else {
4325 playback_cpu = cpu_dai->playback_widget;
4326 capture_cpu = cpu_dai->capture_widget;
4327 }
4328
4329
4330 codec = codec_dai->playback_widget;
4331
4332 if (playback_cpu && codec) {
4333 if (dai_link->params && !rtd->playback_widget) {
4334 substream = streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
4335 dai = snd_soc_dapm_new_dai(card, substream, "playback");
4336 if (IS_ERR(dai))
4337 goto capture;
4338 rtd->playback_widget = dai;
4339 }
4340
4341 dapm_connect_dai_routes(&card->dapm, cpu_dai, playback_cpu,
4342 rtd->playback_widget,
4343 codec_dai, codec);
4344 }
4345
4346capture:
4347
4348 codec = codec_dai->capture_widget;
4349
4350 if (codec && capture_cpu) {
4351 if (dai_link->params && !rtd->capture_widget) {
4352 substream = streams[SNDRV_PCM_STREAM_CAPTURE].substream;
4353 dai = snd_soc_dapm_new_dai(card, substream, "capture");
4354 if (IS_ERR(dai))
4355 return;
4356 rtd->capture_widget = dai;
4357 }
4358
4359 dapm_connect_dai_routes(&card->dapm, codec_dai, codec,
4360 rtd->capture_widget,
4361 cpu_dai, capture_cpu);
4362 }
4363}
4364
4365static void soc_dapm_dai_stream_event(struct snd_soc_dai *dai, int stream,
4366 int event)
4367{
4368 struct snd_soc_dapm_widget *w;
4369 unsigned int ep;
4370
4371 w = snd_soc_dai_get_widget(dai, stream);
4372
4373 if (w) {
4374 dapm_mark_dirty(w, "stream event");
4375
4376 if (w->id == snd_soc_dapm_dai_in) {
4377 ep = SND_SOC_DAPM_EP_SOURCE;
4378 dapm_widget_invalidate_input_paths(w);
4379 } else {
4380 ep = SND_SOC_DAPM_EP_SINK;
4381 dapm_widget_invalidate_output_paths(w);
4382 }
4383
4384 switch (event) {
4385 case SND_SOC_DAPM_STREAM_START:
4386 w->active = 1;
4387 w->is_ep = ep;
4388 break;
4389 case SND_SOC_DAPM_STREAM_STOP:
4390 w->active = 0;
4391 w->is_ep = 0;
4392 break;
4393 case SND_SOC_DAPM_STREAM_SUSPEND:
4394 case SND_SOC_DAPM_STREAM_RESUME:
4395 case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
4396 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
4397 break;
4398 }
4399 }
4400}
4401
4402void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card)
4403{
4404 struct snd_soc_pcm_runtime *rtd;
4405 struct snd_soc_dai *codec_dai;
4406 int i;
4407
4408
4409 for_each_card_rtds(card, rtd) {
4410
4411
4412
4413
4414 if (rtd->dai_link->dynamic)
4415 continue;
4416
4417 if (rtd->num_cpus == 1) {
4418 for_each_rtd_codec_dais(rtd, i, codec_dai)
4419 dapm_connect_dai_pair(card, rtd, codec_dai,
4420 asoc_rtd_to_cpu(rtd, 0));
4421 } else if (rtd->num_codecs == rtd->num_cpus) {
4422 for_each_rtd_codec_dais(rtd, i, codec_dai)
4423 dapm_connect_dai_pair(card, rtd, codec_dai,
4424 asoc_rtd_to_cpu(rtd, i));
4425 } else {
4426 dev_err(card->dev,
4427 "N cpus to M codecs link is not supported yet\n");
4428 }
4429 }
4430}
4431
4432static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
4433 int event)
4434{
4435 struct snd_soc_dai *dai;
4436 int i;
4437
4438 for_each_rtd_dais(rtd, i, dai)
4439 soc_dapm_dai_stream_event(dai, stream, event);
4440
4441 dapm_power_widgets(rtd->card, event);
4442}
4443
4444
4445
4446
4447
4448
4449
4450
4451
4452
4453
4454
4455void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream,
4456 int event)
4457{
4458 struct snd_soc_card *card = rtd->card;
4459
4460 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4461 soc_dapm_stream_event(rtd, stream, event);
4462 mutex_unlock(&card->dapm_mutex);
4463}
4464
4465void snd_soc_dapm_stream_stop(struct snd_soc_pcm_runtime *rtd, int stream)
4466{
4467 if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
4468 if (snd_soc_runtime_ignore_pmdown_time(rtd)) {
4469
4470 snd_soc_dapm_stream_event(rtd,
4471 SNDRV_PCM_STREAM_PLAYBACK,
4472 SND_SOC_DAPM_STREAM_STOP);
4473 } else {
4474
4475 rtd->pop_wait = 1;
4476 queue_delayed_work(system_power_efficient_wq,
4477 &rtd->delayed_work,
4478 msecs_to_jiffies(rtd->pmdown_time));
4479 }
4480 } else {
4481
4482 snd_soc_dapm_stream_event(rtd, SNDRV_PCM_STREAM_CAPTURE,
4483 SND_SOC_DAPM_STREAM_STOP);
4484 }
4485}
4486EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_stop);
4487
4488
4489
4490
4491
4492
4493
4494
4495
4496
4497
4498
4499
4500
4501int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4502 const char *pin)
4503{
4504 return snd_soc_dapm_set_pin(dapm, pin, 1);
4505}
4506EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked);
4507
4508
4509
4510
4511
4512
4513
4514
4515
4516
4517
4518
4519int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
4520{
4521 int ret;
4522
4523 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4524
4525 ret = snd_soc_dapm_set_pin(dapm, pin, 1);
4526
4527 mutex_unlock(&dapm->card->dapm_mutex);
4528
4529 return ret;
4530}
4531EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
4532
4533
4534
4535
4536
4537
4538
4539
4540
4541
4542
4543
4544
4545
4546
4547int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4548 const char *pin)
4549{
4550 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4551
4552 if (!w) {
4553 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4554 return -EINVAL;
4555 }
4556
4557 dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
4558 if (!w->connected) {
4559
4560
4561
4562
4563 dapm_widget_invalidate_input_paths(w);
4564 dapm_widget_invalidate_output_paths(w);
4565 w->connected = 1;
4566 }
4567 w->force = 1;
4568 dapm_mark_dirty(w, "force enable");
4569
4570 return 0;
4571}
4572EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked);
4573
4574
4575
4576
4577
4578
4579
4580
4581
4582
4583
4584
4585
4586int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
4587 const char *pin)
4588{
4589 int ret;
4590
4591 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4592
4593 ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin);
4594
4595 mutex_unlock(&dapm->card->dapm_mutex);
4596
4597 return ret;
4598}
4599EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
4600
4601
4602
4603
4604
4605
4606
4607
4608
4609
4610
4611
4612
4613int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm,
4614 const char *pin)
4615{
4616 return snd_soc_dapm_set_pin(dapm, pin, 0);
4617}
4618EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked);
4619
4620
4621
4622
4623
4624
4625
4626
4627
4628
4629
4630int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
4631 const char *pin)
4632{
4633 int ret;
4634
4635 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4636
4637 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4638
4639 mutex_unlock(&dapm->card->dapm_mutex);
4640
4641 return ret;
4642}
4643EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
4644
4645
4646
4647
4648
4649
4650
4651
4652
4653
4654
4655
4656
4657
4658
4659
4660
4661int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm,
4662 const char *pin)
4663{
4664 return snd_soc_dapm_set_pin(dapm, pin, 0);
4665}
4666EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked);
4667
4668
4669
4670
4671
4672
4673
4674
4675
4676
4677
4678
4679
4680
4681
4682int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
4683{
4684 int ret;
4685
4686 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
4687
4688 ret = snd_soc_dapm_set_pin(dapm, pin, 0);
4689
4690 mutex_unlock(&dapm->card->dapm_mutex);
4691
4692 return ret;
4693}
4694EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
4695
4696
4697
4698
4699
4700
4701
4702
4703
4704
4705int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
4706 const char *pin)
4707{
4708 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
4709
4710 if (w)
4711 return w->connected;
4712
4713 return 0;
4714}
4715EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
4716
4717
4718
4719
4720
4721
4722
4723
4724
4725
4726
4727
4728int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
4729 const char *pin)
4730{
4731 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
4732
4733 if (!w) {
4734 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
4735 return -EINVAL;
4736 }
4737
4738 w->ignore_suspend = 1;
4739
4740 return 0;
4741}
4742EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
4743
4744
4745
4746
4747
4748
4749
4750void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
4751{
4752 dapm_debugfs_cleanup(dapm);
4753 dapm_free_widgets(dapm);
4754 list_del(&dapm->list);
4755}
4756EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
4757
4758void snd_soc_dapm_init(struct snd_soc_dapm_context *dapm,
4759 struct snd_soc_card *card,
4760 struct snd_soc_component *component)
4761{
4762 dapm->card = card;
4763 dapm->component = component;
4764 dapm->bias_level = SND_SOC_BIAS_OFF;
4765
4766 if (component) {
4767 dapm->dev = component->dev;
4768 dapm->idle_bias_off = !component->driver->idle_bias_on;
4769 dapm->suspend_bias_off = component->driver->suspend_bias_off;
4770 } else {
4771 dapm->dev = card->dev;
4772 }
4773
4774 INIT_LIST_HEAD(&dapm->list);
4775
4776 list_add(&dapm->list, &card->dapm_list);
4777}
4778EXPORT_SYMBOL_GPL(snd_soc_dapm_init);
4779
4780static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm)
4781{
4782 struct snd_soc_card *card = dapm->card;
4783 struct snd_soc_dapm_widget *w;
4784 LIST_HEAD(down_list);
4785 int powerdown = 0;
4786
4787 mutex_lock(&card->dapm_mutex);
4788
4789 for_each_card_widgets(dapm->card, w) {
4790 if (w->dapm != dapm)
4791 continue;
4792 if (w->power) {
4793 dapm_seq_insert(w, &down_list, false);
4794 w->new_power = 0;
4795 powerdown = 1;
4796 }
4797 }
4798
4799
4800
4801
4802 if (powerdown) {
4803 if (dapm->bias_level == SND_SOC_BIAS_ON)
4804 snd_soc_dapm_set_bias_level(dapm,
4805 SND_SOC_BIAS_PREPARE);
4806 dapm_seq_run(card, &down_list, 0, false);
4807 if (dapm->bias_level == SND_SOC_BIAS_PREPARE)
4808 snd_soc_dapm_set_bias_level(dapm,
4809 SND_SOC_BIAS_STANDBY);
4810 }
4811
4812 mutex_unlock(&card->dapm_mutex);
4813}
4814
4815
4816
4817
4818void snd_soc_dapm_shutdown(struct snd_soc_card *card)
4819{
4820 struct snd_soc_dapm_context *dapm;
4821
4822 for_each_card_dapms(card, dapm) {
4823 if (dapm != &card->dapm) {
4824 soc_dapm_shutdown_dapm(dapm);
4825 if (dapm->bias_level == SND_SOC_BIAS_STANDBY)
4826 snd_soc_dapm_set_bias_level(dapm,
4827 SND_SOC_BIAS_OFF);
4828 }
4829 }
4830
4831 soc_dapm_shutdown_dapm(&card->dapm);
4832 if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY)
4833 snd_soc_dapm_set_bias_level(&card->dapm,
4834 SND_SOC_BIAS_OFF);
4835}
4836
4837
4838MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
4839MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC");
4840MODULE_LICENSE("GPL");
4841