mini2440 简单的dma工作原理实验

以驱动方式测试dma的工作原理，用户层程序不停调用ioctl触发驱动里面完成的dma操作，把内存的数据块从一个连续地址搬到另一个连续地址，然后用memcmp测试搬移后的数据和搬移前是不是完全一样。

简单的驱动代码：

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#define MEM_CPY_NO_DMA 0

#define MEM_CPY_USE_DMA 1

#define DMA_BUF_SIZE (512*1024)

#define GRH_MODULE_NAME "grh_dma"

#define DMA_REG_BASE_ADDR_0 0x4B000000

#define DMA_REG_BASE_ADDR_1 0x4B000040

#define DMA_REG_BASE_ADDR_2 0x4B000080

#define DMA_REG_BASE_ADDR_3 0x4B0000C0

static struct dma_regs{

volatile unsigned long *disrc;

volatile unsigned long *disrcc;

volatile unsigned long *didst;

volatile unsigned long *didstc;

volatile unsigned long *dcon;

volatile unsigned long *dstat;

volatile unsigned long *dcsrc;

volatile unsigned long *dcdst;

volatile unsigned long *dmasktrig;

};

static struct dma_regs dma_regs_ins;

static int major = 0;

static char *src;

static char *dst;

static unsigned int src_phys; //数据源的物理地址

static unsigned int dst_phys; //目标位置的物理地址

static struct class *dma_class;

static struct class_device *dma_class_device; 

//dma中断处理的相关数据

static DECLARE_WAIT_QUEUE_HEAD(dma_waitq); //休眠的进程队列头

static volatile int sleep_for_dma; //这个变量为0的时候ioctl函数会休眠，中断里面将其置1，read函数末尾将其设置为0

static int dma_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg){

int i;

memset(src, 0xaa, DMA_BUF_SIZE);

memset(dst, 0x55, DMA_BUF_SIZE);

switch(cmd){

case MEM_CPY_NO_DMA:{

for(i=0; i dst[i] = src[i];

if(0 == memcmp(src, dst, DMA_BUF_SIZE))

printk(KERN_EMERG"dma success!n");

else

printk(KERN_EMERG"dma fail!n");

break;

}

case MEM_CPY_USE_DMA:{

*(dma_regs_ins.disrc) = src_phys; //将数据源的物理地址存入disrc寄存器

*(dma_regs_ins.disrcc) = (0<<0) | (0<<1); //源数据和目的位置是位于主存上的，设置dma的地址递增

*(dma_regs_ins.didst) = dst_phys; 将目标物理地址存入didst寄存器

*(dma_regs_ins.didstc) = (0<<0) | (0<<1) | (0<<2); //不使用自动加载，地址递增，目的地址是位于主存中的

*(dma_regs_ins.dcon) = (1<<30) | (1<<29) | (0<<28) | (1<<27) | (0<<23) | (0<<20) | (DMA_BUF_SIZE<<0); //使能中断，不使用突发传输，dma为软件触发，传输的最小单位是1字节

//启动dma

*(dma_regs_ins.dmasktrig) = (1<<1) | (1<<0);

//休眠进程

wait_event_interruptible(dma_waitq, sleep_for_dma);

sleep_for_dma = 0;

if(0 == memcmp(src, dst, DMA_BUF_SIZE))

printk(KERN_EMERG"dma success!n");

else

printk(KERN_EMERG"dma fail!n");

break;

}

}

return 0;

}

static struct file_operations dma_fops = {

.owner = THIS_MODULE,

.ioctl = dma_ioctl,

};

//dma中断处理函数

static irqreturn_t grh_handle_dma_int(int irq, void *dev_id){

printk(KERN_EMERG"dma interrupt happened!n");

sleep_for_dma = 1;

wake_up_interruptible(&dma_waitq);

return IRQ_HANDLED;

}

static int dma_init(void){

unsigned long *p_start;

unsigned long **pp;

int i;

//分配dma使用的缓存空间

src = dma_alloc_writecombine(NULL, DMA_BUF_SIZE, &src_phys, GFP_KERNEL);

dst = dma_alloc_writecombine(NULL, DMA_BUF_SIZE, &dst_phys, GFP_KERNEL);

if(NULL==src){

printk(KERN_EMERG"allocate buffer for dma error!n");

return -ENOMEM;

}

if(NULL==dst){

dma_free_writecombine(NULL, DMA_BUF_SIZE, src, src_phys);

printk(KERN_EMERG"allocate buffer for dma error!n");

return -ENOMEM;

}

//进行地址映射

p_start = (unsigned long*)ioremap(DMA_REG_BASE_ADDR_0, sizeof(struct dma_regs));

pp = &(dma_regs_ins.disrc);

for(i=0; i<9; i++){

*(pp++) = p_start++;

}

//申请dma的中断

if(request_irq(IRQ_DMA0, grh_handle_dma_int, 0, "dma0", 1)){

printk(KERN_EMERG"request irq for dma error!n");

return -ENOMEM;

}

//默认会等待dma进行休眠

sleep_for_dma = 0;

major = register_chrdev(0, GRH_MODULE_NAME, &dma_fops);

//create my own device class

dma_class = class_create(THIS_MODULE, "grh_dma_class");

//create my device of my own class

dma_class_device = device_create(dma_class, NULL, MKDEV(major,0), NULL, "grh_dma_device");

return 0;

}

static void dma_exit(void){

unregister_chrdev(major, GRH_MODULE_NAME);

device_unregister(dma_class_device);

class_destroy(dma_class);

iounmap(dma_regs_ins.disrc);

dma_free_writecombine(NULL, DMA_BUF_SIZE, src, src_phys);

dma_free_writecombine(NULL, DMA_BUF_SIZE, dst, dst_phys);

free_irq(IRQ_DMA0, 1); //释放dma中断

}

module_init(dma_init);

module_exit(dma_exit);

MODULE_AUTHOR("GRH");

MODULE_VERSION("1.0");

MODULE_DESCRIPTION("DMA DRIVER");

MODULE_LICENSE("GPL");

//用户层测试程序

#include

#include

#include

#include

#include

#include

#include

#define MEM_CPY_NO_DMA 0

#define MEM_CPY_USE_DMA 1

void print_usage(const char *command){

printf("usage: %s n", command);

}

int main(int argc, char *argv[]){

int count;

int fd;

fd = open("/dev/grh_dma_device", O_RDWR);

if(fd < 0){

printf("open device error!n");

return -1;

}

if(2 != argc){

printf("command format error!n");

print_usage(argv[0]);

return -1;

}

if(0 == strcmp(argv[1],"nodma")){

while(1){

ioctl(fd, MEM_CPY_NO_DMA);

}

}

else if(0 == strcmp(argv[1],"dma")){

while(1){

ioctl(fd, MEM_CPY_USE_DMA);

}

}

else{

printf("parameter error!n");

print_usage(argv[0]);

return -1;

}

close(fd);

return 0;

}

运行结果：使用dma时和不使用dma时数据搬移的效率明显加快，cpu消耗量锐减，系统响应速度提升。