05 在 Linux 使用 AXI DMA

ZYNQ跑系统 系列(四) AXI-DMA的linux下运行 AXI-DMA的linux驱动 一、搭建硬件环境 vivado版本2017.4,芯片为7010,不过不管什么版本和芯片大致步骤是一样的 硬件平台PL的搭建同ZYNQ基础系列(六) DMA基本用法,在这个工程的基础上添加SD卡(根据自己的开发板硬件选择相应的引脚) 然后直接生成bit文件,然后记得要导出硬件(包含bit文件)进SDK 二、生成设备树 1.解压设备树工具文件夹到一个地方... 阅读详情
AI摘要

本文详细介绍了在Zynq平台Linux系统中使用AXI DMA进行高效数据传输的完整流程,涵盖DMA原理、AXI DMA IP核架构及三种工作模式(Direct Register、Scatter/Gather、Cyclic)、Vivado工程搭建、Petalinux构建、设备树适配、内核编译,重点解析Linux DMA子系统的驱动框架、地址映射机制(虚拟/物理/总线地址)、DMA掩码设置、一致性缓冲区与流式映射(single/SG类型)、统一DMA API及从设备树配置方法,并给出完整的AXI DMA回环测试驱动实现。

DMA简介

DMA 是一种采用硬件实现存储器与存储器之间或存储器与外设之间直接进行高速数据传输的技术,传输过程无需 CPU 参与(但是CPU需要提前配置传输规则),可以大大减轻 CPU 的负担。
DMA 存储传输的过程如下:

  1. CPU 向 DMA 控制器配置传输规则,如源地址、目的地址、长度、地址是否自增等
  2. DMA 控制器根据配置进行数据搬移,此时 CPU 资源被释放
  3. DMA 数据搬移完成后向 CPU 发送中断

AXI DMA简介

AXI Direct Memory Access(AXI DMA)是 ZYNQ PL端的一个 IP 核,它提供了 CPU 内存(AXI4 内存映射)和 PL 端 AXI4-Stream 之间高速数据传输的功能,如下是 AXI DMA 的框图:
在这里插入图片描述

  • AXI4 Memory Map Read:用于从 DDR3 中读取数据
  • AXI4 Memory Map Write:用于向 DDR3 中写入数据
  • AXI4 Stream Master(MM2S):接口用于向外设写入数据
  • AXI4-Stream Slave(S2MM):接口用于从外设读取数据
  • AXI Control stream (MM2S):是控制流接口,该接口的主要作用是 AXI DMA 对目标设备写入数据时进行节流
  • AXI Stream (S2MM):是一个状态流接口,主要作用是将目标设备的状态传输到 AXI DMA 中的用户应用程序数据字段中
  • AXI Memory Map Write/Read:接口的主要作用是在 S/G 模式下 AXI DMA 与外设进行数据的读写

ADX DMA工作模式

AXI DMA 提供 3 种模式,分别是 Direct Register 模式、Scatter/Gather 模式和 Cyclic DMA(循环 DMA)模式,其中 Direct Register 模式最常用,Scatter/Gather 模式和 Cyclic DMA 模式使用的相对较少

  1. Direct Register DMA 模式 :
    Direct Register DMA 模式也就是 Simple DMA(简单 DMA)。Direct Register 模式提供了一种配置,用于在 MM2S 和 S2MM 通道上执行简单的 DMA 传输,这种传输只需要少量的 FPGA 资源。Simple DMA(简单 DMA)允许应用程序在 DMA 和 Device 之间定义单个事务。它有两个通道:一个从 DMA 到 Device,另一个从 Device 到 DMA。这里有个地方需要大家注意下,在编写 Simple DMA(简单 DMA)代码时必须设置缓冲区地址和长度字段以启动相应通道中的传输。
  2. Scatter/Gather DMA 模式 :
    SGDMA(Scatter/Gather DMA)模式允许在单个 DMA 事务中将数据传输到多个存储区域(相当于将多个 Simple DMA 请求通过事务列表链接在一起)。SGDMA 允许应用程序在内存中定义事务列表,硬件将在应用程序没有进一步干预的情况下处理这些事务,在此期间应用程序可以继续添加更多事务以保持硬件工作,还可以通过轮询或中断来检查事务是否完成。
  3. Cyclic DMA 模式:
    Cyclic DMA(循环 DMA)模式是在 Scatter/Gather 模式下的一种独特工作方式,在 Multichannel Mode 下不可用。正常情况下的 Scatter/Gather 模式在遇到 Tail BD(最后一个事务列表项)就应该结束当前的传输,但是如果使能了 Cyclic 模式的话,在遇到 Tail BD时会忽略 completed 位,并且回到 First BD(第一个事务列表项),这一过程会一直持续直到遇到错误或者人为中止。

VIVADO 工程搭建

使用 Direct Register DMA 模式搭建一个 DMA 回环测试的 VIVADO 工程,Vivado 工程框图如下:
在这里插入图片描述

  1. 添加 ZYNQ IP 核,并进行配置,使能flash接口、AXI GP0、AXI HP0、ENET、SD、DDR、PL中断、PL时钟等,其中AXI GP0、AXI HP0、PL 中断、PL 时钟、PL 中断是为了连接 PL 端的AXI DMA IP 核。
    AXI GP0、AXI HP0配置如下:
    在这里插入图片描述
    PL 时钟配置如下:
    在这里插入图片描述
    PL中断配置如下:
    在这里插入图片描述

  2. 添加 DMA IP 核
    在这里插入图片描述

  3. 配置 DMA IP 核
    在这里插入图片描述

  4. 添加 FIFO IP 核心
    在这里插入图片描述

  5. 连接DMA IP和FIFO IP,将 DMA 的 MM2S 和 S2MM 接口通过一个 AXIS DATA FIFO 构成回环。
    在这里插入图片描述

  6. 点击“Run Block Automation”和“Run Connection Automation”进行自动连线(可能会重复操作多次),在连线过程中会自动添加一些 IP 核。
    在这里插入图片描述

  7. 添加 concat IP 核和 const IP 核
    添加 concat IP:
    在这里插入图片描述
    添加 const IP:
    在这里插入图片描述

  8. 配置 concat IP 核和 const IP 核
    配置 concat IP:
    在这里插入图片描述
    配置 const IP:
    在这里插入图片描述

  9. 链接中断信号
    在这里插入图片描述

  10. 生成代码,然后编译并生成bit文件,最后导出 xsa 文件,导出时必须包含bit流
    在这里插入图片描述

