二十二、DMA驱动

一、DMA简介

DMA（Direct Memory Access，直接内存存取），DMA传输将数据从一个地址空间复制到另外一个地址空间。传输过程由DMA控制器独立完成，它并没有拖延CPU的工作，可以让CPU效率提高。

既然DMA用于传输，那么就需要具备传输三要素：源、目的、长度。在传输完成后，DMA会通过产生中断的方式汇报。

由于DMA不使用页表机制，因此必须分配连续的物理内存，这一点需要我们注意，我们可以使用dma_alloc_writecombine()或dma_alloc_coherent()。dma_alloc_coherent()分配的内存不使用缓存，也不会使用写缓冲区，性能较差，dma_alloc_writecombine()不使用缓存，使用写缓冲区。

我们来看4412数据手册Direct Memory Access Controller一章。

可以看到4412上有3个DMA控制器，图中DMA是支持内存到内存的DMA控制器，DMA0和DMA1是同时支持外设到内存和内存到外设的DMA控制器。

那么为什么图中把DMA单独分类，DMA0和DMA1一类呢？

从方向上来说，DMA传输可以分为4类：memory到memory、memory到device、device到memory和device到device。从CPU的角度看，device都是slave，因此将这些有device参与的传输分为一类，称为Slave-DMA传输。而另一种memory到memory的传输，被称为Async TX。

读者若希望了解DMA传输更多信息，可参考：32.Linux-2440下的DMA驱动(详解)

二、DMA Engine介绍和DMA设备驱动步骤

DMA驱动框架定义在drivers/dma/dmaengine.c中，整体关系如下图。下面介绍DMA需要使用到的概念。

1. DMA Channels：如下图，一个DMA控制器同时传输的数据个数是有限的，这个限度称为channel

2. DMA Request Lines：DMA控制器和DMA传输设备之间需要有多条数据线线（称作DMA request，DRQ

3. 传输描述符：DMA传输属于异步传输，在传输前，slave驱动需要将本次传输的信息（如传输大小、方向等）提交给engine，engine返回描述符

编写DMA的设备驱动一般步骤如下：

1. 使用dma_request_channel()函数申请一个DMA通道

2. 使用dmaengine_slave_config()设置DMA通道参数

3. 使用dmaengine_prep_slave_single()或dmaengine_prep_slave_sg()或dmaengine_prep_dma_cyclic()获取传输描述符

4. 使用dmaengine_submit()将描述符提交到DMA等待队列

5. 使用dma_async_issue_pending()启动传输

6. 等待传输完成

步骤中所使用函数声明如下：

/* 1. 申请一个DMA通道 */
/* mask是使用dma_cap_sets()指定的DMA传输类型
 * filter_param是slave ID
 * eg:
 * dma_cap_mask_t mask;
 * dma_cap_zero(mask);
 * dma_cap_set(DMA_MEMCPY, mask);
 * dma_chan0 = dma_request_channel(mask, 0, NULL);
 */
struct dma_chan *dma_request_channel(dma_cap_mask_t *mask, dma_filter_fn fn, void *fn_param)

/* 2. 设置DMA通道参数 */
/* config用于设置DMA通道宽度、数据传输宽带、源和目的等信息 */
int dmaengine_slave_config(struct dma_chan *chan, struct dma_slave_config *config)

/* 3. 获取传输描述符 */
struct dma_async_tx_descriptor *dmaengine_prep_slave_single(
    struct dma_chan *chan, dma_addr_t buf, size_t len,
    enum dma_transfer_direction dir, unsigned long flags)

struct dma_async_tx_descriptor *dmaengine_prep_slave_sg(
    struct dma_chan *chan, struct scatterlist *sgl,    unsigned int sg_len,
    enum dma_transfer_direction dir, unsigned long flags)

struct dma_async_tx_descriptor *dmaengine_prep_dma_cyclic(
        struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
        size_t period_len, enum dma_transfer_direction dir)

