lp542718520
lp542718520

Linux/Android alsa codec音频路由dapm的配置详解

ALSA声卡驱动中的DAPM详解之一：kcontrol

DAPM是Dynamic Audio Power Management的缩写，直译过来就是动态音频电源管理的意思，DAPM是为了使基于Linux的移动设备上的音频子系统，在任何时候都工作在最小功耗状态下。DAPM对用户空间的应用程序来说是透明的，所有与电源相关的开关都在ASoc core中完成。用户空间的应用程序无需对代码做出修改，也无需重新编译，DAPM根据当前激活的音频流（playback/capture）和声卡中的mixer等的配置来决定那些音频控件的电源开关被打开或关闭。

/*****************************************************************************************************/
声明：本博内容均由http://blog.csdn.net/droidphone原创，转载请注明出处，谢谢！
/*****************************************************************************************************/

DAPM控件是由普通的soc音频控件演变而来的，所以本章的内容我们先从普通的soc音频控件开始。

snd_kcontrol_new结构

在正式讨论DAPM之前，我们需要先搞清楚ASoc中的一个重要的概念：kcontrol，不熟悉的读者需要浏览一下我之前的文章：Linux ALSA声卡驱动之四：Control设备的创建。通常，一个kcontrol代表着一个mixer（混音器），或者是一个mux（多路开关），又或者是一个音量控制器等等。 从上述文章中我们知道，定义一个kcontrol主要就是定义一个snd_kcontrol_new结构，为了方便讨论，这里再次给出它的定义：

[cpp]  view plain  copy
  1. struct snd_kcontrol_new {  
  2.         snd_ctl_elem_iface_t iface;     /* interface identifier */  
  3.         unsigned int device;            /* device/client number */  
  4.         unsigned int subdevice;         /* subdevice (substream) number */  
  5.         const unsigned char *name;      /* ASCII name of item */  
  6.         unsigned int index;             /* index of item */  
  7.         unsigned int access;            /* access rights */  
  8.         unsigned int count;             /* count of same elements */  
  9.         snd_kcontrol_info_t *info;  
  10.         snd_kcontrol_get_t *get;  
  11.         snd_kcontrol_put_t *put;  
  12.         union {  
  13.                 snd_kcontrol_tlv_rw_t *c;  
  14.                 const unsigned int *p;  
  15.         } tlv;  
  16.         unsigned long private_value;  
  17. };  

回到Linux ALSA声卡驱动之四：Control设备的创建中，我们知道，对于每个控件，我们需要定义一个和他对应的snd_kcontrol_new结构，这些snd_kcontrol_new结构会在声卡的初始化阶段，通过snd_soc_add_codec_controls函数注册到系统中，用户空间就可以通过amixer或alsamixer等工具查看和设定这些控件的状态。

snd_kcontrol_new结构中，几个主要的字段是get，put，private_value，get回调函数用于获取该控件当前的状态值，而put回调函数则用于设置控件的状态值，而private_value字段则根据不同的控件类型有不同的意义，比如对于普通的控件，private_value字段可以用来定义该控件所对应的寄存器的地址以及对应的控制位在寄存器中的位置信息。值得庆幸的是，ASoc系统已经为我们准备了大量的宏定义，用于定义常用的控件，这些宏定义位于include/sound/soc.h中。下面我们分别讨论一下如何用这些预设的宏定义来定义一些常用的控件。

简单型的控件

SOC_SINGLE    SOC_SINGLE应该算是最简单的控件了，这种控件只有一个控制量，比如一个开关，或者是一个数值变量（比如Codec中某个频率，FIFO大小等等）。我们看看这个宏是如何定义的：

[cpp]  view plain  copy
  1. #define SOC_SINGLE(xname, reg, shift, max, invert) \  
  2. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \  
  3.         .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\  
  4.         .put = snd_soc_put_volsw, \  
  5.         .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }  
宏定义的参数分别是：xname（该控件的名字），reg（该控件对应的寄存器的地址），shift（控制位在寄存器中的位移），max（控件可设置的最大值），invert（设定值是否逻辑取反）。这里又使用了一个宏来定义private_value字段：SOC_SINGLE_VALUE，我们看看它的定义：

[cpp]  view plain  copy
  1. #define SOC_DOUBLE_VALUE(xreg, shift_left, shift_right, xmax, xinvert) \  
  2.         ((unsigned long)&(struct soc_mixer_control) \  
  3.         {.reg = xreg, .rreg = xreg, .shift = shift_left, \  
  4.         .rshift = shift_right, .max = xmax, .platform_max = xmax, \  
  5.         .invert = xinvert})  
  6. #define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) \  
  7.         SOC_DOUBLE_VALUE(xreg, xshift, xshift, xmax, xinvert)  
这里实际上是定义了一个soc_mixer_control结构，然后把该结构的地址赋值给了private_value字段，soc_mixer_control结构是这样的：

[cpp]  view plain  copy
  1. /* mixer control */  
  2. struct soc_mixer_control {  
  3.         int min, max, platform_max;  
  4.         unsigned int reg, rreg, shift, rshift, invert;  
  5. };  
看来soc_mixer_control是控件特征的真正描述者，它确定了该控件对应寄存器的地址，位移值，最大值和是否逻辑取反等特性，控件的put回调函数和get回调函数需要借助该结构来访问实际的寄存器。我们看看这get回调函数的定义：

[cpp]  view plain  copy
  1. int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,  
  2.         struct snd_ctl_elem_value *ucontrol)  
  3. {  
  4.         struct soc_mixer_control *mc =  
  5.                 (struct soc_mixer_control *)kcontrol->private_value;  
  6.         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);  
  7.         unsigned int reg = mc->reg;  
  8.         unsigned int reg2 = mc->rreg;  
  9.         unsigned int shift = mc->shift;  
  10.         unsigned int rshift = mc->rshift;  
  11.         int max = mc->max;  
  12.         unsigned int mask = (1 << fls(max)) - 1;  
  13.         unsigned int invert = mc->invert;  
  14.   
  15.         ucontrol->value.integer.value[0] =  
  16.                 (snd_soc_read(codec, reg) >> shift) & mask;  
  17.         if (invert)  
  18.                 ucontrol->value.integer.value[0] =  
  19.                         max - ucontrol->value.integer.value[0];  
  20.   
  21.         if (snd_soc_volsw_is_stereo(mc)) {  
  22.                 if (reg == reg2)  
  23.                         ucontrol->value.integer.value[1] =  
  24.                                 (snd_soc_read(codec, reg) >> rshift) & mask;  
  25.                 else  
  26.                         ucontrol->value.integer.value[1] =  
  27.                                 (snd_soc_read(codec, reg2) >> shift) & mask;  
  28.                 if (invert)  
  29.                         ucontrol->value.integer.value[1] =  
  30.                                 max - ucontrol->value.integer.value[1];  
  31.         }  
  32.   
  33.         return 0;  
  34. }  
上述代码一目了然，从private_value字段取出soc_mixer_control结构，利用该结构的信息，访问对应的寄存器，返回相应的值。


SOC_SINGLE_TLV    SOC_SINGLE_TLV是SOC_SINGLE的一种扩展，主要用于定义那些有增益控制的控件，例如音量控制器，EQ均衡器等等。

[cpp]  view plain  copy
  1. #define SOC_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \  
  2. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \  
  3.         .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\  
  4.                  SNDRV_CTL_ELEM_ACCESS_READWRITE,\  
  5.         .tlv.p = (tlv_array), \  
  6.         .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\  
  7.         .put = snd_soc_put_volsw, \  
  8.         .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }  
从他的定义可以看出，用于设定寄存器信息的private_value字段的定义和SOC_SINGLE是一样的，甚至put、get回调函数也是使用同一套，唯一不同的是增加了一个tlv_array参数，并把它赋值给了tlv.p字段。关于tlv，已经在 Linux ALSA声卡驱动之四：Control设备的创建 中进行了阐述。用户空间可以通过对声卡的control设备发起以下两种ioctl来访问tlv字段所指向的数组：

  •         SNDRV_CTL_IOCTL_TLV_READ
  •         SNDRV_CTL_IOCTL_TLV_WRITE
  •         SNDRV_CTL_IOCTL_TLV_COMMAND
通常，tlv_array用来描述寄存器的设定值与它所代表的实际意义之间的映射关系，最常用的就是用于音量控件时，设定值与对应的dB值之间的映射关系，请看以下例子：
[cpp]  view plain  copy
  1. static const DECLARE_TLV_DB_SCALE(mixin_boost_tlv, 0, 900, 0);  
  2.   
  3. static const struct snd_kcontrol_new wm1811_snd_controls[] = {  
  4. SOC_SINGLE_TLV("MIXINL IN1LP Boost Volume", WM8994_INPUT_MIXER_1, 7, 1, 0,  
  5.                mixin_boost_tlv),  
  6. SOC_SINGLE_TLV("MIXINL IN1RP Boost Volume", WM8994_INPUT_MIXER_1, 8, 1, 0,  
  7.                mixin_boost_tlv),  
  8. };  
DECLARE_TLV_DB_SCALE用于定义一个dB值映射的tlv_array，上述的例子表明，该tlv的类型是SNDRV_CTL_TLVT_DB_SCALE，寄存器的最小值对应是0dB，寄存器每增加一个单位值，对应的dB数增加是9dB（0.01dB*900），而由接下来的两组SOC_SINGLE_TLV定义可以看出，我们定义了两个boost控件，寄存器的地址都是WM8994_INPUT_MIXER_1，控制位分别是第7bit和第8bit，最大值是1，所以，该控件只能设定两个数值0和1，对应的dB值就是0dB和9dB。

SOC_DOUBLE    与SOC_SINGLE相对应，区别是SOC_SINGLE只控制一个变量，而SOC_DOUBLE则可以同时在一个寄存器中控制两个相似的变量，最常用的就是用于一些立体声的控件，我们需要同时对左右声道进行控制，因为多了一个声道，参数也就相应地多了一个shift位移值，

[cpp]  view plain  copy
  1. #define SOC_DOUBLE(xname, reg, shift_left, shift_right, max, invert) \  
  2. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\  
  3.         .info = snd_soc_info_volsw, .get = snd_soc_get_volsw, \  
  4.         .put = snd_soc_put_volsw, \  
  5.         .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \  
  6.                                           max, invert) }  

SOC_DOUBLE_R     与SOC_DOUBLE类似，对于左右声道的控制寄存器不一样的情况，使用SOC_DOUBLE_R来定义，参数中需要指定两个寄存器地址。

SOC_DOUBLE_TLV    与SOC_SINGLE_TLV对应的立体声版本，通常用于立体声音量控件的定义。

SOC_DOUBLE_R_TLV    左右声道有独立寄存器控制的SOC_DOUBLE_TLV版本

Mixer控件

Mixer控件用于音频通道的路由控制，由多个输入和一个输出组成，多个输入可以自由地混合在一起，形成混合后的输出：


          图1     Mixer混音器

对于Mixer控件，我们可以认为是多个简单控件的组合，通常，我们会为mixer的每个输入端都单独定义一个简单控件来控制该路输入的开启和关闭，反应在代码上，就是定义一个soc_kcontrol_new数组：

[cpp]  view plain  copy
  1. static const struct snd_kcontrol_new left_speaker_mixer[] = {  
  2. SOC_SINGLE("Input Switch", WM8993_SPEAKER_MIXER, 7, 1, 0),  
  3. SOC_SINGLE("IN1LP Switch", WM8993_SPEAKER_MIXER, 5, 1, 0),  
  4. SOC_SINGLE("Output Switch", WM8993_SPEAKER_MIXER, 3, 1, 0),  
  5. SOC_SINGLE("DAC Switch", WM8993_SPEAKER_MIXER, 6, 1, 0),  
  6. };  

以上这个mixer使用寄存器WM8993_SPEAKER_MIXER的第3，5，6，7位来分别控制4个输入端的开启和关闭。

Mux控件

mux控件与mixer控件类似，也是多个输入端和一个输出端的组合控件，与mixer控件不同的是，mux控件的多个输入端同时只能有一个被选中。因此，mux控件所对应的寄存器，通常可以设定一段连续的数值，每个不同的数值对应不同的输入端被打开，与上述的mixer控件不同，ASoc用soc_enum结构来描述mux控件的寄存器信息：

[cpp]  view plain  copy
  1. /* enumerated kcontrol */  
  2. struct soc_enum {  
  3.         unsigned short reg;  
  4.         unsigned short reg2;  
  5.         unsigned char shift_l;  
  6.         unsigned char shift_r;  
  7.         unsigned int max;  
  8.         unsigned int mask;  
  9.         const char * const *texts;  
  10.         const unsigned int *values;  
  11. };  
两个寄存器地址和位移字段：reg，reg2，shift_l，shift_r，用于描述左右声道的控制寄存器信息。字符串数组指针用于描述每个输入端对应的名字，value字段则指向一个数组，该数组定义了寄存器可以选择的值，每个值对应一个输入端，如果value是一组连续的值，通常我们可以忽略values参数。下面我们先看看如何定义一个mux控件：

第一步，定义字符串和values数组，以下的例子因为values是连续的，所以不用定义：

[cpp]  view plain  copy
  1. static const char *drc_path_text[] = {  
  2.         "ADC",  
  3.         "DAC"  
  4. };  
第二步，利用ASoc提供的辅助宏定义soc_enum结构，用于描述寄存器：

[cpp]  view plain  copy
  1. static const struct soc_enum drc_path =  
  2.         SOC_ENUM_SINGLE(WM8993_DRC_CONTROL_1, 14, 2, drc_path_text);  
第三步，利痛ASoc提供的辅助宏，定义soc_kcontrol_new结构，该结构最后用于注册该mux控件：

[cpp]  view plain  copy
  1. static const struct snd_kcontrol_new wm8993_snd_controls[] = {  
  2. SOC_DOUBLE_TLV(......),  
  3. ......  
  4. SOC_ENUM("DRC Path", drc_path),  
  5. ......  
  6. }  
以上几步定义了一个叫DRC PATH的mux控件，该控件具有两个输入选择，分别是来自ADC和DAC，用寄存器WM8993_DRC_CONTROL_1控制。其中，soc_enum结构使用了辅助宏SOC_ENUM_SINGLE来定义，该宏的声明如下：

[cpp]  view plain  copy
  1. #define SOC_ENUM_DOUBLE(xreg, xshift_l, xshift_r, xmax, xtexts) \  
  2. {       .reg = xreg, .shift_l = xshift_l, .shift_r = xshift_r, \  
  3.         .max = xmax, .texts = xtexts, \  
  4.         .mask = xmax ? roundup_pow_of_two(xmax) - 1 : 0}  
  5. #define SOC_ENUM_SINGLE(xreg, xshift, xmax, xtexts) \  
  6.         SOC_ENUM_DOUBLE(xreg, xshift, xshift, xmax, xtexts)  
定义soc_kcontrol_new结构时使用了SOC_ENUM，列出它的定义如下：

[cpp]  view plain  copy
  1. #define SOC_ENUM(xname, xenum) \  
  2. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\  
  3.         .info = snd_soc_info_enum_double, \  
  4.         .get = snd_soc_get_enum_double, .put = snd_soc_put_enum_double, \  
  5.         .private_value = (unsigned long)&xenum }  
思想如此统一，依然是使用private_value字段记录soc_enum结构，不过几个回调函数变了，我们看看get回调对应的snd_soc_get_enum_double函数：

[cpp]  view plain  copy
  1. int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,  
  2.         struct snd_ctl_elem_value *ucontrol)  
  3. {  
  4.         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);  
  5.         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;  
  6.         unsigned int val;  
  7.   
  8.         val = snd_soc_read(codec, e->reg);  
  9.         ucontrol->value.enumerated.item[0]  
  10.                 = (val >> e->shift_l) & e->mask;  
  11.         if (e->shift_l != e->shift_r)  
  12.                 ucontrol->value.enumerated.item[1] =  
  13.                         (val >> e->shift_r) & e->mask;  
  14.   
  15.         return 0;  
  16. }  
