Rockchip RK3399 - DAPM Widget&Route&Path

最新推荐文章于 2024-10-16 20:38:13 发布

Graceful_scenery

最新推荐文章于 2024-10-16 20:38:13 发布

阅读量175

点赞数

本文链接：https://blog.csdn.net/Graceful_scenery/article/details/132243310

版权

本文详细介绍了Rockchip RK3399平台中DAPM（动态音频电源管理）框架的工作原理，包括Widget、Path和Route的概念及相互关系。DAPM用于管理音频系统的电源，确保在不同操作状态下使用最少的电量。文章通过结构体snd_soc_dapm_widget解释了Widget的构成和类型，并展示了如何使用宏定义创建和管理Widget。同时，文中还讨论了Path的结构以及Route的定义方法。此外，文章还涵盖了DAPM事件处理机制，包括事件种类、触发事件的时机以及事件处理函数。最后，通过实际案例展示了如何在Codec驱动和Machine驱动中定义和注册Widget及Route。

摘要由CSDN通过智能技术生成

----------------------------------------------------------------------------------------------------------------------------

开发板：NanoPC-T4开发板eMMC ：16GBLPDDR3 ：4GB显示屏：15.6英寸HDMI接口显示屏u-boot ：2023.04linux ：6.3----------------------------------------------------------------------------------------------------------------------------

DAPM是Dynamic Audio Power Management 的缩写，即动态音频电源管理，旨在允许便携式Linux设备在任何时候使用音频子系统中的最小电量。它独立于其他内核Power Manager，故可以很容易地与其他PM系统共存。

DAPM对所有用户空间应用程序来说也是完全透明的，因为所有电源切换都是在ASoC核心内完成。对于用户空间应用程序，不需要更改代码或重新编译。DAPM 根据当前激活的音频流(playback/capture)和声卡中的Mixer等的配置来决定哪些音频控件的电源开关被打开或关闭。

DAPM贯穿了整个音频子系统的电源控制，它包括了内部codec的电源模块以及machine级别的电源系统。

在声卡之Control设备我们介绍过，通过Control设备我们可以完成对音频系统中的某个kcontrol的控制，比如音量控制、混音控制(Mixer)、开关控制(Mux)等，使得音频控件能够按照我们预想的结果进行工作。同时我们可以看到，kcontrol还是有以下几点不足：

只能描述自身，无法描述各个kcontrol之间的连接关系；
没有相应的电源管理机制；
没有相应的时间处理机制来响应播放、停止、上电、下电等音频事件；
为了防止pop-pop 声，需要用户程序关注各个kcontrol上电和下电的顺序；
当一个音频路径不再有效时，不能自动关闭该路径上的所有的kcontrol；

为此，DAPM 框架正是为了解决以上这些问题而诞生的。

一、Widget

DAPM框架为了解决前面kcontrol不足的问题，引入了widget这一概念。所谓widget，具备路径和电源管理的kcontrol，其实可以理解为是kcontrol的进一步升级和封装，它同样是指音频系统中的某个部件，比如Mixer，Mux，DAC、ADC、Input等等。

widget把kcontrol和动态电源管理进行了有机的结合，同时还具备音频路径的连结功能，一个widget可以和它相邻的widget有某种动态的连结关系。

1.1 struct snd_soc_dapm_widget

在DAPM框架中，widget用结构体snd_soc_dapm_widget 来描述，定义位于include/sound/soc-dapm.h文件；

/* dapm widget */
struct snd_soc_dapm_widget {
        enum snd_soc_dapm_type id;
        const char *name;                       /* widget name */
        const char *sname;                      /* stream name */
        struct list_head list;
        struct snd_soc_dapm_context *dapm;

        void *priv;                             /* widget specific data */
        struct regulator *regulator;            /* attached regulator */
        struct pinctrl *pinctrl;                /* attached pinctrl */

        /* dapm control */
        int reg;                                /* negative reg = no direct dapm */
        unsigned char shift;                    /* bits to shift */
        unsigned int mask;                      /* non-shifted mask */
        unsigned int on_val;                    /* on state value */
        unsigned int off_val;                   /* off state value */
        unsigned char power:1;                  /* block power status */
        unsigned char active:1;                 /* active stream on DAC, ADC's */
        unsigned char connected:1;              /* connected codec pin */
        unsigned char new:1;                    /* cnew complete */
        unsigned char force:1;                  /* force state */
        unsigned char ignore_suspend:1;         /* kept enabled over suspend */
        unsigned char new_power:1;              /* power from this run */
        unsigned char power_checked:1;          /* power checked this run */
        unsigned char is_supply:1;              /* Widget is a supply type widget */
        unsigned char is_ep:2;                  /* Widget is a endpoint type widget */
        int subseq;                             /* sort within widget type */

