linux-alsa详解14之DAPM详解7上下电过程分析

本文转载自查看原文 2020-06-25 12:44 527 linux内核应用

设计dapm的主要目的之一，就是希望声卡上的各种部件的电源按需分配，需要的就上电，不需要的就下电，使得整个音频系统总是处于最小的耗电状态，最主要的就是，这一切对用户空间的应用程序是透明的，也就是说，用户空间的应用程序无需关心那个部件何时需要电源，它只要按需要设定好音频路径，播放音频数据，暂停或停止，dapm框架会根据音频路径，完美地对各种部件的电源进行控制，而且精确地按某种顺序进行，防止上下电过程中产生不必要的pop-pop声。

1 统计widget连接至端点widget的路径个数

端点widget位于音频路径的起始端或者末端，所以通常它们就是指codec的输入输出引脚所对应的widget，或者是外部器件对应的widget，这些widget的类型如linux-alsa详解11之DAPM详解4驱动中widget初始化第4节所述。

dapm要给一个widget上电的其中一个前提条件是：这个widget位于一条完整的音频路径上，而一条完整的音频路径的两头，必须是输入/输出引脚，或者是一个外部音频设备，又或者是一个处于激活状态的音频流widget，也就是上表中的前三项，上表中的后两项，它们可以位于路径的末端，但不是构成完成音频路径的必要条件，我们只用它来判断扫描一条路径的结束条件。dapm提供了两个内部函数，用来统计一个widget连接到输出引脚、输入引脚、激活的音频流widget的有效路径个数：

is_connected_output_ep    返回连接至输出引脚或激活状态的输出音频流的路径数量
is_connected_input_ep    返回连接至输入引脚或激活状态的输入音频流的路径数量

两个函数定义如下：

 1 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget,
 2     struct list_head *list,
 3     bool (*custom_stop_condition)(struct snd_soc_dapm_widget *i,
 4                       enum snd_soc_dapm_direction))
 5 {
 6     return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_OUT,
 7             is_connected_output_ep, custom_stop_condition);
 8 }
 9 
10 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget,
11     struct list_head *list,
12     bool (*custom_stop_condition)(struct snd_soc_dapm_widget *i,
13                       enum snd_soc_dapm_direction))
14 {
15     return is_connected_ep(widget, list, SND_SOC_DAPM_DIR_IN,
16             is_connected_input_ep, custom_stop_condition);
17 }

最终都调用函数is_connected_input_ep

函数具体过程待分析补充

 1 static __always_inline int is_connected_ep(struct snd_soc_dapm_widget *widget,
 2     struct list_head *list, enum snd_soc_dapm_direction dir,
 3     int (*fn)(struct snd_soc_dapm_widget *, struct list_head *,
 4           bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
 5                         enum snd_soc_dapm_direction)),
 6     bool (*custom_stop_condition)(struct snd_soc_dapm_widget *,
 7                       enum snd_soc_dapm_direction))
 8 {
 9     enum snd_soc_dapm_direction rdir = SND_SOC_DAPM_DIR_REVERSE(dir);
10     struct snd_soc_dapm_path *path;
11     int con = 0;
12     /**多个路径可能使用了同一个widget，如果在遍历另一个路径时,已经统计过该widget，直接返回endpoint字段即可/
13     if (widget->endpoints[dir] >= 0)
14         return widget->endpoints[dir];
15 
16     DAPM_UPDATE_STAT(widget, path_checks);
17 
18     /* do we need to add this widget to the list ? */
19     if (list)
20         list_add_tail(&widget->work_list, list);
21 
22     if (custom_stop_condition && custom_stop_condition(widget, dir)) {
23         widget->endpoints[dir] = 1;
24         return widget->endpoints[dir];
25     }
26 
27     if ((widget->is_ep & SND_SOC_DAPM_DIR_TO_EP(dir)) && widget->connected) {
28         widget->endpoints[dir] = snd_soc_dapm_suspend_check(widget);
29         return widget->endpoints[dir];
30     }
31 
32     snd_soc_dapm_widget_for_each_path(widget, rdir, path) {
33         DAPM_UPDATE_STAT(widget, neighbour_checks);
34 
35         if (path->weak || path->is_supply)
36             continue;
37 
38         if (path->walking)
39             return 1;
40 
41         trace_snd_soc_dapm_path(widget, dir, path);
42 
43         if (path->connect) {
44             path->walking = 1;
45             con += fn(path->node[dir], list, custom_stop_condition);
46             path->walking = 0;
47         }
48     }
49 
50     widget->endpoints[dir] = con;
51 
52     return con;
53 }

