linux3.4.2之DMA驱动完整程序

 /*
 *参考arch/arm/mach-s3c24xx/dma-s3c2410.c
 */
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/irq.h>
 #include <asm/uaccess.h>
 #include <asm/irq.h>
 #include <asm/io.h>
 #include <linux/poll.h>
 #include <plat/regs-dma.h>
 #include <mach/dma.h>
 #include <plat/dma-s3c24xx.h>
 #include <linux/cdev.h>
 #include <linux/backing-dev.h>
 #include <linux/wait.h>
 #include <linux/interrupt.h>

 #define DMA_BASE 0x4b000000
 #define BUFF_SIZE 512

 static unsigned char *src_addr;//源
 static unsigned char *dst_addr;//目的
 static int major;
 static dma_addr_t psrc_addr;
 static dma_addr_t pdst_addr;

 static struct class *dma_class;
 static int dma_ok;
 #define MEM_COPY_NO_DMA 0
 #define MEM_COPY_BY_DMA 1
 static DECLARE_WAIT_QUEUE_HEAD(dma_waitq);

 struct 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 volatile struct dma_regs *dma_regs;

 long dma_ioctl(struct file *file, unsigned int cmd, unsigned long dat)
 {
     int i;
     memset(src_addr,0xaa,BUFF_SIZE);  //从src开始的BUFF_SIZE空间每个字节都设置为0xaa
     memset(dst_addr,0x55,BUFF_SIZE);

     if(cmd == MEM_COPY_NO_DMA){
          for(i = ; i < BUFF_SIZE; i++){
               dst_addr[i] = src_addr[i];
          }
           if( == memcmp(src_addr,dst_addr,BUFF_SIZE)){
              printk("no dma transfer has finished!\n");
           }else{
              printk("no dma transfer failed!\n");
            }
     }else if(cmd == MEM_COPY_BY_DMA){

      dma_ok = ;

      dma_regs->disrc  = psrc_addr;
      dma_regs->didst  = pdst_addr;
      dma_regs->dcon   = (<<) | (<<) | (<<) | (BUFF_SIZE);

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

      /*等待DMA传输完成*/
      wait_event_interruptible(dma_waitq, dma_ok);

      if( == memcmp(src_addr,dst_addr,BUFF_SIZE)){
          printk("dma transfer has finished!\n");
      }else{
          printk("dma transfer failed!\n");
      }

     }
     return ;
 }

 ssize_t dma_read(struct file *file, char __user *buff, size_t size, loff_t *loff)
 {
      int err;
      err = copy_to_user(buff,dst_addr,size);
      if(err){
         return -;
      }
      return ;
 }

 static struct file_operations dma_fop = {
            .owner = THIS_MODULE,
            .read  = dma_read,
            .unlocked_ioctl = dma_ioctl,
 };

 irqreturn_t dma_irq(int irq, void *devid)
 {
      dma_ok = ;
      wake_up_interruptible(&dma_waitq);
      return IRQ_HANDLED;
 }

 static int dma_drv_init(void)
 {

      dma_regs = ioremap(DMA_BASE,sizeof(struct dma_regs));

      src_addr = dma_alloc_writecombine(NULL,BUFF_SIZE, &psrc_addr,GFP_KERNEL);
      dst_addr = dma_alloc_writecombine(NULL,BUFF_SIZE, &pdst_addr,GFP_KERNEL);

      if(request_irq(IRQ_DMA0,dma_irq,,"dma_irq",NULL)){
         printk("request dma irq failed!\n");
         free_irq(IRQ_DMA0,NULL);
         return -;
      }

      major = register_chrdev(, "dma-z", &dma_fop);
      dma_class = class_create(THIS_MODULE, "DMA");
      device_create(dma_class, NULL, MKDEV(major,), NULL, "dma0");

      return ;
 }

 static void dma_drv_exit(void)
 {
     device_destroy(dma_class,MKDEV(major,));
     class_destroy(dma_class);
     free_irq(IRQ_DMA0,NULL);
     dma_free_writecombine(NULL, BUFF_SIZE,src_addr,psrc_addr);
     dma_free_writecombine(NULL, BUFF_SIZE,dst_addr,pdst_addr);
     iounmap(dma_regs);
 }

 module_init(dma_drv_init);
 module_exit(dma_drv_exit);

 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("1653699780@qq.com");