当前位置：首页 > news >正文

Linux DMA 技术深度解析：从原理到实战

news 2025/11/4 8:03:02

Linux DMA 技术深度解析：从原理到实战

1 Linux DMA 技术概述

直接内存访问（Direct Memory Access，DMA）是现代计算机系统中至关重要的数据传输技术，它允许外部设备直接在内存与设备之间传输数据，而无需中央处理器（CPU）的持续参与。在 Linux 操作系统中，DMA 机制不仅能够显著提升系统性能，还能有效降低 CPU 占用率，为高性能计算、网络数据包处理和存储系统等应用场景提供基础支撑。

1.1 DMA 的基本概念与工作原理

DMA 的本质是一种专门用于数据传送的硬件机制，它通过独立的 DMA 控制器（DMAC）在设备和内存之间建立直接的数据通路。当设备需要进行大数据量传输时，传统的编程 I/O（PIO）方式需要 CPU 亲自参与每一个数据的读写操作，这不仅会消耗大量 CPU 周期，还会导致系统整体性能下降。而 DMA 方式则通过"委托"机制，将数据传输任务交给 DMA 控制器完成，解放了 CPU 使其能够继续执行其他计算任务。

从架构角度看，DMA 系统包含三个核心参与方：DMA 控制器、CPU 和外围设备。DMA 控制器作为专门的数据传输协处理器，内部包含地址寄存器、计数寄存器和控制寄存器，能够自主执行内存读写操作。CPU 的角色则转变为 DMA 传输的初始化者和监督者，负责配置 DMA 控制器的参数并在传输完成后接收中断通知。

DMA 传输的基本流程可以分为三个主要阶段：

初始化阶段：CPU 设置 DMA 控制器的相关寄存器，包括源地址、目标地址、传输数据量以及传输方向等参数
数据传输阶段：DMA 控制器接管系统总线，直接在设备和内存之间搬运数据，CPU 可并行执行其他任务
完成通知阶段：当指定数据量传输完成后，DMA 控制器向 CPU 发出中断信号，CPU 进行后续处理

1.2 DMA 在 Linux 中的重要性

在 Linux 系统中，DMA 不仅仅是一种硬件特性，更是整个 I/O 子系统的基础架构要素。Linux 通过精心设计的 DMA 子系统，为设备驱动程序开发者提供了统一且安全的 DMA 操作接口，同时解决了以下关键问题：

平台兼容性：不同架构的处理器和 DMA 控制器硬件差异巨大，Linux DMA 子系统通过抽象层封装这些差异，为驱动开发者提供一致的 API
缓存一致性：由于现代 CPU 存在多级缓存，而 DMA 传输直接访问物理内存，可能导致缓存数据与内存数据不一致的问题，Linux 提供了 DMA 一致性映射接口来解决此问题
内存安全：DMA 使用的内存区域必须是物理上连续的，且不能被系统换出，Linux 通过 DMA 内存分配器保障这些需求
性能优化：支持分散/聚集（Scatter/Gather）DMA 操作，能够将物理上不连续的内存块通过单次 DMA 操作传输，减少中断开销

表：PIO 与 DMA 数据传输方式对比

特性	PIO（编程I/O）	DMA（直接内存访问）
CPU参与度	全程参与每个字节/字的传输	仅初始化和完成时参与
系统性能	CPU被占用，系统吞吐量低	CPU可执行其他任务，系统吞吐量高
适用场景	小数据量、低速设备	大数据量、高速设备
实现复杂度	简单	相对复杂，需要专门控制器
功耗表现	较高，CPU需持续工作	较低，CPU可进入节能状态

在实际应用中，几乎所有高性能 I/O 设备都依赖 DMA 技术。例如，千兆/万兆网络接口卡使用 DMA 将接收到的数据包直接写入内核缓冲区，磁盘控制器使用 DMA 读写文件系统缓存，现代显卡也通过 DMA 传输显存数据。没有 DMA，这些设备的高性能表现将无法实现。

2 Linux DMA 实现机制详解

DMA 在 Linux 中的实现是一个涉及硬件、内核底层和驱动层的复杂系统工程。要深入理解其工作机制，需要从 DMA 地址空间、传输流程以及缓存一致性等多个维度进行分析。

2.1 DMA 地址空间与映射机制

