5.2.17.动态映射操作LED request_mem_region 和 ioremap ；iounmap 解除映射 和 release_mem_region 释放申请的内存

5.2.17.动态映射操作LED
5.2.17.1、如何建立动态映射
(1)request_mem_region，向内核申请（报告）需要映射的内存资源。
(2)ioremap，真正用来实现映射，传给他物理地址他给你映射返回一个虚拟地址
5.2.17.2、如何销毁动态映射
(1)iounmap    解除映射
(2)release_mem_region 释放申请的内存
注意：映射建立时，是要先申请再映射；然后使用；使用完要解除映射时要先解除映射再释放申请的内存。

1.request_mem_region向内核申请（报告）需要映射的内存资源。
 request_mem_region(start,n,name)


传参
start ： 起始的  物理地址 真实物理地址
n: 占多少个字节
name ： 这段内存的名字

(2)ioremap真正用来实现映射，传给他物理地址他给你映射返回一个虚拟地址

void __iomem *ioremap(phys_addr_t offset, unsigned long size)

传参
phys_addr_t offset ： 起始的  物理地址 真实物理地址
unsigned long size: 占多少个字节

返回值
void __iomem *iorema ：返回一个指针，表示映射返回的 虚拟地址

5.2.17.3、代码实践
(1)2个寄存器分开独立映射

 1. 驱动文件 module_test.c  只在 驱动文件：装载和卸载函数 里编写代码测试，就不在app.c里编写代码了

#include <linux/module.h>		// module_init  module_exit
#include <linux/init.h>			// __init   __exit
#include <linux/fs.h>
#include <asm/uaccess.h>      //copy_from_user
#include <linux/errno.h>  // 错误码
#include <mach/regs-gpio.h>//arch/arm/mach-s5pv210/include/mach/regs-gpio.h  这两个顺序不能放错，c语言基础
#include <mach/gpio-bank.h> //arch/arm/mach-s5pv210/include/mach/gpio-bank.h
#include <linux/string.h>//包含 内核的 memset  、strcmp
#include <linux/io.h>  //ioremap
#include <linux/ioport.h>  //request_mem_region



#define MYMAJOR 200  /* 定义 register_chrdev 注册设备的 主设备号 */

#define MYNAME  "test_char" /* 定义 register_chrdev 注册设备的 设备名字 */



#define GPJ0CON	  S5PV210_GPJ0CON	   // FD500240 虚拟地址	
#define GPJ0DAT	  S5PV210_GPJ0DAT	   // FD500244


#define rGPJ0CON	*((volatile unsigned int *)GPJ0CON)
#define rGPJ0DAT	*((volatile unsigned int *)GPJ0DAT)


/*********动态内存*****************************/

#define  GPJ0CON_PA	   0xE0200240          // 寄存器真实物理 地址
#define  GPJ0DAT_PA	   0xE0200244	   // 

unsigned int *pGPJOCON;  // ioremap 返回的 虚拟地址
unsigned int *pGPJODAT;

/*********动态内存end*****************************/


int mymajor; /* 定义 register_chrdev 注册设备号*/

char kbuf[100];/* 内核空间的 buf*/





/* NOTE  自己定义函数指针  test_chrdev_open  */
static int test_chrdev_open(struct inode *inode, struct file *file)
{
	/* 这个函数中真正应该 放置 打开这个硬件设备的 操作代码 ,我们先 printk 代替一下 */
	printk(KERN_INFO "test_chrdev_open module_test.c->test_chrdev_open \n");  
	
	/* 在应用app.c 执行open 时，就会执行 LED */
	rGPJ0CON = 0x11111111;
	//rGPJ0DAT = ((0<<3)|(0<<4)|(0<<5));  //LED亮
	
	return 0;

} /* test_chrdev_open() */




