前面已经写过PCM 实例的创建框架，我们现在来看看PCM 实例是如何创建的。
在调用snd_pcm_new时就会创建一个snd_pcm类型的PCM 实例.
struct snd_pcm {
struct snd_card *card;//PCM device 说挂载的声卡
struct list_head list;//一个Card可能有多个PCM 实例，PCM 实例列表
int device; /* device number *///PCM 实例的索引
unsigned int info_flags;
unsigned short dev_class;
unsigned short dev_subclass;
char id[64];
char name[80];
struct snd_pcm_str streams[2];//PCM的playback和capture stream
struct mutex open_mutex;
wait_queue_head_t open_wait;
void *private_data;//private_data一般为芯片专用信息
void (*private_free) (struct snd_pcm *pcm);//用来释放private_data
bool internal; /* pcm is for internal use only */
bool nonatomic; /* whole PCM operations are in non-atomic context */
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
struct snd_pcm_oss oss;
#endif
};
接下来我们来看看在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 = {//device的操作函数
.dev_free = snd_pcm_dev_free,
.dev_register = snd_pcm_dev_register,//在device rigister调用
.dev_disconnect = snd_pcm_dev_disconnect,
};
if (snd_BUG_ON(!card))
return -ENXIO;
if (rpcm)
*rpcm = NULL;
pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);//为PCM 实例创建空间
if (!pcm)
return -ENOMEM;
pcm->card = card;//将声卡保存在PCM 实例中
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));
if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_PLAYBACK, playback_count)) < 0) {//为PCM 实例创建playback stream
snd_pcm_free(pcm);
return err;
}
if ((err = snd_pcm_new_stream(pcm, SNDRV_PCM_STREAM_CAPTURE, capture_count)) < 0) {//为PCM 实例创建capture stream
snd_pcm_free(pcm);
return err;
}
if ((err = snd_device_new(card, SNDRV_DEV_PCM, pcm, &ops)) < 0) {//以PCM 实例创建snd_device并挂载到Card上。
snd_pcm_free(pcm);
return err;
}
if (rpcm)
*rpcm = pcm;
return 0;
}
一个PCM 实例分别有一个playback, capture stream,由snd_pcm_new_stream创建。
playback 和capture stream是一个snd_pcm_str的结构体，
struct snd_pcm_str {
int stream; /* stream (direction) *///是playback stream or capture stream
struct snd_pcm *pcm;//当前的PCM 实例
/* -- substreams -- */
unsigned int substream_count;//substream的数目。
unsigned int substream_opened;//已经open的substream数目。每次open +1,close -1.
struct snd_pcm_substream *substream;//playback stream or capture stream的substream链表
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
/* -- OSS things -- */
struct snd_pcm_oss_stream oss;
#endif
#ifdef CONFIG_SND_VERBOSE_PROCFS
struct snd_info_entry *proc_root;
struct snd_info_entry *proc_info_entry;
#ifdef CONFIG_SND_PCM_XRUN_DEBUG
unsigned int xrun_debug; /* 0 = disabled, 1 = verbose, 2 = stacktrace */
struct snd_info_entry *proc_xrun_debug_entry;
#endif
#endif
struct snd_kcontrol *chmap_kctl; /* channel-mapping controls */
struct device dev;//stream的device结构
};
substream的结构体snd_pcm_substream ：
struct snd_pcm_substream {
struct snd_pcm *pcm;//PCM 实例
struct snd_pcm_str *pstr;//playback stream or substream
void *private_data; /* copied from pcm->private_data *///private_data通常是和PCM 实例的private data相同。
int number;//当前substream的index
char name[32]; /* substream name */
int stream; /* stream (direction) *///是playback or capture的substream
struct pm_qos_request latency_pm_qos_req; /* pm_qos request */
size_t buffer_bytes_max; /* limit ring buffer size *///最大的buffer size
struct snd_dma_buffer dma_buffer;//DMA buffer
size_t dma_max;
/* -- hardware operations -- */
const struct snd_pcm_ops *ops;//substream的操作函数,在创建完PCM 实例后，调用snd_pcm_set_ops设置PCM实例playback stream的每一个substream的操作函数。
/* -- runtime information -- */
struct snd_pcm_runtime *runtime;//runtime信息
/* -- timer section -- */
struct snd_timer *timer; /* timer */
unsigned timer_running: 1; /* time is running */
/* -- next substream -- */
struct snd_pcm_substream *next;
/* -- linked substreams -- */
struct list_head link_list; /* linked list member */
struct snd_pcm_group self_group; /* fake group for non linked substream (with substream lock inside) */
struct snd_pcm_group *group; /* pointer to current group */
/* -- assigned files -- */
void *file;
int ref_count;
atomic_t mmap_count;
unsigned int f_flags;
void (*pcm_release)(struct snd_pcm_substream *);
struct pid *pid;
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
/* -- OSS things -- */
struct snd_pcm_oss_substream oss;
#endif
#ifdef CONFIG_SND_VERBOSE_PROCFS
struct snd_info_entry *proc_root;
struct snd_info_entry *proc_info_entry;
struct snd_info_entry *proc_hw_params_entry;
struct snd_info_entry *proc_sw_params_entry;
struct snd_info_entry *proc_status_entry;
struct snd_info_entry *proc_prealloc_entry;
struct snd_info_entry *proc_prealloc_max_entry;
#ifdef CONFIG_SND_PCM_XRUN_DEBUG
struct snd_info_entry *proc_xrun_injection_entry;
#endif
#endif /* CONFIG_SND_VERBOSE_PROCFS */
/* misc flags */
unsigned int hw_opened: 1;
};
/**
* snd_pcm_new_stream - create a new PCM stream
* @pcm: the pcm instance
* @stream: the stream direction, SNDRV_PCM_STREAM_XXX
* @substream_count: the number of substreams
*/
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];//当前的playback stream or capture 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);
pstr->dev.groups = pcm_dev_attr_groups;
dev_set_name(&pstr->dev, "pcmC%iD%i%c", pcm->card->number, pcm->device, stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');//playback stream的名字
if (!pcm->internal) {
err = snd_pcm_stream_proc_init(pstr);//将playback stream挂到/proc目录下，我们通过cat可以查看。
if (err < 0) {
pcm_err(pcm, "Error in snd_pcm_stream_proc_init
");
return err;
}
}
prev = NULL;
for (idx = 0, prev = NULL; idx < substream_count; idx++) {//一个playback stream下可有多个substream，创建substream
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;
if (prev == NULL)//将substream链接到playback stream的substream成员中。
pstr->substream = substream;
else
prev->next = substream;
if (!pcm->internal) {
err = snd_pcm_substream_proc_init(substream);//将substream挂到/proc下。
if (err < 0) {
pcm_err(pcm,"Error in snd_pcm_stream_proc_init
");
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;
}
在创建完PCM device后，调用snd_device_new(card, SNDRV_DEV_PCM, pcm, &ops)以PCM 实例创建device 并挂载到card上。
在snd_device_new函数中创建一个snd_device结构，并将此结构加到card的device list中。
在注册card时（调用snd_card_register）,就会对card的devcie list中每个device进行注册。
device的注册即调用snd_device_new(card, SNDRV_DEV_PCM, pcm, &ops)函数中最后一个参数的dev_register.
snd_device的dev_register是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;//snd_device的device_data即PCM实例，是在snd_device_new时将pcm赋值给device_data
if (pcm->internal)
return 0;
mutex_lock(®ister_mutex);
err = snd_pcm_add(pcm);
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 */
err = snd_register_device(devtype, pcm->card, pcm->device,&snd_pcm_f_ops[cidx], pcm,&pcm->streams[cidx].dev);//注册device, device是pcm实例的playback stream的device。device的操作函数为snd_pcm_f_ops.
if (err < 0) {
list_del_init(&pcm->list);
goto unlock;
}
for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
snd_pcm_timer_init(substream);//初始化每个substream 的timer
}
list_for_each_entry(notify, &snd_pcm_notify_list, list)
notify->n_register(pcm);
unlock:
mutex_unlock(®ister_mutex);
return err;
}
snd_register_device将pcm->streams[cidx].dev(即name为pcmC*D*p的device，在snd_pcm_new_stream创建和指定名字）注册到device 目录中，并创建snd_minor结构体，snd_pcm_f_ops赋值给snd_minor结构体的f_ops，然后加到snd_minors的数组中。找到一个可用的minor，和major（固定是116）组成pcm->streams[cidx].dev这个device的设备号，将设备device_add()加到系统中。
App在调用alsa lib API: snd_pcm_open打开name为pcmC*D*p的device时，就会调用到alsa-core中的snd_open（pcmC*D*p的major和"alsa"字符设备驱动都是116），在snd_open中通过PCM 实例的 inode找到snd_minor结构，并调用snd_minor结构的操作函数（即snd_pcm_f_ops）的open函数。
alsa lib其他API都是在open，获取driver 文件后，通过ioctl到达snd_pcm_f_ops对应的操作函数。
pcm实例的playback stream的device的操作函数：
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,
}
};