        int (*power_check)(struct snd_soc_dapm_widget *w);

        /* external events */
        unsigned short event_flags;             /* flags to specify event types */
        int (*event)(struct snd_soc_dapm_widget*, struct snd_kcontrol *, int);

        /* kcontrols that relate to this widget */
        int num_kcontrols;
        const struct snd_kcontrol_new *kcontrol_news;
        struct snd_kcontrol **kcontrols;
        struct snd_soc_dobj dobj;

        /* widget input and output edges */
        struct list_head edges[2];

        /* used during DAPM updates */
        struct list_head work_list;
        struct list_head power_list;
        struct list_head dirty;
        int endpoints[2];

        struct clk *clk;

        int channel;
};

该结构体包含了以下成员：

id：widget的类型值，比如snd_soc_dapm_output，snd_soc_dapm_mixer等；
name：widget的名称；
sname：widget所在stream的名字，比如对于snd_soc_dapm_dai_in、snd_soc_dapm_dai_out、snd_soc_dapm_aif_in、snd_soc_dapm_aif_out、snd_soc_dapm_dac、snd_soc_dapm_adc类型的widget，会使用该字段；
list ：所有注册到系统中的widget都会通过该list，链接到代表声卡的snd_soc_card结构的widgets链表中；
dapm：snd_soc_dapm_context结构指针，ASoc把系统划分为多个dapm域，每个widget属于某个dapm域，同一个域代表着同样的偏置电压供电策略；比如，同一个codec中的widget通常位于同一个dapm域，而platform上的widget可能又会位于另外一个dapm域中；
priv：有些widget可能需要一些专有的数据，可以使用该字段来保存，像snd_soc_dapm_dai_in类型的widget，会使用该字段来记住与之相关联的snd_soc_dai结构指针；
regulator：对于snd_soc_dapm_regulator_supply类型的widget，该字段指向与之相关的regulator结构指针；
pinctrl：指向snd_soc_dapm_pinctrl类型的widget，该字段指向与与之相关的pinctrl结构指针；
reg：用于直接DAPM控制的寄存器地址，负值表示没有直接DAPM控制；
shift：需要进行位移的位数；
mask：未经过位移的屏蔽掩码；
on_val：电源开启时的值；
off_val：电源关闭时的值；
power：表示widget的电源状态，上电/下电状态；
active：表示当前widget是否处于激活状态；
connected：表示当前widget是否处于连接状态，新创建的widget默认都是处于连接状态的；需要注意的是这个和path的连接状态没有任何关系，path的连接状态描述的是两个widget之间的连接状态，而widget的连接状态可以看做widget内部有个虚拟开关，用于控制当前widget是否可用的；这个主要的应用场景：判断一个widget是否处于一个complete path上时要求路径上的widget必须是连接状态；
new：我们定义好的widget(snd_soc_dapm_widget结构)，在注册到声卡中时需要进行实例化，该字段用来表示该widget是否已经执行过snd_soc_dapm_new_widgets函数；
force：该位被设置后，将会不管widget当前的状态，强制更新至新的电源状态；
ignore_suspend：保持在挂起期间启用；
new_power：电源状态，运行时的电源状态；
power_checked：用作标志位，标志当前widget的电源状态是否已经检查过；如果为false表明需要执行power_check方法检查电源状态；
is_supply：该widget是供电类型的组件；
is_ep：该widget是端点类型的组件，取值一般为SND_SOC_DAPM_EP_SOURCE、SND_SOC_DAPM_EP_SINK；
subseq：序号，用于在上电/下电时对widget进行排序；
int (*power_check)(struct snd_soc_dapm_widget *w)：指向函数的指针，用于检查电源状态；
event_flags：用于指定事件类型的标志；
int (*event)(struct snd_soc_dapm_widget*, struct snd_kcontrol *, int)：指向函数的指针，用于处理外部事件；
num_kcontrols：kcontrol数量；
kcontrol_news：kcontrol模板数组，长度等于num_kcontrols，每一个成员都是struct snd_kcontrol_new；对于Mixer、Mux等类型的widget需要在使用辅助宏定义widget的时候指定该参数；
kcontrols：指向一个指针数组，指针数组长度等于num_kcontrols。指针数组每一个成员都指向一个struct snd_kcontrol，是以kcontrol模板为参数，调用snd_soc_cnew函数创建得到的；可以简单理解为kcontrols[i] = snd_soc_cnew(kcontrol_news[i],NULL,name,prefix)；
dobj，
edges：widget的输入端和输出端，输入端和输出端中都是保存snd_soc_dapm_path的链表，区别在于输入端中的snd_soc_dapm_path其source为当前widget，而输出端中的snd_soc_dapm_path其sink为当前widget；
work_list：链表节点，在widget连接状态发生改变时使用；
power_list：链表节点，在widget连接状态发生改变时使用；
dirty：链表节点，用于链接到声卡card的dapm_dirty链表；
endpoints：元素0保存从当前widget向后遍历，连接至SND_SOC_DAPM_EP_SOURCE类型端点的路径数量；元素1保存从当前widget向后遍历，连接至SND_SOC_DAPM_EP_SINK类型端点的路径数量；如果元素值为-1，表示该成员尚未初始化；
clk：对于snd_soc_dapm_clock_supply类型的widget，该字段指向与之相关的clk结构指针；
channel：通道数；

