字符设备驱动模型

在linux系统中，驱动程序通常采用内核模块的程序结构来进行编码。因此，编译/安装一个驱动程序，其实质就是编译/安装一个内核模块。

1.字符设备文件

通过字符设备文件，应用程序可以使用相应的字符设备驱动程序来控制字符设备。创建字符设备文件的方法一般有两种：

 * 使用mknod命令 mknod /dev/文件名 c 主设备号 次设备号（c代表是字符设备文件）

 * 使用函数在驱动程序中创建

应用程序通过文件名找到字符设备文件，字符设备文件通过主设备号找到对应的设备驱动程序。

开发板内 cat /proc/devices可查看主设备号，次设备号一般取值0-255

2.字符设备驱动模型

1.1设备描述结构

在任何一种驱动模型中，设备都会用内核中的一种结构来描述。我们的字符设备在内核中使用struct cdev来描述

struct cdev    
struct kobject kobj;
    struct module *owner;
    const struct file_operations *ops; // 设备操作集
    struct list_head list;
    dev_t dev; // 设备号
    unsigned int count; // 设备数
};

设备号

ls -l /dev/ 查看设备号，第一个字母区分是字符设备文件

主设备号：如字符设备文件与字符设备驱动通过主设备号对应

次设备号：如一个串口驱动，有三个串口，每个串口都会对应一个设备文件，他们的主设备号一样，次设备号不同

设备号-操作

linux内核中使用dev_t类型来定义设备号，dev_t这种类型的实质是32位的unsigned int，其中高12位为主设备号，低20位为次设备号

dev_t dev  =  MKDEV(主设备号,次设备号);

主设备号 = MAJOR(dev_t dev);

次设备号 = MINOR(dev_t dev);

设备号-分配

静态申请

开发者自己申请一个数字作为主设备号，然后通过函数register_chrdev_region向内核申请使用。缺点：如果申请使用的设备号已经被内核中的其他驱动使用，则申请失败

动态分配

使用alloc_chrdev_region由内核分配一个可用的主设备号。

设备号-注销

驱动退出时，使用unregister_chrdev_region函数释放这些设备号

操作函数集

Struct file_operations是一个函数指针的集合，定义能在设备上进行的操作。结构中的函数指针指向驱动中的函数，这些函数实现一个针对设备的操作，罪域不支持的操作则设置函数指针为NULL。例如

struct file_operations dev_fops = {
    .llseek = NULL,
    .read = dev_read,
    .write = dev_write,
    .ioctl = dev_ioctl,
    .open = dev_open,
    .release = dev_release,
};

1.2驱动初始化

描述结构-分配

静态分配:：struct cdev mdev;

动态分配:：struct cdev *pdev = cdev_alloc();

描述结构-初始化

cdev_init(struct cdev *cdev, const struct file_operations *fops);
参 数 ：
cdev:待初始化的的cdev 结构
fops:设备对应的操作函数集

描述结构-注册

cdev_add(struct cdev *p, dev_t dev, unsigned count);
参 数 ：
p:     待添加到内核的字符设备结构
dev:   设备号
count: 该类设备的设备个数

1.3实现设备操作

设备操作原型

int (*open)(struct inode *, struct file *);                                打开设备，响应open系统
int (*release)(struct inode *, struct file *);                             关闭设备，响应close系统调用
loff_t (*llseek) (struct file *, loff_t, int);                             重定位读写指针，响应lseek系统调用
ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);           从设备读取数据，响应read系统调用
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);   向设备写入数据，响应write系统调

struct file

在linux系统中，每一个打开的文件，在内核中都会关联一个struct file，它由内核在打开文件时创建，在文件关闭后释放。

重要成员

loff_t f_pos;                  /* 文件读写指针 */
struct file_operations *f_op;  /* 该文件所对应的操作 */

struct inode
每一个存在于文件系统里面的文件都会关联一个inode结构，该结构主要用来记录文件物理上的信息。因此，它和代表打开文件的file结构是不同的。一个文件没有被打开时不会关联file结构，但是却会关联一个inode结构。

重要成员：dev_t i_rdev 设备号

设备操作-open

open驱动方法是驱动程序用来为以后的操作完成初始化准备工作的。在大部分驱动程序中，open完成以下工作：1.标明次设备号 2.启动设备

设备操作-release

release方法的作用正好与open相反 。这个设备方法有时也成为close，它的作用是关闭设备。

设备操作-read

read设备方法通常完成两件事情：

 * 从设备中读取数据（属于硬件访问类操作）

 * 将读到的数据返回给应用程序