DMA 核心在于设备直接访问内存，但设备视角的内存地址与 CPU 视角的内存地址可能存在差异，这就引入了 DMA 地址空间 的概念。在 x86 等某些架构中，设备与 CPU 共享物理地址空间，DMA 地址就是物理地址。但在其他一些架构如 IA-64、Alpha 中，设备通过 I/O 内存管理单元（IOMMU）访问内存，DMA 地址是 IOMMU 转换后的地址。

Linux 使用 dma_addr_t 类型来表示 DMA 地址，这是一种不透明的数据类型，驱动开发者不应直接操作其内容。为了在 DMA 地址与 CPU 可访问的虚拟地址之间建立映射，Linux 提供了多种 DMA 内存分配接口：

一致性 DMA 映射：这种映射在驱动生命周期内持续有效，且保证缓存一致性。适用于长期使用的 DMA 缓冲区
流式 DMA 映射：这种映射为单次 DMA 传输而创建，传输完成后立即解除映射。适用于短期、一次性的 DMA 传输

一致性 DMA 映射 通过 dma_alloc_coherent() 函数实现，该函数会分配物理上连续的内存区域，并返回该区域对应的内核虚拟地址和 DMA 地址。由于硬件实现的不同，一致性映射可能通过非缓存内存或硬件维护的缓存一致性来实现：

void *dma_vaddr;
dma_addr_t dma_handle;dma_vaddr = dma_alloc_coherent(dev, size, &dma_handle, GFP_KERNEL);
if (!dma_vaddr) {/* 错误处理 */
}
/* 使用 dma_vaddr 和 dma_handle 进行 DMA 操作 */

相比之下，流式 DMA 映射 更为灵活，它可以使用驱动已分配的内存进行映射。Linux 提供了 dma_map_single() 和 dma_unmap_single() 等函数来创建和销毁流式 DMA 映射：

dma_addr_t dma_handle;dma_handle = dma_map_single(dev, buf, size, direction);
if (dma_mapping_error(dev, dma_handle)) {/* 错误处理 */
}
/* 使用 dma_handle 进行 DMA 传输 */
dma_unmap_single(dev, dma_handle, size, direction);

DMA 传输方向由 dma_data_direction 枚举指定，包括 DMA_TO_DEVICE、DMA_FROM_DEVICE 和 DMA_BIDIRECTIONAL 等选项。

2.2 DMA 传输流程与控制器操作

DMA 传输的完整流程涉及多个硬件组件和软件组件的协同工作，包括 CPU、DMA 控制器和设备。以下是一个典型的 DMA 读操作（设备到内存）的详细流程：

驱动准备阶段：设备驱动程序分配 DMA 缓冲区，并进行适当的映射
DMA 配置阶段：驱动程序设置 DMA 控制器的寄存器，包括源地址、目标地址、传输数量等
传输启动阶段：驱动程序启动 DMA 传输，设备开始向 DMA 控制器发送数据请求
数据传输阶段：DMA 控制器在设备和内存之间直接传输数据，CPU 可并行执行其他任务
完成中断阶段：传输完成后，DMA 控制器产生中断，驱动程序进行后续处理

在 Linux 中，DMA 控制器的操作被封装在DMA 引擎框架中。该框架定义了 struct dma_device 作为所有 DMA 控制器的抽象表示，其中包含了 DMA 能力描述和操作函数指针。不同的 DMA 控制器驱动程序通过实现这些操作函数来提供硬件特定的 DMA 功能。

2.3 DMA 缓存一致性问题

缓存一致性是 DMA 中最复杂的问题之一。现代 CPU 使用多级缓存来加速内存访问，而 DMA 传输直接操作物理内存，不经过 CPU 缓存。这可能导致以下问题：

陈旧数据问题：当 CPU 修改了缓存中的数据但尚未写回内存时，如果此时 DMA 从内存读取数据，将得到过时的数据
数据丢失问题：当 DMA 向内存写入新数据，但 CPU 缓存中仍保留旧数据，后续 CPU 读取将得到缓存中的旧数据

为了解决这些问题，Linux 采取了多种策略：

一致性 DMA 映射：使用非缓存内存或通过硬件维护缓存一致性
流式 DMA 映射的缓存维护：在映射和解除映射时，根据传输方向适当刷新缓存

对于流式 DMA 映射，驱动程序必须正确指定数据传输方向，以便内核在适当的时候执行缓存维护操作：