1.1.1 widaget类型

在DAPM框架中，把各种不同的widget划分为不同的种类，snd_soc_dapm_widget 结构中的id字段用来表示该widget 的种类，可选的种类都定义在一个枚举中，如下：

/* dapm widget types */
enum snd_soc_dapm_type {
        snd_soc_dapm_input = 0,         /* input pin */
        snd_soc_dapm_output,            /* output pin */
        snd_soc_dapm_mux,               /* selects 1 analog signal from many inputs */
        snd_soc_dapm_demux,             /* connects the input to one of multiple outputs */
        snd_soc_dapm_mixer,             /* mixes several analog signals together */
        snd_soc_dapm_mixer_named_ctl,   /* mixer with named controls */
        snd_soc_dapm_pga,               /* programmable gain/attenuation (volume) */
        snd_soc_dapm_out_drv,           /* output driver */
        snd_soc_dapm_adc,               /* analog to digital converter */
        snd_soc_dapm_dac,               /* digital to analog converter */
        snd_soc_dapm_micbias,           /* microphone bias (power) - DEPRECATED: use snd_soc_dapm_supply */
        snd_soc_dapm_mic,               /* microphone */
        snd_soc_dapm_hp,                /* headphones */
        snd_soc_dapm_spk,               /* speaker */
        snd_soc_dapm_line,              /* line input/output */
        snd_soc_dapm_switch,            /* analog switch */
        snd_soc_dapm_vmid,              /* codec bias/vmid - to minimise pops */
        snd_soc_dapm_pre,               /* machine specific pre widget - exec first */
        snd_soc_dapm_post,              /* machine specific post widget - exec last */
        snd_soc_dapm_supply,            /* power/clock supply */
        snd_soc_dapm_pinctrl,           /* pinctrl */
        snd_soc_dapm_regulator_supply,  /* external regulator */
        snd_soc_dapm_clock_supply,      /* external clock */
        snd_soc_dapm_aif_in,            /* audio interface input */
        snd_soc_dapm_aif_out,           /* audio interface output */
        snd_soc_dapm_siggen,            /* signal generator */
        snd_soc_dapm_sink,
        snd_soc_dapm_dai_in,            /* link to DAI structure */
        snd_soc_dapm_dai_out,
        snd_soc_dapm_dai_link,          /* link between two DAI structures */
        snd_soc_dapm_kcontrol,          /* Auto-disabled kcontrol */
        snd_soc_dapm_buffer,            /* DSP/CODEC internal buffer */
        snd_soc_dapm_scheduler,         /* DSP/CODEC internal scheduler */
        snd_soc_dapm_effect,            /* DSP/CODEC effect component */
        snd_soc_dapm_src,               /* DSP/CODEC SRC component */
        snd_soc_dapm_asrc,              /* DSP/CODEC ASRC component */
        snd_soc_dapm_encoder,           /* FW/SW audio encoder component */
        snd_soc_dapm_decoder,           /* FW/SW audio decoder component */

        /* Don't edit below this line */
        SND_SOC_DAPM_TYPE_COUNT
};

View Code

上面的枚举值实际上是与不同的widget一一对应的，具体如下；