利用 Petalinux 构建根文件系统和 BOOT.BIN

此部分内容参考04 搭建linux驱动开发环境中的利用 Petalinux 构建根文件系统和 BOOT.BIN部分。

获取 Linux 设备树

此部分内容04 搭建linux驱动开发环境中的获取Linux设备树文件部分
可以发现在 pl.dtsi 文件中已经生成了AXI DMA IP核的设备树节点
在这里插入图片描述

编译 Linux 内核

此部分内容04 搭建linux驱动开发环境中的编译Linux内核部分。

Linux 中使用 DMA的要点

DMA驱动框架

DMA驱动框架可分为三层:
DMA slave驱动:使用DMA设备的驱动程序,如SPI控制器驱动、UART控制器驱动等
DMA核心:提供统一的编程接口,管理DMA slave驱动和DMA控制器驱动
DMA控制器驱动:驱动DMA控制器
在Linux系统中DMA核心已经包含在系统中,DMA控制器驱动一般有芯片厂家提供,普通开发人员一般只要掌握DMA slave驱动开发即可
在这里插入图片描述

DMA 区域

部分SOC的DMA只能访问特定的一段内存空间,而非整个内存空间,所以在使用kmalloc()、__get_free_pages()等类似函数申请可能用于DMA缓冲区的内存时需要在申请标志中增加GFP_DMA标志,此外系统也通过了一些快捷接口,如__get_dma_pages()、dma_mem_alloc()等。
提示
大多数嵌入式SOC其DMA都可以访问整个常规内存空间。

虚拟地址、物理地址、总线地址

虚拟地址:CPU所使用的地址就是虚拟地址(站在CPU角度来看)。
物理地址:站在MMU角度来看,即DRAM空间向MMU呈现出来的地址,它可通过MMU转换为虚拟地址。
总线地址:站在设备的角度来看,即DRAM空间向设备呈现出来的地址,部分SOC带有IOMMU,还可以对总线地址进行映射后在呈现给设备。
在这里插入图片描述

DMA地址掩码

部分SOC的DMA只能访问特定的一段内存空间(如系统总线32bit地址,而DMA只能访问低24bit地址,在这种情况下,外设在发起DMA操作的时候就只能访问16M以下的系统物理内存),因此需要设置DMA mask,以指示DMA能访问的地址空间,如DMA只能访问低24位地址则需要执行dma_set_mask(dev, DMA_BIT_MASK(24))和dev.coherent_dma_mask = DMA_BIT_MASK(24)操作,dma_set_mask(dev, DMA_BIT_MASK(24))设置的是DMA流式映射的寻址范围,dev.coherent_dma_mask = DMA_BIT_MASK(24)设置一致性 DMA 缓冲区的寻址范围,或者使用int dma_set_mask_and_coherent(dev, DMA_BIT_MASK(24))一次完成这两部操作。

一致性DMA缓冲区

一致性DMA缓冲区即DMA和CPU可以一致访问的缓冲区,不需要考虑cache的影响,一般通过关闭cache实现(部分SOC的DMA也支持从通过cache访问内存),一致性缓冲区分别使用如下函数申请或释放:

//分配一致性缓冲区
void *dmam_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t gfp)
void *dma_alloc_wc(struct device *dev, size_t size, dma_addr_t *dma_addr, gfp_t gfp)
//释放一致性缓冲区
void dmam_free_coherent(struct device *dev, size_t size, void *vaddr, dma_addr_t dma_handle)
void dma_free_wc(struct device *dev, size_t size, void *cpu_addr, dma_addr_t dma_addr)

single类型流式映射

有时候需要通过DMA传输的内存并非由DMA分配,针对这种情况可以采用流式映射,若来自其他驱动的是一个连续的内存区域可以使用如下函数进行映射和取消映射:

//映射
dma_addr_t dma_map_single(struct device *dev, void *ptr, size_t size, enum dma_data_direction dir)
//取消映射
void dma_unmap_single((struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir)

被映射后的内存在取消映射前原则上CPU不能访问,若CPU实在需要访问需要先申请拥有权,访问完后在释放拥有权:

//申请CPU拥有权
void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir)
//释放CPU拥有权
void dma_sync_single_for_device(struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir)

SG类型流式映射

若来自其他驱动的内存区域在物理上是不连续的则需要进行分段映射,可以使用如下函数进行映射和取消映射:

//映射
#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, 0)
int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction dir, unsigned long attrs)
//取消映射
#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, 0)
void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction dir, unsigned long attrs)

同样对于被映射后的内存在取消映射前原则上CPU不能访问,若CPU实在需要访问需要先申请拥有权,访问完后在释放拥有权:

//申请CPU拥有权
void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,  int nelems, enum dma_data_direction dir)
//释放CPU拥有权
void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems, enum dma_data_direction dir)

此外对于struct scatterlist还有如下常用宏和函数