/* 4. 将描述符提交到DMA等待队列 */
dma_cookie_t dmaengine_submit(struct dma_async_tx_descriptor *desc)

/* 5. 启动传输 */
void dma_async_issue_pending(struct dma_chan *chan)

其中，

1. 传输类型具体列为：

enum dma_transaction_type {
    DMA_MEMCPY,
    DMA_XOR,
    DMA_PQ,
    DMA_XOR_VAL,
    DMA_PQ_VAL,
    DMA_MEMSET,
    DMA_INTERRUPT,
    DMA_SG,
    DMA_PRIVATE,
    DMA_ASYNC_TX,
    DMA_SLAVE,
    DMA_CYCLIC,
    DMA_INTERLEAVE,
/* last transaction type for creation of the capabilities mask */
    DMA_TX_TYPE_END,
};

2. struct dma_slave_config含有DMA传输所需要的参数

struct dma_slave_config {
    enum dma_transfer_direction direction;      /* 传输方向，DMA_MEM_TO_MEM、DMA_MEM_TO_DEV等 */
    dma_addr_t src_addr;                        /* 源，读数据的地址 */
    dma_addr_t dst_addr;                        /* 目的，写数据的地址 */
    enum dma_slave_buswidth src_addr_width;     /* 最大可传输的burst size */
    enum dma_slave_buswidth dst_addr_width;
    u32 src_maxburst;
    u32 dst_maxburst;
    bool device_fc;                             /* 当device是flow controller时，需要设置为true */
};

3. struct dma_async_tx_descriptor是DMA的传输描述符

struct dma_async_tx_descriptor {
    dma_cookie_t cookie;                    /* 用于追踪本次传输 */
    enum dma_ctrl_flags flags;              /* DMA_CTRL_开头的标志， */
    dma_addr_t phys;
    struct dma_chan *chan;                  /* 对应的通道 */
    dma_cookie_t (*tx_submit)(struct dma_async_tx_descriptor *tx);    /* 控制器驱动提供的回调函数 */
    dma_async_tx_callback callback;         /* 传输完成的回调函数和参数 */
    void *callback_param;
#ifdef CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH
    struct dma_async_tx_descriptor *next;
    struct dma_async_tx_descriptor *parent;
    spinlock_t lock;
#endif
};

4. 对于struct scatterlist，读者可参考：Linux内核scatterlist API介绍

三、DMA设备驱动程序

