字符设备驱动高级（II）

老接口分析：

​	register_chrdev：
		__register_chrdev（major,0,256,name,fops）没有指定次设备号
			__register_chrdev_region
			cdev_alloc
			cdev_add

新接口：

	register_chrdev_region:
​		__register_chrdev_region ： 一次申请多个次设备号
	alloc_chrdev_region:
		可以动态申请次设备号

自动创建字符设备驱动文件

1. 使用mknod创建设备文件的缺点不方便，
2. 能否自动生成和删除设备文件

insmod时自动安装设备节点，卸载时自动删除

解决方案：udev机制(mdev)

1. 应用层的一个应用程序, 在busybox中实现
2. 内核驱动和应用层udev之间有一套信息传输机制（netlink协议）
3. 应用层要先默认启用udev，内核驱动中使用相应接口
4. 驱动注册和注销时信息会被传给udev， 由udev在应用层进行设备文件的创建和删除

内核驱动设备类相关函数：之前之所以没有自动创建是因为没有调用创建文件节点的API接口，以下两个函数实现的功能的功能发信息给上层udev

1. class_create
2. device_create

设备类相关代码分析：

1. sys文件系统简介
2. 设备类的概念
3. /sys/class/xxx中的文件作用

cd /sys/class/test : 就是我们自己创建的类， device_create创建的文件在test类下，里面还包括了创建的设备一些基本属性，比如dev : 250:12可以读出设备号，uevent : 可以读出主次设备号和device name这个就是用来发送给udev来创建/dev/test的

很多内核代码都是先定义一个指针，然后使用malloc申请内存，然后再填充。

class_create

​ __class_create

​ class_register

​ kset_register

kobject_uevent : 内核向上层发送uevent事件

device_create : 里面是可以传变参的，变参可以时fb0, fb1, fb2, fb3…

静态映射表建立过程分析：

1.建立映射表的三个关键部分

2. 映射表描述

3. 映射表建立函数， 该函数负责由1中的映射表来建立linux内核的页表映射关系

   1. kernel/arch/arm/mach-s5pv210/mach-smdkc110.c 的smdk110_map_io函数
   2. s5p_init_io
      1. iotable_init(s5p_iodesc)
      2. 结构体中
         1. 虚拟地址起始值
         2. 物理地址转换成页帧编号起始值
         3. 映射长度
   3. 结论：真正的内核移植时给定的静态映射表在arch/arm/plat-s5p/cpu.c中的s5p_desc, 本质是一个结构体数组，数组中每一个元素都是一个映射，这个映射描述了一段物理地址到虚拟地址之间的映射。这个结构体数组所记录的几个映射关系被iotable_init使用，该函数负责将这个结构体数组格式的表映射成MMU所能识别的页表映射关系，这样在开机后可以直接使用相对应的虚拟地址来访问对应的物理地址。
   4. 可以按照格式添加新的映射，在s5p_desc中添加

4. 开机时调用映射表建立函数

   1. 问题： 开机时（kernel启动时）smdk110_map_io如何被调用

      ​ start_kernel:

      ​ paging_init:

      ​ devicemaps_init:

      ​ if(mdsec->map_io)

      ​ mdesc->map_io()

动态映射结构体方式操作寄存器：

用结构体封装的方式来进行单次多寄存器的地址映射，来代替之前的分开映射

内核给我们提供的读写寄存器的接口：
我们之前使用的是直接引用某个地址，然后强转成指针使用，不具备很好的移植性

内核提供的寄存器读写接口：

1. wirtel 和readl
2. ioread32 和 iowrite32

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>
#include <linux/string.h>
#include <linux/io.h>
#include <linux/ioport.h>


int major;
char kbuf[100];

#define GPJ0CON S5PV210_GPJ0CON
#define GPJ0DAT S5PV210_GPJ0DAT

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

#define GPJ0CON_PA 0xe0200240
#define GPJ0DAT_PA 0xe0200244

#define S5P_GPJ0REG(x)       (x)
#define S5P_GPJ0CON         S5P_GPJ0REG(0)
#define S5P_GPJ0DAT         S5P_GPJ0REG(4)

unsigned int *pGPJ0CON;
unsigned int *pGPJ0DAT;

static void __iomem *baseaddr;