Mixer:Mixes：several analog signals into a single analog signal;
Mux：An analog switch that outputs only one of many inputs;
PGA：A programmable gain amplifier or attenuation widget;
ADC：Analog to Digital Converter;
DAC：Digital to Analog Converter;
Switch：An analog switch;
Input：A codec input pin;
Output：A codec output pin;
Headphone：Headphone (and optional Jack);
Mic：Mic (and optional Jack);
Line：Line Input/Output (and optional Jack);
Speaker：Speaker;
Supply：Power or clock supply widget used by other widgets;
Regulator：External regulator that supplies power to audio components;
Clock：External clock that supplies clock to audio components;
AIF IN：Audio Interface Input (with TDM slot mask);
AIF OUT：Audio Interface Output (with TDM slot mask);
Siggen：Signal Generator;
DAI IN：Digital Audio Interface Input;
DAI OUT：Digital Audio Interface Output;
DAI Link：DAI Link between two DAI structures;
Pre：Special PRE widget (exec before all others);
Post：Special POST widget (exec after all others);
Buffer：Inter widget audio data buffer within a DSP;
Scheduler：DSP internal scheduler that schedules component/pipeline processing work;
Effect：Widget that performs an audio processing effect;
SRC：Sample Rate Converter within DSP or CODEC;
ASRC：Asynchronous Sample Rate Converter within DSP or CODEC;
Encoder：Widget that encodes audio data from one format (usually PCM) to another usually more compressed format;
Decoder：Widget that decodes audio data from a compressed format to an uncompressed format like PCM;

1.1.2 snd_soc_dapm_context

ASoc把系统划分为多个dapm域(会或者说上下文)，我们应该如何去理解dapm域的概念？其实我们可以这么理解：dapm把整个音频系统，按照功能和偏置电压级别，划分为若干个电源域，每个域包含各自的widget，每个域中的所有widget通常都处于同一个偏置电压级别上，而一个电源域就是一个dapm context，通常会有以下几种dapm context：

属于codec中的widget位于一个dapm context中；
属于platform的widget位于一个dapm context中；
属于整个声卡的widget位于一个dapm context中；

对于音频系统的硬件来说，通常要提供合适的偏置电压才能正常地工作，有了dapm context这种组织方式，我们可以方便地对同一组widget进行统一的偏置电压管理。

dapm域在ASoC中使用struct snd_soc_dapm_context表示；

/* DAPM context */
struct snd_soc_dapm_context {
        enum snd_soc_bias_level bias_level;

        /* bit field */
        unsigned int idle_bias_off:1;           /* Use BIAS_OFF instead of STANDBY */
        unsigned int suspend_bias_off:1;        /* Use BIAS_OFF in suspend if the DAPM is idle */

        struct device *dev;                     /* from parent - for debug */
        struct snd_soc_component *component;    /* parent component */
        struct snd_soc_card *card;              /* parent card */

        /* used during DAPM updates */
        enum snd_soc_bias_level target_bias_level;
        struct list_head list;  // 链表节点，用于添加到声卡card的dapm_list链表中

        struct snd_soc_dapm_widget *wcache_sink;
        struct snd_soc_dapm_widget *wcache_source;

#ifdef CONFIG_DEBUG_FS
        struct dentry *debugfs_dapm;
#endif
};

snd_soc_bias_level的取值范围是以下几种：

SND_SOC_BIAS_OFF；
SND_SOC_BIAS_STANDBY；
SND_SOC_BIAS_PREPARE；
SND_SOC_BIAS_ON。

1.2 辅助宏定义widget

一个widget用snd_soc_dapm_widget结构体来描述，通常，我们会根据音频硬件的组成，分别在声卡的codec驱动、platform驱动和machine驱动中定义一组widget，这些widget用数组进行组织，DAPM系统提供的一些辅助宏定义来定义各种类型的widget和它所用到的dapm kcontrol(这些由DAPM系统提供的辅助宏定义的kcontrol后面我们统一称为dapm kcontrol，以便和普通的kcontrol进行区分)。

DAPM框架为我们提供了大量的辅助宏来定义各种各样的widget控件，这些宏定义根据widget的类型，按照它们电源所在的域，被分为了几个域。

1.2.1 Codec域widget

比如VREF和VMID等提供参考电压的widget，这些widget通常在codec的probe/remove回调函数中进行控制，当然，在工作中如果没有音频流时，也可以适当地进行控制它们的开启与关闭。目前DAPM框架只提供了一个Codec域widget的辅助定义宏：

/* codec domain */
#define SND_SOC_DAPM_VMID(wname) \
{       .id = snd_soc_dapm_vmid, .name = wname, .kcontrol_news = NULL, \
        .num_kcontrols = 0}

1.2.2 Platform/Machine域widget

位于该域上的widget通常是针对platform/machine的一些需要物理连接的输入/输出接口，例如耳机、扬声器、麦克风。

这些widget是没有寄存器控制位来控制widget的电源状态的，因此reg字段均被设置为 SND_SOC_NOPM(-1)。