源代码：

 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/sched.h>
 #include <linux/miscdevice.h>
 #include <linux/device.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/dmaengine.h>
 #include <linux/dma-mapping.h>

 #include <asm/io.h>
 #include <asm/uaccess.h>

 #include <linux/amba/pl330.h>
 #include <mach/dma.h>

 #define BUF_SIZE            512
 #define PL_NO_DMA            _IOW('M', 0x1, int)        /* magic num */
 #define PL_USE_DMA            _IOW('M', 0x2, int)

 static char *src = NULL;
 static char *dst = NULL;
 static dma_addr_t dma_src;
 static dma_addr_t dma_dst;
 static enum dma_ctrl_flags flags;
 static dma_cookie_t cookie;
 static struct dma_chan *chan0 = NULL;
 static struct dma_device *dev0 = NULL;
 static struct dma_async_tx_descriptor *tx0 = NULL;

 static void dma_callback(void *dma_async_param)
 {
     if ( == memcmp(src, dst, BUF_SIZE))
         printk("PL_USE_DMA succeed\n");
     else
         printk("PL_USE_DMA error\n");
 }

 static int pl330_dma_open(struct inode *inode, struct file *filp)
 {
     return ;
 }

 static long pl330_dma_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
     int i = ;

     memset(src, 0xAA, BUF_SIZE);
     memset(dst, 0xBB, BUF_SIZE);

     switch (cmd)
     {
     case PL_NO_DMA:
         for (i = ; i < BUF_SIZE; i++)
             dst[i] = src[i];

         if ( == memcmp(src, dst, BUF_SIZE))
             printk("PL_NO_DMA succeed\n");
         else
             printk("PL_NO_DMA error\n");
         break;

     case PL_USE_DMA:
         flags    = DMA_CTRL_ACK | DMA_PREP_INTERRUPT;
         dev0    = chan0->device;
         tx0        = dev0->device_prep_dma_memcpy(chan0, dma_dst, dma_src, BUF_SIZE, flags);
         if (!tx0)
             printk("device_prep_dma_memcpy error\n");

         tx0->callback        = dma_callback;
         tx0->callback_param    = NULL;
         cookie = tx0->tx_submit(tx0);
         if (dma_submit_error(cookie))
             printk("tx_submit error\n");

         dma_async_issue_pending(chan0);
         break;

     default:
         break;
     }

     return ;
 }

 static int pl330_dma_release(struct inode *inode, struct file *filp)
 {
     return ;
 }

 static struct file_operations pl330_dma_fops = {
     .open        = pl330_dma_open,
     .unlocked_ioctl = pl330_dma_ioctl,
     .release    = pl330_dma_release,
 };

 static struct miscdevice dma_misc = {
     .minor  = MISC_DYNAMIC_MINOR,
     .name   = "dma_test",
     .fops   = &pl330_dma_fops,
 };

 extern bool pl330_filter(struct dma_chan *chan, void *param);
 extern void msleep(unsigned int msecs);

 static int __init pl330_dma_init(void)
 {
     int ret = misc_register(&dma_misc);
     if (ret < ) {
         printk("misc_register error\n");
         return -EINVAL;
     }

     src = dma_alloc_writecombine(NULL, BUF_SIZE, &dma_src, GFP_KERNEL);
     dst = dma_alloc_writecombine(NULL, BUF_SIZE, &dma_dst, GFP_KERNEL);

     dma_cap_mask_t mask;
     dma_cap_zero(mask);
     dma_cap_set(DMA_SLAVE, mask);

     chan0 = dma_request_channel(mask, pl330_filter, NULL);
     if (NULL == chan0){
         msleep();
         chan0 = dma_request_channel(mask, NULL, NULL);
     }

     if (NULL == chan0)
         printk("dma_request_channel error\n");

     return ;
 }

 static void __exit pl330_dma_exit(void)
 {
     dma_release_channel(chan0);
     dma_free_writecombine(NULL, BUF_SIZE, src, dma_src);
     dma_free_writecombine(NULL, BUF_SIZE, dst, dma_dst);
     misc_deregister(&dma_misc);
 }

 module_init(pl330_dma_init);
 module_exit(pl330_dma_exit);

 MODULE_LICENSE("GPL");

Makefile：

 KERN_DIR = /work/itop4412/tools/linux-3.5

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

 clean:
     make -C $(KERN_DIR) M=`pwd` modules clean
     rm -rf modules.order

 obj-m    += pl330dma.o

测试文件：

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

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

 #define PL_NO_DMA            _IOW('M', 0x1, int)        /* magic num */
 #define PL_USE_DMA            _IOW('M', 0x2, int)

 int main(void)
 {
     int fd;
     fd = open("/dev/dma_test", O_RDWR);
     if (fd < ) {
         printf("can't open /dev/dma_test\n");
         return -;
     }

     ioctl(fd, PL_NO_DMA,    );
     sleep();

     ioctl(fd, PL_USE_DMA,    );
     sleep();

     return ;
 }

在测试之前，我们需要确定内核中是否配置了DMA框架：

Device Drivers --->
    [*] DMA Engine support  --->
        [*]   DMA Engine debugging
        <*>   DMA API Driver for PL330
        [*]   Async_tx: Offload support for the async_tx api 

测试：

在编译并在开发板上insmod后执行测试文件，可以看到设备驱动printk()输出。

下一章  二十三、uevnet机制和U盘自动挂载