2 dapm_dirty链表

在代表声卡的snd_soc_card结构中，有一个链表字段：dapm_dirty，所有状态发生了改变的widget，dapm不会立刻处理它的电源状态，而是需要先挂在该链表下面，等待后续的进一步处理：或者是上电，或者是下电。dapm为我们提供了一个api函数来完成这个动作：

 1 static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason)
 2 {
 3     dapm_assert_locked(w->dapm);
 4 
 5     if (!dapm_dirty_widget(w)) {
 6         dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n",
 7              w->name, reason);
 8         list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty);
 9     }
10 }

3 power_check回调函数

3.1 函数dapm_generic_check_power

在创建widget的时候，widget的power_check回调函数会根据widget的类型，设置不同的回调函数。当widget的状态改变后，dapm会遍历dapm_dirty链表，并通过power_check回调函数，决定该widget是否需要上电。大多数的widget的power_check回调被设置为：dapm_generic_check_power，如linux-alsa详解11之DAPM详解4驱动中widget初始化第三节所述。

 1 /* Generic check to see if a widget should be powered. */
 2 static int dapm_generic_check_power(struct snd_soc_dapm_widget *w)
 3 {
 4     int in, out;
 5 
 6     DAPM_UPDATE_STAT(w, power_checks);
 7 
 8     in = is_connected_input_ep(w, NULL, NULL);
 9     out = is_connected_output_ep(w, NULL, NULL);
10     return out != 0 && in != 0;
11 }

分别用is_connected_output_ep和is_connected_input_ep得到该widget是否有同时连接到一个输入端和一个输出端，如果是，返回1来表示该widget需要上电。

3.2 dai回调

对于snd_soc_dapm_dai_out和snd_soc_dapm_dai_in类型，power_check回调是dapm_adc_check_power和dapm_dac_check_power，这里以dapm_dac_check_power为例：

 1 static int dapm_dac_check_power(struct snd_soc_dapm_widget *w)
 2 {
 3         int out;
 4  
 5         DAPM_UPDATE_STAT(w, power_checks);
 6  
 7         if (w->active) {
 8                 out = is_connected_output_ep(w, NULL);
 9                 dapm_clear_walk_output(w->dapm, &w->sinks);
10                 return out != 0;
11         } else {
12                 return dapm_generic_check_power(w);
13         }
14 }

处于激活状态时，只判断是否有连接到有效的输出路径即可，没有激活时，则需要同时判断是否有连接到输入路径和输出路径。

4 widget的上电和下电顺序
在扫描dapm_dirty链表时，dapm使用两个链表来分别保存需要上电和需要下电的widget：

1 up_list           保存需要上电的widget
2 down_list     保存需要下电的widget

4.1 函数dapm_seq_insert

dapm内部使用dapm_seq_insert函数把一个widget加入到上述两个链表中的其中一个。

 1 /* Insert a widget in order into a DAPM power sequence. */
 2 static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget,
 3                 struct list_head *list,
 4                 bool power_up)
 5 {
 6     struct snd_soc_dapm_widget *w;
 7 
 8     list_for_each_entry(w, list, power_list)
 9         if (dapm_seq_compare(new_widget, w, power_up) < 0) {
10             list_add_tail(&new_widget->power_list, &w->power_list);
11             return;
12         }
13 
14     list_add_tail(&new_widget->power_list, list);
15 }

