DMA 驱动

驱动代码:
dma.c文件

/*
1，DMA : Direct Memory Access 直接内存存取。
2，CPU同一时间，只能做一件事，如果拷贝的数据过大，整个CPU只能做拷贝的动作了，
整个系统就相当于卡死了，另外的程序就不能及时响应。所以，就需要DMA了。
3，只要把源，目的，长度告诉DMA，就可以启动DMA进行数据拷贝，是DMA硬件自动拷贝的，
拷贝过程中和CPU没有任何关系，CPU可以执行其他代码，拷贝完成后，DMA会发出一个中断给CPU。
4，即，可以认为DMA是另外一个有些智能的微控制器，它只负责数据的传输。
5, 2440有自带DMA, 是一个独立于CPU的控制部件，类似的，IIC控制器是2440的一个独立于CPU的控制部件。
*/

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/mutex.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/poll.h>

#include <linux/irq.h>
#include <asm/irq.h>
#include <linux/interrupt.h>

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

#define DEVICE_NAME    "mydma"
static int MYDRIVER_Major = 0;

static struct class * mydma_class;
//static struct class_device    * mydma_class_dev;

/*注意:kmalloc 分配的虚拟地址是连续的，物理地址是不连续的。
dma_alloc_writecombine 分配的虚拟地址是连续的，物理地址也是连续的。
DMA没这么智能，传递给MDA的是物理地址，且必须是连续的，
所以要使用函数:dma_alloc_writecombine来分配内存。
*/
static char * src = NULL;                        //虚拟源地址
static unsigned long src_phys = 0;    //源的物理地址
static char * desc = NULL;                    //虚拟的目的地址
static unsigned long desc_phys = 0;    //目的的物理地址
#define BUF_SIZE (512*1024)

/* DMA相关的寄存器
写成结构体的原因是:一次内存映射所有的寄存器。
 */
struct s3c_dma_regs
{
        unsigned long disrc;            /*0x4B000000 : DMA初始源寄存器*/
        unsigned long disrcc;            /*0x4B000004 : DMA初始源控制寄存器*/
        unsigned long didst;            /*0x4B000008 : DMA初始目标寄存器*/
        unsigned long didstc;            /*0x4B00000C : DMA初始目标控制寄存器*/
        unsigned long dcon;                /*0x4B000010 : DMA控制寄存器*/
        unsigned long dstat;            /*0x4B000014 : DMA状态寄存器*/
        unsigned long dcsrc;            /*0x4B000018 : DMA当前源寄存器*/
        unsigned long dcdst;            /*0x4B00001C : DMA当前目标寄存器*/
        unsigned long dmasktrig;    /*0x4B000020 : DMA触发屏蔽寄存器*/
};
#define MDA0_BASE_ADDR (0x4B000000)
#define MDA1_BASE_ADDR (0x4B000040)
#define MDA2_BASE_ADDR (0x4B000080)
#define MDA3_BASE_ADDR (0x4B0000C0)
static volatile struct s3c_dma_regs * dma_regs;

static int mydma_open(struct inode *inode, struct file *file)
{
    printk("DEVICE:mydma_open Called!\n");
    return 0;
}

static int mydma_release(struct inode *inode, struct file *file)
{
    printk("DEVICE:mydma_release Called!\n");
    return 0;
}