DMA_TO_DEVICE：在 DMA 传输前，将 CPU 写入的数据从缓存刷新到内存
DMA_FROM_DEVICE：在 DMA 传输后，使缓存中相应的数据失效，强制从内存重新读取
DMA_BIDIRECTIONAL：同时执行上述两种操作

在 ARM、PowerPC 等架构中，缓存维护操作是显式进行的，而在 x86 等保持缓存一致性的架构中，这些操作可能是空操作，由平台特定的代码处理这些差异。

3 Linux DMA 核心代码框架

Linux 的 DMA 子系统经过多年发展，已经形成了一套完善且高效的代码框架。该框架既要适应各种硬件平台的差异，又要为设备驱动程序提供简洁统一的编程接口。

3.1 DMA 引擎框架

DMA 引擎框架是 Linux DMA 子系统的核心，它提供了一种标准化的方式来管理和使用系统中的 DMA 控制器。该框架最早针对的是类似 Intel I/O AT 的高性能 DMA 控制器，现已扩展到支持各种嵌入式 DMA 控制器。

DMA 引擎框架的核心数据结构包括：

struct dma_device：代表一个 DMA 控制器或通道集合，包含能力描述和操作函数
struct dma_chan：代表一个 DMA 通道，是 DMA 传输的具体执行单元
struct dma_async_tx_descriptor：描述一个异步 DMA 传输操作
struct dma_slave_config：用于配置从设备 DMA 传输的参数

/* DMA 设备结构示例 */
struct dma_device {const char *name;dma_cap_mask_t cap_mask;  /* 能力掩码 */unsigned short src_addr_widths;  /* 支持的源地址宽度 */unsigned short dst_addr_widths;  /* 支持的目标地址宽度 */int (*device_alloc_chan_resources)(struct dma_chan *chan);void (*device_free_chan_resources)(struct dma_chan *chan);struct dma_async_tx_descriptor *(*device_prep_dma_memcpy)(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,size_t len, unsigned long flags);// ... 其他操作函数
};

DMA 引擎支持多种传输类型，包括内存到内存的复制、分散-聚集（scatter-gather）传输和循环传输等。每种传输类型都通过特定的操作函数实现。

3.2 核心数据结构与 API

Linux DMA 子系统通过一系列精心设计的数据结构和 API 函数，为驱动程序开发者提供了简洁而强大的 DMA 编程接口。理解这些核心数据结构之间的关系对于深入掌握 DMA 编程至关重要。

DMA 通道（struct dma_chan）是 DMA 传输的基本执行单元，每个通道可以独立执行 DMA 操作。系统可能存在多个 DMA 通道，它们通过 DMA 设备（struct dma_device）进行管理。当驱动程序需要执行 DMA 传输时，它首先需要申请一个合适的 DMA 通道，然后配置该通道的参数，最后提交传输描述符到通道的待处理队列中。

表：Linux DMA 核心 API 函数

函数类别	函数名	功能描述
通道管理	`dma_request_channel()`	申请一个 DMA 通道
	`dma_release_channel()`	释放 DMA 通道
内存分配	`dma_alloc_coherent()`	分配一致性 DMA 内存
	`dma_free_coherent()`	释放一致性 DMA 内存
流式映射	`dma_map_single()`	创建单个流式 DMA 映射
	`dma_unmap_single()`	解除单个流式 DMA 映射
	`dma_map_sg()`	创建分散-聚集 DMA 映射
	`dma_unmap_sg()`	解除分散-聚集 DMA 映射
传输控制	`dmaengine_prep_slave_sg()`	准备从设备分散-聚集传输
	`dmaengine_submit()`	提交传输描述符到待处理队列
	`dma_async_issue_pending()`	启动待处理的 DMA 传输

3.3 分散/聚集（Scatter/Gather）DMA

分散/聚集（Scatter/Gather）DMA 是一种高级 DMA 技术，它允许单次 DMA 操作传输多个物理上不连续的内存块。这种技术对于处理网络数据包和文件系统 I/O 特别有用，因为这些场景中的数据通常分散在多个不同的内存缓冲区中。

在传统 DMA 中，如果数据分布在多个不连续的缓冲区，需要多次 DMA 传输或者先将数据复制到连续的临时缓冲区。而分散/聚集 DMA 通过描述符链表的方式，让 DMA 控制器能够自动按顺序访问这些不连续的缓冲区，大大提高了传输效率。

