ALSA System on Chip(ASOC)

此文档仅作为开发随笔记录文档，可作为正式文档做材料参考，但不做正式文档。

 

Written bywolfgang huang(stillinux@gmail.com)

 

此类文档仅记录Android4.1.2+Kernel2.6.37+OMAP3730平台ALSA开发及内核要点，备注好资料应用，以供后续开发人员快速入手，也可作为科普类资料，供其他相关人员学习。

 

ALSA System on Chip(ASOC)

本系列文档的目标是使读者从安卓HAL一直走到硬件层的处理流程，使Kernel的ALSA构架内部细节透露出来。但是由于鄙人水平有限，难免有错误理解，如有错误，请联系，立即改正。
 
下面我们细述linux音频子系统中的ASOC，对于整体的框架作图如下。



我们接下来分块的对ASOC的子模块在内核中如何启动，注册等运作流程。

 

在linux设备模型下，device与相应的driver相匹配，从而支持linux透过drvier对于其绑定的device做到控制管理。故使对应的设备要在linux下进行良好的工作，则必须正确加载device和driver。

Platform模块：

对于platform的设备启动流程如下:

omap_init_audio->platform_device_register(&omap_pcm);

将omap_pcm的设备注册到platform总线的设备链表上。

 

对于platform的驱动，则有：

snd_omap_pcm_init->platform_driver_register(&omap_pcm_driver);

将omap_pcm_driver注册到platform总线的驱动链表上。

 

由linux驱动模型，当注册driver或device时，都会到其隶属总线的对应链表上去查找匹配的驱动或设备(linux更相信设备)。这样匹配后调用对应的driver->probe，则调用到我们的omap_pcm_probe，其调用snd_soc_register_platform，注册omap_soc_platform到ASOC的platform_list中，且由于device中对于其id设置为-1,则platform的名称设置为dev->driver->name。

 

Note：linux驱动模型下，platform总线绑定的依据有三种，of设备树的dtb方式，还有id_table的方式，最后就是默认的name比对方式。对于其他总线，诸如SPI用modalias比对等方式，此处不做过多细述。

 

Cpu_dai模块：

对于cpu_dai启动流程如下:

omap_init_audio->platform_device_register(&omap_mcbsp1);

将omap_mcbsp的设备注册到platform总线的设备链表上。

 

对于cpu_dai的驱动，则有：

snd_omap_mcbsp_init->platform_driver_register(&asoc_mcbsp_driver);

将asoc_mcbsp_driver注册到platform总线的驱动链表上。

 

由上面分析，我们知道驱动模型绑定后，根据名称都为omap-mcbsp-dai匹配后，调用到其驱动的probe接口，即asoc_mcbsp_probe。其调用snd_soc_register_dai，将omap_mcbsp_dai注册到ASOC的dai_list链表上。

 

 

Codec模块和Codec_dai模块：

在我们使用的OMAP平台上，codec使用的集成的TPS65951,其设备加载过程较为复杂，下面进行细述。

其设备的加载流程：

devkit8000_init->devkit8000_i2c_init->omap_register_i2c_bus(..devkit8000_i2c1_boardinfo)。

tps65951，使用的是twl4030兼容的驱动。

twl_init->i2c_add_driver(&twl_driver)<throughid_table(与上面的boardinfo匹配)>

->twl_probe->add_children->add_child<has_codec成立的条件下>

->platform_device_add()<name=”twl4030-audio”>。

将tps65951中的音频声卡codec设备加入到platform总线的设备链表。

但是此处并没有完成codec资源的解析，其又调用一次匹配后，进行资源的分块解析。

该过程为：

twl4030_codec_init->platform_driver_register(&twl4030_codec_driver);

与上面注册的codec设备匹配后，运行其驱动的probe，即twl4030_codec_probe，

其完成对于codec时钟的设置后，调用mfd_add_devices将获得资源重组到新的platform_device中，并将其加入到platform总线上，其名称为twl4030_codec。此时才是最终的tps65951设备声卡加入的真正设备资源。

对于其真正的设备资源，对应的驱动有：

twl4030_modinit-> platform_driver_register(&twl4030_codec_driver);<name=”twl4030_codec”>。