#define MEM_CPY_NO_DMA 0 //不使用DMA
#define MEM_CPY_DMA    1    //使用DMA
static int mydma_ioctl( struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
        int i = 0;
        int ret = 0;
        memset(src, 0xAA, BUF_SIZE);
        memset(desc, 0x55, BUF_SIZE);
        switch(cmd)
        {
                case MEM_CPY_NO_DMA :
                {
                        for(i=0; i<BUF_SIZE; i++)
                        {
                                desc[i] = src[i];
                        }
                        ret = memcmp((void*)src, (void*)desc, BUF_SIZE-1);
                        if(ret == 0)
                        {
                                printk("DEVICE:MEM_CPY_NO_DMA ok!\n");
                        }
                        else
                        {
                                printk("DEVICE:MEM_CPY_NO_DMA err ret=[%d]!\n", ret);
                        }
                        break;
                }
                case MEM_CPY_DMA :
                {
                        /*
                        注意 : 本程序是直接操作DMA相关的寄存器，实际上三星公司在内核中已经提供了一堆函数，
                        可以直接操作DMA控制器。
                        */
                        //1,把源，目的，长度告诉DAM
                        //1.1),把源地址告诉DMA
                        dma_regs->disrc = src_phys; //源的物理地址
                        /*[0]=0:表示源地址递增 =1:表示源地址固定
                         [1]=0:表示源在系统总线上 =1:表示在外设总线上*/
                        dma_regs->disrcc = (0<<1)|(0<<0);

                        //1.2),把目的地址告诉DMA
                        dma_regs->didst = desc_phys; //目的的物理地址
                        /*[0]=0:表示目的地址递增 =1:表示目的地址固定
                         [1]=0:表示目的地址在系统总线上 =1:表示在外设总线上
                         [2]=0:TC到达0时发生中断 =1:执行完自动再加载后发生中断*/
                        dma_regs->didstc = (0<<2)|(0<<1)|(0<<0);

                        //1.3),把目的地址告诉DMA
                        /*[21:20]DSZ : 每1次读写过程，读写数据的大小(1,2,4字节)。
                         [ 28]TSZ : 单次传输 : 每1次传输，有1次读写过程。
                                               burst传输 : 每1次传输，有4次读写过程。
                         [19: 0]TC : 传输次数。
                          总长度 = TC*TSZ(1或4)*DSZ(1或2或4)
                         */
                        dma_regs->dcon = (1<<30)|(1<<29)|(0<<28)|(1<<27)|(0<<23)|(0<<20)|(BUF_SIZE<<0);

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

                        //3,CPU怎么知道DMA什么时候完成?
                        //CPU进入休眠状态，会在中断函数中唤醒。
                        /*
                        函数功能:进程开始休眠，表现为程序阻塞在这里，不继续向下执行。
                        注意：1，应用程序ioctl也会阻塞，直到驱动ioctl被唤醒。
                              2，休眠：意味着进程从调度器的运行队列中移走，不会被任何cpu调度，直到被唤醒
                              3, 本进程被唤醒的条件：1),函数第2个参数为真。并且 2),调用wake_up_interruptible()函数。*/
                        ev_dma = 0;
                        wait_event_interruptible(dma_waitq, ev_dma);

                        ret = memcmp((void*)src, (void*)desc, BUF_SIZE-1);
                        if(ret == 0)
                        {
                                printk("DEVICE:MEM_CPY_DMA ok!\n");
                        }
                        else
                        {
                                printk("DEVICE:MEM_CPY_NO_DMA err ret=[%d]!\n", ret);
                        }

                        break;
                }
                default :
                {
                        printk("DEVICE:cmd=[%d] err\n", cmd);
                        break;
                }
        }

        return 0;
}

/*
static : 表示只在本文件中使用
*/
static struct file_operations mydma_fops =
{
        .owner = THIS_MODULE, /*固定写这个*/
        .open = mydma_open,
        .release = mydma_release,
        .ioctl = mydma_ioctl,
};

/*IRQ_DMA1 中断处理函数*/
static irqreturn_t dma_interrupt(int irq, void *dev_id)
{
        //唤醒
        ev_dma = 1; /* 睡眠函数的第2个参数为真 */
        //printk("Driver : dma_interrupt : wake_up_interruptible begin!\n");

    wake_up_interruptible(&dma_waitq); /* 唤醒休眠的进程 */
    //printk("Driver : dma_interrupt : wake_up_interruptible end!\n");

        return IRQ_HANDLED;
}