DAPM 框架为我们提供了多种Platform/Machine域widget的辅助定义宏：

/* platform domain */
#define SND_SOC_DAPM_SIGGEN(wname) \
{       .id = snd_soc_dapm_siggen, .name = wname, .kcontrol_news = NULL, \
        .num_kcontrols = 0, .reg = SND_SOC_NOPM }
#define SND_SOC_DAPM_SINK(wname) \
{       .id = snd_soc_dapm_sink, .name = wname, .kcontrol_news = NULL, \
        .num_kcontrols = 0, .reg = SND_SOC_NOPM }
#define SND_SOC_DAPM_INPUT(wname) \
{       .id = snd_soc_dapm_input, .name = wname, .kcontrol_news = NULL, \
        .num_kcontrols = 0, .reg = SND_SOC_NOPM }
#define SND_SOC_DAPM_OUTPUT(wname) \
{       .id = snd_soc_dapm_output, .name = wname, .kcontrol_news = NULL, \
        .num_kcontrols = 0, .reg = SND_SOC_NOPM }
#define SND_SOC_DAPM_MIC(wname, wevent) \
{       .id = snd_soc_dapm_mic, .name = wname, .kcontrol_news = NULL, \
        .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
        .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD}
#define SND_SOC_DAPM_HP(wname, wevent) \
{       .id = snd_soc_dapm_hp, .name = wname, .kcontrol_news = NULL, \
        .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
        .event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD}
#define SND_SOC_DAPM_SPK(wname, wevent) \
{       .id = snd_soc_dapm_spk, .name = wname, .kcontrol_news = NULL, \
        .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
        .event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD}
#define SND_SOC_DAPM_LINE(wname, wevent) \
{       .id = snd_soc_dapm_line, .name = wname, .kcontrol_news = NULL, \
        .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \
        .event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD}

View Code

以上这些widget类型对应：

