1、Linux驱动开发笔记（一）--Linux驱动分类及字符设备开发流程

Linux驱动开发笔记

1、Linux下驱动的分类

1.1、Linux下驱动主要分为三类，如下：

其中字符设备是Linux下驱动中最基本的一类设备驱动；

1.2、 Linux 应用程序对驱动程序的调用流程

在Linux中一切皆是文件，驱动加载成功以后会在“/dev”目录下生成一个相应的文件，应用程序通过对这个名为“/dev/xxx”的文件进行相应的操作即可实现对硬件的操作。如现在有个叫做/dev/led 的驱动文件，此文件是 led 灯的驱动文件。应用程序使用 open 函数来打开文件/dev/led，使用完成以后使用 close 函数关闭/dev/led 这个文件。open和 close 就是打开和关闭 led 驱动的函数，如果要点亮或关闭 led，那么就使用 write 函数来操作，也就是向此驱动写入数据，这个数据就是要关闭还是要打开 led 的控制参数。如果要获取led 灯的状态，就用 read 函数从驱动中读取相应的状态。

应用程序运行在用户空间，而 Linux 驱动属于内核的一部分，因此驱动运行于内核空间。

open、close、write 和 read 等这些函数是由 C 库提供的，在 Linux 系统中，系统调用作为 C 库的一部分。

open 函数调用流程

每一个系统调用，在驱动中都有与之对应的一个驱动函数，在 Linux 内核文件 include/linux/fs.h 中有个叫做 file_operations 的结构体，此结构体就是 Linux 内核驱动操作函数集合，内容如下所示：

1588 struct file_operations {
1589 struct module *owner;
1590 loff_t (*llseek) (struct file *, loff_t, int);
1591 ssize_t (*read) (struct file *, char __user *, size_t, loff_t 
	  *);
1592 ssize_t (*write) (struct file *, const char __user *, size_t,
	  loff_t *);
1593 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
1594 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
1595 int (*iterate) (struct file *, struct dir_context *);
1596 unsigned int (*poll) (struct file *, struct poll_table_struct 
	  *);
1597 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned
	  long);
1598 long (*compat_ioctl) (struct file *, unsigned int, unsigned
	  long);
1599 int (*mmap) (struct file *, struct vm_area_struct *);
1600 int (*mremap)(struct file *, struct vm_area_struct *);
1601 int (*open) (struct inode *, struct file *);
1602 int (*flush) (struct file *, fl_owner_t id);
1603 int (*release) (struct inode *, struct file *);
1604 int (*fsync) (struct file *, loff_t, loff_t, int datasync);
1605 int (*aio_fsync) (struct kiocb *, int datasync);
1606 int (*fasync) (int, struct file *, int);
1607 int (*lock) (struct file *, int, struct file_lock *);
1608 ssize_t (*sendpage) (struct file *, struct page *, int, size_t,
	  loff_t *, int);
1609 unsigned long (*get_unmapped_area)(struct file *, unsigned long,
	  unsigned long, unsigned long, unsigned long);
1610 int (*check_flags)(int);
1611 int (*flock) (struct file *, int, struct file_lock *);
1612 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *,
	  loff_t *, size_t, unsigned int);
1613 ssize_t (*splice_read)(struct file *, loff_t *, struct
	 pipe_inode_info *, size_t, unsigned int);
1614 int (*setlease)(struct file *, long, struct file_lock **, void
	 **);
1615 long (*fallocate)(struct file *file, int mode, loff_t offset,
1616 loff_t len);
1617 void (*show_fdinfo)(struct seq_file *m, struct file *f);
1618 #ifndef CONFIG_MMU
1619 unsigned (*mmap_capabilities)(struct file *);
1620 #endif
1621 };

file_operation 结构体中比较重要的、常用的函数：

第 1589 行，owner 拥有该结构体的模块的指针，一般设置为 THIS_MODULE。

第 1590 行，llseek 函数用于修改文件当前的读写位置。

第 1591 行，read 函数用于读取设备文件。

第 1592 行，write 函数用于向设备文件写入(发送)数据。

第 1596 行，poll 是个轮询函数，用于查询设备是否可以进行非阻塞的读写。

第 1597 行，unlocked_ioctl 函数提供对于设备的控制功能，与应用程序中的 ioctl 函数对应。

