17.4 Linux ALSA 音频设备驱动
17.4.1 ALSA 的组成
虽然 OSS 已经非常成熟，但OSS是一个没有完全开放源代码的商业产品，而且目前基本上在 Linux mainline 中失去了更新。 ALSA （Advanced Linux Sound Architecture）恰好弥补这一空白，ALSA符合 GPL，是在 Linux 下进行音频编程时另一种可供选择的声卡驱动体系结构。ALSA 除了像 OSS 提供一组内核驱动程序模块之外，还专门为简化应用程序的编写提供相应的函数库，与 OSS 提供的基于 ioctl 的原始编程接口相比，ALSA 函
数库使用起来更加方便。ALSA 的主要特点如下。
1）支持多种声卡设备
2）模块化的内核驱动程序
3）支持 SMP 和多线程
4）提供应用开发函数库（alsa-lib）以简化应用程序开发
5）支持 OSS API，兼容 OSS 应用程序
ALSA 具友好的编程接口，并且完全兼容OSS，对应用程序员来讲是一个更佳的选择。ALSA 系统包括驱动包 alsa-driver、开发包 alsa-libs、开发包插件 alsa-libplugins、设置管理工具包 alsa-utils、其他声音相关处理小程序包 alsa-tools、特殊音频固件支持包 alsa- firmware、OSS 接口兼容模拟层工具 alsa-oss 共 7 个子项目，其中只有驱动包是必需的。
alsa-driver 指内核驱动程序，包括硬件相关的代码和一些公共代码，非常庞大，代码总量达数十万行；alsa-libs 指用户空间的函数库，提供给应用程序使用，应用程序应包含头文件asoundlib.h，并使用共享库 libasound.so；alsa-utils 包含一些基于 ALSA 的用于控制声卡的应用程序，如 alsaconf（侦测系统中声卡并写一个适合的 ALSA 配置文件）、alsactl（控制 ALSA 声卡驱动的高级设置）、alsamixer （基于窗口菜单 ncurses 的混音器程序）、amidi （用于读写 ALSA RawMIDI）、amixer（ALSA 声卡混音器的命令行控制）、aplay（基于命令行的声音文件播放）、arecord（基于命令行的声音文件录制）等。
目前 ALSA 内核提供给用户空间的接口有：
信息接口（Information Interface，/proc/asound）
控制接口（Control Interface，/dev/snd/controlCX）
混音器接口（Mixer Interface，/dev/snd/mixerCXDX）
PCM 接口（PCM Interface，/dev/snd/pcmCXDX）
Raw 迷笛接口（Raw MIDI Interface，/dev/snd/midiCXDX）
音序器接口（Sequencer Interface，/dev/snd/seq）
定时器接口（Timer Interface，/dev/snd/timer）
和 OSS 类似，上述接口也以文件的方式被提供，不同的是这些接口被提供给 alsa-lib 使用，不是直接给应用程序使用的。应用程序最好使用 alsa-lib，或者更高级的接口，比如 jack 提供的接口。
图17.6所示为ALSA声卡驱动与用户空间体系结构的简图，从中可以看出 ALSA 内核驱动与用户空间库及 OSS 之间的关系。
17.6 ALSA 体系结构
17.4.2 card 和组件
对于每个声卡，必须创建一个 card 实例。card 是声卡的“总部”，它管理这个声卡上的所有设备（组件），如 PCM、mixers、MIDI、synthesizer（合成器） 等。因此，card 和组件是 ALSA 声卡驱动中的主要组成元素。
1．创建 card
struct snd_card *snd_card_new(int idx, const char *xid, struct module *module, int extra_size);
idx ：card 索引号
xid ：标识字符串
module： 一般为 THIS_MODULE
extra_size ：要分配的额外数据的大小，分配的 extra_size 大小的内存将作为 card->private_data
2．创建组件
int snd_device_new(struct snd_card *card, snd_device_type_t type, void *device_data,
struct snd_device_ops *ops);
当 card 被创建后，设备（组件）能够被创建并关联于该 card。
第 1 个参数card是 snd_card_new()创建的 card 指针
第 2 个参数 type 指的是 device-level 即设备类型，形式为 SNDRV_DEV_XXX，包括 SNDRV_DEV_CODEC、SNDRV_DEV_CONTROL、SNDRV_DEV_PCM、SNDRV_DEV_RAWMIDI 等，用户自定义设备的 device-level 是 SNDRV_DEV_LOWLEVEL，ops 参数是 1 个函数集（定义为 snd_device_ops 结构体）的指针，device_data 是设备数据指针，注意函数 snd_device_new()本身不会分配设备数据的内存，因此应事先分配。
3．组件释放
每个ALSA 预定义的组件在构造时需调用创建组件snd_device_new()函数，而每个组件的析构方法则在函数集中被包含。对于PCM、AC97 此类预定义组件，不需关心它们的析构，而对于自定义的组件，则需要填充 snd_device_ops 中的析构函数指针 dev_free，这样，当 snd_card_free()被调用时，组件将自动被释放。
4．芯片特定的数据（Chip-Specific Data）
芯片特定的数据一般以 struct xxxchip 结构体形式组织，这个结构体中包含芯片相关的 I/O 端口地址、资源指针、中断号等，其意义等同于字符设备驱动中的 file->private_data。
定义芯片特定的数据主要有两种方法，一种方法是将sizeof(struct xxxchip)传入snd_card_new()作为 extra_size 参数，它将自动成为 snd_card 的 private_data 成员，如代码清单 17.5 所示。
代码清单 17.5 创建芯片特定的数据方法 1
/* 芯片特定的数据结构体 */
struct xxxchip {
...
};
/* 创建声卡并申请 xxxchip 内存作为 card-> private_data */
card = snd_card_new(index, id, THIS_MODULE, sizeof(struct xxxchip));
struct xxxchip *chip = card->private_data;
另一种方法是在 snd_card_new()传入给 extra_size 参数 0，再分配 sizeof(struct xxxchip)的内存，将分配内
存的地址传入 snd_device_new()的 device_data 的参数，如代码清单 17.6 所示。
代码清单 17.6 创建芯片特定的数据方法 2
struct snd_card *card;
struct xxxchip *chip;
/* 使用 0 作为第 4 个参数，并动态分配 xxx_chip 的内存*/
card = snd_card__new(index[dev], id[dev], THIS_MODULE, 0);
...
chip = kzalloc(sizeof(*chip), GFP_KERNEL);
/* 在 xxxchip 结构体中，应该包括声卡指针*/
struct xxxchip {
struct snd_card *card;
...
};
/* 并将其 card 成员赋值为 snd_card_new()创建的 card 指针*/
chip->card = card;
static struct snd_device_ops ops = {
. dev_free = snd_xxx_chip_dev_free, /* 组件析构*/
}；
...
/* 创建自定义组件*/
snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
/* 在析构函数中释放 xxxchip 内存*/
static int snd_xxx_chip_dev_free(struct snd_device *device)
{
return snd_xxx_chip_free(device->device_data); /* 释放*/
}
5．注册/释放声卡
当 snd_card 被准备好以后，可使用 snd_card_register()函数注册这个声卡，如下所示：
int snd_card_register(struct snd_card *card)；
对应的 snd_card_free()完成相反的功能，如下所示：
int snd_card_free(struct snd_card *card);
17.4.3 PCM 设备
每个声卡最多可以有 4 个 PCM（脉冲编码调制） 实例，一个 PCM 实例对应一个设备文件。PCM 实例由 PCM播放和录音流组成，而每个 PCM 流又由一个或多个 PCM 子流组成。有的声卡支持多重播放功能。
1．PCM 实例构造
int snd_pcm_new(struct snd_card *card, char *id, int device, int playback_count, int capture_count,
struct snd_pcm ** rpcm);
第 1 个参数是 card 指针，第 2 个是标识字符串，第 3 个是 PCM 设备索引（0 表示第 1 个 PCM设备），第 4 和第 5 个分别为播放和录音设备的子流数。当存在多个子流时，需要恰当地处理 open()、close()和其他函数。在每个回调函数中，可以通过 snd_pcm_substream 的 number 成员得知目前操作的是哪个子流，如下所示：
struct snd_pcm_substream *substream;
int index = substream->number;
一种习惯的做法是在驱动中定义一个 PCM“构造函数”，负责 PCM 实例的创建，如代码清单 17.7所示。
代码清单 17.7 PCM 设备的“构造函数”
static int _ _devinit snd_xxxchip_new_pcm(struct xxxchip *chip)
{
struct snd_pcm *pcm;
int err;
/* 创建 PCM 实例 */
if ((err = snd_pcm_new(chip->card, "xxx Chip", 0, 1, 1, &pcm)) < 0)
return err;
/* 置 pcm->private_data 为芯片特定数据*/
strcpy(pcm->name, "xxx Chip");
chip->pcm = pcm;
...
return 0;
}
2．设置 PCM 操作
include/sound/pcm.h
void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops);
sound/core/pcm_lib.c
/**
* snd_pcm_set_ops - set the PCM operators
* @pcm: the pcm instance
* @direction: stream direction, SNDRV_PCM_STREAM_XXX
* @ops: the operator table
*
* Sets the given PCM operators to the pcm instance.
*/
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;
}
EXPORT_SYMBOL(snd_pcm_set_ops);
第 1 个参数是 snd_pcm 的指针，第 2 个参数是 SNDRV_PCM_STREAM_PLAYBACK 或
SNDRV_PCM_STREAM_CAPTURE，第 3 个参数是 PCM 操作结构体 snd_pcm_ops，这个结构体的定义
如代码清单 17.8 所示。
代码清单 17.8 snd_pcm_ops 结构体
include/sound/pcm.h
struct snd_pcm_ops {
int (*open)(struct snd_pcm_substream *substream);
int (*close)(struct snd_pcm_substream *substream);
int (*ioctl)(struct snd_pcm_substream * substream,
unsigned int cmd, void *arg);
int (*compat_ioctl)(struct snd_pcm_substream *substream,
unsigned int cmd, void *arg);
int (*hw_params)(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params);
int (*hw_free)(struct snd_pcm_substream *substream);/* 资源释放*/
int (*prepare)(struct snd_pcm_substream *substream);
/* 在 PCM 被开始、停止或暂停时调用*/
int (*trigger)(struct snd_pcm_substream *substream, int cmd);
/ * 当前缓冲区的硬件位置*/
int (*delay_blk)(struct snd_pcm_substream *substream);
int (*wall_clock)(struct snd_pcm_substream *substream, struct timespec *audio_ts);
/* 缓冲区复制*/
void __user *buf, snd_pcm_uframes_t count);
int (*silence)(struct snd_pcm_substream *substream, int channel,
snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
struct page *(*page)(struct snd_pcm_substream *substream,
unsigned long offset);
int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
int (*ack)(struct snd_pcm_substream *substream);
int (*restart)(struct snd_pcm_substream *substream);
};
备注：
snd_pcm_ops 中的所有操作都需事先通过 snd_pcm_substream_chip()获得 xxxchip （芯片特定的数据结构体）指针，例如：
int xxx()
{
struct xxxchip *chip = snd_pcm_substream_chip(substream);
...
}
当一个 PCM 子流被打开时，snd_pcm_ops 中的 open()函数将被调用，在这个函数中，至少需要初始化 runtime->hw 字段，代码清单 17.9 所示为 open()函数的范例。
代码清单 17.9 snd_pcm_ops 结构体中的 open()函数
static int snd_xxx_open(struct snd_pcm_substream *substream)
{
/* 从子流获得 xxxchip 指针*/struct xxxchip *chip = snd_pcm_substream_chip(substream);
/* 获得 PCM 运行时信息指针*/
struct snd_pcm_runtime *runtime = substream->runtime;
...
/* 初始化 runtime->hw */
runtime->hw = snd_xxxchip_playback_hw;
return 0;}
分析：
snd_xxxchip_playback_hw 是预先定义的硬件描述。在 open()函数中，可以分配一段私有数据。如果硬件配置需要更多的限制，也需设置硬件限制。
当 PCM 子流被关闭时，close()函数将被调用。如果 open()函数中分配了私有数据，则在 close()函数中应该释放 substream 的私有数据，代码清单 17.10 所示为 close()函数的范例。
代码清单 17.10 snd_pcm_ops 结构体中的 close()函数
static int snd_xxx_close(struct snd_pcm_substream *substream)
{
/* 释放子流私有数据*/
kfree(substream->runtime->private_data);
...
}
驱动中通常可以给 snd_pcm_ops 的 ioctl()传递通用的 snd_pcm_lib_ioctl()函数。
snd_pcm_ops 的 hw_params()在应用程序设置硬件参数（PCM 子流的周期大小、缓冲区大小和格式等）时被调用，它的形式如下：
static int snd_xxx_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *hw_params);
在这个函数中，将完成大量硬件设置，甚至包括缓冲区分配，这时可调用如下辅助函数：
snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
仅当 DMA 缓冲区已被预先分配的情况下，上述调用才可成立。
与 hw_params()对应的函数是 hw_free()，它释放由 hw_params()分配的资源，例如，通过如下调用释放 snd_pcm_lib_malloc_pages()缓冲区：snd_pcm_lib_free_pages(substream);
当 PCM 被“准备”时，prepare()函数将被调用，在其中设置采样率、格式等。prepare()函数与 hw_params()函数的不同在于对 prepare()的调用发生在 snd_pcm_prepare()每次被调用的时候。prepare()的形式如下：
static int snd_xxx_prepare(struct snd_pcm_substream *substream);
trigger()成员函数在 PCM 被开始、停止或暂停时调用，函数的形式如下：
static int snd_xxx_trigger(struct snd_pcm_substream *substream, int cmd);
cmd 参数定义具体的行为，在 trigger()成员函数中至少要处理 SNDRV_PCM_TRIGGER_START 和 SNDRV_PCM_TRIGGER_STOP 命令，如果 PCM 支持暂停，还应处理 SNDRV_PCM_TRIGGER_PAUSE_PUSH 和 SNDRV_PCM_TRIGGER_PAUSE_RELEASE 命令。如果设备支持挂起/恢复，当能量管理状态发生变化时将处理 SNDRV_PCM_TRIGGER_SUSPEND 和 SNDRV_PCM_TRIGGER_RESUME 这两个命令。
分析：
trigger()函数是原子的，中途不能睡眠。代码清单 17.11所示为 trigger()函数的范例。
代码清单 17.11 snd_pcm_ops 结构体中的 trigger()函数
static int snd_xxx_trigger(struct snd_pcm_substream *substream, int cmd)
{
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
/* 开启 PCM 引擎*/
break;
case SNDRV_PCM_TRIGGER_STOP:
/* 停止 PCM 引擎*/
break;
... /* 其他命令*/
default:
return - EINVAL;
}
}
pointer()函数用于 PCM 中间层查询目前缓冲区的硬件位置，该函数以帧的形式返回 0～buffer_size – 1 的位置，此函数也是原子的。
copy()和 silence()函数一般可以省略，但是，当硬件缓冲区不处于常规内存中时需要。例如，一些设备有自己的不能被映射的硬件缓冲区，这种情况下，将数据从内存缓冲区复制到硬件缓冲区。当内存缓冲区在物理和虚拟地址上都不连续时，这两个函数也必须被实现。
3．分配缓冲区
分配缓冲区的最简单方法是调用如下函数：
include/sound/pcm.h
int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm, int type, void *data, size_t size,
size_t max);
type 参数是缓冲区的类型，包含 SNDRV_DMA_TYPE_UNKNOWN（未知）、
SNDRV_DMA_TYPE_CONTINUOUS（连续的非 DMA 内存）、SNDRV_DMA_TYPE_DEV（连续的通用设备），SNDRV_DMA_TYPE_DEV_SG（通用设备SG-buffer）和SNDRV_DMA_TYPE_SBUS （连续的SBUS）。
如下代码将分配 64KB 的缓冲区：
snd_pcm_lib_preallocate_pages_for_all(pcm,SNDRV_DMA_TYPE_DEV,snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
sound/core/pcm_memory.c
/**
* snd_pcm_lib_preallocate_pages_for_all - pre-allocation for continous memory type (all substreams)
* @pcm: the pcm instance
* @type: DMA type (SNDRV_DMA_TYPE_*)
* @data: DMA type dependant data
* @size: the requested pre-allocation size in bytes
* @max: the max. allowed pre-allocation size
*
* Do pre-allocation to all substreams of the given pcm for the
* specified DMA type.
*
* Returns zero if successful, or a negative error code on failure.
*/
int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
int type, void *data,
size_t size, size_t max)
{
struct snd_pcm_substream *substream;
int stream, err;
for (stream = 0; stream < 2; stream++)
for (substream = pcm->streams[stream].substream; substream; substream = substream->next)
if ((err = snd_pcm_lib_preallocate_pages(substream, type, data, size, max)) < 0)
return err;
return 0;
}
EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages_for_all);
4．设置标志
在构造 PCM 实例、设置操作集并分配缓冲区之后，如果有需要，应设置 PCM 的信息标志，例如，如果 PCM 设备只支持半双工，则定义标志：
pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
5．PCM 实例析构
PCM 实例的“析构函数”并非是必须的，因为 PCM 实例会被 PCM 中间层代码自动释放，如果驱动中分配了一些特别的内存空间，则必须定义“析构函数”，代码清单 17.12 所示为 PCM“析构函数”与对应的“构造函数”，“析构函数”会释放“构造函数”中创建的 xxx_private__pcm_data。
代码清单 17.12 PCM 设备“析构函数”
static void xxxchip_pcm_free(struct snd_pcm *pcm)
{
/* 从 pcm 实例指针得到 chip指针（芯片特定的数据结构体） */
struct xxxchip *chip = snd_pcm_chip(pcm);
/* 释放自定义用途的内存 */
kfree(chip->xxx_private_pcm_data);
...
}
static int __devinit snd_xxxchip_new_pcm(struct xxxchip *chip)
{
struct snd_pcm *pcm;
...
/* 分配自定义用途的内存 */
chip->xxx_private_pcm_data = kmalloc(...);
pcm->private_data = chip; // 给 PCM 实例赋予的 xxxchip 指针
/* 设置“析构函数” */
pcm->private_free = xxxchip_pcm_free;
...
}
6．PCM 信息运行时结构体
当 PCM 子流被打开后，PCM 运行时实例（定义为结构体 snd_pcm_runtime，如代码清单 17.13所示）将被分配给这个子流，这个指针通过 substream->runtime 获得。运行时指针包含各种各样的信息：hw_params 及 sw_params 配置的拷贝、缓冲区指针、mmap 记录、自旋锁等，几乎 PCM的所有控制信息均能从中取得。
代码清单 17.13 snd_pcm_runtime 结构体
include/sound/pcm.h
struct snd_pcm_runtime {
/* -- Status -- */
struct snd_pcm_substream *trigger_master;
struct timespec trigger_tstamp; /* trigger timestamp */
int overrange;
snd_pcm_uframes_t avail_max;
snd_pcm_uframes_t hw_ptr_base; /* Position at buffer restart */
snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time*/
/* -- HW params -- */
snd_pcm_access_t access; /* access mode */
snd_pcm_format_t format; /* SNDRV_PCM_FORMAT_* */
snd_pcm_subformat_t subformat; /* subformat */
unsigned int rate; /* rate in Hz */
unsigned int channels; /* channels */
snd_pcm_uframes_t period_size; /* period size */
unsigned int periods; /* periods */
snd_pcm_uframes_t buffer_size; /* buffer size */
unsigned int tick_time; /* tick time */
snd_pcm_uframes_t min_align; /* Min alignment for the format */
size_t byte_align;
unsigned int frame_bits;
unsigned int sample_bits;
unsigned int info;
unsigned int rate_num;
unsigned int rate_den;
/* -- SW params -- */
int tstamp_mode; /* mmap timestamp is updated */
unsigned int period_step;
unsigned int sleep_min; /* min ticks to sleep */
snd_pcm_uframes_t xfer_align; /* xfer size need to be a multiple */
snd_pcm_uframes_t start_threshold;
snd_pcm_uframes_t stop_threshold;
snd_pcm_uframes_t silence_threshold; /* Silence filling happens when
noise is nearest than this */
snd_pcm_uframes_t silence_size; /* Silence filling size */
snd_pcm_uframes_t boundary; /* pointers wrap point */
snd_pcm_uframes_t silence_start; /* starting pointer to silence area */
snd_pcm_uframes_t silence_filled; /* size filled with silence */
union snd_pcm_sync_id sync; /* hardware synchronization ID */
/* -- mmap -- */
volatile struct snd_pcm_mmap_status *status;
volatile struct snd_pcm_mmap_control *control;
/* -- locking / scheduling -- */
wait_queue_head_t sleep;
struct timer_list tick_timer;
struct fasync_struct *fasync;
/* -- private section -- */
void *private_data;
void (*private_free)(struct snd_pcm_runtime *runtime);
/* -- hardware description -- */
struct snd_pcm_hardware hw;
struct snd_pcm_hw_constraints hw_constraints;
/* -- interrupt callbacks -- */
void (*transfer_ack_begin)(struct snd_pcm_substream *substream);
void (*transfer_ack_end)(struct snd_pcm_substream *substream);
/* -- timer -- */
unsigned int timer_resolution; /* timer resolution */
/* -- DMA -- */
unsigned char *dma_area; /* DMA area */
dma_addr_t dma_addr; /* physical bus address (not accessible from main CPU) */
size_t dma_bytes; /* size of DMA area */
struct snd_dma_buffer *dma_buffer_p; /* allocated buffer */
#if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
/* -- OSS things -- */
struct snd_pcm_oss_runtime oss;
#endif
};
分析：
snd_pcm_runtime 中的大多数记录对被声卡驱动操作集中的函数是只读的，仅仅 PCM（脉冲编码调制） 中间层可从更新或修改这些信息，但是硬件描述、中断回调函数、DMA 缓冲区信息和私有数据是例外的。
下面解释 snd_pcm_runtime 结构体中的几个重要成员。
（1）硬件描述。
硬件描述（snd_pcm_hardware 结构体）包含了基本硬件配置的定义，需要在 open()函数中赋值。runtime 实例保存的是硬件描述的拷贝，这意味着在 open()函数中可以修改被拷贝的描述（runtime->hw），例如：
struct snd_pcm_runtime *runtime = substream->runtime;
...runtime->hw = snd_xxchip_playback_hw; /* generic 的硬件描述 */
/* 特定的硬件描述 */
if (chip->model == VERY_OLD_ONE)
runtime->hw.channels_max = 1;
snd_pcm_hardware 结构体的定义如代码清单 17.14 所示。
代码清单 17.14 snd_pcm_hardware 结构体
/*
* Hardware (lowlevel) section
*/
struct snd_pcm_hardware {
unsigned int info; /* SNDRV_PCM_INFO_* */
u64 formats; /* SNDRV_PCM_FMTBIT_* */
unsigned int rates; /* SNDRV_PCM_RATE_* */
unsigned int rate_min; /* min rate */
unsigned int rate_max; /* max rate */
unsigned int channels_min; /* min channels */
unsigned int channels_max; /* max channels */
size_t buffer_bytes_max; /* max buffer size */
size_t period_bytes_min; /* min period size */
size_t period_bytes_max; /* max period size */
unsigned int periods_min; /* 最小周期数 */
unsigned int periods_max; /* 最大周期数 */
size_t fifo_size; /* FIFO 字节数 */
};
分析：
snd_pcm_hardware 结构体中的 info 字段标识 PCM 设备的类型和能力，形式为 SNDRV_PCM_INFO_XXX。
info 字段至少需要定义是否支持 mmap，当支持时，应设置 SNDRV_PCM_INFO_MMAP标志；当硬件支持 interleaved 或 non-interleaved 格式时，应设置 SNDRV_PCM_INFO _INTERLEAVED
或 SNDRV_PCM_INFO_NONINTERLEAVED 标志；如果都支持，则两者都可设置。
MMAP_VALID 和 BLOCK_TRANSFER 标志针对 OSS（Open Sound System） mmap，只有 mmap 被真正支持时，才可设置 MMAP_VALID；SNDRV_PCM_INFO_PAUSE 意味着设备可支持暂停操作，
SNDRV_PCM_INFO_RESUME 意味着设备可支持挂起/恢复操作；当 PCM 子流能被同步，如同步播放和录音流的 start/stop，可设置 SNDRV_PCM_INFO_SYNC_START 标志。
formats 包含 PCM 设备支持的格式，形式为 SNDRV_PCM_FMTBIT_XXX，如果设备支持多种模式，应将各种模式标志进行“或”操作。
rates 包含了 PCM 设备支持的采样率，形式如 SNDRV_PCM_RATE_XXX，如果支持连续的采样率，则传递 CONTINUOUS。
rate_min 和 rate_max 分别定义了最小和最大的采样率，注意：要与 rates 字段相符。
channels_min 和 channels_max 定义了最小和最大的通道数量。
buffer_bytes_max 定义最大的缓冲区大小，注意：没有 buffer_bytes_min 字段，这是因为它可以通过最小的周期大小和最小的周期数量计算出来。
period 信息与 OSS 中的 fragment 对应，定义了 PCM（脉冲编码调制） 中断产生的周期。更小的周期大小意味着更多的中断，在录音时，周期大小定义了输入延迟，在播放时，整个缓冲区大小对应着输出延迟。
PCM 可被应用程序通过 alsa-lib 发送 hw_params 来配置，配置信息将保存在运行时实例中。对缓冲区和周期大小的配置以帧形式存储，而 frames_to_bytes()和 bytes_to_frames()可完成帧和字节的转换，如：
period_bytes = frames_to_bytes(runtime, runtime->period_size);（2）DMA 缓冲区信息。
包含 dma_area（逻辑地址）、dma_addr（物理地址）、dma_bytes（缓冲区大小）和 dma_private（被 ALSA DMA 分配器使用）。可以由 snd_pcm_lib_malloc_pages()实现，ALSA 中间层会设置 DMA缓冲区信息的相关字段，这种情况下，驱动中不能再写这些信息，只能读取。也就是说，如果使用标准的缓冲区分配函数 snd_pcm_lib_malloc_pages()分配缓冲区，则不需要自己维护 DMA缓冲区信息。如果缓冲区由自己分配，则需要在 hw_params()函数中管理缓冲区信息，至少需管理dma_bytes 和 dma_addr，如果支持 mmap，则必须管理 dma_area，对 dma_private 的管理视情况而定。
（3）运行状态。
通过 runtime->status 可以获得运行状态，它是 snd_pcm_mmap_status 结构体的指针，例如，通过 runtime->status->hw_ptr 可以获得目前的 DMA 硬件指针。
include/sound/asound.h
struct snd_pcm_mmap_status {
snd_pcm_state_t state; /* RO: state - SNDRV_PCM_STATE_XXXX */
int pad1; /* Needed for 64 bit alignment */
snd_pcm_uframes_t hw_ptr; /* RO: hw ptr (0...boundary-1) */
struct timespec tstamp; /* Timestamp */
snd_pcm_state_t suspended_state; /* RO: suspended stream state */
};
此外，通过 runtime->control 可以获得 DMA 应用指针，它指向 snd_pcm_mmap_control 结构体指针，但是不建议直接访问该指针。
include/sound/asound.h
struct snd_pcm_mmap_control {
snd_pcm_uframes_t appl_ptr; /* RW: appl ptr (0...boundary-1) */
snd_pcm_uframes_t avail_min; /* RW: min available frames for wakeup */
};
（4）私有数据。
驱动中可以为子流分配一段内存并赋值给 runtime->private_data，注意不要与 pcm->private_data 混淆，后者一般指向 xxxchip，而前者是在 PCM 设备的 open()函数中分配的动态数据，例如：
static int snd_xxx_open(struct snd_pcm_substream *substream)
{
struct xxx_pcm_data *data;
....
data = kmalloc(sizeof(*data), GFP_KERNEL);
substream->runtime->private_data = data; /* 赋值 runtime->private_data */
....
}
（5）中断回调函数：
transfer_ack_begin()和transfer_ack_end()函数分别在snd_pcm_period_elapsed()的开始和结束时被调用。
根据以上分析，代码清单 17.15 给出了一个完整的 PCM 设备接口模板。
代码清单 17.15 PCM 设备接口模板
#include <sound/pcm.h>
....
/* 播放设备硬件定义 */
static struct snd_pcm_hardware snd_xxxchip_playback_hw = {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
.formats = SNDRV_PCM_FMTBIT_S16_LE,
.rates = SNDRV_PCM_RATE_8000_48000,
.rate_min = 8000,
.rate_max = 48000,
.channels_min = 2,
.channels_max = 2,
.buffer_bytes_max = 32768,
.period_bytes_min = 4096,
.period_bytes_max = 32768,
.periods_min = 1,
.periods_max = 1024,
};
/* 录音设备硬件定义 */
static struct snd_pcm_hardware snd_xxxchip_capture_hw = {
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
.formats = SNDRV_PCM_FMTBIT_S16_LE,
.rates = SNDRV_PCM_RATE_8000_48000,
.rate_min = 8000,
.rate_max = 48000,
.channels_min = 2,
.channels_max = 2,
.buffer_bytes_max = 32768,
.period_bytes_min = 4096,
.period_bytes_max = 32768,
.periods_min = 1,
.periods_max = 1024,
};
/* 播放：打开函数 */
static int snd_xxxchip_playback_open(struct snd_pcm_substream*substream)
{
struct xxxchip *chip = snd_pcm_substream_chip(substream);
struct snd_pcm_runtime *runtime = substream->runtime;
runtime->hw = snd_xxxchip_playback_hw;
... /* 硬件初始化代码*/
return 0;
}
/* 播放：关闭函数 */
static int snd_xxxchip_playback_close(struct snd_pcm_substream*substream)
{
struct xxxchip *chip = snd_pcm_substream_chip(substream);
/* 硬件相关的代码*/
return 0;
}
/* 录音：打开函数 */
static int snd_xxxchip_capture_open(struct snd_pcm_substream*substream)
{
struct xxxchip *chip = snd_pcm_substream_chip(substream);
struct snd_pcm_runtime *runtime = substream->runtime;
runtime->hw = snd_xxxchip_capture_hw;
... /* 硬件初始化代码*/
return 0;
}
/* 录音：关闭函数 */
static int snd_xxxchip_capture_close(struct snd_pcm_substream*substream)
{
struct xxxchip *chip = snd_pcm_substream_chip(substream);
... /* 硬件相关的代码*/
return 0;
}
/* hw_params 函数 */
static int snd_xxxchip_pcm_hw_params(struct snd_pcm_substream*substream, struct
snd_pcm_hw_params *hw_params)
{
return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
}
/* hw_free 函数 */
static int snd_xxxchip_pcm_hw_free(struct snd_pcm_substream*substream)
{
return snd_pcm_lib_free_pages(substream);
}
/* prepare 函数 */
static int snd_xxxchip_pcm_prepare(struct snd_pcm_substream*substream)
{
struct xxxchip *chip = snd_pcm_substream_chip(substream);
struct snd_pcm_runtime *runtime = substream->runtime;
/* 根据目前的配置信息设置硬件
* 例如：
*/
xxxchip_set_sample_format(chip, runtime->format);
xxxchip_set_sample_rate(chip, runtime->rate);
xxxchip_set_channels(chip, runtime->channels);
xxxchip_set_dma_setup(chip, runtime->dma_addr, chip->buffer_size, chip->period_size);
return 0;
}
/* trigger 函数 */
static int snd_xxxchip_pcm_trigger(struct snd_pcm_substream*substream, int cmd)
{
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
/* do something to start the PCM engine */
break;
case SNDRV_PCM_TRIGGER_STOP:
/* do something to stop the PCM engine */
break;
default:
return - EINVAL;
}
}
/* pointer 函数 */
static snd_pcm_uframes_t snd_xxxchip_pcm_pointer(struct snd_pcm_substream *substream)
{
struct xxxchip *chip = snd_pcm_substream_chip(substream);
unsigned int current_ptr;
/*获得当前的硬件指针*/
current_ptr = xxxchip_get_hw_pointer(chip);
return current_ptr;
}
/* 放音设备操作集 */
static struct snd_pcm_ops snd_xxxchip_playback_ops = {
.open = snd_xxxchip_playback_open,
.close = snd_xxxchip_playback_close,
.ioctl = snd_pcm_lib_ioctl,
.hw_params = snd_xxxchip_pcm_hw_params,
.hw_free = snd_xxxchip_pcm_hw_free,
.prepare = snd_xxxchip_pcm_prepare,
.trigger = snd_xxxchip_pcm_trigger,
.pointer = snd_xxxchip_pcm_pointer,
};
/* 录音设备操作集 */
static struct snd_pcm_ops snd_xxxchip_capture_ops = {
.open = snd_xxxchip_capture_open,
.close = snd_xxxchip_capture_close,
.ioctl = snd_pcm_lib_ioctl,
.hw_params = snd_xxxchip_pcm_hw_params,
.hw_free = snd_xxxchip_pcm_hw_free,
.prepare = snd_xxxchip_pcm_prepare,
.trigger = snd_xxxchip_pcm_trigger,
.pointer = snd_xxxchip_pcm_pointer,
};
/* 创建一个 PCM 设备 */
static int _ _devinit snd_xxxchip_new_pcm(struct xxxchip *chip)
{
struct snd_pcm *pcm;
int err;
if ((err = snd_pcm_new(chip->card, "xxx Chip", 0, 1, 1, &pcm)) < 0)
return err;
pcm->private_data = chip;
strcpy(pcm->name, "xxx Chip");
chip->pcm = pcm;
/* 设置操作集 */
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_xxxchip_playback_ops);
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_xxxchip_capture_ops);
/* 分配缓冲区 */
snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
snd_dma_pci_data(chip - > pci), 64 *1024, 64 *1024);
return 0;
}