上述函数会按照一定的顺序把widget加入到链表中，从而保证正确的上下电顺序：

 1 /* dapm power sequences - make this per codec in the future */
 2 //上电顺序
 3 static int dapm_up_seq[] = {
 4     [snd_soc_dapm_pre] = 0,
 5     [snd_soc_dapm_regulator_supply] = 1,
 6     [snd_soc_dapm_clock_supply] = 1,
 7     [snd_soc_dapm_supply] = 2,
 8     [snd_soc_dapm_micbias] = 3,
 9     [snd_soc_dapm_dai_link] = 2,
10     [snd_soc_dapm_dai_in] = 4,
11     [snd_soc_dapm_dai_out] = 4,
12     [snd_soc_dapm_aif_in] = 4,
13     [snd_soc_dapm_aif_out] = 4,
14     [snd_soc_dapm_mic] = 5,
15     [snd_soc_dapm_mux] = 6,
16     [snd_soc_dapm_demux] = 6,
17     [snd_soc_dapm_dac] = 7,
18     [snd_soc_dapm_switch] = 8,
19     [snd_soc_dapm_mixer] = 8,
20     [snd_soc_dapm_mixer_named_ctl] = 8,
21     [snd_soc_dapm_pga] = 9,
22     [snd_soc_dapm_adc] = 10,
23     [snd_soc_dapm_out_drv] = 11,
24     [snd_soc_dapm_hp] = 11,
25     [snd_soc_dapm_spk] = 11,
26     [snd_soc_dapm_line] = 11,
27     [snd_soc_dapm_kcontrol] = 12,
28     [snd_soc_dapm_post] = 13,
29 };
30 //下点顺序
31 static int dapm_down_seq[] = {
32     [snd_soc_dapm_pre] = 0,
33     [snd_soc_dapm_kcontrol] = 1,
34     [snd_soc_dapm_adc] = 2,
35     [snd_soc_dapm_hp] = 3,
36     [snd_soc_dapm_spk] = 3,
37     [snd_soc_dapm_line] = 3,
38     [snd_soc_dapm_out_drv] = 3,
39     [snd_soc_dapm_pga] = 4,
40     [snd_soc_dapm_switch] = 5,
41     [snd_soc_dapm_mixer_named_ctl] = 5,
42     [snd_soc_dapm_mixer] = 5,
43     [snd_soc_dapm_dac] = 6,
44     [snd_soc_dapm_mic] = 7,
45     [snd_soc_dapm_micbias] = 8,
46     [snd_soc_dapm_mux] = 9,
47     [snd_soc_dapm_demux] = 9,
48     [snd_soc_dapm_aif_in] = 10,
49     [snd_soc_dapm_aif_out] = 10,
50     [snd_soc_dapm_dai_in] = 10,
51     [snd_soc_dapm_dai_out] = 10,
52     [snd_soc_dapm_dai_link] = 11,
53     [snd_soc_dapm_supply] = 12,
54     [snd_soc_dapm_clock_supply] = 13,
55     [snd_soc_dapm_regulator_supply] = 13,
56     [snd_soc_dapm_post] = 14,
57 };

5 widget的上电和下电过程

5.1 函数dapm_power_widgets

