S3C2440 DMA驱动程序编写及测试（三十二）

嵌入式

S3C2440 DMA驱动程序编写及测试（三十二）

2019-07-13 01:13发布生成海报

站内文章 / 嵌入式Linux

15173 0

https://www.cnblogs.com/lifexy/p/7880737.html DMA（Direct Memory Access） 即直接存储访问，DMA传输方式无需CPU直接控制传输，通过硬件为RAM、I/O设备开辟一条直接传输数据的通路，能使CPU的效率大为提高。

学了这么多驱动，不难退出DMA的编写套路：

1）注册DMA中断，分配缓冲区
2）注册字符设备，并提供文件操作集合fops
-> 2.1）file_operations里设置DMA硬件相关操作，来启动DMA

由于我们是用字符设备的测试方式测试的，而本例子只是用两个地址之间的拷贝来演示DMA的作用，所以采用字符设备方式编写 1、驱动编写之前，先来讲如何分配释放缓冲区、DMA相关寄存器、使用DMA中断 1.1 在linux中，分配释放DMA缓冲区，常用以下几个函数 1）dma_alloc_writecombine()函数：

/* 该函数只禁止cache缓冲，保持写缓冲区，也就是对注册的物理区写入数据，也会更新到对应的虚拟缓冲区上 */
void *dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp)
//分配DMA缓存区
//返回值为：申请到的DMA缓冲区的虚拟地址，若为NULL，表示分配失败，需要释放，避免内存泄漏
//参数如下：
    //*dev：指针，这里填0，表示这个申请的缓冲区里没有内容
    //size：分配的地址大小（字节单位）
    //*handle：申请到的物理起始地址
    //gfp：分配出来的内存参数，标志定义在，常用标志如下：
        //GFP_ATOMIC 用来从中断处理和进程上下文之外的其他代码中分配内存，从不休眠
        //GFP_KERNEL 内核内存的正常分配，可能睡眠
        //GFP_USER   用来为用户空间页来分配内存；它可能睡眠

2）dma_alloc_coherent()函数：

/*该函数禁止cache缓存以及禁止写入缓冲区,从而使CPU读写的地址和DMA读写的地址内容一致*/
void * dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp);         
//分配DMA缓存区,返回值和参数和上面的函数一直

3）dma_free_writecombine()函数：

dma_free_writecombine(struct device *dev, size_t size, void *cpu_addr, dma_addr_t handle);   //释放DMA缓存，与dma_alloc_writecombine()对应
//size:释放长度
//cpu_addr:虚拟地址,
//handle:物理地址

4）dma_free_coherent()函数：

dma_free_coherent(struct device *dev, size_t size, void *cpu_addr, dma_addr_t handle)    //释放DMA缓存，与dma_alloc_coherent ()对应
//size:释放长度
//cpu_addr:虚拟地址,
//handle:物理地址

（PS：dma_free_writecombine()其实就是dma_free_coherent()，只不过是用了#define重命名而已。）而我们之前用的内存分配kmalloc()函数，是不能用在DMA上，因为分配出来的内存可能在物理地址上不连续的，因为DMA没有那么智能，不知道一会跑去那里，一会跑去那里。 1.2 那么2440开发板如何来启动DMA，先来看一下2440的DMA寄存器 （PS：实际这些DMA相关的寄存器，在linux内核中三星公司已封装好了，可以直接调用，不过非常麻烦，还不如直接设置寄存器，可以参考：https://blog.csdn.net/mirkerson/article/details/6632273） 1.2.1 2440支持4个通道的DMA控制器 其中4个DMA外设请求源，如下图所示（通过DCONn寄存器的[26:24]来设置）（PS：如果请求源是在系统总线上的，就只需要设置DCONn寄存器的[23]=0即可）

1.2.2 且每个通道都可以处理以下4种情况

1）源和目标都在系统总线上（比如：两个物理内存地址） 2）当目标在外设总线上时，源在系统总线上（外设指：串口，定时器，I2C，I2S等） 3）当目标在系统总线上时，源在外设总线上 4）源和目标都在外设总线上 1.2.3 DMA有两种工作模式（通过DCONn寄存器的[31]来设置） 查询模式： 当DMA请求XnXDREQ为低电平时，则DMA会一直传输数据，直到DMA请求拉高，才停止 握手模式： 当DMA请求XnXDREQ有下降沿触发时，则DMA会传输一次数据