//获取总线地址成员,可用于设置或读取总线地址
#define sg_dma_address(sg)
//获取长度成员,可用于设置或读取长度
#define sg_dma_len(sg)
//设置buf,它会获取buf的页地址和偏移,并将页地址、偏移、长度设置到struct scatterlist中
void sg_set_buf(struct scatterlist *sg, const void *buf, unsigned int buflen)
//获取buf的物理地址,这里的dma_addr_t返回的是物理地址,而非总线地址
dma_addr_t sg_phys(struct scatterlist *sg)
//获取buf的虚拟地址
void *sg_virt(struct scatterlist *sg)
//初始化SG列表,此函数不会设置buf
void sg_init_table(struct scatterlist *, unsigned int);
//初始化单个sg,并设置buf
void sg_init_one(struct scatterlist *, const void *, unsigned int);

DMA统一操作接口

DMA驱动框架提供了一套标准的DMA操作接口,常用的如下:

//申请DMA通道
struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name)
struct dma_chan *dma_request_chan(struct device *dev, const char *name)
//释放DMA通道
void dma_release_channel(struct dma_chan *chan)
//配置DMA通道
int dmaengine_slave_config(struct dma_chan *chan, struct dma_slave_config *config)
//基于总线地址创建一个描述符
struct dma_async_tx_descriptor *dmaengine_prep_slave_single(struct dma_chan *chan, dma_addr_t buf, size_t len, enum dma_transfer_direction dir, unsigned long flags)
//基于struct scatterlist创建一个描述符
struct dma_async_tx_descriptor *dmaengine_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,	unsigned int sg_len, enum dma_transfer_direction dir, unsigned long 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 dir, unsigned long flags)
//创建一个用于设置内存值的描述符
struct dma_async_tx_descriptor *dmaengine_prep_dma_memset(struct dma_chan *chan, dma_addr_t dest, int value, size_t len, unsigned long flags)
//创建一个用于内存拷贝的描述符
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)
//提交描述符,在提交描述符前一般还需要设置描述符的callback和callback_param参数,以便描述符传输完后进行通知和获取处理结果,此外该函数的返回值还应采用dma_submit_error函数检查是否出差
dma_cookie_t dmaengine_submit(struct dma_async_tx_descriptor *desc)
//启动提交的描述符,开始进行传输
void dma_async_issue_pending(struct dma_chan *chan)
//获取传输结果
enum dma_status dma_async_is_tx_complete(struct dma_chan *chan, dma_cookie_t cookie, dma_cookie_t *last, dma_cookie_t *used)
//struct dma_slave_config结构体
struct dma_slave_config {
	//传输的方向,DMA_MEM_TO_MEM:memory到memory的传输, DMA_MEM_TO_DEV:memory到设备的传输,DMA_DEV_TO_MEM:设备到memory的传输,DMA_DEV_TO_DEV:设备到设备的传输
	enum dma_transfer_direction direction;
	//传输方向是DMA_DEV_TO_MEM或DMA_DEV_TO_DEV时,读取数据的位置
	phys_addr_t src_addr;
	//传输方向是DMA_MEM_TO_DEV或DMA_DEV_TO_DEV时,写入数据的位置
	phys_addr_t dst_addr;
	//src地址的宽度,包括1、2、3、4、8、16、32、64(bytes)等
	enum dma_slave_buswidth src_addr_width;
	//dst地址的宽度,包括1、2、3、4、8、16、32、64(bytes)等
	enum dma_slave_buswidth dst_addr_width;
	//src最大可传输的突发长度
	u32 src_maxburst;
	//dst最大可传输的突发长度
	u32 dst_maxburst;
	//当外设是Flow Controller(流控制器)的时候,需要将该字段设置为true
	bool device_fc;
	//外部设备通过slave_id告诉dma controller自己是谁,很多dma controller不区分slave,只要给它src、dst、len等信息,它就可以进行传输,因此slave_id可以忽略,有些dma controller必须清晰地知道此次传输的对象是哪个外设,就必须要提供slave_id
	unsigned int slave_id;
};

DMA 从设备驱动设备树

使用DMA设备时只需要在设备树节点中增加如下属性即可:

//引用DMA节点,并传入参数指定使用哪一个通道(参数的具体值和个数依据DMA驱动决定)
dmas = <&axi_dma_0 0
        &axi_dma_0 1>;
//dma名称,与上面的dmas一一对应,申请dma通道时就是dma-names作为参数
dma-names ="axidma0", "axidma1";

编写AXI DMA回环测试驱动

DMA 驱动编写流程

  1. 申请DMA通道
  2. 配置DMA通道(部分专用DMA不需要进行配置)
  3. 分配DMA内存(对来自其他驱动模块的内存则进行映射操作)
  4. 创建描述符,并绑定传输完成回调函数
  5. 提交描述符
  6. 启动DMA传输
  7. 等待传输完成
  8. 检查传输结果
  9. 释放前面分配的DMA内存
  10. 释放DMA通道

设备树编写

在system-user.dtsi增的根节点中增加如下节点:

	axi_dma_test0: dma_test@0{
		compatible = "axi_dma_test";		/* 用于设备树与驱动进行匹配 */
		status = "okay";					/* 状态 */
		dmas = <&axi_dma_0 0				/* mm2s-channel*/
				&axi_dma_0 1>;				/* s2mm-channel */
		dma-names ="axidma0", "axidma1";	/* DMA名称,与dmas对应 */
	};

驱动代码编写

此驱动采用内核线程进行DMA回环测试,DMA相关操作均放在内核线程中实现(申请和释放dma通道除外)。

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/miscdevice.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/kthread.h>
#include <linux/idr.h>
#include <linux/delay.h>
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>

#define DMA_TEST_TASK_MAX		8

