SM6225 ASLA详解（一）

本文转载：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函数操作子设备的原理。