通过info回调函数则可以获取某个输入端所对应的名字，其实就是从soc_enum结构的texts数组中获得：

[cpp]  view plain  copy
  1. int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,  
  2.         struct snd_ctl_elem_info *uinfo)  
  3. {  
  4.         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;  
  5.   
  6.         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;  
  7.         uinfo->count = e->shift_l == e->shift_r ? 1 : 2;  
  8.         uinfo->value.enumerated.items = e->max;  
  9.   
  10.         if (uinfo->value.enumerated.item > e->max - 1)  
  11.                 uinfo->value.enumerated.item = e->max - 1;  
  12.         strcpy(uinfo->value.enumerated.name,  
  13.                 e->texts[uinfo->value.enumerated.item]);  
  14.         return 0;  
  15. }  

以下是另外几个常用于定义mux控件的宏：

SOC_VALUE_ENUM_SINGLE    用于定义带values字段的soc_enum结构。

SOC_VALUE_ENUM_DOUBLE    SOC_VALUE_ENUM_SINGLE的立体声版本。

SOC_VALUE_ENUM    用于定义带values字段snd_kcontrol_new结构，这个有点特别，我们还是看看它的定义：

[cpp]  view plain  copy
  1. #define SOC_VALUE_ENUM(xname, xenum) \  
  2. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\  
  3.         .info = snd_soc_info_enum_double, \  
  4.         .get = snd_soc_get_value_enum_double, \  
  5.         .put = snd_soc_put_value_enum_double, \  
  6.         .private_value = (unsigned long)&xenum }  
从定义可以看出来，回调函数被换掉了，我们看看他的get回调：

[cpp]  view plain  copy
  1. int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,  
  2.         struct snd_ctl_elem_value *ucontrol)  
  3. {  
  4.         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);  
  5.         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;  
  6.         unsigned int reg_val, val, mux;  
  7.   
  8.         reg_val = snd_soc_read(codec, e->reg);  
  9.         val = (reg_val >> e->shift_l) & e->mask;  
  10.         for (mux = 0; mux < e->max; mux++) {  
  11.                 if (val == e->values[mux])  
  12.                         break;  
  13.         }  
  14.         ucontrol->value.enumerated.item[0] = mux;  
  15.         if (e->shift_l != e->shift_r) {  
  16.                 val = (reg_val >> e->shift_r) & e->mask;  
  17.                 for (mux = 0; mux < e->max; mux++) {  
  18.                         if (val == e->values[mux])  
  19.                                 break;  
  20.                 }  
  21.                 ucontrol->value.enumerated.item[1] = mux;  
  22.         }  
  23.   
  24.         return 0;  
  25. }  
与SOC_ENUM定义的mux不同，它没有直接返回寄存器的设定值，而是通过soc_enum结构中的values字段做了一次转换，与values数组中查找和寄存器相等的值，然后返回他在values数组中的索引值，所以，尽管寄存器的值可能是不连续的，但返回的值是连续的。

通常，我们还可以用以下几个辅助宏定义soc_enum结构，其实和上面所说的没什么区别，只是可以偷一下懒，省掉struct soc_enum xxxx=几个单词而已：

  • SOC_ENUM_SINGLE_DECL    
  • SOC_ENUM_DOUBLE_DECL    
  • SOC_VALUE_ENUM_SINGLE_DECL    
  • SOC_VALUE_ENUM_DOUBLE_DECL    

其它控件

其实，除了以上介绍的几种常用的控件，ASoc还为我们提供了另外一些控件定义辅助宏，详细的请读者参考include/sound/soc.h。这里列举几个：

需要自己定义get和put回调时，可以使用以下这些带EXT的版本：

  • SOC_SINGLE_EXT    
  • SOC_DOUBLE_EXT
  • SOC_SINGLE_EXT_TLV
  • SOC_DOUBLE_EXT_TLV
  • SOC_DOUBLE_R_EXT_TLV
  • SOC_ENUM_EXT
ALSA声卡驱动中的DAPM详解之二：widget-具备路径和电源管理信息的kcontrol

上一篇文章中，我们介绍了音频驱动中对基本控制单元的封装：kcontrol。利用kcontrol，我们可以完成对音频系统中的mixer，mux，音量控制，音效控制，以及各种开关量的控制，通过对各种kcontrol的控制，使得音频硬件能够按照我们预想的结果进行工作。同时我们可以看到，kcontrol还是有以下几点不足：

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

/*****************************************************************************************************/
声明：本博内容均由http://blog.csdn.net/droidphone原创，转载请注明出处，谢谢！
/*****************************************************************************************************/

为此，DAPM框架正是为了要解决以上这些问题而诞生的，DAPM目前已经是ASoc中的重要组成部分，让我们先从DAPM的数据结构开始，了解它的设计思想和工作原理。

DAPM的基本单元：widget

文章的开头，我们说明了一下目前kcontrol的一些不足，而DAPM框架为了解决这些问题，引入了widget这一概念，所谓widget，其实可以理解为是kcontrol的进一步升级和封装，她同样是指音频系统中的某个部件，比如mixer，mux，输入输出引脚，电源供应器等等，甚至，我们可以定义虚拟的widget，例如playback stream widget。widget把kcontrol和动态电源管理进行了有机的结合，同时还具备音频路径的连结功能，一个widget可以与它相邻的widget有某种动态的连结关系。在DAPM框架中，widget用结构体snd_soc_dapm_widget来描述：

[cpp]  view plain  copy
  1. struct snd_soc_dapm_widget {  
  2.         enum snd_soc_dapm_type id;  
  3.         const char *name;               /* widget name */  
  4.   
  5.         ......  
  6.         /* dapm control */  
  7.         int reg;                                /* negative reg = no direct dapm */  
  8.         unsigned char shift;                    /* bits to shift */  
  9.         unsigned int value;                             /* widget current value */  
  10.         unsigned int mask;                      /* non-shifted mask */  
  11.         ......  
  12.   
  13.         int (*power_check)(struct snd_soc_dapm_widget *w);  
  14.   
  15.         int (*event)(struct snd_soc_dapm_widget*, struct snd_kcontrol *, int);  
  16.   
  17.         /* kcontrols that relate to this widget */  
  18.         int num_kcontrols;  
  19.         const struct snd_kcontrol_new *kcontrol_news;  
  20.         struct snd_kcontrol **kcontrols;  
  21.   
  22.         /* widget input and outputs */  
  23.         struct list_head sources;  
  24.         struct list_head sinks;  
  25.         ......  
  26. };  
snd_soc_dapm_widget结构比较大，为了简洁一些，这里我没有列出该结构体的完整字段，不过不用担心，下面我会说明每个字段的意义：

id    该widget的类型值，比如snd_soc_dapm_output，snd_soc_dapm_mixer等等。

*name    该widget的名字

*sname    代表该widget所在stream的名字，比如对于snd_soc_dapm_dai_in类型的widget，会使用该字段。

*codec *platform    指向该widget所属的codec和platform。

list    所有注册到系统中的widget都会通过该list，链接到代表声卡的snd_soc_card结构的widgets链表头字段中。

*dapm    snd_soc_dapm_context结构指针，ASoc把系统划分为多个dapm域，每个widget属于某个dapm域，同一个域代表着同样的偏置电压供电策略，比如，同一个codec中的widget通常位于同一个dapm域，而平台上的widget可能又会位于另外一个platform域中。

*priv    有些widget可能需要一些专有的数据，可以使用该字段来保存，像snd_soc_dapm_dai_in类型的widget，会使用该字段来记住与之相关联的snd_soc_dai结构指针。

*regulator    对于snd_soc_dapm_regulator_supply类型的widget，该字段指向与之相关的regulator结构指针。

*params    目前对于snd_soc_dapm_dai_link类型的widget，指向该dai的配置信息的snd_soc_pcm_stream结构。

reg shift mask     这3个字段用来控制该widget的电源状态，分别对应控制信息所在的寄存器地址，位移值和屏蔽值。

value  on_val  off_val    电源状态的当前只，开启时和关闭时所对应的值。

power invert    用于指示该widget当前是否处于上电状态，invert则用于表明power字段是否需要逻辑反转。

active connected    分别表示该widget是否处于激活状态和连接状态，当和相邻的widget有连接关系时，connected位会被置1，否则置0。

new   我们定义好的widget（snd_soc_dapm_widget结构），在注册到声卡中时需要进行实例化，该字段用来表示该widget是否已经被实例化。

ext    表示该widget当前是否有外部连接，比如连接mic，耳机，喇叭等等。

force    该位被设置后，将会不管widget当前的状态，强制更新至新的电源状态。

ignore_suspend new_power power_checked    这些电源管理相关的字段。

subseq    该widget目前在上电或下电队列中的排序编号，为了防止在上下电的过程中出现pop-pop声，DAPM会给每个widget分配合理的上下电顺序。

*power_check    用于检查该widget是否应该上电或下电的回调函数指针。
event_flags    该字段是一个位或字段，每个位代表该widget会关注某个DAPM事件通知。只有被关注的通知事件会被发送到widget的事件处理回调函数中。

*event    DAPM事件处理回调函数指针。

num_kcontrols *kcontrol_news **kcontrols    这3个字段用来描述与该widget所包含的kcontrol控件，例如一个mixer控件或者是一个mux控件。

sources sinks    两个链表字段，两个widget如果有连接关系，会通过一个snd_soc_dapm_path结构进行连接，sources链表用于链接所有的输入path，sinks链表用于链接所有的输出path。

power_list    每次更新整个dapm的电源状态时，会根据一定的算法扫描所有的widget，然后把需要变更电源状态的widget利用该字段链接到一个上电或下电的链表中，扫描完毕后，dapm系统会遍历这两个链表执行相应的上电或下电操作。

dirty    链表字段，widget的状态变更后，dapm系统会利用该字段，把该widget加入到一个dirty链表中，稍后会对dirty链表进行扫描，以执行整个路径的更新。

inputs    该widget的所有有效路径中，连接到输入端的路径数量。

outputs    该widget的所有有效路径中，连接到输出端的路径数量。

*clk    对于snd_soc_dapm_clock_supply类型的widget，指向相关联的clk结构指针。

以上我们对snd_soc_dapm_widget结构的各个字段所代表的意义一一做出了说明，这里只是让大家现有个概念，至于每个字段的详细作用，我们会在以后相关的章节中提及。

widget的种类

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

[cpp]  view plain  copy
  1. /* dapm widget types */  
  2. enum snd_soc_dapm_type {......}  
下面我们逐个解释一下这些widget的种类：

  • snd_soc_dapm_input     该widget对应一个输入引脚。
  • snd_soc_dapm_output    该widget对应一个输出引脚。
  • snd_soc_dapm_mux    该widget对应一个mux控件。
  • snd_soc_dapm_virt_mux    该widget对应一个虚拟的mux控件。
  • snd_soc_dapm_value_mux    该widget对应一个value类型的mux控件。
  • snd_soc_dapm_mixer    该widget对应一个mixer控件。
  • snd_soc_dapm_mixer_named_ctl    该widget对应一个mixer控件，但是对应的kcontrol的名字不会加入widget的名字作为前缀。
  • snd_soc_dapm_pga    该widget对应一个pga控件（可编程增益控件）。
  • snd_soc_dapm_out_drv    该widget对应一个输出驱动控件
  • snd_soc_dapm_adc    该widget对应一个ADC 
  • snd_soc_dapm_dac    该widget对应一个DAC 
  • snd_soc_dapm_micbias    该widget对应一个麦克风偏置电压控件
  • snd_soc_dapm_mic    该widget对应一个麦克风。
  • snd_soc_dapm_hp    该widget对应一个耳机。
  • snd_soc_dapm_spk    该widget对应一个扬声器。
  • snd_soc_dapm_line     该widget对应一个线路输入。
  • snd_soc_dapm_switch       该widget对应一个模拟开关。
  • snd_soc_dapm_vmid      该widget对应一个codec的vmid偏置电压。
  • snd_soc_dapm_pre      machine级别的专用widget，会先于其它widget执行检查操作。
  • snd_soc_dapm_post    machine级别的专用widget，会后于其它widget执行检查操作。
  • snd_soc_dapm_supply           对应一个电源或是时钟源。
  • snd_soc_dapm_regulator_supply  对应一个外部regulator稳压器。
  • snd_soc_dapm_clock_supply      对应一个外部时钟源。
  • snd_soc_dapm_aif_in            对应一个数字音频输入接口，比如I2S接口的输入端。
  • snd_soc_dapm_aif_out          对应一个数字音频输出接口，比如I2S接口的输出端。
  • snd_soc_dapm_siggen            对应一个信号发生器。
  • snd_soc_dapm_dai_in           对应一个platform或codec域的输入DAI结构。
  • snd_soc_dapm_dai_out        对应一个platform或codec域的输出DAI结构。
  • snd_soc_dapm_dai_link         用于链接一对输入/输出DAI结构。

widget之间的连接器：path

之前已经提到，一个widget是有输入和输出的，而且widget之间是可以动态地进行连接的，那它们是用什么来连接两个widget的呢？DAPM为我们提出了path这一概念，path相当于电路中的一根跳线，它把一个widget的输出端和另一个widget的输入端连接在一起，path用snd_soc_dapm_path结构来描述：

[cpp]  view plain  copy
  1. struct snd_soc_dapm_path {  
  2.         const char *name;  
  3.   
  4.         /* source (input) and sink (output) widgets */  
  5.         struct snd_soc_dapm_widget *source;  
  6.         struct snd_soc_dapm_widget *sink;  
  7.         struct snd_kcontrol *kcontrol;  
  8.   
  9.         /* status */  
  10.         u32 connect:1;  /* source and sink widgets are connected */  
  11.         u32 walked:1;   /* path has been walked */  
  12.         u32 walking:1;  /* path is in the process of being walked */  
  13.         u32 weak:1;     /* path ignored for power management */  
  14.   
  15.         int (*connected)(struct snd_soc_dapm_widget *source,  
  16.                          struct snd_soc_dapm_widget *sink);  
  17.   
  18.         struct list_head list_source;  
  19.         struct list_head list_sink;  
  20.         struct list_head list;  
  21. };  
当widget之间发生连接关系时，snd_soc_dapm_path作为连接者，它的source字段会指向该连接的起始端widget，而它的sink字段会指向该连接的到达端widget，还记得前面snd_soc_dapm_widget结构中的两个链表头字段：sources和sinks么？widget的输入端和输出端可能连接着多个path，所有输入端的snd_soc_dapm_path结构通过list_sink字段挂在widget的souces链表中，同样，所有输出端的snd_soc_dapm_path结构通过list_source字段挂在widget的sinks链表中。这里可能大家会被搞得晕呼呼的，一会source，一会sink，不要紧，只要记住，连接的路径是这样的：起始端widget的输出-->path的输入-->path的输出-->到达端widget输入。



                                                                                   图1    widget通过path进行连接

另外，snd_soc_dapm_path结构的list字段用于把所有的path注册到声卡中，其实就是挂在snd_soc_card结构的paths链表头字段中。如果你要自己定义方法来检查path的当前连接状态，你可以提供自己的connected回调函数指针。

connect，walked，walking，weak是几个辅助字段，用于帮助所有path的遍历。

widget的连接关系：route

通过上一节的内容，我们知道，一个路径的连接至少包含以下几个元素：起始端widget，跳线path，到达端widget，在DAPM中，用snd_soc_dapm_route结构来描述这样一个连接关系：

[cpp]  view plain  copy
  1. struct snd_soc_dapm_route {  
  2.         const char *sink;  
  3.         const char *control;  
  4.         const char *source;  
  5.         int (*connected)(struct snd_soc_dapm_widget *source,  
  6.                          struct snd_soc_dapm_widget *sink);  
  7. };  
sink指向到达端widget的名字字符串，source指向起始端widget的名字字符串，control指向负责控制该连接所对应的kcontrol名字字符串，connected回调则定义了上一节所提到的自定义连接检查回调函数。该结构的意义很明显就是：source通过一个kcontrol，和sink连接在一起，现在是否处于连接状态，请调用connected回调函数检查。