#define DMA_TEST_BUFFER_COUNT	1		//一次传输测试的SG数量,vavido中未使能描述符模式,所以只能是1
#define DMA_TEST_BUFFER_SIZE	512		//每个SG缓冲区大小,不能超过vivado中用于回环的AXI DATA FIFO的大小

#define DMA_TEST_COUNT			10		//测试次数

struct dma_test_handle {
	struct task_struct *kthread;
	uint32_t number;
	struct dma_chan *mm2s_chan;
	struct dma_chan *s2mm_chan;
	uint32_t thread_done;
};

static DEFINE_IDA(task_number_ida);


static void mm2s_chan_callback(void *completion)
{
	complete((struct completion*)completion);
}

static void s2mm_chan_callback(void *completion)
{
	complete((struct completion*)completion);
}

static int dma_test_thread(void *arg)
{
	int loop_count;
	int buffer_index;
	int test_count;
	enum dma_status status;
	uint8_t *ptr_mm2s[DMA_TEST_BUFFER_COUNT];
	uint8_t *ptr_s2mm[DMA_TEST_BUFFER_COUNT];
	struct scatterlist mm2s_sg[DMA_TEST_BUFFER_COUNT];
	struct scatterlist s2mm_sg[DMA_TEST_BUFFER_COUNT];
	struct dma_async_tx_descriptor *mm2s_des;
	struct dma_async_tx_descriptor *s2mm_des;
	struct completion mm2s_cmp;
	struct completion s2mm_cmp;
	dma_cookie_t mm2s_cookie;
	dma_cookie_t s2mm_cookie;
	struct dma_test_handle *dma_test_handle = (struct dma_test_handle*)arg;

	printk("start axi_dma_test, task number = %d\r\n", dma_test_handle->number);
	
	//分配源内存,mm2s
	memset(ptr_mm2s, 0, sizeof(ptr_mm2s));
	for(loop_count = 0; loop_count < DMA_TEST_BUFFER_COUNT; loop_count++)
	{
		ptr_mm2s[loop_count] = kmalloc(DMA_TEST_BUFFER_SIZE, GFP_KERNEL|GFP_DMA);
		if (!ptr_mm2s[loop_count])
			goto MM2S_ALLOC_ERROR;
	}
	//分配目的内存,s2mm
	memset(ptr_s2mm, 0, sizeof(ptr_s2mm));
	for(loop_count = 0; loop_count < DMA_TEST_BUFFER_COUNT; loop_count++)
	{
		ptr_s2mm[loop_count] = kmalloc(DMA_TEST_BUFFER_SIZE, GFP_KERNEL|GFP_DMA);
		if (!ptr_s2mm[loop_count])
			goto S2MM_ALLOC_ERROR;
	}
	
	//初始化完成量
	init_completion(&mm2s_cmp);
	init_completion(&s2mm_cmp);
	
	test_count = 0;
	while(!kthread_should_stop() && (test_count < DMA_TEST_COUNT))
	{
		//填充待发送的数据
		for(loop_count = 0; loop_count < DMA_TEST_BUFFER_COUNT; loop_count++)
		{
			for(buffer_index = 0; buffer_index < DMA_TEST_BUFFER_SIZE; buffer_index++)
			{
				ptr_mm2s[loop_count][buffer_index] = (uint8_t)(loop_count + buffer_index + test_count);
			}
		}
		//复位目的数据
		for(loop_count = 0; loop_count < DMA_TEST_BUFFER_COUNT; loop_count++)
		{
			memset(ptr_s2mm[loop_count], 0, DMA_TEST_BUFFER_SIZE);
		}
		
		//初始化分散聚集映射描述符
		sg_init_table(mm2s_sg, DMA_TEST_BUFFER_COUNT);
		sg_init_table(s2mm_sg, DMA_TEST_BUFFER_COUNT);
		for(loop_count = 0; loop_count < DMA_TEST_BUFFER_COUNT; loop_count++)
		{
			sg_set_buf(&mm2s_sg[loop_count], ptr_mm2s[loop_count], DMA_TEST_BUFFER_SIZE);
			sg_set_buf(&s2mm_sg[loop_count], ptr_s2mm[loop_count], DMA_TEST_BUFFER_SIZE);
		}
		
		//进行分散聚集映射
		if(dma_map_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE) == 0)
		{
			printk("map mm2s_sg faled\r\n");
			break;
		}
		if(dma_map_sg(dma_test_handle->s2mm_chan->device->dev, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_FROM_DEVICE) == 0)
		{
			dma_unmap_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE);
			printk("map s2mm_sg faled\r\n");
			break;
		}
		
		//创建DMA传输描述符
		mm2s_des = dmaengine_prep_slave_sg(dma_test_handle->mm2s_chan, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_MEM_TO_DEV, DMA_CTRL_ACK | DMA_PREP_INTERRUPT);
		if(!mm2s_des)
		{
			dma_unmap_sg(dma_test_handle->s2mm_chan->device->dev, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_FROM_DEVICE);
			dma_unmap_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE);
			printk("create mm2s_des faled\r\n");
			break;
		}
		s2mm_des = dmaengine_prep_slave_sg(dma_test_handle->s2mm_chan, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_DEV_TO_MEM, DMA_CTRL_ACK | DMA_PREP_INTERRUPT);
		if(!s2mm_des)
		{
			dma_unmap_sg(dma_test_handle->s2mm_chan->device->dev, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_FROM_DEVICE);
			dma_unmap_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE);
			printk("create s2mm_des faled\r\n");
			break;
		}
		
		//绑定传输完成回调函数
		reinit_completion(&mm2s_cmp);
		mm2s_des->callback = mm2s_chan_callback;
		mm2s_des->callback_param = &mm2s_cmp;
		reinit_completion(&s2mm_cmp);
		s2mm_des->callback = s2mm_chan_callback;
		s2mm_des->callback_param = &s2mm_cmp;
		
		//提交描述符
		mm2s_cookie = dmaengine_submit(mm2s_des);
		if(dma_submit_error(mm2s_cookie))
		{
			dma_unmap_sg(dma_test_handle->s2mm_chan->device->dev, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_FROM_DEVICE);
			dma_unmap_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE);
			printk("submit mm2s_des faled\r\n");
			break;
		}
		s2mm_cookie = dmaengine_submit(s2mm_des);
		if(dma_submit_error(s2mm_cookie))
		{
			dma_unmap_sg(dma_test_handle->s2mm_chan->device->dev, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_FROM_DEVICE);
			dma_unmap_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE);
			printk("submit s2mm_des faled\r\n");
			break;
		}
		
		//启动传输
		dma_async_issue_pending(dma_test_handle->mm2s_chan);
		dma_async_issue_pending(dma_test_handle->s2mm_chan);
		
		//等待传输完成
		if(wait_for_completion_timeout(&mm2s_cmp, msecs_to_jiffies(300000)) == 0)
		{
			dma_unmap_sg(dma_test_handle->s2mm_chan->device->dev, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_FROM_DEVICE);
			dma_unmap_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE);
			printk("mm2s transfer timeout\r\n");
			break;
		}
		if(wait_for_completion_timeout(&s2mm_cmp, msecs_to_jiffies(300000)) == 0)
		{
			dma_unmap_sg(dma_test_handle->s2mm_chan->device->dev, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_FROM_DEVICE);
			dma_unmap_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE);
			printk("s2mm transfer timeout\r\n");
			break;
		}
		
		//获取传输结果
		status = dma_async_is_tx_complete(dma_test_handle->mm2s_chan, mm2s_cookie, NULL, NULL);
		if(status != DMA_COMPLETE)
		{
			dma_unmap_sg(dma_test_handle->s2mm_chan->device->dev, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_FROM_DEVICE);
			dma_unmap_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE);
			printk("mm2s transfer error\r\n");
			break;
		}
		status = dma_async_is_tx_complete(dma_test_handle->s2mm_chan, s2mm_cookie, NULL, NULL);
		if(status != DMA_COMPLETE)
		{
			dma_unmap_sg(dma_test_handle->s2mm_chan->device->dev, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_FROM_DEVICE);
			dma_unmap_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE);
			printk("s2mm transfer error\r\n");
			break;
		}
		
		//取消映射
		dma_unmap_sg(dma_test_handle->s2mm_chan->device->dev, s2mm_sg, DMA_TEST_BUFFER_COUNT, DMA_FROM_DEVICE);
		dma_unmap_sg(dma_test_handle->mm2s_chan->device->dev, mm2s_sg, DMA_TEST_BUFFER_COUNT, DMA_TO_DEVICE);
		
		//验证传输结果
		for(loop_count = 0; loop_count < DMA_TEST_BUFFER_COUNT; loop_count++)
		{
			for(buffer_index = 0; buffer_index < DMA_TEST_BUFFER_SIZE; buffer_index++)
			{
				if(ptr_mm2s[loop_count][buffer_index] != ptr_s2mm[loop_count][buffer_index])
				{
					printk("verifying failed!!!\r\n");
					printk("mm2s[%d][%d] = %d, s2mm[%d][%d] = %d\r\n", 
						loop_count, buffer_index, ptr_mm2s[loop_count][buffer_index],
						loop_count, buffer_index, ptr_s2mm[loop_count][buffer_index]);
					break;
				}
			}
			if(buffer_index < DMA_TEST_BUFFER_SIZE)
				break;
		}
		if((loop_count < DMA_TEST_BUFFER_COUNT) || (buffer_index < DMA_TEST_BUFFER_SIZE))
			break;
		
		printk("%d.DMA test success\r\n", test_count);
		
		//测试技术递增
		test_count++;
	}
	
	//停止通道上的所有传输事件
	dmaengine_terminate_all(dma_test_handle->mm2s_chan);
	dmaengine_terminate_all(dma_test_handle->s2mm_chan);
	
