ALSA 驱动程序 API¶

卡和设备的管理¶

卡管理¶

int snd_device_alloc(struct device **dev_p, struct snd_card *card)¶: 为声音设备分配和初始化 struct device

参数

struct device **dev_p: 用于存储分配设备的指针
struct snd_card *card: 要分配的卡，可选

描述

要释放分配的设备，请调用 put_device()。

int snd_card_new(struct device *parent, int idx, const char *xid, struct module *module, int extra_size, struct snd_card **card_ret)¶: 创建和初始化声卡结构

参数

struct device *parent

父设备对象

int idx

卡索引（地址）[0 ... (SNDRV_CARDS-1)]

const char *xid

卡标识（ASCII 字符串）

struct module *module

用于锁定的顶层模块

int extra_size

在主声卡结构之后分配此额外大小

struct snd_card **card_ret

用于存储创建的卡实例的指针

该函数通过 kzalloc 分配 snd_card 实例，并为驱动程序提供可用空间。分配的结构存储在给定的 card_ret 指针中。

返回

如果成功，则为零；否则为负错误代码。

int snd_devm_card_new(struct device *parent, int idx, const char *xid, struct module *module, size_t extra_size, struct snd_card **card_ret)¶: 托管的 snd_card 对象创建

参数

struct device *parent: 父设备对象
int idx: 卡索引（地址）[0 ... (SNDRV_CARDS-1)]
const char *xid: 卡标识（ASCII 字符串）
struct module *module: 用于锁定的顶层模块
size_t extra_size: 在主声卡结构之后分配此额外大小
struct snd_card **card_ret: 用于存储创建的卡实例的指针

描述

此函数的工作方式类似于 snd_card_new()，但通过 devres 管理分配的资源，即您不需要显式释放。

当使用此函数创建 snd_card 对象并通过 snd_card_register() 注册时，将自动添加调用 snd_card_free() 的第一个 devres 操作。这样，资源断开连接首先得到保证，然后在预期的顺序中释放。

如果在调用 snd_card_register() 之前探测时发生错误，并且存在其他 devres 资源，则需要通过在错误中调用 snd_card_free() 手动释放卡；否则，由于 devres 调用顺序，可能会导致 UAF。您可以使用 snd_card_free_on_error() 助手来更轻松地处理它。

返回

如果成功，则为零，否则为负错误代码

int snd_card_free_on_error(struct device *dev, int ret)¶: 用于处理 devm 探测错误的小助手

参数

struct device *dev: 托管的设备对象
int ret: 来自探测回调的返回代码

描述

此函数处理来自探测回调的错误时的显式 snd_card_free() 调用。它只是一个用于简化托管设备错误处理的小助手。

返回

如果成功，则为零，否则为负错误代码

struct snd_card *snd_card_ref(int idx)¶: 从索引获取卡对象

参数

int idx: 卡索引

描述

返回与给定索引对应的卡对象，如果未找到，则返回 NULL。通过 snd_card_unref() 释放对象。

返回

卡对象或 NULL

void snd_card_disconnect(struct snd_card *card)¶: 断开所有 API 与文件操作（用户空间）的连接

参数

struct snd_card *card

声卡结构

断开所有 API 与文件操作（用户空间）的连接。

返回

零，否则为负错误代码。

注意

当前实现使用特殊的: 虚拟文件操作（除了释放之外什么都不做）替换所有活动的文件->f_op。

void snd_card_disconnect_sync(struct snd_card *card)¶: 断开声卡连接并等待文件关闭

参数

struct snd_card *card: 要断开连接的声卡对象

描述

此函数调用 snd_card_disconnect() 来断开所有关联组件的连接，并等待所有挂起的文件关闭。它确保用户空间的所有访问都已完成，以便驱动程序可以优雅地释放其资源。

void snd_card_free_when_closed(struct snd_card *card)¶: 断开声卡连接，稍后最终释放

参数

struct snd_card *card: 声卡结构

描述

与 snd_card_free() 不同，此函数不会尝试立即释放声卡资源，而是首先尝试断开连接。当声卡仍在被使用时，该函数会在释放资源之前返回。当引用计数变为零时，声卡资源将被释放。

返回

如果成功，则为零，否则为负错误代码

void snd_card_free(struct snd_card *card)¶: 释放给定的声卡结构

参数

struct snd_card *card: 声卡结构

描述

此函数会自动释放声卡结构和所有已分配的设备。也就是说，您不必自己释放设备。

此函数会等待直到所有资源都正确释放。

返回

零。释放所有关联的设备并释放与给定声卡关联的控制接口。

void snd_card_set_id(struct snd_card *card, const char *nid)¶: 设置声卡识别名称

参数

struct snd_card *card

声卡结构

const char *nid

新的识别字符串

此函数设置声卡识别并检查名称冲突。

int snd_card_add_dev_attr(struct snd_card *card, const struct attribute_group *group)¶: 将新的 sysfs 属性组追加到声卡

参数

struct snd_card *card: 声卡实例
const struct attribute_group *group: 要追加的属性组

返回

如果成功，则为零，否则为负错误代码

int snd_card_register(struct snd_card *card)¶: 注册声卡

参数

struct snd_card *card

声卡结构

此函数注册所有分配给声卡的设备。在调用此函数之前，ALSA 控制接口被阻止来自外部访问。因此，您应该在声卡初始化结束时调用此函数。

返回

成功时返回零，如果注册失败则返回负错误代码。

int snd_component_add(struct snd_card *card, const char *component)¶: 添加组件字符串

参数

struct snd_card *card

声卡结构

const char *component

组件 ID 字符串

此函数将组件 ID 字符串添加到支持列表中。组件可以从 alsa-lib 中引用。

返回

成功时返回零，否则返回负错误代码。

int snd_card_file_add(struct snd_card *card, struct file *file)¶: 将文件添加到声卡的文件列表中

参数

struct snd_card *card

声卡结构

struct file *file

文件指针

此函数将文件添加到声卡的文件链表中。此链表用于跟踪连接状态，并避免热插拔释放忙碌的资源。

返回

成功时返回零，否则返回负错误代码。

int snd_card_file_remove(struct snd_card *card, struct file *file)¶: 从文件列表中删除文件

参数

struct snd_card *card

声卡结构

struct file *file

文件指针

此函数删除先前通过 snd_card_file_add() 函数添加到声卡的文件。如果所有文件都已删除并且之前调用了 snd_card_free_when_closed()，它将处理挂起的资源释放。

返回

成功时返回零，否则返回负错误代码。

int snd_power_ref_and_wait(struct snd_card *card)¶: 等待声卡上电

参数

struct snd_card *card: 声卡结构

描述

获取给定声卡的 power_ref 引用计数，并等待声卡上电到 SNDRV_CTL_POWER_D0 状态。当睡眠直到上电时，引用计数会再次下降，因此此函数可用于同步浮动控制操作的访问，通常在调用控制操作时使用。

无论此函数是否返回错误，调用者都需要稍后通过 snd_power_unref() 来降低引用计数。

返回

成功时返回零，否则返回负错误代码。

int snd_power_wait(struct snd_card *card)¶: 等待声卡上电（旧形式）

参数

struct snd_card *card: 声卡结构

描述

等待声卡上电到 SNDRV_CTL_POWER_D0 状态。

返回

成功时返回零，否则返回负错误代码。

设备组件¶

int snd_device_new(struct snd_card *card, enum snd_device_type type, void *device_data, const struct snd_device_ops *ops)¶: 创建 ALSA 设备组件

参数

struct snd_card *card: 声卡实例
enum snd_device_type type: 设备类型，SNDRV_DEV_XXX
void *device_data: 此设备的数据指针
const struct snd_device_ops *ops: 操作符表

描述

为给定的数据指针创建一个新的设备组件。该设备将被分配给声卡，并由声卡一起管理。

数据指针也扮演标识符的角色，因此指针地址必须是唯一的且不变的。

返回

成功时返回零，失败时返回负错误代码。

void snd_device_disconnect(struct snd_card *card, void *device_data)¶: 断开设备连接

参数

struct snd_card *card: 声卡实例
void *device_data: 要断开连接的数据指针

描述

将设备置于断开连接状态，如果设备已注册，则调用 dev_disconnect 回调。

通常从 snd_card_disconnect() 调用。

返回

成功时返回零，失败或未找到设备时返回负错误代码。

void snd_device_free(struct snd_card *card, void *device_data)¶: 从卡中释放设备

参数

struct snd_card *card: 声卡实例
void *device_data: 要释放的数据指针

描述

从卡上的列表中移除设备，并调用与状态对应的回调函数 dev_disconnect 和 dev_free。然后释放设备。

int snd_device_register(struct snd_card *card, void *device_data)¶: 注册设备

参数

struct snd_card *card: 声卡实例
void *device_data: 要注册的数据指针

描述

注册已通过 snd_device_new() 创建的设备。通常从 snd_card_register() 调用此函数，但如果在调用 snd_card_register() 后创建任何新设备，则可以稍后调用此函数。

返回

成功时返回零，失败或未找到设备时返回负错误代码。

int snd_device_get_state(struct snd_card *card, void *device_data)¶: 获取给定设备的当前状态

参数

struct snd_card *card: 声卡实例
void *device_data: 要释放的数据指针

描述

返回给定设备对象的当前状态。对于有效的设备，将返回 SNDRV_DEV_BUILD、SNDRV_DEV_REGISTERED 或 SNDRV_DEV_DISCONNECTED。对于不存在的设备，则返回 -1 作为错误。

返回

当前状态，如果未找到则返回 -1

模块请求和设备文件条目¶

void snd_request_card(int card)¶: 尝试加载卡模块

参数

int card: 卡号

描述

尝试通过 request_module 加载给定卡号的模块 “snd-card-X”。如果已加载，则立即返回。

void *snd_lookup_minor_data(unsigned int minor, int type)¶: 获取已注册设备的用户数据

参数

unsigned int minor: 次设备号
int type: 设备类型 (SNDRV_DEVICE_TYPE_XXX)

描述

检查是否已注册具有指定类型的次设备，并返回其用户数据指针。

如果找到与给定次设备号和类型关联的实例，此函数会递增卡实例的引用计数器。调用者必须稍后适当调用 snd_card_unref()。

返回

如果找到指定的设备，则返回用户数据指针。否则返回 NULL。

int snd_register_device(int type, struct snd_card *card, int dev, const struct file_operations *f_ops, void *private_data, struct device *device)¶: 为卡注册 ALSA 设备文件

参数

int type: 设备类型，SNDRV_DEVICE_TYPE_XXX
struct snd_card *card: 声卡实例
int dev: 设备索引
const struct file_operations *f_ops: 文件操作
void *private_data: f_ops->open() 的用户指针
struct device *device: 要注册的设备

描述

为给定卡注册 ALSA 设备文件。操作符必须在 reg 参数中设置。

返回

成功时返回零，失败时返回负错误代码。

int snd_unregister_device(struct device *dev)¶: 注销给定卡上的设备

参数

struct device *dev: 设备实例

描述

注销已通过 snd_register_device() 注册的设备文件。

返回

成功时返回零，失败时返回负错误代码。

内存管理助手¶

int copy_to_user_fromio(void __user *dst, volatile const void __iomem *src, size_t count)¶: 将数据从 mmio 空间复制到用户空间

参数

void __user *dst: 用户空间的目标指针
const volatile void __iomem *src: mmio 上的源指针
size_t count: 要复制的数据大小，以字节为单位

描述

将数据从 mmio 空间复制到用户空间。

返回

成功时返回零，失败时返回非零值。

int copy_to_iter_fromio(struct iov_iter *dst, const void __iomem *src, size_t count)¶: 将数据从 mmio 空间复制到 iov_iter

参数

struct iov_iter *dst: 目标 iov_iter
const void __iomem *src: mmio 上的源指针
size_t count: 要复制的数据大小，以字节为单位

描述

将数据从 mmio 空间复制到 iov_iter。

返回

成功时返回零，失败时返回非零值。

int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count)¶: 将数据从用户空间复制到 mmio 空间

参数

volatile void __iomem *dst: mmio 空间中的目标指针
const void __user *src: 用户空间中的源指针
size_t count: 要复制的数据大小，以字节为单位

描述

将数据从用户空间复制到 mmio 空间。

返回

成功时返回零，失败时返回非零值。

int copy_from_iter_toio(void __iomem *dst, struct iov_iter *src, size_t count)¶: 将数据从 iov_iter 复制到 mmio 空间

参数

void __iomem *dst: mmio 空间中的目标指针
struct iov_iter *src: 源 iov_iter
size_t count: 要复制的数据大小，以字节为单位

描述

将数据从 iov_iter 复制到 mmio 空间。

返回

成功时返回零，失败时返回非零值。

int snd_dma_alloc_dir_pages(int type, struct device *device, enum dma_data_direction dir, size_t size, struct snd_dma_buffer *dmab)¶: 根据给定的类型和方向分配缓冲区区域

参数

int type: DMA 缓冲区类型
struct device *device: 设备指针
enum dma_data_direction dir: DMA 方向
size_t size: 要分配的缓冲区大小
struct snd_dma_buffer *dmab: 用于存储已分配数据的缓冲区分配记录

描述

为相应的缓冲区类型调用内存分配器函数。

返回

如果成功分配给定大小的缓冲区，则为零；否则，如果发生错误，则为负值。

int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size, struct snd_dma_buffer *dmab)¶: 根据给定的类型和回退分配缓冲区区域

参数

int type: DMA 缓冲区类型
struct device *device: 设备指针
size_t size: 要分配的缓冲区大小
struct snd_dma_buffer *dmab: 用于存储已分配数据的缓冲区分配记录

描述

为相应的缓冲区类型调用内存分配器函数。当没有剩余空间时，此函数会减小大小并尝试再次分配。实际分配的大小存储在 res_size 参数中。

返回

如果成功分配给定大小的缓冲区，则为零；否则，如果发生错误，则为负值。

void snd_dma_free_pages(struct snd_dma_buffer *dmab)¶: 释放已分配的缓冲区

参数

struct snd_dma_buffer *dmab: 要释放的缓冲区分配记录

描述

通过 snd_dma_alloc_pages() 释放已分配的缓冲区。

struct snd_dma_buffer *snd_devm_alloc_dir_pages(struct device *dev, int type, enum dma_data_direction dir, size_t size)¶: 分配缓冲区并使用 devres 进行管理

参数

struct device *dev: 设备指针
int type: DMA 缓冲区类型
enum dma_data_direction dir: DMA 方向
size_t size: 要分配的缓冲区大小

描述

根据给定的类型分配缓冲区页，并使用 devres 进行管理。这些页将在设备移除时自动释放。

与 snd_dma_alloc_pages() 不同，此函数需要实际的设备指针，因此不能与 SNDRV_DMA_TYPE_CONTINUOUS 或 SNDRV_DMA_TYPE_VMALLOC 类型一起使用。

返回

成功时的 snd_dma_buffer 对象，如果失败则为 NULL

int snd_dma_buffer_mmap(struct snd_dma_buffer *dmab, struct vm_area_struct *area)¶: 执行给定 DMA 缓冲区的 mmap

参数

struct snd_dma_buffer *dmab: 缓冲区分配信息
struct vm_area_struct *area: VM 区域信息

返回

如果成功，则为零，否则为负错误代码

void snd_dma_buffer_sync(struct snd_dma_buffer *dmab, enum snd_dma_sync_mode mode)¶: 在 CPU 和设备之间同步 DMA 缓冲区

参数

struct snd_dma_buffer *dmab: 缓冲区分配信息
enum snd_dma_sync_mode mode: 同步模式

dma_addr_t snd_sgbuf_get_addr(struct snd_dma_buffer *dmab, size_t offset)¶: 返回相应偏移量处的物理地址

参数

struct snd_dma_buffer *dmab: 缓冲区分配信息
size_t offset: 环形缓冲区中的偏移量

返回

物理地址

struct page *snd_sgbuf_get_page(struct snd_dma_buffer *dmab, size_t offset)¶: 返回相应偏移量处的物理页

参数

struct snd_dma_buffer *dmab: 缓冲区分配信息
size_t offset: 环形缓冲区中的偏移量

返回

页指针

unsigned int snd_sgbuf_get_chunk_size(struct snd_dma_buffer *dmab, unsigned int ofs, unsigned int size)¶: 计算 sg 缓冲区上连续页的最大块大小

参数

struct snd_dma_buffer *dmab: 缓冲区分配信息
unsigned int ofs: 环形缓冲区中的偏移量
unsigned int size: 请求的大小

返回

块大小

PCM API¶

PCM 核心¶

const char *snd_pcm_format_name(snd_pcm_format_t format)¶: 返回给定 PCM 格式的名称字符串

参数

snd_pcm_format_t format: PCM 格式

返回

格式名称字符串

int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)¶: 创建新的 PCM 流

参数

struct snd_pcm *pcm: pcm 实例
int stream: 流方向，SNDRV_PCM_STREAM_XXX
int substream_count: 子流的数量

描述

为 PCM 创建一个新的流。在调用此函数之前，PCM 上的对应流必须为空，即必须为 snd_pcm_new() 的参数传递零。

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_new(struct snd_card *card, const char *id, int device, int playback_count, int capture_count, struct snd_pcm **rpcm)¶: 创建一个新的 PCM 实例

参数

struct snd_card *card: 声卡实例
const char *id: id 字符串
int device: 设备索引（从零开始）
int playback_count: 回放的子流数量
int capture_count: 捕获的子流数量
struct snd_pcm **rpcm: 用于存储新 PCM 实例的指针

描述

创建一个新的 PCM 实例。

PCM 操作符必须在之后通过 snd_pcm_set_ops() 设置到新实例。

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_new_internal(struct snd_card *card, const char *id, int device, int playback_count, int capture_count, struct snd_pcm **rpcm)¶: 创建一个新的内部 PCM 实例

参数

struct snd_card *card: 声卡实例
const char *id: id 字符串
int device: 设备索引（从零开始 - 与普通 PCM 共享）
int playback_count: 回放的子流数量
int capture_count: 捕获的子流数量
struct snd_pcm **rpcm: 用于存储新 PCM 实例的指针

描述

创建一个新的内部 PCM 实例，没有用户空间设备或 procfs 条目。这被 ASoC 后端 PCM 用来创建一个只能被内核驱动程序在内部使用的 PCM。也就是说，它不能被用户空间打开。它为现有的 ASoC 组件驱动程序提供了一个子流，并可以访问任何私有数据。

PCM 操作符必须在之后通过 snd_pcm_set_ops() 设置到新实例。

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)¶: 添加/删除通知列表

参数

struct snd_pcm_notify *notify: PCM 通知列表
int nfree: 0 = 注册, 1 = 注销

描述

此函数将给定的通知器添加到全局列表中，以便为每个注册的 PCM 设备调用回调。到目前为止，这仅用于 PCM OSS 仿真。

返回

如果成功，则为零，否则为负错误代码

void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, const struct snd_pcm_ops *ops)¶: 设置 PCM 操作符

参数

struct snd_pcm *pcm: pcm 实例
int direction: 流方向, SNDRV_PCM_STREAM_XXX
const struct snd_pcm_ops *ops: 操作符表

描述

将给定的 PCM 操作符设置到 PCM 实例。

void snd_pcm_set_sync_per_card(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, const unsigned char *id, unsigned int len)¶: 设置带有声卡编号的 PCM 同步 ID

参数

struct snd_pcm_substream *substream: PCM 子流
struct snd_pcm_hw_params *params: 修改后的硬件参数
const unsigned char *id: 标识符（最大 12 字节）
unsigned int len: 标识符长度（最大 12 字节）

描述

设置带有零填充的声卡 PCM 同步标识符。

用户空间或任何用户应仅使用此 16 字节的标识符进行比较，以检查两个 ID 是否相似或不同。特殊情况是标识符仅包含零。此组合的解释是 - 空（未设置）。标识符的内容不应以任何其他方式解释。