Linux 中使用 struct scatterlist 来描述分散的内存块，并通过 dma_map_sg() 和 dma_unmap_sg() 函数来创建和解除分散/聚集映射：

#include <linux/scatterlist.h>/* 初始化 scatterlist 数组 */
struct scatterlist sg[ENTRIES];
sg_init_table(sg, ENTRIES);/* 将多个缓冲区添加到 scatterlist */
for (i = 0; i < ENTRIES; i++) {sg_set_buf(&sg[i], buffers[i], BUFFER_LEN);
}/* 创建分散/聚集 DMA 映射 */
nents = dma_map_sg(dev, sg, ENTRIES, direction);
if (nents == 0) {/* 错误处理 */
}/* 准备并提交分散/聚集传输 */
desc = dmaengine_prep_slave_sg(chan, sg, nents, direction, flags);
if (!desc) {/* 错误处理 */
}dmaengine_submit(desc);
dma_async_issue_pending(chan);

分散/聚集 DMA 不仅提高了传输效率，还减少了内存复制操作，降低了 CPU 开销。现代网络和存储控制器普遍支持这一特性，使其成为高性能 I/O 处理的基石技术。

4 一个简单 DMA 驱动实例

为了深入理解 Linux DMA 编程的实际应用，本节将构建一个完整的模拟设备 DMA 驱动程序。这个实例虽然基于 Platform 总线模拟设备，但涵盖了 DMA 驱动开发的所有关键环节，包括初始化、通道申请、缓冲区管理、传输控制和中断处理。

4.1 模拟设备与驱动框架

我们首先定义模拟设备的硬件参数和驱动数据结构。这个模拟设备包含一个简单的 DMA 控制器，能够执行内存到设备或设备到内存的数据传输。

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <linux/io.h>/* 模拟设备的寄存器定义 */
#define SIMULATOR_CONTROL_REG    0x00
#define SIMULATOR_STATUS_REG     0x04
#define SIMULATOR_SRC_ADDR_REG   0x08
#define SIMULATOR_DST_ADDR_REG   0x0C
#define SIMULATOR_LENGTH_REG     0x10/* 控制寄存器位定义 */
#define CTRL_START_DMA           BIT(0)
#define CTRL_DIRECTION           BIT(1)  /* 0:内存到设备，1:设备到内存 */
#define CTRL_IRQ_ENABLE          BIT(2)/* 状态寄存器位定义 */
#define STATUS_DONE              BIT(0)
#define STATUS_ERROR             BIT(1)/* 驱动私有数据结构 */
struct simulator_dma_dev {struct device *dev;void __iomem *regs;struct dma_chan *dma_chan;struct completion dma_complete;int irq;
};/* 模拟设备的 DMA 操作函数 */
static int simulator_dma_start(struct simulator_dma_dev *sdev, dma_addr_t src, dma_addr_t dst, size_t len, enum dma_transfer_direction dir)
{u32 ctrl_value = CTRL_IRQ_ENABLE;if (dir == DMA_DEV_TO_MEM) {ctrl_value |= CTRL_DIRECTION;}/* 配置 DMA 源地址、目标地址和长度 */writel(src, sdev->regs + SIMULATOR_SRC_ADDR_REG);writel(dst, sdev->regs + SIMULATOR_DST_ADDR_REG);writel(len, sdev->regs + SIMULATOR_LENGTH_REG);/* 启动 DMA 传输 */ctrl_value |= CTRL_START_DMA;writel(ctrl_value, sdev->regs + SIMULATOR_CONTROL_REG);return 0;
}

4.2 DMA 传输实现

接下来实现完整的 DMA 传输流程，包括缓冲区准备、传输执行和完成回调。我们将实现一个简单的内存到内存的 DMA 传输，这在真实驱动中常用于设备初始化或数据搬移。

