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 实例，并为驱动程序提供自由使用的空间。分配的 struct 存储在给定的 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。

返回值

零，否则为负错误代码。

注意

当前实现将所有活动的 file->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() 后创建了任何新设备，则可以稍后调用。

返回值

如果成功，则为零，如果失败或未找到设备，则为负错误代码。

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

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 空间复制到用户空间。

返回值

如果成功，则为零；如果失败，则为非零。

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

参数

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

描述

将数据从 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 空间。

返回值

如果成功，则为零；如果失败，则为非零。

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

参数

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

描述

将数据从 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 是否相似或不同。特殊情况是仅包含零的标识符。对此组合的解释是 - 空（未设置）。不应以任何其他方式解释标识符的内容。

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

此例程使用前四个字节中的卡号和 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)¶: 添加硬件约束 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)¶: 添加硬件约束步长规则

参数

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)¶: 添加硬件约束 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 流的自旋锁或互斥锁，具体取决于给定子流的 nonatomic 标志。这也会获取全局链接读写锁（或读写信号量），以避免与链接流发生竞争。

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 时）。在 nonatomic 情况下，这与 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)¶: 触发 SUSPEND 到给定 pcm 中的所有子流

参数

struct snd_pcm *pcm: PCM 实例

描述

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

返回值

如果成功（或 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 cmd
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 mem 的默认 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 ... (boundary - 1) 之间

返回值

可用帧大小

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

参数

struct snd_pcm_runtime *runtime: PCM 运行时实例

描述

结果介于 0 ... (boundary - 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 大于或等于 boundary，则此函数始终返回非零值。

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() 的循环中调用此函数，以将子流标记为“已完成”。然后，大多数触发操作仅对给定的主子流执行。

触发主标记在触发操作结束时的 timestamp 更新时清除。

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

参数

const struct snd_pcm_hw_params *p: hw params

返回值

通道数

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

参数

const struct snd_pcm_hw_params *p: hw params

返回值

采样率

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

参数

const struct snd_pcm_hw_params *p: hw params

返回值

以帧为单位的周期大小

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

参数

const struct snd_pcm_hw_params *p: hw params

返回值

周期数

unsigned int params_buffer_size(const struct snd_pcm_hw_params *p)¶: 从 hw params 获取缓冲区大小（以帧为单位）

参数

const struct snd_pcm_hw_params *p: hw params

返回值

以帧为单位的缓冲区大小

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

参数

const struct snd_pcm_hw_params *p: hw params

返回值

以字节为单位的缓冲区大小

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)¶: 根据 timestamp 模式填充 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)¶: 计算从给定大小开始的最大大小，该大小适合 contig. 页面

参数

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)¶: 获取分配给给定 chmap 信息的 PCM 子流

参数

struct snd_pcm_chmap *info: chmap 信息
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 实例

描述

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

返回值

如果成功，则为零。

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 都支持的速率。

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: 允许的最大预分配大小

描述

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

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 调用之前实际分配缓冲区时，它会为驱动程序更改其 h/w 参数打开运行时 buffer_changed 标志。

当 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: 允许的最大预分配大小

描述

为指定 DMA 类型和大小的给定 pcm 的所有子流进行预分配，并将 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_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)¶: 优化运行时 hw 参数

参数

struct snd_pcm_substream *substream: PCM 子流
struct snd_dmaengine_dai_dma_data *dma_data: DAI DMA 数据
struct snd_pcm_hardware *hw: PCM hw 参数
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 接收的最大字数（注意：字数，就像 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[])¶: 填充枚举控件的信息结构

参数

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

描述

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

返回值

零（始终成功）

AC97 Codec 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: quirk 列表
const char *override: 显式 quirk 值（如果非 NULL，则覆盖列表）

描述

为每个 pci 设备做一些变通方法，例如将耳机（真线路输出）控件重命名为“Master”。quirk 列表必须以零填充条目结尾。

返回值

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

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 添加多个 follower

参数

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

描述

添加具有给定名称的多个 follower kcontrol。成功时返回 0，否则返回负错误代码。

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

参数

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