每个时钟源的同步 ID 必须是唯一的（通常是一个声卡，但多个声卡可以使用一个 PCM 字时钟源，这意味着它们是完全同步的）。

此例程使用前四个字节中的声卡编号和 12 字节的附加 ID 来组成此 ID。当使用其他 ID 组成（例如，用于多个声卡）时，请确保该组成不会与此组成方案冲突。

int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)¶: 细化配置器的区间值

参数

struct snd_interval *i: 要细化的区间值
const struct snd_interval *v: 要引用的区间值

描述

使用参考值细化区间值。区间被更改为满足两个区间的范围。评估区间状态（最小、最大、整数等）。

返回

如果该值已更改，则为正值；如果未更改，则为零；或者为负错误代码。

void snd_interval_div(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)¶: 使用除法细化区间值

参数

const struct snd_interval *a: 被除数
const struct snd_interval *b: 除数
struct snd_interval *c: 商

描述

c = a / b

如果该值已更改，则返回非零值；如果未更改，则返回零。

void snd_interval_muldivk(const struct snd_interval *a, const struct snd_interval *b, unsigned int k, struct snd_interval *c)¶: 细化区间值

参数

const struct snd_interval *a: 被除数 1
const struct snd_interval *b: 被除数 2
unsigned int k: 除数（作为整数）
struct snd_interval *c: 结果

描述

c = a * b / k

如果该值已更改，则返回非零值；如果未更改，则返回零。

void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k, const struct snd_interval *b, struct snd_interval *c)¶: 细化区间值

参数

const struct snd_interval *a: 被除数 1
unsigned int k: 除数 2 (整数形式)
const struct snd_interval *b: 除数
struct snd_interval *c: 结果

描述

c = a * k / b

如果该值已更改，则返回非零值；如果未更改，则返回零。

int snd_interval_ratnum(struct snd_interval *i, unsigned int rats_count, const struct snd_ratnum *rats, unsigned int *nump, unsigned int *denp)¶: 细化区间值

参数

struct snd_interval *i: 要精炼的区间
unsigned int rats_count: ratnum_t 的数量
const struct snd_ratnum *rats: ratnum_t 数组
unsigned int *nump: 指向存储结果分子指针
unsigned int *denp: 指向存储结果分母的指针

返回

如果该值已更改，则为正值；如果未更改，则为零；或者为负错误代码。

int snd_interval_ratden(struct snd_interval *i, unsigned int rats_count, const struct snd_ratden *rats, unsigned int *nump, unsigned int *denp)¶: 细化区间值

参数

struct snd_interval *i: 要精炼的区间
unsigned int rats_count: struct ratden 的数量
const struct snd_ratden *rats: struct ratden 数组
unsigned int *nump: 指向存储结果分子指针
unsigned int *denp: 指向存储结果分母的指针

返回

如果该值已更改，则为正值；如果未更改，则为零；或者为负错误代码。

int snd_interval_list(struct snd_interval *i, unsigned int count, const unsigned int *list, unsigned int mask)¶: 从列表中精炼区间值

参数

struct snd_interval *i: 要细化的区间值
unsigned int count: 列表中元素的数量
const unsigned int *list: 值列表
unsigned int mask: 用于评估的位掩码

描述

从列表中精炼区间值。当掩码非零时，仅评估与位 1 对应的元素。

返回

如果该值已更改，则为正值；如果未更改，则为零；或者为负错误代码。

int snd_interval_ranges(struct snd_interval *i, unsigned int count, const struct snd_interval *ranges, unsigned int mask)¶: 从范围列表中精炼区间值

参数

struct snd_interval *i: 要细化的区间值
unsigned int count: 范围列表中元素的数量
const struct snd_interval *ranges: 范围列表
unsigned int mask: 用于评估的位掩码

描述

从范围列表中精炼区间值。当掩码非零时，仅评估与位 1 对应的元素。

返回

如果该值已更改，则为正值；如果未更改，则为零；或者为负错误代码。

int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond, int var, snd_pcm_hw_rule_func_t func, void *private, int dep, ...)¶: 添加硬件约束规则

参数

struct snd_pcm_runtime *runtime: pcm 运行时实例
unsigned int cond: 条件位
int var: 要评估的变量
snd_pcm_hw_rule_func_t func: 评估函数
void *private: 传递给函数的私有数据指针
int dep: 依赖变量
...: 可变参数

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_constraint_mask(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, u_int32_t mask)¶: 应用给定的位图掩码约束

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
snd_pcm_hw_param_t var: 要应用掩码的 hw_params 变量
u_int32_t mask: 位图掩码

描述

将给定的位图掩码约束应用于 32 位掩码参数。

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_constraint_mask64(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, u_int64_t mask)¶: 应用给定的位图掩码约束

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
snd_pcm_hw_param_t var: 要应用掩码的 hw_params 变量
u_int64_t mask: 64 位位图掩码

描述

将给定的位图掩码约束应用于 64 位掩码参数。

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var)¶: 将整数约束应用于区间

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
snd_pcm_hw_param_t var: 要应用整数约束的 hw_params 变量

描述

将整数约束应用于区间参数。

返回

如果该值已更改，则为正值；如果未更改，则为零；或者为负错误代码。

int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, unsigned int min, unsigned int max)¶: 将最小/最大范围约束应用于区间

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
snd_pcm_hw_param_t var: 要应用范围的 hw_params 变量
unsigned int min: 最小值
unsigned int max: 最大值

描述

将最小/最大范围约束应用于区间参数。

返回

如果该值已更改，则为正值；如果未更改，则为零；或者为负错误代码。

int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, const struct snd_pcm_hw_constraint_list *l)¶: 将约束列表应用于参数

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
unsigned int cond: 条件位
snd_pcm_hw_param_t var: 应用列表约束的 hw_params 变量
const struct snd_pcm_hw_constraint_list *l: 列表

描述

将约束列表应用于区间参数。

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_constraint_ranges(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, const struct snd_pcm_hw_constraint_ranges *r)¶: 将范围约束列表应用于参数

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
unsigned int cond: 条件位
snd_pcm_hw_param_t var: 应用范围约束列表的 hw_params 变量
const struct snd_pcm_hw_constraint_ranges *r: 范围

描述

将范围约束列表应用于区间参数。

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, const struct snd_pcm_hw_constraint_ratnums *r)¶: 将 ratnums 约束应用于参数

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
unsigned int cond: 条件位
snd_pcm_hw_param_t var: 应用 ratnums 约束的 hw_params 变量
const struct snd_pcm_hw_constraint_ratnums *r: struct snd_ratnums 约束

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, const struct snd_pcm_hw_constraint_ratdens *r)¶: 将 ratdens 约束应用于参数

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
unsigned int cond: 条件位
snd_pcm_hw_param_t var: 应用 ratdens 约束的 hw_params 变量
const struct snd_pcm_hw_constraint_ratdens *r: struct snd_ratdens 约束

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, unsigned int cond, unsigned int width, unsigned int msbits)¶: 添加一个 hw 约束 msbits 规则

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
unsigned int cond: 条件位
unsigned int width: 采样位宽度
unsigned int msbits: msbits 宽度

描述

如果选择了具有指定宽度的采样格式，则此约束将设置最高有效位 (msbits) 的数量。如果 width 设置为 0，则将为任何宽度大于指定 msbits 的采样格式设置 msbits。

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var, unsigned long step)¶: 添加一个 hw 约束步长规则

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
unsigned int cond: 条件位
snd_pcm_hw_param_t var: 应用步长约束的 hw_params 变量
unsigned long step: 步长大小

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime, unsigned int cond, snd_pcm_hw_param_t var)¶: 添加一个 hw 约束 2 的幂规则

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
unsigned int cond: 条件位
snd_pcm_hw_param_t var: 应用 2 的幂约束的 hw_params 变量

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_rule_noresample(struct snd_pcm_runtime *runtime, unsigned int base_rate)¶: 添加一个规则以允许禁用硬件重采样

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
unsigned int base_rate: 硬件不进行重采样的速率

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir)¶: 返回 params 字段 var 的值

参数

const struct snd_pcm_hw_params *params: hw_params 实例
snd_pcm_hw_param_t var: 要检索的参数
int *dir: 指向方向（-1,0,1）的指针或 NULL

返回

如果 var 字段在 params 定义的配置空间中是固定的，则返回其值。否则返回 -EINVAL。

int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir)¶: 优化配置空间并返回最小值

参数

struct snd_pcm_substream *pcm: PCM 实例
struct snd_pcm_hw_params *params: hw_params 实例
snd_pcm_hw_param_t var: 要检索的参数
int *dir: 指向方向（-1,0,1）的指针或 NULL

描述

在 params 定义的配置空间内，从 var 中删除所有 > 最小值的值。相应地减小配置空间。

返回

最小值，或者失败时返回一个负的错误代码。

int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var, int *dir)¶: 优化配置空间并返回最大值

参数

struct snd_pcm_substream *pcm: PCM 实例
struct snd_pcm_hw_params *params: hw_params 实例
snd_pcm_hw_param_t var: 要检索的参数
int *dir: 指向方向（-1,0,1）的指针或 NULL

描述

在 params 定义的配置空间内，从 var 中删除所有 < 最大值的值。相应地减小配置空间。

返回

最大值，或者失败时返回一个负的错误代码。

int snd_pcm_hw_params_bits(const struct snd_pcm_hw_params *p)¶: 获取每个采样的位数。

参数

const struct snd_pcm_hw_params *p: 硬件参数

返回

根据指定的硬件参数的格式、子格式和 msbits，计算每个采样的位数。

int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg)¶: 通用的 PCM ioctl 回调函数

参数

struct snd_pcm_substream *substream: PCM 子流实例
unsigned int cmd: ioctl 命令
void *arg: ioctl 参数

描述

处理 PCM 的通用 ioctl 命令。可以作为 PCM 操作的 ioctl 回调函数传递。

返回

成功时返回零，失败时返回负错误代码。

void snd_pcm_period_elapsed_under_stream_lock(struct snd_pcm_substream *substream)¶: 在获取 PCM 子流锁的情况下，更新下一个周期的运行时状态。

参数

struct snd_pcm_substream *substream: PCM 子流的实例。

描述

当音频数据传输中，一批音频数据帧的大小与缓冲区周期相同时，将调用此函数。

此函数调用会使用音频数据传输的最新位置更新运行时状态，检查缓冲区溢出和欠载，唤醒等待可用音频数据帧的用户进程，采样音频时间戳，并根据配置的阈值执行停止或清空 PCM 子流的操作。

此函数旨在用于 PCM 驱动程序在获取 PCM 子流锁的情况下操作音频数据帧的情况；例如，在进程上下文中snd_pcm_ops的任何操作的回调中。在任何中断上下文中，最好使用snd_pcm_period_elapsed()，因为应该提前获取 PCM 子流的锁。

开发人员应注意，snd_pcm_ops中的某些回调是通过调用此函数完成的。

.pointer - 通过帧计数或 XRUN 状态检索音频数据传输的当前位置。
.trigger - 在 XRUN 或 DRAINING 状态下使用 SNDRV_PCM_TRIGGER_STOP。
.get_time_info - 如果需要，检索音频时间戳。

即使自上次调用以来已经过了一个以上的周期，也只需要调用一次此函数。

void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)¶: 通过获取 PCM 子流的锁，更新下一个周期的运行时状态。

参数

struct snd_pcm_substream *substream: PCM 子流的实例。

描述

此函数与snd_pcm_period_elapsed_under_stream_lock()非常相似，不同之处在于它会主动获取 PCM 子流的锁。

通常在硬件 IRQ 发生时由任何类型的 IRQ 处理程序调用，以通知事件：一批大小与缓冲区周期相同的音频数据帧已在音频数据传输中处理完毕。

int snd_pcm_add_chmap_ctls(struct snd_pcm *pcm, int stream, const struct snd_pcm_chmap_elem *chmap, int max_channels, unsigned long private_value, struct snd_pcm_chmap **info_ret)¶: 创建通道映射控制元素

参数

struct snd_pcm *pcm: 已分配的 PCM 实例
int stream: 流方向
const struct snd_pcm_chmap_elem *chmap: 通道映射元素 (用于查询)
int max_channels: 流的最大通道数
unsigned long private_value: 传递给每个 kcontrol 的 private_value 字段的值
struct snd_pcm_chmap **info_ret: 如果非 NULL，则存储 struct snd_pcm_chmap 实例

描述

创建分配给给定 PCM 流的通道映射控制元素。

返回

成功时返回零，或返回负错误值。

void snd_pcm_stream_lock(struct snd_pcm_substream *substream)¶: 锁定 PCM 流

参数

struct snd_pcm_substream *substream: PCM 子流

描述

这将锁定 PCM 流的自旋锁或互斥锁，具体取决于给定子流的非原子标志。它还会获取全局链接读写锁（或读写信号量），以避免与链接流发生竞争。

void snd_pcm_stream_unlock(struct snd_pcm_substream *substream)¶: 解锁 PCM 流

参数

struct snd_pcm_substream *substream: PCM 子流

描述

这将解锁已通过snd_pcm_stream_lock()锁定的 PCM 流。

void snd_pcm_stream_lock_irq(struct snd_pcm_substream *substream)¶: 锁定 PCM 流

参数

struct snd_pcm_substream *substream: PCM 子流

描述

这像snd_pcm_stream_lock()一样锁定 PCM 流，并禁用本地 IRQ（仅当 nonatomic 为 false 时）。在非原子情况下，这与snd_pcm_stream_lock()相同。

void snd_pcm_stream_unlock_irq(struct snd_pcm_substream *substream)¶: 解锁 PCM 流

参数

struct snd_pcm_substream *substream: PCM 子流

描述

这是snd_pcm_stream_lock_irq()的对应项。

void snd_pcm_stream_unlock_irqrestore(struct snd_pcm_substream *substream, unsigned long flags)¶: 解锁 PCM 流

参数

struct snd_pcm_substream *substream: PCM 子流
unsigned long flags: irq 标志

描述

这是snd_pcm_stream_lock_irqsave()的对应项。

int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params)¶: 选择由 params 定义的配置

参数

struct snd_pcm_substream *pcm: PCM 实例
struct snd_pcm_hw_params *params: hw_params 实例

描述

从 params 定义的配置空间中选择一个配置。选择的配置是通过以下顺序固定的：首先访问，首先格式，首先子格式，最小通道数，最小速率，最小周期时间，最大缓冲区大小，最小滴答时间。

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_start(struct snd_pcm_substream *substream)¶: 启动所有链接的流

参数

struct snd_pcm_substream *substream: PCM 子流实例

返回

成功时返回零，或返回负错误代码。在调用此函数之前，必须先获取流锁。

int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t state)¶: 尝试停止子流组中所有正在运行的流

参数

struct snd_pcm_substream *substream: PCM 子流实例
snd_pcm_state_t state: 停止流后的 PCM 状态

描述

然后，每个流的状态都会无条件地更改为给定的状态。

返回

成功时返回零，否则返回负错误代码。

int snd_pcm_drain_done(struct snd_pcm_substream *substream)¶: 仅当给定流是回放时才停止 DMA

参数

struct snd_pcm_substream *substream: PCM 子流

描述

停止后，状态将更改为 SETUP。与 snd_pcm_stop() 不同，这仅影响给定的流。

返回

成功时返回零，否则返回负错误代码。

int snd_pcm_stop_xrun(struct snd_pcm_substream *substream)¶: 将正在运行的流停止为 XRUN

参数

struct snd_pcm_substream *substream: PCM 子流实例

描述

这将以 XRUN 的形式停止给定的正在运行的子流（以及所有链接的子流）。与 snd_pcm_stop() 不同，此函数会自行获取子流锁。

返回

成功时返回零，否则返回负错误代码。

int snd_pcm_suspend_all(struct snd_pcm *pcm)¶: 触发给定 pcm 中所有子流的暂停

参数

struct snd_pcm *pcm: PCM 实例

描述

调用此函数后，所有流都将更改为暂停状态。

返回

如果成功（或者 pcm 是 NULL），则返回零，否则返回负错误代码。

int snd_pcm_prepare(struct snd_pcm_substream *substream, struct file *file)¶: 准备 PCM 子流以使其可触发

参数

struct snd_pcm_substream *substream: PCM 子流实例
struct file *file: 用于引用 f_flags 的文件

返回

成功时返回零，否则返回负错误代码。

int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg)¶: 在内核空间中执行 PCM ioctl

参数

struct snd_pcm_substream *substream: PCM 子流
unsigned int cmd: IOCTL 命令
void *arg: IOCTL 参数

描述

此函数主要为 OSS 层和 USB gadget 驱动程序提供，它只允许有限的 ioctl 集（hw_params、sw_params、prepare、start、drain、drop、forward）。

返回

如果成功，则为零，否则为负错误代码

int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream, struct vm_area_struct *area)¶: 默认 PCM 数据 mmap 函数

参数

struct snd_pcm_substream *substream: PCM 子流
struct vm_area_struct *area: VMA

描述

这是 PCM 数据的默认 mmap 处理程序。当 mmap pcm_ops 为 NULL 时，会隐式调用此函数。

返回

如果成功，则为零，否则为负错误代码

int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream, struct vm_area_struct *area)¶: I/O 内存的默认 PCM 数据 mmap 函数

参数

struct snd_pcm_substream *substream: PCM 子流
struct vm_area_struct *area: VMA

描述

当您的硬件使用 iomapped 页面作为硬件缓冲区并想要 mmap 它时，请将此函数作为 mmap pcm_ops 传递。请注意，这应该只在有限的架构上工作。

返回

如果成功，则为零，否则为负错误代码

int snd_pcm_stream_linked(struct snd_pcm_substream *substream)¶: 检查子流是否与其他子流链接

参数

struct snd_pcm_substream *substream: 要检查的子流

返回

如果给定的子流与其他子流链接，则为 true

snd_pcm_stream_lock_irqsave¶

snd_pcm_stream_lock_irqsave (substream, flags)

锁定 PCM 流

参数

子流: PCM 子流
标志: irq 标志

描述

这会像 snd_pcm_stream_lock() 一样锁定 PCM 流，但带有本地 IRQ（仅当 nonatomic 为 false 时）。在 nonatomic 情况下，这与 snd_pcm_stream_lock() 相同。

snd_pcm_stream_lock_irqsave_nested¶

snd_pcm_stream_lock_irqsave_nested (substream, flags)

单层嵌套 PCM 流锁定

参数

子流: PCM 子流
标志: irq 标志

描述

这会像 snd_pcm_stream_lock_irqsave() 一样锁定 PCM 流，但带有单深度 lockdep 子类。

snd_pcm_group_for_each_entry¶

snd_pcm_group_for_each_entry (s, substream)

迭代链接的子流

参数

s: 迭代器
子流: 子流

描述

迭代到给定 substream 的所有链接的子流。当 substream 未与任何其他子流链接时，这将返回 substream 本身一次。

int snd_pcm_running(struct snd_pcm_substream *substream)¶: 检查子流是否处于运行状态

参数

struct snd_pcm_substream *substream: 要检查的子流

返回

如果给定的子流处于 RUNNING 状态，或者对于回放处于 DRAINING 状态，则为 true。

void __snd_pcm_set_state(struct snd_pcm_runtime *runtime, snd_pcm_state_t state)¶: 更改当前的 PCM 状态

参数

struct snd_pcm_runtime *runtime: 要设置的 PCM 运行时
snd_pcm_state_t state: 要设置的当前状态

描述

在流锁内调用

ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size)¶: 将大小从字节转换为样本的单位转换

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
ssize_t size: 以字节为单位的大小

返回

以样本为单位的大小

snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size)¶: 将大小从字节转换为帧的单位转换

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
ssize_t size: 以字节为单位的大小