/* DMA 完成回调函数 */
static void simulator_dma_complete(void *completion)
{complete(completion);
}/* 执行内存到内存的 DMA 传输 */
static int simulator_do_dma_transfer(struct simulator_dma_dev *sdev,void *src, void *dst, size_t len)
{struct dma_async_tx_descriptor *desc;struct scatterlist sg_src, sg_dst;dma_addr_t dma_src, dma_dst;int ret;/* 映射源缓冲区用于 DMA 读取 */dma_src = dma_map_single(sdev->dev, src, len, DMA_TO_DEVICE);if (dma_mapping_error(sdev->dev, dma_src)) {dev_err(sdev->dev, "Failed to map source buffer\n");return -ENOMEM;}/* 映射目标缓冲区用于 DMA 写入 */dma_dst = dma_map_single(sdev->dev, dst, len, DMA_FROM_DEVICE);if (dma_mapping_error(sdev->dev, dma_dst)) {dev_err(sdev->dev, "Failed to map destination buffer\n");dma_unmap_single(sdev->dev, dma_src, len, DMA_TO_DEVICE);return -ENOMEM;}/* 准备 DMA 传输描述符 */desc = dmaengine_prep_dma_memcpy(sdev->dma_chan, dma_dst, dma_src, len, DMA_PREP_INTERRUPT);if (!desc) {dev_err(sdev->dev, "Failed to prepare DMA descriptor\n");ret = -EIO;goto unmap_buffers;}/* 设置完成回调 */init_completion(&sdev->dma_complete);desc->callback = simulator_dma_complete;desc->callback_param = &sdev->dma_complete;/* 提交 DMA 传输到待处理队列 */dmaengine_submit(desc);dma_async_issue_pending(sdev->dma_chan);/* 等待传输完成 */if (!wait_for_completion_timeout(&sdev->dma_complete, msecs_to_jiffies(1000))) {dev_err(sdev->dev, "DMA transfer timeout\n");ret = -ETIMEDOUT;goto unmap_buffers;}ret = 0;unmap_buffers:dma_unmap_single(sdev->dev, dma_src, len, DMA_TO_DEVICE);dma_unmap_single(sdev->dev, dma_dst, len, DMA_FROM_DEVICE);return ret;
}

4.3 中断处理与资源管理

DMA 传输完成后通常通过中断通知系统，因此我们需要实现中断处理函数，并完善驱动的初始化和清理逻辑。