当一个widget的状态改变后，该widget会被加入dapm_dirty链表，然后通过dapm_power_widgets函数来改变整个音频路径上的电源状态。

  1 static int dapm_power_widgets(struct snd_soc_card *card, int event)
  2 {
  3     struct snd_soc_dapm_widget *w;
  4     struct snd_soc_dapm_context *d;
  5     LIST_HEAD(up_list);
  6     LIST_HEAD(down_list);
  7     ASYNC_DOMAIN_EXCLUSIVE(async_domain);
  8     enum snd_soc_bias_level bias;
  9 
 10     lockdep_assert_held(&card->dapm_mutex);
 11 
 12     trace_snd_soc_dapm_start(card);
 13 
 14     list_for_each_entry(d, &card->dapm_list, list) {
 15         if (dapm_idle_bias_off(d))
 16             d->target_bias_level = SND_SOC_BIAS_OFF;
 17         else
 18             d->target_bias_level = SND_SOC_BIAS_STANDBY;
 19     }
 20 
 21     dapm_reset(card);
 22 
 23     /* Check which widgets we need to power and store them in
 24      * lists indicating if they should be powered up or down.  We
 25      * only check widgets that have been flagged as dirty but note
 26      * that new widgets may be added to the dirty list while we
 27      * iterate.
 28      */
 29     list_for_each_entry(w, &card->dapm_dirty, dirty) {
 30         dapm_power_one_widget(w, &up_list, &down_list);
 31     }
 32 
 33     list_for_each_entry(w, &card->widgets, list) {
 34         switch (w->id) {
 35         case snd_soc_dapm_pre:
 36         case snd_soc_dapm_post:
 37             /* These widgets always need to be powered */
 38             break;
 39         default:
 40             list_del_init(&w->dirty);
 41             break;
 42         }
 43 
 44         if (w->new_power) {
 45             d = w->dapm;
 46 
 47             /* Supplies and micbiases only bring the
 48              * context up to STANDBY as unless something
 49              * else is active and passing audio they
 50              * generally don't require full power.  Signal
 51              * generators are virtual pins and have no
 52              * power impact themselves.
 53              */
 54             switch (w->id) {
 55             case snd_soc_dapm_siggen:
 56             case snd_soc_dapm_vmid:
 57                 break;
 58             case snd_soc_dapm_supply:
 59             case snd_soc_dapm_regulator_supply:
 60             case snd_soc_dapm_clock_supply:
 61             case snd_soc_dapm_micbias:
 62                 if (d->target_bias_level < SND_SOC_BIAS_STANDBY)
 63                     d->target_bias_level = SND_SOC_BIAS_STANDBY;
 64                 break;
 65             default:
 66                 d->target_bias_level = SND_SOC_BIAS_ON;
 67                 break;
 68             }
 69         }
 70 
 71     }
 72 
 73     /* Force all contexts in the card to the same bias state if
 74      * they're not ground referenced.
 75      */
 76     bias = SND_SOC_BIAS_OFF;
 77     list_for_each_entry(d, &card->dapm_list, list)
 78         if (d->target_bias_level > bias)
 79             bias = d->target_bias_level;
 80     list_for_each_entry(d, &card->dapm_list, list)
 81         if (!dapm_idle_bias_off(d))
 82             d->target_bias_level = bias;
 83 
 84     trace_snd_soc_dapm_walk_done(card);
 85 
 86     /* Run card bias changes at first */
 87     dapm_pre_sequence_async(&card->dapm, 0);
 88     /* Run other bias changes in parallel */
 89     list_for_each_entry(d, &card->dapm_list, list) {
 90         if (d != &card->dapm)
 91             async_schedule_domain(dapm_pre_sequence_async, d,
 92                         &async_domain);
 93     }
 94     async_synchronize_full_domain(&async_domain);
 95 
 96     list_for_each_entry(w, &down_list, power_list) {
 97         dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD);
 98     }
 99 
100     list_for_each_entry(w, &up_list, power_list) {
101         dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU);
102     }
103 
104     /* Power down widgets first; try to avoid amplifying pops. */
105     dapm_seq_run(card, &down_list, event, false);
106 
107     dapm_widget_update(card);
108 
109     /* Now power up. */
110     dapm_seq_run(card, &up_list, event, true);
111 
112     /* Run all the bias changes in parallel */
113     list_for_each_entry(d, &card->dapm_list, list) {
114         if (d != &card->dapm)
115             async_schedule_domain(dapm_post_sequence_async, d,
116                         &async_domain);
117     }
118     async_synchronize_full_domain(&async_domain);
119     /* Run card bias changes at last */
120     dapm_post_sequence_async(&card->dapm, 0);
121 
122     /* do we need to notify any clients that DAPM event is complete */
123     list_for_each_entry(d, &card->dapm_list, list) {
124         if (d->stream_event)
125             d->stream_event(d, event);
126     }
127 
128     pop_dbg(card->dev, card->pop_time,
129         "DAPM sequencing finished, waiting %dms\n", card->pop_time);
130     pop_wait(card->pop_time);
131 
132     trace_snd_soc_dapm_done(card);
133 
134     return 0;
135 }

