瑞芯微-I2S | ALSA基础-3

针对音频设备，linux内核中包含了两类音频设备驱动框架；

OSS：开放声音系统

包含dsp和mixer字符设备接口，应用访问底层硬件是直接通过sound设备节点实现的；
ALSA：先进linux声音架构（Advanced Linux Sound Archiecture）

以card和组件（PCM、mixer等）为组件，应用是通过ALSA提供的alsa-lib库访问底层硬件的操作，不再访问sound设备节点了

1.ALSA概述

ALSA由一系列的内核驱动、应用程序编程接口（API）以及支持linux下声音的应用程序组成、

ALSA项目发起的原因是linux下的声卡驱动（OSS）没有获得积极的维护，而且落后于新的声卡技术。

Jaroslav Kysela早先写了一个声卡驱动，并由此开始了ALSA项目，随后，更多的开发者加入到开发队伍中，更多的声卡获得支持，API的结构也获得了重组。目前已经成为了linux的主流音频体系结构。

ALSA的官网：

https://www.alsa-project.org/wiki/Main_Page

2. ALSA组件

ALSA系统包括：

1、alsa-driver：alsa系统驱动。
2、alsa-lib：alsa库，用户空间调用，和内核空间交互。
3、alsa-utils：命令行工具。
4、alsa-plugin：alsa插件。
5、alsa-tools：alsa工具。

在应用层，ALSA 为我们提供了 alsa-lib，在 Linux 内核设备驱动层，ALSA 提供了 alsa-driver。

Linux 应用程序只需要调用 alsa-lib 提供的 API，即可完成对底层音频硬件的控制。

linux内核中alsa的软件结构如下：

用户空间的 alsa-lib 对应用程序提供统一的 API 接口，隐藏了驱动层的实际细节，简化了应用程序的实现难度

但是由于 alsa-lib 也由于过大，因此在 android 等下也经常使用 tiny-alsa。

如上图所示，在 Linux 内核中，有对 alsa-driver 进一步的封装，即 alsa-soc。

ALSA框架从上到下依次为应用程序、ALSA Library API、ALSA CORE、ASoC CORE、硬件驱动程序、硬件设备；

应用程序：

tinyplay/tinycap/tinymix，这些用户程序直接调用alsa用户库接口来实现放音、录音、控制；
ALSA Library API：

alsa用户库接口，对应用程序提供统一的API接口，这样可以隐藏了驱动层的实现细节，简化了应用程序的实现难度；常见有tinyalsa、alsa-lib；
ALSA CORE：

alsa核心层，向上提供逻辑设备（PCM/CTL/MIDI/TIMER/…）系统调用，向下驱动硬件设备（Machine/I2S/DMA/CODEC）；
ASoC CORE：

建立在标准ALSA CORE基础上，为了更好支持嵌入式系统和应用于移动设备的音频Codec的一套软件体系，它将音频硬件设备驱动划分为Codec、Platform 和 Machine；
Hardware Driver：

音频硬件设备驱动，由三大部分组成，分别是 Machine、Platform、Codec；

3. ALSA 设备文件

Linux 系统下看到的设备文件结构如下：

rk3568_r:/ # cd /dev/snd/

rk3568_r:/dev/snd # ls -l

total 0

crw-rw---- 1 system audio 116,   4 2024-02-18 15:28 controlC0

crw-rw---- 1 system audio 116,   6 2024-02-18 15:28 controlC1

crw-rw---- 1 system audio 116,   3 2024-02-18 15:28 pcmC0D0c

crw-rw---- 1 system audio 116,   2 2024-02-18 15:28 pcmC0D0p

crw-rw---- 1 system audio 116,   5 2024-02-18 15:28 pcmC1D0p

crw-rw---- 1 system audio 116,  33 2024-02-18 15:28 timer

从上面能看到有如下设备文件：

controlC0 -->              用于声卡的控制,例如通道选择,混音,麦克控制，音量加减，开关等

controlC1

pcmC0D0c -->               用于录音的pcm设备

pcmC0D0p -->               用于播放的pcm设备

pcmC1D0p

timer    -->               定时器

有的平台还有以下设备节点：

midiC0D0  -->              用于播放midi音频

seq      -->               音序器

其中,C0、D0代表的是声卡0中的设备0

