← Back to branch summary

~ubuntu-branches/ubuntu/precise/alsa-driver/precise

« back to all changes in this revision

Viewing changes to alsa-kernel/soc/soc-dapm.c

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich
  • Date: 2011-02-21 18:06:40 UTC
  • mfrom: (1.1.15 upstream)
  • Revision ID: james.westby@ubuntu.com-20110221180640-a8p2yxtvgf7xbxub
Tags: 1.0.24+dfsg-0ubuntu1
* New upstream release
* Refreshed patches:
  - distinguish_kernel_makefile_and_source_dirs.patch
  - debian_dfsg_configure.patch
* debian/control: Update Vcs-bzr field to point to new branch location

Show diffs side-by-side

added added

removed removed

Lines of Context:
alsa-kernel/soc/soc-dapm.c
42
42
#include <sound/core.h>
43
43
#include <sound/pcm.h>
44
44
#include <sound/pcm_params.h>
45
 
#include <sound/soc-dapm.h>
 
45
#include <sound/soc.h>
46
46
#include <sound/initval.h>
47
47
 
 
48
#include <trace/events/asoc.h>
 
49
 
48
50
/* dapm power sequences - make this per codec in the future */
49
51
static int dapm_up_seq[] = {
50
52
        [snd_soc_dapm_pre] = 0,
54
56
        [snd_soc_dapm_aif_out] = 3,
55
57
        [snd_soc_dapm_mic] = 4,
56
58
        [snd_soc_dapm_mux] = 5,
 
59
        [snd_soc_dapm_virt_mux] = 5,
57
60
        [snd_soc_dapm_value_mux] = 5,
58
61
        [snd_soc_dapm_dac] = 6,
59
62
        [snd_soc_dapm_mixer] = 7,
60
63
        [snd_soc_dapm_mixer_named_ctl] = 7,
61
64
        [snd_soc_dapm_pga] = 8,
62
65
        [snd_soc_dapm_adc] = 9,
 
66
        [snd_soc_dapm_out_drv] = 10,
63
67
        [snd_soc_dapm_hp] = 10,
64
68
        [snd_soc_dapm_spk] = 10,
65
69
        [snd_soc_dapm_post] = 11,
70
74
        [snd_soc_dapm_adc] = 1,
71
75
        [snd_soc_dapm_hp] = 2,
72
76
        [snd_soc_dapm_spk] = 2,
 
77
        [snd_soc_dapm_out_drv] = 2,
73
78
        [snd_soc_dapm_pga] = 4,
74
79
        [snd_soc_dapm_mixer_named_ctl] = 5,
75
80
        [snd_soc_dapm_mixer] = 5,
77
82
        [snd_soc_dapm_mic] = 7,
78
83
        [snd_soc_dapm_micbias] = 8,
79
84
        [snd_soc_dapm_mux] = 9,
 
85
        [snd_soc_dapm_virt_mux] = 9,
80
86
        [snd_soc_dapm_value_mux] = 9,
81
87
        [snd_soc_dapm_aif_in] = 10,
82
88
        [snd_soc_dapm_aif_out] = 10,
90
96
                schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time));
91
97
}
92
98
 
93
 
static void pop_dbg(u32 pop_time, const char *fmt, ...)
 
99
static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...)
94
100
{
95
101
        va_list args;
 
102
        char *buf;
 
103
 
 
104
        if (!pop_time)
 
105
                return;
 
106
 
 
107
        buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
 
108
        if (buf == NULL)
 
109
                return;
96
110
 
97
111
        va_start(args, fmt);
98
 
 
99
 
        if (pop_time) {
100
 
                vprintk(fmt, args);
101
 
        }
102
 
 
 
112
        vsnprintf(buf, PAGE_SIZE, fmt, args);
 
113
        dev_info(dev, "%s", buf);
103
114
        va_end(args);
 
115
 
 
116
        kfree(buf);
104
117
}
105
118
 
106
119
/* create a new dapm widget */
112
125
 
113
126
/**
114
127
 * snd_soc_dapm_set_bias_level - set the bias level for the system
115
 
 * @socdev: audio device
 
128
 * @card: audio device
116
129
 * @level: level to configure
117
130
 *
118
131
 * Configure the bias (power) levels for the SoC audio device.
119
132
 *
120
133
 * Returns 0 for success else error.
121
134
 */
122
 
static int snd_soc_dapm_set_bias_level(struct snd_soc_device *socdev,
 
135
static int snd_soc_dapm_set_bias_level(struct snd_soc_card *card,
 
136
                                       struct snd_soc_dapm_context *dapm,
123
137
                                       enum snd_soc_bias_level level)
124
138
{
125
 
        struct snd_soc_card *card = socdev->card;
126
 
        struct snd_soc_codec *codec = socdev->card->codec;
127
139
        int ret = 0;
128
140
 
129
141
        switch (level) {
130
142
        case SND_SOC_BIAS_ON:
131
 
                dev_dbg(socdev->dev, "Setting full bias\n");
 
143
                dev_dbg(dapm->dev, "Setting full bias\n");
132
144
                break;
133
145
        case SND_SOC_BIAS_PREPARE:
134
 
                dev_dbg(socdev->dev, "Setting bias prepare\n");
 
146
                dev_dbg(dapm->dev, "Setting bias prepare\n");
135
147
                break;
136
148
        case SND_SOC_BIAS_STANDBY:
137
 
                dev_dbg(socdev->dev, "Setting standby bias\n");
 
149
                dev_dbg(dapm->dev, "Setting standby bias\n");
138
150
                break;
139
151
        case SND_SOC_BIAS_OFF:
140
 
                dev_dbg(socdev->dev, "Setting bias off\n");
 
152
                dev_dbg(dapm->dev, "Setting bias off\n");
141
153
                break;
142
154
        default:
143
 
                dev_err(socdev->dev, "Setting invalid bias %d\n", level);
 
155
                dev_err(dapm->dev, "Setting invalid bias %d\n", level);
144
156
                return -EINVAL;
145
157
        }
146
158
 
147
 
        if (card->set_bias_level)
 
159
        trace_snd_soc_bias_level_start(card, level);
 
160
 
 
161
        if (card && card->set_bias_level)
148
162
                ret = card->set_bias_level(card, level);
149
163
        if (ret == 0) {
150
 
                if (codec->set_bias_level)
151
 
                        ret = codec->set_bias_level(codec, level);
 
164
                if (dapm->codec && dapm->codec->driver->set_bias_level)
 
165
                        ret = dapm->codec->driver->set_bias_level(dapm->codec, level);
152
166
                else
153
 
                        codec->bias_level = level;
154
 
        }
 
167
                        dapm->bias_level = level;
 
168
        }
 
169
        if (ret == 0) {
 
170
                if (card && card->set_bias_level_post)
 
171
                        ret = card->set_bias_level_post(card, level);
 
172
        }
 
173
 
 
174
        trace_snd_soc_bias_level_done(card, level);
155
175
 
156
176
        return ret;
157
177
}
198
218
                }
199
219
        }
200
220
        break;
 
221
        case snd_soc_dapm_virt_mux: {
 
222
                struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value;
 
223
 
 
224
                p->connect = 0;
 
225
                /* since a virtual mux has no backing registers to
 
226
                 * decide which path to connect, it will try to match
 
227
                 * with the first enumeration.  This is to ensure
 
228
                 * that the default mux choice (the first) will be
 
229
                 * correctly powered up during initialization.
 
230
                 */
 
231
                if (!strcmp(p->name, e->texts[0]))
 
232
                        p->connect = 1;
 
233
        }
 
234
        break;
201
235
        case snd_soc_dapm_value_mux: {
202
236
                struct soc_enum *e = (struct soc_enum *)
203
237
                        w->kcontrols[i].private_value;
219
253
        break;
220
254
        /* does not effect routing - always connected */
221
255
        case snd_soc_dapm_pga:
 
256
        case snd_soc_dapm_out_drv:
222
257
        case snd_soc_dapm_output:
223
258
        case snd_soc_dapm_adc:
224
259
        case snd_soc_dapm_input:
243
278
}
244
279
 
245
280
/* connect mux widget to its interconnecting audio paths */
246
 
