韦东山视频_第27课_dma设备驱动程序

DMA驱动实际上是一个字符设备驱动程序，用普通的注册字符设备驱动即可。

驱动代码如下：

/*
 *    dma驱动实际上是一个字符设备驱动。
 *    本程序实现了用DMA将一段内存从一个源地址拷贝到目的地址，源、目的均在内存上，
 *大小为BUF_SIZE。 还可以不适用DMA，直接使用MCU拷贝，使用命令MEM_CPY_NO_DMA和
 *MEM_CPY_DMA选择是否使用DMA拷贝。
 *
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/input.h>
#include <linux/errno.h>
#include <linux/cdev.h>
#include <linux/dma-mapping.h>

//定义是否使用DMA拷贝命令宏
#define MEM_CPY_NO_DMA  0
#define MEM_CPY_DMA     1

#define BUF_SIZE  (512*1024)    //缓存区大小

//S3c2440 4个DMA通道基地址
#define DMA0_BASE_ADDR  0x4B000000
#define DMA1_BASE_ADDR  0x4B000040
#define DMA2_BASE_ADDR  0x4B000080
#define DMA3_BASE_ADDR  0x4B0000C0

//每个DMA通道有9个控制寄存器
struct s3c_dma_regs 
{
    unsigned long disrc;
    unsigned long disrcc;
    unsigned long didst;
    unsigned long didstc;
    unsigned long dcon;
    unsigned long dstat;
    unsigned long dcsrc;
    unsigned long dcdst;
    unsigned long dmasktrig;
};


static int major = 0;        //主设备号
static struct class *cls;    //类

static char *src;        //源虚拟（映射）地址
static u32 src_phys;    //源物理地址

static char *dst;        //目的虚拟（映射）地址
static u32 dst_phys;    //目的物理地址

static volatile struct s3c_dma_regs *dma_regs;

static DECLARE_WAIT_QUEUE_HEAD(dma_waitq);
/* 中断事件标志, 中断服务程序将它置1，ioctl将它清0 */
static volatile int ev_dma = 0;