pcmC0D0c最后一个c代表capture

pcmC0D0p最后一个p代表playback

这些都是alsa-driver中的命名规则，从上面的列表可以看出,声卡下挂了6个设备

根据声卡的实际能力，驱动实际上可以挂载更多种类的设备，在include/sound/core.h 中,定义了以下设备类型，通常更关心的是 pcm 和 control 这两种设备，Default 一个声卡对应一个 Control 设备。

#define    SNDRV_DEV_TOPLEVEL    ((__force snd_device_type_t) 0)

#define    SNDRV_DEV_CONTROL    ((__force snd_device_type_t) 1)

#define    SNDRV_DEV_LOWLEVEL_PRE    ((__force snd_device_type_t) 2)

#define    SNDRV_DEV_LOWLEVEL_NORMAL ((__force snd_device_type_t) 0x1000)

#define    SNDRV_DEV_PCM        ((__force snd_device_type_t) 0x1001)

#define    SNDRV_DEV_RAWMIDI    ((__force snd_device_type_t) 0x1002)

#define    SNDRV_DEV_TIMER        ((__force snd_device_type_t) 0x1003)

#define    SNDRV_DEV_SEQUENCER    ((__force snd_device_type_t) 0x1004)

#define    SNDRV_DEV_HWDEP        ((__force snd_device_type_t) 0x1005)

#define    SNDRV_DEV_INFO        ((__force snd_device_type_t) 0x1006)

#define    SNDRV_DEV_BUS        ((__force snd_device_type_t) 0x1007)

#define    SNDRV_DEV_CODEC        ((__force snd_device_type_t) 0x1008)

#define    SNDRV_DEV_JACK          ((__force snd_device_type_t) 0x1009)

#define    SNDRV_DEV_COMPRESS    ((__force snd_device_type_t) 0x100A)

#define    SNDRV_DEV_LOWLEVEL    ((__force snd_device_type_t) 0x2000)

4. Linux ALSA 源码目录结构

在 Linux 源码中 ALSA 架构的代码在 /sound 下，Linux 5.0 的目录如下：

其中各主要子目录的作用如下：

core       该目录包含了ALSA 驱动的中间层，它是整个 ALSA 驱动的核心部分

core/oss   包含模拟旧的 OSS 架构的 PCM 和 Mixer 模块

core/seq   有关音序器相关的代码

drivers    放置一些与CPU、BUS架构无关的公用代码

i2c        ALSA自己的I2C控制代码

pci        pci声卡的顶层目录,子目录包含各种pci声卡的代码

isa        isa声卡的顶层目录，子目录包含各种isa声卡的代码

soc        针对 system-on-chip 体系的中间层代码，即ASOC代码

soc/rockchip 瑞芯微平台i2s控制器驱动代码

soc/codecs   针对soc 体系的各种 codec 的代码，与平台无关

include    ALSA驱动的公共头文件目录，其路径为 /include/sound，该目录的头文件需要导出给用户空间的应用程序使用，通常，驱动模块私有的头文件不应放置在这里

更多目录结构信息可以参考：

 https://www.kernel.org/doc/html/latest/sound/kernel-api/writing-an-alsa-driver.html。

5. ALSA核心数据结构

由于ASoC是建立在标准ALSA CORE上的一套软件体系，因此本篇博客重点介绍的都是ALSA CORE中的数据结构，并不涉及到ASoC CORE中的数据结构。

ALSA CORE中的数据结构大部分定义在include/sound/core.h、以及sound/core/目录下的文件中。

1) struct snd_card

linux内核中使用struct snd_card表示ALSA音频驱动中的声卡设备

struct snd_card可以说是整个ALSA音频驱动最顶层的一个结构，整个声卡的软件逻辑结构开始于该结构，

几乎所有与声音相关的逻辑设备都是在snd_card的管理之下

声卡驱动的第一个动作通常就是创建一个snd_card结构体。

@include/sound/core.h

/* main structure for soundcard */

struct snd_card {

	int number;			/* number of soundcard (index to

								snd_cards) */

	char id[16];			/* id string of this card */

	char driver[16];		/* driver name */

	char shortname[32];		/* short name of this soundcard */

	char longname[80];		/* name of this soundcard */

	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 */

