本文转载:https://www.cnblogs.com/xinghuo123/p/13121108.html
1、 alsa的简单介绍
ALSA是Advanced Linux Sound Architecture 的缩写,目前已经成为了linux的主流音频体系结构。
在内核设备驱动层,ALSA提供了alsa-driver,同时在应用层,ALSA为我们提供了alsa-lib,应用程序只要调用alsa-lib提供的API,即可以完成对底层音频硬件的控制。linux内核中alsa的软件结构如下:
用户空间的alsa-lib对应用程序提供统一的API接口,这样可以隐藏了驱动层的实现细节,简化了应用程序的实现难度,内核空间中,alsa-soc其实是对alsa-driver的进一步封装,他针对嵌入式设备提供了一些列增强的功能。
1.1 alsa的设备文件结构
1 $ cd /dev/snd
2 $ ls -l
3 crw-rw----+ 1 root audio 116, 8 2011-02-23 21:38 controlC0
4 crw-rw----+ 1 root audio 116, 4 2011-02-23 21:38 midiC0D0
5 crw-rw----+ 1 root audio 116, 7 2011-02-23 21:39 pcmC0D0c
6 crw-rw----+ 1 root audio 116, 6 2011-02-23 21:56 pcmC0D0p
7 crw-rw----+ 1 root audio 116, 5 2011-02-23 21:38 pcmC0D1p
8 crw-rw----+ 1 root audio 116, 3 2011-02-23 21:38 seq
9 crw-rw----+ 1 root audio 116, 2 2011-02-23 21:38 timer
可以看到以下设备文件:
1 controlC0 --> 用于声卡的控制,例如通道选择,混音,麦克控制,音量加减,开关等
2 midiC0D0 --> 用于播放midi音频
3 pcmC0D0c --> 用于录音的pcm设备
4 pcmC0D0p --> 用于播放的pcm设备
5 seq --> 音序器
6 timer --> 定时器
其中,C0D0代表的是声卡0中的设备0,pcmC0D0c最后一个c代表capture,pcmC0D0p最后一个p代表playback,这些都是alsa-driver中的命名规则,从上面的列表可以看出,我的声卡下挂了6个设备,根据声卡的实际能力,驱动实际上可以挂上更多种类的设备,在include/sound/core.h中,定义了以下设备类型,通常更关心的是pcm和control这两种设备.。
1 #define SNDRV_DEV_TOPLEVEL ((__force snd_device_type_t) 0)
2 #define SNDRV_DEV_CONTROL ((__force snd_device_type_t) 1)
3 #define SNDRV_DEV_LOWLEVEL_PRE ((__force snd_device_type_t) 2)
4 #define SNDRV_DEV_LOWLEVEL_NORMAL ((__force snd_device_type_t) 0x1000)
5 #define SNDRV_DEV_PCM ((__force snd_device_type_t) 0x1001)
6 #define SNDRV_DEV_RAWMIDI ((__force snd_device_type_t) 0x1002)
7 #define SNDRV_DEV_TIMER ((__force snd_device_type_t) 0x1003)
8 #define SNDRV_DEV_SEQUENCER ((__force snd_device_type_t) 0x1004)
9 #define SNDRV_DEV_HWDEP ((__force snd_device_type_t) 0x1005)
10 #define SNDRV_DEV_INFO ((__force snd_device_type_t) 0x1006)
11 #define SNDRV_DEV_BUS ((__force snd_device_type_t) 0x1007)
12 #define SNDRV_DEV_CODEC ((__force snd_device_type_t) 0x1008)
13 #define SNDRV_DEV_JACK ((__force snd_device_type_t) 0x1009)
14 #define SNDRV_DEV_COMPRESS ((__force snd_device_type_t) 0x100A)
15 #define SNDRV_DEV_LOWLEVEL ((__force snd_device_type_t) 0x2000)
1.2 linux/sound 下alsa目录
各主要子目录的作用:
1 core 该目录包含了ALSA驱动的中间层,它是整个ALSA驱动的核心部分
2 core/oss 包含模拟旧的OSS架构的PCM和Mixer模块
3 core/seq 有关音序器相关的代码
4 include ALSA驱动的公共头文件目录,该目录的头文件需要导出给用户空间的应用程序使用,通常,驱动模块私有的头文件不应放置在这里
5 drivers 放置一些与CPU、BUS架构无关的公用代码
6 i2c ALSA自己的I2C控制代码
7 pci pci声卡的顶层目录,子目录包含各种pci声卡的代码
8 isa isa声卡的顶层目录,子目录包含各种isa声卡的代码
9 soc 针对system-on-chip体系的中间层代码
10 soc/codecs 针对soc体系的各种codec的代码,与平台无关
2、 声卡结构体
2.1 结构体snd_card
snd_
card可以说是整个ALSA音频驱动最顶层的一个结构,整个声卡的软件逻辑结构开始于该结构,几乎所有与声音相关的逻辑设备都是在snd_card的管理之下,声卡驱动的第一个动作通常就是创建一个snd_card结构体
// m6225_android13.0_r01_r003/target/kernel_platform/common/include/sound/core.h
struct snd_card {
int number; /* number of soundcard (index to //soundcard的序号,通常为0
snd_cards) */
char id[16]; /* id string of this card */ //card的标识符,通常是字符串形式。
char driver[16]; /* driver name */
char shortname[32]; /* short name of this soundcard */
char longname[80]; /* name of this soundcard */ //会在具体驱动中设置,主要反映在/proc/asound/cards中
char irq_descr[32]; /* Interrupt description */
char mixername[80]; /* mixer name */
char components[128]; /* card components delimited with
space */
struct module *module; /* top-level module */
void *private_data; /* private data for soundcard */ //声卡的私有数据,可以在创建声卡时通过参数指定数据的大小
void (*private_free) (struct snd_card *card); /* callback for freeing of
private data */
struct list_head devices; /* devices */// 记录该声卡下所有逻辑设备的链表
struct device ctl_dev; /* control device */
unsigned int last_numid; /* last used numeric ID */
struct rw_semaphore controls_rwsem; /* controls list lock */
rwlock_t ctl_files_rwlock; /* ctl_files list lock */
int controls_count; /* count of all controls */
size_t user_ctl_alloc_size; // current memory allocation by user controls.
struct list_head controls; /* all controls for this card */ //记录该声卡下所有控制单元的链表
struct list_head ctl_files; /* active control files */ //用于管理该card下的active的control设备
#ifdef CONFIG_SND_CTL_FAST_LOOKUP
struct xarray ctl_numids; /* hash table for numids */
struct xarray ctl_hash; /* hash table for ctl id matching */
bool ctl_hash_collision; /* ctl_hash collision seen? */
#endif
struct snd_info_entry *proc_root; /* root for soundcard specific files */
struct proc_dir_entry *proc_root_link; /* number link to real id */
struct list_head files_list; /* all files associated to this card */
struct snd_shutdown_f_ops *s_f_ops; /* file operations in the shutdown
state */
spinlock_t files_lock; /* lock the files for this card */
int shutdown; /* this card is going down */
struct completion *release_completion;
struct device *dev; /* device assigned to this card */ //和card相关的设备
struct device card_dev; /* cardX object for sysfs */ //card用于在sys中显示,用于代表该card
const struct attribute_group *dev_groups[4]; /* assigned sysfs attr */
bool registered; /* card_dev is registered? */
bool managed; /* managed via devres */
bool releasing; /* during card free process */
int sync_irq; /* assigned irq, used for PCM sync */
wait_queue_head_t remove_sleep;
size_t total_pcm_alloc_bytes; /* total amount of allocated buffers */
struct mutex memory_mutex; /* protection for the above */
#ifdef CONFIG_SND_DEBUG
struct dentry *debugfs_root; /* debugfs root for card */
#endif
#ifdef CONFIG_PM
unsigned int power_state; /* power state */
atomic_t power_ref;
wait_queue_head_t power_sleep;
wait_queue_head_t power_ref_sleep;
#endif
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
struct snd_mixer_oss *mixer_oss;
int mixer_oss_change_count;
#endif
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};
snd_card的driver字段保存着芯片的ID字符串,user空间的alsa-lib会使用到该字符串,所以必须要保证该ID的唯一性.shortname字段更多地用于打印信息,longname字段则会出现在/proc/asound/cards中。
3、 声卡的创建
3.1 声卡创建函数snd_card_new
// sm6225_android13.0_r01_r003/target/kernel_platform/msm-kernel/sound/core/init.c
/**
* snd_card_new - create and initialize a soundcard structure
* @parent: the parent device object
* @idx: card index (address) [0 ... (SNDRV_CARDS-1)] // [0 ... (SNDRV_CARDS-1)]//一个整数值,该声卡的编号
* @xid: card identification (ASCII string) //字符串,声卡的标识符
* @module: top level module for locking
* @extra_size: allocate this extra size after the main soundcard structure //该参数决定在创建snd_card实例时,需要同时额外分配的私有数据的大小,该数据的指针最终会赋值给snd_card的private_data数据成员
* @card_ret: the pointer to store the created card instance //返回所创建的snd_card实例的指针
*
* The function allocates snd_card instance via kzalloc with the given
* space for the driver to use freely. The allocated struct is stored
* in the given card_ret pointer.
*
* Return: Zero if successful or a negative error code.
*/
int snd_card_new(struct device *parent, int idx, const char *xid,
struct module *module, int extra_size,
struct snd_card **card_ret)
{
struct snd_card *card; //创建一个声卡结构体 声卡实例
int err;
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); //根据extra_size参数的大小分配内存,该内存区可以作为芯片的专有数据使用
if (!card)
return -ENOMEM;
err = snd_card_init(card, parent, idx, xid, module, extra_size); //调用snd_card_init 按照传过来的参数初始化结构体
if (err < 0) {
kfree(card);
return err;
}
*card_ret = card;
return 0;
}
EXPORT_SYMBOL(snd_card_new);
// 按照传过来的参数初始化结构体
static int snd_card_init(struct snd_card *card, struct device *parent,
int idx, const char *xid, struct module *module,
size_t extra_size)
{
int err;
#ifdef CONFIG_SND_DEBUG
char name[8];
#endif
if (extra_size > 0)
card->private_data = (char *)card + sizeof(struct snd_card);
if (xid)
strscpy(card->id, xid, sizeof(card->id)); //拷贝声卡的ID字符串 类似声卡name
err = 0;
mutex_lock(&snd_card_mutex);
if (idx < 0) /* first check the matching module-name slot */
idx = get_slot_from_bitmask(idx, module_slot_match, module); //判断传入的声卡ID是否大于0 ,否则按顺序自动分配cardID
if (idx < 0) /* if not matched, assign an empty slot */
idx = get_slot_from_bitmask(idx, check_empty_slot, module);
if (idx < 0) //俩次都没有自动分配好ID,直接返回错误
err = -ENODEV;
else if (idx < snd_ecards_limit) { //snd_ecards_limit = 1
if (test_bit(idx, snd_cards_lock))
err = -EBUSY; /* invalid */
} else if (idx >= SNDRV_CARDS) //大于最大声卡编号,SNDRV_CARDS=8 说明最多注册8个声卡
err = -ENODEV;
if (err < 0) {
mutex_unlock(&snd_card_mutex);
dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
idx, snd_ecards_limit - 1, err);
return err;
}
//以上都是看声卡ID是否分配正常
set_bit(idx, snd_cards_lock); /* lock it */
if (idx >= snd_ecards_limit)
snd_ecards_limit = idx + 1; /* increase the limit */
mutex_unlock(&snd_card_mutex);
/*初始化snd_card结构中必要的字段*/
card->dev = parent;
card->number = idx;
#ifdef MODULE
WARN_ON(!module);
card->module = module;
#endif
INIT_LIST_HEAD(&card->devices);
init_rwsem(&card->controls_rwsem);
rwlock_init(&card->ctl_files_rwlock);
INIT_LIST_HEAD(&card->controls);
INIT_LIST_HEAD(&card->ctl_files);
#ifdef CONFIG_SND_CTL_FAST_LOOKUP
xa_init(&card->ctl_numids);
xa_init(&card->ctl_hash);
#endif
spin_lock_init(&card->files_lock);
INIT_LIST_HEAD(&card->files_list);
mutex_init(&card->memory_mutex);
#ifdef CONFIG_PM
init_waitqueue_head(&card->power_sleep);
init_waitqueue_head(&card->power_ref_sleep);
atomic_set(&card->power_ref, 0);
#endif
init_waitqueue_head(&card->remove_sleep);
card->sync_irq = -1;
device_initialize(&card->card_dev);
card->card_dev.parent = parent;
card->card_dev.class = sound_class;
card->card_dev.release = release_card_device;
card->card_dev.groups = card->dev_groups;
card->dev_groups[0] = &card_dev_attr_group;
err = kobject_set_name(&card->card_dev.kobj, "card%d", idx);
if (err < 0)
goto __error;
snprintf(card->irq_descr, sizeof(card->irq_descr), "%s:%s",
dev_driver_string(card->dev), dev_name(&card->card_dev));
/* 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); //建立逻辑设备:Control
if (err < 0) {
dev_err(parent, "unable to register control minors\n");
goto __error;
}
err = snd_info_card_create(card); //建立proc文件中的info节点:通常就是/proc/asound/card0
if (err < 0) {
dev_err(parent, "unable to create card info\n");
goto __error_ctl;
}
#ifdef CONFIG_SND_DEBUG
sprintf(name, "card%d", idx);
card->debugfs_root = debugfs_create_dir(name, sound_debugfs_root);
#endif
return 0;
__error_ctl:
snd_device_free_all(card);
__error:
put_device(&card->card_dev);
return err;
}
3.2 声卡的注册snd_card_register()
定义位于:在/sound/core/init.c中
/**
* snd_card_register - register the soundcard
* @card: soundcard structure
*
* This function registers all the devices assigned to the soundcard.
* Until calling this, the ALSA control interface is blocked from the
* external accesses. Thus, you should call this function at the end
* of the initialization of the card.
*
* Return: Zero otherwise a negative error code if the registration failed.
*/
int snd_card_register(struct snd_card *card) //参数为之前snd_card_init之后的snd_card结构体
{
int err;
if (snd_BUG_ON(!card))
return -EINVAL;
if (!card->registered) {
err = device_add(&card->card_dev); //创建sysfs下的设备dev/*Kobject.name dev/sound
if (err < 0)
return err;
card->registered = true;
} else {
if (card->managed)
devm_remove_action(card->dev, trigger_card_free, card);
}
if (card->managed) { //添加card资源控制 trigger_card_free就是释放snd_card所有资源
err = devm_add_action(card->dev, trigger_card_free, card);
if (err < 0)
return err;
}
/*注册所有挂在该声卡下的逻辑设备,snd_device_register_all()实际上是通过snd_card的devices链表,遍历所有的snd_device,并且调用snd_device的ops->dev_register()来实现各自设备的注册的*/
err = snd_device_register_all(card);
/* for __snd_device_register
|
------ dev->ops->dev_register(card->devices);*/
if (err < 0)
return err;
mutex_lock(&snd_card_mutex);
if (snd_cards[card->number]) {
/* already registered */
mutex_unlock(&snd_card_mutex);
return snd_info_card_register(card); /* register pending info */
}
if (*card->id) {
/* make a unique id name from the given string */
char tmpid[sizeof(card->id)];
memcpy(tmpid, card->id, sizeof(card->id));
snd_card_set_id_no_lock(card, tmpid, tmpid);
} else {
/* create an id from either shortname or longname */
const char *src;
src = *card->shortname ? card->shortname : card->longname;
snd_card_set_id_no_lock(card, src,
retrieve_id_from_card_name(src));
}
snd_cards[card->number] = card;
mutex_unlock(&snd_card_mutex);
err = snd_info_card_register(card); //创建proc下的一些文件节点 实际调用proc_create_data
if (err < 0)
return err;
#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
if (snd_mixer_oss_notify_callback)
snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER);
#endif
return 0;
}
EXPORT_SYMBOL(snd_card_register);
3.3 sound_class创建
//sm6225_android13.0_r01_r003/target/kernel_platform/msm-kernel/sound/sound_core.c
static int __init init_soundcore(void)
{
int rc;
rc = init_oss_soundcore();
if (rc)
return rc;
sound_class = class_create(THIS_MODULE, "sound");
if (IS_ERR(sound_class)) {
cleanup_oss_soundcore();
return PTR_ERR(sound_class);
}
sound_class->devnode = sound_devnode;
return 0;
}
subsys_initcall(init_soundcore);
module_exit(cleanup_soundcore);
sound_devnode的定义:
static char *sound_devnode(struct device *dev, umode_t *mode)
{
if (MAJOR(dev->devt) == SOUND_MAJOR)
return NULL;
return kasprintf(GFP_KERNEL, "snd/%s", dev_name(dev));
}
subsys_initcall 与module_init类似(subsys_initcall与module_init仅仅是__define_initcall的第二个参数不同而已,前者使用4,后者使用6,因此归纳出仅仅是谁先被执行的差异 module_init可以以.ko模块加载 __define_initcall是内置加载模块并且按参数的大小加载)
也就是说在sound_core这个模块加载的时候就会调用init_soundcore注册class sys/class/snd/%s(dev_name)
3.4 创建声卡的各种部件
主要包括:pcm 、mixer、MIDI等。之前snd_card结构体的devices字段,每一种部件的创建最终会调用snd_device_new()来生成一个snd_device实例,并把该实例链接到snd_card的devices链表中.。
通常,alsa-driver的已经提供了一些常用的部件的创建函数,而不必直接调用snd_device_new(),如下
在snd_card_register 调用snd_device_register_all 注册这些snd_device
1 PCM ---- snd_pcm_new()
2 RAWMIDI -- snd_rawmidi_new()
3 CONTROL -- snd_ctl_create()
4 TIMER -- snd_timer_new()
5 INFO -- snd_card_proc_new()
6 JACK -- snd_jack_new()
创建之后声卡的逻辑结构如下:
4 、声卡初始化
定义位于:sound\core\sound.c
sonud.c的入口函数:
申请一个字符设备的主设备号。control、pcm等逻辑设备都是这个主设备号下的次设备。
/*
* INIT PART
*/
static int __init alsa_sound_init(void)
{
snd_major = major;
snd_ecards_limit = cards_limit;
if (register_chrdev(major, "alsa", &snd_fops)) { //注册chr设备即声卡的主设备号,其他声卡设备都是其下的次设备 并创建该设备file_operations 实现文件操作
pr_err("ALSA core: unable to register native major device number %d\n", major);
return -EIO;
}
if (snd_info_init() < 0) {
unregister_chrdev(major, "alsa");
return -ENOMEM;
}
#ifdef CONFIG_SND_DEBUG
sound_debugfs_root = debugfs_create_dir("sound", NULL);
#endif
#ifndef MODULE
pr_info("Advanced Linux Sound Architecture Driver Initialized.\n");
#endif
return 0;
}
次设备共用一个open接口,然后根据下面的全局数组snd_minors找到相应的次设备文件操作结构体,分别调用相应次设备的open函数。snd_fops的定义:
static const struct file_operations snd_fops =
{
.owner = THIS_MODULE,
.open = snd_open,
.llseek = noop_llseek,
};
static int snd_open(struct inode *inode, struct file *file)
{
unsigned int minor = iminor(inode);
struct snd_minor *mptr = 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];
if (mptr == NULL) {
mptr = autoload_device(minor);
if (!mptr) {
mutex_unlock(&sound_mutex);
return -ENODEV;
}
}
new_fops = fops_get(mptr->f_ops);
mutex_unlock(&sound_mutex);
if (!new_fops)
return -ENODEV;
replace_fops(file, new_fops);
if (file->f_op->open)
err = file->f_op->open(inode, file);
return err;
}
snd_minors是定义在sound.c中的全局变量,表示主设备号下的次设备比如control、pcm设备等,inode作为snd_minors的下表,找到对应的次设备。
static struct snd_minor *snd_minors[SNDRV_OS_MINORS];
// 结构体定义,包含设备类型、声卡编号、设备
1 struct snd_minor {
2 int type; /* SNDRV_DEVICE_TYPE_XXX */
3 int card; /* card number */
4 int device; /* device number */
5 const struct file_operations *f_ops; /* file operations */
6 void *private_data; /* private data for f_ops->open */
7 struct device *dev; /* device for sysfs */
8 struct snd_card *card_ptr; /* assigned card instance */
9 }
设备类型:
定义位于:include\sound\minors.h
enum {
SNDRV_DEVICE_TYPE_CONTROL,
SNDRV_DEVICE_TYPE_SEQUENCER,
SNDRV_DEVICE_TYPE_TIMER,
SNDRV_DEVICE_TYPE_HWDEP,
SNDRV_DEVICE_TYPE_RAWMIDI,
SNDRV_DEVICE_TYPE_PCM_PLAYBACK,
SNDRV_DEVICE_TYPE_PCM_CAPTURE,
SNDRV_DEVICE_TYPE_COMPRESS,
};
这样只要调用open(sys/class/snd/XXX) (次设备号,file_ops)就可以操作到对应的pcm control等子设备
这节讲解了snd_card 的init register 以及class的创建以及file_ops open函数操作子设备的原理。