返回

以帧为单位的大小

ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size)¶: 将大小从样本转换为字节的单位转换

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
ssize_t size: 以样本为单位的大小

返回

字节大小

ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size)¶: 将大小从帧转换为字节的单位转换

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
snd_pcm_sframes_t size: 以帧为单位的大小

返回

字节大小

int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes)¶: 检查字节大小是否与帧对齐

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
ssize_t bytes: 以字节为单位的大小

返回

如果对齐则为 true，否则为 false

size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream)¶: 获取当前 PCM 的缓冲区大小（以字节为单位）

参数

struct snd_pcm_substream *substream: PCM 子流

返回

缓冲区字节大小

size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream)¶: 获取当前 PCM 的周期大小（以字节为单位）

参数

struct snd_pcm_substream *substream: PCM 子流

返回

周期字节大小

snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime)¶: 获取可用于回放的可用（可写）空间

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例

描述

结果介于 0 ... (边界 - 1) 之间

返回

可用帧大小

snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime)¶: 获取可用于捕获的可用（可读）空间

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例

描述

结果介于 0 ... (边界 - 1) 之间

返回

可用帧大小

snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime)¶: 获取回放的排队空间

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例

返回

可用帧大小

snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime)¶: 获取捕获的可用空间

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例

返回

可用帧大小

int snd_pcm_playback_ready(struct snd_pcm_substream *substream)¶: 检查回放缓冲区是否可用

参数

struct snd_pcm_substream *substream: PCM 子流实例

描述

检查回放缓冲区上是否有足够的可用空间。

返回

如果可用则为非零，否则为零。

int snd_pcm_capture_ready(struct snd_pcm_substream *substream)¶: 检查捕获缓冲区是否可用

参数

struct snd_pcm_substream *substream: PCM 子流实例

描述

检查捕获缓冲区上是否有足够的捕获数据可用。

返回

如果可用则为非零，否则为零。

int snd_pcm_playback_data(struct snd_pcm_substream *substream)¶: 检查回放缓冲区上是否存在任何数据

参数

struct snd_pcm_substream *substream: PCM 子流实例

描述

检查回放缓冲区上是否存在任何数据。

返回

如果存在任何数据则为非零，否则为零。如果 stop_threshold 大于或等于边界，则此函数始终返回非零。

int snd_pcm_playback_empty(struct snd_pcm_substream *substream)¶: 检查回放缓冲区是否为空

参数

struct snd_pcm_substream *substream: PCM 子流实例

描述

检查回放缓冲区是否为空。

返回

如果为空则为非零，否则为零。

int snd_pcm_capture_empty(struct snd_pcm_substream *substream)¶: 检查捕获缓冲区是否为空

参数

struct snd_pcm_substream *substream: PCM 子流实例

描述

检查捕获缓冲区是否为空。

返回

如果为空则为非零，否则为零。

void snd_pcm_trigger_done(struct snd_pcm_substream *substream, struct snd_pcm_substream *master)¶: 标记主子流

参数

struct snd_pcm_substream *substream: PCM 子流实例
struct snd_pcm_substream *master: 链接的主子流

描述

当同一声卡的多个子流链接且硬件支持单次操作时，驱动程序在 snd_pcm_group_for_each_entry() 的循环中调用此函数，以将子流标记为“完成”。然后，大多数触发操作仅对给定的主子流执行。

trigger_master 标记在触发操作结束时的时间戳更新时清除。

unsigned int params_channels(const struct snd_pcm_hw_params *p)¶: 从 hw 参数获取通道数

参数

const struct snd_pcm_hw_params *p: hw 参数

返回

通道数

unsigned int params_rate(const struct snd_pcm_hw_params *p)¶: 从 hw 参数获取采样率

参数

const struct snd_pcm_hw_params *p: hw 参数

返回

采样率

unsigned int params_period_size(const struct snd_pcm_hw_params *p)¶: 从 hw 参数获取周期大小（以帧为单位）

参数

const struct snd_pcm_hw_params *p: hw 参数

返回

以帧为单位的周期大小

unsigned int params_periods(const struct snd_pcm_hw_params *p)¶: 从 hw 参数获取周期数

参数

const struct snd_pcm_hw_params *p: hw 参数

返回

周期数

unsigned int params_buffer_size(const struct snd_pcm_hw_params *p)¶: 从硬件参数中获取缓冲区大小（以帧为单位）

参数

const struct snd_pcm_hw_params *p: hw 参数

返回

缓冲区大小（以帧为单位）

unsigned int params_buffer_bytes(const struct snd_pcm_hw_params *p)¶: 从硬件参数中获取缓冲区大小（以字节为单位）

参数

const struct snd_pcm_hw_params *p: hw 参数

返回

缓冲区大小（以字节为单位）

int snd_pcm_hw_constraint_single(struct snd_pcm_runtime *runtime, snd_pcm_hw_param_t var, unsigned int val)¶: 将参数约束为单个值

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
snd_pcm_hw_param_t var: 要约束的 hw_params 变量
unsigned int val: 要约束到的值

返回

如果该值已更改，则为正值；如果未更改，则为零；或者为负错误代码。

int snd_pcm_format_cpu_endian(snd_pcm_format_t format)¶: 检查 PCM 格式是否为 CPU 端序

参数

snd_pcm_format_t format: 要检查的格式

返回

如果给定的 PCM 格式为 CPU 端序，则返回 1；如果相反，则返回 0；如果未指定端序，则返回负错误代码。

void snd_pcm_set_sync(struct snd_pcm_substream *substream)¶: 设置 PCM 同步 ID

参数

struct snd_pcm_substream *substream: PCM 子流

描述

为特定卡使用默认的 PCM 同步标识符。

void snd_pcm_set_runtime_buffer(struct snd_pcm_substream *substream, struct snd_dma_buffer *bufp)¶: 设置 PCM 运行时缓冲区

参数

struct snd_pcm_substream *substream: 要设置的 PCM 子流
struct snd_dma_buffer *bufp: 缓冲区信息，NULL 表示清除

描述

当 **bufp** 非 NULL 时，将缓冲区信息复制到 runtime->dma_buffer。否则，它将清除当前缓冲区信息。

void snd_pcm_gettime(struct snd_pcm_runtime *runtime, struct timespec64 *tv)¶: 根据时间戳模式填充 timespec64

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例
struct timespec64 *tv: 要填充的 timespec64

int snd_pcm_set_fixed_buffer(struct snd_pcm_substream *substream, int type, struct device *data, size_t size)¶: 预先分配并设置固定大小的 PCM 缓冲区

参数

struct snd_pcm_substream *substream: PCM 子流实例
int type: DMA 类型 (SNDRV_DMA_TYPE_*)
struct device *data: DMA 类型相关数据
size_t size: 请求的预分配大小（以字节为单位）

描述

这是 snd_pcm_set_managed_buffer() 的一个变体，但它只预先分配给定大小的缓冲区，并且不允许重新分配或动态分配更大的缓冲区，这与标准版本不同。该函数可能返回 -ENOMEM 错误，因此调用者必须检查它。

返回

如果成功，则为零，否则为负错误代码

int snd_pcm_set_fixed_buffer_all(struct snd_pcm *pcm, int type, struct device *data, size_t size)¶: 预先分配并设置固定大小的 PCM 缓冲区

参数

struct snd_pcm *pcm: pcm 实例
int type: DMA 类型 (SNDRV_DMA_TYPE_*)
struct device *data: DMA 类型相关数据
size_t size: 请求的预分配大小（以字节为单位）

描述

通过 snd_pcm_set_fixed_buffer() 为所有子流应用固定缓冲区的设置。如果任何分配失败，则返回 -ENOMEM，因此调用者必须检查返回值。

返回

如果成功，则为零，否则为负错误代码

dma_addr_t snd_pcm_sgbuf_get_addr(struct snd_pcm_substream *substream, unsigned int ofs)¶: 获取相应偏移量处的 DMA 地址

参数

struct snd_pcm_substream *substream: PCM 子流
unsigned int ofs: 字节偏移量

返回

DMA 地址

unsigned int snd_pcm_sgbuf_get_chunk_size(struct snd_pcm_substream *substream, unsigned int ofs, unsigned int size)¶: 计算从给定大小开始，在连续页内能容纳的最大大小

参数

struct snd_pcm_substream *substream: PCM 子流
unsigned int ofs: 字节偏移量
unsigned int size: 要检查的字节大小

返回

块大小

void snd_pcm_limit_isa_dma_size(int dma, size_t *max)¶: 获取适合 ISA DMA 传输的最大大小

参数

int dma: DMA 编号
size_t *max: 用于存储最大大小的指针

const char *snd_pcm_direction_name(int direction)¶: 获取一个字符串，命名流的方向

参数

int direction: 流的方向，为 SNDRV_PCM_STREAM_XXX 之一

描述

返回一个命名流方向的字符串。

const char *snd_pcm_stream_str(struct snd_pcm_substream *substream)¶: 获取一个字符串，命名流的方向

参数

struct snd_pcm_substream *substream: PCM 子流实例

返回

一个命名流方向的字符串。

struct snd_pcm_substream *snd_pcm_chmap_substream(struct snd_pcm_chmap *info, unsigned int idx)¶: 获取分配给指定通道映射信息的 PCM 子流

参数

struct snd_pcm_chmap *info: 通道映射信息
unsigned int idx: 子流编号索引

返回

匹配的 PCM 子流，如果未找到则为 NULL

u64 pcm_format_to_bits(snd_pcm_format_t pcm_format)¶: 将 pcm_format 强类型转换为位表示

参数

snd_pcm_format_t pcm_format: PCM 格式

返回

与给定 PCM 格式对应的 64 位掩码

pcm_for_each_format¶

pcm_for_each_format (f)

用于遍历每种格式类型的辅助函数

参数

f: snd_pcm_format_t 类型的迭代器变量

PCM 格式辅助函数¶

int snd_pcm_format_signed(snd_pcm_format_t format)¶: 检查 PCM 格式是否为有符号线性

参数

snd_pcm_format_t format: 要检查的格式

返回

如果给定的 PCM 格式为有符号线性，则返回 1；如果为无符号线性，则返回 0；对于非线性格式，则返回负错误代码。

int snd_pcm_format_unsigned(snd_pcm_format_t format)¶: 检查 PCM 格式是否为无符号线性

参数

snd_pcm_format_t format: 要检查的格式

返回

如果给定的 PCM 格式为无符号线性，则返回 1；如果为有符号线性，则返回 0；对于非线性格式，则返回负错误代码。

int snd_pcm_format_linear(snd_pcm_format_t format)¶: 检查 PCM 格式是否为线性

参数

snd_pcm_format_t format: 要检查的格式

返回

如果给定的 PCM 格式为线性，则返回 1；否则返回 0。

int snd_pcm_format_little_endian(snd_pcm_format_t format)¶: 检查 PCM 格式是否为小端字节序

参数

snd_pcm_format_t format: 要检查的格式

返回

如果给定的 PCM 格式为小端字节序，则返回 1；如果为大端字节序，则返回 0；如果未指定字节序，则返回负错误代码。

int snd_pcm_format_big_endian(snd_pcm_format_t format)¶: 检查 PCM 格式是否为大端字节序

参数

snd_pcm_format_t format: 要检查的格式

返回

如果给定的 PCM 格式为大端字节序，则返回 1；如果为小端字节序，则返回 0；如果未指定字节序，则返回负错误代码。

int snd_pcm_format_width(snd_pcm_format_t format)¶: 返回格式的位宽度

参数

snd_pcm_format_t format: 要检查的格式

返回

格式的位宽度；如果格式未知，则返回负错误代码。

int snd_pcm_format_physical_width(snd_pcm_format_t format)¶: 返回格式的物理位宽度

参数

snd_pcm_format_t format: 要检查的格式

返回

格式的物理位宽度；如果格式未知，则返回负错误代码。

ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples)¶: 返回给定格式的采样字节大小

参数

snd_pcm_format_t format: 要检查的格式
size_t samples: 采样率

返回

给定格式的采样字节大小；如果格式未知，则返回负错误代码。

const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format)¶: 以 8 字节数组的形式返回静默数据

参数

snd_pcm_format_t format: 要检查的格式

返回

用于填充的格式模式，如果出错则返回 NULL。

int snd_pcm_format_set_silence(snd_pcm_format_t format, void *data, unsigned int samples)¶: 在缓冲区上设置静默数据

参数

snd_pcm_format_t format: PCM 格式
void *data: 缓冲区指针
unsigned int samples: 要设置静默的采样数

描述

为给定采样数在缓冲区上设置静默数据。

返回

成功时返回零，失败时返回负错误代码。

int snd_pcm_hw_limit_rates(struct snd_pcm_hardware *hw)¶: 确定 rate_min/rate_max 字段

参数

struct snd_pcm_hardware *hw: pcm 硬件实例

描述

从给定 hw 的速率位确定 rate_min 和 rate_max 字段。

返回

如果成功，则返回 0。

unsigned int snd_pcm_rate_to_rate_bit(unsigned int rate)¶: 将采样率转换为 SNDRV_PCM_RATE_xxx 位

参数

unsigned int rate: 要转换的采样率

返回

与给定速率对应的 SNDRV_PCM_RATE_xxx 标志；对于未知速率，则返回 SNDRV_PCM_RATE_KNOT。

unsigned int snd_pcm_rate_bit_to_rate(unsigned int rate_bit)¶: 将 SNDRV_PCM_RATE_xxx 位转换为采样率

参数

unsigned int rate_bit: 要转换的速率位

返回

与给定 SNDRV_PCM_RATE_xxx 标志对应的采样率；对于未知速率位，则返回 0。

unsigned int snd_pcm_rate_mask_intersect(unsigned int rates_a, unsigned int rates_b)¶: 计算两个速率掩码之间的交集

参数

unsigned int rates_a: 第一个速率掩码
unsigned int rates_b: 第二个速率掩码

描述

此函数计算两个传递给函数的速率掩码都支持的速率。它将处理 SNDRV_PCM_RATE_CONTINUOUS 和 SNDRV_PCM_RATE_KNOT 的特殊处理。

返回

包含 rates_a 和 rates_b 都支持的速率的速率掩码。

unsigned int snd_pcm_rate_range_to_bits(unsigned int rate_min, unsigned int rate_max)¶: 将采样率范围转换为 SNDRV_PCM_RATE_xxx 位。

参数

unsigned int rate_min: 最小采样率。
unsigned int rate_max: 最大采样率。

描述

此函数有一个隐含的假设：给定范围内的采样率只有预定义的速率，如 44100 或 16000。

返回

与给定采样率范围对应的 SNDRV_PCM_RATE_xxx 标志，或者对于未知范围的 SNDRV_PCM_RATE_KNOT。

PCM 内存管理¶

void snd_pcm_lib_preallocate_free(struct snd_pcm_substream *substream)¶: 释放指定子流的预分配缓冲区。

参数

struct snd_pcm_substream *substream: PCM 子流实例

描述

释放给定子流的预分配缓冲区。

void snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm)¶: 释放 PCM 上所有预分配的缓冲区。

参数

struct snd_pcm *pcm: pcm 实例

描述

释放给定 PCM 上所有预分配的缓冲区。

void snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream, int type, struct device *data, size_t size, size_t max)¶: 为给定的 DMA 类型预分配。

参数

struct snd_pcm_substream *substream: PCM 子流实例
int type: DMA 类型 (SNDRV_DMA_TYPE_*)
struct device *data: DMA 类型相关数据
size_t size: 请求的预分配大小（以字节为单位）
size_t max: 允许的最大预分配大小。

描述

为给定的 DMA 缓冲区类型执行预分配。

void snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm, int type, void *data, size_t size, size_t max)¶: 为连续内存类型（所有子流）预分配。

参数

struct snd_pcm *pcm: pcm 实例
int type: DMA 类型 (SNDRV_DMA_TYPE_*)
void *data: DMA 类型相关数据
size_t size: 请求的预分配大小（以字节为单位）
size_t max: 允许的最大预分配大小。

描述

为给定 PCM 的所有子流执行指定 DMA 类型的预分配。

int snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type, struct device *data, size_t size, size_t max)¶: 为子流设置缓冲区管理。

参数

struct snd_pcm_substream *substream: PCM 子流实例
int type: DMA 类型 (SNDRV_DMA_TYPE_*)
struct device *data: DMA 类型相关数据
size_t size: 请求的预分配大小（以字节为单位）
size_t max: 允许的最大预分配大小。

描述

为给定的 DMA 缓冲区类型执行预分配，并将托管缓冲区分配模式设置为给定的子流。在这种模式下，PCM 核心会在 PCM hw_params 操作调用之前自动分配缓冲区，并在 PCM hw_free 操作调用之后释放缓冲区，这样驱动程序就不需要在其回调中显式调用分配和释放。当缓冲区在 PCM hw_params 调用之前实际分配时，它会为驱动程序打开运行时 buffer_changed 标志，以便相应地更改其 h/w 参数。

当 **size** 非零且 **max** 为零时，它会尝试仅为确切的缓冲区大小分配，而不会回退，并且可能会返回 -ENOMEM。否则，如果分配失败，该函数会尝试分配较小的块。这是 snd_pcm_set_fixed_buffer() 的行为。

当 **size** 和 **max** 都为零时，该函数仅设置缓冲区以供稍后的动态分配。它通常用于 SNDRV_DMA_TYPE_VMALLOC 类型的缓冲区。

成功分配和设置缓冲区后，该函数返回 0。

返回

如果成功，则为零，否则为负错误代码

int snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type, struct device *data, size_t size, size_t max)¶: 为所有子流设置缓冲区管理。

参数

struct snd_pcm *pcm: pcm 实例
int type: DMA 类型 (SNDRV_DMA_TYPE_*)
struct device *data: DMA 类型相关数据
size_t size: 请求的预分配大小（以字节为单位）
size_t max: 允许的最大预分配大小。

描述

为给定 PCM 的所有子流执行指定 DMA 类型和大小的预分配，并将 managed_buffer_alloc 标志设置为每个子流。

返回

如果成功，则为零，否则为负错误代码

int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)¶: 分配 DMA 缓冲区。

参数

struct snd_pcm_substream *substream: 要为其分配 DMA 缓冲区的子流。
size_t size: 请求的缓冲区大小（以字节为单位）。

描述

在之前给 snd_pcm_lib_preallocate_xxx_pages() 的 BUS 类型上分配 DMA 缓冲区。

返回

如果缓冲区已更改，则为 1；如果未更改，则为 0；如果失败，则为负数代码。

int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)¶: 释放已分配的 DMA 缓冲区。

参数

struct snd_pcm_substream *substream: 要释放 DMA 缓冲区的子流。

描述

释放通过 snd_pcm_lib_malloc_pages() 分配的 DMA 缓冲区。

返回

成功时返回零，失败时返回负错误代码。

PCM DMA 引擎 API¶

int snd_hwparams_to_dma_slave_config(const struct snd_pcm_substream *substream, const struct snd_pcm_hw_params *params, struct dma_slave_config *slave_config)¶: 将 hw_params 转换为 dma_slave_config。

参数

const struct snd_pcm_substream *substream: PCM 子流
const struct snd_pcm_hw_params *params: hw_params。
struct dma_slave_config *slave_config: DMA 从设备配置。

描述

此函数可用于在基于 dmaengine 的 PCM 驱动程序实现中，从子流和 hw_params 初始化 dma_slave_config。

返回

如果成功，则为零，否则为负错误代码

void snd_dmaengine_pcm_set_config_from_dai_data(const struct snd_pcm_substream *substream, const struct snd_dmaengine_dai_dma_data *dma_data, struct dma_slave_config *slave_config)¶: 使用 DAI DMA 数据初始化 DMA 从设备配置。

参数