	int user_ctl_count;		/* count of all user controls */

	struct list_head controls;	/* all controls for this card */

	struct list_head ctl_files;	/* active control files */

	struct snd_info_entry *proc_root;	/* root for soundcard specific files */

	struct snd_info_entry *proc_id;	/* the card id */

	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 */

	struct device card_dev;		/* cardX object for sysfs */

	const struct attribute_group *dev_groups[4]; /* assigned sysfs attr */

	bool registered;		/* card_dev is registered? */

	wait_queue_head_t remove_sleep;

	int offline;			/* if this sound card is offline */

	unsigned long offline_change;

	wait_queue_head_t offline_poll_wait;

#ifdef CONFIG_PM

	unsigned int power_state;	/* power state */

	wait_queue_head_t power_sleep;

#endif

#if IS_ENABLED(CONFIG_SND_MIXER_OSS)

	struct snd_mixer_oss *mixer_oss;

	int mixer_oss_change_count;

#endif

};

@include/sound/core.h

struct snd_card {

    number: 声卡设备编号，通常从0开始，通过编号可以在snd_cards指针数组中找到对应的声卡设备；

    id[16]：声卡设备的标识符；

    driver：驱动名称；

    shortname：设备简称，更多地用于打印信息；

    longname：设备名称，会在具体驱动中设置，主要反映在/proc/asound/cards中；

    irq_descr：中断描述信息；

    mixername：混音器名称；

    components：声卡组件名称，由空格分隔；

    module：顶层模块；

    private_data：声卡的私有数据；

    private_free：释放私有数据的回调函数；

    devices：保存该声卡下所有逻辑设备的链表；链表中存放的数据类型为struct snd_device；

    ctl_dev：声卡Control设备内核设备结构体，其parent为card_dev，class为sound_class，主设备号为116；

    last_numid：存储注册snd_control时为其分配的编号；

    controls_rwsem：读写信号量，用于并发操作controls链表；

    ctl_files_rwlock：读写自旋锁，用于并发操作ctl_files链表；

    controls_count：controls链表的长度；

    user_ctl_count：用户控制设备的数量；

    controls：保存该声卡下所有控件（controls）的链表；该链表中存放的数据类型为struct snd_kcontrol；

    ctl_files：用于管理该card下的active的control设备；链表中存放的数据类型为struct snd_ctl_file；

    proc_root：声卡设备在proc文件系统的根目录；即/proc/asound/card%d目录；

    proc_root_link：指向/proc/asound/card%d的链接文件，文件名为id；

    files_list：保存此声卡相关的所有文件的链表；链表中存放的数据类型为struct snd_monitor_file；

    s_f_ops：关机状态下的文件操作；

    files_lock：自旋锁；

    shutdown：此声卡正在关闭；

    release_completion：释放完成；

    dev：分配给此声卡的设备，一般为平台设备的device；

    card_dev：声卡设备的内核设备结构体，card用于在sys中显示，用于代表该card；把snd_card看做是device的子类，其parent为dev，class为sound_class，未设置设备号devt（默认就是0）；

    dev_groups：分配的sysfs属性组；

    registered：声卡设备card_dev是否已注册；

    remove_sleep：等待队列头；

    power_state：电源状态；

    power_sleep：电源等待队列头；

};

每一个声卡设备的创建都是通过snd_card_new函数实现的，声卡设备被注册后都会被添加到全局snd_cards指针数组中；

@include/sound/core.h

int snd_card_new(struct device *parent, int idx, const char *xid,

		 struct module *module, int extra_size,

		 struct snd_card **card_ret);

@sound/core/init.c

static struct snd_card *snd_cards[SNDRV_CARDS];

2) struct snd_device

声卡设备一般包含许多功能模块，比如PCM（录音和播放）、Control（声卡控制），因此ALSA将声卡的功能模块又抽象为一个逻辑设备，与之对应的数据结构就是struct snd_device；

@sound/core/device.c

struct snd_device {

        struct list_head list;          /* list of registered devices */

        struct snd_card *card;          /* card which holds this device */

        enum snd_device_state state;    /* state of the device */

        enum snd_device_type type;      /* device type */

        void *device_data;              /* device structure */