S2MM_ALLOC_ERROR:
	for(loop_count = 0; loop_count < DMA_TEST_BUFFER_COUNT; loop_count++)
	{
		if(ptr_s2mm[loop_count])
			kfree(ptr_s2mm[loop_count]);
	}
MM2S_ALLOC_ERROR:
	for(loop_count = 0; loop_count < DMA_TEST_BUFFER_COUNT; loop_count++)
	{
		if(ptr_mm2s[loop_count])
			kfree(ptr_mm2s[loop_count]);
	}
	
	dma_test_handle->thread_done = 1;
	
	return 0;
}

//设备和驱动匹配成功执行
static int dma_test_probe(struct platform_device *pdev)
{
	int result;
	struct dma_test_handle *dma_test_handle;
	
	printk("%s probe\r\n", pdev->name);
	
	//分配设备句柄
	dma_test_handle = devm_kzalloc(&pdev->dev, sizeof(struct dma_test_handle), GFP_KERNEL);
	if(!dma_test_handle)
	{
		printk("alloc memory failed\r\n");
		return -ENOMEM;
	}
	//复位LED设备句柄
	memset(dma_test_handle, 0, sizeof(struct dma_test_handle));
	
	//分配一个编号,用于标识测试任务
	dma_test_handle->number = ida_simple_get(&task_number_ida, 0, DMA_TEST_TASK_MAX, GFP_KERNEL);
	if(dma_test_handle->number < 0)
	{
		printk("get number failed\r\n");
		return dma_test_handle->number;
	}
	
	//请求DMA通道
	dma_test_handle->mm2s_chan = dma_request_chan(&pdev->dev, "axidma0");
	if(IS_ERR(dma_test_handle->mm2s_chan)) 
	{
		ida_simple_remove(&task_number_ida, dma_test_handle->number);
		result = IS_ERR(dma_test_handle->mm2s_chan);
		printk("xilinx_dmatest: No Tx channel\n");
	}
	dma_test_handle->s2mm_chan = dma_request_chan(&pdev->dev, "axidma1");
	if(IS_ERR(dma_test_handle->s2mm_chan)) 
	{
		dma_release_channel(dma_test_handle->mm2s_chan);
		ida_simple_remove(&task_number_ida, dma_test_handle->number);
		result = IS_ERR(dma_test_handle->s2mm_chan);
		printk("xilinx_dmatest: No Rx channel\n");
	}
	
	//线程主动退出标志
	dma_test_handle->thread_done = 0;
	
	//创建内核线程
	dma_test_handle->kthread = kthread_create(dma_test_thread, dma_test_handle, "dma_test_thread%d", dma_test_handle->number);
	if(IS_ERR(dma_test_handle->kthread))
	{
		dma_release_channel(dma_test_handle->s2mm_chan);
		dma_release_channel(dma_test_handle->mm2s_chan);
		ida_simple_remove(&task_number_ida, dma_test_handle->number);
		printk("create dma_test_thread failed\r\n");
		return IS_ERR(dma_test_handle->kthread);
	}
	//启动内核线程
	wake_up_process(dma_test_handle->kthread);
	
	//设置平台设备的驱动私有数据
	pdev->dev.driver_data = (void*)dma_test_handle;
	
	return 0;
}