/* 中断处理函数 */
static irqreturn_t simulator_irq_handler(int irq, void *dev_id)
{struct simulator_dma_dev *sdev = dev_id;u32 status = readl(sdev->regs + SIMULATOR_STATUS_REG);if (status & STATUS_DONE) {/* DMA 传输完成 */complete(&sdev->dma_complete);/* 清除状态位 */writel(status, sdev->regs + SIMULATOR_STATUS_REG);return IRQ_HANDLED;}if (status & STATUS_ERROR) {dev_err(sdev->dev, "DMA transfer error\n");complete(&sdev->dma_complete);writel(status, sdev->regs + SIMULATOR_STATUS_REG);return IRQ_HANDLED;}return IRQ_NONE;
}/* 探测函数 - 驱动初始化 */
static int simulator_dma_probe(struct platform_device *pdev)
{struct simulator_dma_dev *sdev;struct resource *res;int ret;sdev = devm_kzalloc(&pdev->dev, sizeof(*sdev), GFP_KERNEL);if (!sdev)return -ENOMEM;sdev->dev = &pdev->dev;platform_set_drvdata(pdev, sdev);/* 获取 I/O 内存资源 */res = platform_get_resource(pdev, IORESOURCE_MEM, 0);sdev->regs = devm_ioremap_resource(&pdev->dev, res);if (IS_ERR(sdev->regs))return PTR_ERR(sdev->regs);/* 获取中断资源 */sdev->irq = platform_get_irq(pdev, 0);if (sdev->irq < 0)return sdev->irq;/* 申请 DMA 通道 */sdev->dma_chan = dma_request_chan(&pdev->dev, "dma");if (IS_ERR(sdev->dma_chan)) {dev_err(&pdev->dev, "Failed to request DMA channel\n");return PTR_ERR(sdev->dma_chan);}/* 申请中断 */ret = devm_request_irq(&pdev->dev, sdev->irq, simulator_irq_handler,0, dev_name(&pdev->dev), sdev);if (ret) {dev_err(&pdev->dev, "Failed to request IRQ\n");goto release_dma;}init_completion(&sdev->dma_complete);dev_info(&pdev->dev, "Simulator DMA driver initialized\n");return 0;release_dma:dma_release_channel(sdev->dma_chan);return ret;
}/* 移除函数 - 驱动清理 */
static int simulator_dma_remove(struct platform_device *pdev)
{struct simulator_dma_dev *sdev = platform_get_drvdata(pdev);if (sdev->dma_chan)dma_release_channel(sdev->dma_chan);dev_info(&pdev->dev, "Simulator DMA driver removed\n");return 0;
}/* 平台设备定义 */
static const struct of_device_id simulator_dma_of_match[] = {{ .compatible = "example,simulator-dma", },{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, simulator_dma_of_match);static struct platform_driver simulator_dma_driver = {.probe = simulator_dma_probe,.remove = simulator_dma_remove,.driver = {.name = "simulator-dma",.of_match_table = simulator_dma_of_match,},
};module_platform_driver(simulator_dma_driver);MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simulator DMA Driver Example");

这个完整的 DMA 驱动实例展示了 Linux 下 DMA 编程的关键技术点。在实际应用中，驱动开发者需要根据具体硬件特性调整实现细节，但基本框架和流程与此类似。通过这个实例，我们可以清晰地看到 DMA 驱动中各个组件如何协同工作，从初始化、传输执行到最终的资源释放。

5 DMA 核心框架与模型剖析

Linux DMA 子系统经过多年的发展和完善，形成了一套高度抽象且可扩展的架构。深入理解这一架构的核心模型，对于开发高质量 DMA 驱动和进行内核 DMA 子系统开发至关重要。

5.1 DMA 驱动模型

Linux DMA 驱动模型建立在 DMA 引擎框架 之上，该框架提供了一套统一的接口来管理各种类型的 DMA 控制器。这个框架的核心设计思想是将通用的 DMA 操作抽象出来，而将硬件相关的具体实现留给各个驱动去完成。

DMA 设备抽象 通过 struct dma_device 实现，它包含了 DMA 控制器的完整描述：

struct dma_device {const char *name;dma_cap_mask_t cap_mask;  /* 控制器能力位图 */unsigned short src_addr_widths;  /* 支持的源地址宽度 */unsigned short dst_addr_widths;  /* 支持的目标地址宽度 */u32 directions;  /* 支持的传输方向 *//* 通道资源管理 */int (*device_alloc_chan_resources)(struct dma_chan *chan);void (*device_free_chan_resources)(struct dma_chan *chan);/* 传输操作 */struct dma_async_tx_descriptor *(*device_prep_dma_memcpy)(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,size_t len, unsigned long flags);/* 传输控制 */int (*device_issue_pending)(struct dma_chan *chan);enum dma_status (*device_tx_status)(struct dma_chan *chan,dma_cookie_t cookie,struct dma_tx_state *txstate);
};

能力模型 是 DMA 引擎框架的一个重要特性，它通过位掩码标识 DMA 控制器支持的功能。常见的能力标志包括：

DMA_MEMCPY：支持内存到内存的复制
DMA_SLAVE：支持设备到内存或内存到设备的传输
DMA_SG：支持分散-聚集传输
DMA_CYCLIC：支持循环传输（常用于音频、视频应用）

这种能力模型使得应用程序能够根据特定需求选择合适的 DMA 控制器，也使得驱动开发者能够针对控制器硬件特性实现相应功能。

5.2 DMA 传输模型

Linux DMA 子系统支持多种传输模型，每种模型针对不同的应用场景优化。理解这些传输模型的特点和适用场景，对于选择正确的 DMA 使用方式至关重要。

内存到内存传输模型 是最简单的 DMA 传输形式，常用于大数据块搬移。这种模型通常由支持 DMA_MEMCPY 能力的 DMA 控制器实现：

/*** 执行内存到内存的DMA传输* @chan: DMA通道* @dest: 目标缓冲区物理地址* @src: 源缓冲区物理地址  * @len: 传输长度*/
struct dma_async_tx_descriptor *dmaengine_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src, size_t len, unsigned long flags);

从设备传输模型 涉及设备与内存之间的数据传输，需要更精细的控制。这种传输需要配置从设备特定的参数，如地址、突发大小和总线宽度：

/*** 配置从设备DMA传输参数* @chan: DMA通道* @config: 从设备配置参数*/
int dmaengine_slave_config(struct dma_chan *chan,struct dma_slave_config *config);/*** 准备从设备分散-聚集传输* @chan: DMA通道  * @sgl: 分散-聚集列表* @sg_len: 列表长度* @direction: 传输方向* @flags: 控制标志*/
struct dma_async_tx_descriptor *dmaengine_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,unsigned int sg_len, enum dma_transfer_direction direction,unsigned long flags);

循环传输模型 适用于需要连续环形缓冲区传输的场景，如音频播放和采集。在这种模型中，DMA 控制器在到达缓冲区末尾时会自动回到起始位置继续传输：