        struct snd_device_ops *ops;     /* operations */

};

    list：用于构建双向链表节点，该节点会添加到声卡设备snd_card的devices链表中；

    snd_card：表示当前声卡逻辑设备所属的声卡设备；

    state：表示当前声卡逻辑设备的状态；

    type：表示当前声卡逻辑设备的类型，比如pcm、control设备；

    device_data：一般用于存放具体的功能模块逻辑设备的结构，比如对于pcm逻辑设备存放的就是snd_pcm实例；

    ops：声卡逻辑设备的操作集；

每一个声卡逻辑设备的创建最终会调用snd_device_new来生成一个snd_device实例，并把该实例链接到snd_card的devices链表中。

通常，linux内核已经提供了一些常用的功能模块逻辑设备的创建函数，而不必直接调用snd_device_new，比如： snd_pcm_new、snd_ctl_create。

需要注意的是：声卡逻辑设备注册后会在/dev/snd目录下生成对应的字符设备文件。

3) struct snd_device_ops

linux中使用snd_device_ops来表示声卡逻辑设备的操作集；

@include/sound/core.h

struct snd_device_ops {

	int (*dev_free)(struct snd_device *dev);

	int (*dev_register)(struct snd_device *dev);

	int (*dev_disconnect)(struct snd_device *dev);

};

其中：

dev_free：声卡逻辑设备释放函数，在卸载声卡设备时被调用；
dev_register：声卡逻辑设备注册函数，在注册声卡设备被调用；
dev_disconnect：声卡逻辑设备断开连接函数，在关闭声卡设备时被调用。

4) enum snd_device_state

linux内核使用snd_device_state表示声卡逻辑设备的状态

@include/sound/core.h

enum snd_device_state {

        SNDRV_DEV_BUILD,         // 构建中

        SNDRV_DEV_REGISTERED,    // 已经准备并准备就绪

        SNDRV_DEV_DISCONNECTED,  // 已断开连接

};

5) enum snd_device_type

linux内核使用snd_device_state表示声卡逻辑设备的类型

@include/sound/core.h

enum snd_device_type {

	SNDRV_DEV_LOWLEVEL,

	SNDRV_DEV_INFO,

	SNDRV_DEV_BUS,

	SNDRV_DEV_CODEC,

	SNDRV_DEV_PCM,

	SNDRV_DEV_COMPRESS,

	SNDRV_DEV_RAWMIDI,

	SNDRV_DEV_TIMER,

	SNDRV_DEV_SEQUENCER,

	SNDRV_DEV_HWDEP,

	SNDRV_DEV_JACK,

	SNDRV_DEV_CONTROL,	/* NOTE: this must be the last one */

};

其中：

    SNDRV_DEV_LOWLEVEL：低级别硬件访问接口；

    SNDRV_DEV_INFO：信息查询接口；

    SNDRV_DEV_BUS：总线接口，如USB、PCI等；

    SNDRV_DEV_CODEC：编解码器设备；

    SNDRV_DEV_PCM：PCM 设备，包括输入输出设备以及混音器等；

    SNDRV_DEV_COMPRESS：压缩和解压缩设备；

    SNDRV_DEV_RAWMIDI：原始MIDI设备；

    SNDRV_DEV_TIMER：定时器设备；

    SNDRV_DEV_SEQUENCER：序列器设备；

    SNDRV_DEV_HWDEP：硬件依赖设备；

    SNDRV_DEV_JACK：JACK音频连接设备；

    SNDRV_DEV_CONTROL：control设备，此项必须放在最后；

6) struct snd_minor

linux内核使用snd_minor表示声卡逻辑设备上下文信息，它在调用snd_register_device函数注册声卡逻辑设备时被初始化，在声卡逻辑设备被使用时就可以从该结构体中得到相应的信息。

struct snd_minor {

        int type;                       /* SNDRV_DEVICE_TYPE_XXX */

        int card;                       /* card number */

        int device;                     /* device number */

        const struct file_operations *f_ops;    /* file operations */

        void *private_data;             /* private data for f_ops->open */

        struct device *dev;             /* device for sysfs */

        struct snd_card *card_ptr;      /* assigned card instance */

};

其中：