这里直接使用名字字符串来描述连接关系，所有定义好的route，最后都要注册到dapm系统中，dapm会根据这些名字找出相应的widget，并动态地生成所需要的snd_soc_dapm_path结构，正确地处理各个链表和指针的关系，实现两个widget之间的连接，具体的连接代码分析，我们留到以后的章节中讨论。


ALSA声卡驱动中的DAPM详解之三：如何定义各种widget

上一节中，介绍了DAPM框架中几个重要的数据结构：snd_soc_dapm_widget，snd_soc_dapm_path，snd_soc_dapm_route。其中snd_soc_dapm_path无需我们自己定义，它会在注册snd_soc_dapm_route时动态地生成，但是对于系统中的widget和route，我们是需要自己进行定义的，另外，widget所包含的kcontrol与普通的kcontrol有所不同，它们的定义方法与标准的kcontrol也有所不同。本节的内容我将会介绍如何使用DAPM系统提供的一些辅助宏定义来定义各种类型的widget和它所用到的kcontrol。

/*****************************************************************************************************/
声明：本博内容均由http://blog.csdn.net/droidphone原创，转载请注明出处，谢谢！
/*****************************************************************************************************/

定义widget

和普通的kcontrol一样，DAPM框架为我们提供了大量的辅助宏用来定义各种各样的widget控件，这些宏定义根据widget的类型，按照它们的电源所在的域，被分为了几个域，他们分别是：

  • codec域     比如VREF和VMID等提供参考电压的widget，这些widget通常在codec的probe/remove回调中进行控制，当然，在工作中如果没有音频流时，也可以适当地进行控制它们的开启与关闭。
  • platform域    位于该域上的widget通常是针对平台或板子的一些需要物理连接的输入/输出接口，例如耳机、扬声器、麦克风，因为这些接口在每块板子上都可能不一样，所以通常它们是在machine驱动中进行定义和控制，并且也可以由用户空间的应用程序通过某种方式来控制它们的打开和关闭。
  • 音频路径域    一般是指codec内部的mixer、mux等控制音频路径的widget，这些widget可以根据用户空间的设定连接关系，自动设定他们的电源状态。
  • 音频数据流域    是指那些需要处理音频数据流的widget，例如ADC、DAC等等。

codec域widget的定义

目前，DAPM框架只提供了定义一个codec域widget的辅助宏：

[cpp]  view plain  copy
  1. #define SND_SOC_DAPM_VMID(wname) \  
  2. {       .id = snd_soc_dapm_vmid, .name = wname, .kcontrol_news = NULL, \  
  3.         .num_kcontrols = 0}  

platform域widget的定义

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

[cpp]  view plain  copy
  1. #define SND_SOC_DAPM_SIGGEN(wname) \  
  2. {       .id = snd_soc_dapm_siggen, .name = wname, .kcontrol_news = NULL, \  
  3.         .num_kcontrols = 0, .reg = SND_SOC_NOPM }  
  4. #define SND_SOC_DAPM_INPUT(wname) \  
  5. {       .id = snd_soc_dapm_input, .name = wname, .kcontrol_news = NULL, \  
  6.         .num_kcontrols = 0, .reg = SND_SOC_NOPM }  
  7. #define SND_SOC_DAPM_OUTPUT(wname) \  
  8. {       .id = snd_soc_dapm_output, .name = wname, .kcontrol_news = NULL, \  
  9.         .num_kcontrols = 0, .reg = SND_SOC_NOPM }  
  10. #define SND_SOC_DAPM_MIC(wname, wevent) \  
  11. {       .id = snd_soc_dapm_mic, .name = wname, .kcontrol_news = NULL, \  
  12.         .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \  
  13.         .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD}  
  14. #define SND_SOC_DAPM_HP(wname, wevent) \  
  15. {       .id = snd_soc_dapm_hp, .name = wname, .kcontrol_news = NULL, \  
  16.         .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \  
  17.         .event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD}  
  18. #define SND_SOC_DAPM_SPK(wname, wevent) \  
  19. {       .id = snd_soc_dapm_spk, .name = wname, .kcontrol_news = NULL, \  
  20.         .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \  
  21.         .event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD}  
  22. #define SND_SOC_DAPM_LINE(wname, wevent) \  
  23. {       .id = snd_soc_dapm_line, .name = wname, .kcontrol_news = NULL, \  
  24.         .num_kcontrols = 0, .reg = SND_SOC_NOPM, .event = wevent, \  
  25.         .event_flags = SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD}  
以上这些widget分别对应信号发生器，输入引脚，输出引脚，麦克风，耳机，扬声器，线路输入接口。其中的reg字段被设置为SND_SOC_NOPM（-1），表明这些widget是没有寄存器控制位来控制widget的电源状态的。麦克风，耳机，扬声器，线路输入接口这几种widget，还可以定义一个dapm事件回调函数wevent，从event_flags字段的设置可以看出，他们只会响应SND_SOC_DAPM_POST_PMU（上电后）和SND_SOC_DAPM_PMD（下电前）事件，这几个widget通常会在machine驱动中定义，而SND_SOC_DAPM_INPUT和SND_SOC_DAPM_OUTPUT则用来定义codec芯片的输出输入脚，通常在codec驱动中定义，最后，在machine驱动中增加相应的route，把麦克风和耳机等widget与相应的codec输入输出引脚的widget连接起来。

音频路径（path）域widget的定义

这种widget通常是对普通kcontrols控件的再封装，增加音频路径和电源管理功能，所以这种widget会包含一个或多个kcontrol，普通kcontrol的定义方法我们在 ALSA声卡驱动中的DAPM详解之一：kcontrol 中已经介绍过，不过这些被包含的kcontrol不能使用这种方法定义，它们需要使用dapm框架提供的定义宏来定义，详细的讨论我们后面有介绍。这里先列出这些widget的定义宏：

[cpp]  view plain  copy
  1. #define SND_SOC_DAPM_PGA(wname, wreg, wshift, winvert,\  
  2.          wcontrols, wncontrols) \  
  3. {       .id = snd_soc_dapm_pga, .name = wname, .reg = wreg, .shift = wshift, \  
  4.         .invert = winvert, .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}  
  5. #define SND_SOC_DAPM_OUT_DRV(wname, wreg, wshift, winvert,\  
  6.          wcontrols, wncontrols) \  
  7. {       .id = snd_soc_dapm_out_drv, .name = wname, .reg = wreg, .shift = wshift, \  
  8.         .invert = winvert, .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}  
  9. #define SND_SOC_DAPM_MIXER(wname, wreg, wshift, winvert, \  
  10.          wcontrols, wncontrols)\  
  11. {       .id = snd_soc_dapm_mixer, .name = wname, .reg = wreg, .shift = wshift, \  
  12.         .invert = winvert, .kcontrol_news = wcontrols, .num_kcontrols = wncontrols}  
  13. #define SND_SOC_DAPM_MIXER_NAMED_CTL(wname, wreg, wshift, winvert, \  
  14.          wcontrols, wncontrols)\  
  15. {       .id = snd_soc_dapm_mixer_named_ctl, .name = wname, .reg = wreg, \  
  16.         .shift = wshift, .invert = winvert, .kcontrol_news = wcontrols, \  
  17.         .num_kcontrols = wncontrols}  
  18. #define SND_SOC_DAPM_MICBIAS(wname, wreg, wshift, winvert) \  
  19. {       .id = snd_soc_dapm_micbias, .name = wname, .reg = wreg, .shift = wshift, \  
  20.         .invert = winvert, .kcontrol_news = NULL, .num_kcontrols = 0}  
  21. #define SND_SOC_DAPM_SWITCH(wname, wreg, wshift, winvert, wcontrols) \  
  22. {       .id = snd_soc_dapm_switch, .name = wname, .reg = wreg, .shift = wshift, \  
  23.         .invert = winvert, .kcontrol_news = wcontrols, .num_kcontrols = 1}  
  24. #define SND_SOC_DAPM_MUX(wname, wreg, wshift, winvert, wcontrols) \  
  25. {       .id = snd_soc_dapm_mux, .name = wname, .reg = wreg, .shift = wshift, \  
  26.         .invert = winvert, .kcontrol_news = wcontrols, .num_kcontrols = 1}  
  27. #define SND_SOC_DAPM_VIRT_MUX(wname, wreg, wshift, winvert, wcontrols) \  
  28. {       .id = snd_soc_dapm_virt_mux, .name = wname, .reg = wreg, .shift = wshift, \  
  29.         .invert = winvert, .kcontrol_news = wcontrols, .num_kcontrols = 1}  
  30. #define SND_SOC_DAPM_VALUE_MUX(wname, wreg, wshift, winvert, wcontrols) \  
  31. {       .id = snd_soc_dapm_value_mux, .name = wname, .reg = wreg, \  
  32.         .shift = wshift, .invert = winvert, .kcontrol_news = wcontrols, \  
  33.         .num_kcontrols = 1}  
可以看出，这些widget的reg和shift字段是需要赋值的，说明这些widget是有相应的电源控制寄存器的，DAPM框架在扫描和更新音频路径时，会利用这些寄存器来控制widget的电源状态，使得它们的供电状态是按需分配的，需要的时候（在有效的音频路径上）上电，不需要的时候（不再有效的音频路径上）下电。这些widget需要完成和之前介绍的mixer、mux等控件同样的功能，实际上，这是通过它们包含的kcontrol控件来完成的，这些kcontrol我们需要在定义widget前先定义好，然后通过wcontrols和num_kcontrols参数传递给这些辅助定义宏。
如果需要自定义这些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

音频数据流（stream）域widget的定义

这些widget主要包含音频输入/输出接口，ADC/DAC等等：

[cpp]  view plain  copy
  1. #define SND_SOC_DAPM_AIF_IN(wname, stname, wslot, wreg, wshift, winvert) \  
  2. {       .id = snd_soc_dapm_aif_in, .name = wname, .sname = stname, \  
  3.         .reg = wreg, .shift = wshift, .invert = winvert }  
  4. #define SND_SOC_DAPM_AIF_IN_E(wname, stname, wslot, wreg, wshift, winvert, \  
  5.                               wevent, wflags)                           \  
  6. {       .id = snd_soc_dapm_aif_in, .name = wname, .sname = stname, \  
  7.         .reg = wreg, .shift = wshift, .invert = winvert, \  
  8.         .event = wevent, .event_flags = wflags }  
  9. #define SND_SOC_DAPM_AIF_OUT(wname, stname, wslot, wreg, wshift, winvert) \  
  10. {       .id = snd_soc_dapm_aif_out, .name = wname, .sname = stname, \  
  11.         .reg = wreg, .shift = wshift, .invert = winvert }  
  12. #define SND_SOC_DAPM_AIF_OUT_E(wname, stname, wslot, wreg, wshift, winvert, \  
  13.                              wevent, wflags)                            \  
  14. {       .id = snd_soc_dapm_aif_out, .name = wname, .sname = stname, \  
  15.         .reg = wreg, .shift = wshift, .invert = winvert, \  
  16.         .event = wevent, .event_flags = wflags }  
  17. #define SND_SOC_DAPM_DAC(wname, stname, wreg, wshift, winvert) \  
  18. {       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, .reg = wreg, \  
  19.         .shift = wshift, .invert = winvert}  
  20. #define SND_SOC_DAPM_DAC_E(wname, stname, wreg, wshift, winvert, \  
  21.                            wevent, wflags)                              \  
  22. {       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, .reg = wreg, \  
  23.         .shift = wshift, .invert = winvert, \  
  24.         .event = wevent, .event_flags = wflags}  
  25. #define SND_SOC_DAPM_ADC(wname, stname, wreg, wshift, winvert) \  
  26. {       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, .reg = wreg, \  
  27.         .shift = wshift, .invert = winvert}  
  28. #define SND_SOC_DAPM_ADC_E(wname, stname, wreg, wshift, winvert, \  
  29.                            wevent, wflags)                              \  
  30. {       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, .reg = wreg, \  
  31.         .shift = wshift, .invert = winvert, \  
  32.         .event = wevent, .event_flags = wflags}  
  33. #define SND_SOC_DAPM_CLOCK_SUPPLY(wname) \  
  34. {       .id = snd_soc_dapm_clock_supply, .name = wname, \  
  35.         .reg = SND_SOC_NOPM, .event = dapm_clock_event, \  
  36.         .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD }  
除了上面这些widget，还有另外三种widget没有提供显示的定义方法，它们的种类id分别是：
  • snd_soc_dapm_dai_in
  • snd_soc_dapm_dai_out
  • snd_soc_dapm_dai_link
还记得我们在 Linux ALSA声卡驱动之七：ASoC架构中的Codec中的 snd_soc_dai结构吗？每个codec有多个dai，而cpu（通常就是指某个soc 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的电源状态就可以互相传递。

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

[cpp]  view plain  copy
  1. #define SND_SOC_DAPM_REG(wid, wname, wreg, wshift, wmask, won_val, woff_val) \  
  2. {       .id = wid, .name = wname, .kcontrol_news = NULL, .num_kcontrols = 0, \  
  3.         .reg = -((wreg) + 1), .shift = wshift, .mask = wmask, \  
  4.         .on_val = won_val, .off_val = woff_val, .event = dapm_reg_event, \  
  5.         .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD}  
  6. #define SND_SOC_DAPM_SUPPLY(wname, wreg, wshift, winvert, wevent, wflags) \  
  7. {       .id = snd_soc_dapm_supply, .name = wname, .reg = wreg,  \  
  8.         .shift = wshift, .invert = winvert, .event = wevent, \  
  9.         .event_flags = wflags}  
  10. #define SND_SOC_DAPM_REGULATOR_SUPPLY(wname, wdelay, wflags)        \  
  11. {       .id = snd_soc_dapm_regulator_supply, .name = wname, \  
  12.         .reg = SND_SOC_NOPM, .shift = wdelay, .event = dapm_regulator_event, \  
  13.         .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD, \  
  14.         .invert = wflags}  

定义dapm kcontrol

上一节提到，对于音频路径上的mixer或mux类型的widget，它们包含了若干个kcontrol，这些被包含的kcontrol实际上就是我们之前讨论的mixer和mux等，dapm利用这些kcontrol完成音频路径的控制。不过，对于widget来说，它的任务还不止这些，dapm还要动态地管理这些音频路径的连结关系，以便可以根据这些连接关系来控制这些widget的电源状态，如果按照普通的方法定义这些kcontrol，是无法达到这个目的的，因此，dapm为我们提供了另外一套定义宏，由它们完成这些被widget包含的kcontrol的定义。

[cpp]  view plain  copy
  1. #define SOC_DAPM_SINGLE(xname, reg, shift, max, invert) \  
  2. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \  
  3.         .info = snd_soc_info_volsw, \  
  4.         .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \  
  5.         .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }  
  6. #define SOC_DAPM_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \  
  7. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \  
  8.         .info = snd_soc_info_volsw, \  
  9.         .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | SNDRV_CTL_ELEM_ACCESS_READWRITE,\  
  10.         .tlv.p = (tlv_array), \  
  11.         .get = snd_soc_dapm_get_volsw, .put = snd_soc_dapm_put_volsw, \  
  12.         .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }  
  13. #define SOC_DAPM_ENUM(xname, xenum) \  
  14. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \  
  15.         .info = snd_soc_info_enum_double, \  
  16.         .get = snd_soc_dapm_get_enum_double, \  
  17.         .put = snd_soc_dapm_put_enum_double, \  
  18.         .private_value = (unsigned long)&xenum }  
  19. #define SOC_DAPM_ENUM_VIRT(xname, xenum)                    \  
  20. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \  
  21.         .info = snd_soc_info_enum_double, \  
  22.         .get = snd_soc_dapm_get_enum_virt, \  
  23.         .put = snd_soc_dapm_put_enum_virt, \  
  24.         .private_value = (unsigned long)&xenum }  
  25. #define SOC_DAPM_ENUM_EXT(xname, xenum, xget, xput) \  
  26. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \  
  27.         .info = snd_soc_info_enum_double, \  
  28.         .get = xget, \  
  29.         .put = xput, \  
  30.         .private_value = (unsigned long)&xenum }  
  31. #define SOC_DAPM_VALUE_ENUM(xname, xenum) \  
  32. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \  
  33.         .info = snd_soc_info_enum_double, \  
  34.         .get = snd_soc_dapm_get_value_enum_double, \  
  35.         .put = snd_soc_dapm_put_value_enum_double, \  
  36.         .private_value = (unsigned long)&xenum }  
  37. #define SOC_DAPM_PIN_SWITCH(xname) \  
  38. {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname " Switch", \  
  39.         .info = snd_soc_dapm_info_pin_switch, \  
  40.         .get = snd_soc_dapm_get_pin_switch, \  
  41.         .put = snd_soc_dapm_put_pin_switch, \  
  42.         .private_value = (unsigned long)xname }  
