Linux驱动开发2：字符设备驱动之我的第一个字符设备Linux驱动开发模板

淩亂°似流年 2022-09-02 11:40 263阅读 0赞

## Linux驱动开发2：字符设备驱动之我的第一个字符设备Linux驱动开发模板 ##

在本章节，我们从Linux驱动开发中最基础的字符设备驱动开发开始，重点学习Linux下字符设备开发框架，本章会以一个虚拟的设备为例，讲解如何进行Linux字符设备驱动开发，以及如何编写测试APP来测试驱动开发是否正常，为以后的学习打下坚定的基础；

**1.应用程序和驱动的交互原理：**

驱动就是获取外设，或者传感器的数据，以及控制外设，数据会提交给应用程序；  
在编写Linux驱动的时候，既要编写驱动，也要编写一个简单的应用程序app；单片机下的驱动和应用程序都放在一个文件当中，杂糅在一起，Linux的驱动和应用是完全分开的。

用户空间(用户态)和内核空间(内核态)：  
Linux操作系统内核和驱动程序运行在内核空间；用户程序运行在用户空间；  
应用程序想要访问内核资源咋办？  
系统调用，异常(中断)，陷入。

应用程序不会直接调用系统调用，而是通过API函数来间接的调用系统调用；  
比如：POSIX API C库；

**2.字符设备驱动简介：**

字符设备驱动是Linux驱动中最基础的一类驱动；字符设备就是一个一个字节，按照字节流来对设备进行读写；  
比如我们常见的：点灯，按键，IIC，SPI ，LCD等等；都是字符设备；对于这些设备的驱动，我们称之为：字符设备驱动；

在详细的学习字符设备架构之前：我们来了解一下Linux应用程序是如何调用驱动程序的；  
Linux应用程序对驱动程序的调用流程如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70]

在Linux中一切皆文件；驱动加载成功后会在：/dev目录下生成一个文件；应用程序通过对驱动文件的操作来实现对硬件的操作；  
比如现在有个叫做/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 函数的时候流程如图：  
![在这里插入图片描述][ec9f2bb11579488788cd12cd76c98342.png]  
其中关于== C 库以及如何通过系统调用“陷入”到内核空间这个我们不用去管==，我们重点关注的是应用程序和具体的驱动，应用程序使用到的函数在具体驱动程序中都有与之对应的函数，比如应用程序中调用了 open 这个函数，那么在驱动程序中也得有一个名为 open 的函数。每一个系统调用，在驱动中都有与之对应的一个驱动函数，在 Linux 内核文件 include/linux/fs.h 中有个叫做 file\_operations 的结构体，此结构体就是 Linux 内核驱动操作函数集合，内容如下所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 2]  
简单介绍一下 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 等都是需要实现的，当然了，具体需要实现哪些函数还是要看具体的驱动要求。

**3.字符设备驱动开发步骤：**

我们在学习裸机或者STM32的时候，关于驱动的开发就是初始化相应的寄存器外设，在Linux驱动开发当中肯定也要初始化相应的寄存器外设，这是毫无疑问的，只是在Linux驱动开发过程中，我们需要按照规定的框架来编写驱动，所以，Linux驱动开发重点是学习驱动框架；

**3.1.驱动模块的加载和卸载：**

Linux驱动有两种运行方式，第一种是将驱动编译进Linux内核，这样，当Linux内核启动的时候就会自动运行这些驱动程序；  
第二种就是将驱动编译成模块(Linux下模块的扩展名为.ko)，在Linux内核启动以后，使用：insmod命令加载驱动模块；  
我们在调试驱动的时候一般都选择将其编译成模块，这样我们修改驱动以后只需要编译一下驱动代码即可；不需要编译整个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 函数就会被调用。字符设备驱动模块加载和卸载模板如下所示：

//驱动入口函数
    static int __init xxx_init(void)
    {
        
    	//入口函数具体内容
    	return 0;
    }
    //驱动出口函数
    static void __exit xxx_exit(void)
    {
        
    	//出口函数具体内容
    }
    //将上面两个函数指定为驱动入口和出口函数
    module_init(xxx_init);//加载驱动的时候，函数被调用
    module_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/目录中查找模块，比如本书使用的 Linux kernel 的版本号为 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 命令。