则匹配后调用其驱动的probe，即twl4030_codec_probe(与上面的有区别)。其调用snd_soc_register_codec，注册了对应的

 

则根据驱动模型绑定后，我们知道运行其驱动的probe，即twl4030_codec_probe，其调用snd_soc_register_codec，注册soc_codec_dev_twl4030到ASOC的codec_list，并将对应的twl4030_dai注册到ASOC的dai_list中，twl4030_dai有hifi和voice两种模式，即codec支持这两种音频数据流。其最终根据ASOC的配置环境snd_soc_dai_link，选用对应的配置模式。

 

ASOC(Machine)：

最后对应ASOC整体的框架注册过程：

对应其设备注册流程如下：

omap3beagle_soc_init-> platform_device_add(omap3beagle_snd_device);<name=”soc-audio”>

 

对应的驱动注册则有:

snd_soc_init-> platform_driver_register(&soc_driver);根据驱动模型绑定后，则会调用到soc_probe函数。其获取ASOC定义的snd_soc_card配置数据snd_soc_omap3beagle。

snd_soc_card中的成员num_link定义有几个snd_soc_pcm_runtime，对于该处为1，成员dai_link，则定义了该snd_card对应的配置环境数据。

 

其结构定义如下:

struct snd_soc_dai_link {
/* config - must be set by machine driver */
const char *name;			/* Codec name */
const char *stream_name;		/* Stream name */
const char *codec_name;		/* for multi-codec */
const char *platform_name;	/* for multi-platform */
const char *cpu_dai_name;
const char *codec_dai_name;

/* Keep DAI active over suspend */
unsigned int ignore_suspend:1;

/* Symmetry requirements */
unsigned int symmetric_rates:1;

/* codec/machine specific init - e.g. add machine controls */
int (*init)(struct snd_soc_pcm_runtime *rtd);

/* machine stream operations */
struct snd_soc_ops *ops;
};

根据注释，在观察我们的具体配置：

static struct snd_soc_dai_link omap3beagle_dai = {
.name = "TWL4030",
.stream_name = "TWL4030",		//runtime名称
.cpu_dai_name = "omap-mcbsp-dai.1",	//cpu_dai<I2S>
.platform_name = "omap-pcm-audio",	//platform
.codec_dai_name = "twl4030-hifi",	//codec_dai,选择高保真音频数据流格式
.codec_name = "twl4030-codec",		//tps65951
.ops = &omap3beagle_ops,
};

soc_probe获取对应的snd_soc_card配置数据后，调用snd_soc_register_card。

static int snd_soc_register_card(struct snd_soc_card *card)
{
int i;

if (!card->name || !card->dev)
return -EINVAL;

card->rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime) * card->num_links,
GFP_KERNEL);
if (card->rtd == NULL)
return -ENOMEM;

for (i = 0; i < card->num_links; i++)
card->rtd[i].dai_link = &card->dai_link[i];

INIT_LIST_HEAD(&card->list);
card->instantiated = 0;
mutex_init(&card->mutex);

mutex_lock(&client_mutex);
list_add(&card->list, &card_list);
snd_soc_instantiate_cards();
mutex_unlock(&client_mutex);

dev_dbg(card->dev, "Registered card '%s'\n", card->name);

return 0;
}

根据配置数据的num_links，分配对应的snd_soc_pcm_runtime,并绑定各自snd_soc_pcm_runtime与dai_link，接着将加入的snd_soc_card加入到card_list，ASOC最多支持八个snd_soc_card。最后调用snd_soc_instantiate_cards。该函数在其他的注册接口也有调用，但是其只有在dai_link中的组件全部都组建完成才能继续往下走。故在此处综述。

snd_soc_instantiate_cards：遍历card_list，依次调用snd_soc_instantiate_card。