描述

创建具有给定名称字符串的虚拟主控制。

创建 vmaster 元素后，可以通过 snd_ctl_add_follower() 或 snd_ctl_add_follower_uncached() 添加 follower 控制。

可选参数 tlv 可用于指定主控制的 dB 比例的 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 控制添加 hook

参数

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

描述

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

返回值

零。

void snd_ctl_sync_vmaster(struct snd_kcontrol *kcontrol, bool hook_only)¶: 同步 vmaster follower 和 hook

参数

struct snd_kcontrol *kcontrol: vmaster kctl 元素
bool hook_only: 仅同步 hook

描述

强制调用每个 follower 的 put 回调，并调用 hook 函数以与给定 vmaster 元素的当前值同步。当将 NULL 传递给 kcontrol 时，为 NOP。

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 follower

参数

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

描述

将函数 func 应用于给定 vmaster kctl 的每个 follower 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)¶: 添加虚拟 follower 控制

参数

struct snd_kcontrol *master: vmaster 元素
struct snd_kcontrol *follower: 要添加的 follower 元素

描述

将虚拟 follower 控制添加到先前通过 snd_ctl_create_virtual_master() 创建的给定主元素。

所有 follower 必须是相同的类型（通过 info 回调返回相同的信息）。该函数不检查它，因此您有责任。

此外，还有一些其他限制：最多两个通道，对数音量控制（dB 电平），因此没有线性音量，主控只能衰减音量，没有增益

返回值

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

int snd_ctl_add_follower_uncached(struct snd_kcontrol *master, struct snd_kcontrol *follower)¶: 添加虚拟 follower 控制

参数

struct snd_kcontrol *master: vmaster 元素
struct snd_kcontrol *follower: 要添加的 follower 元素

描述

向给定的主控添加虚拟 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: 原始 MIDI 子流

返回值

丢弃的字节数

int snd_rawmidi_new(struct snd_card *card, char *id, int device, int output_count, int input_count, struct snd_rawmidi **rrawmidi)¶: 创建原始 MIDI 实例

参数

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

描述

创建新的原始 MIDI 实例。使用 snd_rawmidi_set_ops() 将操作符设置为新实例。

返回值

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

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

参数

struct snd_rawmidi *rmidi: 原始 MIDI 实例
int stream: 流方向，SNDRV_RAWMIDI_STREAM_XXX
const struct snd_rawmidi_ops *ops: 操作表

描述

为给定的流方向设置原始 MIDI 操作符。

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: 用于存储新原始 MIDI 实例的指针

描述

创建新的 MPU-401 实例。

请注意，原始 MIDI 实例在 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)¶: 为给定的模块创建 info 条目

参数

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

描述

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

返回值

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

struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card, const char *name, struct snd_info_entry *parent)¶: 为给定的卡创建 info 条目

参数

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

描述

创建一个新的 info 条目并将其分配给给定的卡。

返回值

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

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

参数

struct snd_info_entry * entry: info 条目

描述

释放 info 条目。

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

参数

struct snd_info_entry *entry: info 条目

描述

注册 proc info 条目。所有子条目都会递归注册。

返回值

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

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，假设用户将选择质量配置文件。如果需要，可以在以后阶段添加影响编码质量和速度的其他选项。

默认情况下，编码器使用 Subset 格式。

诸如图片等 TAGS 不能由卸载的编码器处理，并且此 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: 检索当前 h/w 指针信息。强制性
copy: 将压缩数据复制到/从用户空间复制，可选如果 DSP 支持 mmap，则无法实现
mmap: 用于 mmap DSP 存储的 DSP mmap 方法
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: 要设置的压缩子流

描述

允许在耗尽状态下暂停和恢复。只有 HW 驱动程序支持此转换才能调用此 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 将 pcm_runtime 添加到 ASoC 卡。

注意

拓扑可以使用此 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)¶: 将DMI名称注册到声卡

参数

struct snd_soc_card *card: 要注册DMI名称的声卡

描述