**3.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 中进行。

static struct file_operations test_fops;
     /* 驱动入口函数 */
     static int __init xxx_init(void)
     {
        
     	int retvalue = 0;
     	//注册字符设备驱动
     	retvalue = register_chrdev(200, "chrtest", &test_fops);
     	if(retvalue < 0)
     	{
        
     		//字符设备驱动注册失败，自行处理
     	}
     	return 0;
     }
     static void __exit xxx_exit(void)
     {
        
     	//注销字符设备驱动
     	unregister_chrdev(200, "chrtest");
     }
     //将上面两个函数指定为驱动的入口和出口函数：
     module_init(xxx_init);
     module_exit(xxx_exit);

调用函数 register\_chrdev 注册字符设备，主设备号为 200，设备名字为“chrtest”，设备操作函数集合就是第 1 行定义的 test\_fops。要注意的一点就是，选择没有被使用的主设备号，输入命令“cat /proc/devices”可以查看当前已经被使用掉的设备号  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 3]  
**3.3.实现设备的具体操作函数：**

file\_operations 结构体就是设备的具体操作函数，在示例代码 中我们定义了file\_operations结构体类型的变量test\_fops，但是还没对其进行初始化，也就是初始化其中的open、release、read 和 write 等具体的设备操作函数。本节小节我们就完成变量 test\_fops 的初始化，设置好针对 chrtest 设备的操作函数。在初始化 test\_fops 之前我们要分析一下需求，也就是要对chrtest 这个设备进行哪些操作，只有确定了需求以后才知道我们应该实现哪些操作函数。假设对 chrtest 这个设备有如下两个要求：

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

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

需求很清晰了，修改示例代码 ，在其中加入 test\_fops 这个结构体变量的初始化操作，完成以后的内容如下所示：

//打开设备
    static int chrtest_open(struct inode *inode, struct file *filp)
    {
        
    	//用户实现具体功能
    	return 0;
    }
    //从设备中读取
    static ssize_t chrtest_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
    {
        
    	//用户实现具体功能
    	return 0;
    }
    //向设备中写数据
    static ssize_t chrtest_write(struct file *filp,const char __user *buf,size_t cnt, loff_t *offt)
    {
        
    	//用户实现具体功能
    	return 0;
    }
    //关闭释放设备
    static int chrtest_release(struct inode *inode, struct file *filp)
    {
        
    	//用户实现具体功能
    	return 0;
    }
    
    static struct file_operations test_fops = {
        
     .owner = THIS_MODULE, 
     .open = chrtest_open,
     .read = chrtest_read,
     .write = chrtest_write,
     .release = chrtest_release,
     };
    
     /* 驱动入口函数 */
     static int __init xxx_init(void)
     {
        
     	int retvalue = 0;
     	//注册字符设备驱动
     	retvalue = register_chrdev(200, "chrtest", &test_fops);
     	if(retvalue < 0)
     	{
        
     		//字符设备驱动注册失败，自行处理
     	}
     	return 0;
     }
     static void __exit xxx_exit(void)
     {
        
     	//注销字符设备驱动
     	unregister_chrdev(200, "chrtest");
     }
     //将上面两个函数指定为驱动的入口和出口函数：
     module_init(xxx_init);
     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这四个成员变量。

**3.4.添加 LICENSE 和作者信息:**

...
     /* 将上面两个函数指定为驱动的入口和出口函数 */
    module_init(xxx_init);
    module_exit(xxx_exit);
    
    MODULE_LICENSE("GPL");//LICENSE 采用 GPL 协议
    MODULE_AUTHOR("zuozhongkai");//添加作者名字

至此，字符设备驱动开发的完整步骤就讲解完了，而且也编写好了一个完整的字符设备驱动模板，以后字符设备驱动开发都可以在此模板上进行。

**4.Linux设备号：**

**4.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 其实就是 unsigned int 类型，是一个 32 位的数据类型。这 32 位的数据构成了主设备号和次设备号两部分，其中高 12 位为主设备号，低 20 位为次设备号。因此 Linux系统中主设备号范围为 0~4095，所以大家在选择主设备号的时候一定不要超过这个范围。在文件 include/linux/kdev\_t.h 中提供了几个关于设备号的操作函数(本质是宏)，如下所  
示：