const struct snd_pcm_substream *substream: PCM 子流
const struct snd_dmaengine_dai_dma_data *dma_data: DAI DMA 数据。
struct dma_slave_config *slave_config: DMA 从设备配置。

描述

从 DAI DMA 数据结构的相同字段初始化 DMA 从设备配置的 {dst,src}_addr、{dst,src}_maxburst、{dst,src}_addr_width 字段。src 和 dst 字段将根据子流的方向进行初始化。如果子流是回放流，则会初始化 dst 字段；如果是捕获流，则会初始化 src 字段。仅当设置了 SND_DMAENGINE_PCM_DAI_FLAG_PACK 标志或者 DAI DMA 数据结构的 addr_width 字段不等于 DMA_SLAVE_BUSWIDTH_UNDEFINED 时，才会初始化 {dst,src}_addr_width 字段。如果两个条件都满足，则以前者为准。

int snd_dmaengine_pcm_trigger(struct snd_pcm_substream *substream, int cmd)¶: 基于 dmaengine 的 PCM 触发实现

参数

struct snd_pcm_substream *substream: PCM 子流
int cmd: 触发命令

描述

此函数可以用作基于 dmaengine 的 PCM 驱动程序实现的 PCM 触发回调。

返回

成功时返回 0，否则返回负错误代码

snd_pcm_uframes_t snd_dmaengine_pcm_pointer_no_residue(struct snd_pcm_substream *substream)¶: 基于 dmaengine 的 PCM 指针实现

参数

struct snd_pcm_substream *substream: PCM 子流

描述

此函数已弃用，新驱动程序不应使用它，因为其结果可能不可靠。

返回

PCM 位置，以帧为单位

snd_pcm_uframes_t snd_dmaengine_pcm_pointer(struct snd_pcm_substream *substream)¶: 基于 dmaengine 的 PCM 指针实现

参数

struct snd_pcm_substream *substream: PCM 子流

描述

此函数可以用作基于 dmaengine 的 PCM 驱动程序实现的 PCM 指针回调。

返回

PCM 位置，以帧为单位

struct dma_chan *snd_dmaengine_pcm_request_channel(dma_filter_fn filter_fn, void *filter_data)¶: 请求用于 dmaengine PCM 的通道

参数

dma_filter_fn filter_fn: 用于请求 DMA 通道的筛选函数
void *filter_data: 传递给 DMA 筛选函数的数据

描述

此函数请求一个 DMA 通道，用于 dmaengine PCM。

返回

NULL 或请求的 DMA 通道

int snd_dmaengine_pcm_open(struct snd_pcm_substream *substream, struct dma_chan *chan)¶: 打开基于 dmaengine 的 PCM 子流

参数

struct snd_pcm_substream *substream: PCM 子流
struct dma_chan *chan: 用于数据传输的 DMA 通道

描述

此函数通常应从 pcm 打开回调中调用。请注意，此函数将使用子流运行时的 private_data 字段。因此，它对您的 pcm 驱动程序实现不可用。

返回

成功时返回 0，否则返回负错误代码

int snd_dmaengine_pcm_open_request_chan(struct snd_pcm_substream *substream, dma_filter_fn filter_fn, void *filter_data)¶: 打开基于 dmaengine 的 PCM 子流并请求通道

参数

struct snd_pcm_substream *substream: PCM 子流
dma_filter_fn filter_fn: 用于请求 DMA 通道的筛选函数
void *filter_data: 传递给 DMA 筛选函数的数据

描述

此函数将使用传递的筛选函数和数据请求 DMA 通道。此函数通常应从 pcm 打开回调中调用。请注意，此函数将使用子流运行时的 private_data 字段。因此，它对您的 pcm 驱动程序实现不可用。

返回

成功时返回 0，否则返回负错误代码

int snd_dmaengine_pcm_close(struct snd_pcm_substream *substream)¶: 关闭基于 dmaengine 的 PCM 子流

参数

struct snd_pcm_substream *substream: PCM 子流

返回

成功时返回 0，否则返回负错误代码

int snd_dmaengine_pcm_close_release_chan(struct snd_pcm_substream *substream)¶: 关闭基于 dmaengine 的 PCM 子流并释放通道

参数

struct snd_pcm_substream *substream: PCM 子流

描述

释放与 PCM 子流关联的 DMA 通道。

返回

如果成功，则为零，否则为负错误代码

int snd_dmaengine_pcm_refine_runtime_hwparams(struct snd_pcm_substream *substream, struct snd_dmaengine_dai_dma_data *dma_data, struct snd_pcm_hardware *hw, struct dma_chan *chan)¶: 优化运行时硬件参数

参数

struct snd_pcm_substream *substream: PCM 子流
struct snd_dmaengine_dai_dma_data *dma_data: DAI DMA 数据。
struct snd_pcm_hardware *hw: PCM 硬件参数
struct dma_chan *chan: 用于数据传输的 DMA 通道

描述

此函数将查询 DMA 功能，然后优化 pcm 硬件参数。

返回

成功时返回 0，否则返回负错误代码

enum dma_transfer_direction snd_pcm_substream_to_dma_direction(const struct snd_pcm_substream *substream)¶: 获取 PCM 子流的 dma_transfer_direction

参数

const struct snd_pcm_substream *substream: PCM 子流

返回

DMA 传输方向

struct snd_dmaengine_dai_dma_data¶: DAI DMA 配置数据

定义:

struct snd_dmaengine_dai_dma_data {
    dma_addr_t addr;
    enum dma_slave_buswidth addr_width;
    u32 maxburst;
    void *filter_data;
    const char *chan_name;
    unsigned int fifo_size;
    unsigned int flags;
    void *peripheral_config;
    size_t peripheral_size;
};

成员

addr: DAI 数据源或目标寄存器的地址。
addr_width: DAI 数据源或目标寄存器的宽度。
maxburst: 一次突发可以发送到 DAI 或从 DAI 接收的最大字数（注意：字，以 src_addr_width 成员的单位表示，而不是字节）。
filter_data: 自定义 DMA 通道筛选数据，这通常在请求 DMA 通道时使用。
chan_name: 请求 DMA 通道时要使用的自定义通道名称。
fifo_size: DAI 控制器的 FIFO 大小（以字节为单位）
标志: PCM_DAI 标志，目前仅为 SND_DMAENGINE_PCM_DAI_FLAG_PACK
peripheral_config: 用于为 dmaengine 传输编程外围设备的配置
peripheral_size: 外围设备配置缓冲区大小

struct snd_dmaengine_pcm_config¶: 基于 dmaengine 的 PCM 的配置数据

定义:

struct snd_dmaengine_pcm_config {
    int (*prepare_slave_config)(struct snd_pcm_substream *substream,struct snd_pcm_hw_params *params, struct dma_slave_config *slave_config);
    struct dma_chan *(*compat_request_channel)(struct snd_soc_pcm_runtime *rtd, struct snd_pcm_substream *substream);
    int (*process)(struct snd_pcm_substream *substream,int channel, unsigned long hwoff, unsigned long bytes);
    const char *name;
    dma_filter_fn compat_filter_fn;
    struct device *dma_dev;
    const char *chan_names[SNDRV_PCM_STREAM_LAST + 1];
    const struct snd_pcm_hardware *pcm_hardware;
    unsigned int prealloc_buffer_size;
};

成员

prepare_slave_config: 用于填写 PCM 子流的 DMA slave_config 的回调。将从 PCM 驱动程序的 hwparams 回调中调用。
compat_request_channel: 用于为不使用设备树的平台请求 DMA 通道的回调。
process: 用于对从/到用户空间传输的采样应用处理的回调。
name: 组件名称。如果为 null，将使用 dev_name。
compat_filter_fn: 在为不使用设备树的平台请求通道时，将用作筛选函数。筛选参数将是 DAI 的 DMA 数据。
dma_dev: 如果设置，则在此设备而不是 DAI 设备上请求 DMA 通道。
chan_names: 如果设置，则将在注册时请求这些自定义 DMA 通道名称。
pcm_hardware: 用于 PCM 的 snd_pcm_hardware 结构。
prealloc_buffer_size: 预分配的音频缓冲区的大小。

注意

如果设置了 compat_request_channel 和 compat_filter_fn，则将使用 compat_request_channel 请求通道，并且将忽略 compat_filter_fn。否则，将使用 dma_request_channel 请求通道，并将 compat_filter_fn 用作筛选函数。

控制/混音器 API¶

通用控制接口¶

void snd_ctl_notify(struct snd_card *card, unsigned int mask, struct snd_ctl_elem_id *id)¶: 向用户空间发送控制更改的通知

参数

struct snd_card *card: 要发送通知的卡
unsigned int mask: 事件掩码，SNDRV_CTL_EVENT_*
struct snd_ctl_elem_id *id: 要发送通知的 ctl 元素 id

描述

此函数添加一个具有给定 id 和掩码的事件记录，将其附加到列表并唤醒用户空间进行通知。可以在原子上下文中调用此函数。

void snd_ctl_notify_one(struct snd_card *card, unsigned int mask, struct snd_kcontrol *kctl, unsigned int ioff)¶: 向用户空间发送控制更改的通知

参数

struct snd_card *card: 要发送通知的卡
unsigned int mask: 事件掩码，SNDRV_CTL_EVENT_*
struct snd_kcontrol *kctl: 带有控制实例的指针
unsigned int ioff: 控制索引的附加偏移量

描述

此函数调用 snd_ctl_notify() 并执行诸如 LED 状态更改之类的额外工作。

int snd_ctl_new(struct snd_kcontrol **kctl, unsigned int count, unsigned int access, struct snd_ctl_file *file)¶: 使用一些元素创建一个新的控制实例

参数

struct snd_kcontrol **kctl: 用于存储新控制实例的指针
unsigned int count: 此控制中的元素数量
unsigned int access: 此控制中元素的默认访问标志
struct snd_ctl_file *file: 锁定这些元素时给定

描述

为新的控制实例分配一个内存对象。该实例拥有的元素数量与给定的数量 (count) 相同。每个元素都具有给定的访问权限 (access)。当给出 file 时，每个元素都会被锁定。

返回

成功时为 0，失败时为错误代码

struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol, void *private_data)¶: 从模板创建一个控制实例

参数

const struct snd_kcontrol_new *ncontrol: 初始化记录
void *private_data: 要设置的私有数据

描述

分配一个新的 struct snd_kcontrol 实例并从给定的模板初始化。当 ncontrol 的 access 字段为 0 时，假定为 READWRITE 访问。当 count 字段为 0 时，假定为一个。

返回

新生成的实例的指针，如果失败则为 NULL。

void snd_ctl_free_one(struct snd_kcontrol *kcontrol)¶: 释放控制实例

参数

struct snd_kcontrol *kcontrol: 控制实例

描述

释放通过 snd_ctl_new() 或 snd_ctl_new1() 创建的控制实例。请勿在将控制添加到声卡后调用此函数。

int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)¶: 将控制实例添加到声卡

参数

struct snd_card *card: 声卡实例
struct snd_kcontrol *kcontrol: 要添加的控制实例

描述

将通过 snd_ctl_new() 或 snd_ctl_new1() 创建的控制实例添加到给定的声卡。还会分配一个用于快速搜索的唯一 numid。

它会自动释放无法添加的控制。

返回

成功时返回零，失败时返回负错误代码。

int snd_ctl_replace(struct snd_card *card, struct snd_kcontrol *kcontrol, bool add_on_replace)¶: 替换声卡的控制实例

参数

struct snd_card *card: 声卡实例
struct snd_kcontrol *kcontrol: 要替换的控制实例
bool add_on_replace: 如果尚未添加，则添加控件

描述

替换给定的控件。如果给定的控件不存在并且设置了 add_on_replace 标志，则会添加该控件。如果控件存在，则首先销毁它。

它会自动释放无法添加或替换的控制。

返回

成功时返回零，失败时返回负错误代码。

int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)¶: 从声卡中删除控制并释放它

参数

struct snd_card *card: 声卡实例
struct snd_kcontrol *kcontrol: 要删除的控制实例

描述

从声卡中删除控制，然后释放该实例。您无需调用 snd_ctl_free_one()。允许将 NULL 传递给 kcontrol 参数作为空操作。

请注意，此函数在内部获取 card->controls_rwsem 锁。

返回

如果成功，则为 0，如果失败，则为负错误代码。

int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)¶: 删除给定 id 的控制并释放它

参数

struct snd_card *card: 声卡实例
struct snd_ctl_elem_id *id: 要删除的控制 id

描述

查找具有给定 id 的控制实例，将其从声卡列表中删除并释放它。

返回

如果成功，则为 0，如果失败，则为负错误代码。

int snd_ctl_remove_user_ctl(struct snd_ctl_file *file, struct snd_ctl_elem_id *id)¶: 删除并释放未锁定的用户控件

参数

struct snd_ctl_file * file: 活动的控制句柄
struct snd_ctl_elem_id *id: 要删除的控制 id

描述

查找具有给定 id 的控制实例，将其从声卡列表中删除并释放它。

返回

如果成功，则为 0，如果失败，则为负错误代码。

int snd_ctl_activate_id(struct snd_card *card, struct snd_ctl_elem_id *id, int active)¶: 激活/禁用给定 ID 的控制

参数

struct snd_card *card: 声卡实例
struct snd_ctl_elem_id *id: 要激活/禁用的控制 ID
int active: 非零值表示激活

描述

查找具有给定 ID 的控制实例，并激活或禁用该控制，并在发生更改时发送通知。给定的 ID 数据将填充完整信息。

返回

0 表示未更改，1 表示已更改，或者失败时返回负错误代码。

int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id, struct snd_ctl_elem_id *dst_id)¶: 替换卡上控制的 ID

参数

struct snd_card *card: 声卡实例
struct snd_ctl_elem_id *src_id: 旧 ID
struct snd_ctl_elem_id *dst_id: 新 ID

描述

从卡中查找具有旧 ID 的控制，并将 ID 替换为新 ID。

该函数在替换其余部分时尝试保留已分配的 numid。

请注意，此函数应仅在卡初始化阶段使用。在卡实例化后调用可能会导致用户空间期望持久 numid 的问题。

返回

成功时返回零，失败时返回负错误代码。

void snd_ctl_rename(struct snd_card *card, struct snd_kcontrol *kctl, const char *name)¶: 重命名卡上的控制

参数

struct snd_card *card: 声卡实例
struct snd_kcontrol *kctl: 要重命名的控制
const char *name: 新名称

描述

将卡上指定的控制重命名为新名称。

请注意，此函数在内部获取 card->controls_rwsem 锁。

struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid)¶: 查找具有给定数字 ID 的控制实例

参数

struct snd_card *card: 声卡实例
unsigned int numid: 要搜索的数字 ID

描述

从卡中查找具有给定数字 ID 的控制实例。

请注意，此函数在内部获取 card->controls_rwlock 锁。

返回

如果找到，则返回实例的指针，否则返回 NULL。

struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card, const struct snd_ctl_elem_id *id)¶: 查找具有给定 ID 的控制实例

参数

struct snd_card *card: 声卡实例
const struct snd_ctl_elem_id *id: 要搜索的 ID

描述

从卡中查找具有给定 ID 的控制实例。

请注意，此函数在内部获取 card->controls_rwlock 锁。

返回

如果找到，则返回实例的指针，否则返回 NULL。

int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)¶: 注册设备特定的控制 ioctl

参数

snd_kctl_ioctl_func_t fcn: ioctl 回调函数

描述

从诸如 pcm.c、hwdep.c 等每个设备管理器调用。

返回

如果成功，则为零，否则为负错误代码

int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)¶: 注册设备特定的 32 位兼容控制 ioctl

参数

snd_kctl_ioctl_func_t fcn: ioctl 回调函数

返回

如果成功，则为零，否则为负错误代码

int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)¶: 注销设备特定的控制 ioctl

参数

snd_kctl_ioctl_func_t fcn: 要注销的 ioctl 回调函数

返回

如果成功，则为零，否则为负错误代码

int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)¶: 注销设备特定的兼容 32 位控制 ioctl

参数

snd_kctl_ioctl_func_t fcn: 要注销的 ioctl 回调函数

返回

如果成功，则为零，否则为负错误代码

int snd_ctl_request_layer(const char *module_name)¶: 请求使用该层

参数

const char *module_name: 内核模块的名称（NULL == 内置）

返回

成功则返回零，如果无法加载模块则返回错误代码

void snd_ctl_register_layer(struct snd_ctl_layer_ops *lops)¶: 注册新的控制层

参数

struct snd_ctl_layer_ops *lops: 操作结构

描述

新层可以跟踪所有控制元素，并在其之上执行其他操作（如音频 LED 处理）。

void snd_ctl_disconnect_layer(struct snd_ctl_layer_ops *lops)¶: 断开控制层

参数

struct snd_ctl_layer_ops *lops: 操作结构

描述

预计在此调用之前，有关已跟踪卡的信息将被释放（此处不调用断开连接回调）。

int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)¶: 用于具有单声道通道的标准布尔信息回调的辅助函数

参数

struct snd_kcontrol *kcontrol: kcontrol 实例
struct snd_ctl_elem_info *uinfo: 要存储的信息

描述

此函数可用作具有单个单声道通道的标准布尔控件的信息回调。

返回

零（总是成功）

int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)¶: 用于具有立体声双通道的标准布尔信息回调的辅助函数

参数

struct snd_kcontrol *kcontrol: kcontrol 实例
struct snd_ctl_elem_info *uinfo: 要存储的信息

描述

此函数可用作具有立体声双通道的标准布尔控件的信息回调。

返回

零（总是成功）

int snd_ctl_enum_info(struct snd_ctl_elem_info *info, unsigned int channels, unsigned int items, const char *const names[])¶: 为枚举控制填充 info 结构

参数

struct snd_ctl_elem_info *info: 要填充的结构
unsigned int channels: 控制的通道数；通常为 1
unsigned int items: 控制值的数量；也是 names 的大小
const char *const names[]: 一个包含所有控制值名称的数组

描述

将 info 中的所有必需字段设置为适当的值。如果控制的访问性不是默认值（可读写），则调用者必须填充 info->access。

返回

零（总是成功）

AC97 编解码器 API¶

void snd_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short value)¶: 在给定寄存器上写入一个值

参数

struct snd_ac97 *ac97: ac97 实例
unsigned short reg: 要更改的寄存器
unsigned short value: 要设置的值

描述

在给定的寄存器上写入一个值。这将在寄存器检查后直接调用写入回调。此函数不像 #snd_ca97_write_cache() 那样更改寄存器缓存，因此仅当您不想将更改反映到暂停/恢复状态时才使用此函数。

unsigned short snd_ac97_read(struct snd_ac97 *ac97, unsigned short reg)¶: 从给定寄存器读取一个值

参数

struct snd_ac97 *ac97: ac97 实例
unsigned short reg: 要读取的寄存器

描述

从给定寄存器读取一个值。这将在寄存器检查后直接调用读取回调。

返回

读取的值。

void snd_ac97_write_cache(struct snd_ac97 *ac97, unsigned short reg, unsigned short value)¶: 在给定的寄存器上写入一个值并更新缓存

参数

struct snd_ac97 *ac97: ac97 实例
unsigned short reg: 要更改的寄存器
unsigned short value: 要设置的值

描述

在给定的寄存器上写入一个值并更新寄存器缓存。缓存的值用于缓存读取和暂停/恢复。

int snd_ac97_update(struct snd_ac97 *ac97, unsigned short reg, unsigned short value)¶: 更新给定寄存器上的值

参数

struct snd_ac97 *ac97: ac97 实例
unsigned short reg: 要更改的寄存器
unsigned short value: 要设置的值

描述

将该值与寄存器缓存进行比较，仅在该值更改时更新该值。

返回

如果值已更改，则为 1；如果没有更改，则为 0；如果失败，则为负代码。