Intel机器驱动程序可能被许多不同的设备使用，但是用户空间很难区分，因为机器驱动程序通常使用自己的名称作为声卡短名称，而将声卡长名称留为空白。为了区分此类设备并修复由于缺少设备特定的配置而导致的错误，此函数允许将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: 要注销的组件驱动程序

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: 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: 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: mask指定的位的新值

返回值

如果操作成功并且寄存器的值已更改，则为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: mask指定的位的新值

描述

此函数类似于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_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_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: 控制元素信息

描述

回调以提供有关可以跨越多个编解码器寄存器的控制的信息，这些寄存器共同形成单个带符号的值。请注意，与 sx 控制的非 xr 变体不同，这些可能包含也可能不包含符号位，具体取决于 nbits，并且没有移位。

成功返回 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: 控制元素信息

描述

回调以获取可以跨越多个编解码器寄存器的控制的值，这些寄存器共同形成单个带符号的值。控制支持指定用于允许多个编解码器寄存器中的位域的总位数。请注意，与 sx 控制的非 xr 变体不同，这些可能包含也可能不包含符号位，具体取决于 nbits，并且没有移位。

成功返回 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: 控制元素信息

描述

回调以设置可以跨越多个编解码器寄存器的控制的值，这些寄存器共同形成单个带符号的值。控制支持指定用于允许多个编解码器寄存器中的位域的总位数。请注意，与 sx 控制的非 xr 变体不同，这些可能包含也可能不包含符号位，具体取决于 nbits，并且没有移位。

成功返回 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 关联的小部件

参数

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_get_component_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: 值

描述

回调以提供有关在卡级别添加的引脚开关的信息。

int snd_soc_dapm_put_component_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: 小部件模板

描述

基于模板创建新的 DAPM 控制。

成功时返回小部件指针，失败时返回错误指针

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: 小部件数组
unsigned int num: 小部件数量

描述

基于模板创建新的 DAPM 控制。

成功返回 0，否则返回错误。

int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm, struct snd_soc_dai *dai)¶: 创建新的 DAPM 小部件

参数

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 核心发送流事件。然后，核心进行任何必要的小部件电源更改。

成功返回 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: 引脚名称

描述

如果存在有效的音频路由和活动的音频流，则启用输入/输出引脚及其父级或子级小部件。

需要外部锁定。

注意

在此之后需要调用 snd_soc_dapm_sync()，以便 DAPM 进行任何小部件电源切换。

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: 引脚名称

描述

如果存在有效的音频路由和活动的音频流，则启用输入/输出引脚及其父级或子级小部件。

注意

在此之后需要调用 snd_soc_dapm_sync()，以便 DAPM 进行任何小部件电源切换。

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 进行任何小部件电源切换。

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 进行任何小部件电源切换。

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: 引脚名称

描述

禁用输入/输出引脚及其父级或子级小部件。

需要外部锁定。

注意

在此之后需要调用 snd_soc_dapm_sync()，以便 DAPM 进行任何小部件电源切换。

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: 引脚名称

描述

禁用输入/输出引脚及其父级或子级小部件。

注意

在此之后需要调用 snd_soc_dapm_sync()，以便 DAPM 进行任何小部件电源切换。

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: 引脚名称

描述

将指定的引脚标记为未连接，从而禁用它以及任何父级或子级小部件。目前，这与 snd_soc_dapm_disable_pin() 相同，但在将来它将被扩展以执行其他操作，例如禁用仅影响通过引脚的路径的控件。

需要外部锁定。

注意

在此之后需要调用 snd_soc_dapm_sync()，以便 DAPM 进行任何小部件电源切换。

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: 引脚名称

描述

将指定的引脚标记为未连接，从而禁用它以及任何父级或子级小部件。目前，这与 snd_soc_dapm_disable_pin() 相同，但在将来它将被扩展以执行其他操作，例如禁用仅影响通过引脚的路径的控件。

注意

在此之后需要调用 snd_soc_dapm_sync()，以便 DAPM 进行任何小部件电源切换。

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

返回值

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

插孔抽象层 API¶

enum snd_jack_types¶: 可以报告的插孔类型

常量