//设备或驱动卸载时执行
static int dma_test_remove(struct platform_device *pdev)
{
	struct dma_test_handle *dma_test_handle;
	
	printk("%s remove\r\n", pdev->name);
	
	//提取平台设备的驱动私有数据
	dma_test_handle = (struct dma_test_handle*)pdev->dev.driver_data;
	
	//停止内核线程
	if(dma_test_handle->thread_done == 0)
		kthread_stop(dma_test_handle->kthread);
	
	//释放DMA通道
	dma_release_channel(dma_test_handle->s2mm_chan);
	dma_release_channel(dma_test_handle->mm2s_chan);
	
	//释放测试任务编号
	ida_simple_remove(&task_number_ida, dma_test_handle->number);
	
	return 0;
}

//系统关机前执行
static void dma_test_shutdown(struct platform_device *pdev)
{
	printk("%s shutdown\r\n", pdev->name);
}

//系统进入睡眠状态之前执行
static int dma_test_suspend(struct platform_device *pdev, pm_message_t state)
{
	printk("%s suspend\r\n", pdev->name);
	return 0;
}

//系统从睡眠状态中唤醒系统后执行
static int dma_test_resume(struct platform_device *pdev)
{
	printk("%s resume\r\n", pdev->name);
	return 0;
}

//匹配列表,用于设备树和平台驱动匹配
static const struct of_device_id dma_test_of_match[] = {
	{ .compatible = "axi_dma_test" },
	{ /* Sentinel */ }
};
//平台驱动
struct platform_driver dma_test_drv = {
	.driver = {
		.name = "axi_dma_test",				//平台驱动名称
		.owner = THIS_MODULE,
		.pm = NULL,
		.of_match_table = dma_test_of_match,
	},
	.probe = dma_test_probe,				//设备和驱动匹配成功执行
	.remove = dma_test_remove,				//设备或驱动卸载时执行
	.shutdown = dma_test_shutdown,			//系统关机前执行
	.suspend = dma_test_suspend,			//系统休眠前执行
	.resume = dma_test_resume,				//系统唤醒后执行
};

static int __init plt_drv_init(void)
{
	int result;

	printk("%s\r\n", __FUNCTION__);

	//注册平台驱动
	result = platform_driver_register(&dma_test_drv);
	if(result < 0)
	{
		printk("add cdev failed\r\n");
		return result;
	}

	return 0;
}

static void __exit plt_drv_exit(void)
{
	printk("%s\r\n", __FUNCTION__);

	//注销平台驱动
	platform_driver_unregister(&dma_test_drv);
}

module_init(plt_drv_init);
module_exit(plt_drv_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("csdn");
MODULE_DESCRIPTION("dma_test_dev");
axi-dma的使用方式 xilinx官网axi-dma介绍 一、认识axi-dma的接口 先来认识下 AXI DMA 模块 此模块用到了三种总线, AXI4-Lite 用于对寄存器进行配置, AXI4 Memory Map 用于与内存交互,在此模块中又分立出了 AXI4 Memory Map Read 和 AXI4 Memory Map Write 两个接口,又分别叫做 M_AXI_MM2S 和 M_AXI_S2MM,一个是读一个是写,这里要搞清楚,不能混淆。 AXI4 Stream 接口用于对外设的读写,其中 AXI4 Str 阅读详情

相关推荐

zynq 使用AXI_dma 传输==pl到ps,linux驱动开发,应用层处理DMA数据(一)

zynq axi_dma pl到ps数据传输 axi_dma驱动 linux应用层使用dma

ZYH10140的博客 9414

AXI-DMA

AXI-DMA相关简介

做有挑战的事 8860

Zynq UltraScale+高速数据采集:FPGA-Linux-ARM64 DMA框架解析

高速数据采集是软件无线电、图像传感、雷达回波等领域的核心需求,其关键挑战在于如何把ADC采样数据稳定、无损地搬入ARM64内存。FPGA负责时序确定性与并行处理,Linux提供生态与协议栈,ARM64则提供大内存与多核调度,三者通过DMA通道协同,才能解决中断过载、地址映射、缓存一致性等工程难题。零拷贝与环形缓冲设计可有效提升吞吐,降低CPU占用。本文基于Zynq UltraScale+平台,梳理一套FPGA-Linux-ARM64一体化DMA搬运框架,涵盖AXI DMA链路、驱动落地、用户态映射及调优实战

weixin_34216196的博客 370

AXI DMA简介

  DMA(Direct Memory Access)是直接内存访问,指不依赖CPU,完成数据搬运。一般运用在嵌入式软件开发,FPGA中一般不用。   DMAC是PS端的集成硬核,AXI DMA是PL端的软核。   DMA为内存和AXI4-Stream外设之间提供了高带宽的直接内存访问。其可选的S/G功能可以直接将CPU从数据搬运任务重解放出来。   AXI DMA通过AXI4-Lite接口对寄存器做一些配置和获取状态。   MM2S:MemoryMap to Stream 存储器映射(AXI4-Full)

q1594的博客 4632

将 AXI 设计拆分到两片FPGA

本文介绍了如何利用Veloce Prototyping System将包含AXI总线和PCIe接口的设计拆分到两片FPGA上实现。文章详细讲解了从Vivado Block Design构建、OOC综合、多FPGA设计分割与编译到Linux驱动验证的完整流程。核心内容包括:1)设计分割原理,将PCIe/XDMA模块与用户逻辑分别部署在两片FPGA;2)通过proFPGA的板间高速互连实现AXI信号传输;3)使用red工具链实现自动分割和编译。

