Linux DMA 内存拷贝与memcpy 速率比较

DMA理论：https://blog.csdn.net/yizhiniu_xuyw/article/details/113809126

驱动层代码：

#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h> 
#include <linux/cdev.h> 
#include <linux/dmaengine.h>
#include <linux/wait.h>
#include <linux/string.h>
#include <linux/dma-mapping.h>
#include <linux/slab.h>
#include <linux/jiffies.h>


#define DEBUG_PRINT printk

#define MEMCPY_NO_DMA 0
#define MEMCPY_DMA    1
#define BUFF_SIZE     (512*1024)

struct cdev my_cdev;
static int major_ret;
static struct class *pdma_class;
static struct device *pdma_device;

static dma_addr_t *src = NULL;
static dma_addr_t src_phys ;
static dma_addr_t *dst = NULL;
static dma_addr_t dst_phys ;

static volatile int dma_finished = 0;
static DECLARE_WAIT_QUEUE_HEAD(wq);


static void do_memcpy_no_dma(void)
{
    unsigned long t1 , t2,diff,msec;
    int i ;
    t1  = jiffies;
    for(i = 0;i < 1000;i++)
    {
        memcpy(dst,src,BUFF_SIZE);    
    }
    t2 = jiffies;

    diff = (long)t2 - (long)t1;
    msec = diff *1000/HZ;

    DEBUG_PRINT("used:%ld ms\n",msec);
    
}

static void tx_callback(void *dma_async_param)
{
    //DEBUG_PRINT("callback here\n");
    dma_finished = 1;
    wake_up_interruptible(&wq);
}

static int do_memcpy_with_dma(void)
{
    struct dma_chan *chan = NULL;
    dma_cap_mask_t mask;
    
    struct dma_async_tx_descriptor *tx = NULL;

    dma_cookie_t dma_cookie;
    
    memset(src,0xAA,BUFF_SIZE);
    memset(dst,0x55,BUFF_SIZE);    
    
    dma_cap_zero(mask);
    
    dma_cap_set(DMA_MEMCPY, mask);
    
    chan = dma_request_channel(mask, NULL, NULL);
    if(NULL == chan )
    {
        printk("err:%s:%d\n",__FILE__,__LINE__);        
        return -1;
    }
    

    
    
    unsigned long t1 , t2,diff,msec;
    int i ;
    t1  = jiffies;
    for(i=0;i<1000;i++)
    {
        dma_finished = 0;
        //tx = dmaengine_prep_dma_cyclic(chan, src_phys, BUFF_SIZE, 1024, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT|DMA_CTRL_ACK);
        tx = dmaengine_prep_dma_memcpy(chan, dst_phys, src_phys, BUFF_SIZE, DMA_PREP_INTERRUPT|DMA_CTRL_ACK);

        if(NULL == tx)
        {
            printk("err:%s:%d\n",__FILE__,__LINE__);    
            dma_release_channel(chan);
            return -1;
        }

        tx->callback = tx_callback;
        
        dma_cookie = dmaengine_submit(tx);
        if (dma_submit_error(dma_cookie))
        {
            printk("Failed to do DMA tx_submit");
        }
        
        dma_async_issue_pending(chan);    

        wait_event_interruptible(wq, dma_finished);
        
    }

    t2  = jiffies;
    diff = (long)t2 - (long)t1;
    msec = diff *1000/HZ;

    DEBUG_PRINT("used:%ld ms\n",msec);

    printk("ok !\n");
    if(memcmp(src, dst, BUFF_SIZE) == 0)
    {
        printk("memcpy succ !\n");
    }
    else
    {
        printk("memcpy failed !\n");
        int i = 0;
        for(i=0;i<8;i++)
        {
            printk("%x | %x\n",src[i],dst[i]);
        }
    }    

    
    dma_release_channel(chan);
    
}


static long dma_ioctl(struct file *file, unsigned int cmd, unsigned long data)
{
    switch (cmd)
    {
        case MEMCPY_NO_DMA:
            do_memcpy_no_dma();
            break;
        case MEMCPY_DMA:
            do_memcpy_with_dma();
            break;
    }
    return 0;
}


static const struct file_operations fops =
{
    .owner = THIS_MODULE,
    .unlocked_ioctl = dma_ioctl,
};
 
static int __init dma_init(void)
{
    dev_t devno = 0;
    
    alloc_chrdev_region(&devno, 0, 1, "my-dma");
    major_ret = MAJOR(devno);
    cdev_init(&my_cdev, &fops);
    cdev_add(&my_cdev, devno, 1);

    pdma_class = class_create(THIS_MODULE, "my-dma-class");

    pdma_device = device_create(pdma_class, NULL, MKDEV(major_ret,0), NULL, "my-dma");

    src = dma_alloc_coherent(NULL, BUFF_SIZE, &src_phys, GFP_KERNEL);

    if(NULL == src)
    {
        printk("err:%s:%d\n",__FILE__,__LINE__);
        goto _FAILED_ALLOC_SRC;
    }
    
    dst = dma_alloc_coherent(NULL, BUFF_SIZE, &dst_phys, GFP_KERNEL);    

    if(NULL == dst)
    {        
        printk("err:%s:%d\n",__FILE__,__LINE__);
        goto _FAILED_ALLOC_DST;
    }
    
    return 0;
_FAILED_ALLOC_DST:    
    
    dma_free_coherent(NULL, BUFF_SIZE, src, src_phys);
_FAILED_ALLOC_SRC:
    device_destroy(pdma_class, MKDEV(major_ret,0)); 
    class_destroy(pdma_class);    
    cdev_del(&my_cdev);
    unregister_chrdev_region(MKDEV(major_ret, 0), 1);

    return -1;
    
}
 