(1) snd_soc_dapm_siggen：信号发生器(SIGGEN；；

(2) snd_soc_dapm_sink：我也不晓得是干啥用的，未碰到过；

(3)snd_soc_dapm_input：对应的实就是Codec芯片的输入引脚，比如为ALC5651 IN1P、IN2P等输入引脚定义的widget：

SND_SOC_DAPM_INPUT("MIC1"),  // 这个是ALC5651驱动源码给出的，MIC1/2/3个人认为是多余的，并不与实际引脚对应
SND_SOC_DAPM_INPUT("MIC2"),
SND_SOC_DAPM_INPUT("MIC3"),

SND_SOC_DAPM_INPUT("IN1P"),
SND_SOC_DAPM_INPUT("IN2P"),
SND_SOC_DAPM_INPUT("IN2N"),
SND_SOC_DAPM_INPUT("IN3P"),
SND_SOC_DAPM_INPUT("DMIC L1"),
SND_SOC_DAPM_INPUT("DMIC R1")

(4) snd_soc_dapm_output：对应的实就是codec芯片的输出引脚，比如为ALC5651 LOUTL、HPOL等输出引脚定义的widget：

SND_SOC_DAPM_OUTPUT("HPOL"),
SND_SOC_DAPM_OUTPUT("HPOR"),
SND_SOC_DAPM_OUTPUT("LOUTL"),
SND_SOC_DAPM_OUTPUT("LOUTR"),
SND_SOC_DAPM_OUTPUT("PDML"),
SND_SOC_DAPM_OUTPUT("PDMR"),

(5) snd_soc_dapm_mic：对应的就是麦克风(and optional Jack)，比如定义与ALC5651 IN2P、IN2N引脚连接的麦克风：

SND_SOC_DAPM_MIC("Microphone", NULL),

(6) snd_soc_dapm_hp：对应的就是耳机(and optional Jack)，比如定义与ALC5651的HPOL、HPOR引脚连接的耳机；

SND_SOC_DAPM_HP("Headphone", NULL)

(7) snd_soc_dapm_spk：对应的就是扬声器：ALC5651好像没有speaker输出相关引脚，因此不介绍了；

SND_SOC_DAPM_SPK("Speaker", NULL)

(8) snd_soc_dapm_line：对应的就是线路输入/输出(and optional Jack)，比如定义与ALC5651的IN2P、IN2N引脚(这俩引脚是可以功能复用的)连接的音频输入设备、与LOUTL、LOUTR引脚连接的接音频输出设备；

SND_SOC_DAPM_LINE("Line", NULL)

麦克风(snd_soc_dapm_mic)，耳机(snd_soc_dapm_hp)，扬声器(snd_soc_dapm_spk)，线路输入/输出(snd_soc_dapm_line)这几种widget，还可以定义一个dapm事件回调函数wevent，从event flags字段设置可以看出，它们只会响应SND_SOC_DAPM_POST_PMU(上电后)和 SND_SOC_DAPM_POST_PMD(下电前)事件，这几个widget通常会在Machine驱动中定义。

而输入(snd_soc_dapm_input)和输出(snd_soc_dapm_output)则用来定义codec芯片的输入输出引脚，通常在codec驱动中定义。

最后，在machine驱动中增加相应的route，把麦克风和耳机等widget与相应的codec输入输出引脚的widget连接起来。

例如，对于一个外部麦克风的Jack connetcor widget，在麦克风插入的时候启用Mic Bias：

static int spitz_mic_bias(struct snd_soc_dapm_widget* w, int event)
{
      gpio_set_value(SPITZ_GPIO_MIC_BIAS, SND_SOC_DAPM_EVENT_ON(event));
      return 0;
}

SND_SOC_DAPM_MIC("Mic Jack", spitz_mic_bias),

1.2.3 path域widget

一般是指codec内部的Mixer、Mux、Switch、Demux等控制音频路径的widget，这些widget可以根据用户空间的设定连接关系，自动设定它们的电源状态。

DAPM 框架为我们提供了多种path域widget的辅助定义宏：

/* path domain */
#define SND_SOC_DAPM_PGA(wname, wreg, wshift, winvert,\
         wcontrols, wncontrols) \
{       .id = snd_soc_dapm_pga, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}
#define SND_SOC_DAPM_OUT_DRV(wname, wreg, wshift, winvert,\
         wcontrols, wncontrols) \
{       .id = snd_soc_dapm_out_drv, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}
#define SND_SOC_DAPM_MIXER(wname, wreg, wshift, winvert, \
         wcontrols, wncontrols)\
{       .id = snd_soc_dapm_mixer, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}
#define SND_SOC_DAPM_MIXER_NAMED_CTL(wname, wreg, wshift, winvert, \
         wcontrols, wncontrols)\
{       .id = snd_soc_dapm_mixer_named_ctl, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}
/* DEPRECATED: use SND_SOC_DAPM_SUPPLY */
#define SND_SOC_DAPM_MICBIAS(wname, wreg, wshift, winvert) \
{       .id = snd_soc_dapm_micbias, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .kcontrol_news = NULL, .num_kcontrols = 0}
#define SND_SOC_DAPM_SWITCH(wname, wreg, wshift, winvert, wcontrols) \
{       .id = snd_soc_dapm_switch, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .kcontrol_news = wcontrols, .num_kcontrols = 1}
#define SND_SOC_DAPM_MUX(wname, wreg, wshift, winvert, wcontrols) \
{       .id = snd_soc_dapm_mux, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .kcontrol_news = wcontrols, .num_kcontrols = 1}
#define SND_SOC_DAPM_DEMUX(wname, wreg, wshift, winvert, wcontrols) \
{       .id = snd_soc_dapm_demux, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .kcontrol_news = wcontrols, .num_kcontrols = 1}

......

View Code

可以看出，这些widget的reg和shift字段是需要赋值的，说明这些widget是有相应的电源控制寄存器的，DAPM框架在扫描和更新音频路径时，会利用这些寄存器来控制widget的电源状态，使得它们的供电状态是按需分配的，需要的时候(在有效的音频路径上)上电，不需要的时候(不在有效的音频路径上)下电。

这些widget需要完成和之前介绍的Mixer、Mux等控件同样的功能，实际上，这是通过它们包含的dapm kcontrol控件来完成的，这些dapm kcontrol我们需要在定义widget前先定义好，然后通过wcontrols和num_kcontrols参数传递给这些辅助定义宏。

例如，Mixer widget配置如下：

static const struct snd_kcontrol_new wm8960_loutput_mixer[] = {
    SOC_DAPM_SINGLE("PCM Playback Switch", WM8960_LOUTMIX, 8, 1, 0),
    SOC_DAPM_SINGLE("LINPUT3 Switch", WM8960_LOUTMIX, 7, 1, 0),
    SOC_DAPM_SINGLE("Boost Bypass Switch", WM8960_BYPASS1, 7, 1, 0),
};

SND_SOC_DAPM_MIXER("Left Output Mixer", WM8960_POWER3, 3, 0,      // Left Output Mixer
        &wm8960_loutput_mixer[0],   // Left Output Mixer包含3个kcontrol,每个kcontrol控制着Mixer的一个输入端的开启和关闭
        ARRAY_SIZE(wm8960_loutput_mixer)),