/*** 准备循环DMA传输* @chan: DMA通道* @buf_addr: 缓冲区物理地址* @buf_len: 缓冲区长度* @period_len: 周期长度（每次中断的传输量）* @direction: 传输方向* @flags: 控制标志*/
struct dma_async_tx_descriptor *dmaengine_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len, size_t period_len,enum dma_transfer_direction direction, unsigned long flags);

5.3 DMA 内存模型

DMA 内存管理是 Linux DMA 子系统中最复杂的部分之一，主要挑战在于确保 DMA 使用的内存满足设备的物理连续性和对齐要求，同时维护缓存一致性。

一致性 DMA 映射 使用 dma_alloc_coherent() 函数分配，这种内存具有以下特性：

物理上连续，适合需要连续物理内存的 DMA 设备
缓存一致性由硬件或非缓存内存保证
分配开销较大，适合长期使用的缓冲区

流式 DMA 映射 适用于短期或一次性的 DMA 传输，可以使用驱动已分配的内存。这种映射方式更加灵活，但需要驱动正确管理缓存一致性：

/* 流式DMA映射的基本使用流程 */
dma_addr_t dma_handle;/* 创建映射 */
dma_handle = dma_map_single(dev, addr, size, direction);
if (dma_mapping_error(dev, dma_handle)) {/* 错误处理 */
}/* 执行DMA传输 */
dma_sync_single_for_device(dev, dma_handle, size, direction);/* 传输完成后解除映射 */
dma_unmap_single(dev, dma_handle, size, direction);

分散-聚集 DMA 映射 是对流式映射的扩展，允许单次 DMA 操作传输多个物理上不连续的缓冲区。这种映射通过 scatterlist 数据结构实现：

/* 分散-聚集DMA映射示例 */
struct scatterlist sg[ENTRIES];
int nents;/* 初始化scatterlist并添加缓冲区 */
sg_init_table(sg, ENTRIES);
for (i = 0; i < ENTRIES; i++) {sg_set_buf(&sg[i], buffers[i], buffer_len);
}/* 创建分散-聚集映射 */
nents = dma_map_sg(dev, sg, ENTRIES, direction);
if (nents == 0) {/* 错误处理 */
}/* 使用映射后的地址进行DMA传输 */
for_each_sg(sg, s, nents, i) {dma_addr_t dma_addr = sg_dma_address(s);unsigned int dma_len = sg_dma_len(s);/* 配置DMA控制器 */
}

表：Linux DMA 内存映射类型对比

特性	一致性映射	流式映射	分散-聚集映射
内存连续性	物理连续	任意	多个不连续缓冲区
缓存一致性	自动保证	需手动维护	需手动维护
使用场景	长期DMA缓冲区	短期单次传输	分散缓冲区IO
性能特点	分配开销大	映射开销小	适合大块分散数据
API函数	`dma_alloc_coherent()`	`dma_map_single()`	`dma_map_sg()`

6 DMA 相关工具与调试手段

开发和使用 DMA 驱动的过程中，掌握有效的工具和调试手段至关重要。Linux 提供了一系列工具和机制来帮助开发者检测 DMA 相关问题、分析性能瓶颈和调试错误。

6.1 用户空间检测工具

在用户空间，我们可以通过多种工具来检测系统的 DMA 使用情况和相关配置。这些工具不需要特殊的内核配置，适合初步的问题诊断和系统状态监控。

proc 文件系统 提供了多个与 DMA 相关的信息接口。最常用的是 /proc/dma 文件，它列出了系统中已注册的 DMA 通道及其使用者：

$ cat /proc/dma4: cascade5: simulator-dma

debugfs 是另一个重要的信息源，特别是对于较新的 DMA 引擎框架。在支持 debugfs 的内核中，可以找到 DMA 引擎的详细信息：

# 挂载debugfs（如果尚未挂载）
$ mount -t debugfs none /sys/kernel/debug# 查看DMA引擎信息
$ cat /sys/kernel/debug/dmaengine/summary
dma0 (foo-dma): #chans=8, #csrs=0Chan #0: foo:17 (busy=0, queued=0)Chan #1: bar:42 (busy=1, queued=3)...

硬件检测工具 如 lspci 和 lsusb 可以帮助识别设备是否支持 DMA，以及支持的 DMA 能力：