static void snd_soc_instantiate_card(struct snd_soc_card *card)
{
struct platform_device *pdev = to_platform_device(card->dev);
int ret, i;

mutex_lock(&card->mutex);

if (card->instantiated) {
mutex_unlock(&card->mutex);
return;
}

/* bind DAIs */
for (i = 0; i < card->num_links; i++)
soc_bind_dai_link(card, i);

/* bind completed ? */
if (card->num_rtd != card->num_links) {
mutex_unlock(&card->mutex);
return;
}

/*
* #define SNDRV_DEFAULT_IDX1      (-1)
* #define SNDRV_DEFAULT_STR1      NULL
*/

/* card bind complete so register a sound card */
ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
card->owner, 0, &card->snd_card);
if (ret < 0) {
printk(KERN_ERR "asoc: can't create sound card for card %s\n",
card->name);
mutex_unlock(&card->mutex);
return;
}
card->snd_card->dev = card->dev;

#ifdef CONFIG_PM
/* deferred resume work */
INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
#endif

/* initialise the sound card only once */
if (card->probe) {
ret = card->probe(pdev);
if (ret < 0)
goto card_probe_error;
}

for (i = 0;
c887
i < card->num_links; i++) {
ret = soc_probe_dai_link(card, i);
if (ret < 0) {
pr_err("asoc: failed to instantiate card %s: %d\n",
card->name, ret);
goto probe_dai_err;
}
}

snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
"%s",  card->name);
snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
"%s", card->name);

ret = snd_card_register(card->snd_card);
if (ret < 0) {
printk(KERN_ERR "asoc: failed to register soundcard for %s\n", card->name);
goto probe_dai_err;
}

#ifdef CONFIG_SND_SOC_AC97_BUS
/* register any AC97 codecs */
for (i = 0; i < card->num_rtd; i++) {
ret = soc_register_ac97_dai_link(&card->rtd[i]);
if (ret < 0) {
printk(KERN_ERR "asoc: failed to register AC97 %s\n", card->name);
while (--i >= 0)
soc_unregister_ac97_dai_link(&card->rtd[i]);
goto probe_dai_err;
}
}
#endif

card->instantiated = 1;
mutex_unlock(&card->mutex);
return;

probe_dai_err:
for (i = 0; i < card->num_links; i++)
soc_remove_dai_link(card, i);

card_probe_error:
if (card->remove)
card->remove(pdev);

snd_card_free(card->snd_card);

mutex_unlock(&card->mutex);
}

我们把该函数拆分为四段函数进行分析，分别为soc_bind_dai_link，snd_card_create，soc_probe_dai_link及snd_card_register。AC97我们在此略过，一般嵌入式设备都使用I2S。

static int soc_bind_dai_link(struct snd_soc_card *card, int num)
{
struct snd_soc_dai_link *dai_link = &card->dai_link[num];
struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
struct snd_soc_codec *codec;
struct snd_soc_platform *platform;
struct snd_soc_dai *codec_dai, *cpu_dai;

if (rtd->complete)
return 1;
dev_dbg(card->dev, "binding %s at idx %d\n", dai_link->name, num);

/* do we already have the CPU DAI for this link ? */
if (rtd->cpu_dai) {
goto find_codec;
}
/* no, then find CPU DAI from registered DAIs*/
list_for_each_entry(cpu_dai, &dai_list, list) {
//依次遍历，查找是否有dai_link按名称指定的cpu_dai
if (!strcmp(cpu_dai->name, dai_link->cpu_dai_name)) {

if (!try_module_get(cpu_dai->dev->driver->owner))
return -ENODEV;

rtd->cpu_dai = cpu_dai;
goto find_codec;
}
}
dev_dbg(card->dev, "CPU DAI %s not registered\n",
dai_link->cpu_dai_name);

find_codec:
/* do we already have the CODEC for this link ? */
if (rtd->codec) {
goto find_platform;
}

/* no, then find CODEC from registered CODECs*/
list_for_each_entry(codec, &codec_list, list) {
//依次遍历，查找是否有dai_link按名称指定的codec
if (!strcmp(codec->name, dai_link->codec_name)) {
rtd->codec = codec;

if (!try_module_get(codec->dev->driver->owner))
return -ENODEV;

/* CODEC found, so find CODEC DAI from registered DAIs from this CODEC*/
list_for_each_entry(codec_dai, &dai_list, list) {
//依次遍历，查找是否有dai_link按名称指定的codec_dai
if (codec->dev == codec_dai->dev &&
!strcmp(codec_dai->name, dai_link->codec_dai_name)) {
rtd->codec_dai = codec_dai;
goto find_platform;
}
}
dev_dbg(card->dev, "CODEC DAI %s not registered\n",
dai_link->codec_dai_name);

goto find_platform;
}
}
dev_dbg(card->dev, "CODEC %s not registered\n",
dai_link->codec_name);

find_platform:
/* do we already have the CODEC DAI for this link ? */
if (rtd->platform) {
goto out;
}
/* no, then find CPU DAI from registered DAIs*/
list_for_each_entry(platform, &platform_list, list) {
//依次遍历，查找是否有dai_link按名称指定的platform
if (!strcmp(platform->name, dai_link->platform_name)) {

if (!try_module_get(platform->dev->driver->owner))
return -ENODEV;

rtd->platform = platform;
goto out;
}
}

dev_dbg(card->dev, "platform %s not registered\n",
dai_link->platform_name);
return 0;

out:
/* mark rtd as complete if we found all 4 of our client devices */
if (rtd->codec && rtd->codec_dai && rtd->platform && rtd->cpu_dai) {
rtd->complete = 1;
card->num_rtd++;
}
return 1;
}

