zoukankan      html  css  js  c++  java

  • DMA驱动程序编写与测试

    1、驱动程序编写

    在本驱动程序中，我们打算在内存中开辟两个空间，分别作为源和目的。我们用两个方法将源中的数据写到目的中，一种方法是让cpu去做，另外一种发放是让DMA去做！好的，闲话少说，直接分析代码： 
    1. #include <linux/module.h>
    2. #include <linux/kernel.h>
    3. #include <linux/fs.h>
    4. #include <linux/init.h>
    5. #include <linux/delay.h>
    6. #include <linux/irq.h>
    7. #include <asm/uaccess.h>
    8. #include <asm/irq.h>
    9. #include <asm/io.h>
    10. #include <asm/arch/regs-gpio.h>
    11. #include <asm/hardware.h>
    12. #include <linux/poll.h>
    13. #include <linux/dma-mapping.h>
    15. #define MEM_CPY_NO_DMA  0
    16. #define MEM_CPY_DMA     1
    18. #define BUF_SIZE  (512*1024)
    20. #define DMA0_BASE_ADDR  0x4B000000
    21. #define DMA1_BASE_ADDR  0x4B000040
    22. #define DMA2_BASE_ADDR  0x4B000080
    23. #define DMA3_BASE_ADDR  0x4B0000C0
    25. struct s3c_dma_regs {
    26.  unsigned long disrc;
    27.  unsigned long disrcc;
    28.  unsigned long didst;
    29.  unsigned long didstc;
    30.  unsigned long dcon;
    31.  unsigned long dstat;
    32.  unsigned long dcsrc;
    33.  unsigned long dcdst;
    34.  unsigned long dmasktrig;
    35. };
    38. static int major = 0;
    40. static char *src;
    41. static u32 src_phys;
    43. static char *dst;
    44. static u32 dst_phys;
    46. static struct class *cls;
    48. static volatile struct s3c_dma_regs *dma_regs;
    50. static DECLARE_WAIT_QUEUE_HEAD(dma_waitq);
    51. /* 中断事件标志, 中断服务程序将它置1，ioctl将它清0 */
    52. static volatile int ev_dma = 0;
    54. static int s3c_dma_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
    55. {
    56.  int i;
    58.  memset(src, 0xAA, BUF_SIZE);
    59.  memset(dst, 0x55, BUF_SIZE);
    60.  
    61.  switch (cmd)
    62.  {
    63.                 //这是非DMA模式
    64.   case MEM_CPY_NO_DMA :
    65.   {
    66.    for (i = 0; i < BUF_SIZE; i++)
    67.     dst[i] = src[i];  //CPU直接将源拷贝到目的
    68.    if (memcmp(src, dst, BUF_SIZE) == 0)//这个函数见注释2
    69.    {
    70.     printk("MEM_CPY_NO_DMA OK
");
    71.    }
    72.    else
    73.    {
    74.     printk("MEM_CPY_DMA ERROR
");
    75.    }
    76.    break;
    77.   }
    79.                 //这是DMA模式
    80.   case MEM_CPY_DMA :
    81.   {
    82.    ev_dma = 0;
    83.    
    84.    /* 把源,目的,长度告诉DMA */
    85.                         /* 关于下面寄存器的具体情况，我们在注释3里面来详细讲一下 */
    86.    dma_regs->disrc      = src_phys;        /* 源的物理地址 */
    87.    dma_regs->disrcc     = (0<<1) | (0<<0); /* 源位于AHB总线, 源地址递增 */
    88.    dma_regs->didst      = dst_phys;        /* 目的的物理地址 */
    89.    dma_regs->didstc     = (0<<2) | (0<<1) | (0<<0); /* 目的位于AHB总线, 目的地址递增 */
    90.    dma_regs->dcon       = (1<<30)|(1<<29)|(0<<28)|(1<<27)|(0<<23)|(0<<20)|(BUF_SIZE<<0);  /* 使能中断,单个传输,软件触发, */
    92.    /* 启动DMA */
    93.    dma_regs->dmasktrig  = (1<<1) | (1<<0);
    95.    /* 如何知道DMA什么时候完成? */
    96.    /* 休眠 */
    97.    wait_event_interruptible(dma_waitq, ev_dma);
    99.    if (memcmp(src, dst, BUF_SIZE) == 0)
    100.    {
    101.     printk("MEM_CPY_DMA OK
");
    102.    }
    103.    else
    104.    {
    105.     printk("MEM_CPY_DMA ERROR
");
    106.    }
    107.    
    108.    break;
    109.   }
    110.  }
    112.  return 0;
    113. }
    115. static struct file_operations dma_fops = {
    116.  .owner  = THIS_MODULE,
    117.  .ioctl  = s3c_dma_ioctl,
    118. };
    120. static irqreturn_t s3c_dma_irq(int irq, void *devid)
    121. {
    122.  /* 唤醒 */
    123.  ev_dma = 1;
    124.     wake_up_interruptible(&dma_waitq);   /* 唤醒休眠的进程 */
    125.  return IRQ_HANDLED;
    126. }
    128. static int s3c_dma_init(void)
    129. {
    130.          /* 这里注册一个中断，当DMA数据传输完毕之后会发生此中断 */
    131.  if (request_irq(IRQ_DMA3, s3c_dma_irq, 0, "s3c_dma", 1))
    132.  {
    133.   printk("can't request_irq for DMA
");
    134.   return -EBUSY;
    135.  }
    136.  
    137.  /* 分配SRC, DST对应的缓冲区，关于此函数详见注释1 */
    138.  src = dma_alloc_writecombine(NULL, BUF_SIZE, &src_phys, GFP_KERNEL);//源
    139.  if (NULL == src)
    140.  {
    141.   printk("can't alloc buffer for src
");
    142.   free_irq(IRQ_DMA3, 1);
    143.   return -ENOMEM;
    144.  }
    145.  
    146.  dst = dma_alloc_writecombine(NULL, BUF_SIZE, &dst_phys, GFP_KERNEL);//目的
    147.  if (NULL == dst)
    148.  {
    149.   free_irq(IRQ_DMA3, 1);
    150.   dma_free_writecombine(NULL, BUF_SIZE, src, src_phys);
    151.   printk("can't alloc buffer for dst
");
    152.   return -ENOMEM;
    153.  }
    155.  major = register_chrdev(0, "s3c_dma", &dma_fops);//注册字符设备
    157.  /* 为了自动创建设备节点 */
    158.  cls = class_create(THIS_MODULE, "s3c_dma");
    159.  class_device_create(cls, NULL, MKDEV(major, 0), NULL, "dma"); /* /dev/dma */
    161.  dma_regs = ioremap(DMA3_BASE_ADDR, sizeof(struct s3c_dma_regs));//这边是将DMA控制寄存器映射到内核空间
    162.   
    163.  return 0;
    164. }
    166. static void s3c_dma_exit(void)
    167. {
    168.  iounmap(dma_regs);
    169.  class_device_destroy(cls, MKDEV(major, 0));
    170.  class_destroy(cls);
    171.  unregister_chrdev(major, "s3c_dma");
    172.  dma_free_writecombine(NULL, BUF_SIZE, src, src_phys);
    173.  dma_free_writecombine(NULL, BUF_SIZE, dst, dst_phys); 
    174.  free_irq(IRQ_DMA3, 1);
    175. }
    177. module_init(s3c_dma_init);
    178. module_exit(s3c_dma_exit);
    180. MODULE_LICENSE("GPL");
    注释1：
    之前我们知道在内核中开辟空间可以用kmalloc函数，这里却用了dma_alloc_writecombine，这是为什么呢？这是因为kmalloc开辟的空间其逻辑地址虽然是连续的，但是其实际的物理地址可能不是连续的。而DMA传输数据时，要求物理地址是连续的，dma_alloc_writecombine就满足这一点，这个函数的原型是：
    dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp)
    其中size代表开辟的空间的大小，handle代表开辟的空间的物理地址，返回值是开辟的空间的逻辑地址。
    1. int memcmp(const void *cs, const void *ct, size_t count)
    2. {
    3.  const unsigned char *su1, *su2;
    4.  int res = 0;
    6.  for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
    7.   if ((res = *su1 - *su2) != 0)
    8.    break;
    9.  return res;
    10. }
    我们看到这个函数的作用就是将第一个参数和第二个参数一位一位地比较，一旦不相等就返回，此时返回值为非零。比较的位数为第三个参数，如果前两个参数的前count为都是相等的，那么就会返回0

    注释3：
    我们先来解析一下上面几个寄存器：
     
     DISRCn bit Description  Initial State 
     S_ADDR [30:0] 源起始地址 0x00000000 
          
     DISRCCn bit Description Initial State 
     LOC  [1] 用于选择源的位置
     0：源在系统总线上
     1：源在外设总线上    		 0
     INC [0] 用于选择地址是否自动增加
     0：地址自动增加
     1：地址固定不变（此时即便是burst 模式下，传输过程中地址自动增加，  但是一旦传输完这一次数据，地址又变为初值）    		 0
       
     DIDSTn bit Description  Initial State 
     D_ADDR [30:0] 目的起始地址 0x00000000 
          
     DIDSTCn Bit Description Initial State 
     CHK_INT  [2] 当设置为自动加载时，用来选择中断发生的时间
     0：TC为0是产生中断
     1：自动加载完成的时候产生中断    		 0
     LOC [1] 用于选择目的设备的位置
     0：目的设备在系统总线上
     1：目的设备在外设总线上    		 0
     INC [0] 用于选择地址是否自动增加
     0：地址自动增加
     1：地址固定不变（此时即便是burst模式下，传输过程中地址自动增加，但是一旦传输完这一次数据，地址又重新变为初值）    		 0
       
     DCONn Bit Description Initial State 
     DMD_HS  [31]  选择为Demand模式或者是握手模式
     0：选择为Demand模式
     1：选择为握手模式
     这两种模式下都是当发生请求时，DMA控制器开始传输数据并且发出  应  答信号，不同点是握手模式下，当DMA控制器收到请求撤销信号，并且自  身发出应答撤销信号之后才能接收下一次请求。而在Demand模式下，并  不需要等待请求撤销信号，他只需要撤销自身的应答信号，然后等待下一  次的请求。
    		 0
     SYNC [30] 选择DREQ/DACK的同步
     0：DREQ and DACK 与PCLK同步
     1：DREQ and DACK 与HCLK同步
     因此当设备在AHB系统总线时，这一位必须为1，而当设备在APB系统  时，它应该被设为0。当设备位于外部系统时，应根据具体情况而定。    		 0
     INT [29] 是否使能中断
     0：禁止中断，用户需要查看状态寄存器来判断传输是否完成
     1：使能中断，所有的传输完成之后产生中断信号    		 0
     TSZ [28] 选择一个原子传输的大小
     0：单元传输（一次传输一个单元）
     1：突发传输（一次传输四个单元）    		 0
     SERVMODE [27] 选择是单服务模式还是整体服务模式
     0：单服务模式，当一次原子传输完成后需要等待下一个DMA请求
     1：整体服务模式，进行多次原子传输，知道传输计数值到达0    		 0
     HWSRCSEL [26:24] 为每一个DMA选择DMA请求源
     具体参见芯片手册    		 000
     SWHW_SEL [23] 选择DMA源为软件请求模式还是硬件请求模式
     0：软件请求模式，需要将寄存器DMASKTRIG的SW_TRIG置位
     1：硬件请求模式    		 0
     RELOAD [22] 是否自动重新装载
     0：自动重装，当目前的传输计数值变为0时，自动重装
     1：不自动重装
     RELOAD[1]被设置为0以防无意识地进行新的DMA传输    		 0
     DSZ [21:20]  要被传输的数据的大小
     00 = Byte    01 = Half word 
     10 = Word   11 = reserved     		 00
     TC [19:0] 初始化传输计数0000
       
    这里我们需要注意了，里面有三个东东要分清楚：
    DSZ   ：代表数据的大小
    TSZ   ：一次传输多少个数据
    TC     ：一共传输多少次
    所以实际传输的数据的大小为：DSZ * TSZ * TC   
    我们本程序里面由于设置为数据大小为1个字节，一次传输1个数据，所以传输次数直接就是实际数据的大小了。

     DSTATn Bit Description Initial State 
     STAT [21:20]  DMA控制器的状态
     00：DMA控制器已经准备好接收下一个DMA请求
     01：DMA控制器正在处理DMA请求    		 00
     CURR_TC   [19:0] 传输计数的当前值
     每个原子传输减1    		 
       
     DCSRCn Bit Description Initial State 
     CURR_SRC [30:0]  当前的源地址 0x00000000
       
     DCDSTn Bit Description Initial State 
     CURR_DST [30:0]  当前的目的地址 0x00000000
       
     DMASKTRIGn Bit Description Initial State 
     STOP [2] 停止DMA操作
     1：当前的原子传输完成之后，就停止DMA操作。如果当前没有原子  传输正在进行，就立即结束。    		 
     ON_OFF [1] DMA通道的开/闭
     0：DMA通道关闭
     1：DMA通道打开，并且处理DMA请求    		 
     SW_TRIG  [0] 1：在软件请求模式时触发DMA通道 
      
    OK！寄存器分析完毕，具体设置就不在写出来了！
    在此我们在来总结一下DMA的操作流程：
    我们首先设置DMA的工作方式，然后打开DMA通道，紧接着我们使CPU休眠，停止执行代码。与此同时，在DMA控制器的作用下，从源向目的拷贝数据。一旦数据拷贝完成，就会触发中断，在中断函数里面，唤醒进程，从而程序继续运行，打印相关信息。

    2、应用程序编写
    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/stat.h>
    4. #include <fcntl.h>
    5. #include <sys/ioctl.h>
    6. #include <string.h>
    8. /* ./dma_test nodma
    9.  * ./dma_test dma
    10.  */
    11. #define MEM_CPY_NO_DMA  0
    12. #define MEM_CPY_DMA     1
    14. void print_usage(char *name)
    15. {
    16.  printf("Usage:
");
    17.  printf("%s <nodma | dma>
", name);
    18. }
    21. int main(int argc, char **argv)
    22. {
    23.  int fd;
    24.  
    25.   if (argc != 2)
    26.  {
    27.   print_usage(argv[0]);
    28.   return -1;
    29.  }
    31.  fd = open("/dev/dma", O_RDWR);
    32.  if (fd < 0)
    33.  {
    34.   printf("can't open /dev/dma
");
    35.   return -1;
    36.  }
    38.  if (strcmp(argv[1], "nodma") == 0)
    39.  {
    40.   while (1)
    41.   {
    42.    ioctl(fd, MEM_CPY_NO_DMA);
    43.   }
    44.  }
    45.  else if (strcmp(argv[1], "dma") == 0)
    46.  {
    47.   while (1)
    48.   {
    49.    ioctl(fd, MEM_CPY_DMA);
    50.   }
    51.  }
    52.  else
    53.  {
    54.   print_usage(argv[0]);
    55.   return -1;
    56.  }
    57.  return 0;  
    58. }
    应用程序过于简单，不在分析！

    3、测试
    # insmod dma.ko      //加载驱动
    # cat /proc/interrupts //查看中断
               CPU0
     30:      52318         s3c  S3C2410 Timer Tick
     33:          0         s3c  s3c-mci
     34:          0         s3c  I2SSDI
     35:          0         s3c  I2SSDO
     36:          0         s3c  s3c_dma
     37:         12         s3c  s3c-mci
     42:          0         s3c  ohci_hcd:usb1
     43:          0         s3c  s3c2440-i2c
     51:       2725     s3c-ext  eth0
     60:          0     s3c-ext  s3c-mci
     70:         97   s3c-uart0  s3c2440-uart
     71:        100   s3c-uart0  s3c2440-uart
     83:          0           -  s3c2410-wdt
    Err:          0

    # ls /dev/dma     //查看设备
    /dev/dma

    # ./dmatest       //如此就会打印用法
    Usage:
    ./dmatest <nodma | dma>

    # ./dmatest dma     //以DMA方式拷贝，CPU可以做其他事情
    MEM_CPY_DMA OK
    MEM_CPY_DMA OK
    MEM_CPY_DMA OK
    MEM_CPY_DMA OK
    MEM_CPY_DMA OK
    MEM_CPY_DMA OK
    MEM_CPY_DMA OK

    # ./dmatest dma     //CPU拷贝，各种竞争CPU
    MEM_CPY_DMA OK
    MEM_CPY_DMA OK
    MEM_CPY_DMA OK
    MEM_CPY_DMA OK

     

     
     
  • 相关阅读:
    ubuntu16.04下笔记本自带摄像头编译运行PTAM
    ar的主流算法
    ubuntu下安装meshlab
    打开.py文件的方法
    Python_ip代理
    对书名的抓取
    JS动态增加删除UL节点LI及相关内容示例
    js遍历json
    js移除某一类的div
    工厂模式
  • 原文地址：https://www.cnblogs.com/superit/p/3907777.html
Copyright © 2011-2022 走看看