本文介绍了在Zynq7020平台上，通过寄存器方式实现PS和PL之间数据交换的方法。讨论了数据量和交互速度的重要性，并提供了一个动态编译的驱动示例，涉及ioremap、DMA内存分配以及copy_to_user等操作。尽管这种方式在数据量大时效率较低，但在与FPGA交互时，FPGA能直接读取寄存器获取数据地址。
对于 zynq7020 这个器件来说，如果实现PS端和PL端的数据交换，是个很重要的话题，基本上最后都绕不过要实现这个目的。对于我们来说，主要有以下两个方面的考量：
- 数据量，即容量。
- 数据交互速度，即实时性。
这两个方式直接决定着我们使用哪种手段来实现这个流程。
下面本博客将用3种方式，来实现这个交互流程。
方式1 采用寄存器方式
驱动部分
test1_dma_dri.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <asm/io.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#include <linux/ioport.h>
#include <linux/of.h>
#include <linux/uaccess.h>
#include <linux/interrupt.h>
#include <asm/irq.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <linux/dma-mapping.h>
//DMA 基地址
#define DMA_BASE_ADDR 0X40400000
//DMA MM2S控制寄存器
volatile unsigned int * mm2s_cr;
#define MM2S_DMACR 0X00000000
//DMA MM2S状态控制寄存器
volatile unsigned int * mm2s_sr;
#define MM2S_DMASR 0X00000004
//DMA MM2S源地址低32位
volatile unsigned int * mm2s_sa;
#define MM2S_SA 0X00000018
//DMA MM2S传输长度（字节）
volatile unsigned int * mm2s_len;
#define MM2S_LENGTH 0X00000028
//DMA S2MM控制寄存器
volatile unsigned int * s2mm_cr;
#define S2MM_DMACR 0X00000030
//DMA S2MM状态控制寄存器
volatile unsigned int * s2mm_sr;
#define S2MM_DMASR 0X00000034
//DMA S2MM目标地址低32位
volatile unsigned int * s2mm_da;
#define S2MM_DA 0X00000048
//DMA S2MM传输长度（字节）
volatile unsigned int * s2mm_len;
#define S2MM_LENGTH 0X00000058
#define DMA_LENGTH 16384
dma_addr_t axidma_handle;
volatile unsigned int * axidma_addr;
//DMA interrupt functions
static irqreturn_t dma_mm2s_irq(int irq,void *dev_id)
{
printk("irq=%d\n",irq);
iowrite32(0x00001000,mm2s_sr);
return IRQ_HANDLED;
}
static irqreturn_t dma_s2mm_irq(int irq,void *dev_id)
{
printk("irq=%d\n",irq);
iowrite32(0x00001000,s2mm_sr);
return IRQ_HANDLED;
}
int major;
static struct class *dma_class = NULL;
static int __init dma_init(void);
static void __exit dma_exit(void);
static int dma_open(struct inode *inode,struct file *file);
static int dma_release(struct inode *inode,struct file *file);
static int dma_write(struct file *file,const char __user *buf, size_t count,loff_t *ppos);
static int dma_read(struct file *file,char __user *buf,size_t size,loff_t *ppos);
/*
*file_operations 结构数据，沟通内核与操作系统桥梁
*
* */
static struct file_operations dma_lops=
{
.owner = THIS_MODULE,
.open = dma_open,
.release = dma_release,
.read = dma_read,
.write = dma_write,
};
/*
* 初始化，用于module init
*
* */
static int __init dma_init(void)
{
major=register_chrdev(0,"dma_dev",&dma_lops);
dma_class = class_create(THIS_MODULE,"dma_dev");
device_create(dma_class,NULL,MKDEV(major,0),NULL,"dma_dev");
printk("major dev number= %d\n",major);
mm2s_cr = ioremap(DMA_BASE_ADDR+MM2S_DMACR, 4);
mm2s_sr = ioremap(DMA_BASE_ADDR+MM2S_DMASR, 4);
mm2s_sa = ioremap(DMA_BASE_ADDR+MM2S_SA, 4);
mm2s_len = ioremap(DMA_BASE_ADDR+MM2S_LENGTH,4);
s2mm_cr = ioremap(DMA_BASE_ADDR+S2MM_DMACR, 4);
s2mm_sr = ioremap(DMA_BASE_ADDR+S2MM_DMASR, 4);
s2mm_da = ioremap(DMA_BASE_ADDR+S2MM_DA, 4);
s2mm_len = ioremap(DMA_BASE_ADDR+S2MM_LENGTH,4);
return 0;
}
/*
*退出 用于 module exit
*
* */
static void __exit dma_exit(void)
{
unregister_chrdev(major,"dma_dev");
device_destroy(dma_class,MKDEV(major,0));
class_destroy(dma_class);
// free_irq(dma_mm2s_irq,NULL);
// dma_free_coherent(NULL,DMA_LENGTH,axidma_addr,axidma_handle);
iounmap(mm2s_cr);
iounmap(mm2s_sr);
iounmap(mm2s_sa);
iounmap(mm2s_len);
iounmap(s2mm_cr);
iounmap(s2mm_sr);
iounmap(s2mm_da);
iounmap(s2mm_len);
request_irq(61,dma_mm2s_irq,IRQF_TRIGGER_RISING,"dma_dev",NULL);
request_irq(62,dma_s2mm_irq,IRQF_TRIGGER_RISING,"dma_dev",NULL);
// return 0;
}
/*
*open 接口函数
*
* */
static int dma_open(struct inode *inode,struct file *file)
{
int err, err1 = 0, err2 = 0;
//申请一大块空间
axidma_addr = dma_alloc_coherent(NULL,DMA_LENGTH,&axidma_handle,GFP_KERNEL);
//申请中断
// err1 = request_irq(61,dma_mm2s_irq,IRQF_TRIGGER_RISING,"dma_dev",NULL);
// err2 = request_irq(62,dma_s2mm_irq,IRQF_TRIGGER_RISING,"dma_dev",NULL);
printk("dma open\n");
err = err1|err2;
return err;
}
/*
*close 接口函数
*
* */
static int dma_release(struct inode *inode,struct file *file)
{
// 下面注释掉的东西是便于fpga断观察
//释放空间
// dma_free_coherent(NULL,DMA_LENGTH,axidma_addr, axidma_handle);
// //释放中断
// free_irq(61,NULL);
// free_irq(62,NULL);
printk("dma close\n");
return 0;
}
/*
* write 接口函数
*
* */
static int dma_write(struct file *file,const char __user *buf, size_t count,loff_t *ppos)
{
int err=0;
if(count>DMA_LENGTH)
{
printk("the number of data is too large!\n");
return 0;
}
// memcpy(axidma_addr,buf,count);
copy_from_user(axidma_addr, buf, count);
iowrite32(0x00001001,mm2s_cr);//open int & enable DMA
iowrite32(axidma_handle,mm2s_sa);
iowrite32(count,mm2s_len);//write transmission length and DMA start transmission
return 0;
}
/*
* read 接口函数
*
* */
static int dma_read(struct file *file,char __user *buf,size_t size,loff_t *ppos)
{
int err=0;
if(size>DMA_LENGTH)
{
printk("the number of data is not enough!\n");
return 0;
}
iowrite32(0x00001001,s2mm_cr);//open int & enable DMA
iowrite32(axidma_handle,s2mm_da);
iowrite32(size,s2mm_len);//write transmission length and DMA start transmission
// memcpy(buf, axidma_addr, size);
copy_to_user(buf, axidma_addr, size);
return 0;
}
module_init(dma_init);
module_exit(dma_exit);
MODULE_AUTHOR("TEST@dma");
MODULE_DESCRIPTION("dma driver");
MODULE_ALIAS("dma linux driver");
MODULE_LICENSE("GPL");
Makefile
obj-m := test1_dma_dri.o
# 驱动的makefile有的不支持在此里面定义下面两行，所以应换成在命令行定义
# ARCH=arm
# CROSS_COMPILE=/usr/local/gcc-linaro-7.5.0-2019.12-x86_64_arm-linux-gnueabihf/bin/arm-linux-gnueabihf-
SRC := $(shell pwd)
KERNEL_SRC :=/home/francis/Desktop/linux-xlnx-xilinx-v2017.4
all:
$(MAKE) -C $(KERNEL_SRC) M=$(SRC) modules
clean:
rm -f *.o *~ core .depend .*.cmd *.ko *.mod.c
rm -f Module.markers Module.symvers modules.order
rm -rf .tmp_versions Modules.symvers
上面采用的是动态编译方式，最后生成的驱动模块需要放到开发板之后，再手动 insmod .
如果采用静态编译的方式，即直接编进内核，不需要再手动加载，这种方式也很简单，网上有大把参考教程，这里不再赘述了。
用户层测试程序
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
unsigned char array[101],readarray[101];
unsigned char array2[101],readarray2[101];
int main(int argc , char ** argv)
{
int fd;
int i,j = 2;
int ret = 0;
fd = open("/dev/dma_dev",O_RDWR);
if(fd<0)
{
printf("can not open file\n");
exit(-1);
}
for(i=0;i<100;i++)
{
array[i]=i;
array2[i]=(unsigned char)(i*2);
}
write(fd,array,100);
read(fd,readarray,100);
printf("-----display test_readary datas------\n ");
for(i=0;i<100;i++)
{
printf("%d ",readarray[i]);
if((i+1)%20==0)
printf(" \n");
}
for(i=0;i<100;i++)
{
if(array[i]!=readarray[i])
{
ret = 1;
break;
}
}
if (ret)
{
printf("error!\n ");
ret = 0;
}
else
{
printf("write dma and read successful!\n ");
}
// sleep(1);
write(fd,array2,100);
read(fd,readarray2,100);
printf("-----display test_readary datas------\n ");
for(i=0;i<100;i++)
{
printf("%d ",readarray2[i]);
if((i+1)%20==0)
printf(" \n");
}
for(i=0;i<100;i++)
{
if(array2[i]!=readarray2[i])
{
ret = 1;
break;
}
}
if (ret)
{
printf("error!\n ");
ret = 0;
}
else
{
printf("write dma and read successful!\n ");
}
close(fd);
return 0;
}
得到
驱动分析
1 了解上面的驱动之前，需要读芯片手册得到具体寄存器代表着什么意思。比如
MM2S_DMACR ## 代表DMA MM2S控制寄存器，该寄存器有使能DMA的字段
然后我们通过 ioremap 的方式影射到了不同的寄存器，往这些寄存器里面读数据写数据。
同时，我们也申请了一大片供 DMA 使用的内存，这个地址也会放到DMA源地址寄存器(指针 mm2s_sa)里面，待 DMA 完成之后，采用 copy_to_user(or copy_from_user)实现用户空间和内核空间数据的交换。
2 上面的缺点显而易见，首先，使用 copy_to_user(or copy_from_user) 这种方式会占用太多的时间，数据量小的情况下还不明显，但是频繁使用而且数据量很大的情况下会造成很大影响。
3 本测试程序仅仅是用于arm端的自测试。但是跟PL端进行交互时，我们需要把这个 axidma_handle 这个实际的物理地址给到 FPGA，但是，实际上我们驱动已经将这个 axidma_handle 地址写到 mm2s_sa 这个寄存器里面了，这里FPGA 那边可以直接通过其寄存器的物理地址读这个寄存器的值，就可以拿到这个地址了。
扫一扫
852
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