其完成的工作单调而统一，就是依次比对dai_link指定的四大模块，缺一不可，且对应于多个num_links的还需要一一绑定。找到对应的dai_link指定的模块后，就将runtime与其对应模块进行绑定。

int snd_card_create(int idx, const char *xid,
struct module *module, int extra_size,
struct snd_card **card_ret)
{
struct snd_card *card;
int err, idx2;

if (snd_BUG_ON(!card_ret))
return -EINVAL;
*card_ret = NULL;

if (extra_size < 0)
extra_size = 0;
card = kzalloc(sizeof(*card) + extra_size, GFP_KERNEL);
……
/* the control interface cannot be accessed from the user space until */
/* snd_cards_bitmask and snd_cards are set with snd_card_register */
err = snd_ctl_create(card);
if (err < 0) {
snd_printk(KERN_ERR "unable to register control minors\n");
goto __error;
}
err = snd_info_card_create(card);
if (err < 0) {
snd_printk(KERN_ERR "unable to create card info\n");
goto __error_ctl;
}
……
return err;
}

其分配对应的snd_card，并分配对应的id，且ASOC最大支持八个snd_card。之后调用snd_ctl_create->snd_device_new(card, SNDRV_DEV_CONTROL,…);注册该snd_card绑定的mixer控制设备节点，controlCx。且其目前只是创建，在后面snd_card_register的时候注册到用户空间设备节点。该函数调用snd_info_card_create，创建/proc/asound/cardX，向用户透露信息。

static int soc_probe_dai_link(struct snd_soc_card *card, int num)
{
struct snd_soc_dai_link *dai_link = &card->dai_link[num];
struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_platform *platform = rtd->platform;
struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
int ret;

dev_dbg(card->dev, "probe %s dai link %d\n", card->name, num);

/* config components */
codec_dai->codec = codec;
codec->card = card;
cpu_dai->platform = platform;
rtd->card = card;
rtd->dev.parent = card->dev;
codec_dai->card = card;
cpu_dai->card = card;

/* set default power off timeout */
rtd->pmdown_time = pmdown_time;

/* probe the cpu_dai */
if (!cpu_dai->probed) {
if (cpu_dai->driver->probe) {
ret = cpu_dai->driver->probe(cpu_dai);
if (ret < 0) {
printk(KERN_ERR "asoc: failed to probe CPU DAI %s\n",
cpu_dai->name);
return ret;
}
}
cpu_dai->probed = 1;
/* mark cpu_dai as probed and add to card cpu_dai list */
list_add(&cpu_dai->card_list, &card->dai_dev_list);
}

/* probe the CODEC */
if (!codec->probed) {
if (codec->driver->probe) {
ret = codec->driver->probe(codec);
if (ret < 0) {
printk(KERN_ERR "asoc: failed to probe CODEC %s\n",
codec->name);
return ret;
}
}

soc_init_codec_debugfs(codec);

/* mark codec as probed and add to card codec list */
codec->probed = 1;
list_add(&codec->card_list, &card->codec_dev_list);
}

/* probe the platform */
if (!platform->probed) {
if (platform->driver->probe) {
ret = platform->driver->probe(platform);
if (ret < 0) {
printk(KERN_ERR "asoc: failed to probe platform %s\n",
platform->name);
return ret;
}
}
/* mark platform as probed and add to card platform list */
platform->probed = 1;
list_add(&platform->card_list, &card->platform_dev_list);
}

/* probe the CODEC DAI */
if (!codec_dai->probed) {
if (codec_dai->driver->probe) {
ret = codec_dai->driver->probe(codec_dai);
if (ret < 0) {
printk(KERN_ERR "asoc: failed to probe CODEC DAI %s\n",
codec_dai->name);
return ret;
}
}

/* mark cpu_dai as probed and add to card cpu_dai list */
codec_dai->probed = 1;
list_add(&codec_dai->card_list, &card->dai_dev_list);
}

/* DAPM dai link stream work */
INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);