static int dapm_connect_mux(struct snd_soc_codec *codec,
 
281
static int dapm_connect_mux(struct snd_soc_dapm_context *dapm,
247
282
        struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
248
283
        struct snd_soc_dapm_path *path, const char *control_name,
249
284
        const struct snd_kcontrol_new *kcontrol)
253
288
 
254
289
        for (i = 0; i < e->max; i++) {
255
290
                if (!(strcmp(control_name, e->texts[i]))) {
256
 
                        list_add(&path->list, &codec->dapm_paths);
 
291
                        list_add(&path->list, &dapm->card->paths);
257
292
                        list_add(&path->list_sink, &dest->sources);
258
293
                        list_add(&path->list_source, &src->sinks);
259
294
                        path->name = (char*)e->texts[i];
266
301
}
267
302
 
268
303
/* connect mixer widget to its interconnecting audio paths */
269
 
static int dapm_connect_mixer(struct snd_soc_codec *codec,
 
304
static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm,
270
305
        struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest,
271
306
        struct snd_soc_dapm_path *path, const char *control_name)
272
307
{
275
310
        /* search for mixer kcontrol */
276
311
        for (i = 0; i < dest->num_kcontrols; i++) {
277
312
                if (!strcmp(control_name, dest->kcontrols[i].name)) {
278
 
                        list_add(&path->list, &codec->dapm_paths);
 
313
                        list_add(&path->list, &dapm->card->paths);
279
314
                        list_add(&path->list_sink, &dest->sources);
280
315
                        list_add(&path->list_source, &src->sinks);
281
316
                        path->name = dest->kcontrols[i].name;
292
327
        int change, power;
293
328
        unsigned int old, new;
294
329
        struct snd_soc_codec *codec = widget->codec;
 
330
        struct snd_soc_dapm_context *dapm = widget->dapm;
 
331
        struct snd_soc_card *card = dapm->card;
295
332
 
296
333
        /* check for valid widgets */
297
334
        if (widget->reg < 0 || widget->id == snd_soc_dapm_input ||
311
348
 
312
349
        change = old != new;
313
350
        if (change) {
314
 
                pop_dbg(codec->pop_time, "pop test %s : %s in %d ms\n",
 
351
                pop_dbg(dapm->dev, card->pop_time,
 
352
                        "pop test %s : %s in %d ms\n",
315
353
                        widget->name, widget->power ? "on" : "off",
316
 
                        codec->pop_time);
317
 
                pop_wait(codec->pop_time);
 
354
                        card->pop_time);
 
355
                pop_wait(card->pop_time);
318
356
                snd_soc_write(codec, widget->reg, new);
319
357
        }
320
 
        pr_debug("reg %x old %x new %x change %d\n", widget->reg,
321
 
                 old, new, change);
 
358
        dev_dbg(dapm->dev, "reg %x old %x new %x change %d\n", widget->reg,
 
359
                old, new, change);
322
360
        return change;
323
361
}
324
362
 
325
363
/* create new dapm mixer control */
326
 
static int dapm_new_mixer(struct snd_soc_codec *codec,
 
364
static int dapm_new_mixer(struct snd_soc_dapm_context *dapm,
327
365
        struct snd_soc_dapm_widget *w)
328
366
{
329
367
        int i, ret = 0;
330
368
        size_t name_len;
331
369
        struct snd_soc_dapm_path *path;
 
370
        struct snd_card *card = dapm->codec->card->snd_card;
332
371
 
333
372
        /* add kcontrol */
334
373
        for (i = 0; i < w->num_kcontrols; i++) {
370
409
 
371
410
                        path->kcontrol = snd_soc_cnew(&w->kcontrols[i], w,
372
411
                                path->long_name);
373
 
                        ret = snd_ctl_add(codec->card, path->kcontrol);
 
412
                        ret = snd_ctl_add(card, path->kcontrol);
374
413
                        if (ret < 0) {
375
 
                                printk(KERN_ERR "asoc: failed to add dapm kcontrol %s: %d\n",
376
 
                                       path->long_name,
377
 
                                       ret);
 
414
                                dev_err(dapm->dev,
 
415
                                        "asoc: failed to add dapm kcontrol %s: %d\n",
 
416
                                        path->long_name, ret);
378
417
                                kfree(path->long_name);
379
418
                                path->long_name = NULL;
380
419
                                return ret;
385
424
}
386
425
 
387
426
/* create new dapm mux control */
388
 
static int dapm_new_mux(struct snd_soc_codec *codec,
 
427
static int dapm_new_mux(struct snd_soc_dapm_context *dapm,
389
428
        struct snd_soc_dapm_widget *w)
390
429
{
391
430
        struct snd_soc_dapm_path *path = NULL;
392
431
        struct snd_kcontrol *kcontrol;
 
432
        struct snd_card *card = dapm->codec->card->snd_card;
393
433
        int ret = 0;
394
434
 
395
435
        if (!w->num_kcontrols) {
396
 
                printk(KERN_ERR "asoc: mux %s has no controls\n", w->name);
 
436
                dev_err(dapm->dev, "asoc: mux %s has no controls\n", w->name);
397
437
                return -EINVAL;
398
438
        }
399
439
 
400
440
        kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name);
401
 
        ret = snd_ctl_add(codec->card, kcontrol);
 
441
        ret = snd_ctl_add(card, kcontrol);
 
442
 
402
443
        if (ret < 0)
403
444
                goto err;
404
445
 
408
449
        return ret;
409
450
 
410
451
err:
411
 
        printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name);
 
452
        dev_err(dapm->dev, "asoc: failed to add kcontrol %s\n", w->name);
412
453
        return ret;
413
454
}
414
455
 
415
456
/* create new dapm volume control */
416
 
static int dapm_new_pga(struct snd_soc_codec *codec,
 
457
static int dapm_new_pga(struct snd_soc_dapm_context *dapm,
417
458
        struct snd_soc_dapm_widget *w)
418
459
{
419
460
        if (w->num_kcontrols)
420
 
                pr_err("asoc: PGA controls not supported: '%s'\n", w->name);
 
461
                dev_err(w->dapm->dev,
 
462
                        "asoc: PGA controls not supported: '%s'\n", w->name);
421
463
 
422
464
        return 0;
423
465
}
424
466
 
425
467
/* reset 'walked' bit for each dapm path */
426
 
static inline void dapm_clear_walk(struct snd_soc_codec *codec)
 
468
static inline void dapm_clear_walk(struct snd_soc_dapm_context *dapm)
427
469
{
428
470
        struct snd_soc_dapm_path *p;
429
471
 
430
 
        list_for_each_entry(p, &codec->dapm_paths, list)
 
472
        list_for_each_entry(p, &dapm->card->paths, list)
431
473
                p->walked = 0;
432
474
}
433
475
 
 
476
/* We implement power down on suspend by checking the power state of
 
477
 * the ALSA card - when we are suspending the ALSA state for the card
 
478
 * is set to D3.
 
479
 */
 
480
static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget)
 
481
{
 
482
        int level = snd_power_get_state(widget->dapm->codec->card->snd_card);
 
483
 
 
484
        switch (level) {
 
485
        case SNDRV_CTL_POWER_D3hot:
 
486
        case SNDRV_CTL_POWER_D3cold:
 
487
                if (widget->ignore_suspend)
 
488
                        dev_dbg(widget->dapm->dev, "%s ignoring suspend\n",
 
489
                                widget->name);
 
490
                return widget->ignore_suspend;
 
491
        default:
 
492
                return 1;
 
493
        }
 
494
}
 
495
 
434
496
/*
435
497
 * Recursively check for a completed path to an active or physically connected
436
498
 * output widget. Returns number of complete paths.
447
509
        case snd_soc_dapm_adc:
448
510
        case snd_soc_dapm_aif_out:
449
511
                if (widget->active)
450
 
                        return 1;
 
512
                        return snd_soc_dapm_suspend_check(widget);
451
513
        default:
452
514
                break;
453
515
        }
455
517
        if (widget->connected) {
456
518
                /* connected pin ? */
457
519
                if (widget->id == snd_soc_dapm_output && !widget->ext)
458
 
                        return 1;
 
520
                        return snd_soc_dapm_suspend_check(widget);
459
521
 
460
522
                /* connected jack or spk ? */
461
523
                if (widget->id == snd_soc_dapm_hp || widget->id == snd_soc_dapm_spk ||
462
524
                    (widget->id == snd_soc_dapm_line && !list_empty(&widget->sources)))
463
 
                        return 1;
 
525
                        return snd_soc_dapm_suspend_check(widget);
464
526
        }
465
527
 
466
528
        list_for_each_entry(path, &widget->sinks, list_source) {
493
555
        case snd_soc_dapm_dac:
494
556
        case snd_soc_dapm_aif_in:
495
557
                if (widget->active)
496
 
                        return 1;
 
558
                        return snd_soc_dapm_suspend_check(widget);
497
559
        default:
498
560
                break;
499
561
        }
501
563
        if (widget->connected) {
502
564
                /* connected pin ? */
503
565
                if (widget->id == snd_soc_dapm_input && !widget->ext)
504
 
                        return 1;
 
566
                        return snd_soc_dapm_suspend_check(widget);
505
567
 
506
568
                /* connected VMID/Bias for lower pops */
507
569
                if (widget->id == snd_soc_dapm_vmid)
508
 
                        return 1;
 
570
                        return snd_soc_dapm_suspend_check(widget);
509
571
 
510
572
                /* connected jack ? */
511
573
                if (widget->id == snd_soc_dapm_mic ||
512
574
                    (widget->id == snd_soc_dapm_line && !list_empty(&widget->sinks)))
513
 
                        return 1;
 
575
                        return snd_soc_dapm_suspend_check(widget);
514
576
        }
515
577
 
516
578
        list_for_each_entry(path, &widget->sources, list_sink) {
555
617
 
556
618
        /* call any power change event handlers */
557
619
        if (w->event)
558
 
                pr_debug("power %s event for %s flags %x\n",
 
620
                dev_dbg(w->dapm->dev, "power %s event for %s flags %x\n",
559
621
                         w->power ? "on" : "off",
560
622
                         w->name, w->event_flags);
561
623
 
604
666
        int in, out;
605
667
 
606
668
        in = is_connected_input_ep(w);
607
 
        dapm_clear_walk(w->codec);
 
669
        dapm_clear_walk(w->dapm);
608
670
        out = is_connected_output_ep(w);
609
 
        dapm_clear_walk(w->codec);
 
671
        dapm_clear_walk(w->dapm);
610
672
        return out != 0 && in != 0;
611
673
}
612
674
 
617
679
 
618
680
        if (w->active) {
619
681
                in = is_connected_input_ep(w);
620
 
                dapm_clear_walk(w->codec);
 
682
                dapm_clear_walk(w->dapm);
621
683
                return in != 0;
622
684
        } else {
623
685
                return dapm_generic_check_power(w);
631
693
 
632
694
        if (w->active) {
633
695
                out = is_connected_output_ep(w);
634
 
                dapm_clear_walk(w->codec);
 
696
                dapm_clear_walk(w->dapm);
635
697
                return out != 0;
636
698
        } else {
637
699
                return dapm_generic_check_power(w);
657
719
                }
658
720
        }
659
721
 
660
 
        dapm_clear_walk(w->codec);
 
722
        dapm_clear_walk(w->dapm);
661
723
 
662
724
        return power;
663
725
}
666
728
                            struct snd_soc_dapm_widget *b,
667
729
                            int sort[])
668
730
{
669
 
        if (a->codec != b->codec)
670
 
                return (unsigned long)a - (unsigned long)b;
671
731
        if (sort[a->id] != sort[b->id])
672
732
                return sort[a->id] - sort[b->id];
673
733
        if (a->reg != b->reg)
674
734
                return a->reg - b->reg;
 
735
        if (a->dapm != b->dapm)
 
736
                return (unsigned long)a->dapm - (unsigned long)b->dapm;
675
737
 
676
738
        return 0;
677
739
}
692
754
        list_add_tail(&new_widget->power_list, list);
693
755
}
694
756
 
 
757
static void dapm_seq_check_event(struct snd_soc_dapm_context *dapm,
 
758
                                 struct snd_soc_dapm_widget *w, int event)
 
759
{
 
760
        struct snd_soc_card *card = dapm->card;
 
761
        const char *ev_name;
 
762
        int power, ret;
 
763
 
 
764
        switch (event) {
 
765
        case SND_SOC_DAPM_PRE_PMU:
 
766
                ev_name = "PRE_PMU";
 
767
                power = 1;
 
768
                break;
 
769
        case SND_SOC_DAPM_POST_PMU:
 
770
                ev_name = "POST_PMU";
 
771
                power = 1;
 
772
                break;
 
773
        case SND_SOC_DAPM_PRE_PMD:
 
774
                ev_name = "PRE_PMD";
 
775
                power = 0;
 
776
                break;
 
777
        case SND_SOC_DAPM_POST_PMD:
 
778
                ev_name = "POST_PMD";
 
779
                power = 0;
 
780
                break;
 
781
        default:
 
782
                BUG();
 
783
                return;
 
784
        }
 
785
 
 
786
        if (w->power != power)
 
787
                return;
 
788
 
 
789
        if (w->event && (w->event_flags & event)) {
 
790
                pop_dbg(dapm->dev, card->pop_time, "pop test : %s %s\n",
 
791
                        w->name, ev_name);
 
792
                trace_snd_soc_dapm_widget_event_start(w, event);
 
793
                ret = w->event(w, NULL, event);
 
794
                trace_snd_soc_dapm_widget_event_done(w, event);
 
795
                if (ret < 0)
 
796
                        pr_err("%s: %s event failed: %d\n",
 
797
                               ev_name, w->name, ret);
 
798
        }
 
799
}
 
800
 
695
801
/* Apply the coalesced changes from a DAPM sequence */
696
 
static void dapm_seq_run_coalesced(struct snd_soc_codec *codec,
 
802
static void dapm_seq_run_coalesced(struct snd_soc_dapm_context *dapm,
697
803
                                   struct list_head *pending)
698
804
{
 
805
        struct snd_soc_card *card = dapm->card;
699
806
        struct snd_soc_dapm_widget *w;
700
 
        int reg, power, ret;
 
807
        int reg, power;
701
808
        unsigned int value = 0;
702
809
        unsigned int mask = 0;
703
810
        unsigned int cur_mask;
718
825
                if (power)
719
826
                        value |= cur_mask;
720
827
 
721
 
                pop_dbg(codec->pop_time,
 
828
                pop_dbg(dapm->dev, card->pop_time,
722
829
                        "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n",
723
830
                        w->name, reg, value, mask);
724
831
 
725
 
                /* power up pre event */
726
 
                if (w->power && w->event &&
727
 
                    (w->event_flags & SND_SOC_DAPM_PRE_PMU)) {
728
 
                        pop_dbg(codec->pop_time, "pop test : %s PRE_PMU\n",
729
 
                                w->name);
730
 
                        ret = w->event(w, NULL, SND_SOC_DAPM_PRE_PMU);
731
 
                        if (ret < 0)
732
 
                                pr_err("%s: pre event failed: %d\n",
733
 
                                       w->name, ret);
734
 
                }
735
 
 
736
 
                /* power down pre event */
737
 
                if (!w->power && w->event &&
738
 
                    (w->event_flags & SND_SOC_DAPM_PRE_PMD)) {
739
 
                        pop_dbg(codec->pop_time, "pop test : %s PRE_PMD\n",
740
 
                                w->name);
741
 
                        ret = w->event(w, NULL, SND_SOC_DAPM_PRE_PMD);
742
 
                        if (ret < 0)
743
 
                                pr_err("%s: pre event failed: %d\n",
744
 
                                       w->name, ret);
745
 
                }
 
832
                /* Check for events */
 
833
                dapm_seq_check_event(dapm, w, SND_SOC_DAPM_PRE_PMU);
 
834
                dapm_seq_check_event(dapm, w, SND_SOC_DAPM_PRE_PMD);
746
835
        }
747
836
 
748
837
        if (reg >= 0) {
749
 
                pop_dbg(codec->pop_time,
 
838
                pop_dbg(dapm->dev, card->pop_time,
750
839
                        "pop test : Applying 0x%x/0x%x to %x in %dms\n",
751
 
                        value, mask, reg, codec->pop_time);
752
 
                pop_wait(codec->pop_time);
753
 
                snd_soc_update_bits(codec, reg, mask, value);
 
840
                        value, mask, reg, card->pop_time);
 
841
                pop_wait(card->pop_time);
 
842
                snd_soc_update_bits(dapm->codec, reg, mask, value);
754
843
        }
755
844
 
756
845
        list_for_each_entry(w, pending, power_list) {
757
 
                /* power up post event */
758
 
                if (w->power && w->event &&
759
 
                    (w->event_flags & SND_SOC_DAPM_POST_PMU)) {
760
 
                        pop_dbg(codec->pop_time, "pop test : %s POST_PMU\n",
761
 
                                w->name);
762
 
                        ret = w->event(w,
763
 
                                       NULL, SND_SOC_DAPM_POST_PMU);
764
 
                        if (ret < 0)
765
 
                                pr_err("%s: post event failed: %d\n",
766
 
                                       w->name, ret);
767
 
                }
768
 
 
769
 
                /* power down post event */
770
 
                if (!w->power && w->event &&
771
 
                    (w->event_flags & SND_SOC_DAPM_POST_PMD)) {
772
 
                        pop_dbg(codec->pop_time, "pop test : %s POST_PMD\n",
773
 
                                w->name);
774
 
                        ret = w->event(w, NULL, SND_SOC_DAPM_POST_PMD);
775
 
                        if (ret < 0)
776
 
                                pr_err("%s: post event failed: %d\n",
777
 
                                       w->name, ret);
778
 
                }
 
846
                dapm_seq_check_event(dapm, w, SND_SOC_DAPM_POST_PMU);
 
847
                dapm_seq_check_event(dapm, w, SND_SOC_DAPM_POST_PMD);
779
848
        }
780
849
}
781
850
 
787
856
 * Currently anything that requires more than a single write is not
788
857
 * handled.
789
858
 */
790
 
static void dapm_seq_run(struct snd_soc_codec *codec, struct list_head *list,
791
 
                         int event, int sort[])
 
859
static void dapm_seq_run(struct snd_soc_dapm_context *dapm,
 
860
                         struct list_head *list, int event, int sort[])
792
861
{
793
862
        struct snd_soc_dapm_widget *w, *n;
794
863
        LIST_HEAD(pending);
795
864
        int cur_sort = -1;
796
865
        int cur_reg = SND_SOC_NOPM;
 
866
        struct snd_soc_dapm_context *cur_dapm = NULL;
797
867
        int ret;
798
868
 
799
869
        list_for_each_entry_safe(w, n, list, power_list) {
800
870
                ret = 0;
801
871
 
802
872
                /* Do we need to apply any queued changes? */
803
 
                if (sort[w->id] != cur_sort || w->reg != cur_reg) {
 
873
                if (sort[w->id] != cur_sort || w->reg != cur_reg ||
 
874
                    w->dapm != cur_dapm) {
804
875
                        if (!list_empty(&pending))
805
 
                                dapm_seq_run_coalesced(codec, &pending);
 
876
                                dapm_seq_run_coalesced(cur_dapm, &pending);
806
877
 
807
878
                        INIT_LIST_HEAD(&pending);
808
879
                        cur_sort = -1;
809
880
                        cur_reg = SND_SOC_NOPM;
 
881
                        cur_dapm = NULL;
810
882
                }
811
883
 
812
884
                switch (w->id) {
850
922
                        /* Queue it up for application */
851
923
                        cur_sort = sort[w->id];
852
924
                        cur_reg = w->reg;
 
925
                        cur_dapm = w->dapm;
853
926
                        list_move(&w->power_list, &pending);
854
927
                        break;
855
928
                }
856
929
 
857
930
                if (ret < 0)
858
 
                        pr_err("Failed to apply widget power: %d\n",
859
 
                               ret);
 
931
                        dev_err(w->dapm->dev,
 
932
                                "Failed to apply widget power: %d\n", ret);
860
933
        }
861
934
 
862
935
        if (!list_empty(&pending))
863
 
                dapm_seq_run_coalesced(codec, &pending);
864
 
}
 
936
                dapm_seq_run_coalesced(dapm, &pending);
 
937
}
 
938
 
 
939
static void dapm_widget_update(struct snd_soc_dapm_context *dapm)
 
940
{
 
941
        struct snd_soc_dapm_update *update = dapm->update;
 
942
        struct snd_soc_dapm_widget *w;
 
943
        int ret;
 
944
 
 
945
        if (!update)
 
946
                return;
 
947
 
 
948
        w = update->widget;
 
949
 
 
950
        if (w->event &&
 
951
            (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
 
952
                ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
 
953
                if (ret != 0)
 
954
                        pr_err("%s DAPM pre-event failed: %d\n",
 
955
                               w->name, ret);
 
956
        }
 
957
 
 
958
        ret = snd_soc_update_bits(w->codec, update->reg, update->mask,
 
959
                                  update->val);
 
960
        if (ret < 0)
 
961
                pr_err("%s DAPM update failed: %d\n", w->name, ret);
 
962
 
 
963
        if (w->event &&
 
964
            (w->event_flags & SND_SOC_DAPM_POST_REG)) {
 
965
                ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
 
966
                if (ret != 0)
 
967
                        pr_err("%s DAPM post-event failed: %d\n",
 
968
                               w->name, ret);
 
969
        }
 
970
}
 
971
 
 
972
 
865
973
 
866
974
/*
867
975
 * Scan each dapm widget for complete audio path.
872
980
 *  o Input pin to Output pin (bypass, sidetone)
873
981
 *  o DAC to ADC (loopback).
874
982
 */
875
 
static int dapm_power_widgets(struct snd_soc_codec *codec, int event)
 
983
static int dapm_power_widgets(struct snd_soc_dapm_context *dapm, int event)
876
984
{
877
 
        struct snd_soc_device *socdev = codec->socdev;
 
985
        struct snd_soc_card *card = dapm->codec->card;
878
986
        struct snd_soc_dapm_widget *w;
 
987
        struct snd_soc_dapm_context *d;
879
988
        LIST_HEAD(up_list);
880
989
        LIST_HEAD(down_list);
881
990
        int ret = 0;
882
991
        int power;
883
 
        int sys_power = 0;
 
992
 
 
993
        trace_snd_soc_dapm_start(card);
 
994
 
 
995
        list_for_each_entry(d, &card->dapm_list, list)
 
996
                if (d->n_widgets)
 
997
                        d->dev_power = 0;
884
998
 
885
999
        /* Check which widgets we need to power and store them in
886
1000
         * lists indicating if they should be powered up or down.
887
1001
         */
888
 
        list_for_each_entry(w, &codec->dapm_widgets, list) {
 
1002
        list_for_each_entry(w, &card->widgets, list) {
889
1003
                switch (w->id) {
890
1004
                case snd_soc_dapm_pre:
891
1005
                        dapm_seq_insert(w, &down_list, dapm_down_seq);
898
1012
                        if (!w->power_check)
899
1013
                                continue;
900
1014
 
901
 
                        /* If we're suspending then pull down all the 
902
 
                         * power. */
903
 
                        switch (event) {
904
 
                        case SND_SOC_DAPM_STREAM_SUSPEND:
905
 
                                power = 0;
906
 
                                break;
907
 
 
908
 
                        default:
909
 
                                if (!w->force)
910
 
                                        power = w->power_check(w);
911
 
                                else
912
 
                                        power = 1;
913
 
                                if (power)
914
 
                                        sys_power = 1;
915
 
                                break;
916
 
                        }
 
1015
                        if (!w->force)
 
1016
                                power = w->power_check(w);
 
1017
                        else
 
1018
                                power = 1;
 
1019
                        if (power)
 
1020
                                w->dapm->dev_power = 1;
917
1021
 
918
1022
                        if (w->power == power)
919
1023
                                continue;
920
1024
 
 
1025
                        trace_snd_soc_dapm_widget_power(w, power);
 
1026
 
921
1027
                        if (power)
922
1028
                                dapm_seq_insert(w, &up_list, dapm_up_seq);
923
1029
                        else
931
1037
        /* If there are no DAPM widgets then try to figure out power from the
932
1038
         * event type.
933
1039
         */
934
 
        if (list_empty(&codec->dapm_widgets)) {
 
1040
        if (!dapm->n_widgets) {
935
1041
                switch (event) {
936
1042
                case SND_SOC_DAPM_STREAM_START:
937
1043
                case SND_SOC_DAPM_STREAM_RESUME:
938
 
                        sys_power = 1;
 
1044
                        dapm->dev_power = 1;
 
1045
                        break;
 
1046
                case SND_SOC_DAPM_STREAM_STOP:
 
1047
                        dapm->dev_power = !!dapm->codec->active;
939
1048
                        break;
940
1049
                case SND_SOC_DAPM_STREAM_SUSPEND:
941
 
                        sys_power = 0;
 
1050
                        dapm->dev_power = 0;
942
1051
                        break;
943
1052
                case SND_SOC_DAPM_STREAM_NOP:
944
 
                        switch (codec->bias_level) {
 
1053
                        switch (dapm->bias_level) {
945
1054
                                case SND_SOC_BIAS_STANDBY:
946
1055
                                case SND_SOC_BIAS_OFF:
947
 
                                        sys_power = 0;
 
1056
                                        dapm->dev_power = 0;
948
1057
                                        break;
949
1058
                                default:
950
 
                                        sys_power = 1;
 
1059
                                        dapm->dev_power = 1;
951
1060
                                        break;
952
1061
                        }
953
1062
                        break;
956
1065
                }
957
1066
        }
958
1067
 
959
 
        if (sys_power && codec->bias_level == SND_SOC_BIAS_OFF) {
960
 
                ret = snd_soc_dapm_set_bias_level(socdev,
961
 
                                                  SND_SOC_BIAS_STANDBY);
962
 
                if (ret != 0)
963
 
                        pr_err("Failed to turn on bias: %d\n", ret);
964
 
        }
 
1068
        list_for_each_entry(d, &dapm->card->dapm_list, list) {
 
1069
                if (d->dev_power && d->bias_level == SND_SOC_BIAS_OFF) {
 
1070
                        ret = snd_soc_dapm_set_bias_level(card, d,
 
1071
                                                          SND_SOC_BIAS_STANDBY);
 
1072
                        if (ret != 0)
 
1073
                                dev_err(d->dev,
 
1074
                                        "Failed to turn on bias: %d\n", ret);
 
1075
                }
965
1076
 
966
 
        /* If we're changing to all on or all off then prepare */
967
 
        if ((sys_power && codec->bias_level == SND_SOC_BIAS_STANDBY) ||
968
 
            (!sys_power && codec->bias_level == SND_SOC_BIAS_ON)) {
969
 
                ret = snd_soc_dapm_set_bias_level(socdev,
970
 
                                                  SND_SOC_BIAS_PREPARE);
971
 
                if (ret != 0)
972
 
                        pr_err("Failed to prepare bias: %d\n", ret);
 
1077
                /* If we're changing to all on or all off then prepare */
 
1078
                if ((d->dev_power && d->bias_level == SND_SOC_BIAS_STANDBY) ||
 
1079
                    (!d->dev_power && d->bias_level == SND_SOC_BIAS_ON)) {
 
1080
                        ret = snd_soc_dapm_set_bias_level(card, d,
 
1081
                                                          SND_SOC_BIAS_PREPARE);
 
1082
                        if (ret != 0)
 
1083
                                dev_err(d->dev,
 
1084
                                        "Failed to prepare bias: %d\n", ret);
 
1085
                }
973
1086
        }
974
1087
 
975
1088
        /* Power down widgets first; try to avoid amplifying pops. */
976
 
        dapm_seq_run(codec, &down_list, event, dapm_down_seq);
 
1089
        dapm_seq_run(dapm, &down_list, event, dapm_down_seq);
 
1090
 
 
1091
        dapm_widget_update(dapm);
977
1092
 
978
1093
        /* Now power up. */
979
 
        dapm_seq_run(codec, &up_list, event, dapm_up_seq);
980
 
 
981
 
        /* If we just powered the last thing off drop to standby bias */
982
 
        if (codec->bias_level == SND_SOC_BIAS_PREPARE && !sys_power) {
983
 
                ret = snd_soc_dapm_set_bias_level(socdev,
984
 
                                                  SND_SOC_BIAS_STANDBY);
985
 
                if (ret != 0)
986
 
                        pr_err("Failed to apply standby bias: %d\n", ret);
987
 
        }
988
 
 
989
 
        /* If we're in standby and can support bias off then do that */
990
 
        if (codec->bias_level == SND_SOC_BIAS_STANDBY &&
991
 
            codec->idle_bias_off) {
992
 
                ret = snd_soc_dapm_set_bias_level(socdev, SND_SOC_BIAS_OFF);
993
 
                if (ret != 0)
994
 
                        pr_err("Failed to turn off bias: %d\n", ret);
995
 
        }
996
 
 
997
 
        /* If we just powered up then move to active bias */
998
 
        if (codec->bias_level == SND_SOC_BIAS_PREPARE && sys_power) {
999
 
                ret = snd_soc_dapm_set_bias_level(socdev,
1000
 
                                                  SND_SOC_BIAS_ON);
1001
 
                if (ret != 0)
1002
 
                        pr_err("Failed to apply active bias: %d\n", ret);
1003
 
        }
1004
 
 
1005
 
        pop_dbg(codec->pop_time, "DAPM sequencing finished, waiting %dms\n",
1006
 
                codec->pop_time);
1007
 
        pop_wait(codec->pop_time);
 
1094
        dapm_seq_run(dapm, &up_list, event, dapm_up_seq);
 
1095
 
 
1096
        list_for_each_entry(d, &dapm->card->dapm_list, list) {
 
1097
                /* If we just powered the last thing off drop to standby bias */
 
1098
                if (d->bias_level == SND_SOC_BIAS_PREPARE && !d->dev_power) {
 
1099
                        ret = snd_soc_dapm_set_bias_level(card, d,
 
1100
                                                          SND_SOC_BIAS_STANDBY);
 
1101
                        if (ret != 0)
 
1102
                                dev_err(d->dev,
 
1103
                                        "Failed to apply standby bias: %d\n",
 
1104
                                        ret);
 
1105
                }
 
1106
 
 
1107
                /* If we're in standby and can support bias off then do that */
 
1108
                if (d->bias_level == SND_SOC_BIAS_STANDBY &&
 
1109
                    d->idle_bias_off) {
 
1110
                        ret = snd_soc_dapm_set_bias_level(card, d,
 
1111
                                                          SND_SOC_BIAS_OFF);
 
1112
                        if (ret != 0)
 
1113
                                dev_err(d->dev,
 
1114
                                        "Failed to turn off bias: %d\n", ret);
 
1115
                }
 
1116
 
 
1117
                /* If we just powered up then move to active bias */
 
1118
                if (d->bias_level == SND_SOC_BIAS_PREPARE && d->dev_power) {
 
1119
                        ret = snd_soc_dapm_set_bias_level(card, d,
 
1120
                                                          SND_SOC_BIAS_ON);
 
1121
                        if (ret != 0)
 
1122
                                dev_err(d->dev,
 
1123
                                        "Failed to apply active bias: %d\n",
 
1124
                                        ret);
 
1125
                }
 
1126
        }
 
1127
 
 
1128
        pop_dbg(dapm->dev, card->pop_time,
 
1129
                "DAPM sequencing finished, waiting %dms\n", card->pop_time);
 
1130
        pop_wait(card->pop_time);
 
1131
 
 
1132
        trace_snd_soc_dapm_done(card);
1008
1133
 
1009
1134
        return 0;
1010
1135
}
1031
1156
                return -ENOMEM;
1032
1157
 
1033
1158
        in = is_connected_input_ep(w);
1034
 
        dapm_clear_walk(w->codec);
 
1159
        dapm_clear_walk(w->dapm);
1035
1160
        out = is_connected_output_ep(w);
1036
 
        dapm_clear_walk(w->codec);
 
1161
        dapm_clear_walk(w->dapm);
1037
1162
 
1038
1163
        ret = snprintf(buf, PAGE_SIZE, "%s: %s  in %d out %d",
1039
1164
                       w->name, w->power ? "On" : "Off", in, out);
1080
1205
static const struct file_operations dapm_widget_power_fops = {
1081
1206
        .open = dapm_widget_power_open_file,
1082
1207
        .read = dapm_widget_power_read_file,
 
1208
        .llseek = default_llseek,
1083
1209
};
1084
1210
 
1085
 
void snd_soc_dapm_debugfs_init(struct snd_soc_codec *codec)
 
1211
void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm)
1086
1212
{
1087
1213
        struct snd_soc_dapm_widget *w;
1088
1214
        struct dentry *d;
1089
1215
 
1090
 
        if (!codec->debugfs_dapm)
 
1216
        if (!dapm->debugfs_dapm)
1091
1217
                return;
1092
1218
 
1093
 
        list_for_each_entry(w, &codec->dapm_widgets, list) {
1094
 
                if (!w->name)
 
1219
        list_for_each_entry(w, &dapm->card->widgets, list) {
 
1220
                if (!w->name || w->dapm != dapm)
1095
1221
                        continue;
1096
1222
 
1097
1223
                d = debugfs_create_file(w->name, 0444,
1098
 
                                        codec->debugfs_dapm, w,
 
1224
                                        dapm->debugfs_dapm, w,
1099
1225
                                        &dapm_widget_power_fops);
1100
1226
                if (!d)
1101
 
                        printk(KERN_WARNING
1102
 
                               "ASoC: Failed to create %s debugfs file\n",
1103
 
                               w->name);
 
1227
                        dev_warn(w->dapm->dev,
 
1228
                                "ASoC: Failed to create %s debugfs file\n",
 
1229
                                w->name);
1104
1230
        }
1105
1231
}
1106
1232
#else
1107
 
void snd_soc_dapm_debugfs_init(struct snd_soc_codec *codec)
 
1233
void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm)
1108
1234
{
1109
1235
}
1110
1236
#endif
1118
1244
        int found = 0;
1119
1245
 
1120
1246
        if (widget->id != snd_soc_dapm_mux &&
 
1247
            widget->id != snd_soc_dapm_virt_mux &&
1121
1248
            widget->id != snd_soc_dapm_value_mux)
1122
1249
                return -ENODEV;
1123
1250
 
1125
1252
                return 0;
1126
1253
 
1127
1254
        /* find dapm widget path assoc with kcontrol */
1128
 
        list_for_each_entry(path, &widget->codec->dapm_paths, list) {
 
1255
        list_for_each_entry(path, &widget->dapm->card->paths, list) {
1129
1256
                if (path->kcontrol != kcontrol)
1130
1257
                        continue;
1131
1258
 
1141
1268
        }
1142
1269
 
1143
1270
        if (found)
1144
 
                dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
 
1271
                dapm_power_widgets(widget->dapm, SND_SOC_DAPM_STREAM_NOP);
1145
1272
 
1146
1273
        return 0;
1147
1274
}
1159
1286
                return -ENODEV;
1160
1287
 
1161
1288
        /* find dapm widget path assoc with kcontrol */
1162
 
        list_for_each_entry(path, &widget->codec->dapm_paths, list) {
 
1289
        list_for_each_entry(path, &widget->dapm->card->paths, list) {
1163
1290
                if (path->kcontrol != kcontrol)
1164
1291
                        continue;
1165
1292
 
1170
1297
        }
1171
1298
 
1172
1299
        if (found)
1173
 
                dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP);
 
1300
                dapm_power_widgets(widget->dapm, SND_SOC_DAPM_STREAM_NOP);
1174
1301
 
1175
1302
        return 0;
1176
1303
}
1179
1306
static ssize_t dapm_widget_show(struct device *dev,
1180
1307
        struct device_attribute *attr, char *buf)
1181
1308
{
1182
 
        struct snd_soc_device *devdata = dev_get_drvdata(dev);
1183
 
        struct snd_soc_codec *codec = devdata->card->codec;
 
1309
        struct snd_soc_pcm_runtime *rtd =
 
1310
                        container_of(dev, struct snd_soc_pcm_runtime, dev);
 
1311
        struct snd_soc_codec *codec =rtd->codec;
1184
1312
        struct snd_soc_dapm_widget *w;
1185
1313
        int count = 0;
1186
1314
        char *state = "not set";
1187
1315
 
1188
 
        list_for_each_entry(w, &codec->dapm_widgets, list) {
 
1316
        list_for_each_entry(w, &codec->card->widgets, list) {
 
1317
                if (w->dapm != &codec->dapm)
 
1318
                        continue;
1189
1319
 
1190
1320
                /* only display widgets that burnm power */
1191
1321
                switch (w->id) {
1197
1327
                case snd_soc_dapm_dac:
1198
1328
                case snd_soc_dapm_adc:
1199
1329
                case snd_soc_dapm_pga:
 
1330
                case snd_soc_dapm_out_drv:
1200
1331
                case snd_soc_dapm_mixer:
1201
1332
                case snd_soc_dapm_mixer_named_ctl:
1202
1333
                case snd_soc_dapm_supply:
1209
1340
                }
1210
1341
        }
1211
1342
 
1212
 
        switch (codec->bias_level) {
 
1343
        switch (codec->dapm.bias_level) {
1213
1344
        case SND_SOC_BIAS_ON:
1214
1345
                state = "On";
1215
1346
                break;
1241
1372
}
1242
1373
 
1243
1374
/* free all dapm widgets and resources */
1244
 
static void dapm_free_widgets(struct snd_soc_codec *codec)
 
1375
static void dapm_free_widgets(struct snd_soc_dapm_context *dapm)
1245
1376
{
1246
1377
        struct snd_soc_dapm_widget *w, *next_w;
1247
1378
        struct snd_soc_dapm_path *p, *next_p;
1248
1379
 
1249
 
        list_for_each_entry_safe(w, next_w, &codec->dapm_widgets, list) {
 
1380
        list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) {
 
1381
                if (w->dapm != dapm)
 
1382
                        continue;
1250
1383
                list_del(&w->list);
 
1384
                /*
 
1385
                 * remove source and sink paths associated to this widget.
 
1386
                 * While removing the path, remove reference to it from both
 
1387
                 * source and sink widgets so that path is removed only once.
 
1388
                 */
 
1389
                list_for_each_entry_safe(p, next_p, &w->sources, list_sink) {
 
1390
                        list_del(&p->list_sink);
 
1391
                        list_del(&p->list_source);
 
1392
                        list_del(&p->list);
 
1393
                        kfree(p->long_name);
 
1394
                        kfree(p);
 
1395
                }
 
1396
                list_for_each_entry_safe(p, next_p, &w->sinks, list_source) {
 
1397
                        list_del(&p->list_sink);
 
1398
                        list_del(&p->list_source);
 
1399
                        list_del(&p->list);
 
1400
                        kfree(p->long_name);
 
1401
                        kfree(p);
 
1402
                }
 
1403
                kfree(w->name);
1251
1404
                kfree(w);
1252
1405
        }
1253
 
 
1254
 
        list_for_each_entry_safe(p, next_p, &codec->dapm_paths, list) {
1255
 
                list_del(&p->list);
1256
 
                kfree(p->long_name);
1257
 
                kfree(p);
1258
 
        }
1259
1406
}
1260
1407
 
1261
 
static int snd_soc_dapm_set_pin(struct snd_soc_codec *codec,
 
1408
static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm,
1262
1409
                                const char *pin, int status)
1263
1410
{
1264
1411
        struct snd_soc_dapm_widget *w;
1265
1412
 
1266
 
        list_for_each_entry(w, &codec->dapm_widgets, list) {
 
1413
        list_for_each_entry(w, &dapm->card->widgets, list) {
 
1414
                if (w->dapm != dapm)
 
1415
                        continue;
1267
1416
                if (!strcmp(w->name, pin)) {
1268
 
                        pr_debug("dapm: %s: pin %s\n", codec->name, pin);
 
1417
                        dev_dbg(w->dapm->dev, "dapm: pin %s = %d\n",
 
1418
                                pin, status);
1269
1419
                        w->connected = status;
1270
1420
                        /* Allow disabling of forced pins */
1271
1421
                        if (status == 0)
1274
1424
                }
1275
1425
        }
1276
1426
 
1277
 
        pr_err("dapm: %s: configuring unknown pin %s\n", codec->name, pin);
 
1427
        dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
1278
1428
        return -EINVAL;
1279
1429
}
1280
1430
 
1281
1431
/**
1282
1432
 * snd_soc_dapm_sync - scan and power dapm paths
1283
 
 * @codec: audio codec
 
1433
 * @dapm: DAPM context
1284
1434
 *
1285
1435
 * Walks all dapm audio paths and powers widgets according to their
1286
1436
 * stream or path usage.
1287
1437
 *
1288
1438
 * Returns 0 for success.
1289
1439
 */
1290
 
int snd_soc_dapm_sync(struct snd_soc_codec *codec)
 
1440
int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)
1291
1441
{
1292
 
        return dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
 
1442
        return dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
1293
1443
}
1294
1444
EXPORT_SYMBOL_GPL(snd_soc_dapm_sync);
1295
1445
 
1296
 
static int snd_soc_dapm_add_route(struct snd_soc_codec *codec,
 
1446
static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,
1297
1447
                                  const struct snd_soc_dapm_route *route)
1298
1448
{
1299
1449
        struct snd_soc_dapm_path *path;
1300
1450
        struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;
1301
 
        const char *sink = route->sink;
 
1451
        struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;
 
1452
        const char *sink;
1302
1453
        const char *control = route->control;
1303
 
        const char *source = route->source;
 
1454
        const char *source;
 
1455
        char prefixed_sink[80];
 
1456
        char prefixed_source[80];
1304
1457
        int ret = 0;
1305
1458
 
1306
 
        /* find src and dest widgets */
1307
 
        list_for_each_entry(w, &codec->dapm_widgets, list) {
 
1459
        if (dapm->codec->name_prefix) {
 
1460
                snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s",
 
1461
                         dapm->codec->name_prefix, route->sink);
 
1462
                sink = prefixed_sink;
 
1463
                snprintf(prefixed_source, sizeof(prefixed_source), "%s %s",
 
1464
                         dapm->codec->name_prefix, route->source);
 
1465
                source = prefixed_source;
 
1466
        } else {
 
1467
                sink = route->sink;
 
1468
                source = route->source;
 
1469
        }
1308
1470
 
 
1471
        /*
 
1472
         * find src and dest widgets over all widgets but favor a widget from
 
1473
         * current DAPM context
 
1474
         */
 
1475
        list_for_each_entry(w, &dapm->card->widgets, list) {
1309
1476
                if (!wsink && !(strcmp(w->name, sink))) {
1310
 
                        wsink = w;
 
1477
                        wtsink = w;
 
1478
                        if (w->dapm == dapm)
 
1479
                                wsink = w;
1311
1480
                        continue;
1312
1481
                }
1313
1482
                if (!wsource && !(strcmp(w->name, source))) {
1314
 
                        wsource = w;
 
1483
                        wtsource = w;
 
1484
                        if (w->dapm == dapm)
 
1485
                                wsource = w;
1315
1486
                }
1316
1487
        }
 
1488
        /* use widget from another DAPM context if not found from this */
 
1489
        if (!wsink)
 
1490
                wsink = wtsink;
 
1491
        if (!wsource)
 
1492
                wsource = wtsource;
1317
1493
 
1318
1494
        if (wsource == NULL || wsink == NULL)
1319
1495
                return -ENODEV;
1347
1523
 
1348
1524
        /* connect static paths */
1349
1525
        if (control == NULL) {
1350
 
                list_add(&path->list, &codec->dapm_paths);
 
1526
                list_add(&path->list, &dapm->card->paths);
1351
1527
                list_add(&path->list_sink, &wsink->sources);
1352
1528
                list_add(&path->list_source, &wsource->sinks);
1353
1529
                path->connect = 1;
1359
1535
        case snd_soc_dapm_adc:
1360
1536
        case snd_soc_dapm_dac:
1361
1537
        case snd_soc_dapm_pga:
 
1538
        case snd_soc_dapm_out_drv:
1362
1539
        case snd_soc_dapm_input:
1363
1540
        case snd_soc_dapm_output:
1364
1541
        case snd_soc_dapm_micbias:
1368
1545
        case snd_soc_dapm_supply:
1369
1546
        case snd_soc_dapm_aif_in:
1370
1547
        case snd_soc_dapm_aif_out:
1371
 
                list_add(&path->list, &codec->dapm_paths);
 
1548
                list_add(&path->list, &dapm->card->paths);
1372
1549
                list_add(&path->list_sink, &wsink->sources);
1373
1550
                list_add(&path->list_source, &wsource->sinks);
1374
1551
                path->connect = 1;
1375
1552
                return 0;
1376
1553
        case snd_soc_dapm_mux:
 
1554
        case snd_soc_dapm_virt_mux:
1377
1555
        case snd_soc_dapm_value_mux:
1378
 
                ret = dapm_connect_mux(codec, wsource, wsink, path, control,
 
1556
                ret = dapm_connect_mux(dapm, wsource, wsink, path, control,
1379
1557
                        &wsink->kcontrols[0]);
1380
1558
                if (ret != 0)
1381
1559
                        goto err;
1383
1561
        case snd_soc_dapm_switch:
1384
1562
        case snd_soc_dapm_mixer:
1385
1563
        case snd_soc_dapm_mixer_named_ctl:
1386
 
                ret = dapm_connect_mixer(codec, wsource, wsink, path, control);
 
1564
                ret = dapm_connect_mixer(dapm, wsource, wsink, path, control);
1387
1565
                if (ret != 0)
1388
1566
                        goto err;
1389
1567
                break;
1391
1569
        case snd_soc_dapm_mic:
1392
1570
        case snd_soc_dapm_line:
1393
1571
        case snd_soc_dapm_spk:
1394
 
                list_add(&path->list, &codec->dapm_paths);
 
1572
                list_add(&path->list, &dapm->card->paths);
1395
1573
                list_add(&path->list_sink, &wsink->sources);
1396
1574
                list_add(&path->list_source, &wsource->sinks);
1397
1575
                path->connect = 0;
1400
1578
        return 0;
1401
1579
 
1402
1580
err:
1403
 
        printk(KERN_WARNING "asoc: no dapm match for %s --> %s --> %s\n", source,
1404
 
                control, sink);
 
1581
        dev_warn(dapm->dev, "asoc: no dapm match for %s --> %s --> %s\n",
 
1582
                 source, control, sink);
1405
1583
        kfree(path);
1406
1584
        return ret;
1407
1585
}
1408
1586
 
1409
1587
/**
1410
1588
 * snd_soc_dapm_add_routes - Add routes between DAPM widgets
1411
 
 * @codec: codec
 
1589
 * @dapm: DAPM context
1412
1590
 * @route: audio routes
1413
1591
 * @num: number of routes
1414
1592
 *
1419
1597
 * Returns 0 for success else error. On error all resources can be freed
1420
1598
 * with a call to snd_soc_card_free().
1421
1599
 */
1422
 
int snd_soc_dapm_add_routes(struct snd_soc_codec *codec,
 
1600
int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,
1423
1601
                            const struct snd_soc_dapm_route *route, int num)
1424
1602
{
1425
1603
        int i, ret;
1426
1604
 
1427
1605
        for (i = 0; i < num; i++) {
1428
 
                ret = snd_soc_dapm_add_route(codec, route);
 
1606
                ret = snd_soc_dapm_add_route(dapm, route);
1429
1607
                if (ret < 0) {
1430
 
                        printk(KERN_ERR "Failed to add route %s->%s\n",
1431
 
                               route->source,
1432
 
                               route->sink);
 
1608
                        dev_err(dapm->dev, "Failed to add route %s->%s\n",
 
1609
                                route->source, route->sink);
1433
1610
                        return ret;
1434
1611
                }
1435
1612
                route++;
1441
1618
 
1442
1619
/**
1443
1620
 * snd_soc_dapm_new_widgets - add new dapm widgets
1444
 
 * @codec: audio codec
 
1621
 * @dapm: DAPM context
1445
1622
 *
1446
1623
 * Checks the codec for any new dapm widgets and creates them if found.
1447
1624
 *
1448
1625
 * Returns 0 for success.
1449
1626
 */
1450
 
int snd_soc_dapm_new_widgets(struct snd_soc_codec *codec)
 
1627
int snd_soc_dapm_new_widgets(struct snd_soc_dapm_context *dapm)
1451
1628
{
1452
1629
        struct snd_soc_dapm_widget *w;
1453
1630
 
1454
 
        list_for_each_entry(w, &codec->dapm_widgets, list)
 
1631
        list_for_each_entry(w, &dapm->card->widgets, list)
1455
1632
        {
1456
1633
                if (w->new)
1457
1634
                        continue;
1461
1638
                case snd_soc_dapm_mixer:
1462
1639
                case snd_soc_dapm_mixer_named_ctl:
1463
1640
                        w->power_check = dapm_generic_check_power;
1464
 
                        dapm_new_mixer(codec, w);
 
1641
                        dapm_new_mixer(dapm, w);
1465
1642
                        break;
1466
1643
                case snd_soc_dapm_mux:
 
1644
                case snd_soc_dapm_virt_mux:
1467
1645
                case snd_soc_dapm_value_mux:
1468
1646
                        w->power_check = dapm_generic_check_power;
1469
 
                        dapm_new_mux(codec, w);
 
1647
                        dapm_new_mux(dapm, w);
1470
1648
                        break;
1471
1649
                case snd_soc_dapm_adc:
1472
1650
                case snd_soc_dapm_aif_out:
1477
1655
                        w->power_check = dapm_dac_check_power;
1478
1656
                        break;
1479
1657
                case snd_soc_dapm_pga:
 
1658
                case snd_soc_dapm_out_drv:
1480
1659
                        w->power_check = dapm_generic_check_power;
1481
 
                        dapm_new_pga(codec, w);
 
1660
                        dapm_new_pga(dapm, w);
1482
1661
                        break;
1483
1662
                case snd_soc_dapm_input:
1484
1663
                case snd_soc_dapm_output:
1499
1678
                w->new = 1;
1500
1679
        }
1501
1680
 
1502
 
        dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP);
 
1681
        dapm_power_widgets(dapm, SND_SOC_DAPM_STREAM_NOP);
1503
1682
        return 0;
1504
1683
}
1505
1684
EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets);
1560
1739
                (struct soc_mixer_control *)kcontrol->private_value;
1561
1740
        unsigned int reg = mc->reg;
1562
1741
        unsigned int shift = mc->shift;
1563
 
        unsigned int rshift = mc->rshift;
1564
1742
        int max = mc->max;
1565
1743
        unsigned int mask = (1 << fls(max)) - 1;
1566
1744
        unsigned int invert = mc->invert;
1567
 
        unsigned int val, val2, val_mask;
1568
 
        int connect;
1569
 
        int ret;
 
1745
        unsigned int val, val_mask;
 
1746
        int connect, change;
 
1747
        struct snd_soc_dapm_update update;
1570
1748
 
1571
1749
        val = (ucontrol->value.integer.value[0] & mask);
1572
1750
 
1574
1752
                val = max - val;
1575
1753
        val_mask = mask << shift;
1576
1754
        val = val << shift;
1577
 
        if (shift != rshift) {
1578
 
                val2 = (ucontrol->value.integer.value[1] & mask);
1579
 
                if (invert)
1580
 
                        val2 = max - val2;
1581
 
                val_mask |= mask << rshift;
1582
 
                val |= val2 << rshift;
1583
 
        }
1584
1755
 
1585
1756
        mutex_lock(&widget->codec->mutex);
1586
1757
        widget->value = val;
1587
1758
 
1588
 
        if (snd_soc_test_bits(widget->codec, reg, val_mask, val)) {
 
1759
        change = snd_soc_test_bits(widget->codec, reg, val_mask, val);
 
1760
        if (change) {
1589
1761
                if (val)
1590
1762
                        /* new connection */
1591
1763
                        connect = invert ? 0:1;
1593
1765
                        /* old connection must be powered down */
1594
1766
                        connect = invert ? 1:0;
1595
1767
 
 
1768
                update.kcontrol = kcontrol;
 
1769
                update.widget = widget;
 
1770
                update.reg = reg;
 
1771
                update.mask = mask;
 
1772
                update.val = val;
 
1773
                widget->dapm->update = &update;
 
1774
 
1596
1775
                dapm_mixer_update_power(widget, kcontrol, connect);
 
1776
 
 
1777
                widget->dapm->update = NULL;
1597
1778
        }
1598
1779
 
1599
 
        if (widget->event) {
1600
 
                if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1601
 
                        ret = widget->event(widget, kcontrol,
1602
 
                                                SND_SOC_DAPM_PRE_REG);
1603
 
                        if (ret < 0) {
1604
 
                                ret = 1;
1605
 
                                goto out;
1606
 
                        }
1607
 
                }
1608
 
                ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1609
 
                if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1610
 
                        ret = widget->event(widget, kcontrol,
1611
 
                                                SND_SOC_DAPM_POST_REG);
1612
 
        } else
1613
 
                ret = snd_soc_update_bits(widget->codec, reg, val_mask, val);
1614
 
 
1615
 
out:
1616
1780
        mutex_unlock(&widget->codec->mutex);
1617
 
        return ret;
 
1781
        return 0;
1618
1782
}
1619
1783
EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw);
1620
1784
 
1662
1826
        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1663
1827
        unsigned int val, mux, change;
1664
1828
        unsigned int mask, bitmask;
1665
 
        int ret = 0;
 
1829
        struct snd_soc_dapm_update update;
1666
1830
 
1667
1831
        for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
1668
1832
                ;
1681
1845
        mutex_lock(&widget->codec->mutex);
1682
1846
        widget->value = val;
1683
1847
        change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
 
1848
 
 
1849
        update.kcontrol = kcontrol;
 
1850
        update.widget = widget;
 
1851
        update.reg = e->reg;
 
1852
        update.mask = mask;
 
1853
        update.val = val;
 
1854
        widget->dapm->update = &update;
 
1855
 
1684
1856
        dapm_mux_update_power(widget, kcontrol, change, mux, e);
1685
1857
 
1686
 
        if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1687
 
                ret = widget->event(widget,
1688
 
                                    kcontrol, SND_SOC_DAPM_PRE_REG);
1689
 
                if (ret < 0)
1690
 
                        goto out;
1691
 
        }
1692
 
 
1693
 
        ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1694
 
 
1695
 
        if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1696
 
                ret = widget->event(widget,
1697
 
                                    kcontrol, SND_SOC_DAPM_POST_REG);
1698
 
 
1699
 
out:
 
1858
        widget->dapm->update = NULL;
 
1859
 
1700
1860
        mutex_unlock(&widget->codec->mutex);
1701
 
        return ret;
 
1861
        return change;
1702
1862
}
1703
1863
EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double);
1704
1864
 
1810
1970
        struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1811
1971
        unsigned int val, mux, change;
1812
1972
        unsigned int mask;
1813
 
        int ret = 0;
 
1973
        struct snd_soc_dapm_update update;
1814
1974
 
1815
1975
        if (ucontrol->value.enumerated.item[0] > e->max - 1)
1816
1976
                return -EINVAL;
1827
1987
        mutex_lock(&widget->codec->mutex);
1828
1988
        widget->value = val;
1829
1989
        change = snd_soc_test_bits(widget->codec, e->reg, mask, val);
 
1990
 
 
1991
        update.kcontrol = kcontrol;
 
1992
        update.widget = widget;
 
1993
        update.reg = e->reg;
 
1994
        update.mask = mask;
 
1995
        update.val = val;
 
1996
        widget->dapm->update = &update;
 
1997
 
1830
1998
        dapm_mux_update_power(widget, kcontrol, change, mux, e);
1831
1999
 
1832
 
        if (widget->event_flags & SND_SOC_DAPM_PRE_REG) {
1833
 
                ret = widget->event(widget,
1834
 
                                    kcontrol, SND_SOC_DAPM_PRE_REG);
1835
 
                if (ret < 0)
1836
 
                        goto out;
1837
 
        }
1838
 
 
1839
 
        ret = snd_soc_update_bits(widget->codec, e->reg, mask, val);
1840
 
 
1841
 
        if (widget->event_flags & SND_SOC_DAPM_POST_REG)
1842
 
                ret = widget->event(widget,
1843
 
                                    kcontrol, SND_SOC_DAPM_POST_REG);
1844
 
 
1845
 
out:
 
2000
        widget->dapm->update = NULL;
 
2001
 
1846
2002
        mutex_unlock(&widget->codec->mutex);
1847
 
        return ret;
 
2003
        return change;
1848
2004
}
1849
2005
EXPORT_SYMBOL_GPL(snd_soc_dapm_put_value_enum_double);
1850
2006
 
1883
2039
        mutex_lock(&codec->mutex);
1884
2040
 
1885
2041
        ucontrol->value.integer.value[0] =
1886
 
                snd_soc_dapm_get_pin_status(codec, pin);
 
2042
                snd_soc_dapm_get_pin_status(&codec->dapm, pin);
1887
2043
 
1888
2044
        mutex_unlock(&codec->mutex);
1889
2045
 
1906
2062
        mutex_lock(&codec->mutex);
1907
2063
 
1908
2064
        if (ucontrol->value.integer.value[0])
1909
 
                snd_soc_dapm_enable_pin(codec, pin);
 
2065
                snd_soc_dapm_enable_pin(&codec->dapm, pin);
1910
2066
        else
1911
 
                snd_soc_dapm_disable_pin(codec, pin);
 
2067
                snd_soc_dapm_disable_pin(&codec->dapm, pin);
1912
2068
 
1913
 
        snd_soc_dapm_sync(codec);
 
2069
        snd_soc_dapm_sync(&codec->dapm);
1914
2070
 
1915
2071
        mutex_unlock(&codec->mutex);
1916
2072
 
1920
2076
 
1921
2077
/**
1922
2078
 * snd_soc_dapm_new_control - create new dapm control
1923
 
 * @codec: audio codec
 
2079
 * @dapm: DAPM context
1924
2080
 * @widget: widget template
1925
2081
 *
1926
2082
 * Creates a new dapm control based upon the template.
1927
2083
 *
1928
2084
 * Returns 0 for success else error.
1929
2085
 */
1930
 
int snd_soc_dapm_new_control(struct snd_soc_codec *codec,
 
2086
int snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
1931
2087
        const struct snd_soc_dapm_widget *widget)
1932
2088
{
1933
2089
        struct snd_soc_dapm_widget *w;
 
2090
        size_t name_len;
1934
2091
 
1935
2092
        if ((w = dapm_cnew_widget(widget)) == NULL)
1936
2093
                return -ENOMEM;
1937
2094
 
1938
 
        w->codec = codec;
 
2095
        name_len = strlen(widget->name) + 1;
 
2096
        if (dapm->codec->name_prefix)
 
2097
                name_len += 1 + strlen(dapm->codec->name_prefix);
 
2098
        w->name = kmalloc(name_len, GFP_KERNEL);
 
2099
        if (w->name == NULL) {
 
2100
                kfree(w);
 
2101
                return -ENOMEM;
 
2102
        }
 
2103
        if (dapm->codec->name_prefix)
 
2104
                snprintf(w->name, name_len, "%s %s",
 
2105
                        dapm->codec->name_prefix, widget->name);
 
2106
        else
 
2107
                snprintf(w->name, name_len, "%s", widget->name);
 
2108
 
 
2109
        dapm->n_widgets++;
 
2110
        w->dapm = dapm;
 
2111
        w->codec = dapm->codec;
1939
2112
        INIT_LIST_HEAD(&w->sources);
1940
2113
        INIT_LIST_HEAD(&w->sinks);
1941
2114
        INIT_LIST_HEAD(&w->list);
1942
 
        list_add(&w->list, &codec->dapm_widgets);
 
2115
        list_add(&w->list, &dapm->card->widgets);
1943
2116
 
1944
2117
        /* machine layer set ups unconnected pins and insertions */
1945
2118
        w->connected = 1;
1949
2122
 
1950
2123
/**
1951
2124
 * snd_soc_dapm_new_controls - create new dapm controls
1952
 
 * @codec: audio codec
 
2125
 * @dapm: DAPM context
1953
2126
 * @widget: widget array
1954
2127
 * @num: number of widgets
1955
2128
 *
1957
2130
 *
1958
2131
 * Returns 0 for success else error.
1959
2132
 */
1960
 
int snd_soc_dapm_new_controls(struct snd_soc_codec *codec,
 
2133
int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,
1961
2134
        const struct snd_soc_dapm_widget *widget,
1962
2135
        int num)
1963
2136
{
1964
2137
        int i, ret;
1965
2138
 
1966
2139
        for (i = 0; i < num; i++) {
1967
 
                ret = snd_soc_dapm_new_control(codec, widget);
 
2140
                ret = snd_soc_dapm_new_control(dapm, widget);
1968
2141
                if (ret < 0) {
1969
 
                        printk(KERN_ERR
1970
 
                               "ASoC: Failed to create DAPM control %s: %d\n",
1971
 
                               widget->name, ret);
 
2142
                        dev_err(dapm->dev,
 
2143
                                "ASoC: Failed to create DAPM control %s: %d\n",
 
2144
                                widget->name, ret);
1972
2145
                        return ret;
1973
2146
                }
1974
2147
                widget++;
1977
2150
}
1978
2151
EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls);
1979
2152
 
1980
 
 
1981
 
/**
1982
 
 * snd_soc_dapm_stream_event - send a stream event to the dapm core
1983
 
 * @codec: audio codec
1984
 
 * @stream: stream name
1985
 
 * @event: stream event
1986
 
 *
1987
 
 * Sends a stream event to the dapm core. The core then makes any
1988
 
 * necessary widget power changes.
1989
 
 *
1990
 
 * Returns 0 for success else error.
1991
 
 */
1992
 
int snd_soc_dapm_stream_event(struct snd_soc_codec *codec,
1993
 
        char *stream, int event)
 
2153
static void soc_dapm_stream_event(struct snd_soc_dapm_context *dapm,
 
2154
        const char *stream, int event)
1994
2155
{
1995
2156
        struct snd_soc_dapm_widget *w;
1996
2157
 
1997
 
        if (stream == NULL)
1998
 
                return 0;
1999
 
 
2000
 
        mutex_lock(&codec->mutex);
2001
 
        list_for_each_entry(w, &codec->dapm_widgets, list)
 
2158
        list_for_each_entry(w, &dapm->card->widgets, list)
2002
2159
        {
2003
 
                if (!w->sname)
 
2160
                if (!w->sname || w->dapm != dapm)
2004
2161
                        continue;
2005
 
                pr_debug("widget %s\n %s stream %s event %d\n",
2006
 
                         w->name, w->sname, stream, event);
 
2162
                dev_dbg(w->dapm->dev, "widget %s\n %s stream %s event %d\n",
 
2163
                        w->name, w->sname, stream, event);
2007
2164
                if (strstr(w->sname, stream)) {
2008
2165
                        switch(event) {
2009
2166
                        case SND_SOC_DAPM_STREAM_START:
2013
2170
                                w->active = 0;
2014
2171
                                break;
2015
2172
                        case SND_SOC_DAPM_STREAM_SUSPEND:
2016
 
                                if (w->active)
2017
 
                                        w->suspend = 1;
2018
 
                                w->active = 0;
2019
 
                                break;
2020
2173
                        case SND_SOC_DAPM_STREAM_RESUME:
2021
 
                                if (w->suspend) {
2022
 
                                        w->active = 1;
2023
 
                                        w->suspend = 0;
2024
 
                                }
2025
 
                                break;
2026
2174
                        case SND_SOC_DAPM_STREAM_PAUSE_PUSH:
2027
 
                                break;
2028
2175
                        case SND_SOC_DAPM_STREAM_PAUSE_RELEASE:
2029
2176
                                break;
2030
2177
                        }
2031
2178
                }
2032
2179
        }
2033
2180
 
2034
 
        dapm_power_widgets(codec, event);
 
2181
        dapm_power_widgets(dapm, event);
 
2182
}
 
2183
 
 
2184
/**
 
2185
 * snd_soc_dapm_stream_event - send a stream event to the dapm core
 
2186
 * @rtd: PCM runtime data
 
2187
 * @stream: stream name
 
2188
 * @event: stream event
 
2189
 *
 
2190
 * Sends a stream event to the dapm core. The core then makes any
 
2191
 * necessary widget power changes.
 
2192
 *
 
2193
 * Returns 0 for success else error.
 
2194
 */
 
2195
int snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd,
 
2196
        const char *stream, int event)
 
2197
{
 
2198
        struct snd_soc_codec *codec = rtd->codec;
 
2199
 
 
2200
        if (stream == NULL)
 
2201
                return 0;
 
2202
 
 
2203
        mutex_lock(&codec->mutex);
 
2204
        soc_dapm_stream_event(&codec->dapm, stream, event);
2035
2205
        mutex_unlock(&codec->mutex);
2036
2206
        return 0;
2037
2207
}
2039
2209
 
2040
2210
/**
2041
2211
 * snd_soc_dapm_enable_pin - enable pin.
2042
 
 * @codec: SoC codec
 
2212
 * @dapm: DAPM context
2043
2213
 * @pin: pin name
2044
2214
 *
2045
2215
 * Enables input/output pin and its parents or children widgets iff there is
2047
2217
 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2048
2218
 * do any widget power switching.
2049
2219
 */
2050
 
int snd_soc_dapm_enable_pin(struct snd_soc_codec *codec, const char *pin)
 
2220
int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)
2051
2221
{
2052
 
        return snd_soc_dapm_set_pin(codec, pin, 1);
 
2222
        return snd_soc_dapm_set_pin(dapm, pin, 1);
2053
2223
}
2054
2224
EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin);
2055
2225
 
2056
2226
/**
2057
2227
 * snd_soc_dapm_force_enable_pin - force a pin to be enabled
2058
 
 * @codec: SoC codec
 
2228
 * @dapm: DAPM context
2059
2229
 * @pin: pin name
2060
2230
 *
2061
2231
 * Enables input/output pin regardless of any other state.  This is
2065
2235
 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2066
2236
 * do any widget power switching.
2067
2237
 */
2068
 
int snd_soc_dapm_force_enable_pin(struct snd_soc_codec *codec, const char *pin)
 
2238
int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm,
 
2239
                                  const char *pin)
2069
2240
{
2070
2241
        struct snd_soc_dapm_widget *w;
2071
2242
 
2072
 
        list_for_each_entry(w, &codec->dapm_widgets, list) {
 
2243
        list_for_each_entry(w, &dapm->card->widgets, list) {
 
2244
                if (w->dapm != dapm)
 
2245
                        continue;
2073
2246
                if (!strcmp(w->name, pin)) {
2074
 
                        pr_debug("dapm: %s: pin %s\n", codec->name, pin);
 
2247
                        dev_dbg(w->dapm->dev,
 
2248
                                "dapm: force enable pin %s\n", pin);
2075
2249
                        w->connected = 1;
2076
2250
                        w->force = 1;
2077
2251
                        return 0;
2078
2252
                }
2079
2253
        }
2080
2254
 
2081
 
        pr_err("dapm: %s: configuring unknown pin %s\n", codec->name, pin);
 
2255
        dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
2082
2256
        return -EINVAL;
2083
2257
}
2084
2258
EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin);
2085
2259
 
2086
2260
/**
2087
2261
 * snd_soc_dapm_disable_pin - disable pin.
2088
 
 * @codec: SoC codec
 
2262
 * @dapm: DAPM context
2089
2263
 * @pin: pin name
2090
2264
 *
2091
2265
 * Disables input/output pin and its parents or children widgets.
2092
2266
 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2093
2267
 * do any widget power switching.
2094
2268
 */
2095
 
int snd_soc_dapm_disable_pin(struct snd_soc_codec *codec, const char *pin)
 
2269
int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm,
 
2270
                             const char *pin)
2096
2271
{
2097
 
        return snd_soc_dapm_set_pin(codec, pin, 0);
 
2272
        return snd_soc_dapm_set_pin(dapm, pin, 0);
2098
2273
}
2099
2274
EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin);
2100
2275
 
2101
2276
/**
2102
2277
 * snd_soc_dapm_nc_pin - permanently disable pin.
2103
 
 * @codec: SoC codec
 
2278
 * @dapm: DAPM context
2104
2279
 * @pin: pin name
2105
2280
 *
2106
2281
 * Marks the specified pin as being not connected, disabling it along
2112
2287
 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to
2113
2288
 * do any widget power switching.
2114
2289
 */
2115
 
int snd_soc_dapm_nc_pin(struct snd_soc_codec *codec, const char *pin)
 
2290
int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)
2116
2291
{
2117
 
        return snd_soc_dapm_set_pin(codec, pin, 0);
 
2292
        return snd_soc_dapm_set_pin(dapm, pin, 0);
2118
2293
}
2119
2294
EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin);
2120
2295
 
2121
2296
/**
2122
2297
 * snd_soc_dapm_get_pin_status - get audio pin status
2123
 
 * @codec: audio codec
 
2298
 * @dapm: DAPM context
2124
2299
 * @pin: audio signal pin endpoint (or start point)
2125
2300
 *
2126
2301
 * Get audio pin status - connected or disconnected.
2127
2302
 *
2128
2303
 * Returns 1 for connected otherwise 0.
2129
2304
 */
2130
 
int snd_soc_dapm_get_pin_status(struct snd_soc_codec *codec, const char *pin)
 
2305
int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm,
 
2306
                                const char *pin)
2131
2307
{
2132
2308
        struct snd_soc_dapm_widget *w;
2133
2309
 
2134
 
        list_for_each_entry(w, &codec->dapm_widgets, list) {
 
2310
        list_for_each_entry(w, &dapm->card->widgets, list) {
 
2311
                if (w->dapm != dapm)
 
2312
                        continue;
2135
2313
                if (!strcmp(w->name, pin))
2136
2314
                        return w->connected;
2137
2315
        }
2141
2319
EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status);
2142
2320
 
2143
2321
/**
 
2322
 * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint
 
2323
 * @dapm: DAPM context
 
2324
 * @pin: audio signal pin endpoint (or start point)
 
2325
 *
 
2326
 * Mark the given endpoint or pin as ignoring suspend.  When the
 
2327
 * system is disabled a path between two endpoints flagged as ignoring
 
2328
 * suspend will not be disabled.  The path must already be enabled via
 
2329
 * normal means at suspend time, it will not be turned on if it was not
 
2330
 * already enabled.
 
2331
 */
 
2332
int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
 
2333
                                const char *pin)
 
2334
{
 
2335
        struct snd_soc_dapm_widget *w;
 
2336
 
 
2337
        list_for_each_entry(w, &dapm->card->widgets, list) {
 
2338
                if (w->dapm != dapm)
 
2339
                        continue;
 
2340
                if (!strcmp(w->name, pin)) {
 
2341
                        w->ignore_suspend = 1;
 
2342
                        return 0;
 
2343
                }
 
2344
        }
 
2345
 
 
2346
        dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
 
2347
        return -EINVAL;
 
2348
}
 
2349
EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
 
2350
 
 
2351
/**
2144
2352
 * snd_soc_dapm_free - free dapm resources
2145
 
 * @socdev: SoC device
 
2353
 * @card: SoC device
2146
2354
 *
2147
2355
 * Free all dapm widgets and resources.
2148
2356
 */
2149
 
void snd_soc_dapm_free(struct snd_soc_device *socdev)
 
2357
void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
2150
2358
{
2151
 
        struct snd_soc_codec *codec = socdev->card->codec;
2152
 
 
2153
 
        snd_soc_dapm_sys_remove(socdev->dev);
2154
 
        dapm_free_widgets(codec);
 
2359
        snd_soc_dapm_sys_remove(dapm->dev);
 
2360
        dapm_free_widgets(dapm);
 
2361
        list_del(&dapm->list);
2155
2362
}
2156
2363
EXPORT_SYMBOL_GPL(snd_soc_dapm_free);
2157
2364
 
2158
 
/*
2159
 
 * snd_soc_dapm_shutdown - callback for system shutdown
2160
 
 */
2161
 
void snd_soc_dapm_shutdown(struct snd_soc_device *socdev)
 
2365
static void soc_dapm_shutdown_codec(struct snd_soc_dapm_context *dapm)
2162
2366
{
2163
 
        struct snd_soc_codec *codec = socdev->card->codec;
2164
2367
        struct snd_soc_dapm_widget *w;
2165
2368
        LIST_HEAD(down_list);
2166
2369
        int powerdown = 0;
2167
2370
 
2168
 
        list_for_each_entry(w, &codec->dapm_widgets, list) {
 
2371
        list_for_each_entry(w, &dapm->card->widgets, list) {
 
2372
                if (w->dapm != dapm)
 
2373
                        continue;
2169
2374
                if (w->power) {
2170
2375
                        dapm_seq_insert(w, &down_list, dapm_down_seq);
2171
2376
                        w->power = 0;
2177
2382
         * standby.
2178
2383
         */
2179
2384
        if (powerdown) {
2180
 
                snd_soc_dapm_set_bias_level(socdev, SND_SOC_BIAS_PREPARE);
2181
 
                dapm_seq_run(codec, &down_list, 0, dapm_down_seq);
2182
 
                snd_soc_dapm_set_bias_level(socdev, SND_SOC_BIAS_STANDBY);
2183
 
        }
2184
 
 
2185
 
        snd_soc_dapm_set_bias_level(socdev, SND_SOC_BIAS_OFF);
 
2385
                snd_soc_dapm_set_bias_level(NULL, dapm, SND_SOC_BIAS_PREPARE);
 
2386
                dapm_seq_run(dapm, &down_list, 0, dapm_down_seq);
 
2387
                snd_soc_dapm_set_bias_level(NULL, dapm, SND_SOC_BIAS_STANDBY);
 
2388
        }
 
2389
}
 
2390
 
 
2391
/*
 
2392
 * snd_soc_dapm_shutdown - callback for system shutdown
 
2393
 */
 
2394
void snd_soc_dapm_shutdown(struct snd_soc_card *card)
 
2395
{
 
2396
        struct snd_soc_codec *codec;
 
2397
 
 
2398
        list_for_each_entry(codec, &card->codec_dev_list, list) {
 
2399
                soc_dapm_shutdown_codec(&codec->dapm);
 
2400
                snd_soc_dapm_set_bias_level(card, &codec->dapm, SND_SOC_BIAS_OFF);
 
2401
        }
2186
2402
}
2187
2403
 
2188
2404
/* Module information */