第 1598 行，compat_ioctl 函数与 unlocked_ioctl 函数功能一样，区别在于在 64 位系统上，32 位的应用程序调用将会使用此函数。在 32 位的系统上运行 32 位的应用程序调用的是unlocked_ioctl。

第 1599 行，mmap 函数用于将将设备的内存映射到进程空间中(也就是用户空间)，一般帧

缓冲设备会使用此函数，比如 LCD 驱动的显存，将帧缓冲(LCD 显存)映射到用户空间中以后应

用程序就可以直接操作显存了，这样就不用在用户空间和内核空间之间来回复制。

第 1601 行，open 函数用于打开设备文件。

第 1603 行，release 函数用于释放(关闭)设备文件，与应用程序中的 close 函数对应。

第 1604 行，fasync 函数用于刷新待处理的数据，用于将缓冲区中的数据刷新到磁盘中。

第 1605 行，aio_fsync 函数与 fasync 函数的功能类似，只是 aio_fsync 是异步刷新待处理的

数据。

字符驱动开发中常用的就是：open、release、write、read函数。

2、字符设备驱动开发步骤

2.1、驱动模块的加载和卸载

Linux驱动的两种运行方式：

①、将驱动编译进Linux内核中，当内核启动时就会自动运行驱动程序；

②、将驱动编译成模块（Linux下模块扩展名位.ko），在Linux内核启动以后使用“insmod”命令加载驱动模块。

在调试阶段一般将驱动编译成模块，有利于驱动代码的更新，不需要编译整个Linux代码，调试时只需要加载或者卸载驱动代码，不需要重启整个系统；当确定驱动功能完备后再编译进内核中。

模块加载和卸载函数：

module_init(xxx_init); //注册模块加载函数
module_exit(xxx_exit); //注册模块卸载函数

module_init() 函数用来向 Linux 内核注册一个模块加载函数，参数 xxx_init 就是需要注册的具体函数，当使用“insmod”命令加载驱动的时候，xxx_init 这个函数就会被调用。

module_exit() 函数用来向 Linux 内核注册一个模块卸载函数，参数 xxx_exit 就是需要注册的具体函数，当使用“rmmod”命令卸载具体驱动的时候 xxx_exit 函数就会被调用。

字符设备驱动模块加载和卸载模板:

1 /* 驱动入口函数 */
2 static int __init xxx_init(void) 
3 { 
4 	/* 入口函数具体内容 */
5 	return 0; 
6 }
7 
8 /* 驱动出口函数 */
9 static void __exit xxx_exit(void)
10 {
11 		/* 出口函数具体内容 */
12 }
13
14 /* 将上面两个函数指定为驱动的入口和出口函数 */
15 module_init(xxx_init);
16 module_exit(xxx_exit);

第 2 行，定义了个名为 xxx_init 的驱动入口函数，并且使用了“__init”来修饰。

第 9 行，定义了个名为 xxx_exit 的驱动出口函数，并且使用了“__exit”来修饰。

第 15 行，调用函数 module_init 来声明 xxx_init 为驱动入口函数，当加载驱动的时候 xxx_init函数就会被调用。

第16行，调用函数module_exit来声明xxx_exit为驱动出口函数，当卸载驱动的时候xxx_exit函数就会被调用。

加载驱动模块命令：

驱动编译完成以后扩展名为.ko；有两种命令可以加载驱动模块：insmod和 modprobe；

①、insmod是最简单的模块加载命令，此命令用于加载指定的.ko 模块，比如加载 drv.ko 这个驱动模块，命令如下：

insmod drv.ko

insmod命令的缺点：insmod 命令不能解决模块的依赖关系，比如 drv.ko 依赖 first.ko 这个模块，就必须先使用insmod 命令加载 first.ko 这个模块，然后再加载 drv.ko 这个模块。

②、而modprobe 就不会存在insmod的问题，modprobe 会分析模块的依赖关系，然后会将所有的依赖模块都加载到内核中，因此modprobe 命令相比 insmod 要智能一些。

modprobe 命令主要智能在提供了模块的依赖性分析、错误检查、错误报告等功能，推荐使用 modprobe 命令来加载驱动。modprobe 命令默认会去/lib/modules/目录中查找模块，如使用Linux kernel 4.4.15版本，modprobe就会再/lib/modules/4.1.15目录中查找相应的驱动模块，一般自己制作的根文件系统中是不会有这个目录的，所以需要自己手动创建。

③、驱动模块的卸载使用命令“rmmod”即可，比如要卸载 drv.ko，使用如下命令即可：