分析如下：

（1）可见，该函数通过遍历dapm_dirty链表，对每个链表中的widget调用dapm_power_one_widget，dapm_power_one_widget函数除了处理自身的状态改变外，还把自身的变化传递到和它相连的邻居widget中，结果就是，所有需要上电的widget会被放在up_list链表中，而所有需要下电的widget会被放在down_list链表中，这个函数我们稍后再讨论。
（2）遍历down_list链表，向其中的widget发出SND_SOC_DAPM_WILL_PMD事件，感兴趣该事件的widget的event回调会被调用。
（3）遍历up_list链表，向其中的widget发出SND_SOC_DAPM_WILL_PMU事件，感兴趣该事件的widget的event回调会被调用。
（4）通过dapm_seq_run函数，处理down_list中的widget，使它们按定义好的顺序依次下电。
（5）通过dapm_widget_update函数，切换触发该次状态变化的widget的kcontrol中的寄存器值，对应的结果就是：改变音频路径。
（6）通过dapm_seq_run函数，处理up_list中的widget，使它们按定义好的顺序依次上电。
（7）对每个dapm context发出状态改变回调。
（8）适当的延时，防止pop-pop声。

调用过程如下：

5.2 函数dapm_power_one_widget

dapm_power_widgets的第一步，就是遍历dapm_dirty链表，对每个链表中的widget调用dapm_power_one_widget，把需要上电和需要下电的widget分别加入到up_list和down_list链表中，同时，他还会把受到影响的邻居widget再次加入到dapm_dirty链表的末尾，通过这个动作，声卡中所以受到影响的widget都会被“感染”，依次被加到dapm_dirty链表，然后依次被执行dapm_power_one_widget函数。dapm_power_one_widget函数定义如下：

 1 static void dapm_power_one_widget(struct snd_soc_dapm_widget *w,
 2                   struct list_head *up_list,
 3                   struct list_head *down_list)
 4 {
 5     int power;
 6 
 7     switch (w->id) {
 8     case snd_soc_dapm_pre:
 9         dapm_seq_insert(w, down_list, false);
10         break;
11     case snd_soc_dapm_post:
12         dapm_seq_insert(w, up_list, true);
13         break;
14 
15     default:
16         power = dapm_widget_power_check(w);
17 
18         dapm_widget_set_power(w, power, up_list, down_list);
19         break;
20     }
21 }

作用如下：

（1）通过dapm_widget_power_check，调用widget的power_check回调函数，获得该widget新的电源状态。
（2）调用dapm_widget_set_power，“感染”与之相连的邻居widget。
（3）遍历source widget，通过dapm_widget_set_peer_power函数，把处于连接状态的source widget加入dapm_dirty链表中。
（4）遍历sink widget，通过dapm_widget_set_peer_power函数，把处于连接状态的sink widget加入dapm_dirty链表中。
（5）根据第一步得到的新的电源状态，把widget加入到up_list或down_list链表中。

可见，通过该函数，一个widget的状态改变，邻居widget会受到“感染”而被加入到dapm_dirty链表的末尾，所以扫描到链表的末尾时，邻居widget也会执行同样的操作，从而“感染”邻居的邻居，直到没有新的widget被加入dapm_dirty链表为止，这时，所有受到影响的widget都被加入到up_list或down_li链表中，等待后续的上下电操作。可谓牵一发而动全身。
dapm_power_one_widget函数的调用过程如下：

5.3 函数dapm_seq_run