/* now that all clients have probed, initialise the DAI link */
if (dai_link->init) {
ret = dai_link->init(rtd);
if (ret < 0) {
printk(KERN_ERR "asoc: failed to init %s\n", dai_link->stream_name);
return ret;
}
}

/* Make sure all DAPM widgets are instantiated */
snd_soc_dapm_new_widgets(codec);
snd_soc_dapm_sync(codec);

/* register the rtd device */
rtd->dev.release = rtd_release;
rtd->dev.init_name = dai_link->name;
ret = device_register(&rtd->dev);	/* TWL4030 in the /sys/devices/platform/soc-audio */
if (ret < 0) {
printk(KERN_ERR "asoc: failed to register DAI runtime device %d\n", ret);
return ret;
}

rtd->dev_registered = 1;
ret = device_create_file(&rtd->dev, &dev_attr_pmdown_time);
if (ret < 0)
printk(KERN_WARNING "asoc: failed to add pmdown_time sysfs\n");

/* add DAPM sysfs entries for this codec */
ret = snd_soc_dapm_sys_add(&rtd->dev);
if (ret < 0)
printk(KERN_WARNING "asoc: failed to add codec dapm sysfs entries\n");

/* add codec sysfs entries */
ret = device_create_file(&rtd->dev, &dev_attr_codec_reg);
if (ret < 0)
printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");

/* create the pcm */
ret = soc_new_pcm(rtd, num);
if (ret < 0) {
printk(KERN_ERR "asoc: can't create pcm %s\n", dai_link->stream_name);
return ret;
}

/* add platform data for AC97 devices */
if (rtd->codec_dai->driver->ac97_control)
snd_ac97_dev_add_pdata(codec->ac97, rtd->cpu_dai->ac97_pdata);

return 0;
}

该函数对四个模块依次调用probe接口，这些probe函数不进行细述，主要是对于声卡的初始化，并把声卡内部的控件加入到系统snd_kcontrol中，其他模块未做主要事宜或者没有probe接口。接着初始化close_delayed_work工作队列，其在关闭接口时，用于延时调用，防止pop刺耳噪音。接下来对于DAPM的初始化和同步。开始DAPM将加入的codec->dapm_widget进行分类型初始化，并绑定相关的电源操作接口，最后以snd_kcontrol提供用户控制。调用snd_soc_dapm_sync,对加入的控件分类加到上电和下电的链表中，并根据情况对不同的链表上下电处理。之后就是相关sysfs属性文件的注册，注册到sysfs文件系统中。最后调用soc_new_pcm，根据对应配置的codec_dai的packback和capture创建对应的pcm设备空间，并完成其初始化，绑定对应的操作接口，但是其也要在最后snd_card_register的时候才能注册到sysfs和devtmpfs中。

snd_card_register->snd_device_register_all:完成controlCx,pcmCxDx(p/c)的到sysfs和devtmpfs文件系统的注册。<timer在alsa_timer_init -> snd_register_device 完成，不过我们不关注>

 

 

通过上述分析，我们知道了音频子系统，用户操作的接口在内核中是经过了怎样的流程才注册到用户空间。对于具体操作这些设备节点，又会是怎样的流程我们在后续的文档进行分析。对于访问具体的控件，调整路径，电源控制，都留在后续的文档一一分析。

 

下面我们以图表的形式分析这些设备节点的注册过程。