rmmod drv.ko

④、也可以使用“modprobe -r”命令卸载驱动，比如要卸载 drv.ko，命令如下：

modprobe -r drv.ko

使用 modprobe 命令可以卸载掉驱动模块所依赖的其他模块，前提是这些依赖模块已经没有被其他模块所使用，否则就不能使用 modprobe 来卸载驱动模块。所以对于模块的卸载，推荐使用 rmmod 命令。

2.2、字符设备注册与注销

对于字符设备驱动，驱动模块加载成功后需要注册字符设备，卸载后也需要注销掉字符设备。

字符设备的注册和注销函数原型：

static inline int register_chrdev(unsigned int major, const char *name,
								const struct file_operations *fops)
static inline void unregister_chrdev(unsigned int major, const char *name)

register_chrdev函数：

作用：用于注册字符设备，有三个参数；

major：主设备号，Linux 下每个设备都有一个设备号，设备号分为主设备号和次设备号两部分；

name：设备名字，指向一串字符串；

fops：结构体 file_operations 类型指针，指向设备的操作函数集合变量。

unregister_chrdev函数：

作用：用户注销字符设备，此函数有两个参数；

major：要注销的设备对应的主设备号；

name：要注销的设备对应的设备名。

字符设备注册和注销模板：

一般字符设备的注册在驱动模块的入口函数 xxx_init 中进行，字符设备的注销在驱动模块的出口函数 xxx_exit 中进行。

1 static struct file_operations test_fops; 
2
3 /* 驱动入口函数 */
4 static int __init xxx_init(void) 
5 {
6 	/* 入口函数具体内容 */
7 	  int retvalue = 0; 89 /* 注册字符设备驱动 */
10 	  retvalue = register_chrdev(200, "chrtest", &test_fops);
11 	  if(retvalue < 0)
	  {
12 		/* 字符设备注册失败,自行处理 */
13 	   }
14 	return 0;
15 }
16
17 /* 驱动出口函数 */
18 static void __exit xxx_exit(void)
19 {
20 	   /* 注销字符设备驱动 */
21 	   unregister_chrdev(200, "chrtest");
22 }
23
24 /* 将上面两个函数指定为驱动的入口和出口函数 */
25 module_init(xxx_init);
26 module_exit(xxx_exit);

第 1 行，定义了一个 file_operations 结构体变量 test_fops，test_fops 就是设备的操作函数集合，只是此时我们还没有初始化 test_fops 中的 open、release 等这些成员变量，所以这个操作函数集合还是空的；

第 10 行，调用函数 register_chrdev 注册字符设备，主设备号为 200，设备名字为“chrtest”，设备操作函数集合就是第 1 行定义的 test_fops。要注意的一点就是，选择没有被使用的主设备号，输入命令“cat /proc/devices”可以查看当前已经被使用掉的设备号；

第 21 行，调用函数 unregister_chrdev 注销主设备号为 200 的这个设备。

2.3、实现设备的具体操作函数

file_operations 结构体就是设备的具体操作函数；对 chrtest 这个设备有如下两个要求：

1、能够对 chrtest进行打开和关闭操作：设备打开和关闭是最基本的要求，几乎所有的设备都得提供打开和关闭的功能。因此我们需要实现 file_operations 中的 open 和 release 这两个函数。

2、对chrtest进行读写操作：假设 chrtest 这个设备控制着一段缓冲区(内存)，应用程序需要通过 read 和 write 这两个函数对 chrtest 的缓冲区进行读写操作。所以需要实现 file_operations 中的 read 和 write 这两个函数。

具体代码实现模板：

 static struct file_operations test_fops; 