以上上电过程，当所有需要上电或下电的widget都被加入到dapm_dirty链表后，接着会通过dapm_seq_run处理down_list链表上的widget，把该链表上的widget按顺序下电，然后通过dapm_widget_update更新widget中的kcontrol（这个kcontrol通常就是触发本次状态改变的触发源），接着又通过apm_seq_run处理up_list链表上的widget，把该链表上的widget按顺序上电。最终的上电或下电操作需要通过codec的寄存器来实现，因为定义widget时，如果这是一个带电源控制的widget，我们必须提供reg/shift等字段的设置值，如果该widget无需寄存器控制电源状态，则reg字段必须赋值为：

SND_SOC_NOPM        (该宏定义的实际值是-1)

函数定义：

具体实现上，dapm框架使用了一点技巧：如果位于同一个上下电顺序的几个widget使用了同一个寄存器地址（一个寄存器可能使用不同的位来控制不同的widget的电源状态），dapm_seq_run通过dapm_seq_run_coalesced函数合并这几个widget的变更，然后只需要把合并后的值一次写入寄存器即可。

  1 static void dapm_seq_run(struct snd_soc_card *card,
  2     struct list_head *list, int event, bool power_up)
  3 {
  4     struct snd_soc_dapm_widget *w, *n;
  5     struct snd_soc_dapm_context *d;
  6     LIST_HEAD(pending);
  7     int cur_sort = -1;
  8     int cur_subseq = -1;
  9     int cur_reg = SND_SOC_NOPM;
 10     struct snd_soc_dapm_context *cur_dapm = NULL;
 11     int ret, i;
 12     int *sort;
 13 
 14     if (power_up)
 15         sort = dapm_up_seq;
 16     else
 17         sort = dapm_down_seq;
 18 
 19     list_for_each_entry_safe(w, n, list, power_list) {
 20         ret = 0;
 21 
 22         /* Do we need to apply any queued changes? */
 23         if (sort[w->id] != cur_sort || w->reg != cur_reg ||
 24             w->dapm != cur_dapm || w->subseq != cur_subseq) {
 25             if (!list_empty(&pending))
 26                 dapm_seq_run_coalesced(card, &pending);//合并这几个widget的变更，然后只需要把合并后的值一次写入寄存器即可
 27 
 28             if (cur_dapm && cur_dapm->seq_notifier) {
 29                 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
 30                     if (sort[i] == cur_sort)
 31                         cur_dapm->seq_notifier(cur_dapm,
 32                                        i,
 33                                        cur_subseq);
 34             }
 35 
 36             if (cur_dapm && w->dapm != cur_dapm)
 37                 soc_dapm_async_complete(cur_dapm);
 38 
 39             INIT_LIST_HEAD(&pending);
 40             cur_sort = -1;
 41             cur_subseq = INT_MIN;
 42             cur_reg = SND_SOC_NOPM;
 43             cur_dapm = NULL;
 44         }
 45 
 46         switch (w->id) {
 47         case snd_soc_dapm_pre:
 48             if (!w->event)
 49                 list_for_each_entry_safe_continue(w, n, list,
 50                                   power_list);
 51 
 52             if (event == SND_SOC_DAPM_STREAM_START)
 53                 ret = w->event(w,
 54                            NULL, SND_SOC_DAPM_PRE_PMU);
 55             else if (event == SND_SOC_DAPM_STREAM_STOP)
 56                 ret = w->event(w,
 57                            NULL, SND_SOC_DAPM_PRE_PMD);
 58             break;
 59 
 60         case snd_soc_dapm_post:
 61             if (!w->event)
 62                 list_for_each_entry_safe_continue(w, n, list,
 63                                   power_list);
 64 
 65             if (event == SND_SOC_DAPM_STREAM_START)
 66                 ret = w->event(w,
 67                            NULL, SND_SOC_DAPM_POST_PMU);
 68             else if (event == SND_SOC_DAPM_STREAM_STOP)
 69                 ret = w->event(w,
 70                            NULL, SND_SOC_DAPM_POST_PMD);
 71             break;
 72 
 73         default:
 74             /* Queue it up for application */
 75             cur_sort = sort[w->id];
 76             cur_subseq = w->subseq;
 77             cur_reg = w->reg;
 78             cur_dapm = w->dapm;
 79             list_move(&w->power_list, &pending);
 80             break;
 81         }
 82 
 83         if (ret < 0)
 84             dev_err(w->dapm->dev,
 85                 "ASoC: Failed to apply widget power: %d\n", ret);
 86     }
 87 
 88     if (!list_empty(&pending))
 89         dapm_seq_run_coalesced(card, &pending);
 90 
 91     if (cur_dapm && cur_dapm->seq_notifier) {
 92         for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++)
 93             if (sort[i] == cur_sort)
 94                 cur_dapm->seq_notifier(cur_dapm,
 95                                i, cur_subseq);
 96     }
 97 
 98     list_for_each_entry(d, &card->dapm_list, list) {
 99         soc_dapm_async_complete(d);
100     }
101 }