#define MINORBITS 20
     #define MINORMASK ((1U << MINORBITS) - 1)  
     #define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
     #define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
     #define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))

宏 MINORBITS 表示次设备号位数，一共是 20 位。  
宏 MINORMASK 表示次设备号掩码。  
宏 MAJOR 用于从 dev\_t 中获取主设备号，将 dev\_t 右移 20 位即可。  
宏 MINOR 用于从 dev\_t 中获取次设备号，取 dev\_t 的低 20 位的值即可。  
宏 MKDEV 用于将给定的主设备号和次设备号的值组合成 dev\_t 类型的设备号。

**4.2.设备号的分配：**

静态分配设备号：

本小节讲的设备号分配主要是主设备号的分配。前面讲解字符设备驱动的时候说过了，注册字符设备的时候需要给设备指定一个设备号，这个设备号可以是驱动开发者静态的指定一个设备号，比如选择 200 这个主设备号。有一些常用的设备号已经被 Linux 内核开发者给分配掉了，具体分配的内容可以查看文档 Documentation/devices.txt。并不是说内核开发者已经分配掉的主设备号我们就不能用了，具体能不能用还得看我们的硬件平台运行过程中有没有使用这个主设备号，使用“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 开始，要释放的设备号数量

**5. chrdevbase 字符设备驱动开发实验：**

字符设备驱动开发的基本步骤我们已经了解了，本节我们就以 chrdevbase 这个虚拟设备为例，完整的编写一个字符设备驱动模块。chrdevbase 不是实际存在的一个设备，是笔者为了方便讲解字符设备的开发而引入的一个虚拟设备。chrdevbase 设备有两个缓冲区，一个为读缓冲区，一个为写缓冲区，这两个缓冲区的大小都为 100 字节。在应用程序中可以向 chrdevbase 设备的写缓冲区中写入数据，从读缓冲区中读取数据。chrdevbase 这个虚拟设备的功能很简单，但是它包含了字符设备的最基本功能。

5.1.实验程序的编写的开发环境：

应用程序调用 open 函数打开 chrdevbase 这个设备，打开以后可以使用 write 函数向chrdevbase 的写缓冲区 writebuf 中写入数据(不超过 100 个字节)，也可以使用 read 函数读取读缓冲区 readbuf 中的数据操作，操作完成以后应用程序使用 close 函数关闭 chrdevbase 设备。

创建VSCode工程，在Ubuntu创建一个目录，来存放Linux驱动程序，在目录下新建VSCode工程，并且新建.c文件，添加头文件路径：因为Linux驱动会用到Linux源码中的函数，我们需要在VSCode当中添加Linux源码的头文件路径；  
打开 VSCode，按下“Crtl+Shift+P”打开 VSCode 的控制台，然后输入“C/C++: Edit configurations(JSON) ”，打开 C/C++编辑配置文件，打开以后会自动在.vscode 目录下生成一个名为 c\_cpp\_properties.json 的文件，此文件默认内容如下所示：

{
        
        "configurations": [
            {
        
                "name": "Linux",
                "includePath": [
                    "${workspaceFolder}/**",
                    "/home/dazai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek/include", 
                    "/home/dazai/linux/IMX6ULL/linux/temp/linux-imxrel_imx_4.1.15_2.1.0_ga_alientek/arch/arm/include", 
                    "/home/dazai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek/arch/arm/include/generated/"
                ],
                "defines": [],
                "compilerPath": "/usr/bin/clang",
                "cStandard": "c11",
                "cppStandard": "c++17",
                "intelliSenseMode": "clang-x64"
            }
        ],
        "version": 4
    }

includePath 表示头文件路径，需要将 Linux 源码里面的头文件路径添加进来，也就是我们前面移植的 Linux 源码中的头文件路径。分别是开发板所使用的 Linux 源码下的 include、arch/arm/include 和 arch/arm/include/generated 这三个目录的路径，注意，这里使用了绝对路径。

5.2.编写驱动实验程序：

工程建立好以后就可以开始编写驱动程序了，新建 chrdevbase.c，然后在里面输入如下内容：