留意WM8960_POWER3寄存器的位3正是控制 Left Output Mixer上下电的。

如果需要自定义这些widget的dapm事件处理回调函数，也可以使用下面这些带 "_E" 后缀的版本：

SND_SOC_DAPM_PGA_E；
SND_SOC_DAPM_OUT_DRV_E；
SND_SOC_DAPM_MIXER_E；
SND_SOC_DAPM_MIXER_NAMED_CTL_E；
SND_SOC_DAPM_SWITCH_E；
SND_SOC_DAPM_MUX_E；
SND_SOC_DAPM_VIRT_MUX_E；

1.2.4 stream域widget

是指那些需要处理音频数据流的widget，例如 ADC、DAC、AIF IN、AIF OUT等等。DAPM 框架为我们提供了多种stream域widget的辅助定义宏：

/* stream domain */
#define SND_SOC_DAPM_AIF_IN(wname, stname, wchan, wreg, wshift, winvert) \
{       .id = snd_soc_dapm_aif_in, .name = wname, .sname = stname, \
        .channel = wchan, SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), }
#define SND_SOC_DAPM_AIF_IN_E(wname, stname, wchan, wreg, wshift, winvert, \
                              wevent, wflags)                           \
{       .id = snd_soc_dapm_aif_in, .name = wname, .sname = stname, \
        .channel = wchan, SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .event = wevent, .event_flags = wflags }
#define SND_SOC_DAPM_AIF_OUT(wname, stname, wchan, wreg, wshift, winvert) \
{       .id = snd_soc_dapm_aif_out, .name = wname, .sname = stname, \
        .channel = wchan, SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), }
#define SND_SOC_DAPM_AIF_OUT_E(wname, stname, wchan, wreg, wshift, winvert, \
                             wevent, wflags)                            \
{       .id = snd_soc_dapm_aif_out, .name = wname, .sname = stname, \
        .channel = wchan, SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .event = wevent, .event_flags = wflags }
#define SND_SOC_DAPM_DAC(wname, stname, wreg, wshift, winvert) \
{       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert) }
#define SND_SOC_DAPM_DAC_E(wname, stname, wreg, wshift, winvert, \
                           wevent, wflags)                              \
{       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .event = wevent, .event_flags = wflags}

#define SND_SOC_DAPM_ADC(wname, stname, wreg, wshift, winvert) \
{       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), }
#define SND_SOC_DAPM_ADC_E(wname, stname, wreg, wshift, winvert, \
                           wevent, wflags)                              \
{       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .event = wevent, .event_flags = wflags}
#define SND_SOC_DAPM_CLOCK_SUPPLY(wname) \
{       .id = snd_soc_dapm_clock_supply, .name = wname, \
        .reg = SND_SOC_NOPM, .event = dapm_clock_event, \
        .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD }

View Code

需要注意的是：我们在codec驱动中定义stream widget时，他们的sname必须要包含codec dai的sname，这样才能让ASoC自动的把codec dai widget和stream widget连接在一起，只有把它们连接在一起，ASoc中的播放、录音和停止等事件，才能通过dai widget传递到codec中，使得codec中的widget能根据目前的播放状态，动态地开启或关闭音频路径complete path上所有widget的电源。

例如，针对HiFi音频播放和捕获，可以使用如下的stream widget配置：

SND_SOC_DAPM_DAC("HiFi DAC", "HiFi Playback", REG, 3, 1),
SND_SOC_DAPM_ADC("HiFi ADC", "HiFi Capture", REG, 2, 1),

针对AIF，可以使用如下的stream widget配置：