int snd_ac97_update_bits(struct snd_ac97 *ac97, unsigned short reg, unsigned short mask, unsigned short value)¶: 更新给定寄存器上的位

参数

struct snd_ac97 *ac97: ac97 实例
unsigned short reg: 要更改的寄存器
unsigned short mask: 要更改的位掩码
unsigned short value: 要设置的值

描述

仅在值更改时更新给定寄存器上的掩码位。

返回

如果位已更改，则为 1；如果没有更改，则为 0；如果失败，则为负代码。

const char *snd_ac97_get_short_name(struct snd_ac97 *ac97)¶: 检索编解码器名称

参数

struct snd_ac97 *ac97: 编解码器实例

返回

编解码器的简短标识名称。

int snd_ac97_bus(struct snd_card *card, int num, const struct snd_ac97_bus_ops *ops, void *private_data, struct snd_ac97_bus **rbus)¶: 创建 AC97 总线组件

参数

struct snd_card *card: 声卡实例
int num: 总线编号
const struct snd_ac97_bus_ops *ops: 总线回调表
void *private_data: 新实例的私有数据指针
struct snd_ac97_bus **rbus: 用于存储新 AC97 总线实例的指针。

描述

创建一个 AC97 总线组件。将新分配和初始化一个 struct snd_ac97_bus 实例。

ops 表必须包含有效的回调（至少是读取和写入）。其他回调，等待和重置，不是强制性的。

时钟设置为 48000。如果需要另一个时钟，请手动设置 (*rbus)->clock。

AC97 总线实例注册为底层设备，因此您不必手动释放它。

返回

成功时返回零，失败时返回负错误代码。

int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template, struct snd_ac97 **rac97)¶: 创建 Codec97 组件

参数

struct snd_ac97_bus *bus: 编解码器所连接的 AC97 总线
struct snd_ac97_template *template: ac97 的模板，包括索引、回调和私有数据。
struct snd_ac97 **rac97: 用于存储新 ac97 实例的指针。

描述

创建一个 Codec97 组件。从模板中新分配和初始化一个 struct snd_ac97 实例。然后通过标准程序初始化编解码器。

该模板必须包括编解码器编号 (num) 和地址 (addr) 以及私有数据 (private_data)。

ac97 实例注册为底层设备，因此您不必手动释放它。

返回

成功时返回零，失败时返回负错误代码。

int snd_ac97_update_power(struct snd_ac97 *ac97, int reg, int powerup)¶: 更新掉电寄存器

参数

struct snd_ac97 *ac97: 编解码器实例
int reg: 速率寄存器，例如 AC97_PCM_FRONT_DAC_RATE
int powerup: 当启动部件时非零

描述

更新给定部件的 AC97 掉电寄存器位。

返回

零。

void snd_ac97_suspend(struct snd_ac97 *ac97)¶: AC97 编解码器的通用挂起函数

参数

struct snd_ac97 *ac97: ac97 实例

描述

挂起编解码器，关闭芯片电源。

void snd_ac97_resume(struct snd_ac97 *ac97)¶: AC97 编解码器的通用恢复函数

参数

struct snd_ac97 *ac97: ac97 实例

描述

执行标准的恢复过程，上电并恢复旧的寄存器值。

int snd_ac97_tune_hardware(struct snd_ac97 *ac97, const struct ac97_quirk *quirk, const char *override)¶: 调整硬件

参数

struct snd_ac97 *ac97: ac97 实例
const struct ac97_quirk *quirk: 怪癖列表
const char *override: 显式怪癖值（如果非 NULL，则覆盖列表）

描述

为每个 pci 设备执行一些解决方法，例如将耳机（真正的线路输出）控件重命名为“Master”。怪癖列表必须以零填充的条目终止。

返回

成功时返回零，失败时返回负错误代码。

int snd_ac97_set_rate(struct snd_ac97 *ac97, int reg, unsigned int rate)¶: 更改给定输入/输出的速率。

参数

struct snd_ac97 *ac97: ac97 实例
int reg: 要更改的寄存器
unsigned int rate: 要设置的采样率

描述

更改编解码器上给定输入/输出的速率。如果编解码器不支持 VAR，则速率必须为 48000（SPDIF 除外）。

有效的寄存器有 AC97_PCM_MIC_ADC_RATE、AC97_PCM_FRONT_DAC_RATE、AC97_PCM_LR_ADC_RATE。如果编解码器支持，则接受 AC97_PCM_SURR_DAC_RATE 和 AC97_PCM_LFE_DAC_RATE。AC97_SPDIF 被接受为修改 SPDIF 状态位的伪寄存器。

返回

成功时返回零，失败时返回负错误代码。

int snd_ac97_pcm_assign(struct snd_ac97_bus *bus, unsigned short pcms_count, const struct ac97_pcm *pcms)¶: 将 AC97 插槽分配给给定的 PCM 流

参数

struct snd_ac97_bus *bus: ac97 总线实例
unsigned short pcms_count: 要分配的 PCM 的计数
const struct ac97_pcm *pcms: 要分配的 PCM

描述

它为给定的 PCM 分配可用的 AC97 插槽。如果只有部分插槽可用，则 pcm->xxx.slots 和 pcm->xxx.rslots[] 成员会减少，并且可能为零。

返回

成功时返回零，失败时返回负错误代码。

int snd_ac97_pcm_open(struct ac97_pcm *pcm, unsigned int rate, enum ac97_pcm_cfg cfg, unsigned short slots)¶: 打开给定的 AC97 pcm

参数

struct ac97_pcm *pcm: ac97 pcm 实例
unsigned int rate: 以 Hz 为单位的速率，如果编解码器不支持 VRA，则此值必须为 48000Hz
enum ac97_pcm_cfg cfg: 输出流特性
unsigned short slots: 为此 pcm 分配的插槽（snd_ac97_pcm_assign）的子集

描述

它锁定指定的插槽并将给定的速率设置为 AC97 寄存器。

返回

成功时返回零，失败时返回负错误代码。

int snd_ac97_pcm_close(struct ac97_pcm *pcm)¶: 关闭给定的 AC97 pcm

参数

struct ac97_pcm *pcm: ac97 pcm 实例

描述

它释放锁定的 AC97 插槽。

返回

零。

int snd_ac97_pcm_double_rate_rules(struct snd_pcm_runtime *runtime)¶: 设置双倍速率约束

参数

struct snd_pcm_runtime *runtime: ac97 前端回放 pcm 的运行时

描述

安装硬件约束规则以防止同时使用双倍速率和两个以上通道。

返回

成功时返回零，失败时返回负错误代码。

虚拟主控制 API¶

int snd_ctl_add_followers(struct snd_card *card, struct snd_kcontrol *master, const char *const *list)¶: 向 vmaster 添加多个跟随者

参数

struct snd_card *card: 声卡实例
struct snd_kcontrol *master: 目标 vmaster kcontrol 对象
const char * const *list: 要添加的跟随者的名称字符串的 NULL 终止列表

描述

使用给定的名称添加多个跟随者 kcontrol。成功返回 0，失败返回负错误代码。

struct snd_kcontrol *snd_ctl_make_virtual_master(char *name, const unsigned int *tlv)¶: 创建虚拟主控件

参数

char *name: 要创建的控制元素的名称字符串
const unsigned int *tlv: 可选的用于分贝信息的 TLV int 数组

描述

使用给定的名称字符串创建虚拟主控件。

创建 vmaster 元素后，可以通过 snd_ctl_add_follower() 或 snd_ctl_add_follower_uncached() 添加跟随者控件。

可选参数 tlv 可用于指定主控件的分贝刻度的 TLV 信息。它应该是一个带有 #SNDRV_CTL_TLVT_DB_SCALE、#SNDRV_CTL_TLV_DB_MINMAX 或 #SNDRV_CTL_TLVT_DB_MINMAX_MUTE 类型的单个元素，并且最大值应为 0dB。

返回

创建的控制元素，或者错误时为 NULL (ENOMEM)。

int snd_ctl_add_vmaster_hook(struct snd_kcontrol *kcontrol, void (*hook)(void *private_data, int), void *private_data)¶: 向 vmaster 控件添加钩子

参数

struct snd_kcontrol *kcontrol: vmaster kctl 元素
void (*hook)(void *private_data, int): 钩子函数
void *private_data: 要保存的 private_data 指针

描述

将给定的钩子添加到 vmaster 控制元素，以便在每次值更改时调用它。

返回

零。

void snd_ctl_sync_vmaster(struct snd_kcontrol *kcontrol, bool hook_only)¶: 同步虚拟主设备 (vmaster) 的跟随者和钩子函数。

参数

struct snd_kcontrol *kcontrol: vmaster kctl 元素
bool hook_only: 仅同步钩子函数。

描述

强制调用每个跟随者的 put 回调函数，并调用钩子函数，以与给定的虚拟主设备元素的当前值同步。当传递 NULL 给 kcontrol 时，不执行任何操作。

int snd_ctl_apply_vmaster_followers(struct snd_kcontrol *kctl, int (*func)(struct snd_kcontrol *vfollower, struct snd_kcontrol *follower, void *arg), void *arg)¶: 对每个虚拟主设备 (vmaster) 的跟随者应用函数。

参数

struct snd_kcontrol *kctl: vmaster kctl 元素
int (*func)(struct snd_kcontrol *vfollower, struct snd_kcontrol *follower, void *arg): 要应用的函数。
void *arg: 可选的函数参数。

描述

将函数 func 应用于给定虚拟主设备 (vmaster) kctl 的每个跟随者 kctl。

返回

如果成功，则返回 0；否则返回负错误代码。

struct snd_kcontrol *snd_ctl_find_id_mixer(struct snd_card *card, const char *name)¶: 查找具有给定名称字符串的控制实例。

参数

struct snd_card *card: 声卡实例
const char *name: 名称字符串。

描述

查找具有给定名称和 SNDRV_CTL_ELEM_IFACE_MIXER 的控制实例。其他字段设置为零。

这仅仅是对 snd_ctl_find_id() 的包装。

返回

如果找到，则返回实例的指针，否则返回 NULL。

int snd_ctl_add_follower(struct snd_kcontrol *master, struct snd_kcontrol *follower)¶: 添加一个虚拟的跟随控制。

参数

struct snd_kcontrol *master: 虚拟主设备元素。
struct snd_kcontrol *follower: 要添加的跟随元素。

描述

将一个虚拟的跟随控制添加到之前通过 snd_ctl_create_virtual_master() 创建的给定主设备元素。

所有跟随者必须是相同类型的（通过 info 回调函数返回相同的信息）。该函数不检查这一点，因此您有责任确保这一点。

此外，还有一些额外的限制：最多两个通道，对数音量控制（dB 级别），因此没有线性音量，主设备只能衰减音量而不能增益。

返回

如果成功，则为零；否则为负错误代码。

int snd_ctl_add_follower_uncached(struct snd_kcontrol *master, struct snd_kcontrol *follower)¶: 添加一个虚拟的跟随控制。

参数

struct snd_kcontrol *master: 虚拟主设备元素。
struct snd_kcontrol *follower: 要添加的跟随元素。

描述

将虚拟的跟随控制添加到给定的主设备。与 snd_ctl_add_follower() 不同，通过此函数添加的元素应该具有易失性值，并且每次从主设备查询时都会调用 get 回调函数。

当控制直接窥视硬件值并且该值可以通过元素 put 回调之外的其他方式更改时，应使用此函数以使该值始终保持最新状态。

返回

如果成功，则为零；否则为负错误代码。

MIDI API¶

原始 MIDI API¶

int snd_rawmidi_receive(struct snd_rawmidi_substream *substream, const unsigned char *buffer, int count)¶: 从设备接收输入数据。

参数

struct snd_rawmidi_substream *substream: 原始 MIDI 子流。
const unsigned char *buffer: 缓冲区指针
int count: 要读取的数据大小。

描述

从内部缓冲区读取数据。

返回

读取的数据大小；如果失败，则返回负错误代码。

int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream)¶: 检查输出缓冲区是否为空。

参数

struct snd_rawmidi_substream *substream: 原始 MIDI 子流。

返回

如果内部输出缓冲区为空，则返回 1；否则返回 0。

int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream, unsigned char *buffer, int count)¶: 从内部缓冲区复制数据。

参数

struct snd_rawmidi_substream *substream: 原始 MIDI 子流。
unsigned char *buffer: 缓冲区指针
int count: 要传输的数据大小。

描述

将数据从内部输出缓冲区复制到给定的缓冲区。

当 MIDI 输出就绪时在中断处理程序中调用此函数，并在传输完成后调用 snd_rawmidi_transmit_ack()。

返回

复制的数据大小；如果失败，则返回负错误代码。

int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count)¶: 确认传输。

参数

struct snd_rawmidi_substream *substream: 原始 MIDI 子流。
int count: 已传输的计数。

描述

使用给定大小的内部输出缓冲区推进硬件指针，并更新条件。在传输完成后调用。

返回

如果成功，则返回推进的大小；如果失败，则返回负错误代码。

int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream, unsigned char *buffer, int count)¶: 从缓冲区复制数据到设备

参数

struct snd_rawmidi_substream *substream: 原始 MIDI 子流。
unsigned char *buffer: 缓冲区指针
int count: 要传输的数据大小

描述

将数据从缓冲区复制到设备，并移动指针。

返回

如果成功，则返回复制的大小；如果失败，则返回负错误代码。

int snd_rawmidi_proceed(struct snd_rawmidi_substream *substream)¶: 丢弃所有待处理的字节并继续

参数

struct snd_rawmidi_substream *substream: rawmidi 子流

返回

已丢弃的字节数

int snd_rawmidi_new(struct snd_card *card, char *id, int device, int output_count, int input_count, struct snd_rawmidi **rrawmidi)¶: 创建一个 rawmidi 实例

参数

struct snd_card *card: 声卡实例
char *id: id 字符串
int device: 设备索引
int output_count: 输出流的数量
int input_count: 输入流的数量
struct snd_rawmidi **rrawmidi: 用于存储新 rawmidi 实例的指针

描述

创建一个新的 rawmidi 实例。使用 snd_rawmidi_set_ops() 为新实例设置操作符。

返回

成功时返回零，失败时返回负错误代码。

void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream, const struct snd_rawmidi_ops *ops)¶: 设置 rawmidi 操作符

参数

struct snd_rawmidi *rmidi: rawmidi 实例
int stream: 流的方向，SNDRV_RAWMIDI_STREAM_XXX
const struct snd_rawmidi_ops *ops: 操作符表

描述

为给定的流方向设置 rawmidi 操作符。

MPU401-UART API¶

irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id)¶: 通用的 MPU401-UART 中断处理程序

参数

int irq: irq 号
void *dev_id: mpu401 实例

描述

处理 MPU401-UART i/o 的中断。

返回

如果中断被处理，则返回 IRQ_HANDLED。否则返回 IRQ_NONE。

irqreturn_t snd_mpu401_uart_interrupt_tx(int irq, void *dev_id)¶: 通用的 MPU401-UART 发送 irq 处理程序

参数

int irq: irq 号
void *dev_id: mpu401 实例

描述

处理 MPU401-UART 输出的中断。

返回

如果中断被处理，则返回 IRQ_HANDLED。否则返回 IRQ_NONE。

int snd_mpu401_uart_new(struct snd_card *card, int device, unsigned short hardware, unsigned long port, unsigned int info_flags, int irq, struct snd_rawmidi **rrawmidi)¶: 创建一个 MPU401-UART 实例

参数

struct snd_card *card: 声卡实例
int device: 设备索引，从零开始
unsigned short hardware: 硬件类型，MPU401_HW_XXXX
unsigned long port: MPU401 端口的基地址
unsigned int info_flags: 位标志 MPU401_INFO_XXX
int irq: ISA irq 号，如果不需要分配则为 -1
struct snd_rawmidi ** rrawmidi: 用于存储新 rawmidi 实例的指针

描述

创建一个新的 MPU-401 实例。

请注意，rawmidi 实例是在 rrawmidi 参数上返回的，而不是 mpu401 实例本身。要访问 mpu401 实例，请从 rawmidi->private_data 进行强制转换（使用 struct snd_mpu401 magic-cast）。

返回

成功时返回零，否则返回负错误代码。

Proc Info API¶

Proc Info 接口¶

int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len)¶: 从 procfs 缓冲区读取一行

参数

struct snd_info_buffer *buffer: procfs 缓冲区
char *line: 用于存储的缓冲区
int len: 最大缓冲区大小

描述

从缓冲区读取一行并存储字符串。

返回

如果成功，则返回零；如果错误或 EOF，则返回 1。

const char *snd_info_get_str(char *dest, const char *src, int len)¶: 解析一个字符串标记

参数

char *dest: 用于存储字符串标记的缓冲区
const char *src: 原始字符串
int len: 标记的最大长度 - 1

描述

解析原始字符串并将标记复制到给定的字符串缓冲区。

返回

原始字符串的更新指针，以便可以用于下一次调用。

struct snd_info_entry *snd_info_create_module_entry(struct module *module, const char *name, struct snd_info_entry *parent)¶: 为给定的模块创建一个信息条目

参数

struct module * module: 模块指针
const char *name: 文件名
struct snd_info_entry *parent: 父目录

描述

创建一个新的信息条目，并将其分配给给定的模块。

返回

新实例的指针，如果失败则为 NULL。

struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card, const char *name, struct snd_info_entry *parent)¶: 为给定声卡创建一个信息条目

参数

struct snd_card *card: 声卡实例
const char *name: 文件名
struct snd_info_entry * parent: 父目录

描述

创建一个新的信息条目，并将其分配给给定的声卡。

返回

新实例的指针，如果失败则为 NULL。

void snd_info_free_entry(struct snd_info_entry *entry)¶: 释放信息条目

参数

struct snd_info_entry * entry: 信息条目

描述

释放信息条目。

int snd_info_register(struct snd_info_entry *entry)¶: 注册信息条目

参数

struct snd_info_entry *entry: 信息条目

描述

注册 proc 信息条目。所有子条目都会被递归注册。

返回

成功时返回零，失败时返回负错误代码。

int snd_card_rw_proc_new(struct snd_card *card, const char *name, void *private_data, void (*read)(struct snd_info_entry*, struct snd_info_buffer*), void (*write)(struct snd_info_entry *entry, struct snd_info_buffer *buffer))¶: 为声卡创建一个读/写文本 proc 文件条目

参数

struct snd_card *card: 声卡实例
const char *name: 文件名
void *private_data: 任意的私有数据
void (*read)(struct snd_info_entry *, struct snd_info_buffer *): 读取回调
void (*write)(struct snd_info_entry *entry, struct snd_info_buffer *buffer): 写入回调，只读则为 NULL

描述

此 proc 文件条目将通过 snd_card_register() 调用注册，并且也会在声卡移除时自动移除。

返回

如果成功，则为零，否则为负错误代码

压缩卸载¶

压缩卸载 API¶

int snd_compr_stop_error(struct snd_compr_stream *stream, snd_pcm_state_t state)¶: 报告流上的致命错误

参数

struct snd_compr_stream *stream: 指向流的指针
snd_pcm_state_t state: 流要转换到的状态

描述

停止流并设置其状态。

应该在持有压缩设备锁的情况下调用。

返回

如果成功，则为零，否则为负错误代码

void snd_compr_task_finished(struct snd_compr_stream *stream, struct snd_compr_task_runtime *task)¶: 通知任务已完成

参数

struct snd_compr_stream *stream: 指向流的指针
struct snd_compr_task_runtime *task: 运行时任务结构

描述

设置已完成的任务状态并通知等待者。

int snd_compress_new(struct snd_card *card, int device, int dirn, const char *id, struct snd_compr *compr)¶: 创建新的压缩设备

参数

struct snd_card *card: 声卡指针
int device: 设备编号
int dirn: 设备方向，应为 enum snd_compr_direction 类型
const char *id: ID 字符串
struct snd_compr *compr: 压缩设备指针