type：设备类型，取值为 SNDRV_DEVICE_TYPE_XXX；
card：声卡逻辑设备所属的声卡设备的编号；
device：设备索引；
f_ops：文件操作集。
private_data：用户提供给 f_ops->open函数的私有数据指针；
dev：声卡逻辑设备对应的 struct device 结构体指针；
card_ptr：指向所属声卡设备；

每一个snd_minor的创建都是通过snd_register_device函数实现的，并被添加到全局snd_minors指针数组中；

static struct snd_minor *snd_minors[SNDRV_OS_MINORS];

6. alsa数据结构之间关系

为了更加形象的表示struct snd_card、struct snd_device、struct snd_minor 之间的关系，我们绘制了如下关系框图：

7. 内核中alsa几个主要函数

1） snd_register_device()

Linux 内核 ALSA 音频框架的其它部分需要创建音频设备文件时，调用 snd_register_device() 函数为声卡注册 ALSA 设备文件，该函数定义 (位于 sound/core/sound.c)

/**

 * snd_register_device - Register the ALSA device file for the card

 * @type: the device type, SNDRV_DEVICE_TYPE_XXX

 * @card: the card instance

 * @dev: the device index

 * @f_ops: the file operations

 * @private_data: user pointer for f_ops->open()

 * @device: the device to register

 *

 * Registers an ALSA device file for the given card.

 * The operators have to be set in reg parameter.

 *

 * Return: Zero if successful, or a negative error code on failure.

 */

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;

	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);

	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;

 error:

	mutex_unlock(&sound_mutex);

	if (err < 0)

		kfree(preg);

	return err;

}

EXPORT_SYMBOL(snd_register_device);

参数说明如下

type：  设备类型

card：  声卡实例

dev：   设备索引

f_ops： 文件操作。用户空间程序对设备文件的各种操作，都将由这里传入的文件操作执行。

private_data：f_ops->open() 要用到的用户指针

device：要注册的设备

snd_register_device() 函数的执行过程如下：

分配 struct snd_minor 对象，并初始化它；
为要注册的设备寻找可用的从设备号。这有两种策略，一种是动态从设备号，另一种是静态从设备号。无论是哪种策略，SEQUENCER 和 TIMER 类型的设备的从设备号都是固定的 1 和 33。其它类型的设备，在动态从设备号策略中，顺序查找可用的从设备号；在静态从设备号策略中，根据声卡索引、设备类型和设备索引构造从设备号；
构造包含主设备号和从设备号的设备号；
向设备层次体系结构添加设备；
将 struct snd_minor 对象指针保存在 struct snd_minor 对象指针数组中。

2） device_add()

snd_register_device() 函数调用 device_add() 函数向设备层次体系结构添加设备，这个函数定义 (位于 drivers/base/core.c) 如下：

int device_add(struct device *dev)