static int dma_init(void)
{
        unsigned int ret = 0;
        printk("DEVICE:dma_init\n");

        ret = request_irq(IRQ_DMA1, dma_interrupt, 0, "dma_irq", NULL);
        if(ret != 0)
        {
                printk("DEVICE: request_irq IRQ_DMA1 :[%d],[%d]!\n", EIO, ret);
                return -EIO;
        }

        //分配源对应的缓冲区:返回的src是虚拟地址， src_phys是对应的物理地址
        src = dma_alloc_writecombine(NULL, BUF_SIZE, (dma_addr_t *)&src_phys, GFP_KERNEL);
        if(src == NULL)
        {
                disable_irq(IRQ_DMA1);
                free_irq(IRQ_DMA1, NULL);
                printk("DEVICE:dma_alloc_writecombine() for src err!\n");
                return -1;
        }

        //分配目的对应的缓冲区
        desc = dma_alloc_writecombine(NULL, BUF_SIZE, (dma_addr_t *)&desc_phys, GFP_KERNEL);
        if(desc == NULL)
        {
                disable_irq(IRQ_DMA1);
                free_irq(IRQ_DMA1, NULL);
                dma_free_writecombine(NULL, BUF_SIZE, src, (dma_addr_t)src_phys);
                printk("DEVICE:dma_alloc_writecombine() for desc err!\n");
                return -1;
        }

        /* 设置S3C2440的DMA寄存器 */
        dma_regs = ioremap(MDA1_BASE_ADDR, sizeof(struct s3c_dma_regs));
        if(dma_regs == NULL)
        {
                printk("DEVICE:ioremap() dma_regs err!\n");
                return -1;
        }

        MYDRIVER_Major = register_chrdev(0, DEVICE_NAME, &mydma_fops);
        if(MYDRIVER_Major < 0)
        {
                printk(DEVICE_NAME " can't register major number\n");
                return MYDRIVER_Major;
        }
        printk("DEVICE:register mydma OK! Major = [%d]\n", MYDRIVER_Major);

        //自动创建一个设备节点，节点名为DEVICE_NAME
        mydma_class = class_create(THIS_MODULE, DEVICE_NAME);
        if(IS_ERR(mydma_class))
        {
                printk("DEVICE:class_create err!\n");
                return -1;
        }
        /* 为了让mdev根据这些信息来创建设备节点 */
        device_create(mydma_class, NULL, MKDEV(MYDRIVER_Major, 0), NULL, DEVICE_NAME); /* /dev/leddriver */

        printk("DEVICE:initialized\n");
        return 0;
}

static void dma_exit(void)
{
        iounmap(dma_regs);

        device_destroy(mydma_class, MKDEV(MYDRIVER_Major, 0));
        class_destroy(mydma_class);
        unregister_chrdev(MYDRIVER_Major, DEVICE_NAME);

        dma_free_writecombine(NULL, BUF_SIZE, src, (dma_addr_t)src_phys);
        dma_free_writecombine(NULL, BUF_SIZE, desc, (dma_addr_t)desc_phys);

        disable_irq(IRQ_DMA1);
        free_irq(IRQ_DMA1, NULL);

        return;
}

module_init(dma_init);
module_exit(dma_exit);

MODULE_LICENSE("GPL");


/*
分析 :
# cat /proc/interrupts //看看哪些中断已经被用了?
           CPU0
 30: 9189         s3c  S3C2410 Timer Tick
 33: 0         s3c  s3c-mci //SD卡，这个说明 IRQ_DMA0 中断已经被用了。
 37: 21         s3c  s3c-mci //SD卡，这个说明 IRQ_DMA3 中断已经被用了。
 41: 1         s3c  s3c2410_udc
 42: 0         s3c  ohci_hcd:usb1
 43: 0         s3c  s3c2440-i2c
 51: 1304     s3c-ext  eth0
 60: 0     s3c-ext  s3c-mci
 70: 48   s3c-uart0  s3c2440-uart
 71: 253   s3c-uart0  s3c2440-uart
 80: 0     s3c-adc  adc
Err: 0

卸载ko的时候，还有问题
*/