可以看出，SOC_DAPM_SINGLE对应与普通控件的SOC_SINGLE，SOC_DAPM_SINGLE_TLV对应SOC_SINGLE_TLV......，相比普通的kcontrol控件，dapm的kcontrol控件只是把info，get，put回调函数换掉了。dapm kcontrol的put回调函数不仅仅会更新控件本身的状态，他还会把这种变化传递到相邻的dapm kcontrol，相邻的dapm kcontrol又会传递这个变化到他自己相邻的dapm kcontrol，知道音频路径的末端，通过这种机制，只要改变其中一个widget的连接状态，与之相关的所有widget都会被扫描并测试一下自身是否还在有效的音频路径中，从而可以动态地改变自身的电源状态，这就是dapm的精髓所在。这里我只提一下这种概念，后续的章节会有较为详细的代码分析过程。


建立widget和route

上面介绍了一大堆的辅助宏，那么，对于一个实际的系统，我们怎么定义我们需要的widget？怎样定义widget的连接关系？下面我们还是以Wolfson公司的codec芯片WM8993为例子来了解这个过程。

第一步，利用辅助宏定义widget所需要的dapm kcontrol：

[cpp]  view plain  copy
  1. static const struct snd_kcontrol_new left_speaker_mixer[] = {  
  2. SOC_DAPM_SINGLE("Input Switch", WM8993_SPEAKER_MIXER, 7, 1, 0),  
  3. SOC_DAPM_SINGLE("IN1LP Switch", WM8993_SPEAKER_MIXER, 5, 1, 0),  
  4. SOC_DAPM_SINGLE("Output Switch", WM8993_SPEAKER_MIXER, 3, 1, 0),  
  5. SOC_DAPM_SINGLE("DAC Switch", WM8993_SPEAKER_MIXER, 6, 1, 0),  
  6. };  
  7.   
  8. static const struct snd_kcontrol_new right_speaker_mixer[] = {  
  9. SOC_DAPM_SINGLE("Input Switch", WM8993_SPEAKER_MIXER, 6, 1, 0),  
  10. SOC_DAPM_SINGLE("IN1RP Switch", WM8993_SPEAKER_MIXER, 4, 1, 0),  
  11. SOC_DAPM_SINGLE("Output Switch", WM8993_SPEAKER_MIXER, 2, 1, 0),  
  12. SOC_DAPM_SINGLE("DAC Switch", WM8993_SPEAKER_MIXER, 0, 1, 0),  
  13. };  
  14.   
  15. static const char *aif_text[] = {  
  16.         "Left", "Right"  
  17. };  
  18.   
  19. static const struct soc_enum aifinl_enum =  
  20.         SOC_ENUM_SINGLE(WM8993_AUDIO_INTERFACE_2, 15, 2, aif_text);  
  21.   
  22.   
  23. static const struct snd_kcontrol_new aifinl_mux =  
  24.         SOC_DAPM_ENUM("AIFINL Mux", aifinl_enum);  
  25.   
  26.   
  27. static const struct soc_enum aifinr_enum =  
  28.         SOC_ENUM_SINGLE(WM8993_AUDIO_INTERFACE_2, 14, 2, aif_text);  
  29.   
  30.   
  31. static const struct snd_kcontrol_new aifinr_mux =  
  32.         SOC_DAPM_ENUM("AIFINR Mux", aifinr_enum);  
以上，我们定义了wm8993中左右声道的speaker mixer控件：left_speaker_mixer和right_speaker_mixer，同时还为左右声道各定义了一个叫做AIFINL Mux和AIFINR Mux的输入选择mux控件。


第二步，定义真正的widget，包含第一步定义好的dapm控件：

[cpp]  view plain  copy
  1. static const struct snd_soc_dapm_widget wm8993_dapm_widgets[] = {  
  2.     ......  
  3.     SND_SOC_DAPM_AIF_IN("AIFINL", "Playback", 0, SND_SOC_NOPM, 0, 0),  
  4.     SND_SOC_DAPM_AIF_IN("AIFINR", "Playback", 1, SND_SOC_NOPM, 0, 0),  
  5.     ......      
  6.     SND_SOC_DAPM_MUX("DACL Mux", SND_SOC_NOPM, 0, 0, &aifinl_mux),  
  7.     SND_SOC_DAPM_MUX("DACR Mux", SND_SOC_NOPM, 0, 0, &aifinr_mux),  
  8.   
  9.     SND_SOC_DAPM_MIXER("SPKL", WM8993_POWER_MANAGEMENT_3, 8, 0,  
  10.                    left_speaker_mixer, ARRAY_SIZE(left_speaker_mixer)),  
  11.     SND_SOC_DAPM_MIXER("SPKR", WM8993_POWER_MANAGEMENT_3, 9, 0,  
  12.                    right_speaker_mixer, ARRAY_SIZE(right_speaker_mixer)),  
  13.     ......  
  14. };  

这一步，为左右声道各自定义了一个mux widget：DACL Mux和DACR Mux，实际的多路选择由dapm kcontrol：aifinl_mux和aifinr_mux，来完成，因为传入了SND_SOC_NOPM参数，这两个widget不具备电源属性，但是mux的切换会影响到与之相连的其它具备电源属性的电源状态。我们还为左右声道的扬声器各自定义了一个mixer widget：SPKL和SPKR，具体的mixer控制由上一步定义的left_speaker_mixer和right_speaker_mixer来完成，两个widget具备电源属性，所以，当这两个widget在一条有效的音频路径上时，dapm框架可以通过寄存器WM8993_POWER_MANAGEMENT_3的第8位和第9位控制它的电源状态。


第三步，定义这些widget的连接路径：
[cpp]  view plain  copy
  1. static const struct snd_soc_dapm_route routes[] = {  
  2.         ......  
  3.   
  4.         { "DACL Mux", "Left", "AIFINL" },  
  5.         { "DACL Mux", "Right", "AIFINR" },  
  6.         { "DACR Mux", "Left", "AIFINL" },  
  7.         { "DACR Mux", "Right", "AIFINR" },  
  8.   
  9.         ......  
  10.   
  11.         { "SPKL", "DAC Switch", "DACL" },  
  12.         { "SPKL", NULL, "CLK_SYS" },  
  13.   
  14.         { "SPKR", "DAC Switch", "DACR" },  
  15.         { "SPKR", NULL, "CLK_SYS" },  
  16. };  
通过第一步的定义，我们知道DACL Mux和DACR Mux有两个输入引脚，分别是

  • Left
  • Right

而SPKL和SPKR有四个输入选择引脚，分别是：

  • Input Switch
  • IN1LP Switch/IN1RP Switch
  • Output Switch
  • DAC Switch
所以，很显然，上面的路径定义的意思就是：

  • AIFINL连接到DACL Mux的Left输入脚
  • AIFINR连接到DACL Mux的Right输入脚
  • AIFINL连接到DACR Mux的Left输入脚
  • AIFINR连接到DACR Mux的Right输入脚
  • DACL连接到SPKL的DAC Switch输入脚
  • DACR连接到SPKR的DAC Switch输入脚
第四步，在codec驱动的probe回调中注册这些widget和路径：

[cpp]  view plain  copy
  1. static int wm8993_probe(struct snd_soc_codec *codec)  
  2. {  
  3.         ......  
  4.         snd_soc_dapm_new_controls(dapm, wm8993_dapm_widgets,  
  5.                                   ARRAY_SIZE(wm8993_dapm_widgets));  
  6.         ......  
  7.   
  8.         snd_soc_dapm_add_routes(dapm, routes, ARRAY_SIZE(routes));  
  9.         ......  
  10. }  

在machine驱动中，我们可以用同样的方式定义和注册板子特有的widget和路径信息。


ALSA声卡驱动中的DAPM详解之四：在驱动程序中初始化并注册widget和route

前几篇文章我们从dapm的数据结构入手，了解了代表音频控件的widget，代表连接路径的route以及用于连接两个widget的path。之前都是一些概念的讲解以及对数据结构中各个字段的说明，从本章开始，我们要从代码入手，分析dapm的详细工作原理：

  • 如何注册widget
  • 如何连接两个widget
  • 一个widget的状态裱画如何传递到整个音频路径中
/*****************************************************************************************************/
声明：本博内容均由 http://blog.csdn.net/droidphone原创，转载请注明出处，谢谢！
/*****************************************************************************************************/

dapm context

在讨论widget的注册之前，我们先了解另一个概念：dapm context，直译过来的意思是dapm上下文，这个好像不好理解，其实我们可以这么理解：dapm把整个音频系统，按照功能和偏置电压级别，划分为若干个电源域，每个域包含各自的widget，每个域中的所有widget通常都处于同一个偏置电压级别上，而一个电源域就是一个dapm context，通常会有以下几种dapm context：
  • 属于codec中的widget位于一个dapm context中
  • 属于platform的widget位于一个dapm context中
  • 属于整个声卡的widget位于一个dapm context中
对于音频系统的硬件来说，通常要提供合适的偏置电压才能正常地工作，有了dapm context这种组织方式，我们可以方便地对同一组widget进行统一的偏置电压管理，ASoc用snd_soc_dapm_context结构来表示一个dapm context：
[cpp]  view plain  copy
  1. struct snd_soc_dapm_context {  
  2.         enum snd_soc_bias_level bias_level;  
  3.         enum snd_soc_bias_level suspend_bias_level;  
  4.         struct delayed_work delayed_work;  
  5.         unsigned int idle_bias_off:1; /* Use BIAS_OFF instead of STANDBY */  
  6.   
  7.         struct snd_soc_dapm_update *update;  
  8.   
  9.         void (*seq_notifier)(struct snd_soc_dapm_context *,  
  10.                              enum snd_soc_dapm_type, int);  
  11.   
  12.         struct device *dev; /* from parent - for debug */  
  13.         struct snd_soc_codec *codec; /* parent codec */  
  14.         struct snd_soc_platform *platform; /* parent platform */  
  15.         struct snd_soc_card *card; /* parent card */  
  16.   
  17.         /* used during DAPM updates */  
  18.         enum snd_soc_bias_level target_bias_level;  
  19.         struct list_head list;  
  20.   
  21.         int (*stream_event)(struct snd_soc_dapm_context *dapm, int event);  
  22.   
  23. #ifdef CONFIG_DEBUG_FS  
  24.         struct dentry *debugfs_dapm;  
  25. #endif  
  26. };  
snd_soc_bias_level的取值范围是以下几种：
  • SND_SOC_BIAS_OFF
  • SND_SOC_BIAS_STANDBY
  • SND_SOC_BIAS_PREPARE
  • SND_SOC_BIAS_ON
snd_soc_dapm_context被内嵌到代表codec、platform、card、dai的结构体中：
[cpp]  view plain  copy
  1. struct snd_soc_codec {  
  2.         ......  
  3.         /* dapm */  
  4.         struct snd_soc_dapm_context dapm;  
  5.         ......  
  6. };  
  7.   
  8. struct snd_soc_platform {  
  9.         ......  
  10.         /* dapm */  
  11.         struct snd_soc_dapm_context dapm;  
  12.         ......  
  13. };  
  14.   
  15. struct snd_soc_card {  
  16.         ......  
  17.         /* dapm */  
  18.         struct snd_soc_dapm_context dapm;  
  19.         ......  
  20. };  
  21. :  
  22. struct snd_soc_dai {  
  23.         ......  
  24.         /* dapm */  
  25.         struct snd_soc_dapm_widget *playback_widget;  
  26.         struct snd_soc_dapm_widget *capture_widget;  
  27.         struct snd_soc_dapm_context dapm;  
  28.         ......  
  29. };  
代表widget结构snd_soc_dapm_widget中，有一个snd_soc_dapm_context结构指针，指向所属的codec、platform、card、或dai的dapm结构。同时，所有的dapm结构，通过它的list字段，链接到代表声卡的snd_soc_card结构的dapm_list链表头字段。

创建和注册widget

我们已经知道，一个widget用snd_soc_dapm_widget结构体来描述，通常，我们会根据音频硬件的组成，分别在声卡的codec驱动、platform驱动和machine驱动中定义一组widget，这些widget用数组进行组织，我们一般会使用dapm框架提供的大量的辅助宏来定义这些widget数组，辅助宏的说明请参考前一偏文章：ALSA声卡驱动中的DAPM详解之三：如何定义各种widget。

codec驱动中注册    我们知道，我们会通过ASoc提供的api函数snd_soc_register_codec来注册一个codec驱动，该函数的第二个参数是一个snd_soc_codec_driver结构指针，这个snd_soc_codec_driver结构需要我们在codec驱动中显式地进行定义，其中有几个与dapm框架有关的字段：

[cpp]  view plain  copy
  1. struct snd_soc_codec_driver {  
  2.         ......          
  3.         /* Default control and setup, added after probe() is run */  
  4.         const struct snd_kcontrol_new *controls;  
  5.         int num_controls;  
  6.         const struct snd_soc_dapm_widget *dapm_widgets;  
  7.         int num_dapm_widgets;  
  8.         const struct snd_soc_dapm_route *dapm_routes;  
  9.         int num_dapm_routes;  
  10.         ......  
  11. }  
我们只要把我们定义好的snd_soc_dapm_widget结构数组的地址和widget的数量赋值到dapm_widgets和num_dapm_widgets字段即可，这样，经过snd_soc_register_codec注册codec后，在machine驱动匹配上该codec时，系统会判断这两个字段是否被赋值，如果有，它会调佣dapm框架提供的api来创建和注册widget，注意这里我说还要创建这个词，你可能比较奇怪，既然代表widget的snd_soc_dapm_widget结构数组已经在codec驱动中定义好了，为什么还要在创建？事实上，我们在codec驱动中定义的widget数组只是作为一个模板，dapm框架会根据该模板重新申请内存并初始化各个widget。我们看看实际的例子可能是这样的：

[cpp]  view plain  copy
  1. static const struct snd_soc_dapm_widget wm8993_dapm_widgets[] = {  
  2.         ......  
  3.         SND_SOC_DAPM_SUPPLY("VMID", SND_SOC_NOPM, 0, 0, NULL, 0),  
  4.         SND_SOC_DAPM_AIF_IN("AIFINL", "Playback", 0, SND_SOC_NOPM, 0, 0),  
  5.         SND_SOC_DAPM_AIF_IN("AIFINR", "Playback", 1, SND_SOC_NOPM, 0, 0),  
  6.         ......  
  7. };  
  8.   
  9. static struct snd_soc_codec_driver soc_codec_dev_wm8993 = {  
  10.         .probe =        codec_xxx_probe,  
  11.         ......  
  12.         .dapm_widgets =       &wm8993_dapm_widgets[0],  
  13.         .num_dapm_widgets =      ARRAY_SIZE(wm8993_dapm_widgets),  
  14.         ......  
  15. };   
  16.   
  17. static int codec_wm8993_i2c_probe(struct i2c_client *i2c,  
  18.                             const struct i2c_device_id *id)  
  19. {  
  20.         ......  
  21.         ret = snd_soc_register_codec(&i2c->dev,  
  22.                         &soc_codec_dev_wm8993, &wm8993_dai, 1);  
  23.         ......  
  24. }  