Hi20240217的博客 365

避开这些坑!Microblaze跑Linux的硬件设计清单与验证要点(以AXI EthernetLite为例)

本文详细解析了在Microblaze软核上运行Linux时的硬件设计陷阱与验证要点,特别以AXI EthernetLite为例,揭示了时钟架构、内存子系统、网络接口等关键环节的常见错误。通过实战案例和具体配置建议,帮助FPGA工程师避开硬件设计缺陷导致的系统崩溃、网络丢包等问题,提升Linux移植成功率。

weixin_42527401的博客 404

Zynq7000 1.Linux平台AXI-DMA

本文中所使用的实验环境说明:VMware虚拟机,ubuntu16.04版本的linux系统,Xilinx SDK2017.4(文中用到了它的编译器),Petalinux2019.1(可以选装黑金的2017.4版本,笔者这里安装错了版本也就没有卸载重装)。 目录: 1.下载参考工程的axi_dma模块文件包,下载链接——https://github.com/bperez77/xilinx_axidma/tree/master 1.建立petalinux工程 2.配置Linux内核 3.修改设备树文件 4.修改

LV_LEOlanj的博客 734

告别迷茫!手把手用Vivado配置Xilinx 7系列PCIE XDMA IP核(含AXI4接口详解)

本文详细介绍了如何在Vivado中配置Xilinx 7系列FPGA的PCIE XDMA IP核,重点解析AXI4接口的优化配置与实战应用。通过具体案例演示物理层参数设置、DMA接口配置及中断机制,帮助开发者解决高速数据传输中的常见问题,提升FPGA开发效率。

weixin_42548893的博客 444

Zynq7000学习 1.如何在Linux平台上运行DMA模块

本文中所使用的实验环境说明:VMware虚拟机,ubuntu16.04版本的linux系统,Xilinx SDK2017.4(文中用到了它的 编译器),Petalinux2019.1(可以选装黑金的2017.4版本,笔者这里安装错了版本也就没有卸载重装)。

weixin_38218267的博客 7114

如何用Zynq UltraScale+的PL端实现2.5G以太网?AXI Ethernet Subsystem配置详解

本文详细解析了如何在Xilinx Zynq UltraScale+平台的PL端实现2.5G以太网,重点介绍了AXI Ethernet Subsystem的配置方法。从PHY选型、硬件设计到Vivado IP核配置和软件优化,提供了全面的实战指南,帮助工程师突破千兆以太网限制,满足工业视觉和数据中心边缘计算的高带宽需求。

weixin_30889885的博客 324

ZYNQ7010 与 AD7768 高速采集:LVDS 接口、AXI-DMA 与 SPI 配置实战

在多通道同步采集系统中,FPGA 常被用于实现高速 ADC 的接口逻辑与数据搬运。其核心原理是利用可编程逻辑实现硬时序控制,通过 LVDS 等差分接口完成串并转换,再借助 AXI-Stream 与 DMA 将数据高效传输至处理器系统。这种软硬协同架构能显著提升采样精度与吞吐率,广泛应用于振动监测、声学分析、电力检测等场景。SPI 配置则负责 ADC 寄存器初始化与状态校验,确保链路可靠。本文以 ZYNQ7010 采集 AD7768 为例,详解 LVDS 解串、通道对齐、DMA 搬运及 SPI 配置的工程实现

weixin_33827731的博客 399

ZYNQ AXI_DMA_UDP以太网传输(三)

本次实验跟之前的实验有所不同,不同点在于:1、前面一个实验的UDP协议,ZYNQ板卡是作为服务端(Server),向PC端一直主动的发数据,但是这一次不同,这一次ZYNQ板卡是作为客户端(Client),需要等待PC端发送相应指令,然后进入UDP协议接收回调函数,再往PC端发送一次数据;2、另一个不同点在于,本次实验加入了将PC端的参数文件通过UDP协议发送到PS端,然后PS端通过AXI BRAM CTRL下发到PL端的BRAM中。

weixin_43982855的博客 2631

一文搞懂什么是OTA(空中升级)

OTA(Over-The-Air,空中升级)是一种通过无线通信技术实现远程更新设备固件或软件的方法。这项技术广泛应用于现代物联网(IoT)设备、智能手机、汽车、嵌入式系统等领域,提供了一种无需物理连接的便捷更新方式。OTA更新的核心在于使设备能够自动、可靠、安全地从远程服务器获取和应用更新,改善设备性能、添加新功能或修复安全漏洞。