1.2.4 DMA有两种传输模式（通过DCONn寄存器的[28]来设置） 单元传输： 指传输过程中，每执行一次，则读1次，写1次（如上图所示） 突发4传输： 指传输过程中，每执行一次，则读4次，然后写4次（如下图所示）

1.2.5 2440中的DMA寄存器如下图所示：

共有4个通道的寄存器，且每个通道的寄存器内容都一致，所以我们以DMA通道0为例： 1）DISR0 初始源寄存器（DMA Initial Source Register） bit[30:0]：存放DMA源的基地址（物理地址） 2）DISRCC0 初始源控制寄存器（DMA Initial Source Control Register） bit[1]：源位置选择， 0：源在系统总线上 1：源在外设总线上 bit[0]：源地址增加的选择，0：传输时，源地址自动增加 1：源地址固定 3）DIDST0 初始目标寄存器（DMA Initial Destination Register） bit[30:0]：设置DMA目的的基地址（物理地址） 4）DIDSTC0 初始目标控制寄存器（DMA Initial Destination Control Register） bit[2]：中断时间选择， 0：当DMA传输计数=0，立即发生中断 1：执行完自动加载后再发送中断（也就是计数为0，然后重新加载计数值） bit[1]：目的位置选择， 0：目的在系统总线上 1：目的在外设总线上 bit[0]：目的地址选择， 0：传输时目的地址自动增加 1：目的地址固定 5）DCON0 控制寄存器（DMA Control Register） bit[31]：工作模式选择，0：查询模式 1：握手模式（当源出于外设时，尽量选择握手模式） bit[30]：中断请求(DREQ)/中断回应(DACK)的同步时钟选择，0:PCLK同步 1:HCLK同步 （PS：如果有设备在HCLK上，该为应当设为1，比如：（SDRAM）内存数组，反之当这些设备在PCLK上，应当设为0，比如：ADC，IIS，I2C，UART） bit[29]：DMA传输计数中断使能/禁止 0：禁止中断 1：当传输完成后，产生中断 bit[28]：传输模式选择， 0：单元传输 1：突发4传输 bit[27]：传输服务模式 0：单服务模式，比如：有2个DMA请求，它们会被顺序执行一次（单元传输/突发4传输）后停止，然后知道下一次DMA请求，再重新开始另一次循环。 1：全服务模式，指DMA若有请求，则会占用DMA总线，一直传输，期间若有其他DMA请求，只有等待传输计数TC为0，才会执行其他DMA请求 bit[26:24]：DMA外设请求源选择（我们是用软件触发，没有用到） bit[23]：软件/硬件请求源选择， 0：软件请求 1：硬件请求（还需要设置[26:24]来选择外设源） bit[22]：重新加载开关选项，不需要，为0即可 bit[21:20]：传输数据大小，为了简单，一个字节（8位）即可 bit[19:0]：设置DMA传输的计数TC（BUF_SIZE 2k大小） 6）DSTAT0 状态寄存器（DMA Status Register） bit[21:20]：DMA状态，00:空闲，01：忙 bit[19:0]：传输计数当前值CURR_TC 为0表示传输结束 7）DCSRC0 当前源寄存器（DMA Current Source Register） bit[30:0]：存放DMA当前的源基地址 8）DCDST0 当前目标寄存器（Current Destination Register） bit[30:0]：存放DMA当前的目的基地址 9）DMASKTRIG0 触发屏蔽寄存器 bit[2]：停止STOP 该为写1，立刻停止DMA当前的传输 bit[1]：DMA通道使能 0:关闭DMA的通道0（禁止DMA请求） 1:开启DMA的通道0（开启DMA请求） bit[0]：软件请求触发 1：表示启动一次软件请求DMA，只有DCONn[23]=0和DMASKTRIGn[1]=1才有效，DMA传输时，该位自动清0 1.3 接下来就开始讲linux注册DMA中断 首先，DMA的每个通道只能只有一个源->目的，所以输入命令cat /proc/interrupts，找到DMA3中断未被使用

所以在linux中使用：

request_irq(IRQ_DMA3, s3c_dma_irq, NULL, "s3c_dma", 1);// s3c_dma_irq:中断服务函数,这里注册DMA3中断服务函数
//NULL:中断产生类型, 不需要,所以填NULL
//1:表示中断时,传入中断函数的参数,本节不需要所以填1,切记不能填0,否则注册失败