/* NOTE  自己定义函数指针 test_chrdev_release ,   release对应的就是 close  */
static int test_chrdev_release(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "test_chrdev_release module_test.c->test_chrdev_release \n");


		/* 在应用app.c 执行close 时，就会执行 LED灭 */
	rGPJ0DAT = ((1<<3)|(1<<4)|(1<<5)); //LED灭
	return 0;
}


static ssize_t test_chrdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *ppos)
{
	int ret = -1;
	
	printk(KERN_INFO "test_chrdev_release module_test.c->test_chrdev_read \n");
	
	/* 从内核 的 kbuf， 复制到用户的 ubuf  */
	ret = copy_to_user(ubuf,kbuf,size);    /* 成功后 就会拷贝到用户 ubuf */
	if(ret)  /* 如果 不成功复制则返回尚未成功复制剩下的字节数, 这里 就不做 纠错 机制了 */
	{
		printk(KERN_ERR "copy_to_user  fail \n"); 
		return -EINVAL;
	}
	printk(KERN_INFO "copy_to_user  OK!!! module_test.c->test_chrdev_write\n");
	
	
	
	
	return 0;
}

// 写函数的本质：将应用层 传递过来的数据先 复制到 内核中，然后将之正确的方式写入硬件完成的操作！（数据从应用层到驱动层的复制，）
// 内核有一个 虚拟地址空间，应用层有一个 虚拟地址空间
static ssize_t test_chrdev_write(struct file *file, const char __user *user_buf,
			size_t count, loff_t *ppos)
{
	int ret = -1;
	
	printk(KERN_INFO "test_chrdev_release module_test.c->test_chrdev_write\n");
	
	
	memset(kbuf,0,sizeof(kbuf)); /*清除kbuf */
	//使用改函数将: 应用层传过来的 ubuf 中的内容 拷贝到驱动空间中的 一个 kbuf 中
	/* 不能用memcpy(kbuf,buf); 因为 2 个 不在一个地址空间中，不能 比较 霍元甲和成龙 谁更厉害 ，不在一个年龄段*/
	ret = copy_from_user(kbuf,user_buf,count);    /*  成功后 就会 放到 kbuf 中 */
	if(ret)  /* 如果 不成功复制则返回尚未成功复制剩下的字节数, 这里 就不做 纠错 机制了 */
	{
		printk(KERN_ERR "copy_from_user fail \n"); 
		return -EINVAL;
	}
	printk(KERN_INFO "copy_from_user OK!!! module_test.c->test_chrdev_write\n");
	
	
	/* 真正的 驱动的 数据从 应用层 复制 到 驱动中后，我们就要根据这个数据去写硬件的操作，所以下面就应该操作硬件 */
	
	if(kbuf[0] == '1')
	{
		rGPJ0DAT = ((0<<3)|(0<<4)|(0<<5));  //LED亮
	}
	else if (kbuf[0]=='0')
	{
		rGPJ0DAT = ((1<<3)|(1<<4)|(1<<5)); //LED灭
	}

	return 0;
}


//自定义  file_operations 结构体 及其元素填充
/* NOTE  定义 register_chrdev 注册设备的 设备结构体 test_fops */
static const struct file_operations test_fops = {
	.owner		= THIS_MODULE,                    /* 所有的驱动 代码这一行不需要动，所有的都是这样，不是函数指针, 惯例直接写即可 */
	
	.open		= test_chrdev_open,  /* 将来应用 open 打开这个设备时实际 调用的就是这个 .open  函数指针*/
	.release	= test_chrdev_release,         /* release对应的就是 close    函数指针 */
	.write		= test_chrdev_write, 
	.read		= test_chrdev_read, 
};