返回

如果成功，则为零，否则为负错误代码

struct snd_compressed_buffer¶: 压缩缓冲区

定义:

struct snd_compressed_buffer {
    __u32 fragment_size;
    __u32 fragments;
};

成员

fragment_size: 缓冲区片段的大小，以字节为单位
fragments: 此类片段的数量

struct snd_compr_params¶: 压缩流参数

定义:

struct snd_compr_params {
    struct snd_compressed_buffer buffer;
    struct snd_codec codec;
    __u8 no_wake_mode;
};

成员

buffer: 缓冲区描述
codec: 编解码器参数
no_wake_mode: 不要在片段经过时唤醒

struct snd_compr_tstamp¶: 时间戳描述符

定义:

struct snd_compr_tstamp {
    __u32 byte_offset;
    __u32 copied_total;
    __u32 pcm_frames;
    __u32 pcm_io_frames;
    __u32 sampling_rate;
};

成员

byte_offset: 环形缓冲区中到 DSP 的字节偏移
copied_total: 从/到环形缓冲区复制到/由 DSP 复制的总字节数
pcm_frames: DSP 解码或编码的帧数。此字段将以较大步长演变，应仅用于监视编码/解码进度。不应用于时间估算。
pcm_io_frames: DSP 渲染或接收到混音器或音频输出/输入的帧数。此字段应用于 A/V 同步或时间估算。
sampling_rate: 音频采样率

struct snd_compr_avail¶: 可用描述符

定义:

struct snd_compr_avail {
    __u64 avail;
    struct snd_compr_tstamp tstamp;
};

成员

avail: 环形缓冲区中可用于写入/读取的字节数
tstamp: 时间戳信息

struct snd_compr_caps¶: caps 描述符

定义:

struct snd_compr_caps {
    __u32 num_codecs;
    __u32 direction;
    __u32 min_fragment_size;
    __u32 max_fragment_size;
    __u32 min_fragments;
    __u32 max_fragments;
    __u32 codecs[MAX_NUM_CODECS];
    __u32 reserved[11];
};

成员

num_codecs: 支持的编解码器数量
direction: 支持的方向。类型为 snd_compr_direction
min_fragment_size: DSP 支持的最小片段
max_fragment_size: DSP 支持的最大片段
min_fragments: DSP 支持的最小片段数
max_fragments: DSP 支持的最大片段数
codecs: 指向编解码器数组的指针
reserved: 保留字段

struct snd_compr_codec_caps¶: 查询编解码器的能力

定义:

struct snd_compr_codec_caps {
    __u32 codec;
    __u32 num_descriptors;
    struct snd_codec_desc descriptor[MAX_NUM_CODEC_DESCRIPTORS];
};

成员

codec: 查询能力的编解码器
num_descriptors: 编解码器描述符的数量
descriptor: 编解码器能力描述符数组

enum sndrv_compress_encoder¶: 编码器元数据键

常量

SNDRV_COMPRESS_ENCODER_PADDING: 编码器在音轨末尾附加的样本数
SNDRV_COMPRESS_ENCODER_DELAY: 编码器在音轨开头插入的样本数

struct snd_compr_metadata¶: 压缩流元数据

定义:

struct snd_compr_metadata {
    __u32 key;
    __u32 value[8];
};

成员

key: 键 ID
value: 键值

struct snd_compr_task¶: 非实时操作的任务原语

定义:

struct snd_compr_task {
    __u64 seqno;
    __u64 origin_seqno;
    int input_fd;
    int output_fd;
    __u64 input_size;
    __u32 flags;
    __u8 reserved[16];
};

成员

seqno: 序列号（任务标识符）
origin_seqno: 上一个序列号（任务标识符） - 用于重用
input_fd: 数据输入文件描述符 (dma-buf)
output_fd: 数据输出文件描述符 (dma-buf)
input_size: 已填充数据的字节数（来自调用者，不得超过片段大小）
标志: 请参阅 SND_COMPRESS_TFLG_* 定义
reserved: 保留供将来扩展

enum snd_compr_state¶: 任务状态

常量

SND_COMPRESS_TASK_STATE_IDLE: 任务未入队
SND_COMPRESS_TASK_STATE_ACTIVE: 任务在队列中
SND_COMPRESS_TASK_STATE_FINISHED: 任务已处理，输出可用

struct snd_compr_task_status¶: 任务状态

定义:

struct snd_compr_task_status {
    __u64 seqno;
    __u64 input_size;
    __u64 output_size;
    __u32 output_flags;
    __u8 state;
    __u8 reserved[15];
};

成员

seqno: 序列号（任务标识符）
input_size: 已填充数据的字节数（来自用户空间）
output_size: 已填充数据的字节数（来自驱动程序）
output_flags: 保留供将来使用（来自驱动程序的所有零）
state: 实际任务状态 (SND_COMPRESS_TASK_STATE_*)
reserved: 保留供将来扩展

struct snd_enc_vorbis¶: Vorbis 编码器参数

定义:

struct snd_enc_vorbis {
    __s32 quality;
    __u32 managed;
    __u32 max_bit_rate;
    __u32 min_bit_rate;
    __u32 downmix;
};

成员

quality: 设置编码质量为 n，范围在 -1（低）和 10（高）之间。在默认操作模式下，质量级别为 3。正常质量范围为 0 - 10。
managed: 布尔值。设置比特率管理模式。这将关闭正常的 VBR 编码，但允许编码器强制执行硬性或软性比特率约束。此模式可能较慢，也可能质量较低。它主要用于流式传输。
max_bit_rate: 仅当 managed 为 TRUE 时启用
min_bit_rate: 仅当 managed 为 TRUE 时启用
downmix: 布尔值。将输入从立体声下混音为单声道（对非立体声流无效）。适用于较低比特率的编码。

描述

这些选项是从 OpenMAX IL 规范和 Gstreamer vorbisenc 属性中提取的

为了获得最佳质量，用户应指定 VBR 模式并设置质量级别。

struct snd_enc_real¶: RealAudio 编码器参数

定义:

struct snd_enc_real {
    __u32 quant_bits;
    __u32 start_region;
    __u32 num_regions;
};

成员

quant_bits: 流中耦合量化位的数量
start_region: 流中的耦合起始区域
num_regions: 区域值的数量

描述

这些选项是从 OpenMAX IL 规范中提取的

struct snd_enc_flac¶: FLAC 编码器参数

定义:

struct snd_enc_flac {
    __u32 num;
    __u32 gain;
};

成员

num: 序列号，仅对 OGG 格式有效，需要由应用程序设置
gain: 添加重放增益标签

描述

这些选项是从 FLAC 在线文档 http://flac.sourceforge.net/documentation_tools_flac.html 中提取的

为了简化 API，假设用户将选择质量配置文件。如果需要，可以在后期添加影响编码质量和速度的其他选项。

默认情况下，编码器使用子集格式。

诸如图片之类的标签不能由卸载的编码器处理，并且此 API 不支持这些标签。

struct snd_compr_task_runtime¶: 任务运行时描述

定义:

struct snd_compr_task_runtime {
    struct list_head list;
    struct dma_buf *input;
    struct dma_buf *output;
    u64 seqno;
    u64 input_size;
    u64 output_size;
    u32 flags;
    u8 state;
    void *private_value;
};

成员

列表: 所有托管任务的列表
input: 输入 DMA 缓冲区
output: 输出 DMA 缓冲区
seqno: sequence number
input_size: 输入缓冲区中实际使用的数据
output_size: 输出缓冲区中实际使用的数据
标志: 请参阅 SND_COMPRESS_TFLG_*
state: 实际任务状态
private_value: 由底层驱动程序使用（不透明）

struct snd_compr_runtime¶: 运行时流描述

定义:

struct snd_compr_runtime {
    snd_pcm_state_t state;
    struct snd_compr_ops *ops;
    void *buffer;
    u64 buffer_size;
    u32 fragment_size;
    u32 fragments;
    u64 total_bytes_available;
    u64 total_bytes_transferred;
    wait_queue_head_t sleep;
    void *private_data;
    unsigned char *dma_area;
    dma_addr_t dma_addr;
    size_t dma_bytes;
    struct snd_dma_buffer *dma_buffer_p;
#if IS_ENABLED(CONFIG_SND_COMPRESS_ACCEL);
    u32 active_tasks;
    u32 total_tasks;
    u64 task_seqno;
    struct list_head tasks;
#endif;
};

成员

state: 流状态
ops: 指向 DSP 回调的指针
buffer: 指向内核缓冲区的指针，仅当不在 mmap 模式或 DSP 不实现复制时有效
buffer_size: 上述缓冲区的大小
fragment_size: 缓冲区片段的大小，以字节为单位
fragments: 此类片段的数量
total_bytes_available: 环形缓冲区中可用的累积字节数
total_bytes_transferred: 卸载 DSP 传输的累积字节数
sleep: 轮询睡眠
private_data: 驱动程序私有数据指针
dma_area: 虚拟缓冲区地址
dma_addr: 物理缓冲区地址（无法从主 CPU 访问）
dma_bytes: DMA 区域的大小
dma_buffer_p: 运行时 DMA 缓冲区指针
active_tasks: 活动任务的计数
total_tasks: 所有任务的计数
task_seqno: 上一个任务序列号 (!= 0)
tasks: 所有任务的列表

struct snd_compr_stream¶: 压缩流

定义:

struct snd_compr_stream {
    const char *name;
    struct snd_compr_ops *ops;
    struct snd_compr_runtime *runtime;
    struct snd_compr *device;
    struct delayed_work error_work;
    enum snd_compr_direction direction;
    bool metadata_set;
    bool next_track;
    bool partial_drain;
    bool pause_in_draining;
    void *private_data;
    struct snd_dma_buffer dma_buffer;
};

成员

name: 设备名称
ops: 指向 DSP 回调的指针
runtime: 指向运行时结构的指针
device: 设备指针
error_work: 因错误关闭流时使用的延迟工作
direction: 流方向，播放/录制
metadata_set: 元数据设置标志，设置时为 true
next_track: 具有用户空间信号的下一曲目过渡，设置时为 true
partial_drain: 正在进行流的部分排空，设置时为 true
pause_in_draining: 在排空状态期间暂停，设置时为 true
private_data: 指向 DSP 私有数据的指针
dma_buffer: 分配的缓冲区（如果有）

struct snd_compr_ops¶: 压缩路径 DSP 操作

定义:

struct snd_compr_ops {
    int (*open)(struct snd_compr_stream *stream);
    int (*free)(struct snd_compr_stream *stream);
    int (*set_params)(struct snd_compr_stream *stream, struct snd_compr_params *params);
    int (*get_params)(struct snd_compr_stream *stream, struct snd_codec *params);
    int (*set_metadata)(struct snd_compr_stream *stream, struct snd_compr_metadata *metadata);
    int (*get_metadata)(struct snd_compr_stream *stream, struct snd_compr_metadata *metadata);
    int (*trigger)(struct snd_compr_stream *stream, int cmd);
    int (*pointer)(struct snd_compr_stream *stream, struct snd_compr_tstamp *tstamp);
    int (*copy)(struct snd_compr_stream *stream, char __user *buf, size_t count);
    int (*mmap)(struct snd_compr_stream *stream, struct vm_area_struct *vma);
    int (*ack)(struct snd_compr_stream *stream, size_t bytes);
    int (*get_caps) (struct snd_compr_stream *stream, struct snd_compr_caps *caps);
    int (*get_codec_caps) (struct snd_compr_stream *stream, struct snd_compr_codec_caps *codec);
#if IS_ENABLED(CONFIG_SND_COMPRESS_ACCEL);
    int (*task_create) (struct snd_compr_stream *stream, struct snd_compr_task_runtime *task);
    int (*task_start) (struct snd_compr_stream *stream, struct snd_compr_task_runtime *task);
    int (*task_stop) (struct snd_compr_stream *stream, struct snd_compr_task_runtime *task);
    int (*task_free) (struct snd_compr_stream *stream, struct snd_compr_task_runtime *task);
#endif;
};

成员

open: 打开压缩流。此回调是强制性的，应保持 DSP 准备好接收流参数
free: 关闭压缩流，强制性
set_params: 设置压缩流参数，强制性。这可以在创建流期间调用，仅用于设置编解码器参数和流属性
get_params: 检索编解码器参数，强制性
set_metadata: 设置流的元数据值
get_metadata: 从流中检索请求的元数据值
trigger: 触发开始、暂停、恢复、排空、停止等操作。此回调是强制性的
pointer: 检索当前硬件指针信息。强制性
copy: 将压缩数据复制到/从用户空间，可选。如果 DSP 支持 mmap，则无法实现
mmap: DSP mmap 方法用于 mmap DSP 内存
ack: 当数据写入音频缓冲区时 DSP 的确认，可选。如果实现了复制，则无效
get_caps: 检索 DSP 功能，强制性
get_codec_caps: 检索特定编解码器的功能，强制性
task_create: 为加速操作创建一组输入/输出缓冲区
task_start: 启动（排队）加速操作的任务
task_stop: 停止（取消排队）加速操作的任务
task_free: 释放一组用于加速操作的输入/输出缓冲区

struct snd_compr¶: 压缩设备

定义:

struct snd_compr {
    const char *name;
    struct device *dev;
    struct snd_compr_ops *ops;
    void *private_data;
    struct snd_card *card;
    unsigned int direction;
    struct mutex lock;
    int device;
    bool use_pause_in_draining;
#ifdef CONFIG_SND_VERBOSE_PROCFS;
};

成员

name: DSP 设备名称
dev: 关联的设备实例
ops: 指向 DSP 回调的指针
private_data: 指向 DSP pvt 数据的指针
card: 声卡指针
direction: 播放或捕获方向
lock: 设备锁
device: device id
use_pause_in_draining: 允许在排空状态下暂停，设置时为 true

void snd_compr_use_pause_in_draining(struct snd_compr_stream *substream)¶: 允许在排空状态下暂停和恢复

参数

struct snd_compr_stream *substream: 要设置的压缩子流

描述

允许在排空状态下暂停和恢复。仅支持此转换的硬件驱动程序可以调用此 API。

void snd_compr_set_runtime_buffer(struct snd_compr_stream *stream, struct snd_dma_buffer *bufp)¶: 设置压缩运行时缓冲区

参数

struct snd_compr_stream *stream: 要设置的压缩流
struct snd_dma_buffer *bufp: 缓冲区信息，NULL 表示清除

描述

当 bufp 不为 NULL 时，将缓冲区信息复制到运行时缓冲区。否则，它将清除当前缓冲区信息。

ASoC¶

ASoC 核心 API¶

struct snd_soc_component *snd_soc_kcontrol_component(struct snd_kcontrol *kcontrol)¶: 返回注册该控件的组件

参数

struct snd_kcontrol *kcontrol: 要获取组件的控件

注意

如果控件已为组件注册，此函数将正常工作。使用 snd_soc_add_codec_controls() 或通过基于表的设置用于 CODEC 或组件驱动程序。否则，行为是未定义的。

struct snd_soc_dai *snd_soc_find_dai(const struct snd_soc_dai_link_component *dlc)¶: 查找已注册的 DAI

参数

const struct snd_soc_dai_link_component *dlc: 要匹配的 DAI 的名称或 DAI 驱动程序以及可选的组件信息

描述

此函数将搜索所有已注册的组件及其 DAI，以查找同名的 DAI。如果指定了组件的 of_node 和名称，则也应匹配。

返回

DAI 的指针，如果未找到则为 NULL。

void snd_soc_remove_pcm_runtime(struct snd_soc_card *card, struct snd_soc_pcm_runtime *rtd)¶: 从卡中移除 pcm_runtime

参数

struct snd_soc_card *card: pcm_runtime 所属的 ASoC 卡
struct snd_soc_pcm_runtime *rtd: 要移除的 pcm_runtime

描述

此函数从 ASoC 卡中移除 pcm_runtime。

int snd_soc_add_pcm_runtime(struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)¶: 通过 dai_link 动态添加 pcm_runtime

参数

struct snd_soc_card *card: 要添加 pcm_runtime 的 ASoC 卡
struct snd_soc_dai_link *dai_link: 用于查找 pcm_runtime 的 DAI 链接

描述

此函数通过使用 dai_link 向 ASoC 卡添加 pcm_runtime。

注意

拓扑可以使用此 API 在探测拓扑组件时添加 pcm_runtime。机器驱动程序仍然可以在 dai_link 数组中定义静态 DAI 链接。

int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd, unsigned int dai_fmt)¶: 更改 ASoC 运行时的 DAI 链接格式

参数

struct snd_soc_pcm_runtime *rtd: 应更改 DAI 链接格式的运行时
unsigned int dai_fmt: 新的 DAI 链接格式

描述

此函数为指定运行时的 DAI 链接连接的所有 DAI 更新 DAI 链接格式。

成功返回 0，否则返回负错误代码。

注意

对于具有静态格式设置的设置，请在相应的 snd_dai_link 结构中设置 dai_fmt 字段，而不是使用此函数。

int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour)¶: 向卡注册 DMI 名称

参数

struct snd_soc_card *card: 要注册 DMI 名称的卡
const char *flavour: 卡在其同类中的“区分器”。

描述

英特尔机器驱动程序可能被许多不同的设备使用，但用户空间很难区分，因为机器驱动程序通常使用自己的名称作为卡短名称，并使卡长名称为空。为了区分此类设备并修复因缺少特定于设备的配置而导致的错误，此函数允许将 DMI 信息用作声卡长名称，格式为“vendor-product-version-board”（字符“-”用于分隔此处不同的 DMI 字段）。这将有助于用户空间为卡加载特定于设备的用例管理器 (UCM) 配置。

可能的卡长名称可能是：DellInc.-XPS139343-01-0310JH ASUSTeKCOMPUTERINC.-T100TA-1.0-T100TA Circuitco-MinnowboardMaxD0PLATFORM-D0-MinnowBoardMAX

此函数还支持为卡长名称添加“风味”，以提供额外的区分，如“vendor-product-version-board-flavor”。

我们只保留卡长名称中的数字和字母字符以及一些分隔符字符，因为用户空间中的 UCM 使用卡长名称作为卡配置目录名称，而 AudoConf 不支持空格等特殊字符。

成功返回 0，否则返回负错误代码。

struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template, void *data, const char *long_name, const char *prefix)¶: 创建新控件

参数

const struct snd_kcontrol_new *_template: 控件模板
void *data: 控件私有数据
const char *long_name: 控件长名称
const char *prefix: 控件名称前缀

描述

从模板控件创建新的混音器控件。

成功返回 0，否则返回错误。

int snd_soc_add_component_controls(struct snd_soc_component *component, const struct snd_kcontrol_new *controls, unsigned int num_controls)¶: 向组件添加一个控件数组。

参数

struct snd_soc_component *component: 要向其添加控件的组件
const struct snd_kcontrol_new *controls: 要添加的控件数组
unsigned int num_controls: 数组中的元素数

返回

成功返回 0，否则返回错误。

int snd_soc_add_card_controls(struct snd_soc_card *soc_card, const struct snd_kcontrol_new *controls, int num_controls)¶: 向 SoC 卡添加一个控件数组。添加控件列表的便捷函数。

参数

struct snd_soc_card *soc_card: 要向其添加控件的 SoC 卡
const struct snd_kcontrol_new *controls: 要添加的控件数组
int num_controls: 数组中的元素数

描述

成功返回 0，否则返回错误。

int snd_soc_add_dai_controls(struct snd_soc_dai *dai, const struct snd_kcontrol_new *controls, int num_controls)¶: 向 DAI 添加一系列控制项。用于添加控制项列表的便捷函数。

参数

struct snd_soc_dai *dai: 要向其添加控制项的 DAI
const struct snd_kcontrol_new *controls: 要添加的控件数组
int num_controls: 数组中的元素数