2、接下来，我们便来写一个DMA的字符设备驱动 步骤如下： 1）注册DMA中断，分配两个DMA缓冲区（源、目的） 2）注册字符设备，并提供文件操作集合fops 2.1）通过ioctl的cmd来判断是使用DMA启动两个地址之间的拷贝，还是直接两个地址之间的拷贝 2.2）若是DMA启动，则设置DMA的相关硬件，并启动DMA传输 2.1 所以，驱动代码如下所示：dma.c

#include 	
#include 	
#include 		
#include 		
#include 
#include 
#include 	
#include 
#include 			
#include 
#include 
#include 
#include 

#define MEM_CPY_NO_DMA 0    //复制内存不使用DMA
#define MEM_CPY_DMA    1	//复制内存使用DMA

#define BUF_SIZE (512*1024)	//大小512k

//DMA各通道的起始地址
#define DMA0_BASE_ADDR  0x4B000000
#define DMA1_BASE_ADDR  0x4B000040
#define DMA2_BASE_ADDR  0x4B000080
#define DMA3_BASE_ADDR  0x4B0000C0

//DMA通道寄存器
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;//结构体指针,加上volatile,免得被优化

//定义一个等待队列
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 ://复制内存不使用DMA
		{
			for(i = 0; i < BUF_SIZE; i++)
				dst[i] = src[i];//把源的数据拷到目的
			//拷贝完后，进行比较，等于0表示相等
			if (memcmp(src, dst, BUF_SIZE) == 0)
			{
				printk("MEM_CPY_NO_DMA OK
");
			}
			else
			{
				printk("MEM_CPY_NO_DMA ERROR
");
			}
			break;
		}
		case MEM_CPY_DMA ://复制内存使用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);        /* 同步信号,使能中断,单个传输,软件触发.数据传输大小为1字节, */

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

			/* 如何知道DMA什么时候完成?dma返回一个中断给cpu(现在执行的程序在cpu里) */
			/* 启动DMA后,如果ev_dma=0,就休眠, */
			wait_event_interruptible(dma_waitq, ev_dma);

			//拷贝完后，进行比较，等于0表示相等
			if (memcmp(src, dst, BUF_SIZE) == 0)
			{
				printk("MEM_CPY_DMA OK
");
			}
			else
			{
				printk("MEM_CPY_DMA ERROR
");
			}
		
			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)
{
	//注册一个中断，用来dma完成以后，返回一个中断给cpu
	if (request_irq(IRQ_DMA3, s3c_dma_irq, 0, "s3c_dma", 1))
	{
		printk("can't request_irq for DMA
");
		return -EBUSY;
	}

	/* 分配SRC源, DST目的对应的缓冲区           ，不能用kmalloc，分配的物理地址是不连续的 */
	src = dma_alloc_writecombine(NULL, BUF_SIZE, &src_phys, GFP_KERNEL);//返回虚拟地址,第三个参数返回物理地址
	if (NULL == src)
	{
		printk("can't alloc buffer for src
");
		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
");
		return -ENOMEM;
	}

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

	/* 为了自动创建设备节点，创建类class */
	cls = class_create(THIS_MODULE, "s3c_dma");
	/* 在这个类下面再创建一个设备，mdev就会根据信息来创建/dev/dma设备节点 */
	class_device_create(cls, NULL, MKDEV(major, 0), NULL, "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");

2.2 应用测试程序如下所示：

#include 
#include 
#include 
#include 
#include 
#include 

/* ./dma_test nodma
 * ./dma_test dma
 */
#define MEM_CPY_NO_DMA 0    //复制内存不使用DMA
#define MEM_CPY_DMA    1	//复制内存使用DMA

void print_usage(char *name)
{
	printf("Usage:
");
	printf("%s 
",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
");
		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;
}

3、测试运行 测试时，如果用默认的uboot启动，使用不了dma。要使用上一节的uboot，或其他uboot启动，才能使用dma。 输入./dma_test nodma &，使用CPU正常拷贝，可以发现占用了大部分资源，输入ls命令，要等好久才有反应：

输入./dma_test dma &，使用DMA拷贝，输入ls命令立马有反应，从而释放了CPU的压力：

S3C2440 DMA驱动程序编写及测试（三十二）

Ta的文章更多 >>

热门文章

S3C2440 DMA驱动程序编写及测试（三十二）

Ta的文章 更多 >>

热门文章

举报内容

检举类型

检举原因

检举说明(必填)

打开微信“扫一扫”，打开网页后点击屏幕右上角分享按钮

Ta的文章更多 >>