1 /* 打开设备 */
2 static int chrtest_open(struct inode *inode, struct file *filp) 
3 {
4 		/* 用户实现具体功能 */
5 		return 0;
6 }
7 
8 /* 从设备读取 */
9 static ssize_t chrtest_read(struct file *filp, char __user *buf, 
size_t cnt, loff_t *offt)
10 {
11 		/* 用户实现具体功能 */
12 		return 0;
13 }
14
15 /* 向设备写数据 */
16 static ssize_t chrtest_write(struct file *filp,
const char __user *buf,size_t cnt, loff_t *offt)
17 {
18 		/* 用户实现具体功能 */
19 		return 0;
20 }
21
22 /* 关闭/释放设备 */
23 static int chrtest_release(struct inode *inode, struct file *filp)
24 {
25 		/* 用户实现具体功能 */
26 		return 0;
27 }
28
29 static struct file_operations test_fops = {
30 	.owner = THIS_MODULE, 
31 	.open = chrtest_open,
32 	.read = chrtest_read,
33 	.write = chrtest_write,
34 	.release = chrtest_release,
35 };
36
37 /* 驱动入口函数 */
38 static int __init xxx_init(void)
39 {
40 		/* 入口函数具体内容 */
41 		int retvalue = 0;
42
43 		/* 注册字符设备驱动 */
44 		retvalue = register_chrdev(200, "chrtest", &test_fops);
45 		if(retvalue < 0)
		{
46 			/* 字符设备注册失败,自行处理 */
47 		}
48 		return 0;
49 }
50
51 /* 驱动出口函数 */
52 static void __exit xxx_exit(void)
53 {
54 		/* 注销字符设备驱动 */
55 		unregister_chrdev(200, "chrtest");
56 }
57
58 /* 将上面两个函数指定为驱动的入口和出口函数 */
59 module_init(xxx_init);
60 module_exit(xxx_exit);

61 /* 添加 LICENSE 和作者信息 */
62 MODULE_LICENSE("GPL");
63 MODULE_AUTHOR("zuozhongkai");

3、Linux 设备号

3.1、设备号的组成

为了方便管理，Linux 中每个设备都有一个设备号，设备号由主设备号和次设备号两部分组成，主设备号表示某一个具体的驱动，次设备号表示使用这个驱动的各个设备。Linux 提供了一个名为 dev_t 的数据类型表示设备号，dev_t 定义在文件 include/linux/types.h 里面，定义如下：

12 typedef __u32 __kernel_dev_t;
......
15 typedef __kernel_dev_t dev_t;

dev_t 是 __u32 类型的，而 _ _u32 定义在文件 include/uapi/asm-generic/int-ll64.h 里面，定义如下：

26 typedef unsigned int __u32;

综上所述，dev_t 其实就是 unsigned int 类型，是一个 32 位的数据类型。这 32 位的数据构成了主设备号和次设备号两部分，其中高 12 位为主设备号，低 20 位为次设备号。因此 Linux系统中主设备号范围为 0~4095，所以在选择主设备号的时候一定不要超过这个范围。

在文件 include/linux/kdev_t.h 中提供了几个关于设备号的操作函数(本质是宏)，如下所示：

6 #define MINORBITS 20
7 #define MINORMASK ((1U << MINORBITS) - 1) 8 
9 #define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
10 #define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
11 #define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))

第 6 行，宏 MINORBITS 表示次设备号位数，一共是 20 位。

第 7 行，宏 MINORMASK 表示次设备号掩码。

第 9 行，宏 MAJOR 用于从 dev_t 中获取主设备号，将 dev_t 右移 20 位即可。

第 10 行，宏 MINOR 用于从 dev_t 中获取次设备号，取 dev_t 的低 20 位的值即可。

第 11 行，宏 MKDEV 用于将给定的主设备号和次设备号的值组合成 dev_t 类型的设备号。

3.2、设备号的分配

分为：静态分配设备号和动态分配设备号

①、静态分配设备号

自定义设备号，但是要避免申请Linux内核已经分配掉的设备号，可以用“cat/proc/devices”命令查看当前系统中已经使用过的设备号。

②、动态分配设备号

静态分配设备号需要我们检查当前系统中所有被使用了的设备号，然后挑选一个没有使用的。**Linux 社区推荐使用动态分配设备号，在注册字符设备之前先申请一个设备号，系统会自动给你一个没有被使用的设备号，这样就避免了冲突。**卸载驱动的时候释放掉这个设备号即可，设备号的申请函数如下：

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)

函数 alloc_chrdev_region 用于申请设备号，此函数有 4 个参数：

dev：保存申请到的设备号。

baseminor：次设备号起始地址，alloc_chrdev_region 可以申请一段连续的多个设备号，这些设备号的主设备号一样，但是次设备号不同，次设备号以 baseminor 为起始地址地址开始递增。一般 baseminor 为 0，也就是说次设备号从 0 开始。

count：要申请的设备号数量。

name：设备名字。

注销字符设备之后要释放掉设备号，设备号释放函数如下：

void unregister_chrdev_region(dev_t from, unsigned count)

from：要释放的设备号。

count：表示从 from 开始，要释放的设备号数量。