02_字符设备驱动开发

目录

1 字符设备驱动简介

2 字符设备驱动开发步骤

2.1 驱动模块的加载和卸载

2.2 字符设备注册与注销

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

2.4 添加 LICENSE 和作者信息

3 Linux 设备号

3.1 设备号的组成

3.2 设备号的分配

1、静态分配设备号

2、动态分配设备号

4 chrdevbase 字符设备驱动开发实验

4.1 实验程序编写

1、创建工程

2、编写实验程序

4.2 编写测试APP

1、C 库文件操作基本函数

2、编写测试 APP 程序

4.3 编译驱动程序和测试 APP

1、编译驱动程序

2、编译测试 APP

4.4 运行测试

1、加载驱动模块

2、创建设备节点文件

3、chrdevbase 设备操作测试

4、卸载驱动模块

---

1 字符设备驱动简介

        字符设备是 Linux 驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的 LED、按键、IIC、SPI，LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。

2 字符设备驱动开发步骤

        要按照其规定的驱动框架来编写驱动。

2.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 函数就会被调用。字符设备驱动模块加载和卸载模板如下所示：

/* 驱动入口函数 */
static int __init xxx_init(void)//定义了个名为 xxx_init 的驱动入口函数，并且使用了“__init”来修饰。
{
/* 入口函数具体内容 */
return 0;
}

/* 驱动出口函数 */
static void __exit xxx_exit(void)//定义了个名为 xxx_exit 的驱动出口函数，并且使用了“__exit”来修饰。
{
/* 出口函数具体内容 */
}

/* 将上面两个函数指定为驱动的入口和出口函数 */
module_init(xxx_init);//调用函数 module_init 来声明 xxx_init 为驱动入口函数，当加载驱动的时候xxx_init 函数就会被调用。
module_exit(xxx_exit);//调用函数 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/<kernel-version>目录中查找模块，比如本书使用的 Linux kernel 的版本号为 4.14.0，因此 modprobe 命令默认会到/lib/modules/4.14.0 这个目录中查找相应的驱动模块，一般自己制作的根文件系统中是不会有这个目录的，所以需要自己手动创建。

        驱动模块的卸载使用命令“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 中进行。字符设备的注册和注销示例代码内容如下所示：

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

/* 驱动入口函数 */
static int __init xxx_init(void)
{
    /* 入口函数具体内容 */
    int retvalue = 0;

    /* 注册字符设备驱动 */
    retvalue = register_chrdev(200, "chrtest", &test_fops);//调用函数 register_chrdev 注册字符设备，主设备号为 200，设备名为“chrtest”，设备操作函数集合就是第 1 行定义的 test_fops。
    if(retvalue < 0){
        /* 字符设备注册失败,自行处理 */
    }
    return 0;
}

/* 驱动出口函数 */
static void __exit xxx_exit(void)
{
    /* 注销字符设备驱动 */
    unregister_chrdev(200, "chrtest");//调用函数 unregister_chrdev 注销主设备号为 200 的这个设备。
}

/* 将上面两个函数指定为驱动的入口和出口函数 */
module_init(xxx_init);
module_exit(xxx_exit);

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

2.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 这四个成员变量。

2.4 添加 LICENSE 和作者信息

        最后我们需要在驱动中加入 LICENSE 信息和作者信息，其中 LICENSE 是必须添加的，否则的话编译的时候会报错，作者信息可以添加也可以不添加。LICENSE 和作者信息的添加使用如下两个函数：

MODULE_LICENSE() //添加模块 LICENSE 信息
MODULE_AUTHOR() //添加模块作者信息

最后给加入设备操作函数的示例代码加入 LICENSE 和作者信息，完成以后的内容如下：

/* 打开设备 */
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);

MODULE_LICENSE("GPL");//LICENSE 采用 GPL 协议。
MODULE_AUTHOR("alientek");//添加作者名字。

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

3 Linux 设备号

3.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/intll64.h 里面，定义如下：
typedef unsigned int __u32;

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

​​

#define MINORBITS 20//宏 MINORBITS 表示次设备号位数，一共是 20 位。
#define MINORMASK ((1U << MINORBITS) - 1)//宏 MINORMASK 表示次设备号掩码。

#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))//宏 MAJOR 用于从 dev_t 中获取主设备号，将 dev_t 右移 20 位即可。
#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))//宏 MINOR 用于从 dev_t 中获取次设备号，取 dev_t 的低 20 位的值即可。
#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))//宏 MKDEV 用于将给定的主设备号和次设备号的值组合成 dev_t 类型的设备号。

3.2 设备号的分配

1、静态分配设备号

2、动态分配设备号

        静态分配设备号需要我们检查当前系统中所有被使用了的设备号，然后挑选一个没有使用的。而且静态分配设备号很容易带来冲突问题，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 开始，要释放的设备号数量。

4 chrdevbase 字符设备驱动开发实验

4.1 实验程序编写

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

1、创建工程

        在 Ubuntu 中创建一个目录用来存放 Linux 驱动程序。

2、编写实验程序

#include <linux/types.h> 
#include <linux/kernel.h> 
#include <linux/delay.h> 
#include <linux/ide.h> 
#include <linux/init.h> 
#include <linux/module.h> 
 
 #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("alientek");

        chrdevbase_open 函数，当应用程序调用 open 函数的时候此函数就会调用，本例程中我们没有做任何工作，只是输出一串字符，用于调试。这里使用了 printk 来输出信息，而不是 printf。因为在 Linux 内核中没有 printf 这个函数。printk 相当于 printf 的孪