上面这种注册方法有个缺点，有时候我们为了代码的清晰，可能会根据功能把不同的widget定义成多个数组，但是snd_soc_codec_driver中只有一个dapm_widgets字段，无法设定多个widget数组，这时候，我们需要主动在codec的probe回调中调用dapm框架提供的api来创建这些widget：
[cpp]  view plain  copy
  1. static int wm8993_probe(struct snd_soc_codec *codec)  
  2. {  
  3.         ......  
  4.         snd_soc_dapm_new_controls(dapm, wm8993_dapm_widgets,  
  5.                                   ARRAY_SIZE(wm8993_dapm_widgets));  
  6.         ......  
  7. }  
实际上，对于第一种方法，snd_soc_register_codec内部其实也是调用snd_soc_dapm_new_controls来完成的。后面会有关于这个函数的详细分析。

platform驱动中注册    和codec驱动一样，我们会通过ASoc提供的api函数snd_soc_register_platform来注册一个platform驱动，该函数的第二个参数是一个snd_soc_platform_driver结构指针，snd_soc_platform_driver结构中同样也包含了与dapm相关的字段：

[cpp]  view plain  copy
  1. struct snd_soc_platform_driver {  
  2.         ......          
  3.         /* Default control and setup, added after probe() is run */  
  4.         const struct snd_kcontrol_new *controls;  
  5.         int num_controls;  
  6.         const struct snd_soc_dapm_widget *dapm_widgets;  
  7.         int num_dapm_widgets;  
  8.         const struct snd_soc_dapm_route *dapm_routes;  
  9.         int num_dapm_routes;  
  10.         ......  
  11. }  
要注册platform级别的widget，和codec驱动一样，只要把定义好的widget数组赋值给dapm_widgets和num_dapm_widgets字段即可，snd_soc_register_platform函数注册paltform后，当machine驱动匹配上该platform时，系统会自动完成创建和注册的工作。同理，我们也可以在platform驱动的probe回调函数中主动使用snd_soc_dapm_new_controls来完成widget的创建工作。具体的代码和codec驱动是类似的，这里就不贴了。

machine驱动中注册    有些widget可能不是位于codec中，例如一个独立的耳机放大器，或者是喇叭功放等，这种widget通常需要在machine驱动中注册，通常他们的dapm context也从属于声卡（snd_soc_card）域。做法依然和codec驱动类似，通过代表声卡的snd_soc_card结构中的几个dapm字段完成：

[cpp]  view plain  copy
  1. struct snd_soc_card {  
  2.         ......  
  3.         /* 
  4.          * Card-specific routes and widgets. 
  5.          */  
  6.         const struct snd_soc_dapm_widget *dapm_widgets;  
  7.         int num_dapm_widgets;  
  8.         const struct snd_soc_dapm_route *dapm_routes;  
  9.         int num_dapm_routes;  
  10.         bool fully_routed;  
  11.         ......  
  12. }  
只要把定义好的widget数组和数量赋值给dapm_widgets指针和num_dapm_widgets即可，注册声卡使用的api：snd_soc_register_card()，也会通过snd_soc_dapm_new_controls来完成widget的创建工作。

注册音频路径

系统中注册的各种widget需要互相连接在一起才能协调工作，连接关系通过snd_soc_dapm_route结构来定义，关于如何用snd_soc_dapm_route结构来定义路径信息，请参考： ALSA声卡驱动中的DAPM详解之三：如何定义各种widget中的"建立widget和route"一节的内容。通常，所有的路径信息会用一个snd_soc_dapm_route结构数组来定义。和widget一样，路径信息也分别存在与codec驱动，machine驱动和platform驱动中，我们一样有两种方式来注册音频路径信息：
  • 通过snd_soc_codec_driver/snd_soc_platform_driver/snd_soc_card结构中的dapm_routes和num_dapm_routes字段；
  • 在codec、platform的的probe回调中主动注册音频路径，machine驱动中则通过snd_soc_dai_link结构的init回调函数来注册音频路径；
两种方法最终都是通过调用snd_soc_dapm_add_routes函数来完成音频路径的注册工作的。以下的代码片段是omap的pandora板子的machine驱动，使用第二种方法注册路径信息：
[cpp]  view plain  copy
  1. static const struct snd_soc_dapm_widget omap3pandora_in_dapm_widgets[] = {  
  2.         SND_SOC_DAPM_MIC("Mic (internal)", NULL),  
  3.         SND_SOC_DAPM_MIC("Mic (external)", NULL),  
  4.         SND_SOC_DAPM_LINE("Line In", NULL),  
  5. };  
  6.   
  7. static const struct snd_soc_dapm_route omap3pandora_out_map[] = {  
  8.         {"PCM DAC", NULL, "APLL Enable"},  
  9.         {"Headphone Amplifier", NULL, "PCM DAC"},  
  10.         {"Line Out", NULL, "PCM DAC"},  
  11.         {"Headphone Jack", NULL, "Headphone Amplifier"},  
  12. };  
  13.   
  14. static const struct snd_soc_dapm_route omap3pandora_in_map[] = {  
  15.         {"AUXL", NULL, "Line In"},  
  16.         {"AUXR", NULL, "Line In"},  
  17.   
  18.         {"MAINMIC", NULL, "Mic (internal)"},  
  19.         {"Mic (internal)", NULL, "Mic Bias 1"},  
  20.   
  21.         {"SUBMIC", NULL, "Mic (external)"},  
  22.         {"Mic (external)", NULL, "Mic Bias 2"},  
  23. };  
  24. static int omap3pandora_out_init(struct snd_soc_pcm_runtime *rtd)  
  25. {  
  26.         struct snd_soc_codec *codec = rtd->codec;  
  27.         struct snd_soc_dapm_context *dapm = &codec->dapm;  
  28.         int ret;  
  29.   
  30.         /* All TWL4030 output pins are floating */  
  31.         snd_soc_dapm_nc_pin(dapm, "EARPIECE");  
  32.         ......  
  33.         //注册kcontrol控件  
  34.         ret = snd_soc_dapm_new_controls(dapm, omap3pandora_out_dapm_widgets,  
  35.                                 ARRAY_SIZE(omap3pandora_out_dapm_widgets));  
  36.         if (ret < 0)  
  37.                 return ret;  
  38.         //注册machine的音频路径  
  39.         return snd_soc_dapm_add_routes(dapm, omap3pandora_out_map,  
  40.                 ARRAY_SIZE(omap3pandora_out_map));  
  41. }  
  42.   
  43. static int omap3pandora_in_init(struct snd_soc_pcm_runtime *rtd)  
  44. {  
  45.         struct snd_soc_codec *codec = rtd->codec;  
  46.         struct snd_soc_dapm_context *dapm = &codec->dapm;  
  47.         int ret;  
  48.   
  49.         /* Not comnnected */  
  50.         snd_soc_dapm_nc_pin(dapm, "HSMIC");  
  51.         ......  
  52.         //注册kcontrol控件  
  53.         ret = snd_soc_dapm_new_controls(dapm, omap3pandora_in_dapm_widgets,  
  54.                                 ARRAY_SIZE(omap3pandora_in_dapm_widgets));  
  55.         if (ret < 0)  
  56.                 return ret;  
  57.         //注册machine音频路径  
  58.         return snd_soc_dapm_add_routes(dapm, omap3pandora_in_map,  
  59.                 ARRAY_SIZE(omap3pandora_in_map));  
  60. }  
  61.   
  62. /* Digital audio interface glue - connects codec <--> CPU */  
  63. static struct snd_soc_dai_link omap3pandora_dai[] = {  
  64.         {  
  65.                 .name = "PCM1773",  
  66.                 ......  
  67.                 .init = omap3pandora_out_init,  
  68.         }, {  
  69.                 .name = "TWL4030",  
  70.                 .stream_name = "Line/Mic In",  
  71.                 ......  
  72.                 .init = omap3pandora_in_init,  
  73.         }  
  74. };  



dai widget

上面几节的内容介绍了codec、platform以及machine级别的widget和route的注册方法，在dapm框架中，还有另外一种widget，它代表了一个dai（数字音频接口），关于dai的描述，请参考：Linux ALSA声卡驱动之七：ASoC架构中的Codec。dai按所在的位置，又分为cpu dai和codec dai，在硬件上，通常一个cpu dai会连接一个codec dai，而在machine驱动中，我们要在snd_soc_card结构中指定一个叫做snd_soc_dai_link的结构，该结构定义了声卡使用哪一个cpu dai和codec dai进行连接。在Asoc中，一个dai用snd_soc_dai结构来表述，其中有几个字段和dapm框架有关：

[cpp]  view plain  copy
  1. struct snd_soc_dai {  
  2.         ......  
  3.         struct snd_soc_dapm_widget *playback_widget;  
  4.         struct snd_soc_dapm_widget *capture_widget;  
  5.         struct snd_soc_dapm_context dapm;  
  6.         ......  
  7. }  
dai由codec驱动和平台代码中的iis或pcm接口驱动注册，machine驱动负责找到 snd_soc_dai_link中指定的一对cpu/codec dai，并把它们进行绑定。不管是cpu dai还是codec dai，通常会同时传输播放和录音的音频流的能力，所以我们可以看到，snd_soc_dai中有两个widget指针，分别代表播放流和录音流。这两个dai widget是何时创建的呢？下面我们逐一进行分析。

codec dai widget    

首先，codec驱动在注册codec时，会传入该codec所支持的dai个数和记录dai信息的snd_soc_dai_driver结构指针：

[cpp]  view plain  copy
  1. static struct snd_soc_dai_driver wm8993_dai = {  
  2.         .name = "wm8993-hifi",  
  3.         .playback = {  
  4.                 .stream_name = "Playback",  
  5.                 .channels_min = 1,  
  6.                 .channels_max = 2,  
  7.                 .rates = WM8993_RATES,  
  8.                 .formats = WM8993_FORMATS,  
  9.                 .sig_bits = 24,  
  10.         },  
  11.         .capture = {  
  12.                  .stream_name = "Capture",  
  13.                  .channels_min = 1,  
  14.                  .channels_max = 2,  
  15.                  .rates = WM8993_RATES,  
  16.                  .formats = WM8993_FORMATS,  
  17.                  .sig_bits = 24,  
  18.          },  
  19.         .ops = &wm8993_ops,  
  20.         .symmetric_rates = 1,  
  21. };  
  22.   
  23. static int wm8993_i2c_probe(struct i2c_client *i2c,  
  24.                             const struct i2c_device_id *id)  
  25. {  
  26.         ......  
  27.         ret = snd_soc_register_codec(&i2c->dev,  
  28.                         &soc_codec_dev_wm8993, &wm8993_dai, 1);  
  29.         ......  
  30. }  
这回使得ASoc把codec的dai注册到系统中，并把这些dai都挂在全局链表变量dai_list中，然后，在codec被machine驱动匹配后，soc_probe_codec函数会被调用，他会通过全局链表变量dai_list查找所有属于该codec的dai，调用snd_soc_dapm_new_dai_widgets函数来生成该dai的播放流widget和录音流widget：

[cpp]  view plain  copy
  1. static int soc_probe_codec(struct snd_soc_card *card,  
  2.                            struct snd_soc_codec *codec)  
  3. {  
  4.         ......  
  5.         /* Create DAPM widgets for each DAI stream */  
  6.         list_for_each_entry(dai, &dai_list, list) {  
  7.                 if (dai->dev != codec->dev)  
  8.                         continue;  
  9.   
  10.                 snd_soc_dapm_new_dai_widgets(&codec->dapm, dai);  
  11.         }  
  12.         ......  
  13. }  
我们看看snd_soc_dapm_new_dai_widgets的代码：

[cpp]  view plain  copy
  1. int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm,  
  2.                                  struct snd_soc_dai *dai)  
  3. {                 
  4.         struct snd_soc_dapm_widget template;  
  5.         struct snd_soc_dapm_widget *w;  
  6.           
  7.         WARN_ON(dapm->dev != dai->dev);  
  8.           
  9.         memset(&template, 0, sizeof(template));  
  10.         template.reg = SND_SOC_NOPM;  
  11.         // 创建播放 dai widget                  
  12.         if (dai->driver->playback.stream_name) {  
  13.                 template.id = snd_soc_dapm_dai_in;  
  14.                 template.name = dai->driver->playback.stream_name;  
  15.                 template.sname = dai->driver->playback.stream_name;  
  16.                           
  17.                 w = snd_soc_dapm_new_control(dapm, &template);  
  18.           
  19.                 w->priv = dai;  
  20.                 dai->playback_widget = w;  
  21.         }  
  22.         // 创建录音 dai widget  
  23.         if (dai->driver->capture.stream_name) {  
  24.                 template.id = snd_soc_dapm_dai_out;  
  25.                 template.name = dai->driver->capture.stream_name;  
  26.                 template.sname = dai->driver->capture.stream_name;  
  27.   
  28.                 w = snd_soc_dapm_new_control(dapm, &template);  
  29.    
  30.                 w->priv = dai;  
  31.                 dai->capture_widget = w;  
  32.         }  
  33.   
  34.         return 0;  
  35. }  
分别为Playback和Capture创建了一个widget，widget的priv字段指向了该dai，这样通过widget就可以找到相应的dai，并且widget的名字就是 snd_soc_dai_driver结构的stream_name。

cpu dai widget    
这里顺便说一个小意外，昨天晚上手贱，执行了一下git pull，版本升级到了3.12 rc7，结果发现ASoc的代码有所变化，于是稍稍纠结了一下，用新的代码继续还是恢复之前的3.10 rc5?经过查看了一些变化后，发现还是新的版本改进得更合理，现在决定，后面的内容都是基于3.12 rc7了。如果大家发现后面贴的代码和之前贴的有差异的地方，自己比较一下这两个版本的代码吧！
回到cpu dai，以前的内核版本由驱动通过snd_soc_register_dais注册，新的版本中，这个函数变为了soc-core的内部函数，驱动改为使用snd_soc_register_component注册，snd_soc_register_component函数再通过调用snd_soc_register_dai/snd_soc_register_dais来完成实际的注册工作。和codec dai widget一样，cpu dai widget也发生在machine驱动匹配上相应的platform驱动之后，soc_probe_platform会被调用，在soc_probe_platform函数中，通过比较dai->dev和platform->dev，挑选出属于该platform的dai，然后通过snd_soc_dapm_new_dai_widgets为cpu dai创建相应的widget：
[cpp]  view plain  copy
  1. static int soc_probe_platform(struct snd_soc_card *card,  
  2.                            struct snd_soc_platform *platform)  
  3. {  
  4.         int ret = 0;  
  5.         const struct snd_soc_platform_driver *driver = platform->driver;  
  6.         struct snd_soc_dai *dai;  
  7.   
  8.         ......  
  9.   
  10.         if (driver->dapm_widgets)  
  11.                 snd_soc_dapm_new_controls(&platform->dapm,  
  12.                         driver->dapm_widgets, driver->num_dapm_widgets);  
  13.   
  14.         /* Create DAPM widgets for each DAI stream */  
  15.         list_for_each_entry(dai, &dai_list, list) {  
  16.                 if (dai->dev != platform->dev)  
  17.                         continue;  
  18.   
  19.                 snd_soc_dapm_new_dai_widgets(&platform->dapm, dai);  
  20.         }  
  21.   
  22.         platform->dapm.idle_bias_off = 1;  
  23.   
  24.         ......  
  25.   
  26.         if (driver->controls)  
  27.                 snd_soc_add_platform_controls(platform, driver->controls,  
  28.                                      driver->num_controls);  
  29.         if (driver->dapm_routes)  
  30.                 snd_soc_dapm_add_routes(&platform->dapm, driver->dapm_routes,  
  31.                                         driver->num_dapm_routes);  
  32.         ......  
  33.   
  34.         return 0;  
  35. }  
