2021-08-16Zynq linux系统下的AXI DMA驱动与应用程序简单Demo实现

在参考网友（天使之猜）的例程（https://blog.csdn.net/hello_jinjin/article/details/102058119）中遇到了一些问题，导致内核崩溃。
在英勇无比的网友（兜兜里么糖√º）帮助下，成功解决了这一问题。 现将解决方法整理如下：
1.天使之猜网友的DMA驱动源码中第126行有误，应修改为static void dma_exit(void)并将“return 0”注释掉，注意第84行函数的声明也应一起修改。
2.第179行应改为copy_from_user(axidma_addr,buf,count);
3.第220行应改为copy_to_user(buf, axidma_addr, size);
其他部分如常，无特别需要更正的。
修改后的DMA驱动源码如下：

#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驱动程序
 *
 *
 *
 *
 *
 *
 *`
 *
 * **/
//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;
int major;


static struct class *dma_class   = NULL;
static int dmadev_init(void);
static void dmadev_exit(void);
static int dma_open(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,
.read  = dma_read,
.open  = dma_open,
.write = dma_write,
};
//DMA interrupt functions
static irqreturn_t dma_mm2s_irq(int irq,void *dev_id)
{
    printk(KERN_ERR"irq=%d\n",irq);
    iowrite32(0x00001000,mm2s_sr);
    return IRQ_HANDLED;
}
static irqreturn_t dma_s2mm_irq(int irq,void *dev_id)
{
    printk(KERN_ERR"irq=%d\n",irq);
    iowrite32(0x00001000,s2mm_sr);
    return IRQ_HANDLED;
}
/*
 *open 接口函数
 *
 * */
static int dma_open(struct inode *inode,struct file *file)
{
    int err;
    printk(KERN_ERR"DMA open\n");
    //申请一大块空间
    axidma_addr = dma_alloc_coherent(NULL,DMA_LENGTH,&axidma_handle,GFP_KERNEL);

	//申请中断
    err = request_irq(61,dma_mm2s_irq,IRQF_TRIGGER_RISING,"dmadev",NULL);
    printk(KERN_ERR"request_irq err=%d\n",err);
    err = request_irq(62,dma_s2mm_irq,IRQF_TRIGGER_RISING,"dmadev",NULL);
    printk(KERN_ERR"request_irq err=%d\n",err);
    return 0;
}
/*
 * write 接口函数
 *
 * */
static int dma_write(struct file *file,const char __user *buf, size_t count,loff_t *ppos)
{
    int err=0;
    printk(KERN_ERR"dma write start !\n");
    if(count>DMA_LENGTH)
    {
	printk(KERN_ERR"the number of data is too large!\n");
	return 0;
    }
	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
    printk(KERN_ERR"dma write is over!\n");

    return 0;
}
/*
 * read 接口函数
 *
 * */
static int dma_read(struct file *file,char __user *buf,size_t size,loff_t *ppos)
{
    int err=0;
    printk(KERN_ERR"dma read start!\n");
    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
	printk(KERN_ERR"dma kernel read is begin!\n");
    // memcpy(buf, axidma_addr, size);   
	copy_to_user(buf, axidma_addr, size);
    return 0;
}
/*
 * 初始化，用于module init
 *
 * */
static int __init dmadev_init(void)
{
    major=register_chrdev(0,"dmadev",&dma_lops);
    dma_class    = class_create(THIS_MODULE,"dmadev");
    device_create(dma_class,NULL,MKDEV(major,0),NULL,"dmadev");
    printk(KERN_ERR"major dev number= %d",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);
	printk(KERN_ERR"dma init ok!\n");

   return 0;
}
/*
 *退出 用于 module exit
 *
 * */
static void __exit dmadev_exit(void)
{
    unregister_chrdev(major,"dmadev");
    
    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);
}

module_init(dmadev_init);
module_exit(dmadev_exit);

MODULE_AUTHOR("TEST@dma");
MODULE_DESCRIPTION("dma driver");
MODULE_ALIAS("dma linux driver");
MODULE_LICENSE("GPL");

应用程序如下：

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>

short readarray[4096];
int main(int argc , char ** argv)
{
    int fd; 
    int i;
    int val=0;

    fd = open("/dev/dmadev",O_RDWR);
    if(fd<0) 
	{
		printf("can not open file\n");
	}
    else 
	printf("open file sucuss\n");
	sleep(1);
	read(fd,(void *)readarray,2048);
	sleep(1);
	for(i=0;i<16;i++)
	{
		printf("	%hu=%hu\n",i,readarray[i]);
	}
	printf("now  exit\n");
		
	close(fd); 
    return 0;
}

以上~