static int s3c_dma_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    int i;

    memset(src, 0xAA, BUF_SIZE);
    memset(dst, 0x55, BUF_SIZE);
    
    switch (cmd)
    {
        case MEM_CPY_NO_DMA :
        {
            for (i = 0; i < BUF_SIZE; i++)
                dst[i] = src[i];
            if (memcmp(src, dst, BUF_SIZE) == 0)
            {
                printk("MEM_CPY_NO_DMA OK
");
            }
            else
            {
                printk("MEM_CPY_DMA ERROR
");
            }
            break;
        }

        case MEM_CPY_DMA :
        {
            ev_dma = 0;
            
            /* 把源,目的,长度告诉DMA */
            dma_regs->disrc      = src_phys;        /* 源的物理地址 */
            dma_regs->disrcc     = (0<<1) | (0<<0); /* 源位于AHB总线, 源地址递增 */
            dma_regs->didst      = dst_phys;        /* 目的的物理地址 */
            dma_regs->didstc     = (0<<2) | (0<<1) | (0<<0); /* 目的位于AHB总线, 目的地址递增 */
            dma_regs->dcon       = (1<<30)|(1<<29)|(0<<28)|(1<<27)|(0<<23)|(0<<20)|(BUF_SIZE<<0);  /* 使能中断,单个传输,软件触发, */

            /* 启动DMA */
            dma_regs->dmasktrig  = (1<<1) | (1<<0);

            /* 如何知道DMA什么时候完成? */
            /* 休眠 */
            wait_event_interruptible(dma_waitq, ev_dma);

            if (memcmp(src, dst, BUF_SIZE) == 0)
            {
                printk("MEM_CPY_DMA OK
");
            }
            else
            {
                printk("MEM_CPY_DMA ERROR
");
            }
            
            break;
        }
    }

    return 0;
}

static struct file_operations dma_fops = {
    .owner  = THIS_MODULE,
    .ioctl  = s3c_dma_ioctl,
};

static irqreturn_t s3c_dma_irq(int irq, void *devid)
{
    /* 唤醒 */
    ev_dma = 1;
    wake_up_interruptible(&dma_waitq);   /* 唤醒休眠的进程 */
    return IRQ_HANDLED;
}

static int s3c_dma_init(void)
{
    //DMA拷贝完成后产生一个中断
    if (request_irq(IRQ_DMA3, s3c_dma_irq, 0, "s3c_dma", (void *)1))
    {
        printk("can't request_irq for DMA
");
        return -EBUSY;
    }
    
    /* 分配SRC, DST对应的缓冲区 */
    //不能使用kalloc分配内存，因为kalloc可能分配的内存虚拟地址连续，物理地址不一
    //定连续，而DMA不能处理物理地址不连续的地址
    src = dma_alloc_writecombine(NULL, BUF_SIZE, &src_phys, GFP_KERNEL);
    if (NULL == src)
    {
        printk("can't alloc buffer for src
");
        free_irq(IRQ_DMA3, (void *)1);
        return -ENOMEM;
    }
    
    dst = dma_alloc_writecombine(NULL, BUF_SIZE, &dst_phys, GFP_KERNEL);
    if (NULL == dst)
    {
        free_irq(IRQ_DMA3, (void *)1);
        dma_free_writecombine(NULL, BUF_SIZE, src, src_phys);
        printk("can't alloc buffer for dst
");
        return -ENOMEM;
    }

    major = register_chrdev(0, "s3c_dma", &dma_fops);

    /* 为了自动创建设备节点 */
    cls = class_create(THIS_MODULE, "s3c_dma");
    device_create(cls, NULL, MKDEV(major, 0), NULL, "dma"); /* /dev/dma */

    //使用第三通道，使用前先看一下系统已经使用了哪些DMA通道，可查看/proc/interrupts,
    //查看中断号即可,s3c2440的DMA对应的4个通道的中断号为33、34、35、36
    dma_regs = ioremap(DMA3_BASE_ADDR, sizeof(struct s3c_dma_regs));
        
    return 0;
}

static void s3c_dma_exit(void)
{
    iounmap(dma_regs);
    device_destroy(cls, MKDEV(major, 0));
    class_destroy(cls);
    unregister_chrdev(major, "s3c_dma");
    dma_free_writecombine(NULL, BUF_SIZE, src, src_phys);
    dma_free_writecombine(NULL, BUF_SIZE, dst, dst_phys);    
    free_irq(IRQ_DMA3, (void *)1);
}

module_init(s3c_dma_init);
module_exit(s3c_dma_exit);

MODULE_LICENSE("GPL");

测试程序如下：

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

/* ./dma_test nodma
 * ./dma_test dma
 */
#define MEM_CPY_NO_DMA  0
#define MEM_CPY_DMA     1

void print_usage(char *name)
{
    printf("Usage:
");
    printf("%s <nodma | dma>
", name);
}


int main(int argc, char **argv)
{
    int fd;
    
     if (argc != 2)
    {
        print_usage(argv[0]);
        return -1;
    }

    fd = open("/dev/dma", O_RDWR);
    if (fd < 0)
    {
        printf("can't open /dev/dma
");
        return -1;
    }

    if (strcmp(argv[1], "nodma") == 0)
    {
        while (1)
        {
            ioctl(fd, MEM_CPY_NO_DMA);
        }
    }
    else if (strcmp(argv[1], "dma") == 0)
    {
        while (1)
        {
            ioctl(fd, MEM_CPY_DMA);
        }
    }
    else
    {
        print_usage(argv[0]);
        return -1;
    }
    return 0;     
}

makefile 代码如下:

KERN_DIR = /linux-2.6.32.2

all:
    make -C $(KERN_DIR) M=`pwd` modules

clean:
    rm -rf modules.order *.o *.ko *.cmd *.swp *.symvers *.mod.c

obj-m += dma.o