#include <linux/types.h>
    #include <linux/kernel.h>
    #include <linux/delay.h>
    #include <linux/ide.h>
    #include <linux/init.h>
    #include <linux/module.h>
    /***************************************************************
    Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
    文件名		: chrdevbase.c
    作者	  	: 哒宰
    版本	   	: V1.0
    描述	   	: chrdevbase驱动文件。
    其他	   	: 无
    论坛 	   	: www.哒宰云.com
    日志	   	: 初版V1.0 哒宰创建
    ***************************************************************/
    
    #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!\r\n");
    	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!\r\n");
    	}else{
        
    		printk("kernel senddata failed!\r\n");
    	}
    	
    	//printk("chrdevbase read!\r\n");
    	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:%s\r\n", writebuf);
    	}else{
        
    		printk("kernel recevdata failed!\r\n");
    	}
    	
    	//printk("chrdevbase write!\r\n");
    	return 0;
    }
    
    /*
     * @description		: 关闭/释放设备
     * @param - filp 	: 要关闭的设备文件(文件描述符)
     * @return 			: 0 成功;其他 失败
     */
    static int chrdevbase_release(struct inode *inode, struct file *filp)
    {
        
    	//printk("chrdevbase release！\r\n");
    	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 failed\r\n");
    	}
    	printk("chrdevbase init!\r\n");
    	return 0;
    }
    
    /*
     * @description	: 驱动出口函数
     * @param 		: 无
     * @return 		: 无
     */
    static void __exit chrdevbase_exit(void)
    {
        
    	/* 注销字符设备驱动 */
    	unregister_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME);
    	printk("chrdevbase exit!\r\n");
    }
    
    /* 
     * 将上面两个函数指定为驱动的入口和出口函数 
     */
    module_init(chrdevbase_init);
    module_exit(chrdevbase_exit);
    
    /* 
     * LICENSE和作者信息
     */
    MODULE_LICENSE("GPL");
    MODULE_AUTHOR("zuozhongkai");

chrdevbase\_open 函数，当应用程序调用 open 函数的时候此函数就会调用，本例程中我们没有做任何工作，只是输出一串字符，用于调试。这里使用了 printk 来输出信息，而不是 printf！因为在 Linux 内核中没有 printf 这个函数。printk 相当于 printf 的孪生兄妹，printf运行在用户态，printk 运行在内核态。在内核中想要向控制台输出或显示一些内容，必须使用printk 这个函数。不同之处在于，printk 可以根据日志级别对消息进行分类，一共有 8 个消息级别，这 8 个消息级别定义在文件 include/linux/kern\_levels.h 里面，定义如下：

#define KERN_SOH "\001"
    #define KERN_EMERG KERN_SOH "0" /* 紧急事件，一般是内核崩溃 */
    #define KERN_ALERT KERN_SOH "1" /* 必须立即采取行动 */
    #define KERN_CRIT KERN_SOH "2" /* 临界条件，比如严重的软件或硬件错误*/
    #define KERN_ERR KERN_SOH "3" /* 错误状态，一般设备驱动程序中使用KERN_ERR 报告硬件错误 */
    #define KERN_WARNING KERN_SOH "4" /* 警告信息，不会对系统造成严重影响 */
    #define KERN_NOTICE KERN_SOH "5" /* 有必要进行提示的一些信息 */
    #define KERN_INFO KERN_SOH "6" /* 提示性的信息 */
    #define KERN_DEBUG KERN_SOH "7" /* 调试信息 */

一共定义了 8 个级别，其中 0 的优先级最高，7 的优先级最低。如果要设置消息级别，参考如下示例：

printk(KERN_EMERG "gsmi: Log Shutdown Reason\n");

上述代码就是设置“gsmi: Log Shutdown Reason\\n”这行消息的级别为 KERN\_EMERG。在具体的消息前面加上 KERN\_EMERG 就可以将这条消息的级别设置为 KERN\_EMERG。如果使用 printk 的 时 候 不 显 式 的 设 置 消 息 级 别 ， 那 么 printk 将 会 采 用 默 认 级 别MESSAGE\_LOGLEVEL\_DEFAULT，MESSAGE\_LOGLEVEL\_DEFAULT 默认为 4。

在 include/linux/printk.h 中有个宏 CONSOLE\_LOGLEVEL\_DEFAULT，定义如下：