从上面的代码我们也可以看出，在上面的”创建和注册widget“一节提到的第一种方法，即通过给snd_soc_platform_driver结构的dapm_widgets和num_dapm_widgets字段赋值，ASoc会自动为我们创建所需的widget，真正执行创建工作就在上面所列的soc_probe_platform函数中完成的，普通的kcontrol和音频路径也是一样的原理。反推回来，codec的widget也是一样的，在soc_probe_codec中会做同样的事情，只是我上面贴出来soc_probe_codec的代码里没有贴出来，有兴趣的读者自己查看一下它的代码即可。
花了这么多篇幅来讲解dai widget，好像现在看来它还没有什么用处。嗯，不要着急，实际上dai widget是一条完整dapm音频路径的重要元素，没有她，我们无法完成dapm的动态电源管理工作，因为它是音频流和其他widget的纽带，细节我们要留到下一篇文章中来阐述了。

端点widget

一条完整的dapm音频路径，必然有起点和终点，我们把位于这些起点和终点的widget称之为端点widget。以下这些类型的widget可以成为端点widget：

codec的输入输出引脚：

  • snd_soc_dapm_output
  • snd_soc_dapm_input
外接的音频设备：
  • snd_soc_dapm_hp
  • snd_soc_dapm_spk
  • snd_soc_dapm_line
音频流（stream domain）：
  • snd_soc_dapm_adc
  • snd_soc_dapm_dac
  • snd_soc_dapm_aif_out
  • snd_soc_dapm_aif_in
  • snd_soc_dapm_dai_out
  • snd_soc_dapm_dai_in
电源、时钟和其它：
  • snd_soc_dapm_supply
  • snd_soc_dapm_regulator_supply
  • snd_soc_dapm_clock_supply
  • snd_soc_dapm_kcontrol

当声卡上的其中一个widget的状态发生改变时，从这个widget开始，dapm框架会向前和向后遍历路径上的所有widget，判断每个widget的状态是否需要跟着变更，到达这些端点widget就会认为它是一条完整音频路径的开始和结束，从而结束一次扫描动作。至于代码的分析，先让我歇一会......，我会在后面的文章中讨论。

ALSA声卡驱动中的DAPM详解之五：建立widget之间的连接关系

前面我们主要着重于codec、platform、machine驱动程序中如何使用和建立dapm所需要的widget，route，这些是音频驱动开发人员必须要了解的内容，经过前几章的介绍，我们应该知道如何在alsa音频驱动的3大部分（codec、platform、machine）中，按照所使用的音频硬件结构，定义出相应的widget，kcontrol，以及必要的音频路径，而在本章中，我们将会深入dapm的核心部分，看看各个widget之间是如何建立连接关系，形成一条完整的音频路径。

/*****************************************************************************************************/
声明：本博内容均由http://blog.csdn.net/droidphone原创，转载请注明出处，谢谢！
/*****************************************************************************************************/

前面我们已经简单地介绍过，驱动程序需要使用以下api函数创建widget：

  • snd_soc_dapm_new_controls
实际上，这个函数只是创建widget的第一步，它为每个widget分配内存，初始化必要的字段，然后把这些widget挂在代表声卡的snd_soc_card的widgets链表字段中。要使widget之间具备连接能力，我们还需要第二个函数：
  • snd_soc_dapm_new_widgets
这个函数会根据widget的信息，创建widget所需要的dapm kcontrol，这些dapm kcontol的状态变化，代表着音频路径的变化，从而影响着各个widget的电源状态。看到函数的名称可能会迷惑一下， 实际上， snd_soc_dapm_new_controls的作用更多地是创建widget，而 snd_soc_dapm_new_widget的作用则更多地是创建widget所包含的kcontrol，所以 在我看来，这两个函数名称应该换过来叫更好！下面我们分别介绍一下这两个函数是如何工作的。

创建widget：snd_soc_dapm_new_controls

snd_soc_dapm_new_controls函数完成widget的创建工作，并把这些创建好的widget注册在声卡的widgets链表中，我们看看他的定义：
[cpp]  view plain  copy
  1. int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm,  
  2.         const struct snd_soc_dapm_widget *widget,  
  3.         int num)  
  4. {         
  5.         ......   
  6.         for (i = 0; i < num; i++) {  
  7.                 w = snd_soc_dapm_new_control(dapm, widget);  
  8.                 if (!w) {  
  9.                         dev_err(dapm->dev,  
  10.                                 "ASoC: Failed to create DAPM control %s\n",  
  11.                                 widget->name);  
  12.                         ret = -ENOMEM;  
  13.                         break;  
  14.                 }                 
  15.                 widget++;  
  16.         }  
  17.         ......  
  18.         return ret;  
  19. }  
该函数只是简单的一个循环，为传入的widget模板数组依次调用snd_soc_dapm_new_control函数，实际的工作由snd_soc_dapm_new_control完成，继续进入该函数，看看它做了那些工作。
我们之前已经说过，驱动中定义的snd_soc_dapm_widget数组，只是作为一个模板，所以，snd_soc_dapm_new_control所做的第一件事，就是为该widget重新分配内存，并把模板的内容拷贝过来：

[cpp]  view plain  copy
  1. static struct snd_soc_dapm_widget *  
  2. snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,  
  3.                          const struct snd_soc_dapm_widget *widget)  
  4. {  
  5.         struct snd_soc_dapm_widget *w;  
  6.         int ret;  
  7.   
  8.         if ((w = dapm_cnew_widget(widget)) == NULL)  
  9.                 return NULL;  

由dapm_cnew_widget完成内存申请和拷贝模板的动作。接下来，根据widget的类型做不同的处理：
[cpp]  view plain  copy
  1.         switch (w->id) {  
  2.         case snd_soc_dapm_regulator_supply:  
  3.                 w->regulator = devm_regulator_get(dapm->dev, w->name);  
  4.                 ......  
  5.   
  6.                 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) {  
  7.                         ret = regulator_allow_bypass(w->regulator, true);  
  8.                         ......  
  9.                 }  
  10.                 break;  
  11.         case snd_soc_dapm_clock_supply:  
  12. #ifdef CONFIG_CLKDEV_LOOKUP  
  13.                 w->clk = devm_clk_get(dapm->dev, w->name);  
  14.                 ......  
  15. #else  
  16.                 return NULL;  
  17. #endif  
  18.                 break;  
  19.         default:  
  20.                 break;  
  21.         }  
对于snd_soc_dapm_regulator_supply类型的widget，根据widget的名称获取对应的regulator结构，对于snd_soc_dapm_clock_supply类型的widget，根据widget的名称，获取对应的clock结构。接下来，根据需要，在widget的名称前加入必要的前缀：
[cpp]  view plain  copy
  1. if (dapm->codec && dapm->codec->name_prefix)  
  2.         w->name = kasprintf(GFP_KERNEL, "%s %s",  
  3.                 dapm->codec->name_prefix, widget->name);  
  4. else  
  5.         w->name = kasprintf(GFP_KERNEL, "%s", widget->name);  
然后，为不同类型的widget设置合适的power_check电源状态回调函数，widget类型和对应的power_check回调函数设置如下表所示：
widget的power_check回调函数
widget类型 power_check回调函数
mixer类：
snd_soc_dapm_switch
snd_soc_dapm_mixer
snd_soc_dapm_mixer_named_ctl		 dapm_generic_check_power
mux类：
snd_soc_dapm_mux
snd_soc_dapm_mux
snd_soc_dapm_mux		 dapm_generic_check_power
snd_soc_dapm_dai_out dapm_adc_check_power
snd_soc_dapm_dai_in dapm_dac_check_power
端点类：
snd_soc_dapm_adc
snd_soc_dapm_aif_out
snd_soc_dapm_dac
snd_soc_dapm_aif_in
snd_soc_dapm_pga
snd_soc_dapm_out_drv
snd_soc_dapm_input
snd_soc_dapm_output
snd_soc_dapm_micbias
snd_soc_dapm_spk
snd_soc_dapm_hp
snd_soc_dapm_mic
snd_soc_dapm_line
snd_soc_dapm_dai_link		 dapm_generic_check_power
电源/时钟/影子widget：
snd_soc_dapm_supply
snd_soc_dapm_regulator_supply
snd_soc_dapm_clock_supply
snd_soc_dapm_kcontrol		 dapm_supply_check_power
其它类型 dapm_always_on_check_power
当音频路径发生变化时，power_check回调会被调用，用于检查该widget的电源状态是否需要更新。power_check设置完成后，需要设置widget所属的codec、platform和dapm context，几个用于音频路径的链表也需要初始化，然后，把该widget加入到声卡的widgets链表中：
[cpp]  view plain  copy
  1. w->dapm = dapm;  
  2. w->codec = dapm->codec;  
  3. w->platform = dapm->platform;  
  4. INIT_LIST_HEAD(&w->sources);  
  5. INIT_LIST_HEAD(&w->sinks);  
  6. INIT_LIST_HEAD(&w->list);  
  7. INIT_LIST_HEAD(&w->dirty);  
  8. list_add(&w->list, &dapm->card->widgets);  
几个链表的作用如下：
  • sources    用于链接所有连接到该widget输入端的snd_soc_path结构
  • sinks    用于链接所有连接到该widget输出端的snd_soc_path结构
  • list    用于链接到声卡的widgets链表
  • dirty    用于链接到声卡的dapm_dirty链表
最后，把widget设置为connect状态：
[cpp]  view plain  copy
  1. /* machine layer set ups unconnected pins and insertions */  
  2. w->connected = 1;  
  3. return w;  
connected字段代表着引脚的连接状态， 目前， 只有以下这些widget使用connected字段：
  • snd_soc_dapm_output
  • snd_soc_dapm_input
  • snd_soc_dapm_hp
  • snd_soc_dapm_spk
  • snd_soc_dapm_line
  • snd_soc_dapm_vmid
  • snd_soc_dapm_mic
  • snd_soc_dapm_siggen
驱动程序可以使用以下这些api来设置引脚的连接状态：
  • snd_soc_dapm_enable_pin
  • snd_soc_dapm_force_enable_pin
  • snd_soc_dapm_disable_pin
  • snd_soc_dapm_nc_pin
到此，widget已经被正确地创建并初始化，而且被挂在声卡的widgets链表中，以后我们就可以通过声卡的widgets链表来遍历所有的widget，再次强调一下snd_soc_dapm_new_controls函数所完成的主要功能：
  • 为widget分配内存，并拷贝参数中传入的在驱动中定义好的模板
  • 设置power_check回调函数
  • 把widget挂在声卡的widgets链表中

为widget建立dapm kcontrol

定义一个widget，我们需要指定两个很重要的内容：一个是用于控制widget的电源状态的reg/shift等寄存器信息，另一个是用于控制音频路径切换的dapm kcontrol信息，这些dapm kcontrol有它们自己的reg/shift寄存器信息用于切换widget的路径连接方式。前一节的内容中，我们只是创建了widget的实例，并把它们注册到声卡的widgts链表中，但是到目前为止，包含在widget中的dapm kcontrol并没有建立起来，dapm框架在声卡的初始化阶段，等所有的widget（包括machine、platform、codec）都创建好之后，通过snd_soc_dapm_new_widgets函数，创建widget内包含的dapm kcontrol，并初始化widget的初始电源状态和音频路径的初始连接状态。我们看看声卡的初始化函数，都有那些初始化与dapm有关：
[cpp]  view plain  copy
  1. static int snd_soc_instantiate_card(struct snd_soc_card *card)  
  2. {  
  3.         ......  
  4.         /* card bind complete so register a sound card */  
  5.         ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,  
  6.                         card->owner, 0, &card->snd_card);  
  7.         ......  
  8.    
  9.         card->dapm.bias_level = SND_SOC_BIAS_OFF;  
  10.         card->dapm.dev = card->dev;  
  11.         card->dapm.card = card;  
  12.         list_add(&card->dapm.list, &card->dapm_list);  
  13.   
  14. #ifdef CONFIG_DEBUG_FS  
  15.         snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);  
  16. #endif  
  17.         ......  
  18.         if (card->dapm_widgets)    /* 创建machine级别的widget  */  
  19.                 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,  
  20.                                           card->num_dapm_widgets);  
  21.         ......  
  22.         snd_soc_dapm_link_dai_widgets(card);  /*  连接dai widget  */  
  23.   
  24.         if (card->controls)    /*  建立machine级别的普通kcontrol控件  */  
  25.                 snd_soc_add_card_controls(card, card->controls, card->num_controls);  
  26.   
  27.         if (card->dapm_routes)    /*  注册machine级别的路径连接信息  */  
  28.                 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,  
  29.                                         card->num_dapm_routes);  
  30.         ......  
  31.   
  32.         if (card->fully_routed)    /*  如果该标志被置位，自动把codec中没有路径连接信息的引脚设置为无用widget  */  
  33.                 list_for_each_entry(codec, &card->codec_dev_list, card_list)  
  34.                         snd_soc_dapm_auto_nc_codec_pins(codec);  
  35.   
  36.         snd_soc_dapm_new_widgets(card);    /*初始化widget包含的dapm kcontrol、电源状态和连接状态*/  
  37.   
  38.         ret = snd_card_register(card->snd_card);  
  39.         ......  
  40.         card->instantiated = 1;  
  41.         snd_soc_dapm_sync(&card->dapm);  
  42.         ......  
  43.         return 0;  
  44. }   
正如我添加的注释中所示，在完成machine级别的widget和route处理之后，调用的snd_soc_dapm_new_widgets函数，来为所有已经注册的widget初始化他们所包含的dapm kcontrol，并初始化widget的电源状态和路径连接状态。下面我们看看snd_soc_dapm_new_widgets函数的工作过程。

snd_soc_dapm_new_widgets函数    

