文章目录
一、字符设备驱动简介
字符设备是Linux驱动中最基本的一类设备驱动，字符设备就是一个一个字节，根据字节流进行读写操作的设备，读写数据是分先后次序的。例如我们最常见的点灯、按键、IIC、SPI，LCD等等都是字符设备，这种设备的驱动就称作字符设备驱动。
Linux下的应用程序调用驱动程序
在Linux中一切皆为文件，驱动加载成功之后会在“/dev”目录下生成一个相应的文件，应用程序通过对这个名为“/dev/xxx”(xxx是具体的驱动文件名子)的文件进行相应的操作即可实现对硬件的操作。例如现今有个称作/dev/led的驱动文件，此文件是led灯的驱动文件。应用程序使用open函数来打开文件/dev/led，使用完成之后使用close函数关掉/dev/led这个文件。open和close就是打开和关掉led驱动的函数，假若要照亮或关掉led，这么就使用write函数来操作，也就是向此驱动写入数据，这个数据就是要关掉还是要打开led的控制参数。假如要获取led灯的状态，就用read函数从驱动中读取相应的状态。
应用程序运行在用户空间，而Linux驱动属于内核的一部份，因而驱动运行于内核空间。当我们在用户空间想要实现对内核的操作，例如使用open函数打开/dev/led这个驱动，由于用户空间不能直接对内核进行操作，因而必须使用一个称作“系统调用”的方式来实现从用户空间“陷入”到内核空间，这样就能实现对底层驱动的操作。open、close、write和read等这种函数是由C库提供的，在Linux系统中，系统调用作为C库的一部份。当我们调用open函数的时侯流程如图：
其中关于C库以及怎样通过系统调用“陷入”到内核空间这个我们不用去管，我们重点关注的是应用程序和具体的驱动，应用程序使用到的函数在具体驱动程序中都有与之对应的函数，例如应用程序中调用了open这个函数，这么在驱动程序中也得有一个名为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函数用于刷新待处理的数据，用于将缓冲区中的数据刷新到c盘中。
第1605行，aio_fsync函数与fasync函数的功能类似，只是aio_fsync是异步刷新待处理的数据。
在字符设备驱动开发中最常用的就是前面那些函数，关于其他的函数你们可以查阅相关文档。我们在字符设备驱动开发中最主要的工作就是实现里面那些函数，不一定全部都要实现，并且像open、release、write、read等都是须要实现的，其实了，具体须要实现什么函数还是要看具体的驱动要求。
二、字符设备驱动开发步骤1.驱动模块的加载和卸载
Linux驱动有两种运行方法，第一种就是将驱动编译进Linux内核中，这样当Linux内核启动的时侯才会手动运行驱动程序。第二种就是将驱动编译成模块(Linux下模块扩充名为.ko)，在Linux内核启动之后使用“insmod”命令加载驱动模块。在调试驱动的时侯通常都选择将其编译为模块，这样我们更改驱动之后只须要编译一下驱动代码即可，不须要编译整个Linux代码。并且在调试的时侯只须要加载或则卸载驱动模块即可，不须要重启整个系统。其实，将驱动编译为模块最大的用处就是便捷开发，当驱动开发完成，确定没有问题之后就可以将驱动编译进Linux内核中，其实也可以不编译进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命令不能解决模块的依赖关系，例如drv.ko依赖first.ko这个模块，就必须先使用insmod命令加载first.ko这个模块，之后再加载drv.ko这个模块。并且modprobe就不会存在这个问题，modprobe会剖析模块的依赖关系，之后会将所有的依赖模块都加载到内核中，因而modprobe命令相比insmod要智能一些。modprobe命令主要智能在提供了模块的依赖性剖析、错误检测、错误报告等功能，推荐使用modprobe命令来加载驱动。modprobe命令默认会去/lib/modules/目录中查找模块，例如本书使用的Linuxkernel的版本号为4.1.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.字符设备注册与注销
对于字符设备驱动而言，当驱动模块加载成功之后须要注册字符设备，同样，卸载驱动模块的时侯也须要注销掉字符设备。字符设备的注册和注销函数原型如下所示：
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;
8
9 /* 注册字符设备驱动 */
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”可以查看当前早已被使用掉的设备号，如图：
在图中可以列举当前系统中所有的字符设备和块设备，其中第1列就是设备对应的主设备号。200这个主设备号在我的开发板中并没有被使用，所以我这儿就用了200这个主设备号。
第21行，调用函数unregister_chrdev注销主设备号为200的这个设备。
3.实现设备的具体操作函数
file_operations结构体就是设备的具体操作函数，在示例代码中我们定义了file_operations结构体类型的变量test_fops，而且还没对其进行初始化，也就是初始化其中的open、release、read和write等具体的设备操作函数。本小节我们就完成变量test_fops的初始化，设置好针对chrtest设备的操作函数。在初始化test_fops之前我们要剖析一下需求，也就是要对chrtest这个设备进行什么操作，只有确定了需求之后才晓得我们应当实现什么操作函数。假定对chrtest这个设备有如下两个要求：
3.1才能对chrtest进行打开和关掉操作
设备打开和关掉是最基本的要求，几乎所有的设备都得提供打开和关掉的功能。为此我们须要实现file_operations中的open和release这两个函数。
3.2对chrtest进行读写操作
假定chrtest这个设备控制着一段缓冲区(显存)，应用程序须要通过read和write这两个函数对chrtest的缓冲区进行读写操作。所以须要实现file_operations中的read和write这两个函数。
需求很清晰了，更改示例代码在其中加入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);
我们一开始编撰了四个函数：chrtest_open、chrtest_read、chrtest_write和chrtest_release。这四个函数就是chrtest设备的open、read、write和release操作函数。第29行~35行初始化test_fops的open、read、write和release这四个成员变量。
4.添加LICENSE和作者信息
最后我们须要在驱动中加入LICENSE信息和作者信息，其中LICENSE是必须添加的，否则的话编译的时侯会报错，作者信息可以添加也可以不添加。LICENSE和作者信息的添加使用如下两个函数：
MODULE_LICENSE() //添加模块 LICENSE 信息
MODULE_AUTHOR() //添加模块作者信息
在3.2代码中加入LICENSE和作者信息，完成之后的内容如下：
1 /* 打开设备 */
2 static int chrtest_open(struct inode *inode, struct file *filp)
3 {
4 /* 用户实现具体功能 */
5 return 0;
6 }
......
57
58 /* 将上面两个函数指定为驱动的入口和出口函数 */
59 module_init(xxx_init);
60 module_exit(xxx_exit);
61
62 MODULE_LICENSE("GPL");
63 MODULE_AUTHOR("zuozhongkai");
第62行，LICENSE采用GPL合同。
第63行，添加作者名子。
至此，字符设备驱动开发的完整步骤就讲解完了，并且也编撰好了一个完整的字符设备驱动模板，之后字符设备驱动开发都可以在此模板上进行。
三、Linux设备号1.设备号的组成
为了便捷管理，Linux中每位设备都有一个设备号，设备号由主设备号和次设备号两部份组成，主设备号表示某一个具体的驱动，次设备号表示使用这个驱动的各个设备。Linux提供了一个名为dev_t的数据类型表示设备号，dev_t定义在文件include/linux/types.h上面，定义如下：
typedef __u32 __kernel_dev_t;
typedef __kernel_dev_t dev_t;
可以看出dev_t是__u32类型的，而__u32定义在文件include/uapi/asm-generic/int-ll64.h上面，定义如下：
typedef unsigned int __u32;
综上所述，dev_t似乎就是unsignedint类型，是一个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类型的设备号。
2.设备号的分配2.1静态分配设备号
设备号分配主要是主设备号的分配。上面讲解字符设备驱动的时侯说过了，注册字符设备的时侯须要给设备指定一个设备号，这个设备号可以是驱动开发者静态的指定一个设备号，例如选择200这个主设备号。有一些常用的设备号早已被Linux内核开发者给分配掉了，具体分配的内容可以查看文档Documentation/devices.txt。并不是说内核开发者早已分配掉的主设备号我们就不能用了，具体能不能用还得看我们的硬件平台运行过程中有没有使用这个主设备号，使用“cat/proc/devices”命令即可查看当前系统中所有早已使用了的设备号。
2.2动态分配设备号
静态分配设备号须要我们检测当前系统中所有被使用了的设备号，之后选购一个没有使用的。并且静态分配设备号很容易带来冲突问题，Linux社区推荐使用动态分配设备号，在注册字符设备之前先申请一个设备号，系统会手动给你一个没有被使用的设备号，这样就防止了冲突。卸载驱动的时侯释放掉这个设备号即可。
设备号的申请函数如下：
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
/*
dev：保存申请到的设备号。
baseminor： 次设备号起始地址， alloc_chrdev_region 可以申请一段连续的多个设备号，这
些设备号的主设备号一样，但是次设备号不同，次设备号以 baseminor 为起始地址地址开始递
增。一般 baseminor 为 0，也就是说次设备号从 0 开始。
count： 要申请的设备号数量。
name：设备名字。
*/
注销字符设备以后要释放掉设备号，设备号释放函数如下：
void unregister_chrdev_region(dev_t from, unsigned count)
/*
from：要释放的设备号。
count： 表示从 from 开始，要释放的设备号数量。
*/
四、chrdevbase字符设备驱动开发实验
字符设备驱动开发的基本步骤我们早已了解了，本节我们就以chrdevbase这个虚拟设备为例，完整的编撰一个字符设备驱动模块。chrdevbase不是实际存在的一个设备，是笔者为了便捷讲解字符设备的开发而引入的一个虚拟设备。chrdevbase设备有两个缓冲区，一个为读缓冲区，一个为写缓冲区，这两个缓冲区的大小都为100字节。在应用程序中可以向chrdevbase设备的写缓冲区中写入数据，从读缓冲区中读取数据。chrdevbase这个虚拟设备的功能很简单，而且它包含了字符设备的最基本功能。
1.实验程序编撰
应用程序调用open函数打开chrdevbase这个设备，打开之后可以使用write函数向chrdevbase的写缓冲区writebuf中写入数据(不超过100个字节)linux 程序卸载，也可以使用read函数读取读缓冲区readbuf中的数据操作，操作完成之后应用程序使用close函数关掉chrdevbase设备。
1.1创建VSCode工程
在Ubuntu中创建一个目录用来储存Linux驱动程序，例如我创建了一个名为Linux_Drivers的目录来储存所有的Linux驱动。在Linux_Drivers目录下新建一个名为1_chrdevbase的子目录来储存本实验所有文件，如图：
在1_chrdevbase目录中新建VSCode工程，而且新建chrdevbase.c文件，完成之后1_chrdevbase目录中的文件如图：
1.2添加头文件路径
由于是编撰Linux驱动，因而会用到Linux源码中的函数。我们须要在VSCode中添加Linux源码中的头文件路径。打开VSCodelinux软件工程师培训，按下“Crtl+Shift+P”打开VSCode的控制台，之后输入“C/C++:Editconfigurations(JSON)”，打开C/C++编辑配置文件，如图：
打开之后会手动在.vscode目录下生成一个名为c_cpp_properties.json的文件，此文件默认
内容如下所示：
1 {
2 "configurations": [
3 {
4 "name": "Linux",
5 "includePath": [
6 "${workspaceFolder}/**",
7 ],
8 "defines": [],
9 "compilerPath": "/usr/bin/clang",
10 "cStandard": "c11",
11 "cppStandard": "c++17",
12 "intelliSenseMode": "clang-x64"
13 }
14 ],
15 "version": 4
16 }
第5行的includePath表示头文件路径，须要将Linux源码上面的头文件路径添加进来，也就是我们上面移植的Linux源码中的头文件路径。添加头文件路径之后的c_cpp_properties.json的文件内容如下所示：
1 {
2 "configurations": [
3 {
4 "name": "Linux",
5 "includePath": [
6 "${workspaceFolder}/**",
7 "/home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imxrel_imx_4.1.15_2.1.0_ga_alientek/include",
8 "/home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imxrel_imx_4.1.15_2.1.0_ga_alientek/arch/arm/include",
9 "/home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imxrel_imx_4.1.15_2.1.0_ga_alientek/arch/arm/include/generated/"
10 ],
11 "defines": [],
......
16 }
17 ],
18 "version": 4
19 }
第7~9行就是添加好的Linux头文件路径。分别是开发板所使用的Linux源码下的include、arch/arm/include和arch/arm/include/generated这三个目录的路径，注意，这儿使用了绝对路径。
1.3编撰实验程序
工程构建好之后就可以开始编撰驱动程序了，新建chrdevbase.c，之后在上面输入如下内容：
#include
#include
#include
#include
#include
#include
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名 : chrdevbase.c
作者 : 左忠凯
版本 : V1.0
描述 : chrdevbase驱动文件。
其他 : 无
论坛 : www.openedv.com
日志 : 初版V1.0 2019/1/30 左忠凯创建
***************************************************************/
#define CHRDEVBASE_MAJOR 200 /* 主设备号 */
#define CHRDEVBASE_NAME "chrdevbase" /* 设备名 */
static char readbuf[100]; /* 读缓冲区 */
static char writebuf[100]; /* 写缓冲区 */
static char kerneldata[] = {"kernel data!"};
/*
* @description : 打开设备
* @param - inode : 传递给驱动的inode
* @param - filp : 设备文件，file结构体有个叫做private_data的成员变量
* 一般在open的时候将private_data指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int chrdevbase_open(struct inode *inode, struct file *filp)
{
//printk("chrdevbase open!rn");
return 0;
}
/*
* @description : 从设备读取数据
* @param - filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param - offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t chrdevbase_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int retvalue = 0;
/* 向用户空间发送数据 */
memcpy(readbuf, kerneldata, sizeof(kerneldata));
retvalue = copy_to_user(buf, readbuf, cnt);
if(retvalue == 0){
printk("kernel senddata ok!rn");
}else{
printk("kernel senddata failed!rn");
}
//printk("chrdevbase read!rn");
return 0;
}
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param - offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t chrdevbase_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
int retvalue = 0;
/* 接收用户空间传递给内核的数据并且打印出来 */
retvalue = copy_from_user(writebuf, buf, cnt);
if(retvalue == 0){
printk("kernel recevdata:%srn", writebuf);
}else{
printk("kernel recevdata failed!rn");
}
//printk("chrdevbase write!rn");
return 0;
}
/*
* @description : 关闭/释放设备
* @param - filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int chrdevbase_release(struct inode *inode, struct file *filp)
{
//printk("chrdevbase release！rn");
return 0;
}
/*
* 设备操作函数结构体
*/
static struct file_operations chrdevbase_fops = {
.owner = THIS_MODULE,
.open = chrdevbase_open,
.read = chrdevbase_read,
.write = chrdevbase_write,
.release = chrdevbase_release,
};
/*
* @description : 驱动入口函数
* @param : 无
* @return : 0 成功;其他 失败
*/
static int __init chrdevbase_init(void)
{
int retvalue = 0;
/* 注册字符设备驱动 */
retvalue = register_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME, &chrdevbase_fops);
if(retvalue < 0){
printk("chrdevbase driver register failedrn");
}
printk("chrdevbase init!rn");
return 0;
}
/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit chrdevbase_exit(void)
{
/* 注销字符设备驱动 */
unregister_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME);
printk("chrdevbase exit!rn");
}
/*
* 将上面两个函数指定为驱动的入口和出口函数
*/
module_init(chrdevbase_init);
module_exit(chrdevbase_exit);
/*
* LICENSE和作者信息
*/
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zuozhongkai");
第32~36行，chrdevbase_open函数，当应用程序调用open函数的时侯此函数都会调用，本类库中我们没有做任何工作，只是输出一串字符，用于调试。这儿使用了printk来输出信息，而不是printf！由于在Linux内核中没有printf这个函数。printk相当于printf的双胞父子，printf运行在用户态，printk运行在内核态。在内核中想要向控制台输出或显示一些内容，必须使用printk这个函数。不同之处在于，printk可以按照日志级别对消息进行分类，一共有8个消息级别，这8个消息级别定义在文件include/linux/kern_levels.h上面linux 程序卸载，其中0的优先级最高，7的优先级最低，定义如下：
第46~61行，chrdevbase_read函数，应用程序调用read函数从设备中读取数据的时侯此函数会执行。参数buf是用户空间的显存，读取到的数据储存在buf中，参数cnt是要读取的字节数，参数offt是相对于文件首地址的偏斜。kerneldata上面保存着用户空间要读取的数据，第51行先将kerneldata链表中的数据拷贝到读缓冲区readbuf中，第52行通过函数copy_to_user将readbuf中的数据复制到参数buf中。由于内核空间不能直接操作用户空间的显存，因而须要利用copy_to_user函数来完成内核空间的数据到用户空间的复制。copy_to_user函数原型如下：
static inline long copy_to_user(void __user *to, const void *from, unsigned long n)
参数to表示目的，参数from表示源，参数n表示要复制的数据宽度。假如复制成功，返回值为0，假如复制失败则返回正数。
第71~84行，chrdevbase_write函数，应用程序调用write函数向设备写数据的时侯此函数都会执行。参数buf就是应用程序要写入设备的数据，也是用户空间的显存linux之家，参数cnt是要写入的数据宽度，参数offt是相对文件首地址的偏斜。第75行通过函数copy_from_user将buf中的数据复制到写缓冲区writebuf中，由于用户空间显存不能直接访问内核空间的显存，所以须要利用函数copy_from_user将用户空间的数据复制到writebuf这个内核空间中。
第91~95行，chrdevbase_release函数，应用程序调用close关掉设备文件的时侯此函数会执行，通常会在此函数上面执行一些释放操作。假如在open函数中设置了filp的private_data成员变量指向设备结构体，这么在release函数最终就要释放掉。
第100~106行，新建chrdevbase的设备文件操作结构体chrdevbase_fops，初始化chrdevbase_fops。
第113~124行，驱动入口函数chrdevbase_init，第118行调用函数register_chrdev来注册字符设备。
第131~136行，驱动出口函数chrdevbase_exit，第134行调用函数unregister_chrdev来注销字符设备。
第141~142行，通过module_init和module_exit这两个函数来指定驱动的入口和出口函数。
第147~148行，添加LICENSE和作者信息。
2.编撰测试APP2.1C库文件操作基本函数
编撰测试APP就是编撰Linux应用，须要用到C库上面和文件操作有关的一些函数，例如open、read、write和close这四个函数。
2.1.1open函数
int open(const char *pathname, int flags)
/*
pathname：要打开的设备或者文件名。
flags：文件打开模式，以下三种模式必选其一：
O_RDONLY 只读模式
O_WRONLY 只写模式
O_RDWR 读写模式
因为我们要对 chrdevbase 这个设备进行读写操作，所以选择 O_RDWR。除了上述三种
模式以外还有其他的可选模式，通过逻辑或来选择多种模式：
O_APPEND 每次写操作都写入文件的末尾
O_CREAT 如果指定文件不存在，则创建这个文件
O_EXCL 如果要创建的文件已存在，则返回 -1，并且修改 errno 的值
O_TRUNC 如果文件存在，并且以只写/读写方式打开，则清空文件全部内容
O_NOCTTY 如果路径名指向终端设备，不要把这个设备用作控制终端。
O_NONBLOCK 如果路径名指向 FIFO/块文件/字符文件，则把文件的打开和后继 I/O 设置为非阻塞
DSYNC 等待物理 I/O 结束后再 write。在不影响读取新写入的数据的前提下，不等待文件属性更新。
O_RSYNC read 等待所有写入同一区域的写操作完成后再进行。
O_SYNC 等待物理 I/O 结束后再 write，包括更新文件属性的 I/O。
返回值：如果文件打开成功的话返回文件的文件描述符。
*/
2.1.2read函数
ssize_t read(int fd, void *buf, size_t count)
/*
fd：要读取的文件描述符，读取文件之前要先用 open 函数打开文件， open 函数打开文件成功以后会得到文件描述符。
buf： 数据读取到此 buf 中。
count： 要读取的数据长度，也就是字节数。
返回值： 读取成功的话返回读取到的字节数；如果返回 0 表示读取到了文件末尾；如果返回负值，表示读取失败。在 Ubuntu 中输入“man 2 read”命令即可查看 read 函数的详细内容。
*/
2.1.3write函数
ssize_t write(int fd, const void *buf, size_t count);
/*
fd：要进行写操作的文件描述符，写文件之前要先用 open 函数打开文件， open 函数打开文件成功以后会得到文件描述符。
buf： 要写入的数据。
count： 要写入的数据长度，也就是字节数。
返回值： 写入成功的话返回写入的字节数；如果返回 0 表示没有写入任何数据；如果返回负值，表示写入失败。在 Ubuntu 中输入“man 2 write”命令即可查看 write 函数的详细内容。
*/
2.1.4close函数
int close(int fd);
/*
fd：要关闭的文件描述符。
返回值： 0 表示关闭成功，负值表示关闭失败。在 Ubuntu 中输入“man 2 close”命令即可查看 close 函数的详细内容。
*/
2.2编撰测试APP程序
驱动编撰好之后是须要测试的，通常编撰一个简单的测试APP，测试APP运行在用户空间。测试APP很简单通过输入相应的指令来对chrdevbase设备执行读或则写操作。在1_chrdevbase目录中新建chrdevbaseApp.c文件，在此文件中输入如下内容：
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名 : chrdevbaseApp.c
作者 : 左忠凯
版本 : V1.0
描述 : chrdevbase驱测试APP。
其他 : 使用方法：./chrdevbase /dev/chrdevbase |
argv[2] 1:读文件
argv[2] 2:写文件
论坛 : www.openedv.com
日志 : 初版V1.0 2019/1/30 左忠凯创建
***************************************************************/
static char usrdata[] = {"usr data!"};
/*
* @description : main主程序
* @param - argc : argv数组元素个数
* @param - argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
int fd, retvalue;
char *filename;
char readbuf[100], writebuf[100];
if(argc != 3){
printf("Error Usage!rn");
return -1;
}
filename = argv[1];
/* 打开驱动文件 */
fd = open(filename, O_RDWR);
if(fd < 0){
printf("Can't open file %srn", filename);
return -1;
}
if(atoi(argv[2]) == 1){ /* 从驱动文件读取数据 */
retvalue = read(fd, readbuf, 50);
if(retvalue < 0){
printf("read file %s failed!rn", filename);
}else{
/* 读取成功，打印出读取成功的数据 */
printf("read data:%srn",readbuf);
}
}
if(atoi(argv[2]) == 2){
/* 向设备驱动写数据 */
memcpy(writebuf, usrdata, sizeof(usrdata));
retvalue = write(fd, writebuf, 50);
if(retvalue < 0){
printf("write file %s failed!rn", filename);
}
}
/* 关闭设备 */
retvalue = close(fd);
if(retvalue < 0){
printf("Can't close file %srn", filename);
return -1;
}
return 0;
}
第21行，链表usrdata是测试APP要向chrdevbase设备写入的数据。
第35行，判定运行测试APP的时侯输入的参数是不是为3个，main函数的argc参数表示
参数数目，argv[]保存着具体的参数，假如参数不为3个的话就表示测试APP用法错误。例如，
如今要从chrdevbase设备中读取数据，须要输入如下命令：
./chrdevbaseApp/dev/chrdevbase1
上述命令一共有三个参数“./chrdevbaseApp”、“/dev/chrdevbase”和“1”，这三个参数分别对应argv[0]、argv[1]和argv[2]。第一个参数表示运行chrdevbaseAPP这个软件，第二个参数表示测试APP要打开/dev/chrdevbase这个设备。第三个参数就是要执行的操作，1表示从chrdevbase中读取数据，2表示向chrdevbase写数据。
第40行，获取要打开的设备文件名子，argv[1]保存着设备名子。
第43行，调用C库中的open函数打开设备文件：/dev/chrdevbase。
第49行，判定argv[2]参数的值是1还是2，由于输入命令的时侯其参数都是字符串格式的，因而须要利用atoi函数将字符串格式的数字转换为真实的数字。
第50行，当argv[2]为1的时侯表示要从chrdevbase设备中读取数据，一共读取50字节的数据，读取到的数据保存在readbuf中，读取成功之后就在终端上复印出读取到的数据。
第59行，当argv[2]为2的时侯表示要向chrdevbase设备写数据。
第69行，对chrdevbase设备操作完成之后就关掉设备。
chrdevbaseApp.c内容还是很简单的，就是最普通的文件打开、关闭和读写操作。
2.3编译驱动程序和测试APP2.3.1编译驱动程序
首先编译驱动程序，也就是chrdevbase.c这个文件，我们须要将其编译为.ko模块，创建Makefile文件，之后在其中输入如下内容
KERNELDIR := /home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
CURRENT_PATH := $(shell pwd)
obj-m := chrdevbase.o
build: kernel_modules
kernel_modules:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
第1行，KERNELDIR表示开发板所使用的Linux内核源码目录，使用绝对路径，你们按照自己的实际情况填写即可。
第2行，CURRENT_PATH表示当前路径，直接通过运行“pwd”命令来获取当前所处路径。
第3行，obj-m表示将chrdevbase.c这个文件编译为chrdevbase.ko模块。
第8行，具体的编译命令，旁边的modules表示编译模块，-C表示将当前的工作目录切换到指定目录中，也就是KERNERLDIR目录。M表示模块源码目录，“makemodules”命令中加入M=dir之后程序会手动到指定的dir目录中读取模块的源码并将其编译为.ko文件
编译成功之后才会生成一个称作chrdevbaes.ko的文件，此文件就是chrdevbase设备的驱动模块。至此，chrdevbase设备的驱动就编译成功。
2.3.2编译测试APP
测试APP比较简单，只有一个文件，因而就不须要编撰Makefile了，直接输入命令编译。由于测试APP是要在ARM开发板上运行的，所以须要使用arm-linux-gnueabihf-gcc来编译，输入如下命令：
arm-linux-gnueabihf-gcc chrdevbaseApp.c -o chrdevbaseApp
编译完成之后会生成一个称作chrdevbaseApp的可执行程序，输入如下命令查看chrdevbaseAPP这个程序的文件信息：
file chrdevbaseApp
可以看出，chrdevbaseAPP这个可执行文件是32位LSB格式，ARM版本的，因而chrdevbaseAPP只能在ARM芯片下运行。
2.4运行测试2.4.1加载驱动模块
驱动模块chrdevbase.ko和测试软件chrdevbaseAPP都早已打算好了，接出来就是运行测试。为了便捷测试，Linux系统选择通过TFTP从网路启动，而且使用NFS挂载网路根文件系统，确保uboot中bootcmd环境变量的值为：
tftp 80800000 zImage;tftp 83000000 imx6ull-alientek-emmc.dtb;bootz 80800000 - 83000000
bootargs环境变量的值为：
console=ttymxc0,115200 root=/dev/nfs rw nfsroot=192.168.1.250:/home/zuozhongkai/linux/nfs/rootfs ip=192.168.1.251:192.168.1.250:192.168.1.1:255.255.255.0::eth0:off
设置好之后启动Linux系统，检测开发板根文件系统中有没有“/lib/modules/4.1.15”这个目录，假如没有的话自行创建。注意，“/lib/modules/4.1.15”这个目录用来储存驱动模块，使用modprobe命令加载驱动模块的时侯，驱动模块要储存在此目录下。“/lib/modules”是通用的，不管你用的哪些板子、什么内核，这部份是一样的。不一样的是前面的“4.1.15”，这儿要按照你所使用的Linux内核版本来设置，例如ALPHA开发板现今用的是4.1.15版本的Linux内核，因而就是“/lib/modules/4.1.15”。假如你使用的其他版本内核，例如5.14.31，这么就应当创建“/lib/modules/5.14.31”目录，否则modprobe命令未能加载驱动模块。
由于是通过NFS将Ubuntu中的rootfs(第三十八章制做好的根文件系统)目录挂载为根文件系统，所以可以很便捷的将chrdevbase.ko和chrdevbaseAPP复制到rootfs/lib/modules/4.1.15目录中，命令如下：
sudo cp chrdevbase.ko chrdevbaseApp /home/zuozhongkai/linux/nfs/rootfs/lib/modules/4.1.15/ -f
拷贝完成以后就会在开发板的/lib/modules/4.1.15目录下存在chrdevbase.ko和chrdevbaseAPP这两个文件，如图：
输入如下命令加载chrdevbase.ko驱动文件：
insmod chrdevbase.ko
或
modprobe chrdevbase.ko
假如使用modprobe加载驱动的话，可能会出现如图的提示：
可以看出，modprobe提示未能打开“modules.dep”这个文件，因而驱动挂载失败了。我们不用自动创建modules.dep这个文件，直接输入depmod命令即可手动生成modules.dep，有些根文件系统可能没有depmod这个命令，假如没有这个命令就只能重新配置busybox，使能此命令，之后重新编译busybox。输入“depmod”命令之后会手动生成modules.alias、modules.symbols和modules.dep这三个文件，如图所示：
重新使用modprobe加载chrdevbase.ko，结果如图：
可以见到“chrdevbaseinit！”这一行，这一行正是chrdevbase.c中模块入口函数chrdevbase_init输出的信息，说明模块加载成功！
输入“lsmod”命令即可查看当前系统中存在的模块，结果如图
从上图可以看出，当前系统只有“chrdevbase”这一个模块。输入如下命令查看当前系统中有没有chrdevbase这个设备：
cat /proc/devices
上图可以看出，当前系统存在chrdevbase这个设备，主设备号为200，跟我们设置的主设备号一致。
2.4.2创建设备节点文件
驱动加载成功须要在/dev目录下创建一个与之对应的设备节点文件，应用程序就是通过操作这个设备节点文件来完成对具体设备的操作。输入如下命令创建/dev/chrdevbase这个设备节点文件：
mknod /dev/chrdevbase c 200 0
其中“mknod”是创建节点命令，“/dev/chrdevbase”是要创建的节点文件，“c”表示这是个字符设备，“200”是设备的主设备号，“0”是设备的次设备号。创建完成之后才会存在/dev/chrdevbase这个文件，可以使用“ls/dev/chrdevbase-l”命令查看，结果如图所示：
假如chrdevbaseAPP想要读写chrdevbase设备，直接对/dev/chrdevbase进行读写操作即可。相当于/dev/chrdevbase这个文件是chrdevbase设备在用户空间中的实现。上面仍然说Linux下一切皆文件，包括设备也是文件。
2.4.3chrdevbase设备操作测试
使用chrdevbaseApp软件操作chrdevbase这个设备，瞧瞧读写是否正常，首先进行读操作，输入如下命令：
./chrdevbaseApp /dev/chrdevbase 1
可以看出，首先输出“kernelsenddataok!”这一行信息，这是驱动程序中chrdevbase_read函数输出的信息，由于chrdevbaseAPP使用read函数从chrdevbase设备读取数据，因而chrdevbase_read函数都会执行。chrdevbase_read函数向chrdevbaseAPP发送“kerneldata!”数据，chrdevbaseAPP接收到之后就复印下来，“readdata:kerneldata!”就是chrdevbaseAPP复印下来的接收到的数据。说明对chrdevbase的读操作正常，接出来测试对chrdevbase设备的写操作，输入如下命令：
./chrdevbaseApp /dev/chrdevbase 2
只有一行“kernelrecevdata:usrdata!”，这个是驱动程序中的chrdevbase_write函数输出的。chrdevbaseAPP使用write函数向chrdevbase设备写入数据“usrdata!”。chrdevbase_write函数接收到之后将其复印下来。说明对chrdevbase的写操作正常，既然读写都没问题，说明我们编撰的chrdevbase驱动是没有问题的。
2.4.4卸载驱动模块
倘若不再使用某个设备的话可以将其驱动卸载掉，例如输入如下命令卸载掉chrdevbase这个设备：
rmmod chrdevbase.ko
卸载之后使用lsmod命令查看chrdevbase这个模块还存不存在，结果如图所示：
从图可以看出，此时系统早已没有任何模块了，chrdevbase这个模块也不存在了，说明模块卸载成功。