6 触发dapm扫描操作

上面我们已经讨论了如何判断一个widget是否需要上电，以及widget的上电过程，一个widget的状态改变如何传递到整个音频路径上的所有widget。这些过程总是需要一个起始点：是谁触动了dapm，使得它需要执行上述的扫描和上电过程？事实上，以下几种情况可以触发dapm发起一次扫描操作：

（1）声卡初始化阶段，snd_soc_dapm_new_widgets函数创建widget包含的kcontrol后，会触发一次扫描操作。
（2）用户空间的应用程序修改了widget中包含的dapm kcontrol的配置值时，会触发一次扫描操作。
（3）pcm的打开或关闭，会通过音频流widget触发一次扫描操作。
（4）驱动程序在改变了某个widget并把它加入到dapm_dirty链表后，主动调用snd_soc_dapm_sync函数触发扫描操作。
这里我们主要讨论一下第二种，用户空间对kcontrol的修改，最终都会调用到kcontrol的put回调函数。对于常用的dapm kcontrol，系统已经为我们定义好了它们的put回调函数：

1 snd_soc_dapm_put_volsw                                  mixer类型的dapm kcontrol使用的put回调
2 snd_soc_dapm_put_enum_double                   mux类型的dapm kcontrol使用的put回调
3 snd_soc_dapm_put_enum_virt                          虚拟mux类型的dapm kcontrol使用的put回调
4 snd_soc_dapm_put_value_enum_double      控制值不连续的mux类型的dapm kcontrol使用的put回调
5 snd_soc_dapm_put_pin_switch                         引脚类dapm kcontrol使用的put回调

我们以mixer类型的dapm kcontrol的put回调讲解一下触发的过程：

6.1 函数snd_soc_dapm_put_volsw

 1 /**
 2  * snd_soc_dapm_put_volsw - dapm mixer set callback
 3  * @kcontrol: mixer control
 4  * @ucontrol: control element information
 5  *
 6  * Callback to set the value of a dapm mixer control.
 7  *
 8  * Returns 0 for success.
 9  */
10 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol,
11     struct snd_ctl_elem_value *ucontrol)
12 {
13     struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
14     struct snd_soc_card *card = dapm->card;
15     struct soc_mixer_control *mc =
16         (struct soc_mixer_control *)kcontrol->private_value;
17     int reg = mc->reg;
18     unsigned int shift = mc->shift;
19     int max = mc->max;
20     unsigned int mask = (1 << fls(max)) - 1;
21     unsigned int invert = mc->invert;
22     unsigned int val;
23     int connect, change, reg_change = 0;
24     struct snd_soc_dapm_update update;
25     int ret = 0;
26 
27     if (snd_soc_volsw_is_stereo(mc))
28         dev_warn(dapm->dev,
29              "ASoC: Control '%s' is stereo, which is not supported\n",
30              kcontrol->id.name);
31     /*从参数中取出要设置的新的设置值*/
32     val = (ucontrol->value.integer.value[0] & mask);
33     connect = !!val;
34 
35     if (invert)
36         val = max - val;
37 
38     mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
39     
40     change = dapm_kcontrol_set_value(kcontrol, val);//把新的设置值缓存到kcontrol的影子widget中
41 
42     if (reg != SND_SOC_NOPM) {
43         mask = mask << shift;
44         val = val << shift;
45 
46         reg_change = soc_dapm_test_bits(dapm, reg, mask, val);
47     }
48 /*和实际寄存器中的值进行对比，不一样时才会触发寄存器的写入;寄存器通常都会通过regmap机制进行缓存，所以这个测试不会发生实际的寄存器读取操作;*/
49     if (change || reg_change) {//这里只是触发，真正的寄存器写入操作要在扫描完dapm_dirty链表后的执行
50         if (reg_change) {
51             update.kcontrol = kcontrol;
52             update.reg = reg;
53             update.mask = mask;
54             update.val = val;
55             card->update = &update;
56         }
57         change |= reg_change;
58 
59         ret = soc_dapm_mixer_update_power(card, kcontrol, connect);//触发dapm的上下电扫描过程
60 
61         card->update = NULL;
62     }
63 
64     mutex_unlock(&card->dapm_mutex);
65 
66     if (ret > 0)
67         soc_dpcm_runtime_update(card);
68 
69     return change;
70 }