该函数通过声卡的widgets链表，遍历所有已经注册了的widget，其中的new字段用于判断该widget是否已经执行过snd_soc_dapm_new_widgets函数，如果num_kcontrols字段有数值，表明该widget包含有若干个dapm kcontrol，那么就需要为这些kcontrol分配一个指针数组，并把数组的首地址赋值给widget的kcontrols字段，该数组存放着指向这些kcontrol的指针，当然现在这些都是空指针，因为实际的kcontrol现在还没有被创建：
[cpp]  view plain  copy
  1. int snd_soc_dapm_new_widgets(struct snd_soc_card *card)  
  2. {  
  3.         ......  
  4.         list_for_each_entry(w, &card->widgets, list)  
  5.         {                 
  6.                 if (w->new)       
  7.                         continue;  
  8.                                   
  9.                 if (w->num_kcontrols) {  
  10.                         w->kcontrols = kzalloc(w->num_kcontrols *  
  11.                                                 sizeof(struct snd_kcontrol *),  
  12.                                                 GFP_KERNEL);  
  13.                         ......  
  14.                 }  
接着，对几种能影响音频路径的widget，创建并初始化它们所包含的dapm kcontrol：
[cpp]  view plain  copy
  1. switch(w->id) {  
  2. case snd_soc_dapm_switch:  
  3. case snd_soc_dapm_mixer:  
  4. case snd_soc_dapm_mixer_named_ctl:  
  5.         dapm_new_mixer(w);  
  6.         break;  
  7. case snd_soc_dapm_mux:  
  8. case snd_soc_dapm_virt_mux:  
  9. case snd_soc_dapm_value_mux:  
  10.         dapm_new_mux(w);  
  11.         break;  
  12. case snd_soc_dapm_pga:  
  13. case snd_soc_dapm_out_drv:  
  14.         dapm_new_pga(w);  
  15.         break;  
  16. default:  
  17.         break;  
  18. }  
需要用到的创建函数分别是：
  • dapm_new_mixer()    对于mixer类型，用该函数创建dapm kcontrol；
  • dapm_new_mux()   对于mux类型，用该函数创建dapm kcontrol；
  • dapm_new_pga()   对于pga类型，用该函数创建dapm kcontrol；
然后，根据widget寄存器的当前值，初始化widget的电源状态，并设置到power字段中：
[cpp]  view plain  copy
  1. /* Read the initial power state from the device */  
  2. if (w->reg >= 0) {  
  3.         val = soc_widget_read(w, w->reg) >> w->shift;  
  4.         val &= w->mask;  
  5.         if (val == w->on_val)  
  6.                 w->power = 1;  
  7. }  
接着，设置new字段，表明该widget已经初始化完成，我们还要吧该widget加入到声卡的dapm_dirty链表中，表明该widget的状态发生了变化，稍后在合适的时刻，dapm框架会扫描dapm_dirty链表，统一处理所有已经变化的widget。为什么要统一处理？因为dapm要控制各种widget的上下电顺序，同时也是为了减少寄存器的读写次数（多个widget可能使用同一个寄存器）：
[cpp]  view plain  copy
  1. w->new = 1;  
  2.   
  3. dapm_mark_dirty(w, "new widget");  
  4. dapm_debugfs_add_widget(w);  

最后，通过dapm_power_widgets函数，统一处理所有位于dapm_dirty链表上的widget的状态改变：
[cpp]  view plain  copy
  1. dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP);  
  2. ......  
  3. return 0;  

dapm mixer kcontrol

上一节中，我们提到，对于mixer类型的dapm kcontrol，我们会使用dapm_new_mixer来完成具体的创建工作，先看代码后分析：
[cpp]  view plain  copy
  1. static int dapm_new_mixer(struct snd_soc_dapm_widget *w)  
  2. {  
  3.         int i, ret;  
  4.         struct snd_soc_dapm_path *path;  
  5.   
  6.         /* add kcontrol */  
  7. "font-family:Arial,Helvetica,sans-serif">（1）        for (i = 0; i < w->num_kcontrols; i++) {                                  
  8.                 /* match name */  
  9. （2）                list_for_each_entry(path, &w->sources, list_sink) {               
  10.                         /* mixer/mux paths name must match control name */  
  11. （3）                        if (path->name != (char *)w->kcontrol_news[i].name)       
  12.                                 continue;  
  13.   
  14. （4）                        if (w->kcontrols[i]) {                                   
  15.                                 dapm_kcontrol_add_path(w->kcontrols[i], path);  
  16.                                 continue;  
  17.                         }  
  18.   
  19. （5）                        ret = dapm_create_or_share_mixmux_kcontrol(w, i);        
  20.                         if (ret < 0)  
  21.                                 return ret;  
  22.   
  23. （6）                        dapm_kcontrol_add_path(w->kcontrols[i], path);           
  24.                 }  
  25.         }  
  26.   
  27.         return 0;  
  28. }  
（1）  因为一个mixer是由多个kcontrol组成的，每个kcontrol控制着mixer的一个输入端的开启和关闭，所以，该函数会根据kcontrol的数量做循环，逐个建立对应的kcontrol。
（2）（3）  之前多次提到，widget之间使用snd_soc_path进行连接，widget的sources链表保存着所有和输入端连接的snd_soc_path结构，所以我们可以用kcontrol模板中指定的名字来匹配对应的snd_soc_path结构。
（4）  因为一个输入脚可能会连接多个输入源，所以可能在上一个输入源的path关联时已经创建了这个kcontrol，所以这里判断kcontrols指针数组中对应索引中的指针值，如果已经赋值，说明kcontrol已经在之前创建好了，所以我们只要简单地 把连接该输入端的path加入到kcontrol的path_list链表中，并且 增加一个虚拟的影子widget，该影子widget连接和输入端对应的源widget，因为使用了kcontrol本身的reg/shift等寄存器信息，所以实际上控制的是该kcontrol的开和关，这个影子widget只有在kcontrol的autodisable字段被设置的情况下才会被创建，该特性使得source的关闭时，与之连接的mixer的输入端也可以自动关闭，这个特性通过dapm_kcontrol_add_path来实现这一点：
[cpp]  view plain  copy
  1. static void dapm_kcontrol_add_path(const struct snd_kcontrol *kcontrol,  
  2.         struct snd_soc_dapm_path *path)  
  3. {  
  4.         struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol);  
  5.         /*  把kcontrol连接的path加入到paths链表中  */  
  6.         /*  paths链表所在的dapm_kcontrol_data结构会保存在kcontrol的private_data字段中  */  
  7.         list_add_tail(&path->list_kcontrol, &data->paths);  
  8.   
  9.         if (data->widget) {  
  10.                 snd_soc_dapm_add_path(data->widget->dapm, data->widget,  
  11.                     path->source, NULL, NULL);  
  12.         }  
  13. }  

（5）  如果kcontrol之前没有被创建，则通过dapm_create_or_share_mixmux_kcontrol创建这个输入端的kcontrol，同理，kcontrol对应的影子widget也会通过dapm_kcontrol_add_path判断是否需要创建。

dapm mux kcontrol

因为一个widget最多只会包含一个mux类型的damp kcontrol，所以他的创建方法稍有不同，dapm框架使用dapm_new_mux函数来创建mux类型的dapm kcontrol：
[cpp]  view plain  copy
  1. static int dapm_new_mux(struct snd_soc_dapm_widget *w)  
  2. {         
  3.         struct snd_soc_dapm_context *dapm = w->dapm;  
  4.         struct snd_soc_dapm_path *path;  
  5.         int ret;  
  6.           
  7. (1)     if (w->num_kcontrols != 1) {  
  8.                 dev_err(dapm->dev,  
  9.                         "ASoC: mux %s has incorrect number of controls\n",  
  10.                         w->name);  
  11.                 return -EINVAL;  
  12.         }  
  13.   
  14.         if (list_empty(&w->sources)) {  
  15.                 dev_err(dapm->dev, "ASoC: mux %s has no paths\n", w->name);  
  16.                 return -EINVAL;  
  17.         }  
  18.   
  19. (2)     ret = dapm_create_or_share_mixmux_kcontrol(w, 0);  
  20.         if (ret < 0)  
  21.                 return ret;  
  22. (3)       list_for_each_entry(path, &w->sources, list_sink)  
  23.                 dapm_kcontrol_add_path(w->kcontrols[0], path);  
  24.         return 0;  
  25. }  


（1）  对于mux类型的widget，因为只会有一个kcontrol，所以在这里做一下判断。
（2）  同样地，和mixer类型一样，也使用dapm_create_or_share_mixmux_kcontrol来创建这个kcontrol。
（3）  对每个输入端所连接的path都加入dapm_kcontrol_data结构的paths链表中，并且创建一个影子widget，用于支持autodisable特性。

dapm pga kcontrol

目前对于pga类型的widget，kcontrol的创建函数是个空函数，所以我们不用太关注它：
[cpp]  view plain  copy
  1. static int dapm_new_pga(struct snd_soc_dapm_widget *w)  
  2. {  
  3.         if (w->num_kcontrols)  
  4.                 dev_err(w->dapm->dev,  
  5.                         "ASoC: PGA controls not supported: '%s'\n", w->name);  
  6.   
  7.         return 0;  
  8. }  

dapm_create_or_share_mixmux_kcontrol函数

上面所说的mixer类型和mux类型的widget，在创建他们所包含的dapm kcontrol时，最后其实都是使用了dapm_create_or_share_mixmux_kcontrol函数来完成创建工作的，所以在这里我们有必要分析一下这个函数的工作原理。这个函数中有很大一部分代码实在处理kcontrol的名字是否要加入codec的前缀，我们会忽略这部分的代码，感兴趣的读者可以自己查看内核的代码，路径在：sound/soc/soc-dapm.c中，简化后的代码如下：
[cpp]  view plain  copy
  1. static int dapm_create_or_share_mixmux_kcontrol(struct snd_soc_dapm_widget *w,  
  2.         int kci)  
  3. {  
  4.           ......  
  5. (1)       shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],  
  6.                                          &kcontrol);  
  7.      
  8. (2)       if (!kcontrol) {  
  9. (3)            kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name,prefix）;  
  10.                ......  
  11.                kcontrol->private_free = dapm_kcontrol_free;  
  12. (4)            ret = dapm_kcontrol_data_alloc(w, kcontrol);  
  13.                 ......  
  14. (5)            ret = snd_ctl_add(card, kcontrol);  
  15.                 ......  
  16.         }  
  17. (6)     ret = dapm_kcontrol_add_widget(kcontrol, w);  
  18.         ......  
  19. (7)     w->kcontrols[kci] = kcontrol;  
  20.         return 0;  
  21. }  

（1）  为了节省内存，通过kcontrol名字的匹配查找，如果这个kcontrol已经在其他widget中已经创建好了，那我们不再创建，dapm_is_shared_kcontrol的参数kcontrol会返回已经创建好的kcontrol的指针。
（2）  如果kcontrol指针被赋值，说明在（1）中查找到了其他widget中同名的kcontrol，我们不用再次创建，只要共享该kcontrol即可。
（3）  标准的kcontrol创建函数，请参看： Linux ALSA声卡驱动之四：Control设备的创建中的“创建control“一节的内容。
（4）  如果widget支持autodisable特性，创建与该kcontrol所对应的影子widget，该影子widget的类型是：snd_soc_dapm_kcontrol。
（5）  标准的kcontrol创建函数，请参看： Linux ALSA声卡驱动之四：Control设备的创建中的“创建control“一节的内容。
（6）  把所有共享该kcontrol的影子widget（snd_soc_dapm_kcontrol），加入到kcontrol的private_data字段所指向的dapm_kcontrol_data结构中。
（7）  把创建好的kcontrol指针赋值到widget的kcontrols数组中。
需要注意的是，如果kcontol支持autodisable特性，一旦kcontrol由于source的关闭而被自动关闭，则用户空间只能操作该kcontrol的cache值，只有该kcontrol再次打开时，该cache值才会被真正地更新到寄存器中。
现在。我们总结一下，创建一个widget所包含的kcontrol所做的工作：
  • 循环每一个输入端，为每个输入端依次执行下面的一系列操作
  • 为每个输入端创建一个kcontrol，能共享的则直接使用创建好的kcontrol
  • kcontrol的private_data字段保存着这些共享widget的信息
  • 如果支持autodisable特性，每个输入端还要额外地创建一个虚拟的snd_soc_dapm_kcontrol类型的影子widget，该影子widget也记录在private_data字段中
  • 创建好的kcontrol会依次存放在widget的kcontrols数组中，供路径的控制和匹配之用。

为widget建立连接关系

如果widget之间没有连接关系，dapm就无法实现动态的电源管理工作，正是widget之间有了连结关系，这些连接关系形成了一条所谓的完成的音频路径，dapm可以顺着这条路径，统一控制路径上所有widget的电源状态，前面我们已经知道，widget之间是使用snd_soc_path结构进行连接的，驱动要做的是定义一个snd_soc_route结构数组，该数组的每个条目描述了目的widget的和源widget的名称，以及控制这个连接的kcontrol的名称，最终，驱动程序使用api函数snd_soc_dapm_add_routes来注册这些连接信息，接下来我们就是要分析该函数的具体实现方式：
[cpp]  view plain  copy
  1. int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm,  
  2.                             const struct snd_soc_dapm_route *route, int num)  
  3. {  
  4.         int i, r, ret = 0;  
  5.   
  6.         mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT);  
  7.         for (i = 0; i < num; i++) {  
  8.                 r = snd_soc_dapm_add_route(dapm, route);  
  9.                 ......  
  10.                 route++;  
  11.         }  
  12.         mutex_unlock(&dapm->card->dapm_mutex);  
  13.   
  14.         return ret;  
  15. }  
该函数只是一个循环，依次对参数传入的数组调用snd_soc_dapm_add_route，主要的工作由snd_soc_dapm_add_route完成。我们进入snd_soc_dapm_add_route函数看看：
[cpp]  view plain  copy
  1. static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm,  
  2.                                   const struct snd_soc_dapm_route *route)  
  3. {  
  4.         struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w;  
  5.         struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL;  
  6.         const char *sink;  
  7.         const char *source;  
  8.         ......  
  9.         list_for_each_entry(w, &dapm->card->widgets, list) {  
  10.                 if (!wsink && !(strcmp(w->name, sink))) {  
  11.                         wtsink = w;  
  12.                         if (w->dapm == dapm)  
  13.                                 wsink = w;  
  14.                         continue;  
  15.                 }  
  16.                 if (!wsource && !(strcmp(w->name, source))) {  
  17.                         wtsource = w;  
  18.                         if (w->dapm == dapm)  
  19.                                 wsource = w;  
  20.                 }  
  21.         }  
上面的代码我再次省略了关于名称前缀的处理部分。我们可以看到，用widget的名字来比较，遍历声卡的widgets链表，找出源widget和目的widget的指针，这段代码虽然正确，但我总感觉少了一个判断退出循环的条件，如果链表的开头就找到了两个widget，还是要遍历整个链表才结束循环，好浪费时间。
下面，如果在本dapm context中没有找到，则使用别的dapm context中找到的widget：
[cpp]  view plain  copy
  1. if (!wsink)  
  2.         wsink = wtsink;  
  3. if (!wsource)  
  4.         wsource = wtsource;  
最后，使用来增加一条连接信息：
[cpp]  view plain  copy
  1.         ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control,  
  2.                 route->connected);  
  3.         ......  
  4.   
  5.         return 0;  
  6. }  
snd_soc_dapm_add_path函数是整个调用链条中的关键，我们来分析一下：
[cpp]  view plain  copy
  1. static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm,  
  2.         struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink,  
  3.         const char *control,  
  4.         int (*connected)(struct snd_soc_dapm_widget *source,  
  5.                          struct snd_soc_dapm_widget *sink))  
  6. {  
  7.         struct snd_soc_dapm_path *path;  
  8.         int ret;  
  9.   
  10.         path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);  
  11.         if (!path)  
  12.                 return -ENOMEM;  
  13.   
  14.         path->source = wsource;  
  15.         path->sink = wsink;  
  16.         path->connected = connected;  
  17.         INIT_LIST_HEAD(&path->list);  
  18.         INIT_LIST_HEAD(&path->list_kcontrol);  
  19.         INIT_LIST_HEAD(&path->list_source);  
  20.         INIT_LIST_HEAD(&path->list_sink);  
函数的一开始，首先为这个连接分配了一个snd_soc_path结构，path的source和sink字段分别指向源widget和目的widget，connected字段保存connected回调函数，初始化几个snd_soc_path结构中的几个链表。
[cpp]  view plain  copy
  1. /* check for external widgets */  
  2.         if (wsink->id == snd_soc_dapm_input) {  
  3.                 if (wsource->id == snd_soc_dapm_micbias ||  
  4.                         wsource->id == snd_soc_dapm_mic ||  
  5.                         wsource->id == snd_soc_dapm_line ||  
  6.                         wsource->id == snd_soc_dapm_output)  
  7.                         wsink->ext = 1;  
  8.         }  
  9.         if (wsource->id == snd_soc_dapm_output) {  
  10.                 if (wsink->id == snd_soc_dapm_spk ||  
  11.                         wsink->id == snd_soc_dapm_hp ||  
  12.                         wsink->id == snd_soc_dapm_line ||  
  13.                         wsink->id == snd_soc_dapm_input)  
  14.                         wsource->ext = 1;  
  15.         }  
这段代码用于判断是否有外部连接关系，如果有，置位widget的ext字段。判断方法从代码中可以方便地看出：
  • 目的widget是一个输入脚，如果源widget是mic、line、micbias或output，则认为目的widget具有外部连接关系。
  • 源widget是一个输出脚，如果目的widget是spk、hp、line或input，则认为源widget具有外部连接关系。
[cpp]  view plain  copy
  1. dapm_mark_dirty(wsource, "Route added");  
  2. dapm_mark_dirty(wsink, "Route added");  
  3.   
  4. /* connect static paths */  
  5. if (control == NULL) {  
  6.         list_add(&path->list, &dapm->card->paths);  
  7.         list_add(&path->list_sink, &wsink->sources);  
  8.         list_add(&path->list_source, &wsource->sinks);  
  9.         path->connect = 1;  
  10.         return 0;  
  11. }  
