ALSA声卡驱动：
1.Linux ALSA声卡驱动之一：ALSA架构简介和ASOC架构简介
2.Linux ALSA声卡驱动之二：Platform
3. Linux ALSA声卡驱动之三：Platform之Cpu_dai
4. Linux ALSA声卡驱动之四：Codec 以及Codec_dai
5.Linux ALSA声卡驱动之五：Machine 以及ALSA声卡的注册
6.Linux ALSA声卡驱动之六：PCM的注册流程
7.Linux ALSA声卡驱动之七：录音(Capture) 调用流程
一、PCM设备的基础介绍
PCM是英文Pulse-code modulation的缩写，中文译名是脉冲编码调制。我们知道在现实生活中，人耳听到的声音是模拟信号，PCM就是要把声音从模拟转换成数字信号的一种技术，他的原理简单地说就是利用一个固定的频率对模拟信号进行采样，采样后的信号在波形上看就像一串连续的幅值不一的脉冲，把这些脉冲的幅值按一定的精度进行量化，这些量化后的数值被连续地输出、传输、处理或记录到存储介质中，所有这些组成了数字音频的产生过程。
-
1.1基本的名称解释
1.采样率(rate)：也称为采样速度或者采样率，定义了每秒从连续信号中提取并组成离散信号的采样个数，它用赫兹（Hz）来表示。采样频率的倒数是采样周期或者叫作采样时间，它是采样之间的时间间隔。通俗的讲采样频率是指计算机每秒钟采集多少个声音样本，是描述声音文件的音质、音调，衡量声卡、声音文件的质量标准。采样频率常有：8khz，16khz，44.1khz，48khz。
2.量化位数（bits）：是对模拟音频信号的振幅进行的数字化。常用的8位,16位,32位。量化度越高，音频信号越可能接近原生信号。
3.声道数(channels): 是指支持能不同发声的音响的个数，它是衡量音响设备的重要指标之一，一般分单声道和双通道。
4.帧（frame）：桢记录了一个声音单元，其长度为样本长度与通道数的乘积。其大小等于=bits * channels /8 ，单位是btye。
5. 周期(period_size) 周期大小，即每次dma硬件中断处理音频数据的帧数。如果周期设定得较大，则单次处理的数据较多，这意味着单位时间内硬件中断的次数较少，CPU也就有更多时间处理其他任务，功耗也更低，但这样也带来一个显著的弊端——数据处理的时延（latency）会增大 period_size=frame*rate*framecount. framecount的值是底层定义好的。
6.周期数（period_count） 应用程序缓存区的大小可以通过ALSA库函数调用来控制。缓存区可以很大，一次传输操作可能会导致不可接受的延迟，我们把它称为延时(latency)。为了解决这个问题，ALSA将缓存区拆分成一系列周期(period)(OSS/Free中叫片断fragments).ALSA以period为单元来传送数据。
7.声音缓存(buffer)和数据传输：
每个声卡都有一个硬件缓存区来保存记录下来的样本。当缓存区足够满时，声卡将产生一个中断。内核声卡驱动然后使用直接内存(DMA)访问通道将样本传送到内存中的应用程序缓存区。类似地，对于回放，任何应用程序使用DMA将自己的缓存区数据传送到声卡的硬件缓存区中。
这样硬件缓存区是环缓存。也就是说当数据到达缓存区末尾时将重新回到缓存区的起始位置。ALSA维护一个指针来指向硬件缓存以及应用程序缓存区中数据操作的当前位置。从内核外部看，我们只对应用程序的缓存区感兴趣，所以本文只讨论应用程序缓存区。
应用程序缓存区的大小可以通过ALSA库函数调用来控制。缓存区可以很大，一次传输操作可能会导致不可接受的延迟，我们把它称为延时(latency)。为了解决这个问题，ALSA将缓存区拆分成一系列周期(period)(OSS/Free中叫片断fragments).ALSA以period为单元来传送数据。
一个周期(period)存储一些帧(frames)。每一帧包含时间上一个点所抓取的样本。对于立体声设备，一个帧会包含两个信道上的样本。分解过程：一个缓存区分解成周期，然后是帧，然后是样本。左右信道信息被交替地存储在一个帧内。这称为交错 (interleaved)模式。在非交错模式中，一个信道的所有样本数据存储在另外一个信道的数据之后。
缓存的大小会等于=period_size * period_count
二、PCM的注册
-
2.1 pcm注册时序图
从上面的时序图，我们可以看出有一部分跟声卡驱动注册相同，都是从snd_soc_register_card开始，然后调用soc_new_pcm，调用soc_new_pcm之前部分读者自己看源码，我们来看看soc_new_pcm做了哪些。
- 2.2 soc_new_pcm
int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
{
struct snd_soc_platform *platform = rtd->platform;
struct snd_soc_dai *codec_dai;
struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
struct snd_pcm *pcm;
char new_name[64];
int ret = 0, playback = 0, capture = 0;
int i;
//dai_link->dynamic 0
if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm) {
playback = rtd->dai_link->dpcm_playback;
capture = rtd->dai_link->dpcm_capture;
} else {
for (i = 0; i < rtd->num_codecs; i++) {
codec_dai = rtd->codec_dais[i];
//mtk_6357_dai_codecs 里面定义
if (codec_dai->driver->playback.channels_min)
playback = 1;
if (codec_dai->driver->capture.channels_min)
capture = 1;
}
//mtk_dai_stub_dai 和mtk_6357_dai_codecs 两个共同决定pcm里面是否拥有playback和capture
capture = capture && cpu_dai->driver->capture.channels_min;
playback = playback && cpu_dai->driver->playback.channels_min;
}
if (rtd->dai_link->playback_only) {
playback = 1;
capture = 0;
}
if (rtd->dai_link->capture_only) {
playback = 0;
capture = 1;
}
/* create the PCM */
if (rtd->dai_link->no_pcm) {
snprintf(new_name, sizeof(new_name), "(%s)",
rtd->dai_link->stream_name);
ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
playback, capture, &pcm);
} else {
if (rtd->dai_link->dynamic)
snprintf(new_name, sizeof(new_name), "%s (*)",
rtd->dai_link->stream_name);
else
snprintf(new_name, sizeof(new_name), "%s %s-%d",
rtd->dai_link->stream_name,
(rtd->num_codecs > 1) ?
"multicodec" : rtd->codec_dai->name, num);
//创建pcm以及pcm下面挂载的substream
ret = snd_pcm_new(rtd->card->snd_card, new_name, num, playback,
capture, &pcm);
}
if (ret < 0) {
dev_err(rtd->card->dev, "ASoC: can't create pcm for %s\n",
rtd->dai_link->name);
return ret;
}
dev_dbg(rtd->card->dev, "ASoC: registered pcm #%d %s\n",num, new_name);
/* DAPM dai link stream work */
INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
pcm->nonatomic = rtd->dai_link->nonatomic;
rtd->pcm = pcm;
pcm->private_data = rtd;
if (rtd->dai_link->no_pcm) {
if (playback)
pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
if (capture)
pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
goto out;
}
/* ASoC PCM operations */
if (rtd->dai_link->dynamic) {
rtd->ops.open = dpcm_fe_dai_open;
rtd->ops.hw_params = dpcm_fe_dai_hw_params;
rtd->ops.prepare = dpcm_fe_dai_prepare;
rtd->ops.trigger = dpcm_fe_dai_trigger;
rtd->ops.hw_free = dpcm_fe_dai_hw_free;
rtd->ops.close = dpcm_fe_dai_close;
rtd->ops.pointer = soc_pcm_pointer;
rtd->ops.ioctl = soc_pcm_ioctl;
} else {
rtd->ops.open = soc_pcm_open;
rtd->ops.hw_params = soc_pcm_hw_params;
rtd->ops.prepare = soc_pcm_prepare;
rtd->ops.trigger = soc_pcm_trigger;
rtd->ops.hw_free = soc_pcm_hw_free;
rtd->ops.close = soc_pcm_close;
rtd->ops.pointer = soc_pcm_pointer;
rtd->ops.ioctl = soc_pcm_ioctl;
}
if (platform->driver->ops) {
rtd->ops.ack = platform->driver->ops->ack;
rtd->ops.copy = platform->driver->ops->copy;
rtd->ops.silence = platform->driver->ops->silence;
rtd->ops.page = platform->driver->ops->page;
rtd->ops.mmap = platform->driver->ops->mmap;
}
if (playback)
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &rtd->ops);//通过substream->next，挂载pcm下面的所有substream
if (capture)
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &rtd->ops);//通过substream->next，挂载pcm下面的所有substream
if (platform->driver->pcm_new) {
DEBUG_I("soc_pcm_open soc_new_pcm platform->driver->pcm_new \n");//xiao
ret = platform->driver->pcm_new(rtd);
if (ret < 0) {
dev_err(platform->dev,
"ASoC: pcm constructor failed: %d\n",
ret);
return ret;
}
}
pcm->private_free = platform->driver->pcm_free;
out:
dev_info(rtd->card->dev, "%s <-> %s mapping ok\n",
(rtd->num_codecs > 1) ? "multicodec" : rtd->codec_dai->name,
cpu_dai->name);
return ret;
}总的来看做了如下事情：
1.确认rtd下面是否有playback和 capture，有的rtd有capture而没有playback
2.对rtd->ops进行赋值 比如 open close等，赋值的意义在于上层对pcm设备的调用
3.创建substream 并且通过substream->next挂载到pcm下面
4.pcm设备创建完成
上层最open最终会调用如下函数
rtd->ops.open = soc_pcm_open;
rtd->ops.hw_params = soc_pcm_hw_params;
rtd->ops.prepare = soc_pcm_prepare;
rtd->ops.trigger = soc_pcm_trigger;
rtd->ops.hw_free = soc_pcm_hw_free;
rtd->ops.close = soc_pcm_close;
rtd->ops.pointer = soc_pcm_pointer;
rtd->ops.ioctl = soc_pcm_ioctl;
- 2.3 _snd_pcm_new
static int _snd_pcm_new(struct snd_card *card, const char *id, int device,
int playback_count, int capture_count, bool internal,
struct snd_pcm **rpcm)
{
struct snd_pcm *pcm;
int err;
static struct snd_device_ops ops = {
.dev_free = snd_pcm_dev_free,
.dev_register = snd_pcm_dev_register,
.dev_disconnect = snd_pcm_dev_disconnect,
};
if (snd_BUG_ON(!card))
return -ENXIO;
if (rpcm)
*rpcm = NULL;
pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
if (!pcm)
return -ENOMEM;
pcm->card = card;
pcm->device = device;
pcm->internal = internal;
mutex_init(&pcm->open_mutex);
init_waitqueue_head(&pcm->open_wait);
INIT_LIST_HEAD(&pcm->list);
if (id)
strlcpy(pcm->id, id, sizeof(pcm->id));
//新建playback
if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, playback_count)) < 0) {
snd_pcm_free(pcm);
return err;
}
//新建capture
if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count)) < 0) {
snd_pcm_free(pcm);
return err;
}
//创建snd_device 挂载到snd_card上面
if ((err = snd_device_new(card, SNDRV_DEV_PCM, pcm, &ops)) < 0) {
snd_pcm_free(pcm);
return err;
}
if (rpcm)
*rpcm = pcm;
return 0;
}
- 2.3 snd_pcm_new_stream 从字面就能看其实就是创建流： snd_pcm_substream
int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
{
int idx, err;
struct snd_pcm_str *pstr = &pcm->streams[stream];
struct snd_pcm_substream *substream, *prev;
#if IS_ENABLED(CONFIG_SND_PCM_OSS)
mutex_init(&pstr->oss.setup_mutex);
#endif
pstr->stream = stream;
pstr->pcm = pcm;
pstr->substream_count = substream_count;
if (!substream_count)
return 0;
snd_device_initialize(&pstr->dev, pcm->card);//pcm 设备挂到snd_card下面。dev->parent = &card->card_dev
pstr->dev.groups = pcm_dev_attr_groups;
// proc/asound/card0/ 下面的名称显示 设置pcm设备的名称。
dev_set_name(&pstr->dev, "pcmC%iD%i%c", pcm->card->number, pcm->device,
stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
DEBUG_I("snd_pcm_new_stream pstr->dev->kobj.name=%s \n", pstr->dev.kobj.name);//xiao
//pcm->internal=false
if (!pcm->internal) {
err = snd_pcm_stream_proc_init(pstr);//创建/proc/asound/card0/下面的pcm信息
if (err < 0) {
pcm_err(pcm, "Error in snd_pcm_stream_proc_init\n");
return err;
}
}
prev = NULL;
//substream_count=card->num_links
for (idx = 0, prev = NULL; idx < substream_count; idx++) {
substream = kzalloc(sizeof(*substream), GFP_KERNEL);
if (!substream)
return -ENOMEM;
substream->pcm = pcm;
substream->pstr = pstr;
substream->number = idx;
substream->stream = stream;
sprintf(substream->name, "subdevice #%i", idx);
substream->buffer_bytes_max = UINT_MAX;
//通过prev->next = substream,使substream都挂载到snd_pcm_str->substream
//一个playback stream下可有多个substream
//pstr=&pcm->streams
if (prev == NULL)
pstr->substream = substream;
else
prev->next = substream;
///proc/asound/card0/pcm0p/sub0目录和下面具体的文件
if (!pcm->internal) {
err = snd_pcm_substream_proc_init(substream);
if (err < 0) {
pcm_err(pcm,
"Error in snd_pcm_stream_proc_init\n");
if (prev == NULL)
pstr->substream = NULL;
else
prev->next = NULL;
kfree(substream);
return err;
}
}
substream->group = &substream->self_group;
spin_lock_init(&substream->self_group.lock);
mutex_init(&substream->self_group.mutex);
INIT_LIST_HEAD(&substream->self_group.substreams);
list_add_tail(&substream->link_list, &substream->self_group.substreams);//队列的方式添加到列表中
atomic_set(&substream->mmap_count, 0);
prev = substream;
}
return 0;
} - 2.4 snd_pcm_set_ops 就是把之前rtd->ops.open = soc_pcm_open 等相关的操作函数赋值给新创建snd_pcm_substream
void snd_pcm_set_ops(struct snd_pcm *pcm, int direction,
const struct snd_pcm_ops *ops)
{
struct snd_pcm_str *stream = &pcm->streams[direction];
struct snd_pcm_substream *substream;
for (substream = stream->substream; substream != NULL; substream = substream->next)
substream->ops = ops;
}- 2.5 snd_device_register_all
int snd_device_register_all(struct snd_card *card)
{
struct snd_device *dev;
int err;
if (snd_BUG_ON(!card))
return -ENXIO;
//card->devices是通过snd_device_new添加的
//注册所有snd_card下面挂载的声卡逻辑设备 snd_device_ops.dev_register
list_for_each_entry(dev, &card->devices, list) {
err = __snd_device_register(dev);
if (err < 0)
return err;
}
return 0;
}- 2.6 __snd_device_register
static int __snd_device_register(struct snd_device *dev)
{
if (dev->state == SNDRV_DEV_BUILD) {
if (dev->ops->dev_register) {
int err = dev->ops->dev_register(dev);//dev 注册 会调用pcm.c snd_pcm_dev_register
if (err < 0)
return err;
}
dev->state = SNDRV_DEV_REGISTERED;
}
return 0;
}不知道读者有没有疑惑，snd_device *dev 是什么时候被注册到声卡上面的？dev_register这个函数又是在哪里赋值呢？
前面讲解_snd_pcm_new 函数会调用 snd_device_new，这个函数的主要功能是创建新snd_device *dev ，并且把dev 添加到链表snd_card->devices。snd_card->devices这个链表记录了所有device，比如pcm control。
_snd_pcm_new函数会有如下的代码，是不是发现__snd_device_register函数里面的dev_register 跟下面的dev_register 一样，不错__snd_device_register dev_register的值就是由下面函数赋值的。
static struct snd_device_ops ops = {
.dev_free = snd_pcm_dev_free,
.dev_register = snd_pcm_dev_register,
.dev_disconnect = snd_pcm_dev_disconnect,
};
- 2.7 snd_pcm_dev_register
static int snd_pcm_dev_register(struct snd_device *device)
{
int cidx, err;
struct snd_pcm_substream *substream;
struct snd_pcm_notify *notify;
struct snd_pcm *pcm;
if (snd_BUG_ON(!device || !device->device_data))
return -ENXIO;
pcm = device->device_data;
if (pcm->internal)
return 0;
mutex_lock(®ister_mutex);
err = snd_pcm_add(pcm);//添加到链表snd_pcm_devices
if (err)
goto unlock;
for (cidx = 0; cidx < 2; cidx++) {
int devtype = -1;
if (pcm->streams[cidx].substream == NULL)
continue;
switch (cidx) {
case SNDRV_PCM_STREAM_PLAYBACK:
devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
break;
case SNDRV_PCM_STREAM_CAPTURE:
devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
break;
}
/* register pcm */ //注册pcm设备中的playback 和capture
err = snd_register_device(devtype, pcm->card, pcm->device,
&snd_pcm_f_ops[cidx], pcm,
&pcm->streams[cidx].dev);
if (err < 0) {
list_del_init(&pcm->list);
goto unlock;
}
//初始化每个substream的时间
for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
snd_pcm_timer_init(substream);
}
list_for_each_entry(notify, &snd_pcm_notify_list, list)
notify->n_register(pcm);
unlock:
mutex_unlock(®ister_mutex);
return err;
}
- 2.8 snd_register_device
int snd_register_device(int type, struct snd_card *card, int dev,
const struct file_operations *f_ops,
void *private_data, struct device *device)
{
int minor;
int err = 0;
struct snd_minor *preg;
//add xiao
struct snd_pcm *pcm=NULL;
pcm=private_data;
DEBUG_I("snd_register_device pcm type=%d device number:%d pcm->name=%s \n", type,dev,pcm->name);//xiao
if (snd_BUG_ON(!device))
return -EINVAL;
preg = kmalloc(sizeof *preg, GFP_KERNEL);
if (preg == NULL)
return -ENOMEM;
preg->type = type;
preg->card = card ? card->number : -1;
preg->device = dev;
preg->f_ops = f_ops;
preg->private_data = private_data;
preg->card_ptr = card;
mutex_lock(&sound_mutex);
//全局数组snd_minors 的情况分配minor
minor = snd_find_free_minor(type, card, dev);
if (minor < 0) {
err = minor;
goto error;
}
preg->dev = device;
device->devt = MKDEV(major, minor);
err = device_add(device);//注册到设备总线上
if (err < 0)
goto error;
snd_minors[minor] = preg;//更新snd_minors数组,snd_minors数组是由 pcm.c snd_pcm_dev_register
error:
mutex_unlock(&sound_mutex);
if (err < 0)
kfree(preg);
return err;
}- 2.9 snd_pcm_f_ops
const struct file_operations snd_pcm_f_ops[2] = {
{
.owner = THIS_MODULE,
.write = snd_pcm_write,
.write_iter = snd_pcm_writev,
.open = snd_pcm_playback_open,
.release = snd_pcm_release,
.llseek = no_llseek,
.poll = snd_pcm_playback_poll,
.unlocked_ioctl = snd_pcm_playback_ioctl,
.compat_ioctl = snd_pcm_ioctl_compat,
.mmap = snd_pcm_mmap,
.fasync = snd_pcm_fasync,
.get_unmapped_area = snd_pcm_get_unmapped_area,
},
{
.owner = THIS_MODULE,
.read = snd_pcm_read,
.read_iter = snd_pcm_readv,
.open = snd_pcm_capture_open,
.release = snd_pcm_release,
.llseek = no_llseek,
.poll = snd_pcm_capture_poll,
.unlocked_ioctl = snd_pcm_capture_ioctl,
.compat_ioctl = snd_pcm_ioctl_compat,
.mmap = snd_pcm_mmap,
.fasync = snd_pcm_fasync,
.get_unmapped_area = snd_pcm_get_unmapped_area,
}
};
上面有两个比较重要的数据snd_pcm_f_ops和snd_minors ，snd_pcm_f_ops的操作函数主要用于上层调用，看函数就清楚，open，read，writer等。
snd_minors 也是用于上层open调用底层驱动的回调，具体怎么调用，如下代码。就是当上层录音或者播放会调用 open ( open("/dev/snd/pcmC%0D%2%c", O_RDWR|O_NONBLOCK))，open函数会调用snd_open,根据传递的inode 可以从snd_minors数组里面获得之前存储的snd_minor实例，snd_minor结构体有f_ops，再把f_ops替换file的open。
snd_minor结构体f_ops又是哪里来的呢？就是前面snd_pcm_f_ops，具体的赋值流程可以查看snd_register_device函数，所以上层播放和录音调用open函数最终会调用snd_pcm_f_ops的操作函数
static int snd_open(struct inode *inode, struct file *file)
{
unsigned int minor = iminor(inode);
struct snd_minor *mptr = NULL;
//add xiao
struct snd_pcm *pcm=NULL;
const struct file_operations *new_fops;
int err = 0;
if (minor >= ARRAY_SIZE(snd_minors))
return -ENODEV;
mutex_lock(&sound_mutex);
mptr = snd_minors[minor];//获取与次设备号相关联的snd_minor结构体指针
if (mptr == NULL) {
//如果设备未挂载自动装载
mptr = autoload_device(minor);
if (!mptr) {
mutex_unlock(&sound_mutex);
return -ENODEV;
}
}
//add xiao
pcm=mptr->private_data;
DEBUG_I("snd_open device =%d ,dev->name=%s , pcm type:%d\n",mptr->device,pcm->name,mptr->type);//xiao
new_fops = fops_get(mptr->f_ops);// 取出mptr的file_operations
mutex_unlock(&sound_mutex);
if (!new_fops)
return -ENODEV;
replace_fops(file, new_fops);// 替换字符设备的file_operations
if (file->f_op->open)
err = file->f_op->open(inode, file);// 调用字符设备驱动的open()方法
return err;
}
1071
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