static int test_open(struct inode *inode, struct file *file)
{
	printk("test_open-----");
	return 0;
}

static int test_release(struct inode *inode, struct file *file)
{
	printk("test_release----------");
	return 0;
}


static ssize_t test_read( struct file *file, char *buf, size_t count, loff_t *ppos )
{
	int ret = -1;
	printk("test_read----------");
	//使用该函数将应用层传过来的ubuf中的内容拷贝到驱动空间的一个buf中
	ret = copy_to_user(buf, kbuf, count);
	if(ret)
	{
		printk("copy to user failed\n");
		return -EINVAL;
	}
	
	
	return 0;
}

//写函数的本质就是将应用层传递过来的数据先复制到内核中，然后以正确的方式写入硬件，完成操作
static ssize_t test_write( struct file *file, const char *buf, size_t count,
						  loff_t *ppos )
{
	int ret = -1;
	rGPJ0CON = 0x11111111;
	
	printk("test_write----------");
	
	memset(kbuf, 0, sizeof(kbuf));
	//使用该函数将应用层传过来的ubuf中的内容拷贝到驱动空间的一个buf中
	ret = copy_from_user(kbuf, buf, count);
	if(ret)
	{
		printk("copy from user failed\n");
		return -EINVAL;
	}

	if(kbuf[0] == '1')
	{
		rGPJ0DAT = ((0<<3) | (0<<4) | (0<<5));
	}
	else if(kbuf[0] == '0')
	{
		rGPJ0DAT = ((1<<3) | (1<<4) | (1<<5));
	}


	printk("copy from user successful\n");
	
	//从应用层过来的数据可以用来真正操控硬件
	return 0;
}

//定义一个file_operation结构体
static const struct file_operations test_fops = {
	.owner		= THIS_MODULE,  

	.open		= test_open,     //将来应用open打开这个设备实际调用
	.release	= test_release,  //就是这个close对应的函数
	.read       = test_read,
	.write      = test_write,
};

static int __init chrdev_init(void)
{
	//在这里注册file_operation结构体，在module_init宏调用的函数中去注册字符设备驱动
	printk("chrdev_init\n");
	if ((major = register_chrdev(0, "test", &test_fops)) < 0) {
		printk("adb: unable to get major %d\n", major);
		return -1;
	}
	printk("register_chrdev successful\n");

#if 0
	//使用动态映射的方法来操控寄存器
	if(!request_mem_region(GPJ0CON_PA, 4, "GPJ0CON"))
		return -EINVAL;
	
	if(!request_mem_region(GPJ0DAT_PA, 4, "GPJ0DAT"))
		return -EINVAL;
	
	pGPJ0CON = ioremap(GPJ0CON_PA, 4);
	pGPJ0DAT = ioremap(GPJ0DAT_PA, 4);
#endif

#if 0	
	*pGPJ0CON  = 0x11111111;
	*pGPJ0DAT  = ((0<<3) | (0<<4) | (0<<5));  //亮
#endif

	//测试1 : 通过动态去设置
#if 0
	writel(0x11111111, pGPJ0CON);
	writel(((0<<3) | (0<<4) | (0<<5)), pGPJ0DAT );
#endif

#if 0
	//通过静态地址去映射
	writel(0x11111111, GPJ0CON);
	writel(((0<<3) | (0<<4) | (0<<5)), GPJ0DAT );
#endif

	//测试3：通过动态地址映射设置
	if(!request_mem_region(GPJ0CON_PA, 8, "GPJ0BASE"))
	return -EINVAL;
	
	baseaddr = ioremap(GPJ0CON_PA, 8);
	
	writel(0x11111111, baseaddr + S5P_GPJ0CON);
	writel(((0<<3) | (0<<4) | (0<<5)), baseaddr + S5P_GPJ0DAT);
	return 0;
}

static void __exit chrdev_exit(void)
{
	unregister_chrdev(major, "test");
	//解除映射
	iounmap(pGPJ0CON);
	iounmap(pGPJ0DAT);
	
	release_mem_region(GPJ0CON_PA, 4);
	release_mem_region(GPJ0DAT_PA, 4);
	//在module_exit宏调用的函数中去注销字符设备驱动
	printk("chrdev_exit\n");
}

module_init(chrdev_init);
module_exit(chrdev_exit);

MODULE_LICENSE("GPL");