描述

成功返回 0，否则返回错误。

int snd_soc_register_card(struct snd_soc_card *card)¶: 向 ASoC 核心注册一个声卡

参数

struct snd_soc_card *card: 要注册的声卡

void snd_soc_unregister_card(struct snd_soc_card *card)¶: 从 ASoC 核心注销一个声卡

参数

struct snd_soc_card *card: 要注销的声卡

struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component, struct snd_soc_dai_driver *dai_drv, bool legacy_dai_naming)¶: 动态注册一个 DAI 并创建其小部件

参数

struct snd_soc_component *component: 注册 DAI 的组件
struct snd_soc_dai_driver *dai_drv: 用于 DAI 的 DAI 驱动程序
bool legacy_dai_naming: 如果为 true，则使用旧的单名称格式；如果为 false，则使用多名称格式；

描述

当探测组件时，拓扑可以使用此 API 注册 DAI。这些 DAI 的小部件将在声卡清理时释放，而 DAI 将在组件清理时释放。

void snd_soc_unregister_dais(struct snd_soc_component *component)¶: 从 ASoC 核心注销 DAI

参数

struct snd_soc_component *component: 应该注销 DAI 的组件

int snd_soc_register_dais(struct snd_soc_component *component, struct snd_soc_dai_driver *dai_drv, size_t count)¶: 向 ASoC 核心注册一个 DAI

参数

struct snd_soc_component *component: 注册 DAI 的组件
struct snd_soc_dai_driver *dai_drv: 用于 DAI 的 DAI 驱动程序
size_t count: DAI 的数量

void snd_soc_unregister_component_by_driver(struct device *dev, const struct snd_soc_component_driver *component_driver)¶: 使用给定的驱动程序从 ASoC 核心注销组件

参数

struct device *dev: 要注销的设备
const struct snd_soc_component_driver *component_driver: 要注销的组件驱动程序

void snd_soc_unregister_component(struct device *dev)¶: 从 ASoC 核心注销所有相关的组件

参数

struct device *dev: 要注销的设备

int devm_snd_soc_register_component(struct device *dev, const struct snd_soc_component_driver *cmpnt_drv, struct snd_soc_dai_driver *dai_drv, int num_dai)¶: 资源管理的组件注册

参数

struct device *dev: 用于管理组件的设备
const struct snd_soc_component_driver *cmpnt_drv: 组件驱动程序
struct snd_soc_dai_driver *dai_drv: DAI 驱动程序
int num_dai: 要注册的 DAI 的数量

描述

注册一个组件，并在设备注销时自动注销。

int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card)¶: 资源管理的声卡注册

参数

struct device *dev: 用于管理声卡的设备
struct snd_soc_card *card: 要注册的声卡

描述

注册一个声卡，并在设备注销时自动注销。

int devm_snd_dmaengine_pcm_register(struct device *dev, const struct snd_dmaengine_pcm_config *config, unsigned int flags)¶: 资源管理的 dmaengine PCM 注册

参数

struct device *dev: PCM 设备的父设备
const struct snd_dmaengine_pcm_config *config: 平台特定的 PCM 配置
unsigned int flags: 平台特定的怪癖

描述

注册一个基于 dmaengine 的 PCM 设备，并在设备注销时自动注销。

int snd_soc_component_set_sysclk(struct snd_soc_component *component, int clk_id, int source, unsigned int freq, int dir)¶: 配置 COMPONENT 系统或主时钟。

参数

struct snd_soc_component *component: COMPONENT
int clk_id: DAI 特定时钟 ID
int source: 时钟源
unsigned int freq: 新的时钟频率，单位为 Hz
int dir: 新的时钟方向 - 输入/输出。

描述

配置 CODEC 主时钟 (MCLK) 或系统时钟 (SYSCLK)。

int snd_soc_component_set_jack(struct snd_soc_component *component, struct snd_soc_jack *jack, void *data)¶: 配置组件的插孔。

参数

struct snd_soc_component *component: 组件
struct snd_soc_jack *jack: 用于插孔的结构
void *data: 如果编解码器驱动程序需要额外的用于配置插孔的数据，则可以使用

描述

配置并启用插孔检测功能。

int snd_soc_component_get_jack_type(struct snd_soc_component *component)¶

参数

struct snd_soc_component *component: 组件

描述

返回组件的插孔类型。这可以是支持的类型，也可以是从设备树中读取的，属性为：jack-type。

void snd_soc_component_init_regmap(struct snd_soc_component *component, struct regmap *regmap)¶: 初始化组件的 regmap 实例

参数

struct snd_soc_component *component: 要为其初始化 regmap 实例的组件
struct regmap *regmap: 该组件应使用的 regmap 实例

描述

此函数允许延迟分配与组件关联的 regmap 实例。仅当在注册组件时 regmap 实例尚未准备就绪时才使用此功能。必须在组件的第一次 IO 尝试之前调用此函数。

void snd_soc_component_exit_regmap(struct snd_soc_component *component)¶: 取消初始化组件的 regmap 实例

参数

struct snd_soc_component *component: 要为其取消初始化 regmap 实例的组件

描述

在与组件关联的 regmap 实例上调用 regmap_exit()，并从组件中删除 regmap 实例。

仅当使用 snd_soc_component_init_regmap() 初始化 regmap 实例时，才应使用此函数。

unsigned int snd_soc_component_read(struct snd_soc_component *component, unsigned int reg)¶: 读取寄存器值

参数

struct snd_soc_component *component: 要读取的组件
unsigned int reg: 要读取的寄存器

返回

读取的值

int snd_soc_component_write(struct snd_soc_component *component, unsigned int reg, unsigned int val)¶: 写入寄存器值

参数

struct snd_soc_component *component: 要写入的组件
unsigned int reg: 要写入的寄存器
unsigned int val: 要写入寄存器的值

返回

成功时为 0，否则为负错误代码。

int snd_soc_component_update_bits(struct snd_soc_component *component, unsigned int reg, unsigned int mask, unsigned int val)¶: 执行读取/修改/写入循环

参数

struct snd_soc_component *component: 要更新的组件
unsigned int reg: 要更新的寄存器
unsigned int mask: 指定要更新哪些位的掩码
unsigned int val: 由掩码指定的新位值

返回

如果操作成功且寄存器的值已更改，则为 1；如果操作成功，但值未更改，则为 0。否则返回负错误代码。

int snd_soc_component_update_bits_async(struct snd_soc_component *component, unsigned int reg, unsigned int mask, unsigned int val)¶: 执行异步读取/修改/写入循环

参数

struct snd_soc_component *component: 要更新的组件
unsigned int reg: 要更新的寄存器
unsigned int mask: 指定要更新哪些位的掩码
unsigned int val: 由掩码指定的新位值

描述

此函数类似于 snd_soc_component_update_bits()，但更新操作是异步调度的。这意味着当函数返回时，可能尚未完成。要确保所有计划的更新已完成，必须调用 snd_soc_component_async_complete()。

返回

如果操作成功且寄存器的值已更改，则为 1；如果操作成功，但值未更改，则为 0。否则返回负错误代码。

unsigned int snd_soc_component_read_field(struct snd_soc_component *component, unsigned int reg, unsigned int mask)¶: 读取寄存器字段值

参数

struct snd_soc_component *component: 要读取的组件
unsigned int reg: 要读取的寄存器
unsigned int mask: 寄存器字段的掩码

返回

寄存器字段的读取值。

int snd_soc_component_write_field(struct snd_soc_component *component, unsigned int reg, unsigned int mask, unsigned int val)¶: 写入寄存器字段

参数

struct snd_soc_component *component: 要写入的组件
unsigned int reg: 要写入的寄存器
unsigned int mask: 要更新的寄存器字段的掩码
unsigned int val: 要写入的字段的值

返回

更改为 1，否则为 0。

void snd_soc_component_async_complete(struct snd_soc_component *component)¶: 确保异步 I/O 已完成

参数

struct snd_soc_component *component: 要等待的组件

描述

此函数会阻塞，直到之前使用 snd_soc_component_update_bits_async() 调度的所有异步 I/O 完成。

int snd_soc_component_test_bits(struct snd_soc_component *component, unsigned int reg, unsigned int mask, unsigned int value)¶: 用于更改的测试寄存器

参数

struct snd_soc_component *component: 组件
unsigned int reg: 要测试的寄存器
unsigned int mask: 指定要测试哪些位的掩码
unsigned int value: 要比较的测试值

描述

用一个新值测试寄存器，并检查新值是否与旧值不同。

返回

更改为 1，否则为 0。

void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd, int stream, int action)¶: 增加/减少PCM运行时组件的活动计数

参数

struct snd_soc_pcm_runtime *rtd: 被激活的ASoC PCM运行时
int stream: PCM流的方向
int action: 如果为1则激活流。如果为-1则停用。

描述

增加/减少附加到 PCM 运行时的所有 DAI 和组件的活动计数。通常应在打开流时调用。

必须在持有 rtd->card->pcm_mutex 的情况下调用

bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd)¶: 检查是否忽略掉电延迟

参数

struct snd_soc_pcm_runtime *rtd: 应检查的 ASoC PCM 运行时。

描述

此函数检查是否应为特定的 PCM 运行时忽略掉电延迟。如果延迟为 0，如果 DAI 链接已配置为忽略延迟，或者如果没有组件从延迟中受益，则返回 true。

int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd, struct snd_pcm_hardware *hw, int stream)¶: 计算 PCM 流的硬件限制

参数

struct snd_soc_pcm_runtime *rtd: ASoC PCM 运行时
struct snd_pcm_hardware *hw: PCM 硬件参数（输出）
int stream: PCM流的方向

描述

计算与 PCM 流关联的所有 DAI 支持的流参数的子集。

int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)¶: 枚举的双混音器信息回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_info *uinfo: 控制元素信息

描述

提供有关双枚举混音器控制信息的回调。

成功返回 0。

int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 枚举的双混音器获取回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

用于获取双枚举混音器值的回调。

成功返回 0。

int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 枚举的双混音器设置回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

用于设置双枚举混音器值的回调。

成功返回 0。

int snd_soc_read_signed(struct snd_soc_component *component, unsigned int reg, unsigned int mask, unsigned int shift, unsigned int sign_bit, int *signed_val)¶: 读取编解码器寄存器并解释为有符号值

参数

struct snd_soc_component *component: 组件
unsigned int reg: 要读取的寄存器
unsigned int mask: 在移动寄存器值后使用的掩码
unsigned int shift: 寄存器值右移
unsigned int sign_bit: 描述数字是否为负数的位。
int *signed_val: 指向应存储读取值的指针

描述

此函数读取编解码器寄存器。寄存器值右移 ‘shift’ 位，并用给定的 ‘mask’ 屏蔽。然后，如果 sign_bit 非零，则将给定的寄存器值转换为有符号整数。

成功返回 0，否则返回错误值

int snd_soc_info_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)¶: 单个混音器信息回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_info *uinfo: 控制元素信息

描述

用于提供有关单个混音器控制或跨越 2 个寄存器的双混音器控制的信息的回调。

成功返回 0。

int snd_soc_info_volsw_sx(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)¶: SX TLV 控制的混音器信息回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_info *uinfo: 控制元素信息

描述

用于提供有关 SX TLV 类型的单个混音器控制或跨越 2 个寄存器的双混音器控制的信息的回调。SX TLV 控制的范围表示零两侧的正值和负值，但没有符号位。min 是最小寄存器值，max 是步数。

成功返回 0。

int snd_soc_get_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 单个混音器获取回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

用于获取单个混音器控制值或跨越 2 个寄存器的双混音器控制值的回调。

成功返回 0。

int snd_soc_put_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 单个混音器设置回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

用于设置单个混音器控制值或跨越 2 个寄存器的双混音器控制值的回调。

成功返回 0。

int snd_soc_get_volsw_sx(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 单个混音器获取回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

用于获取单个混音器控制值或跨越 2 个寄存器的双混音器控制值的回调。

成功返回 0。

int snd_soc_put_volsw_sx(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 双混音器设置回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

用于设置跨越 2 个寄存器的双混音器控制值的回调。

成功返回 0。

int snd_soc_info_volsw_range(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)¶: 带范围的单个混音器信息回调。

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_info *uinfo: 控制元素信息

描述

回调函数，用于提供关于单个混音器控制在一定范围内的信息。

成功返回 0。

int snd_soc_put_volsw_range(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 带范围的单个混音器设置值回调。

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

回调函数，用于设置单个混音器控制在一定范围内的值。

成功返回 0。

int snd_soc_get_volsw_range(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 带范围的单个混音器获取回调。

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

回调函数，用于获取单个混音器控制在一定范围内的值。

成功返回 0。

int snd_soc_limit_volume(struct snd_soc_card *card, const char *name, int max)¶: 设置现有音量控制的新限制。

参数

struct snd_soc_card *card: 在哪里查找控制。
const char *name: 控制的名称。
int max: 新的最大限制。

描述

成功返回 0，否则返回错误。

int snd_soc_info_xr_sx(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)¶: 带符号的多寄存器信息回调。

参数

struct snd_kcontrol *kcontrol: mreg 控制。
struct snd_ctl_elem_info *uinfo: 控制元素信息

描述

回调函数，用于提供控制的信息，该控制可以跨越多个编解码器寄存器，这些寄存器以 MSB/LSB 的方式共同形成一个带符号的单个值。

成功返回 0。

int snd_soc_get_xr_sx(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 带符号的多寄存器获取回调。

参数

struct snd_kcontrol *kcontrol: mreg 控制。
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

回调函数，用于获取一个控制的值，该控制可以跨越多个编解码器寄存器，这些寄存器以 MSB/LSB 的方式共同形成一个带符号的单个值。该控制支持指定使用的总位数，以便允许跨多个编解码器寄存器的位域。

成功返回 0。

int snd_soc_put_xr_sx(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 带符号的多寄存器获取回调。

参数

struct snd_kcontrol *kcontrol: mreg 控制。
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

回调函数，用于设置一个控制的值，该控制可以跨越多个编解码器寄存器，这些寄存器以 MSB/LSB 的方式共同形成一个带符号的单个值。该控制支持指定使用的总位数，以便允许跨多个编解码器寄存器的位域。

成功返回 0。

int snd_soc_get_strobe(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 选通获取回调。

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

回调函数，用于获取选通混音器控制的值。

成功返回 0。

int snd_soc_put_strobe(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 选通设置回调。

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

回调函数，用于在单个混音器枚举控制的一次传递中，将寄存器位选通为高电平然后低电平（或相反）。

成功返回 1。

int snd_soc_new_compress(struct snd_soc_pcm_runtime *rtd)¶: 创建一个新的压缩。

参数

struct snd_soc_pcm_runtime *rtd: 我们将为其创建压缩的运行时。

返回

成功返回 0，否则返回错误。

ASoC DAPM API¶

struct snd_soc_dapm_widget *snd_soc_dapm_kcontrol_widget(struct snd_kcontrol *kcontrol)¶: 返回与 kcontrol 关联的 widget。

参数

struct snd_kcontrol *kcontrol: kcontrol。

struct snd_soc_dapm_context *snd_soc_dapm_kcontrol_dapm(struct snd_kcontrol *kcontrol)¶: 返回与 kcontrol 关联的 dapm 上下文。

参数

struct snd_kcontrol *kcontrol: kcontrol。

注意

此函数只能用于已知已为 CODEC 注册的 kcontrol。否则，行为是未定义的。

int snd_soc_dapm_force_bias_level(struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)¶: 设置 DAPM 偏置电平。

参数

struct snd_soc_dapm_context *dapm: 要为其设置电平的 DAPM 上下文。
enum snd_soc_bias_level level: 要设置的电平。

描述

强制将 DAPM 偏置电平设置为特定状态。它将使用指定的电平调用 DAPM 上下文的偏置电平回调。即使上下文已经处于相同的电平，也会发生这种情况。此外，它不会经过正常的偏置电平排序，这意味着不会进入当前状态和目标状态之间的任何中间状态。

请注意，偏置电平的更改只是暂时的，下次调用 snd_soc_dapm_sync() 时，状态将设置为由 DAPM 核心确定的电平。该函数主要用于在探测或从挂起恢复期间用于为设备供电，以便在 DAPM 核心接管之前完成初始化。

int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm, enum snd_soc_bias_level level)¶: 设置系统的偏置电平

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
enum snd_soc_bias_level level: 要配置的电平

描述

为 SoC 音频设备配置偏置（功率）电平。

成功返回 0，否则返回错误。

int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream, struct snd_soc_dapm_widget_list **list, bool (*custom_stop_condition)(struct snd_soc_dapm_widget*, enum snd_soc_dapm_direction))¶: 查询音频路径及其部件。

参数

struct snd_soc_dai *dai: soc DAI。
int stream: 流方向。
struct snd_soc_dapm_widget_list **list: 此流的活动部件列表。
bool (*custom_stop_condition)(struct snd_soc_dapm_widget *, enum snd_soc_dapm_direction): （可选）一个旨在根据自定义逻辑停止部件图遍历的函数。

描述

查询 DAPM 图，以确定是否存在指定名称的初始流的有效音频流路径。这会考虑当前混音器和多路复用器 kcontrol 设置。创建有效部件列表。

可以选择提供一个函数作为停止条件。此函数将当前正在检查的 dapm 部件和遍历方向作为参数，如果应该停止遍历，则应返回 true，否则返回 false。

返回有效路径数或负错误。

void snd_soc_dapm_free_widget(struct snd_soc_dapm_widget *w)¶: 释放指定的部件

参数

struct snd_soc_dapm_widget *w: 要释放的部件

描述

从所有路径中删除部件并释放其占用的内存。

int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm)¶: 扫描和电源 dapm 路径

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文

描述

遍历所有 dapm 音频路径，并根据其流或路径使用情况为部件供电。

需要外部锁定。

成功返回 0。

int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm)¶: 扫描和电源 dapm 路径

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文

描述

遍历所有 dapm 音频路径，并根据其流或路径使用情况为部件供电。

成功返回 0。

int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm, const struct snd_soc_dapm_route *route, int num)¶: 在 DAPM 部件之间添加路由

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const struct snd_soc_dapm_route *route: 音频路由
int num: 路由数

描述

通过命名的音频路径将 2 个 dapm 部件连接在一起。接收音频信号的部件是接收器，而发送音频信号的部件是发送器。

成功返回 0，否则返回错误。发生错误时，可以通过调用 snd_soc_card_free() 释放所有资源。

int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm, const struct snd_soc_dapm_route *route, int num)¶: 删除 DAPM 部件之间的路由

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const struct snd_soc_dapm_route *route: 音频路由
int num: 路由数

描述

从 DAPM 上下文中删除路由。

int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm, const struct snd_soc_dapm_route *route, int num)¶: 将 DAPM 部件之间的路由标记为弱

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const struct snd_soc_dapm_route *route: 音频路由
int num: 路由数

描述

将传递的数组中指定的匹配现有路由标记为弱，这意味着为了电源决策的目的将忽略它们。主要的预期用例是用于侧音路径，如果它们都是活动的，则这些侧音路径会将音频耦合到其他独立路径之间，以便在用户级别更好地工作，但不打算“使用”。

请注意，CODEC 驱动程序不应将此用作侧音类型路径，因为侧音类型路径通常也可用作旁路路径。

int snd_soc_dapm_new_widgets(struct snd_soc_card *card)¶: 添加新的 dapm 部件

参数

struct snd_soc_card *card: 要检查是否有新 dapm 部件的卡片

描述

检查编解码器是否有任何新的 dapm 部件，如果找到则创建它们。

成功返回 0。

int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: dapm 混音器获取回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

获取 dapm 混音器控件值的回调。

成功返回 0。

int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: dapm 混音器设置回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

设置 dapm 混音器控件值的回调。

成功返回 0。

int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: dapm 枚举双混音器获取回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

获取 dapm 枚举双混音器控件值的回调。

成功返回 0。

int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: dapm 枚举双混音器设置回调

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 控制元素信息

描述

设置 dapm 枚举双混音器控件值的回调。

成功返回 0。

int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)¶: 引脚开关的信息

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_info *uinfo: 控制元素信息