{

	struct device *parent;

	struct kobject *kobj;

	struct class_interface *class_intf;

	int error = -EINVAL;

	struct kobject *glue_dir = NULL;

	dev = get_device(dev);

	if (!dev)

		goto done;

	if (!dev->p) {

		error = device_private_init(dev);

		if (error)

			goto done;

	}

	/*

	 * for statically allocated devices, which should all be converted

	 * some day, we need to initialize the name. We prevent reading back

	 * the name, and force the use of dev_name()

	 */

	if (dev->init_name) {

		dev_set_name(dev, "%s", dev->init_name);

		dev->init_name = NULL;

	}

	/* subsystems can specify simple device enumeration */

	if (!dev_name(dev) && dev->bus && dev->bus->dev_name)

		dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);

	if (!dev_name(dev)) {

		error = -EINVAL;

		goto name_error;

	}

	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);

	parent = get_device(dev->parent);

	kobj = get_device_parent(dev, parent);

	if (IS_ERR(kobj)) {

		error = PTR_ERR(kobj);

		goto parent_error;

	}

	if (kobj)

		dev->kobj.parent = kobj;

	/* use parent numa_node */

	if (parent && (dev_to_node(dev) == NUMA_NO_NODE))

		set_dev_node(dev, dev_to_node(parent));

	/* first, register with generic layer. */

	/* we require the name to be set before, and pass NULL */

	error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);

	if (error) {

		glue_dir = get_glue_dir(dev);

		goto Error;

	}

	/* notify platform of device entry */

	error = device_platform_notify(dev, KOBJ_ADD);

	if (error)

		goto platform_error;

	error = device_create_file(dev, &dev_attr_uevent);

	if (error)

		goto attrError;

	error = device_add_class_symlinks(dev);

	if (error)

		goto SymlinkError;

	error = device_add_attrs(dev);

	if (error)

		goto AttrsError;

	error = bus_add_device(dev);

	if (error)

		goto BusError;

	error = dpm_sysfs_add(dev);

	if (error)

		goto DPMError;

	device_pm_add(dev);

	if (MAJOR(dev->devt)) {

		error = device_create_file(dev, &dev_attr_dev);

		if (error)

			goto DevAttrError;

		error = device_create_sys_dev_entry(dev);

		if (error)

			goto SysEntryError;

		devtmpfs_create_node(dev);

	}

	/* Notify clients of device addition.  This call must come

	 * after dpm_sysfs_add() and before kobject_uevent().

	 */

	if (dev->bus)

		blocking_notifier_call_chain(&dev->bus->p->bus_notifier,

					     BUS_NOTIFY_ADD_DEVICE, dev);

	kobject_uevent(&dev->kobj, KOBJ_ADD);

	/*

	 * Check if any of the other devices (consumers) have been waiting for

	 * this device (supplier) to be added so that they can create a device

	 * link to it.

	 *

	 * This needs to happen after device_pm_add() because device_link_add()

	 * requires the supplier be registered before it's called.

	 *

	 * But this also needs to happen before bus_probe_device() to make sure

	 * waiting consumers can link to it before the driver is bound to the

	 * device and the driver sync_state callback is called for this device.

	 */

	if (dev->fwnode && !dev->fwnode->dev) {

		dev->fwnode->dev = dev;

		fw_devlink_link_device(dev);

	}

	bus_probe_device(dev);

	if (parent)

		klist_add_tail(&dev->p->knode_parent,

			       &parent->p->klist_children);

	if (dev->class) {

		mutex_lock(&dev->class->p->mutex);

		/* tie the class to the device */

		klist_add_tail(&dev->p->knode_class,

			       &dev->class->p->klist_devices);

		/* notify any interfaces that the device is here */

		list_for_each_entry(class_intf,

				    &dev->class->p->interfaces, node)

			if (class_intf->add_dev)

				class_intf->add_dev(dev, class_intf);

		mutex_unlock(&dev->class->p->mutex);

	}

done:

	put_device(dev);

	return error;

 SysEntryError:

	if (MAJOR(dev->devt))

		device_remove_file(dev, &dev_attr_dev);

 DevAttrError:

	device_pm_remove(dev);

	dpm_sysfs_remove(dev);

 DPMError:

	bus_remove_device(dev);

 BusError:

	device_remove_attrs(dev);

 AttrsError:

	device_remove_class_symlinks(dev);

 SymlinkError:

	device_remove_file(dev, &dev_attr_uevent);

 attrError:

	device_platform_notify(dev, KOBJ_REMOVE);

platform_error:

	kobject_uevent(&dev->kobj, KOBJ_REMOVE);

	glue_dir = get_glue_dir(dev);

	kobject_del(&dev->kobj);

 Error:

	cleanup_glue_dir(dev, glue_dir);

parent_error:

	put_device(parent);

name_error:

	kfree(dev->p);

	dev->p = NULL;

	goto done;

}

EXPORT_SYMBOL_GPL(device_add);

device_add() 函数调用 device_create_file() 和 devtmpfs_create_node() 等函数在 sysfs 和 devtmpfs 文件系统中创建文件。

内核各模块通过 devtmpfs_create_node() 函数创建 devtmpfs 文件，这个函数定义 (位于 drivers/base/devtmpfs.c) 如下：

static int devtmpfs_submit_req(struct req *req, const char *tmp)

{

	init_completion(&req->done);

	spin_lock(&req_lock);

	req->next = requests;

	requests = req;

	spin_unlock(&req_lock);

	wake_up_process(thread);

	wait_for_completion(&req->done);

	kfree(tmp);

	return req->err;

}

int devtmpfs_create_node(struct device *dev)