因为增加了连结关系，所以把源widget和目的widget加入到dapm_dirty链表中。如果没有kcontrol来控制该连接关系，则这是一个静态连接，直接用path把它们连接在一起。在接着往下看：
[cpp]  view plain  copy
  1. /* connect dynamic paths */  
  2. switch (wsink->id) {  
  3. case snd_soc_dapm_adc:  
  4. case snd_soc_dapm_dac:  
  5. case snd_soc_dapm_pga:  
  6. case snd_soc_dapm_out_drv:  
  7. case snd_soc_dapm_input:  
  8. case snd_soc_dapm_output:  
  9. case snd_soc_dapm_siggen:  
  10. case snd_soc_dapm_micbias:  
  11. case snd_soc_dapm_vmid:  
  12. case snd_soc_dapm_pre:  
  13. case snd_soc_dapm_post:  
  14. case snd_soc_dapm_supply:  
  15. case snd_soc_dapm_regulator_supply:  
  16. case snd_soc_dapm_clock_supply:  

你可能感兴趣的:(Linux,android)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 简介Shell、zsh、bash zhaosuningsn Shellzshbashshelllinuxbash
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
  • Linux MariaDB使用OpenSSL安装SSL证书 Meta39 MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • 【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linuxlinux运维服务器
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
  • linux 发展史 种树的猴子 内核java操作系统linux大数据
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
  • Linux sh命令 fengyehongWorld Linuxlinux
    目录一.基本语法二.选项2.1-c字符串中读取内容，并执行2.1.1基本用法2.1.2获取当前目录下失效的超链接2.2-x每个命令执行之前，将其打印出来2.3结合Here文档使用一.基本语法⏹Linux和Unix系统中用于执行shell脚本或运行命令的命令。sh[选项][脚本文件][参数...]⏹选项-c：从字符串中读取内容，并执行。-x：在每个命令执行之前，将其打印出来。-s：从标准流中读取内容
  • Linux vi常用命令 fengyehongWorld Linuxlinux
    参考资料viコマンド（vimコマンド）リファレンス目录一.保存系命令二.删除系命令三.移动系命令四.复制粘贴系命令一.保存系命令⏹保存并退出:wq⏹强制保存并退出:wq!⏹退出(文件未编辑):q⏹强制退出(忽略已编辑内容):q!⏹另存为:w新文件名二.删除系命令⏹删除当前行dd⏹清空整个文档gg：移动到文档顶部dG：删除到最后一行ggdG三.移动系命令⏹移动到文档顶部gg⏹移动到文档底部#方式1G
  • Linux查看服务器日志 TPBoreas 运维linux运维
    一、tail这个是我最常用的一种查看方式用法如下：tail-n10test.log查询日志尾部最后10行的日志;tail-n+10test.log查询10行之后的所有日志;tail-fn10test.log循环实时查看最后1000行记录(最常用的)一般还会配合着grep用，(实时抓包)例如:tail-fn1000test.log|grep'关键字'（动态抓包）tail-fn1000test.log
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
  • Linux CTF逆向入门 蚁景网络安全 linux运维CTF
    1.ELF格式我们先来看看ELF文件头，如果想详细了解，可以查看ELF的manpage文档。关于ELF更详细的说明：e_shoff：节头表的文件偏移量（字节）。如果文件没有节头表，则此成员值为零。sh_offset：表示了该section（节）离开文件头部位置的距离+-------------------+|ELFheader|---++--------->+-------------------
  • NPM私库搭建-verdaccio（Linux） Beam007 npmlinux前端
    1、安装nodelinux服务器安装nodea)、官网下载所需的node版本https://nodejs.org/dist/v14.21.0/b)、解压安装包若下载的是xxx.tar.xz文件，解压命令为tar-xvfxxx.tar.xzc)、修改环境变量修改：/etc/profile文件#SETPATHFORNODEJSexportNODE_HOME=NODEJS解压安装的路径exportPAT
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • linux脚本sed替换变量,sed 命令中替换值为shell变量 诺坎普之约 linux脚本sed替换变量
    文章目录sed命令中替换值为shell变量替换基本语法sed中替换使用shell变量总结参考文档sed命令中替换值为shell变量替换基本语法大家都是sed有很多用法，最多就应该是替换一些值了。让我们先回忆sed的替换语法。在sed进行替换的时候sed-i's/old/new/g'1.txtecho"hellooldfrank"|sed's/old/new/g'结果如下：hellonewfrank
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • linux 安装Sublime Text 3 hhyiyuanyu Python学习linuxsublimetext
    方法/步骤打开官网http://www.sublimetext.com/3，选择64位进行下载执行命令wgethttps://download.sublimetext.com/sublime_text_3_build_3126_x64.tar.bz2进行下载3、下载完成进行解压,执行tar-xvvfsublime_text_3_build_3126_x64.tar.bz解压4、解压完成以后，移动到
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • Js函数返回值 _wy_ jsreturn
    一、返回控制与函数结果，语法为：return 表达式;作用: 结束函数执行，返回调用函数，而且把表达式的值作为函数的结果 二、返回控制语法为：return;作用: 结束函数执行，返回调用函数，而且把undefined作为函数的结果 在大多数情况下,为事件处理函数返回false,可以防止默认的事件行为.例如,默认情况下点击一个<a>元素,页面会跳转到该元素href属性
  • MySQL 的 char 与 varchar bylijinnan mysql
    今天发现，create table 时，MySQL 4.1有时会把 char 自动转换成 varchar 测试举例： CREATE TABLE `varcharLessThan4` ( `lastName` varchar(3) ) ; mysql> desc varcharLessThan4; +----------+---------+------+-
  • Quartz——TriggerListener和JobListener eksliang TriggerListenerJobListenerquartz
    转载请出自出处：http://eksliang.iteye.com/blog/2208624 一.概述 listener是一个监听器对象，用于监听scheduler中发生的事件，然后执行相应的操作；你可能已经猜到了，TriggerListeners接受与trigger相关的事件，JobListeners接受与jobs相关的事件。   二.JobListener监听器  j
  • oracle层次查询 18289753290 oracle；层次查询；树查询
    .oracle层次查询(connect  by) oracle的emp表中包含了一列mgr指出谁是雇员的经理，由于经理也是雇员，所以经理的信息也存储在emp表中。这样emp表就是一个自引用表，表中的mgr列是一个自引用列，它指向emp表中的empno列，mgr表示一个员工的管理者， select   empno,mgr,ename,sal  from e
  • 通过反射把map中的属性赋值到实体类bean对象中 酷的飞上天空 javaee泛型类型转换
    使用过struts2后感觉最方便的就是这个框架能自动把表单的参数赋值到action里面的对象中 但现在主要使用Spring框架的MVC，虽然也有@ModelAttribute可以使用但是明显感觉不方便。 好吧，那就自己再造一个轮子吧。 原理都知道，就是利用反射进行字段的赋值，下面贴代码 主要类如下：   import java.lang.reflect.Field; imp
  • SAP HANA数据存储：传统硬盘的瓶颈问题 蓝儿唯美 HANA
    SAPHANA平台有各种各样的应用场景，这也意味着客户的实施方法有许多种选择，关键是如何挑选最适合他们需求的实施方案。 在 《Implementing SAP HANA》这本书中，介绍了SAP平台在现实场景中的运作原理，并给出了实施建议和成功案例供参考。本系列文章节选自《Implementing SAP HANA》，介绍了行存储和列存储的各自特点，以及SAP HANA的数据存储方式如何提升空间压
  • Java Socket 多线程实现文件传输 随便小屋 javasocket
            高级操作系统作业，让用Socket实现文件传输，有些代码也是在网上找的，写的不好，如果大家能用就用上。 客户端类：   package edu.logic.client; import java.io.BufferedInputStream; import java.io.Buffered
  • java初学者路径 aijuans java
    学习Java有没有什么捷径?要想学好Java，首先要知道Java的大致分类。自从Sun推出Java以来，就力图使之无所不包，所以Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE,这也就是Sun ONE(Open Net Environment)体系。J2SE就是Java2的标准版，主要用于桌面应用软件的编程；J2ME主要应用于嵌入是系统开发，如手机和PDA的编程；J2EE
  • APP推广 aoyouzi APP推广
    一，免费篇 1，APP推荐类网站自主推荐 最美应用、酷安网、DEMO8、木蚂蚁发现频道等,如果产品独特新颖，还能获取最美应用的评测推荐。PS：推荐简单。只要产品有趣好玩，用户会自主分享传播。例如足迹APP在最美应用推荐一次，几天用户暴增将服务器击垮。 2，各大应用商店首发合作 老实盯着排期，多给应用市场官方负责人献殷勤。 3，论坛贴吧推广 百度知道，百度贴吧，猫扑论坛，天涯社区，豆瓣（
  • JSP转发与重定向 百合不是茶 jspservletJava Webjsp转发
      在servlet和jsp中我们经常需要请求,这时就需要用到转发和重定向;   转发包括;forward和include     例子;forwrad转发;  将请求装法给reg.html页面   关键代码;    req.getRequestDispatcher("reg.html
  • web.xml之jsp-config bijian1013 javaweb.xmlservletjsp-config
    1.作用：主要用于设定JSP页面的相关配置。 2.常见定义： <jsp-config> <taglib> <taglib-uri>URI(定义TLD文件的URI,JSP页面的tablib命令可以经由此URI获取到TLD文件)</tablib-uri> <taglib-location> TLD文件所在的位置
  • JSF2.2 ViewScoped Using CDI sunjing CDIJSF 2.2ViewScoped
    JSF 2.0 introduced annotation @ViewScoped; A bean annotated with this scope maintained its state as long as the user stays on the same view(reloads or navigation - no intervening views). One problem w
  • 【分布式数据一致性二】Zookeeper数据读写一致性 bit1129 zookeeper
    很多文档说Zookeeper是强一致性保证，事实不然。关于一致性模型请参考http://bit1129.iteye.com/blog/2155336    Zookeeper的数据同步协议 Zookeeper采用称为Quorum Based Protocol的数据同步协议。假如Zookeeper集群有N台Zookeeper服务器(N通常取奇数，3台能够满足数据可靠性同时
  • Java开发笔记 白糖_ java开发
    1、Map<key,value>的remove方法只能识别相同类型的key值   Map<Integer,String> map = new HashMap<Integer,String>(); map.put(1,"a"); map.put(2,"b"); map.put(3,"c"
  • 图片黑色阴影 bozch 图片
     .event{ padding:0;    width:460px;    min-width: 460px;    border:0px solid #e4e4e4;    height: 350px;    min-heig
  • 编程之美-饮料供货-动态规划 bylijinnan 动态规划
    import java.util.Arrays; import java.util.Random; public class BeverageSupply { /** * 编程之美 饮料供货 * 设Opt（V’，i）表示从i到n-1种饮料中，总容量为V’的方案中，满意度之和的最大值。 * 那么递归式就应该是：Opt（V’，i）=max{ k * Hi+Op
  • ajax大参数（大数据）提交性能分析 chenbowen00 WebAjax框架浏览器prototype
    近期在项目中发现如下一个问题 项目中有个提交现场事件的功能，该功能主要是在web客户端保存现场数据（主要有截屏，终端日志等信息）然后提交到服务器上方便我们分析定位问题。客户在使用该功能的过程中反应点击提交后反应很慢，大概要等10到20秒的时间浏览器才能操作，期间页面不响应事件。 根据客户描述分析了下的代码流程，很简单，主要通过OCX控件截屏，在将前端的日志等文件使用OCX控件打包，在将之转换为
  • [宇宙与天文]在太空采矿,在太空建造 comsci
         我们在太空进行工业活动...但是不太可能把太空工业产品又运回到地面上进行加工,而一般是在哪里开采,就在哪里加工,太空的微重力环境,可能会使我们的工业产品的制造尺度非常巨大....      地球上制造的最大工业机器是超级油轮和航空母舰,再大些就会遇到困难了,但是在空间船坞中,制造的最大工业机器,可能就没
  • ORACLE中CONSTRAINT的四对属性 daizj oracleCONSTRAINT
    ORACLE中CONSTRAINT的四对属性 summary:在data migrate时,某些表的约束总是困扰着我们,让我们的migratet举步维艰,如何利用约束本身的属性来处理这些问题呢?本文详细介绍了约束的四对属性: Deferrable/not deferrable, Deferred/immediate, enalbe/disable, validate/novalidate,以及如
  • Gradle入门教程 dengkane gradle
    一、寻找gradle的历程 一开始的时候，我们只有一个工程，所有要用到的jar包都放到工程目录下面，时间长了，工程越来越大，使用到的jar包也越来越多，难以理解jar之间的依赖关系。再后来我们把旧的工程拆分到不同的工程里，靠ide来管理工程之间的依赖关系，各工程下的jar包依赖是杂乱的。一段时间后，我们发现用ide来管理项程很不方便，比如不方便脱离ide自动构建，于是我们写自己的ant脚本。再后
  • C语言简单循环示例 dcj3sjt126com c
    # include <stdio.h> int main(void) { int i; int count = 0; int sum = 0; float avg; for (i=1; i<=100; i++) { if (i%2==0) { count++; sum += i; } } avg
  • presentModalViewController 的动画效果 dcj3sjt126com controller
    系统自带(四种效果)： presentModalViewController模态的动画效果设置：     [cpp]  view plain copy   UIViewController *detailViewController = [[UIViewController al
  • java 二分查找 shuizhaosi888 二分查找java二分查找
    需求：在排好顺序的一串数字中，找到数字T   一般解法：从左到右扫描数据，其运行花费线性时间O(N)。然而这个算法并没有用到该表已经排序的事实。 /** * * @param array * 顺序数组 * @param t * 要查找对象 * @return */ public stati
  • Spring Security（07）——缓存UserDetails 234390216 ehcache缓存Spring Security
           Spring Security提供了一个实现了可以缓存UserDetails的UserDetailsService实现类，CachingUserDetailsService。该类的构造接收一个用于真正加载UserDetails的UserDetailsService实现类。当需要加载UserDetails时，其首先会从缓存中获取，如果缓存中没
  • Dozer 深层次复制 jayluns VOmavenpo
    最近在做项目上遇到了一些小问题，因为架构在做设计的时候web前段展示用到了vo层，而在后台进行与数据库层操作的时候用到的是Po层。这样在业务层返回vo到控制层，每一次都需要从po-->转化到vo层，用到BeanUtils.copyProperties(source, target)只能复制简单的属性，因为实体类都配置了hibernate那些关联关系，所以它满足不了现在的需求，但后发现还有个很
  • CSS规范整理（摘自懒人图库） a409435341 htmlUIcss浏览器
       刚没事闲着在网上瞎逛，找了一篇CSS规范整理，粗略看了一下后还蛮有一定的道理，并自问是否有这样的规范，这也是初入前端开发的人一个很好的规范吧。 一、文件规范 1、文件均归档至约定的目录中。 具体要求通过豆瓣的CSS规范进行讲解： 所有的CSS分为两大类：通用类和业务类。通用的CSS文件，放在如下目录中： 基本样式库 /css/core
  • C++动态链接库创建与使用 你不认识的休道人 C++dll
    一、创建动态链接库 1.新建工程test中选择”MFC [dll]”dll类型选择第二项"Regular DLL With MFC shared linked"，完成 2.在test.h中添加 extern “C” 返回类型 _declspec(dllexport)函数名(参数列表); 3.在test.cpp中最后写 extern “C” 返回类型 _decls
  • Android代码混淆之ProGuard rensanning ProGuard
    Android应用的Java代码，通过反编译apk文件（dex2jar、apktool）很容易得到源代码，所以在release版本的apk中一定要混淆一下一些关键的Java源码。 ProGuard是一个开源的Java代码混淆器（obfuscation）。ADT r8开始它被默认集成到了Android SDK中。 官网： http://proguard.sourceforge.net/
  • 程序员在编程中遇到的奇葩弱智问题 tomcat_oracle jquery编程ide
    　　现在收集一下：       　　排名不分先后，按照发言顺序来的。   1、Jquery插件一个通用函数一直报错，尤其是很明显是存在的函数，很有可能就是你没有引入jquery。。。或者版本不对 2、调试半天没变化：不在同一个文件中调试。这个很可怕，我们很多时候会备份好几个项目，改完发现改错了。有个群友说的好：   在汤匙
  • 解决maven-dependency-plugin (goals "copy-dependencies","unpack") is not supported xp9802 dependency
    解决办法：在plugins之前添加如下pluginManagement，二者前后顺序如下：   [html]  view plain copy   <build>           <pluginManagement
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他