描述

提供关于引脚开关控制信息的的回调函数。

int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 获取引脚开关的信息

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 值

int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)¶: 设置引脚开关的信息

参数

struct snd_kcontrol *kcontrol: 混音器控制
struct snd_ctl_elem_value *ucontrol: 值

struct snd_soc_dapm_widget *snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm, const struct snd_soc_dapm_widget *widget)¶: 创建新的 dapm 控制

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const struct snd_soc_dapm_widget *widget: widget 模板

描述

基于模板创建新的 DAPM 控制。

成功返回一个 widget 指针，失败返回一个错误指针

int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm, const struct snd_soc_dapm_widget *widget, unsigned int num)¶: 创建新的 dapm 控制

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const struct snd_soc_dapm_widget *widget: widget 数组
unsigned int num: widget 的数量

描述

基于模板创建新的 DAPM 控制。

成功返回 0，否则返回错误。

int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm, struct snd_soc_dai *dai)¶: 创建新的 DAPM widget

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
struct snd_soc_dai *dai: 父 DAI

描述

成功返回 0，否则返回错误代码。

void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream, int event)¶: 向 dapm 核心发送流事件

参数

struct snd_soc_pcm_runtime *rtd: PCM 运行时数据
int stream: 流名称
int event: 流事件

描述

向 dapm 核心发送一个流事件。然后核心进行任何必要的 widget 电源更改。

成功返回 0，否则返回错误。

int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm, const char *pin)¶: 启用引脚。

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const char *pin: 引脚名称

描述

如果存在有效的音频路由和活动的音频流，则启用输入/输出引脚及其父或子 widget。

需要外部锁定。

注意

之后需要调用 snd_soc_dapm_sync() 以便 DAPM 进行任何 widget 电源切换。

int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)¶: 启用引脚。

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const char *pin: 引脚名称

描述

如果存在有效的音频路由和活动的音频流，则启用输入/输出引脚及其父或子 widget。

注意

之后需要调用 snd_soc_dapm_sync() 以便 DAPM 进行任何 widget 电源切换。

int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm, const char *pin)¶: 强制启用引脚

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const char *pin: 引脚名称

描述

无论任何其他状态，都启用输入/输出引脚。这旨在用于麦克风插孔检测中使用的麦克风偏置电源。

需要外部锁定。

注意

之后需要调用 snd_soc_dapm_sync() 以便 DAPM 进行任何 widget 电源切换。

int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin)¶: 强制启用引脚

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const char *pin: 引脚名称

描述

无论任何其他状态，都启用输入/输出引脚。这旨在用于麦克风插孔检测中使用的麦克风偏置电源。

注意

之后需要调用 snd_soc_dapm_sync() 以便 DAPM 进行任何 widget 电源切换。

int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm, const char *pin)¶: 禁用引脚。

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const char *pin: 引脚名称

描述

禁用输入/输出引脚及其父或子 widget。

需要外部锁定。

注意

之后需要调用 snd_soc_dapm_sync() 以便 DAPM 进行任何 widget 电源切换。

int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm, const char *pin)¶: 禁用引脚。

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const char *pin: 引脚名称

描述

禁用输入/输出引脚及其父或子 widget。

注意

之后需要调用 snd_soc_dapm_sync() 以便 DAPM 进行任何 widget 电源切换。

int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm, const char *pin)¶: 永久禁用引脚。

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const char *pin: 引脚名称

描述

将指定的引脚标记为未连接，禁用它以及任何父或子 widget。目前，这与 snd_soc_dapm_disable_pin() 相同，但将来会扩展到执行其他操作，例如禁用仅影响通过引脚的路径的控件。

需要外部锁定。

注意

之后需要调用 snd_soc_dapm_sync() 以便 DAPM 进行任何 widget 电源切换。

int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin)¶: 永久禁用引脚。

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const char *pin: 引脚名称

描述

将指定的引脚标记为未连接，禁用它以及任何父或子 widget。目前，这与 snd_soc_dapm_disable_pin() 相同，但将来会扩展到执行其他操作，例如禁用仅影响通过引脚的路径的控件。

注意

之后需要调用 snd_soc_dapm_sync() 以便 DAPM 进行任何 widget 电源切换。

int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm, const char *pin)¶: 获取音频引脚状态

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const char *pin: 音频信号引脚端点（或起始点）

描述

获取音频引脚状态 - 连接或断开连接。

连接返回 1，否则返回 0。

int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm, const char *pin)¶: 忽略 DAPM 端点的挂起状态

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文
const char *pin: 音频信号引脚端点（或起始点）

描述

将给定的端点或引脚标记为忽略挂起。当系统禁用时，两个标记为忽略挂起的端点之间的路径不会被禁用。该路径必须在挂起时通过正常方式启用，如果它尚未启用，则不会打开。

void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)¶: 释放 dapm 资源

参数

struct snd_soc_dapm_context *dapm: DAPM 上下文

描述

释放所有 dapm 小部件和资源。

ASoC DMA 引擎 API¶

int snd_dmaengine_pcm_prepare_slave_config(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct dma_slave_config *slave_config)¶: 通用 prepare_slave_config 回调

参数

struct snd_pcm_substream *substream: PCM 子流
struct snd_pcm_hw_params *params: hw_params。
struct dma_slave_config *slave_config: 要准备的 DMA 从设备配置

描述

此函数可用作平台的通用 prepare_slave_config 回调，这些平台使用 snd_dmaengine_dai_dma_data 结构作为其 DAI DMA 数据。在内部，该函数将首先调用 snd_hwparams_to_dma_slave_config 以根据 hw_params 填充从设备配置，然后调用 snd_dmaengine_pcm_set_config_from_dai_data 以根据 DAI DMA 数据填充其余字段。

int snd_dmaengine_pcm_register(struct device *dev, const struct snd_dmaengine_pcm_config *config, unsigned int flags)¶: 注册一个基于 dmaengine 的 PCM 设备

参数

struct device *dev: PCM 设备的父设备
const struct snd_dmaengine_pcm_config *config: 平台特定的 PCM 配置
unsigned int flags: 平台特定的怪癖

void snd_dmaengine_pcm_unregister(struct device *dev)¶: 移除一个基于 dmaengine 的 PCM 设备

参数

struct device *dev: PCM 注册的父设备

描述

移除先前使用 snd_dmaengine_pcm_register 注册的基于 dmaengine 的 PCM 设备。

杂项函数¶

硬件相关设备 API¶

int snd_hwdep_new(struct snd_card *card, char *id, int device, struct snd_hwdep **rhwdep)¶: 创建一个新的 hwdep 实例

参数

struct snd_card *card: 声卡实例
char *id: id 字符串
int device: 设备索引（从零开始）
struct snd_hwdep **rhwdep: 用于存储新 hwdep 实例的指针

描述

在卡上使用给定的索引创建一个新的 hwdep 实例。回调（hwdep->ops）必须在调用者手动调用后在返回的实例上设置。

返回

成功时返回零，失败时返回负错误代码。

Jack 抽象层 API¶

enum snd_jack_types¶: 可以报告的 Jack 类型

常量

SND_JACK_HEADPHONE: 耳机
SND_JACK_MICROPHONE: 麦克风
SND_JACK_HEADSET: 耳机麦克风
SND_JACK_LINEOUT: 线路输出
SND_JACK_MECHANICAL: 机械开关
SND_JACK_VIDEOOUT: 视频输出
SND_JACK_AVOUT: 影音（音频视频）输出
SND_JACK_LINEIN: 线路输入
SND_JACK_BTN_0: 按钮 0
SND_JACK_BTN_1: 按钮 1
SND_JACK_BTN_2: 按钮 2
SND_JACK_BTN_3: 按钮 3
SND_JACK_BTN_4: 按钮 4
SND_JACK_BTN_5: 按钮 5

描述

这些值用作位掩码。

请注意，这必须与 sound/core/jack.c 中的查找表保持同步。

int snd_jack_add_new_kctl(struct snd_jack *jack, const char *name, int mask)¶: 创建一个新的 snd_jack_kctl 并将其添加到 jack

参数

struct snd_jack *jack: kctl 将附加到的 jack 实例
const char * name: snd_kcontrol 对象的名称
int mask: 此 snd_jack_kctl 对象可以检测到的枚举 snd_jack_type 值的位掩码。

描述

创建一个新的 snd_kcontrol 对象并将其添加到 jack kctl_list。

返回

成功时返回零，失败时返回负错误代码。

int snd_jack_new(struct snd_card *card, const char *id, int type, struct snd_jack **jjack, bool initial_kctl, bool phantom_jack)¶: 创建一个新的 jack

参数

struct snd_card *card: 声卡实例
const char *id: 此 jack 的标识字符串
int type: 此 jack 可以检测到的枚举 snd_jack_type 值的位掩码
struct snd_jack **jjack: 用于向调用者提供已分配的 jack 对象。
bool initial_kctl: 如果为 true，则创建一个 kcontrol 并将其添加到 jack 列表。
bool phantom_jack: 不要为幻影 jack 创建输入设备。

描述

创建一个新的 jack 对象。

返回

成功时返回零，失败时返回负错误代码。成功时，将初始化 jjack。

void snd_jack_set_parent(struct snd_jack *jack, struct device *parent)¶: 设置 jack 的父设备

参数

struct snd_jack *jack: 要配置的 jack
struct device *parent: 要设置为 jack 的父设备的设备。

描述

在设备树中设置插孔设备的父设备。此函数仅在注册插孔之前有效。如果未配置父设备，则父设备将为声卡。

int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type, int keytype)¶: 在插孔上设置按键映射

参数

struct snd_jack *jack: 要配置的 jack
enum snd_jack_types type: 此按键的插孔报告类型
int keytype: 要报告的输入层按键类型

描述

将 SND_JACK_BTN_* 按钮类型映射到输入层按键，允许通过插孔抽象报告配件上的按键。如果没有提供映射，但在插孔类型中启用了按键，则将报告 BTN_n 数字按钮。

如果插孔不通过输入 API 报告，则此调用无效。

请注意，这旨在供具有少量可报告按键的简单设备使用。也可以直接访问输入设备 - 配件上具有复杂输入功能的设备应考虑这样做，而不是使用此抽象。

此函数只能在注册插孔之前调用。

返回

成功时返回零，失败时返回负错误代码。

void snd_jack_report(struct snd_jack *jack, int status)¶: 报告插孔的当前状态

参数

struct snd_jack *jack: 要报告状态的插孔
int status: 插孔的当前状态

注意

此函数使用互斥锁，应从可以休眠的上下文（例如工作队列）中调用。

void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask)¶: 报告插孔的当前状态

参数

struct snd_soc_jack *jack: 插孔
int status: 当前检测到的 snd_jack_type 枚举值的位掩码。
int mask: 要报告的 snd_jack_type 枚举值的位掩码。

描述

如果使用 snd_soc_jack_add_pins() 配置，则将根据需要启用或禁用相关的 DAPM 引脚，并同步 DAPM。

注意

此函数使用互斥锁，应从可以休眠的上下文（例如工作队列）中调用。

int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count, struct snd_soc_jack_zone *zones)¶: 将电压区域与插孔关联

参数

struct snd_soc_jack *jack: ASoC 插孔
int count: 区域数量
struct snd_soc_jack_zone *zones: 区域数组

描述

调用此函数后，数组中指定的区域将与插孔关联。

int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage)¶: 根据麦克风偏置值，此函数从插孔类型中声明的区域返回插孔的类型

参数

struct snd_soc_jack *jack: ASoC 插孔
int micbias_voltage: 插入插孔时 ADC 通道上的麦克风偏置电压

描述

根据传递的麦克风偏置值，此函数有助于从已声明的插孔区域中识别插孔的类型

int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count, struct snd_soc_jack_pin *pins)¶: 将 DAPM 引脚与 ASoC 插孔关联

参数

struct snd_soc_jack *jack: 使用 snd_soc_card_jack_new_pins() 创建的 ASoC 插孔
int count: 引脚数
struct snd_soc_jack_pin *pins: 引脚数组

描述

调用此函数后，每当更新插孔状态时，引脚数组中指定的 DAPM 引脚的状态都将更新以反映插孔的当前状态。

void snd_soc_jack_notifier_register(struct snd_soc_jack *jack, struct notifier_block *nb)¶: 注册插孔状态的通知器

参数

struct snd_soc_jack *jack: ASoC 插孔
struct notifier_block *nb: 要注册的通知器块

描述

注册插孔当前状态的通知。请注意，无法从通知器的回调中报告其他插孔事件，这旨在支持仅在发生机械检测事件时才启用电气检测等应用程序。

void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack, struct notifier_block *nb)¶: 取消注册插孔状态的通知器

参数

struct snd_soc_jack *jack: ASoC 插孔
struct notifier_block *nb: 要取消注册的通知器块

描述

停止通知状态更改。

int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count, struct snd_soc_jack_gpio *gpios)¶: 将 GPIO 引脚与 ASoC 插孔关联

参数

struct snd_soc_jack *jack: ASoC 插孔
int count: 引脚数
struct snd_soc_jack_gpio *gpios: gpio 引脚数组

描述

此函数将请求 gpio，设置数据方向并请求数组中每个 gpio 的 irq。

int snd_soc_jack_add_gpiods(struct device *gpiod_dev, struct snd_soc_jack *jack, int count, struct snd_soc_jack_gpio *gpios)¶: 将 GPIO 描述符引脚与 ASoC 插孔关联

参数

struct device *gpiod_dev: GPIO 消费者设备
struct snd_soc_jack *jack: ASoC 插孔
int count: 引脚数
struct snd_soc_jack_gpio *gpios: gpio 引脚数组

描述

此函数将请求 gpio，设置数据方向并请求数组中每个 gpio 的 irq。

void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count, struct snd_soc_jack_gpio *gpios)¶: 释放 ASoC 插孔的 GPIO 引脚资源

参数

struct snd_soc_jack *jack: ASoC 插孔
int count: 引脚数
struct snd_soc_jack_gpio *gpios: gpio 引脚数组

描述

释放与 ASoC 插孔关联的 gpio 引脚的 gpio 和 irq 资源。

ISA DMA 助手¶

void snd_dma_program(unsigned long dma, unsigned long addr, unsigned int size, unsigned short mode)¶: 编程 ISA DMA 传输

参数

unsigned long dma: DMA 编号
unsigned long addr: 缓冲区物理地址
unsigned int size: DMA 传输大小
unsigned short mode: DMA 传输模式，DMA_MODE_XXX

描述

为给定的缓冲区编程一个 ISA DMA 传输。

void snd_dma_disable(unsigned long dma)¶: 停止 ISA DMA 传输

参数

unsigned long dma: DMA 编号

描述

停止 ISA DMA 传输。

unsigned int snd_dma_pointer(unsigned long dma, unsigned int size)¶: 返回 DMA 传输缓冲区中当前指针的字节位置

参数

unsigned long dma: DMA 编号
unsigned int size: DMA 传输大小

返回

DMA 传输缓冲区中当前指针的字节位置。

int snd_devm_request_dma(struct device *dev, int dma, const char *name)¶: request_dma() 的托管版本

参数

struct device *dev: 设备指针
int dma: DMA 编号
const char *name: 请求者的名称字符串

描述

请求的 DMA 将在通过 devres 取消绑定时自动释放。

返回

成功返回零，否则返回负错误代码

其他辅助宏¶

void snd_power_ref(struct snd_card *card)¶: 获取电源控制的引用计数

参数

struct snd_card *card: 声卡对象

描述

卡的 power_ref 引用用于管理阻止 snd_power_sync_ref() 操作。此函数会增加引用。稍后必须适当调用对应的 snd_power_unref()。

void snd_power_unref(struct snd_card *card)¶: 释放电源控制的引用计数

参数

struct snd_card *card: 声卡对象

void snd_power_sync_ref(struct snd_card *card)¶: 等待直到卡 power_ref 被释放

参数

struct snd_card *card: 声卡对象

描述

此函数用于与待释放的 power_ref 同步。

void snd_card_unref(struct snd_card *card)¶: 释放卡对象

参数

struct snd_card *card: 要释放的卡对象

描述

对通过 snd_card_ref() 或 snd_lookup_minor_data() 获取的卡对象调用此函数。

snd_BUG¶

snd_BUG ()

给出 BUG 警告消息和堆栈跟踪

描述

如果设置了 CONFIG_SND_DEBUG，则调用 WARN()。如果未设置 CONFIG_SND_DEBUG，则忽略。

snd_BUG_ON¶

snd_BUG_ON (cond)

调试检查宏

参数

cond: 要评估的条件

描述

当设置 CONFIG_SND_DEBUG 时，行为与 WARN_ON 相同，否则只评估条件并返回值。

int register_sound_special_device(const struct file_operations *fops, int unit, struct device *dev)¶: 注册一个特殊的音频节点

参数

const struct file_operations *fops

驱动程序的文件操作

int unit

要分配的单元号

struct device *dev

设备指针

通过次要编号从音频子系统中分配一个特殊的音频设备。

返回

成功时返回分配的编号。失败时，: 返回负错误代码。

int register_sound_mixer(const struct file_operations *fops, int dev)¶: 注册混音器设备

参数

const struct file_operations *fops

驱动程序的文件操作

int dev

要分配的单元号

分配一个混音器设备。单元是要请求的混音器编号。传递 -1 以请求下一个空闲的混音器单元。

返回

成功时，返回分配的编号。失败时，: 返回负错误代码。

int register_sound_dsp(const struct file_operations *fops, int dev)¶: 注册 DSP 设备

参数

const struct file_operations *fops

驱动程序的文件操作

int dev

要分配的单元号

分配一个 DSP 设备。单元是要请求的 DSP 编号。传递 -1 以请求下一个空闲的 DSP 单元。

此函数将音频和 dsp 设备条目一起分配，并且始终将它们作为匹配对分配 - 例如 dsp3/audio3

返回

成功时，返回分配的编号。失败时，: 返回负错误代码。

void unregister_sound_special(int unit)¶: 注销一个特殊的音频设备

参数

int unit

要分配的单元号

释放使用 register_sound_special() 分配的音频设备。传递的单元是来自注册函数的返回值。

void unregister_sound_mixer(int unit)¶: 注销混音器

参数

int unit

要分配的单元号

释放使用 register_sound_mixer() 分配的音频设备。传递的单元是来自注册函数的返回值。

void unregister_sound_dsp(int unit)¶: 注销 DSP 设备

参数

int unit

要分配的单元号

释放使用 register_sound_dsp() 分配的音频设备。传递的单元是来自注册函数的返回值。

两个分配的单元将一起自动释放。

Linux 内核

目录

本页

ALSA 驱动程序 API¶

卡和设备的管理¶

卡管理¶

设备组件¶

模块请求和设备文件条目¶

内存管理助手¶

PCM API¶

PCM 核心¶

PCM 格式辅助函数¶

PCM 内存管理¶

PCM DMA 引擎 API¶

控制/混音器 API¶

通用控制接口¶

AC97 编解码器 API¶

虚拟主控制 API¶

MIDI API¶

原始 MIDI API¶

MPU401-UART API¶

Proc Info API¶

Proc Info 接口¶

压缩卸载¶

压缩卸载 API¶

ASoC¶

ASoC 核心 API¶

ASoC DAPM API¶

ASoC DMA 引擎 API¶

杂项函数¶

硬件相关设备 API¶

Jack 抽象层 API¶

ISA DMA 助手¶

其他辅助宏¶