#define CONSOLE_LOGLEVEL_DEFAULT 7

CONSOLE\_LOGLEVEL\_DEFAULT 控制着哪些级别的消息可以显示在控制台上，此宏默认为 7，意味着只有优先级高于 7 的消息才能显示在控制台上。  
这个就是 printk 和 printf 的最大区别，可以通过消息级别来决定哪些消息可以显示在控制台上。默认消息级别为 4，4 的级别比 7 高，所示直接使用 printk 输出的信息是可以显示在控制台上的。  
参数 filp 有个叫做 private\_data 的成员变量，private\_data 是个 void 指针，一般在驱动中将private\_data 指向设备结构体，设备结构体会存放设备的一些属性。

copy\_to\_user 函数原型如下：

static inline long copy_to_user(void __user *to, const void *from, unsigned long n)

5.3.编写测试APP：

C库文件操作基本函数：  
编写测试 APP 就是编写 Linux 应用，需要用到 C 库里面和文件操作有关的一些函数，比如open、read、write 和 close 这四个函数。

open函数的原型如下：

int open(const char *pathname, int flags)

open 函数参数含义如下：  
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。  
> 返回值：如果文件打开成功的话返回文件的文件描述符。

在 Ubuntu 中输入“man 2 open”即可查看 open 函数的详细内容。

read函数：

ssize_t read(int fd, void *buf, size_t count)

read 函数参数含义如下：  
fd：要读取的文件描述符，读取文件之前要先用 open 函数打开文件，open 函数打开文件成功以后会得到文件描述符。  
buf：数据读取到此 buf 中。  
count：要读取的数据长度，也就是字节数。  
返回值：读取成功的话返回读取到的字节数；如果返回 0 表示读取到了文件末尾；如果返回负值，表示读取失败。在 Ubuntu 中输入“man 2 read”命令即可查看 read 函数的详细内容。

write函数：

ssize_t write(int fd, const void *buf, size_t count);

write 函数参数含义如下：  
fd：要进行写操作的文件描述符，写文件之前要先用 open 函数打开文件，open 函数打开文件成功以后会得到文件描述符。  
buf：要写入的数据。  
count：要写入的数据长度，也就是字节数。  
返回值：写入成功的话返回写入的字节数；如果返回 0 表示没有写入任何数据；如果返回负值，表示写入失败。在 Ubuntu 中输入“man 2 write”命令即可查看 write 函数的详细内容。

close函数：

int close(int fd);

close 函数参数含义如下：  
fd：要关闭的文件描述符。  
返回值：0 表示关闭成功，负值表示关闭失败。在 Ubuntu 中输入“man 2 close”命令即可查看 close 函数的详细内容。

驱动编写好以后是需要测试的，一般编写一个简单的测试 APP，测试 APP 运行在用户空间。测试 APP 很简单通过输入相应的指令来对 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 <1>|<2>
      			 argv[2] 1:读文件
      			 argv[2] 2:写文件		
    论坛 	   	: www.openedv.com
    日志	   	: 初版V1.0 哒宰创建
    ***************************************************************/
    
    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!\r\n");
    		return -1;
    	}
    
    	filename = argv[1];
    
    	/* 打开驱动文件 */
    	fd  = open(filename, O_RDWR);
    	if(fd < 0){
        
    		printf("Can't open file %s\r\n", filename);
    		return -1;
    	}
    
    	if(atoi(argv[2]) == 1){
         /* 从驱动文件读取数据 */
    		retvalue = read(fd, readbuf, 50);
    		if(retvalue < 0){
        
    			printf("read file %s failed!\r\n", filename);
    		}else{
        
    			/*  读取成功，打印出读取成功的数据 */
    			printf("read data:%s\r\n",readbuf);
    		}
    	}
    
    	if(atoi(argv[2]) == 2){
        
     	/* 向设备驱动写数据 */
    		memcpy(writebuf, usrdata, sizeof(usrdata));
    		retvalue = write(fd, writebuf, 50);
    		if(retvalue < 0){
        
    			printf("write file %s failed!\r\n", filename);
    		}
    	}
    
    	/* 关闭设备 */
    	retvalue = close(fd);
    	if(retvalue < 0){
        
    		printf("Can't close file %s\r\n", filename);
    		return -1;
    	}
    
    	return 0;
    }

