（三）写一个完整的Linux驱动程序访问硬件并写应用程序进行测试
本系列导航
（一）初识Linux驱动
（二）Linux设备驱动的模块化编程
（三）写一个完整的Linux驱动程序访问硬件并写应用程序进行测试
（四）Linux设备驱动之多个同类设备共用一套驱动
（五）Linux设备驱动模型介绍
（六）Linux驱动子系统-I2C子系统
（七）Linux驱动子系统-SPI子系统
（八）Linux驱动子系统-PWM子系统
（九）Linux驱动子系统-Light子系统
（十）Linux驱动子系统-背光子系统
（十一）Linux驱动-触摸屏驱动
文章目录
- 1. Linux设备驱动的分类
- 2. Linux字符设备驱动框架
- 1). 设备号
- 2).字符设备操作集合 -- file_operations结构体
- 3). 字符设备的核心 -- cdev结构体
- 完整代码：hello.c
- 3. 实现文件操作集合
- 4. 写应用程序测试驱动 app.c
- 5. 画框图解释从应用层访问到驱动的过程
- 6. 自动创建设备节点
1. Linux设备驱动的分类
Linux内核驱动按照访问方式，可以分为以下三类：
字符设备驱动
字符设备是能够像访问字节流（类似文件）的方式一样被访问的设备，最终在文件系统中以设备文件的形式存在。
常见的字符设备：鼠标、键盘（IO设备），LCD、Camera（帧缓冲设备）等。
块设备驱动
块设备和字符设备的区别在于内核内部管理数据的方式，块设备的访问方式是按照块进行随机访问的。
常见的块设备：磁盘、flash等存储设备。
网络设备驱动
如网卡。
2. Linux字符设备驱动框架
1). 设备号
Linux内核中有很多的字符设备驱动，内核是如何区分它们的？ 每个字符设备都有一个唯一的标识 – 设备号
设备号的本质： 32位的无符号整数（dev_t）
设备号由两部分组成：
1 – 高12位称为主设备号，表明这个设备属于哪一类设备。
2 – 低20位成为次设备号，表明这个设备是同类设备中得具体哪一个。
设备号的申请方法：
第一种方法：静态定义并注册设备号
首先查看系统中有哪些设备号没有被分配给具体的设备，然后确定一个给当前的设备使用(cat /proc/devices可以看哪些号被占用了)，定义方法如下：
dev_t devno = 主设备号<<20 | 次设备号;
或者使用系统接口进行组合
int maj = xx, int min = xx;
dev_t devno = MKDEV(maj, min);
注册设备号 – 使申请的设备号生效并保证设备号在Linux内核中的唯一性
使用下面的接口：
int register_chrdev_region(dev_t from, unsigned count, const char *name)
参数：
from： 要注册的设备号
count：要注册多少个设备号，例如count = 3， 主设备号是255， 次设备号是0，那么将按照顺序依次注册三个设备号，分别是（主：255，从：0）、（255，1）、（255，2）
name：给要注册的设备命名，注册成功可以通过cat /proc/devices查看到
第二种方法：动态申请并注册设备号
此方法无需自己去确定哪个设备号可用，内核会查询哪个设备号没有被使用，然后分配给当前驱动进行注册，所以大部分驱动都采用这种注册方法，使驱动更加具有通用性（如果用静态注册，你选的设备号在当前设备上没有使用，但是当这个驱动移植到其他的设备上，可是其他设备上的某个驱动也使用的这个这个设备号，那么这个驱动就会注册失败）。
函数原型：
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
功能：申请一个或多个设备号并进行注册
参数：
dev：要注册的设备的设备号，输入参数，内核会寻找没有使用的设备号，然后填充到这个dev参数中。
baseminor：主设备号由内核来确定，次设备号由我们自己去确定，baseminor就对应要申请的设备号的次设备号。
count：可以一次申请多个设备号，count表示要申请的设备号的数量，当申请多个设备号时，他们的主设备号一致，次设备号会在baseminor的基础上依次加1。
name：要注册的设备的名字，注册成功可以通过cat /proc/devices查看到
最后，无论通过哪种方式注册的设备号，在卸载模块的时候都需要将注册的设备号资源进行释放：
void unregister_chrdev_region(dev_t from, unsigned count)
功能：释放一个已经注册的设备号
参数：
from：要释放的设备号
count：要一次释放的设备号的数量，当释放多个设备号时，系统会从from开始，依次加1作为新的设备号进行释放
2).字符设备操作集合 – file_operations结构体
设备驱动有各种各样的， 鼠标驱动需要获取用户的坐标以及单双击动作、LCD驱动需要写framebuffer等等，但是对上层开发调用这些驱动的人来说，他们可能不懂也不关心底层设备是如何工作的，为了简化上层应用的操作，驱动程序给上层提供了统一的操作接口–open、read、write等，这样，对应做应用开发的人来说，不管你是什么样的设备，我只需要去打开（open）你这个设备，然后进行读写等操作就可以操作这个设备了。那么，驱动程序如何实现这样统一的接口呢？需要实现下面的file_operations结构体：
struct file_operations {
struct module *owner;
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
int (*open) (struct inode *, struct file *);
int (*release) (struct inode *, struct file *);
...
}
这里只列出了几个最基本的成员：
owner：一般填充THIS_MODULE，表示这个驱动（模块）归自己所有（这个概念对于初学者可能难以理解，到后面我会继续说明）
open：打开设备驱动的函数指针
release：关闭设备驱动的函数指针，为了对每个设备驱动的访问保护，所以用户必须先打开设备，才能对设备进行读写等操作，操作完必须再关掉。
read：读设备驱动的函数指针（比如用户可以通过read接口读取按键驱动的按键状态等）
write：写设备驱动的函数指针（比如用户可以通过write接口写LCD驱动的framebuffer显存，将画面显示再lcd上）
用法：
定义一个属于自己设备的操作集合xxx_fops，xxx通常命名为设备的名字，例如lcd_fops, key_fops等。
struct file_operations xxx_fops ={
.owner = THIS_MODULE, //表示这个模块为自己所有
.open = xxx_open, //当用户调用open接口时，内核就会根据系统调用来调用对应的xxx_fops里面的xxx_open函数（xxx表示自己命名）
.release = xxx_close,
.read = xxx_read,
...
};
xxx_open、xxx_read等函数需要自己去实现，根据不同的驱动，去做不同的事情，从而达到了不同的驱动给上层提供统一的接口。
3). 字符设备的核心 – cdev结构体
分配、设置、注册cdev结构体
内核用cdev结构体来表示一个字符设备，所以每个字符设备驱动，都需要注册一个cdev结构体
struct cdev {
struct kobject kobj;
struct module *owner;
const struct file_operations *ops;
struct list_head list;
dev_t dev;
unsigned int count;
};
owner：一般填充THIS_MODULE，表示这个驱动（模块）归自己所有。
ops：对应这个设备的文件操作集合。
list：内核中有很多字符设备，每个设备对应一个自己的cdev，这些cdev通过这个list连在一起，当注册一个新的cdev时，就会通过cdev里面的list挂到内核的cdev链表上。
count：同类设备，可以一次注册多个cdev，但是他们的操作方法(fops)是一样的，比如usb设备，多个usb共用一套操作方法(fops)，但是每个usb都有自己的cdev。
分配（创建）cdev
struct cdev cdev；
设置（初始化）cdev，函数原型：
void cdev_init(struct cdev *, const struct file_operations *);
使用：
cdev_init(&cdev, &xxx_fops);
注册cdev结构体 – 添加一个字符设备(cdev)到系统中，函数原型：
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
@p: 要注册的cdev结构体。
@dev: 第一个设备号。
@count: 与此设备对应的连续的次设备号的数量 – 也就是要注册的cdev的数量，当count > 1时，会向系统注册多个cdev结构体，这些个cdev的fops是同一个，但是设备号的次设备号不同。
使用：
dev_add(&cdev, devno, 1);
有注册同样也有释放：
void cdev_del(struct cdev *p)
cdev_del(&cdev);
完整代码：hello.c
#include Makefile
KERNEL_PATH := /lib/modules/`uname -r`/build
PWD := $(shell pwd)
MODULE_NAME := hello
obj-m := $(MODULE_NAME).o
all:
$(MAKE) -C $(KERNEL_PATH) M=$(PWD)
clean:
rm -rf .*.cmd *.o *.mod.c *.order *.symvers *.tmp *.ko
测试：
make生成hello.ko
sudo insmod hello.ko //如过出现下面的log，
insmod: ERROR: could not insert module hello.ko: File exists
说明之前安装的没有卸载，需要先卸载然后再安装新的hello.ko。
lsmod | grep hello //如果打印出
说明模块没有问题，已经装载到系统中。
cat /proc/devices | grep hello //打印出
说明字符设备注册成功，255是注册的设备号，hello_device是注册的名字
最后别忘了卸载设备：sudo rmmod hello
有些同学会发现，明明卸载完了，但是在安装hello.ko的时候，提示：
ERROR: could not insert module hello.ko: Operation not permitted，那么就有可能是你的代码中设备号没有释放或者cdev没有释放，需要检查代码，修改后重启电脑再次安装即可。
3. 实现文件操作集合
#include 注意：
hello_read是将内核空间的数据copy到用户空间，hello_write是将用户数据copy到内核空间。用户空间(应用程序)和内核空间(驱动)数据的交互一定要用copy_to_user和copy_from_user。在read和write中还应该判断参数的合法性，比如传入的count是负数肯定是非法的，这一步也很重要，但是为了代码简洁就没加。这只是个框架，以后根据具体的驱动，再在函数体里填充具体的操作。
4. 写应用程序测试驱动 app.c
#include \n" , argv[0]);
return -1;
}
fd = open(argv[1], O_RDWR);
if (fd < 0)
{
perror("fail to open file");
return -1;
}
/* read data */
ret = read(fd, buf, sizeof(buf));
if (ret < 0)
{
printf("read err!");
return -1;
}
printf("buf = %s\n", buf);
/* write data */
ret = write(fd, buf, sizeof(buf));
if (ret < 0)
{
printf("read err!");
return -1;
}
close(fd);
return 0;
}
前面说过，用户访问字符设备驱动最终以字符设备文件的形式访问的，所以测试无非就是写一个应用程序，去open、read、write这个对应的设备节点，然后通过系统调用去访问驱动里的fops对应函数。
测试：
安装驱动：sudo insmod hello.ko
查看是否安装成功：cat /proc/devices 查找对应设备号和名字
创建设备节点和设备挂钩：sudo mknod /dev/hello c 255 0
当我们执行insmod后驱动就被安装到了内核中，但是我们要想访问驱动，必须先创建设备节点，通过设备节点来访问驱动，设备节点其实就是个文件，文件类型是c–字符设备文件。
/dev/hello：要创建的设备节点的名字及路径，一般都在/dev目录下创建。
c： 表示要创建一个字符设备。
255 0：主设备号和次设备号，表示创建的这个设备节点和对应设备号是(255，0)的这个设备关联，这样访问这个设备节点就可以通过设备号唯一确定一个设备了。
ls -l /dev/hello 可以看到这个设备节点的详细信息
crw-r--r-- 1 root root 255, 0 11月 26 19:40 /dev/hello
在命令行编译并执行应用程序进行测试：
gcc app.c -o app //生成用户空间的可执行程序app
./app /dev/hello //执行生成的可执行程序app，并传入参数
打印出了我们从驱动中读到的数据：
buf = Hello world!
然后执行dmesg，可以看到驱动的执行过程log：
[12752.386888] hello_init : 83
[12752.386891] success!
[12948.418264] hello_open : 21
[12948.418269] hello_read : 42
[12948.418286] hello_write : 58
[12948.418322] hello_close : 30
5. 画框图解释从应用层访问到驱动的过程
首先了解几个概念：
在写驱动的时候，实现open和close函数都有两个重要的参数struct inode和struct file结构体。
inode结构体：
struct inode {
unsigned int i_flags;
dev_t i_rdev;
...
}
一切皆文件，用户在文件系统下看到和操作的都是文件，但是这个文件对应在内核中是以一个inode结构体的形式存在的，当我们在文件系统下用touch或者mknod等命令创建文件时，内核都会创建唯一一个与之对应的inode结构体，保存这个文件的基本信息，当我们用户操作这个文件的时候，操作系统(内核)其实操作的是对应的inode结构体，会将我们的访问需求转换为对某个方法的调用，根据你打开的文件的类型进行不同的操作。
file结构体：
struct file {
struct inode *f_inode; /* cached value */
const struct file_operations *f_op;
unsigned int f_flags;
void *private_data;
...
}
操作系统将用户对某个文件的访问的需求转换为对某个方法的调用，内核根据你打开的文件的类型进行不同的操作，当用户打开某个文件时，实际上内核操作的是这个文件对应的inode结构体，同时内核会创建一个file结构体与之对应，这个file结构体里面保存了用户对这个文件（inode）结构体的操作信息（操作哪个文件：inode；以什么方式打开的，R/W/RW等：f_flags）。
总结：
也就是说，inode结构体和文件是一一对应的关系，每个文件在内核系统中都有一个唯一的inode结构体与之对应。只有在用户对文件进行打开操作的时候，内核空间才会创建一个file结构体，那么当多个用户对同一个文件进行打开时，就会创建多个file结构体，分别保存每个用户的操作，file结构体和文件是多对一的关系。
6. 自动创建设备节点
在实际的项目场景中，不可能每次开机让用户自己手动去创建设备节点然后装载，所以需要我们在代码中自动创建设备节点。在所有的初始化完成并成功之后加上如下：
struct class *hello_class;
hello_class = class_create(THIS_MODULE, "hello"); //hello：会在/sys/class这个目录下创建以hello为名的类，表示注册的这个设备属于hello这个类
device_create(hello_class, NULL, devno, NULL, "hello device"); //devno是对应注册的设备号, hello device就是内核自动在/dev目录下创建的设备节点的名字
同样，在卸载设备的时候，也要卸载这个设备节点：
device_destroy(hello_class, devno);
class_destroy(hello_class);
例;
struct class *hello_class;
static int hello_init(void)
{
/* 1. 生成并注册设备号 */
/* 2. 分配file_operations结构体 */
/* 3. 分配、设置、注册cdev结构体 */
...
hello_class = class_create(THIS_MODULE, "hello");
device_create(hello_class, NULL, devno, NULL, "hello device");
return 0;
}
static void hello_exit(void)
{
/* 释放资源 */
...
device_destroy(hello_class, devno);
class_destroy(hello_class);
}
编译安装完驱动后：
/dev$ ls -l hello_device
crw------- 1 root root 255, 0 2月 18 18:02 hello_device