{

	const char *tmp = NULL;

	struct req req;

	if (!thread)

		return 0;

	req.mode = 0;

	req.uid = GLOBAL_ROOT_UID;

	req.gid = GLOBAL_ROOT_GID;

	req.name = device_get_devnode(dev, &req.mode, &req.uid, &req.gid, &tmp);

	if (!req.name)

		return -ENOMEM;

	if (req.mode == 0)

		req.mode = 0600;

	if (is_blockdev(dev))

		req.mode |= S_IFBLK;

	else

		req.mode |= S_IFCHR;

	req.dev = dev;

	return devtmpfs_submit_req(&req, tmp);

}

这个函数通过 device_get_devnode() 函数获得 devtmpfs 设备文件的文件名，创建一个 devtmpfs 设备文件创建请求，并提交。在 devtmpfs_submit_req() 函数中，可以看到所有的请求由单链表维护，新的请求被放在单链表的头部。

device_get_devnode() 函数定义 (位于 drivers/base/core.c) 如下：

const char *device_get_devnode(struct device *dev,

			       umode_t *mode, kuid_t *uid, kgid_t *gid,

			       const char **tmp)

{

	char *s;

	*tmp = NULL;

	/* the device type may provide a specific name */

	if (dev->type && dev->type->devnode)

		*tmp = dev->type->devnode(dev, mode, uid, gid);

	if (*tmp)

		return *tmp;

	/* the class may provide a specific name */

	if (dev->class && dev->class->devnode)

		*tmp = dev->class->devnode(dev, mode);

	if (*tmp)

		return *tmp;

	/* return name without allocation, tmp == NULL */

	if (strchr(dev_name(dev), '!') == NULL)

		return dev_name(dev);

	/* replace '!' in the name with '/' */

	s = kstrdup(dev_name(dev), GFP_KERNEL);

	if (!s)

		return NULL;

	strreplace(s, '!', '/');

	return *tmp = s;

}

device_get_devnode() 函数按照一定的优先级，尝试从几个地方获得设备文件名：

设备的设备类型 struct device_type 的 devnode 操作；
设备的总线 struct class 的 devnode 操作；
设备名字。

对于音频设备，我们在 sound/sound_core.c 文件中看到，其总线 struct class 的 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));

}

3） snd_unregister_device()

注销 ALSA 设备文件

当不再需要某个 ALSA 设备文件时，可以注销它，这通过 snd_unregister_device() 函数完成。snd_unregister_device() 函数定义 (位于 sound/core/sound.c)

int snd_unregister_device(struct device *dev)

{

	int minor;

	struct snd_minor *preg;

	mutex_lock(&sound_mutex);

	for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) {

		preg = snd_minors[minor];

		if (preg && preg->dev == dev) {

			snd_minors[minor] = NULL;

			device_del(dev);

			kfree(preg);

			break;

		}

	}

	mutex_unlock(&sound_mutex);

	if (minor >= ARRAY_SIZE(snd_minors))

		return -ENOENT;

	return 0;

}

EXPORT_SYMBOL(snd_unregister_device);

这个函数根据传入的设备，查找对应的 struct snd_minor 对象，找到时，则从系统中删除设备，这包括删除 devtmpfs 文件系统中的设备文件等，并释放 struct snd_minor 对象。

在 snd_register_device() 函数中可以看到，是给设备计算了设备号的，这里不能获取设备号，并根据设备号在 struct snd_minor 对象指针数组中快速查找么？

音频设备文件的文件操作

注册音频字符设备时，绑定的文件操作是 snd_fops，这个文件操作只定义了 open 和 llseek 两个操作，其中 llseek 操作 noop_llseek 的定义 (位于 fs/read_write.c) 如下：

loff_t noop_llseek(struct file *file, loff_t offset, int whence)

{

	return file->f_pos;

}

EXPORT_SYMBOL(noop_llseek);

这个操作基本上什么也没做。

open 操作 snd_open 的定义 (位于 sound/core/sound.c) 如下：

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;

}

这个函数：

从 struct inode 中获得音频设备文件的从设备号；
根据从设备号，在 struct snd_minor 对象指针数组中，找到对应的 struct snd_minor 对象；
从 struct snd_minor 对象获得它的文件操作，即注册 ALSA 设备文件时传入的文件操作；
将 struct file 的文件操作替换为获得的文件操作；
执行新的文件操作的 open 操作。

具体详细的函数，后面驱动分析章节会继续分析讨论。