生兄妹，printf 运行在用户态，printk 运行在内核态。在内核中想要向控制台输出或显示一些内容，必须使用 printk 这个函数。不同之处在于，printk 可以根据日志级别对消息进行分类，一共有 8 个消息级别，这 8 个消息级别定义在文件 include/linux/kern_levels.h 里面，定义如下：

#define KERN_SOH "\001" /* ASCII Start Of Header */
#define KERN_SOH_ASCII '\001'

#define KERN_EMERG KERN_SOH "0" /* system is unusable */
#define KERN_ALERT KERN_SOH "1" /* action must be taken immediately */
#define KERN_CRIT KERN_SOH "2" /* critical conditions */
#define KERN_ERR KERN_SOH "3" /* error conditions */
#define KERN_WARNING KERN_SOH "4" /* warning conditions */
#define KERN_NOTICE KERN_SOH "5" /* normal but significant condition */
#define KERN_INFO KERN_SOH "6" /* informational */
#define KERN_DEBUG KERN_SOH "7" /* debug-level messages */

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

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

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

        在 include/linux/printk.h 中有个宏 CONSOLE_LOGLEVEL_DEFAULT，定义如下：

/*
* Default used to be hard-coded at 7, we're now allowing it to be set from
* kernel config.
*/
#define CONSOLE_LOGLEVEL_DEFAULT CONFIG_CONSOLE_LOGLEVEL_DEFAULT

        CONSOLE_LOGLEVEL_DEFAULT 控制着哪些级别的消息可以显示在控制台上，从注释可知此宏默认为 7，意味着只有优先级高于 7 的消息才能显示在控制台上。

        参数 filp 有个叫做 private_data 的成员变量，private_data 是个 void 指针，一般在驱动中将 private_data 指向设备结构体，设备结构体会存放设备的一些属性。

        chrdevbase_read 函数，应用程序调用 read 函数从设备中读取数据的时候此函数会执行。参数 buf 是用户空间的内存，读取到的数据存储在 buf 中，参数 cnt 是要读取的字节数，参数 offt 是相对于文件首地址的偏移。kerneldata 里面保存着用户空间要读取的数据，先将 kerneldata 数组中的数据拷贝到读缓冲区 readbuf 中，通过函数 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，如果复制失败则返回负数。

        chrdevbase_write 函数，应用程序调用 write 函数向设备写数据的时候此函数就会执行。参数 buf 就是应用程序要写入设备的数据，也是用户空间的内存，参数 cnt 是要写入的数据长度，参数 offt 是相对文件首地址的偏移。第 75 行通过函数 copy_from_user 将 buf 中的数据复制到写缓冲区 writebuf 中，因为用户空间内存不能直接访问内核空间的内存，所以需要借助函数 copy_from_user 将用户空间的数据复制到 writebuf 这个内核空间中。

        chrdevbase_release 函数，应用程序调用 close 关闭设备文件的时候此函数会执行，一般会在此函数里面执行一些释放操作。如果在 open 函数中设置了 filp 的 private_data 成员变量指向设备结构体，那么在 release 函数最终就要释放掉。

4.2 编写测试APP

1、C 库文件操作基本函数

①、open 函数

②、read 函数

③、write 函数

④、close 函数

2、编写测试 APP 程序

新建 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"

 static char usrdata[] = {"usr data!"};//数组 usrdata 是测试 APP 要向 chrdevbase 设备写入的数据

 /*
 * @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;
}

4.3 编译驱动程序和测试 APP

1、编译驱动程序

        在目录中创建一个 Makefile 文件，然后在其中输入如下内容：

KERN_DIR := /home/wurao/zynq/linux/kernel/linux-xlnx-xilinx-v2018.3

obj-m := chrdevbase.o


all:
    make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -C $(KERN_DIR) M=`pwd` modules

clean:
    make -C $(KERN_DIR) M=`pwd` clean

        第 1 行，KERN_DIR 表示开发板所使用的 Linux 内核源码目录，使用绝对路径，大家根据

自己的实际情况填写即可。

        第 3 行，obj-m 表示将 chrdevbase.c 这个文件编译为模块。

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

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

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

2、编译测试 APP

        测试 APP 比较简单，只有一个文件，因此就不需要编写 Makefile 了，直接输入命令编译。因为测试 APP 是要在 ARM 开发板上运行的，所以需要使用 arm-linux-gnueabihf-gcc 来编译，输入如下命令：

arm-linux-gnueabihf-gcc chrdevbaseApp.c -o chrdevbaseApp

        编译完成以后会生成一个叫做 chrdevbaseApp 的可执行程序，输入如下命令查看 chrdevbaseApp 这个程序的文件信息：

file chrdevbaseApp

4.4 运行测试

1、加载驱动模块

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

depmod

modprobe chrdevbase.ko

         输入“lsmod”命令即可查看当前系统中存在的模块.

        从上图可以看出，当前系统只有“chrdevbase”这一个模块。输入如下命令查看当前系统中有没有 chrdevbase 这个设备：

cat /proc/devices | grep 'chr' //查看当前系统中的所有设备

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 下一切皆文件，包括设备也是文件，现在大家应该是有这个概念了吧。

3、chrdevbase 设备操作测试

./chrdevbaseApp /dev/chrdevbase 1

./chrdevbaseApp /dev/chrdevbase 2

4、卸载驱动模块

rmmod chrdevbase.ko

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