static void __exit dma_exit(void)
{    
    //printk("hello dma openwrt exit\n");
    device_destroy(pdma_class, MKDEV(major_ret,0));    
    class_destroy(pdma_class);

    dev_t devno = MKDEV(major_ret, 0);
    cdev_del(&my_cdev);
    unregister_chrdev_region(devno, 1);    

    dma_free_coherent(NULL, BUFF_SIZE, src, src_phys);
    dma_free_coherent(NULL, BUFF_SIZE, dst, dst_phys);    
    
}
 
module_init(dma_init);
module_exit(dma_exit);
 
MODULE_AUTHOR("hello world");
MODULE_DESCRIPTION("dma driver");
MODULE_LICENSE("GPL");
//MODULE_ALIAS("platform:" DRV_NAME);

应用层测试代码：

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>

#define MEMCPY_NO_DMA 0
#define MEMCPY_DMA    1


void print_usage(char *argv)
{
    printf("usge:\n");
    printf("%s <nodma|dma> \n");
}


int main(int argc ,char **argv)
{
    if(argc < 2)
    {
        print_usage(argv[0]);
        return -1;
    }

    int fd = open("/dev/my-dma",O_RDWR);

    if(fd < 0)
    {
        printf("open /dev/my-dma failed!\n");
        return -1;
    }

    if(strcmp("dma", argv[1]) == 0)
    {
        ioctl(fd,MEMCPY_DMA);
    }
    else
    {
        ioctl(fd,MEMCPY_NO_DMA);
    }

    close(fd);
    
}

测试结果：（H3 平台）
DMA 比 memcpy 快一倍！

疑问：

tx = dmaengine_prep_dma_memcpy(chan, dst_phys, src_phys, BUFF_SIZE, DMA_PREP_INTERRUPT|DMA_CTRL_ACK);

这里的 tx 没有看到 在哪 free 的，是否会内存泄漏？
答：不会，传输完成后由中断处理函数自动释放内存。

代码跟踪：

dmaengine_prep_dma_memcpy
  sun6i_dma_prep_dma_memcpy
    return vchan_tx_prep(&vchan->vc, &txd->vd, flags);
      list_add_tail(&vd->node, &vc->desc_allocated);

  先看 struct virt_dma_chan

struct virt_dma_chan {
    struct dma_chan    chan;
    struct tasklet_struct task;
    void (*desc_free)(struct virt_dma_desc *);

    spinlock_t lock;

    /* protected by vc.lock */
    struct list_head desc_allocated;
    struct list_head desc_submitted;
    struct list_head desc_issued;
    struct list_head desc_completed;

    struct virt_dma_desc *cyclic;
};

里面包含了void (*desc_free)(struct virt_dma_desc *); desc_free 函数。
来看一下desc_free 函数在哪被调用？

sun6i_dma_probe
    vchan->vc.desc_free = sun6i_dma_free_desc;
    vchan_init
      tasklet_init(&vc->task, vchan_complete, (unsigned long)vc)
        vchan_complete
          list_for_each_entry_safe(vd, _vd, &head, node) {
                dmaengine_desc_get_callback(&vd->tx, &cb);
        
                list_del(&vd->node);
                if (dmaengine_desc_test_reuse(&vd->tx))
                    list_add(&vd->node, &vc->desc_allocated);
                else
                    vc->desc_free(vd);             //最终调用 sun6i_dma_free_desc
                dmaengine_desc_callback_invoke(&cb, NULL);
            }

  ret = devm_request_irq(&pdev->dev, sdc->irq, sun6i_dma_interrupt, 0,
                   dev_name(&pdev->dev), sdc);
    sun6i_dma_interrupt                               // dma 中断处理函数
      vchan_cyclic_callback 
        tasklet_schedule(&vc->task)              //这里之后调用 vchan_complete


static void sun6i_dma_free_desc(struct virt_dma_desc *vd)
{
    struct sun6i_desc *txd = to_sun6i_desc(&vd->tx);
    struct sun6i_dma_dev *sdev = to_sun6i_dma_dev(vd->tx.chan->device);
    struct sun6i_dma_lli *v_lli, *v_next;
    dma_addr_t p_lli, p_next;

    if (unlikely(!txd))
        return;

    p_lli = txd->p_lli;
    v_lli = txd->v_lli;

    while (v_lli) {
        v_next = v_lli->v_lli_next;
        p_next = v_lli->p_lli_next;

        dma_pool_free(sdev->pool, v_lli, p_lli);

        v_lli = v_next;
        p_lli = p_next;
    }

    kfree(txd);    //释放内存
}