1. 为什么嵌入式Linux驱动开发离不开DMA技术
记得我第一次接触嵌入式Linux驱动开发时,总是被数据吞吐性能问题困扰。CPU既要处理网络协议栈,又要搬运大量传感器数据,系统很快就出现瓶颈。直到我开始使用DMA技术,才发现这才是嵌入式系统高速数据处理的"杀手锏"。
DMA(Direct Memory Access)直接内存访问技术,允许外设设备直接与系统内存进行数据传输,完全不需要CPU的参与。想象一下,你的CPU是一个忙碌的工厂经理,而DMA就像一个得力的助手,能够自主处理原材料(数据)的搬运工作,让经理可以专注于更重要的生产调度任务。
在嵌入式Linux系统中,DMA的应用场景非常广泛:网络数据包的高速收发、摄像头图像采集、音频数据流处理、磁盘读写操作等。我做过的一个视频采集项目中,使用DMA后CPU占用率从70%直接降到了15%,而且数据传输速率提升了3倍以上。
2. Linux DMA引擎框架深度解析
2.1 dmaengine框架的核心组成
Linux内核的dmaengine框架为DMA控制器提供了统一的抽象接口,这让驱动开发变得简单多了。框架主要包含几个关键组件:DMA通道(channel)、DMA设备(device)、传输描述符(descriptor)和完成回调机制。
在实际开发中,我通常这样初始化DMA引擎:
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>
static struct dma_chan *dma_channel;
static int init_dma_engine(struct device *dev)
{
dma_cap_mask_t mask;
// 设置DMA能力掩码
dma_cap_zero(mask);
dma_cap_set(DMA_SLAVE, mask);
// 请求DMA通道
dma_channel = dma_request_channel(mask, NULL, dev);
if (!dma_channel) {
dev_err(dev, "Failed to request DMA channel\n");
return -ENODEV;
}
return 0;
}
这里的dma_request_channel函数会根据能力掩码找到合适的DMA通道。我建议在设备树中明确指定DMA通道,这样可以避免资源冲突。
2.2 一致性DMA缓冲区分配
一致性DMA缓冲区(Coherent DMA Buffer)是保证CPU和外设看到相同数据内容的关键。在Linux中,我们使用dma_alloc_coherent来分配这种缓冲区:
#define BUF_SIZE 4096
static void *dma_buffer;
static dma_addr_t dma_handle;
static int alloc_dma_buffer(struct device *dev)
{
dma_buffer = dma_alloc_coherent(dev, BUF_SIZE, &dma_handle, GFP_KERNEL);
if (!dma_buffer) {
dev_err(dev, "Failed to allocate DMA buffer\n");
return -ENOMEM;
}
// 初始化缓冲区
memset(dma_buffer, 0, BUF_SIZE);
return 0;
}
重要提示:一致性缓冲区虽然解决了缓存一致性问题,但性能上会有一定损耗。对于大数据量传输,我更喜欢使用流式DMA映射。
3. 分散/聚集列表(Scatter-Gather)实战应用
3.1 Scatter-Gather的工作原理
Scatter-Gather是DMA技术中的一个高级特性,它允许一次性传输多个非连续的内存块。想象一下,这就像是一个快递员能够一次性地从多个发货点取货,然后统一配送到多个收货点,而不是每个点都单独跑一趟。
在我的网络驱动开发经验中,Scatter-Gather特别有用。网络数据包往往分散在不同的内存缓冲区中,使用SG模式可以极大地提高传输效率。
3.2 实际代码实现
#include <linux/scatterlist.h>
static int setup_scatterlist(struct scatterlist *sg,
void **buffers,
size_t *lengths,
int nents)
{
int i;
sg_init_table(sg, nents);
for (i = 0; i < nents; i++) {
sg_set_buf(&sg[i], buffers[i], lengths[i]);
}
return nents;
}
static int perform_sg_transfer(struct dma_chan *chan,
enum dma_transfer_direction dir,
struct scatterlist *sg,
int nents)
{
struct dma_async_tx_descriptor *desc;
dma_cookie_t cookie;
int ret;
// 准备SG传输
desc = dmaengine_prep_slave_sg(chan, sg, nents, dir, DMA_CTRL_ACK);
if (!desc) {
pr_err("Failed to prepare SG transfer\n");
return -EIO;
}
// 设置完成回调
desc->callback = dma_transfer_complete;
desc->callback_param = chan;
// 提交传输
cookie = dmaengine_submit(desc);
ret = dma_submit_error(cookie);
if (ret) {
pr_err("Failed to submit DMA transaction\n");
return ret;
}
// 启动传输
dma_async_issue_pending(chan);
return 0;
}
在实际项目中,我发现合理设置scatterlist的数目很重要。太少会影响性能,太多则会增加管理开销。一般我建议根据实际数据特征来动态调整。
4. DMA传输完成回调机制详解
4.1 回调函数的设计要点
DMA传输完成回调是异步编程的核心。设计一个好的回调函数需要考虑多个因素:错误处理、资源释放、状态更新等。
这是我常用的回调函数模板:
static void dma_transfer_complete(void *param)
{
struct dma_chan *chan = param;
struct dma_device *dma_dev = chan->device;
enum dma_status status;
// 获取传输状态
status = dma_async_is_tx_complete(chan, cookie, NULL, NULL);
switch (status) {
case DMA_COMPLETE:
// 传输成功处理
handle_successful_transfer();
break;
case DMA_ERROR:
// 传输错误处理
handle_transfer_error();
break;
case DMA_IN_PROGRESS:
// 传输仍在进行中
break;
case DMA_PAUSED:
// 传输暂停
break;
}
// 释放资源或准备下一次传输
prepare_next_transfer();
}
4.2 实际项目中的回调处理
在我最近的一个音频处理项目中,回调函数不仅要处理数据传输状态,还要管理环形缓冲区的读写指针:
static void audio_dma_callback(void *data)
{
struct audio_device *adev = data;
struct dma_tx_state state;
unsigned int residue;
// 获取剩余字节数
dmaengine_tx_status(adev->dma_channel, adev->cookie, &state);
residue = state.residue;
// 更新缓冲区指针
spin_lock(&adev->lock);
adev->bytes_transferred = adev->period_size - residue;
adev->buffer_pos = (adev->buffer_pos + adev->bytes_transferred) % adev->buffer_size;
spin_unlock(&adev->lock);
// 唤醒等待的进程
wake_up_interruptible(&adev->wait_queue);
// 如果需要,重新启动DMA传输
if (adev->streaming)
start_audio_transfer(adev);
}
这种设计确保了音频数据的连续传输,同时提供了精确的缓冲区管理。
5. 缓存一致性问题与解决方案
5.1 缓存一致性问题的根源
缓存一致性问题是DMA编程中最棘手的挑战之一。问题根源在于CPU和DMA控制器看到的内存视图可能不一致:CPU通过缓存访问内存,而DMA直接访问物理内存。
我记得有一次调试了整整两天,发现数据损坏问题就是因为缓存同步没做好。CPU修改了数据,但新数据还留在缓存里没有写回内存,DMA读取到的就是旧数据。
5.2 解决方案与实践
Linux提供了多种缓存一致性管理API:
// 在DMA传输前,确保CPU缓存数据写回内存
void dma_sync_single_for_device(struct device *dev, dma_addr_t addr,
size_t size, enum dma_data_direction dir);
// 在DMA传输后,使CPU缓存失效以确保读取最新数据
void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
size_t size, enum dma_data_direction dir);
// 对于scatterlist的缓存同步
void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
int nents, enum dma_data_direction dir);
void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
int nents, enum dma_data_direction dir);
在我的实践中,总结出了几个最佳实践:
- 明确数据流向:如果是设备到内存的传输,传输前不需要同步,传输后需要使CPU缓存失效
- 如果是内存到设备的传输,传输前需要确保数据写回内存,传输后不需要特殊处理
- 批量处理:尽量避免频繁的缓存同步操作,批量处理数据可以减少性能开销
6. 设备树中的DMA配置详解
6.1 设备树DMA节点配置
现代嵌入式Linux系统都使用设备树来配置硬件资源,DMA也不例外。正确的设备树配置是DMA驱动正常工作的基础。
这是一个典型的使用DMA的设备树节点配置:
&dma_controller {
#dma-cells = <1>;
compatible = "vendor,dma-controller";
reg = <0x48000000 0x1000>;
interrupts = <0 50 4>;
clocks = <&dma_clk>;
status = "okay";
};
&my_device {
compatible = "vendor,my-device";
reg = <0x48100000 0x1000>;
interrupts = <0 51 4>;
dmas = <&dma_controller 0>, /* TX通道 */
<&dma_controller 1>; /* RX通道 */
dma-names = "tx", "rx";
status = "okay";
};
6.2 驱动中的DMA配置解析
在驱动代码中,我们需要解析这些设备树配置:
static int parse_dma_config(struct device *dev)
{
struct dma_slave_config config;
int ret;
// 获取TX DMA通道
my_device->tx_chan = dma_request_slave_channel(dev, "tx");
if (!my_device->tx_chan) {
dev_err(dev, "Failed to request TX DMA channel\n");
return -ENODEV;
}
// 配置DMA从设备参数
memset(&config, 0, sizeof(config));
config.direction = DMA_MEM_TO_DEV;
config.dst_addr = my_device->dma_addr;
config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
config.dst_maxburst = 8;
ret = dmaengine_slave_config(my_device->tx_chan, &config);
if (ret) {
dev_err(dev, "Failed to configure TX DMA: %d\n", ret);
goto err_tx_config;
}
// 类似地配置RX通道...
return 0;
err_tx_config:
dma_release_channel(my_device->tx_chan);
return ret;
}
7. 用户空间与DMA驱动的交互
7.1 字符设备接口设计
让用户空间程序能够使用DMA功能是驱动开发的重要部分。我通常实现一个字符设备接口:
static const struct file_operations dma_fops = {
.owner = THIS_MODULE,
.open = dma_device_open,
.release = dma_device_release,
.read = dma_device_read,
.write = dma_device_write,
.unlocked_ioctl = dma_device_ioctl,
.mmap = dma_device_mmap,
};
static int dma_device_mmap(struct file *filp, struct vm_area_struct *vma)
{
struct dma_device *dev = filp->private_data;
unsigned long size = vma->vm_end - vma->vm_start;
// 将DMA缓冲区映射到用户空间
return dma_mmap_coherent(dev->device, vma, dev->dma_buffer,
dev->dma_handle, size);
}
static long dma_device_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
struct dma_device *dev = filp->private_data;
switch (cmd) {
case DMA_START_TRANSFER:
return start_dma_transfer(dev);
case DMA_STOP_TRANSFER:
return stop_dma_transfer(dev);
case DMA_GET_STATUS:
return get_dma_status(dev, (struct dma_status __user *)arg);
default:
return -ENOTTY;
}
}
7.2 用户空间测试程序
为了方便测试,我通常会写一个简单的用户空间测试程序:
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#define DEVICE_PATH "/dev/dma_device"
#define DMA_START_TRANSFER _IO('D', 1)
#define DMA_STOP_TRANSFER _IO('D', 2)
int main()
{
int fd = open(DEVICE_PATH, O_RDWR);
if (fd < 0) {
perror("Failed to open device");
return -1;
}
// 启动DMA传输
if (ioctl(fd, DMA_START_TRANSFER) < 0) {
perror("Failed to start DMA");
close(fd);
return -1;
}
printf("DMA transfer started\n");
// 等待用户输入后停止
getchar();
// 停止DMA传输
ioctl(fd, DMA_STOP_TRANSFER);
close(fd);
return 0;
}
8. 实战经验:调试DMA驱动的常见陷阱
8.1 内存对齐问题
DMA传输对内存对齐有严格要求。我曾经遇到过一个诡异的问题:数据传输总是错位几个字节。最后发现是缓冲区地址没有按照DMA要求对齐。
解决方案是使用dma_alloc_coherent或者确保自定义缓冲区的对齐:
// 手动对齐缓冲区
#define ALIGNMENT 32
void *buffer = kmalloc(size + ALIGNMENT, GFP_KERNEL);
void *aligned_buffer = (void *)ALIGN((unsigned long)buffer, ALIGNMENT);
// 或者使用内核提供的对齐分配函数
void *aligned_buffer = kmalloc_aligned(size, ALIGNMENT, GFP_KERNEL);
8.2 超时和错误处理
DMA传输可能会因为各种原因超时或失败。健全的错误处理机制很重要:
static int wait_for_dma_completion(struct dma_chan *chan, unsigned long timeout_ms)
{
enum dma_status status;
unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
while (time_before(jiffies, timeout)) {
status = dma_async_is_tx_complete(chan, cookie, NULL, NULL);
if (status == DMA_COMPLETE)
return 0;
if (status == DMA_ERROR) {
pr_err("DMA transfer error\n");
return -EIO;
}
// 短暂休眠避免忙等待
usleep_range(100, 200);
}
pr_err("DMA transfer timeout\n");
return -ETIMEDOUT;
}
8.3 性能优化技巧
经过多个项目的优化,我总结出几个DMA性能优化技巧:
- 使用多描述符环形缓冲区:提前准备多个传输描述符,实现乒乓缓冲
- 合理设置burst大小:根据总线特性和设备能力调整burst参数
- 避免频繁的缓存同步:批量处理数据,减少缓存同步次数
- 使用DMA池:对于小内存块的频繁分配,使用
dma_pool可以提高效率
// 创建DMA内存池
struct dma_pool *pool = dma_pool_create("my_pool", dev,
pool_size, alignment, 0);
// 从池中分配内存
void *buffer = dma_pool_alloc(pool, GFP_KERNEL, &dma_handle);
// 使用后释放
dma_pool_free(pool, buffer, dma_handle);
// 销毁内存池
dma_pool_destroy(pool);
这些实战经验都是我在实际项目中踩过坑后总结出来的。DMA驱动开发确实有门槛,但一旦掌握,就能为嵌入式系统带来显著的性能提升。最重要的是多实践,从简单项目开始,逐步深入理解DMA的各个细节。
417



被折叠的 条评论
为什么被折叠?