不积跬步无以至千里 7万+

linux怎么读zynq的ddr数据,Zedboard & Zynq 图像采集 视频开发 (三) AXI4总线读写DDR

/*-----------------------------------------------------------------------CONFIDENTIALINCONFIDENCEThisconfidentialandproprietarysoftwaremaybeonlyusedasauthorizedbyalicensingagreementfro...

weixin_35928736的博客 655

Seedance2.5本地部署指南:从环境配置到生产优化的完整实践

在 AI 内容生成领域,本地部署方案正逐渐成为开发者和技术团队关注的焦点。Seedance2.5 作为一款支持图像和视频生成的 AI 工具,其完全离线运行的能力解决了云端服务在数据隐私、使用成本和访问稳定性方面的痛点。对于需要处理敏感内容、频繁生成素材或希望完全掌控生成流程的技术人员来说,掌握本地部署方法具有实际价值。 本文将以 Seedance2.5 的本地部署为例,详细介绍从环境准备、依赖配置到运行验证的完整流程,同时深入分析关键参数配置、常见问题排查方法以及生产环境下的优化建议。通过实际部署过程,理解

weixin_33139275的博客 740

从零开始理解二极管限幅:5种典型电路设计及实际应用场景解析

本文系统解析了二极管限幅电路的五大经典拓扑,包括串联与并联型上下限幅及双向限幅。通过剖析其核心原理与二极管的单向导电性、正向压降特性,结合ADC输入保护、电源管理、音频处理等实际应用场景,提供了从器件选型到设计陷阱规避的完整实战指南,帮助工程师为信号构建可靠的“安全笼”。

2y3u4i5o6p的博客 1038

Linux AMBA 驱动:DMA 控制器 PL330 驱动简析

Linux,AMBA 驱动,PL330

JiMoKuangXiangQu的专栏 2026

【AWS】创建aws云服务器EC2实例

本文介绍了如何创建aws的EC2云服务器,并介绍了如何使用Xshell远程连接上云服务器

Marcos921的博客 2505

AXI VDMA原理与实战:FPGA图像数据搬运核心机制

AXI VDMA是Xilinx FPGA中专用于视频流与DDR内存高效交互的关键IP,本质是AXI-Stream到AXI-MM协议转换器与帧级DMA控制器。其核心原理在于硬件级双缓冲管理、跨时钟域同步及严格地址对齐(256字节起始+16字节行宽),确保VGA/1080P等二维图像帧无撕裂、低延迟锚定至内存。技术价值体现在卸载CPU图像搬运任务、支撑HLS算法加速、适配Linux DMA-BUF零拷贝架构,并与AXI仲裁器协同保障多主设备总线公平性。典型应用场景包括OV5640摄像头采集、HDMI实时输出、边

weixin_33762130的博客 351

加湿器方案-DLT8M04TS-杰力科创

基本组成: 一个触摸按键、一组RGB灯、一个雾化片、一个充电IC。 产品功能: 第一次上电光机状态,RGB红/绿/红灯依次闪烁灭; 2、按键功能:短按开关机和三档喷雾工作模式,第一次短按持续喷雾,短按第二次喷3S,停3S,短按第三次关闭喷雾模式,依次循环; 在喷雾或是不喷雾的状态下长按1.5S RGB灯渐变,一直循环,第二次长按当前灯光闪烁一下常亮,第三次长按关机; 3、持续喷雾定时5小时自动断电,间歇喷雾定时10小时自动断电,若在间歇工作时有切换为持续喷雾,那间歇喷雾的...

JLKCsz的博客 514

(一)DaVinci Developer AutoSAR工具 如何新建SWC、Component、RTE工程,超级详细步骤,赚到

​ 1,创建SWC,第一步需要创建一个App组件类型,首先点击Object Brower菜单,然后左键Application Component Types 选项,然后右键New Application Component Type,组件类型的作用是来后续实例一个Compoent 2、 Properties 选项卡中Nane中输入Type的名字,注意根据规范命名规则已CtAp开头,其他默认就好 ​

weixin_42602687的博客 3582

FPGA 设计详细笔记:XDMA + PCIe + AXI-Stream

主要内容包括: PCIe配置空间核心字段:Vendor ID标识厂商,Device ID标识设备型号,Class Code说明设备类别,BAR用于地址映射。 Vivado中XDMA参数配置: PCIe IDs页设置厂商和设备标识 BARs页配置地址空间大小和类型 链路参数页设置PCIe版本和通道数 DMA/AXI页选择接口模式和位宽 XDMA+AXI-Stream架构中: 数据面通过AXI-Stream通道

m0_46644103的博客 512

HAL STM32+EC11编码器实现增减调节及单击、双击、长按功能

HAL STM32+EC11编码器实现增减调节及单击、双击、长按功能

perseverance51博客 4239

Xilinx FPGA PCIe | XDMA IP 核 / 应用 / 测试 / 实践

……

u013669912的博客 7959

DSP的CLA调试技巧

本文介绍了基于TMS320F28377D的CLA(Control Law Accelerator)开发实战教程,涵盖基础配置、编程、调试与优化全流程。主要内容包括:CLA核心特性及其作为实时控制协处理器的优势;开发环境搭建与工程配置要点;CLA任务调度、数据交换及编程约束;调试技巧如断点设置和性能分析方法;进阶应用案例(批量除法运算)及优化策略;以及推荐的学习资源和硬件平台。教程强调数据一致性和任务同步问题,为快速上手CLA开发提供实用指导。

1051

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

上一篇: 04 搭建linux驱动开发环境
下一篇: 06 实现自定义AXI DMA驱动
lf282481431
博客等级 码龄10年 506粉丝 90原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值