判断运行测试 APP 的时候输入的参数是不是为 3 个，main 函数的 argc 参数表示参数数量，argv\[\]保存着具体的参数，如果参数不为 3 个的话就表示测试 APP 用法错误。比如，现在要从 chrdevbase 设备中读取数据，需要输入如下命令：

./chrdevbaseApp /dev/chrdevbase 1

上述命令一共有三个参数“./chrdevbaseApp”、“/dev/chrdevbase”和“1”，这三个参数分别对应 argv\[0\]、argv\[1\]和 argv\[2\]。第一个参数表示运行 chrdevbaseAPP 这个软件，第二个参数表示测试APP要打开/dev/chrdevbase这个设备。第三个参数就是要执行的操作，1表示从chrdevbase中读取数据，2 表示向 chrdevbase 写数据。

5.4.编译驱动程序和测试app：

首先编译驱动程序，也就是 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

KERNELDIR 表示开发板所使用的 Linux 内核源码目录，使用绝对路径，大家根据自己的实际情况填写即可。  
CURRENT\_PATH 表示当前路径，直接通过运行“pwd”命令来获取当前所处路径。  
obj-m 表示将 chrdevbase.c 这个文件编译为 chrdevbase.ko 模块。

具体的编译命令，后面的 modules 表示编译模块，-C 表示将当前的工作目录切换到指定目录中，也就是 KERNERLDIR 目录。M 表示模块源码目录，“make modules”命令中加入 M=dir 以后程序会自动到指定的 dir 目录中读取模块的源码并将其编译为.ko 文件。

Makefile 编写好以后输入“make”命令编译驱动模块；

编译成功以后就会生成一个叫做 chrdevbaes.ko 的文件，此文件就是 chrdevbase 设备的驱动模块。至此，chrdevbase 设备的驱动就编译成功。

编译测试 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 芯片下运行。

**5.5.运行测试：**

启动 Linux 系统，检查开发板根文件系统中有没有“/lib/modules/4.1.15”这个目录，如果没有的话自行创建。  
拷 贝 完 成 以 后 就 会 在 开 发 板 的 /lib/modules/4.1.15 目 录 下 存 在 chrdevbase.ko 和chrdevbaseAPP 这两个文件。

输入如下命令加载 chrdevbase.ko 驱动文件：

insmod chrdevbase.ko
    或
    modprobe chrdevbase.ko

如果使用 modprobe 加载驱动的话，可能会出现如图：  
![在这里插入图片描述][9c02dd8f396e49fb88f0c4165fe16ce7.png]  
可以看出，modprobe 提示无法打开“modules.dep”这个文件，因此驱动挂载失败了。我们不用手动创建 modules.dep 这个文件，直接输入 depmod 命令即可自动生成modules.dep，有些根文件系统可能没有 depmod 这个命令，如果没有这个命令就只能重新配置busybox，使能此命令，然后重新编译 busybox。输入“depmod”命令以后会自动生成 modules.alias、  
modules.symbols 和 modules.dep 这三个文件。  
![在这里插入图片描述][3ce62c833c7246e096e4dcf17a03cb35.png]  
可以看到“chrdevbase init！”这一行，这一行正是 chrdevbase.c 中模块入口函数 chrdevbase\_init 输出的信息，说明模块加载成功！  
输入“lsmod”命令即可查看当前系统中存在的模块，结果如图：  
![在这里插入图片描述][74b984828cd04fdd825eb2636f252841.png]  
可以看出，当前系统只有“chrdevbase”这一个模块。输入如下命令查看当前系统中有没有 chrdevbase 这个设备：

cat /proc/devices

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 4]  
**创建设备节点文件：**  
驱动加载成功需要在/dev 目录下创建一个与之对应的设备节点文件，应用程序就是通过操作这个设备节点文件来完成对具体设备的操作。输入如下命令创建/dev/chrdevbase 这个设备节点文件：

mknod /dev/chrdevbase c 200 0

