--------------------- 
作者：kjfureone 
来源：CSDN 
原文：https://blog.csdn.net/KjfureOne/article/details/51842399 
版权声明：本文为博主原创文章，转载请附上博文链接！

 DMA概念
DMA的英文拼写是“Direct Memory Access”，汉语的意思就是直接内存访问。 
内存与内存（外设）交换数据不经过CPU。 
使用DMA的好处就是它不需要CPU的干预而直接服务外设，这样CPU就可以去处理别的事务，从而提高系统的效率，对于慢速设备，如UART，其作用只是降低CPU的使用率，但对于高速设备，如硬盘，它不只是降低CPU的使用率，而且能大大提高硬件设备的吞吐量。因为对于这种设备，CPU直接供应数据的速度太低。 因CPU只能一个总线周期最多存取一次总线，而且对于ARM，它不能把内存中A地址的值直接搬到B地址。它只能先把A地址的值搬到一个寄存器，然后再从这个寄存器搬到B地址。也就是说，对于ARM，要花费两个总线周期才能将A地址的值送到B地址。而DMA就不同了，一般系统中的DMA都有突发（Burst）传输的能力，在这种模式下，DMA能一次传输几个甚至几十个字节的数据，所以使用DMA能使设备的吞吐能力大为增强。

 

//不使用DMA的情况
char *src;
char *dst;
char len = 256;
for(int i=0;i<256;i++)
{
     *dst++=*src++; //需要cpu参与 
}
.....
//如果使用DMA
char *src;
char *dst;
char *len;

dma_src_regadr = src;
dma_dst_regadr = dst;
dma_trans_len = 8;
dma_addr_inc = 1; //1bit
dmaenable = 1;
......
//总结 使用DMA只是在初始化阶段配置DMAC的寄存器，之后内存到内存（外设）数据的传输和CPU无关了

对于任何类型的DMA传输，我们都需要规定数据的起始源和目标地址。对于外设DMA的情况来说，外设的FIFO可以作为数据源或者目标端。当外设作为源端时，某个存储器的位置(内部或外部)则成为目标端地址。当外设作为目标端，存储的位置(内部或者外部)则成为源端地址

 

API

void *
dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp)
{
    return __dma_alloc(dev, size, handle, gfp,
               pgprot_writecombine(pgprot_kernel));
}
函数参数：struct device *dev 设备
         size_t size 大小
         dma_addr_t *handle 物理地址
         gfp_t gfp 分配内存的标记
返回值：  虚拟地址

认识一个例子： 
卫东山给出的而一个操作S3C2440的一个例子

 

#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 <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>
#include <linux/dma-mapping.h>

#define MEM_CPY_NO_DMA  0
#define MEM_CPY_DMA     1

#define BUF_SIZE  (512*1024)

#define DMA0_BASE_ADDR  0x4B000000
#define DMA1_BASE_ADDR  0x4B000040
#define DMA2_BASE_ADDR  0x4B000080
#define DMA3_BASE_ADDR  0x4B0000C0

struct s3c_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 int major = 0;

static char *src;
static u32 src_phys;

static char *dst;
static u32 dst_phys;

static struct class *cls;

static volatile struct s3c_dma_regs *dma_regs;

static DECLARE_WAIT_QUEUE_HEAD(dma_waitq);
/* 中断事件标志, 中断服务程序将它置1，ioctl将它清0 */
static volatile int ev_dma = 0;

static int s3c_dma_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    int i;

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

    switch (cmd)
    {
        case MEM_CPY_NO_DMA :
        {
            for (i = 0; i < BUF_SIZE; i++)
                dst[i] = src[i];
            if (memcmp(src, dst, BUF_SIZE) == 0)
            {
                printk("MEM_CPY_NO_DMA OK\n");
            }
            else
            {
                printk("MEM_CPY_DMA ERROR\n");
            }
            break;
        }

        case MEM_CPY_DMA :
        {
            ev_dma = 0;

            /* 把源,目的,长度告诉DMA */
            dma_regs->disrc      = src_phys;        /* 源的物理地址 */
            dma_regs->disrcc     = (0<<1) | (0<<0); /* 源位于AHB总线, 源地址递增 */
            dma_regs->didst      = dst_phys;        /* 目的的物理地址 */
            dma_regs->didstc     = (0<<2) | (0<<1) | (0<<0); /* 目的位于AHB总线, 目的地址递增 */
            dma_regs->dcon       = (1<<30)|(1<<29)|(0<<28)|(1<<27)|(0<<23)|(0<<20)|(BUF_SIZE<<0);  /* 使能中断,单个传输,软件触发, */

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

            /* 如何知道DMA什么时候完成? */
            /* 休眠 */
            wait_event_interruptible(dma_waitq, ev_dma);

            if (memcmp(src, dst, BUF_SIZE) == 0)
            {
                printk("MEM_CPY_DMA OK\n");
            }
            else
            {
                printk("MEM_CPY_DMA ERROR\n");
            }

            break;
        }
    }

    return 0;
}