其中的dapm_kcontrol_set_value函数用于把设置值缓存到kcontrol对应的影子widget，影子widget是为了实现autodisable特性而创建的一个虚拟widget，影子widget的输出连接到kcontrol的source widget，影子widget的寄存器被设置为和kcontrol一样的寄存器地址，这样当source widget被关闭时，会触发影子widget被关闭，其作用就是kcontrol也被自动关闭从而在物理上断开与source widget的连接，但是此时逻辑连接依然有效，dapm依然认为它们是连接在一起的。
6.2 函数soc_dapm_mixer_update_power

触发dapm进行电源状态扫描关键函数

 1 static int soc_dapm_mixer_update_power(struct snd_soc_card *card,
 2                                    struct snd_kcontrol *kcontrol, int connect)
 3 {
 4         struct snd_soc_dapm_path *path;
 5         int found = 0;
 6  
 7         /* 更新所有和该kcontrol对应输入端相连的path的connect字段 */
 8         dapm_kcontrol_for_each_path(path, kcontrol) {
 9                 found = 1;
10                soc_dapm_connect_path(path, connect, "mixer update");
11         }
12         /* 发起dapm_dirty链表扫描和上下电过程 */
13         if (found)
14                 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);
15  
16         return found;
17 }

函数soc_dapm_connect_path

 1 static void soc_dapm_connect_path(struct snd_soc_dapm_path *path,
 2     bool connect, const char *reason)
 3 {
 4     if (path->connect == connect)
 5         return;
 6 
 7     path->connect = connect;
 8          /*把自己和相连的source widget加入到dirty链表中*/
 9     dapm_mark_dirty(path->source, reason);
10     dapm_mark_dirty(path->sink, reason);
11     dapm_path_invalidate(path);
12 }

最终，还是通过dapm_power_widgets函数，触发整个音频路径的扫描过程，这个函数执行后，因为kcontrol的状态改变，被断开连接的音频路径上的所有widget被按顺序下电，而重新连上的音频路径上的所有widget被顺序地上电，所以，尽管我们只改变了mixer kcontrol中的一个输入端的连接状态，所有相关的widget的电源状态都会被重新设定，这一切，都是自动完成的，对用户空间的应用程序完全透明，实现了dapm的原本设计目标。
总结下整个mixer类型的dapm kcontrol的put回调触发的过程：

参考博文：https://blog.csdn.net/DroidPhone/java/article/details/14146319

免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。

猜您在找 linux-alsa详解8之DAPM详解1kcontrol linux-alsa详解13之DAPM详解6音频路径route linux-alsa详解11之DAPM详解4驱动中widget初始化 linux-alsa详解3 control设备 linux-alsa详解4 ASOC介绍 linux-alsa详解1 基本知识 linux-alsa详解2 pcm设备 linux-alsa详解5 ASOC-platform ALSA声卡驱动的DAPM（一）-DPAM详解 ALSA声卡驱动中的DAPM详解之一：kcontrol