# 查看PCI设备的DMA能力
$ lspci -v
00:1f.2 SATA controller: Intel Corporation 82801IBM/IEM (ICH9M/ICH9M-E) 4 port SATA Controller [AHCI mode] (rev 03)Subsystem: Lenovo Device 20f0Flags: bus master, 66MHz, medium devsel, latency 0, IRQ 28I/O ports at 4088 [size=8]I/O ports at 4094 [size=4]I/O ports at 4080 [size=8]I/O ports at 4090 [size=4]I/O ports at 4060 [size=32]Memory at d2520000 (32-bit, non-prefetchable) [size=2K]Capabilities: [80] MSI: Enable+ Count=1/1 Maskable- 64bit-Capabilities: [70] Power Management version 3Capabilities: [a8] SATA HBA v1.0Capabilities: [b0] PCI Advanced FeaturesKernel driver in use: ahci

6.2 内核调试与性能分析

对于更深入的 DMA 问题调试和性能分析，需要借助内核提供的调试机制和性能分析工具。

DMA 调试接口 在内核配置 CONFIG_DMA_API_DEBUG 后可用，它可以检测常见的 DMA API 误用，如未映射的 DMA 访问、重复映射/解除映射等：

# 启用DMA API调试
$ echo 1 > /sys/kernel/debug/dma/api_errors
$ echo 1 > /sys/kernel/debug/dma/transaction_errors# 查看调试信息
$ dmesg | grep -i dma
[  125.366742] dma-debug: DMA-API: device driver tries to free DMA memory it has not allocated [device address=0x00000000c5f4f000] [size=4096 bytes]

DMA 引擎统计信息 可以帮助分析 DMA 控制器的利用率和性能特征：

# 查看DMA通道统计
$ cat /sys/kernel/debug/dmaengine/chan0/stats
transactions: 1250
timeouts: 3
last_transaction: 125 ms ago

动态调试与跟踪 是分析复杂 DMA 问题的有力工具。使用 ftrace 可以跟踪 DMA API 的调用序列：

# 启用DMA相关函数跟踪
$ echo 1 > /sys/kernel/debug/tracing/events/dma/enable
$ cat /sys/kernel/debug/tracing/trace
# tracer: nop
#
#           TASK-PID   CPU#  TIMESTAMP  FUNCTION
#              | |      |       |         |kworker/0:1-125   [000] 125.366742: dma_alloc_coherent: dev=ffff880036a1c000 size=4096 dir=0kworker/0:1-125   [000] 125.366745: dma_map_single: dev=ffff880036a1c000 phys=c5f4f000 size=1024 dir=1

内存损坏检测工具 如 KASAN（Kernel Address SANitizer）可以帮助检测 DMA 内存访问越界等问题：

// 在内核配置中启用CONFIG_KASAN
// 重新编译内核后，KASAN会自动检测内存访问错误// 典型的DMA内存越界访问错误报告
[   12.456789] ==================================================================
[   12.456792] BUG: KASAN: slab-out-of-bounds in dma_transfer+0x123/0x456
[   12.456795] Write of size 4 at addr ffff880036a1c100 by task kworker/0:1/125
[   12.456798] 
[   12.456800] CPU: 0 PID: 125 Comm: kworker/0:1 Tainted: G    B           4.19.0-dbg+
[   12.456802] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.10.2-1ubuntu1 04/01/2014
[   12.456804] Workqueue: events dma_work_handler
[   12.456807] Call Trace:
[   12.456812]  dump_stack+0x8c/0xc8
[   12.456816]  print_address_description+0x73/0x290
[   12.456820]  kasan_report+0x23f/0x360
[   12.456823]  ? dma_transfer+0x123/0x456
[   12.456827]  dma_transfer+0x123/0x456

表：DMA 调试工具与技巧总结

工具/技巧	适用场景	使用方法	输出信息
/proc/dma	查看传统DMA通道使用	`cat /proc/dma`	已注册DMA通道列表
debugfs	查看DMA引擎状态	`cat /sys/kernel/debug/dmaengine/*`	通道状态、统计信息
DMA API调试	检测API误用	启用`CONFIG_DMA_API_DEBUG`	DMA API使用错误
ftrace	跟踪DMA函数调用	启用dma事件跟踪	DMA操作序列和时间
KASAN	检测内存访问错误	启用`CONFIG_KASAN`	内存越界、use-after-free
perf	性能分析	`perf record -g -a`	函数调用热点和瓶颈