static struct file_operations dma_fops = {
    .owner  = THIS_MODULE,
    .ioctl  = s3c_dma_ioctl,
};

static irqreturn_t s3c_dma_irq(int irq, void *devid)
{
    /* 唤醒 */
    ev_dma = 1;
    wake_up_interruptible(&dma_waitq);   /* 唤醒休眠的进程 */
    return IRQ_HANDLED;
}

static int s3c_dma_init(void)
{
    if (request_irq(IRQ_DMA3, s3c_dma_irq, 0, "s3c_dma", 1))
    {
        printk("can't request_irq for DMA\n");
        return -EBUSY;
    }

    /* 分配SRC, DST对应的缓冲区 */
    src = dma_alloc_writecombine(NULL, BUF_SIZE, &src_phys, GFP_KERNEL);
    if (NULL == src)
    {
        printk("can't alloc buffer for src\n");
        free_irq(IRQ_DMA3, 1);
        return -ENOMEM;
    }

    dst = dma_alloc_writecombine(NULL, BUF_SIZE, &dst_phys, GFP_KERNEL);
    if (NULL == dst)
    {
        free_irq(IRQ_DMA3, 1);
        dma_free_writecombine(NULL, BUF_SIZE, src, src_phys);
        printk("can't alloc buffer for dst\n");
        return -ENOMEM;
    }

    major = register_chrdev(0, "s3c_dma", &dma_fops);

    /* 为了自动创建设备节点 */
    cls = class_create(THIS_MODULE, "s3c_dma");
    class_device_create(cls, NULL, MKDEV(major, 0), NULL, "dma"); /* /dev/dma */

    dma_regs = ioremap(DMA3_BASE_ADDR, sizeof(struct s3c_dma_regs));

    return 0;
}

static void s3c_dma_exit(void)
{
    iounmap(dma_regs);
    class_device_destroy(cls, MKDEV(major, 0));
    class_destroy(cls);
    unregister_chrdev(major, "s3c_dma");
    dma_free_writecombine(NULL, BUF_SIZE, src, src_phys);
    dma_free_writecombine(NULL, BUF_SIZE, dst, dst_phys);   
    free_irq(IRQ_DMA3, 1);
}

module_init(s3c_dma_init);
module_exit(s3c_dma_exit);

MODULE_LICENSE("GPL");

测试例子

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

/* ./dma_test nodma
 * ./dma_test dma
 */
#define MEM_CPY_NO_DMA  0
#define MEM_CPY_DMA     1

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


int main(int argc, char **argv)
{
    int fd;

    if (argc != 2)
    {
        print_usage(argv[0]);
        return -1;
    }

    fd = open("/dev/dma", O_RDWR);
    if (fd < 0)
    {
        printf("can't open /dev/dma\n");
        return -1;
    }

    if (strcmp(argv[1], "nodma") == 0)
    {
        while (1)
        {
            ioctl(fd, MEM_CPY_NO_DMA);
        }
    }
    else if (strcmp(argv[1], "dma") == 0)
    {
        while (1)
        {
            ioctl(fd, MEM_CPY_DMA);
        }
    }
    else
    {
        print_usage(argv[0]);
        return -1;
    }
    return 0;   
}

inux下DMA编程
dam的一致性问题
一致性问题 ：DAM针对内存区域的目标地址与cache缓存对象存在重叠区域，经过DMA后， 
cache中的值发生改变，但CPU不知道cache中的值改变了，它仍然认为Cache中的数据就是 
内存中的数据，以后访问cache映射的内存时，它仍然使用陈旧的cache数据，就造成Cache 
与内存之间的数据不一致。 
解决办法：直接禁止DMA目标地址范围内的Cache功能。

API

1.DMA缓冲区分配：DMA缓冲区的物理内存必须是连续的

//addr mask
int dma_set_mask(struct device *dev,u64 mask)

//DAM缓冲区分配API
static unsigned long dma_mem_alloc(int size);
//一致性DAM缓冲区分配
void * dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp);
void * dma_free_coherent(struct device *dev, size_t size, dma_addr_t *handle);
void * dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp);
void * dma_free_writecombine(struct device *dev, size_t size, dma_addr_t *handle);
//对于PCI
void * pci_alloc_consistent(struct pci_dev *pdev,size_t size,void cpu_addr);
//流式DMA映射

 

--------------------- 
作者：kjfureone 
来源：CSDN 
原文：https://blog.csdn.net/KjfureOne/article/details/51873630 
版权声明：本文为博主原创文章，转载请附上博文链接！