SND_JACK_HEADPHONE: 耳机
SND_JACK_MICROPHONE: 麦克风
SND_JACK_HEADSET: 耳机
SND_JACK_LINEOUT: 线路输出
SND_JACK_MECHANICAL: 机械开关
SND_JACK_VIDEOOUT: 视频输出
SND_JACK_AVOUT: AV（音频视频）输出
SND_JACK_LINEIN: 线路输入
SND_JACK_USB: USB 音频设备
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 将附加到的插孔实例
const char * name: snd_kcontrol 对象的名称
int mask: 一个 enum snd_jack_type 值的位掩码，可以由此 snd_jack_kctl 对象检测到。

描述

创建一个新的 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)¶: 创建一个新的插孔

参数

struct snd_card *card: 卡实例
const char *id: 此插孔的标识字符串
int type: 可以由此插孔检测到的 enum snd_jack_type 值的位掩码
struct snd_jack **jjack: 用于向调用方提供已分配的插孔对象。
bool initial_kctl: 如果为 true，则创建一个 kcontrol 并将其添加到插孔列表。
bool phantom_jack: 不要为幻像插孔创建输入设备。

描述

创建一个新的插孔对象。

返回值

如果成功则为零，失败则为负错误代码。如果成功，则将初始化 jjack。

int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type, int keytype)¶: 在插孔上设置键映射

参数

struct snd_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: 当前检测到的 enum snd_jack_type 值的位掩码。
int mask: 正在报告的 enum 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: 引脚数组

描述

调用此函数后，每当更新插孔状态时，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: 要注册的通知程序块

描述

注册以接收插孔当前状态的通知。请注意，无法在通知程序的callback中报告其他插孔事件，这旨在支持仅在发生机械检测事件时才启用电气检测等应用。

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)¶: 等待直到 card power_ref 被释放

参数

struct snd_card *card: 声卡对象

描述

此函数用于与待释放的 power_ref 进行同步。

void snd_card_unref(struct snd_card *card)¶: 取消引用 card 对象

参数

struct snd_card *card: 要取消引用的 card 对象

描述

对通过 snd_card_ref() 或 snd_lookup_minor_data() 获取的 card 对象调用此函数。

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

要分配的单元号

分配一个混音器设备。Unit 是请求的混音器的编号。传递 -1 以请求下一个空闲的混音器单元。

返回值

成功时，返回分配的编号。失败时，: 返回一个负错误代码。

int register_sound_dsp(const struct file_operations *fops, int dev)¶: 注册一个 DSP 设备

参数

const struct file_operations *fops

驱动程序的文件操作

int dev

要分配的单元号

分配一个 DSP 设备。Unit 是请求的 DSP 的编号。传递 -1 以请求下一个空闲的 DSP 单元。

此函数同时分配音频和 dsp 设备条目，并将始终将它们分配为匹配对 - 例如 dsp3/audio3

返回值

成功时，返回分配的编号。失败时，: 返回一个负错误代码。

void unregister_sound_special(int unit)¶: 注销一个特殊的音频设备

参数

int unit

要分配的单元号

释放使用 register_sound_special() 分配的音频设备。传递的 unit 是 register 函数的返回值。

void unregister_sound_mixer(int unit)¶: 注销一个混音器

参数

int unit

要分配的单元号

释放使用 register_sound_mixer() 分配的音频设备。传递的 unit 是 register 函数的返回值。

void unregister_sound_dsp(int unit)¶: 注销一个 DSP 设备

参数

int unit

要分配的单元号

释放使用 register_sound_dsp() 分配的音频设备。传递的 unit 是 register 函数的返回值。

两个分配的单元将自动一起释放。

Linux 内核

目录

本页

ALSA 驱动程序 API¶

卡和设备管理¶

卡管理¶

设备组件¶

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

内存管理助手¶

PCM API¶

PCM 核心¶

PCM 格式助手¶

PCM 内存管理¶

PCM DMA 引擎 API¶

控制/混音器 API¶

通用控制接口¶

AC97 Codec 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¶

插孔抽象层 API¶

ISA DMA 助手¶

其他助手宏¶