SND_SOC_DAPM_AIF_IN("AIF1RX", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
SND_SOC_DAPM_AIF_OUT("AIF1TX", "AIF1 Capture", 0, SND_SOC_NOPM, 0, 0),

除了上述这些 widget，还有另外三种widget没有提供显示的定义方法，其种类id分别为：

snd_soc_dapm_dai_in；
snd_soc_dapm_dai_out；
snd_soc_dapm_dai_link；

还记得ASOC架构中Codec中的snd_soc_dai结构吗？每个codec有多个dai，而cpu也会有多个dai，dai注册时，dapm系统会为每个dai创建一个snd_soc_dapm_dai_in或snd_soc_dapm_dai_out类型的widget，通常，这两种widget会和codec中具有相同的stream name的widget进行连接。

另外一种情况，当系统中具有多个音频处理器(比如多个Codec)时，它们之间可能会通过某两个dai进行连接，当Machine驱动确认有这种配置时(通过判断dai_links结构中的param字段)，会为它们建立一个dai_link把它们绑定在一起，因为有连接关系，两个音频处理器之间的widget的电源状态就可以互相传递。

1.2.5 虚拟widget

有时候在codec和machine中存在一些没有widget，它们没有对应的软件电源控制位。在这种情景下，有必要创建虚拟的widget，例如：

SND_SOC_DAPM_MIXER("AC97 Mixer", SND_SOC_DAPM_NOPM, 0, 0, NULL, 0),

1.2.6 其它

除了上面的还有几个通用的widget，它们的定义方法如下：

/* generic widgets */
#define SND_SOC_DAPM_REG(wid, wname, wreg, wshift, wmask, won_val, woff_val) \
{       .id = wid, .name = wname, .kcontrol_news = NULL, .num_kcontrols = 0, \
        .reg = wreg, .shift = wshift, .mask = wmask, \
        .on_val = won_val, .off_val = woff_val, }
#define SND_SOC_DAPM_SUPPLY(wname, wreg, wshift, winvert, wevent, wflags) \
{       .id = snd_soc_dapm_supply, .name = wname, \
        SND_SOC_DAPM_INIT_REG_VAL(wreg, wshift, winvert), \
        .event = wevent, .event_flags = wflags}
#define SND_SOC_DAPM_REGULATOR_SUPPLY(wname, wdelay, wflags)        \
{       .id = snd_soc_dapm_regulator_supply, .name = wname, \
        .reg = SND_SOC_NOPM, .shift = wdelay, .event = dapm_regulator_event, \
        .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD, \
        .on_val = wflags}
#define SND_SOC_DAPM_PINCTRL(wname, active, sleep) \
{       .id = snd_soc_dapm_pinctrl, .name = wname, \
        .priv = (&(struct snd_soc_dapm_pinctrl_priv) \
                { .active_state = active, .sleep_state = sleep,}), \
        .reg = SND_SOC_NOPM, .event = dapm_pinctrl_event, \
        .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD }

View Code

在完成所有的widget定义之后，我们可以使用snd_soc_dapm_new_control方法将这些widget添加到DAPM子系统。

1.3 辅助宏定义dapm kcontrol

对于音频路径上的Mixer或Mux类型的widget，它们包含了若干个kcontrol，这些被包含的kcontrol实际上就是我们之前讨论的Mixer和Mux等，dapm利用这些kcontrol完成音频的控制。

static const struct snd_kcontrol_new wm8960_lin_boost[] = { // 这个Mixer使用寄存器WM8960_LINPATH的第6，7、8位来分别控制3个输入端的开启和关闭。
    SOC_SINGLE("LINPUT2 Switch", WM8960_LINPATH, 6, 1, 0),
    SOC_SINGLE("LINPUT3 Switch", WM8960_LINPATH, 7, 1, 0),
    SOC_SINGLE("LINPUT1 Switch", WM8960_LINPATH, 8, 1, 0),
};

不过，对于widget来说，它的任务还不止这些，dapm还要动态地管理这些音频路径的连结关系，以便可以根据这些连接关系来控制这些widget的电源状态，如果按照普通的方法定义这些kcontrol，是无法达到这个目的的，因此，dapm为我们提供另外一套定义宏，由它们完成这些被widget包含的kcontrol的定义，如下：

/* dapm kcontrol types */
#define SOC_DAPM_DOUBLE(xname, reg, lshift, rshift, max, invert) \
{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
        .info = snd_soc_info_volsw, \
        .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \
        .private_value = SOC_DOUBLE_VALUE(reg, lshift, rshift, max, invert, 0) }
#define SOC_DAPM_DOUBLE_R(xname, lreg, rreg, shift, max, invert) \
{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
        .info = snd_soc_info_volsw, \
        .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \
        .private_value = SOC_DOUBLE_R_VALUE(lreg, rreg, shift, max, invert) }
#define SOC_DAPM_SINGLE(xname, reg, shift, max, invert) \
{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
        .info = snd_soc_info_volsw, \
        .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \
        .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
#define SOC_DAPM_SINGLE_AUTODISABLE(xname, reg, shift, max, invert) \
{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
        .info = snd_soc_info_volsw, \
        .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \
        .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 1) }
#define SOC_DAPM_SINGLE_VIRT(xname, max) \
        SOC_DAPM_SINGLE(xname, SND_SOC_NOPM, 0, max, 0)
#define SOC_DAPM_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
        .info = snd_soc_info_volsw, \
        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | SNDRV_CTL_ELEM_ACCESS_READWRITE,\
        .tlv.p = (tlv_array), \
        .get = snd_soc_dapm_get_volsw, .put = snd_soc_dap