ssize_t (*read)(struct file *filp, char __user *buff, size_t count, loff_t *offp)
参数分析：
filp： 与字符设备文件关联的file结构指针，由由内核创 建。
buff： 从设备读取到的数据，需要保存到的位置，由read系统调用提供该参数。
count：请求传输的数据量，由read 系统调用提供该参数。
offp： 文件的读写位置，由内核从file 结构中取出后，传递进来。

buff参数是 来源于用户空间的指针，这类指针都不能被内核代码直接引用，必须使用专门的函数

int copy_from_user(void *to, const void __user *from, int n)
int copy_to_user(void __user *to, const void *from, int n)

设备操作-write
write方法通常完成2件事情：

 * 从应用程序提供的地址中取出数据

 * 将数据写入设备（属于硬件访问类操作）

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *)

参数类似于read

1.4驱动注销

当我们从内核中卸载驱动程序的时候，需要使用cdev_del函数来完成字符设备的注销。

2.自己动手写驱动

/* memdev.c */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

struct cdev mdev; /* 静态分配设备描述结构 */
dev_t devnum; /* 设备号 */
int dev1_regs[5];
int dev2_regs[5];

loff_t mem_lseek(struct file *file, loff_t offset, int whence)
{
	loff_t new_pos = 0;
	switch (whence) 
	{
		case SEEK_SET:
			new_pos = 0+offset;
			break;
		case SEEK_CUR:
			new_pos = file->f_pos+offset;
			break;
		case SEEK_END:
			new_pos = 5*sizeof(int)+offset;
			break;
	}
	file->f_pos = new_pos;
	return new_pos;
}

ssize_t mem_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
	int *reg_base = file->private_data;
	copy_to_user(buf, reg_base+(*ppos), size);
	file->f_pos += size;
	return size;
}

ssize_t mem_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
{
	int *reg_base = file->private_data;
	copy_from_user(reg_base+(*ppos), buf, size);
	file->f_pos += size;
	return size;
}

int mem_open(struct inode *node, struct file *file)
{
	int num = MINOR(node->i_rdev); /* 次设备号 */
	if(num == 0)
	{
		file->private_data = dev1_regs;
	}
	if(num == 1)
	{
		file->private_data = dev2_regs;
	}
	return 0;
}

int mem_close(struct inode *node, struct file *filp)
{
	return 0;
}

struct file_operations memfops = 
{
	.llseek = mem_lseek,
	.read = mem_read,
	.write = mem_write,
	.open = mem_open,
	.release = mem_close
};

int memdev_init()
{
	cdev_init(&mdev, &memfops); /* 描述结构-初始化 */
	alloc_chrdev_region(&devnum, 0, 2, "memdev"); /* 动态分配设备号 */
	cdev_add(&mdev, devnum, 2); /* 描述结构-注册 */
	return 0;
}

void memdev_exit()
{
	cdev_del(&mdev); /* 驱动注销 */
	unregister_chrdev_region(devnum, 2); /* 取消设备号 */
}

MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(memdev_exit);

# Makefile

obj-m := memdev.o
KDIR := /root/linux-ok6410
all:
	make -C $(KDIR) M=$(PWD) modules CROSS_COMPILE=arm-linux- ARCH=arm
clean:
	rm -f *.ko *.o *.mod.o *.mod.c *.symvers *.bak *.order

/* write-mem.c */

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

int main()
{
	int fd = 0;
	int src = 2013;
	
	/*打开设备文件*/
	fd = open("/dev/memdev0",O_RDWR);
	
	/*写入数据*/
	write(fd, &src, sizeof(int));
	
	/*关闭设备*/
	close(fd);
	
	return 0;	

}

/* read_mem.c */

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

int main()
{
	int fd = 0;
	int dst = 0;
	
	/*打开设备文件*/
	fd = open("/dev/memdev0",O_RDWR);
	
	/*写入数据*/
	read(fd, &dst, sizeof(int));
	
	printf("dst is %d\n",dst);
	
	/*关闭设备*/
	close(fd);
	
	return 0;	

}

[root@localhost lesson]# arm-linux-gcc -static write-mem.c -o write-mem
[root@localhost lesson]# arm-linux-gcc -static read-mem.c -o read-mem
[root@localhost lesson]# cp write-mem /root/rootfs/
[root@localhost lesson]# cp read-mem /root/rootfs/

# cat /proc/devices 查看主设备号为252
# mknod /dev/memdev0 c 252 0
# ls
bin        lib        mnt        read-mem   tmp        write-mem
dev        linuxrc    mylist.ko  sbin       usr
etc        memdev.ko  proc       sys        var
# ./write-mem 
# ./read-mem 
dst is 2013