makefile文件

# File: Makefile
# wangxiancai

MODEXT = ko
# INSTALLDIR=/home/wangxc/linux/rootfs/nfs_2.6.13/wxc/driver/chardriver/ko
INSTALLDIR=/home/wangxc/linux/rootfs/nfs_2.6.30/wxc/driver/chardriver/ko
# CROSS=/home/wangxc/linux/toolchain/crosstools_3.4.1_softfloat/arm-linux/gcc-3.4.1-glibc-2.3.3/bin/arm-linux-
CROSS=/home/wangxc/linux/toolchain/crosstools_4.4.3_softfloat/bin/arm-linux-
# KERNELDIR=/home/wangxc/linux/kernel/kernel-2.6.13
KERNELDIR=/home/wangxc/linux/kernel/kerner-2.6.30

CC= $(CROSS)gcc
LD= $(CROSS)ld

#############################################################################
# Compiler Flags
#############################################################################
EXTRA_CFLAGS += -I$(KERNELDIR)/include
#############################################################################
# Make Targets
#############################################################################
obj-m := dma.o
default:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
# Otherwise we were called directly from the command line; invoke the kernel build system.

install: default
    cp -rf $(PWD)/dma.$(MODEXT) $(INSTALLDIR)

clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions *.bak modules.order Module.symvers

应用程序代码
dmatest.c文件

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <errno.h>


/*下面是ioctl识别的宏定义 和内核中定义的一样*/
#define MEM_CPY_NO_DMA 0 //不使用DMA
#define MEM_CPY_DMA    1    //使用DMA

/* 命令行参数如下:
 * dmatest nodma 100                //oled初始化
 * dmatest dma   100                //oled清屏
 */

void print_usage(char *cmd);

int main(int argc, char **argv)
{
    int fd;

    /*判断参数的合法性*/
    if(argc != 2)
    {
        print_usage(argv[0]);
        return -1;
    }

    /*打开oled文件*/
    printf("open begin:\n");
    fd = open("/dev/mydma", O_RDWR);
    if(fd < 0)
    {
        printf("can't open /dev/mydma\n");
        return -1;
    }
    printf("open succ!\n");

    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;
    }
    close(fd);

    return 0;
}


void print_usage(char *cmd)
{
    printf("Usage:\n");
    printf("%s [nodma|dma]\n", cmd);
}


/*
测试 :
1， 刚才开始的测试的时候，由于open函数使用的是 RDONLY 只读打开，驱动函数 write不能调用，
使用 O_RDWR 可读可写方式打开，才能正确
2，
# ./dmatest
Usage:
./dmatest [nodma|dma]

# nohup ./dmatest nodma & //后台执行
会不停的打印一些信息:DEVICE:MEM_CPY_NO_DMA
如果这个时候 执行 ls命令，
会看见ls的结果不是立马执行的。要等一会才会执行。

重新启动开发板:
# nohup ./dmatest dma & //后台执行
会不停的打印一些信息:
如果这个时候 执行 ls命令，
会看见ls的结果是立马执行的。不用等，立即执行。

测试结果说明 : 如果使用DMA，cpu会解放出来，有更多的时间可以干其他事情
*/

makefile文件

# CROSS=/home/wangxc/linux/toolchain/crosstools_3.4.1_softfloat/arm-linux/gcc-3.4.1-glibc-2.3.3/bin/arm-linux-gcc
CROSS=/home/wangxc/linux/toolchain/crosstools_4.4.3_softfloat/bin/arm-linux-gcc
all:dmatest
dmatest:dmatest.c
    $(CROSS) -o dmatest dmatest.c
clean:
    rm -vf dmatest.o dmatest