其中“mknod”是创建节点命令，“/dev/chrdevbase”是要创建的节点文件，“c”表示这是个字符设备，“200”是设备的主设备号，“0”是设备的次设备号。创建完成以后就会存在/dev/chrdevbase 这个文件，可以使用“ls /dev/chrdevbase -l”命令查看，结果如图：  
![在这里插入图片描述][4bc8bf69c13244c1b9127e96f3c0846b.png]  
如果 chrdevbaseAPP 想要读写 chrdevbase 设备，直接对/dev/chrdevbase 进行读写操作即可。  
相当于/dev/chrdevbase 这个文件是 chrdevbase 设备在用户空间中的实现。前面一直说 Linux 下一切皆文件，包括设备也是文件，现在大家应该是有这个概念了吧？

**chrdevbase 设备操作测试**  
一切准备就绪，接下来就是“大考”的时刻了。使用 chrdevbaseApp 软件操作 chrdevbase 这个设备，看看读写是否正常，首先进行读操作，输入如下命令：

./chrdevbaseApp /dev/chrdevbase 1

![在这里插入图片描述][546edc84913e47e9b71cd393ae4ea634.png]  
可以看出，首先输出“kernel senddata ok!”这一行信息，这是驱动程序中chrdevbase\_read 函数输出的信息，因为 chrdevbaseAPP 使用 read 函数从 chrdevbase 设备读取数据，因此 chrdevbase\_read 函数就会执行。chrdevbase\_read 函数向 chrdevbaseAPP 发送“kernel data!”数据，chrdevbaseAPP 接收到以后就打印出来，“read data:kernel data!”就是 chrdevbaseAPP打印出来的接收到的数据。说明对 chrdevbase 的读操作正常，接下来测试对 chrdevbase 设备的写操作，输入如下命令：

./chrdevbaseApp /dev/chrdevbase 2

![在这里插入图片描述][6d595877e8864f5eb1965669b56c65c8.png]  
只有一行“kernel recevdata:usr data!”，这个是驱动程序中的 chrdevbase\_write 函数输出的。chrdevbaseAPP 使用 write 函数向 chrdevbase 设备写入数据“usr data!”。chrdevbase\_write 函数接收到以后将其打印出来。说明对 chrdevbase 的写操作正常，既然读写都没问题，说明我们编写的 chrdevbase 驱动是没有问题的。

**卸载驱动模块**  
如果不再使用某个设备的话可以将其驱动卸载掉，比如输入如下命令卸载掉 chrdevbase 这个设备：

rmmod chrdevbase.ko
    lsmod

此时系统已经没有任何模块了，chrdevbase 这个模块也不存在了，说明模块卸载成功。

至此，chrdevbase 这个设备的整个驱动就验证完成了，驱动工作正常。本章我们详细的讲解了字符设备驱动的开发步骤，并且以一个虚拟的 chrdevbase 设备为例，带领大家完成了第一个字符设备驱动的开发，掌握了字符设备驱动的开发框架以及测试方法，以后的字符设备驱动实验基本都以此为\*\*蓝本\*\*。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70]: /images/20220829/8ed192d7139547f5b7b781571eadb283.png
[ec9f2bb11579488788cd12cd76c98342.png]: /images/20220829/fa1678a6f1eb4df289c9e110fe80bdb4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 1]: /images/20220829/b80ac479ea0d4877bf8213a375e90eb7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 2]: /images/20220829/4e9f0e10e8be4723b3fe35bcabd572c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 3]: /images/20220829/9d873208c0ee43b89c1ba2ccfd0e55ac.png
[9c02dd8f396e49fb88f0c4165fe16ce7.png]: /images/20220829/19f9818b47b44556b74a7715cbdfe618.png
[3ce62c833c7246e096e4dcf17a03cb35.png]: /images/20220829/da38f47b03da43e499b1dea24c363764.png
[74b984828cd04fdd825eb2636f252841.png]: /images/20220829/a1a6e158342146c4aec10be27738e2b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 4]: /images/20220829/f3574491d79d40d6a3e4f1a816bc68cb.png
[4bc8bf69c13244c1b9127e96f3c0846b.png]: /images/20220829/bcb6846b4e1c4c50a3ad306c3e77433f.png
[546edc84913e47e9b71cd393ae4ea634.png]: /images/20220829/4edca19c11684e2190f13032f2c23ca9.png
[6d595877e8864f5eb1965669b56c65c8.png]: /images/20220829/89577cc0e8ff459a87110ddd54443266.png