// 模块安装函数
static int __init chrdev_init(void)
{	
	//int ret = -1;  /* 定义 register_chrdev 的返回值  */
	
	printk(KERN_INFO "chrdev_init helloworld init\n");
	
	
	// 在 module_init 宏 调用函数中去注册字符串 设备驱动
	mymajor = register_chrdev(0, "test_char", &test_fops);   /* major设成0，内核帮我们自动分配空白的设备号，分配的值会 做返回值 ，负数还是返回失败  */
	if(mymajor < 0)
	{
		printk(KERN_ERR "registe_chrdev fail \n");
		return -EINVAL;  /* 返回一个错误码 需要加 ’-‘负号*/
	}
	printk(KERN_INFO "自动分配 register_chrdev success....mymajor = %d \n",mymajor);
#if 0	
	/* 现在把 硬件操作放到这里，不用操作app.c 就可以操作硬件 */
	rGPJ0CON = 0x11111111;
	rGPJ0DAT = ((0<<3)|(0<<4)|(0<<5));  //LED亮
	
	printk(KERN_INFO "S5PV210_GPJ0CON = %p \n",S5PV210_GPJ0CON);
	printk(KERN_INFO "S5PV210_GPJ0DAT = %p \n",S5PV210_GPJ0DAT );
#endif 


	//使用动态映射 操作 寄存器
	if (!request_mem_region(GPJ0CON_PA, 4, "GPJ0CON_PA")) /* 向内核申请（报告）需要映射的内存资源。*/
		return -EINVAL;
		
		
	if (!request_mem_region(GPJ0DAT_PA, 4, "GPJ0CDAT_PA")) /* 向内核申请（报告）需要映射的内存资源。*/
		return -EINVAL;
		
	pGPJOCON = ioremap(GPJ0CON_PA, 4);//真正用来实现映射，传给他物理地址他给你映射返回一个虚拟地址
	pGPJODAT = ioremap(GPJ0DAT_PA, 4);//真正用来实现映射，传给他物理地址他给你映射返回一个虚拟地址
	
	*pGPJOCON = 0x11111111;
	*(pGPJOCON+1) = ((0<<3)|(0<<4)|(0<<5));  //LED亮	//*pGPJODAT = ((0<<3)|(0<<4)|(0<<5));  等同于 *(pGPJOCON+1) = ((0<<3)|(0<<4)|(0<<5)); 
	
	return 0;
}

// 模块卸载函数
static void __exit chrdev_exit(void)
{
	printk(KERN_INFO "chrdev_exit helloworld exit\n");
	
	// 在 module_exit宏 调用函数中去注销 字符串 设备驱动
	unregister_chrdev(mymajor, "test_char");  /* 这里不判断返回值 了，一般不会出错 */
#if 0		
	// 模块卸载 LED灭
	rGPJ0DAT = ((1<<3)|(1<<4)|(1<<5)); //LED灭
#endif

/**** 动态内存 释放   ****/
	*pGPJODAT = ((1<<3)|(1<<4)|(1<<5));   //LED灭
	iounmap(pGPJOCON);//解除映射时，传给他一个虚拟地址
	iounmap(pGPJODAT);//解除映射时，传给他一个虚拟地址
	
	release_mem_region(GPJ0CON_PA,4);//释放申请的内存 物理内存
	release_mem_region(GPJ0DAT_PA,4); //释放申请的内存
	
}


module_init(chrdev_init);
module_exit(chrdev_exit);

// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL");				// 描述模块的许可证
MODULE_AUTHOR("aston");				// 描述模块的作者
MODULE_DESCRIPTION("module test");	// 描述模块的介绍信息
MODULE_ALIAS("alias xxx");			// 描述模块的别名信息




/***********************************************************
如果 KERN_DEBUG 打印不出来，更改打印级别 或者  	
printk(KERN_DEBUG "chrdev_init helloworld init\n"); 

[root@liang_x210 driver_test]# cat /proc/sys/kernel/printk
7       4       1       7
[root@liang_x210 driver_test]# echo 8 > /proc/sys/kernel/printk
[root@liang_x210 driver_test]# cat /proc/sys/kernel/printk
8       4       1       7


************************************************************/

运行效果：

 

 
(2)2个寄存器在一起映射

 下个章节 ： 字符串高级阶段