嵌入式Linux应用开发-基础知识-第二章 Hello驱动

第二章 Hello 驱动(不涉及硬件操作)

我们选用的内核都是 4.x 版本，操作都是类似的：

rk3399 linux 4.4.154 
rk3288 linux 4.4.154 
imx6ul linux 4.9.88 
am3358 linux 4.9.168 

2.1 APP 打开的文件在内核中如何表示

APP 打开文件时，可以得到一个整数，这个整数被称为文件句柄。对于 APP 的每一个文件句柄，在内核里面都有一个“struct file”与之对应。

可以猜测，我们使用 open 打开文件时，传入的 flags、mode 等参数会被记录在内核中对应的 struct
file 结构体里(f_flags、f_mode)：
int open(const char *pathname, int flags, mode_t mode);

去读写文件时，文件的当前偏移地址也会保存在 struct file 结构体的 f_pos 成员里。

2.2 打开字符设备节点时，内核中也有对应的 struct file

注意这个结构体中的结构体：struct file_operations *f_op，这是由驱动程序提供的。

结构体 struct file_operations 的定义如下：

2.3 请猜猜怎么编写驱动程序

① 确定主设备号，也可以让内核分配
② 定义自己的 file_operations 结构体
③ 实现对应的 drv_open/drv_read/drv_write 等函数，填入 file_operations 结构体
④ 把 file_operations 结构体告诉内核：register_chrdev
⑤ 谁来注册驱动程序啊？得有一个入口函数：安装驱动程序时，就会去调用这个入口函数
⑥ 有入口函数就应该有出口函数：卸载驱动程序时，出口函数调用 unregister_chrdev
⑦ 其他完善：提供设备信息，自动创建设备节点：class_create, device_create

2.4 请不要啰嗦，表演你的代码吧

2.4.1 写驱动程序

参考 driver/char 中的程序，包含头文件，写框架，传输数据：
A. 驱动中实现 open, read, write, release，APP 调用这些函数时，都打印内核信息
B. APP 调用 write 函数时，传入的数据保存在驱动中
C. APP 调用 read 函数时，把驱动中保存的数据返回给 APP

使用 GIT 下载所有源码后，本节源码位于如下目录：

01_all_series_quickstart\ 
05_嵌入式 Linux 驱动开发基础知识\source\01_hello_drv\hello_drv.c 

hello_drv.c 源码如下：

01 #include <linux/module.h> 
02 
03 #include <linux/fs.h> 
04 #include <linux/errno.h> 
05 #include <linux/miscdevice.h> 
06 #include <linux/kernel.h> 
07 #include <linux/major.h> 
08 #include <linux/mutex.h> 
09 #include <linux/proc_fs.h> 
10 #include <linux/seq_file.h> 
11 #include <linux/stat.h> 
12 #include <linux/init.h> 
13 #include <linux/device.h> 
14 #include <linux/tty.h> 
15 #include <linux/kmod.h> 
16 #include <linux/gfp.h> 
17 
18 /* 1. 确定主设备号 */ 
19 static int major = 0; 
20 static char kernel_buf[1024]; 
21 static struct class *hello_class; 
22 
23 
24 #define MIN(a, b) (a < b ? a : b) 
25 
26 /* 3. 实现对应的 open/read/write 等函数，填入 file_operations 结构体 */ 
27 static ssize_t hello_drv_read (struct file *file, char __user *buf, size_t size, loff_t 
*offset) 
28 { 
29 int err;
30 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); 
31 err = copy_to_user(buf, kernel_buf, MIN(1024, size)); 
32 return MIN(1024, size); 
33 } 
34 
35 static ssize_t hello_drv_write (struct file *file, const char __user *buf, size_t size, 
loff_t *offset) 
36 { 
37 int err; 
38 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); 
39 err = copy_from_user(kernel_buf, buf, MIN(1024, size)); 
40 return MIN(1024, size); 
41 } 
42 
43 static int hello_drv_open (struct inode *node, struct file *file) 
44 { 
45 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); 
46 return 0; 
47 } 
48 
49 static int hello_drv_close (struct inode *node, struct file *file) 
50 { 
51 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); 
52 return 0; 
53 } 
54 
55 /* 2. 定义自己的 file_operations 结构体 */ 
56 static struct file_operations hello_drv = { 
57 .owner = THIS_MODULE, 
58 .open = hello_drv_open, 
59 .read = hello_drv_read, 
60 .write = hello_drv_write, 
61 .release = hello_drv_close, 
62 }; 
63 
64 /* 4. 把 file_operations 结构体告诉内核：注册驱动程序 */ 
65 /* 5. 谁来注册驱动程序啊？得有一个入口函数：安装驱动程序时，就会去调用这个入口函数 */ 
66 static int __init hello_init(void) 
67 { 
68 int err; 
69 
70 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); 
71 major = register_chrdev(0, "hello", &hello_drv); /* /dev/hello */ 
72 
73 
74 hello_class = class_create(THIS_MODULE, "hello_class"); 
75 err = PTR_ERR(hello_class); 
76 if (IS_ERR(hello_class)) { 
77 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); 
78 unregister_chrdev(major, "hello"); 
79 return -1; 
80 } 
81 
82 device_create(hello_class, NULL, MKDEV(major, 0), NULL, "hello"); /* /dev/hello 
*/ 
 83 
84 return 0; 
85 } 
86 
87 /* 6. 有入口函数就有出口函数：卸载驱动程序时就会去调用这个出口函数 */ 
88 static void __exit hello_exit(void) 
89 { 
90 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); 
91 device_destroy(hello_class, MKDEV(major, 0)); 
92 class_destroy(hello_class); 
93 unregister_chrdev(major, "hello"); 
94 } 
95 
96 
97 /* 7. 其他完善：提供设备信息，自动创建设备节点 */ 
98 
99 module_init(hello_init); 
100 module_exit(hello_exit); 
101 
102 MODULE_LICENSE("GPL"); 
103 

阅读一个驱动程序，从它的入口函数开始，第 66 行就是入口函数。它的主要工作就是第 71 行，向内
核注册一个 file_operations 结构体：hello_drv，这就是字符设备驱动程序的核心。
file_operations 结构体 hello_drv 在第 56 行定义，里面提供了 open/read/write/release 成员，应
用程序调用 open/read/write/close 时就会导致这些成员函数被调用。
file_operations 结构体 hello_drv 中的成员函数都比较简单，大多数只是打印而已。要注意的是，
驱动程序和应用程序之间传递数据要使用 copy_from_user/copy_to_user 函数。

2.4.2 写测试程序

测试程序要实现写、读功能：
A. ./hello_drv_test -w wiki.xxxxxx.net // 把字符串“wiki.xxxxxx.net”发给驱动程序
B. ./hello_drv_test -r // 把驱动中保存的字符串读回来

使用 GIT 下载所有源码后，本节源码位于如下目录：

01_all_series_quickstart\ 
05_嵌入式 Linux 驱动开发基础知识\source\01_hello_drv\hello_drv_test.c 

hello_drv_test.c 源码如下：

01 
02 #include <sys/types.h> 
03 #include <sys/stat.h> 
04 #include <fcntl.h> 
05 #include <unistd.h> 
06 #include <stdio.h> 
07 #include <string.h> 
08 
09 /* 
10 * ./hello_drv_test -w abc 
11 * ./hello_drv_test -r 
12 */ 
13 int main(int argc, char **argv) 
14 { 
15 int fd; 
16 char buf[1024]; 
17 int len; 
18 
19 /* 1. 判断参数 */ 
20 if (argc < 2) 
21 { 
22 printf("Usage: %s -w \n", argv[0]); 
23 printf(" %s -r\n", argv[0]); 
24 return -1; 
25 } 
26 
27 /* 2. 打开文件 */ 
28 fd = open("/dev/hello", O_RDWR); 
29 if (fd == -1) 
30 { 
31 printf("can not open file /dev/hello\n"); 
32 return -1; 
33 } 
34 
35 /* 3. 写文件或读文件 */ 
36 if ((0 == strcmp(argv[1], "-w")) && (argc == 3)) 
37 { 
38 len = strlen(argv[2]) + 1; 
39 len = len < 1024 ? len : 1024; 
40 write(fd, argv[2], len); 
41 } 
42 else 
43 { 
44 len = read(fd, buf, 1024); 
45 buf[1023] = '\0'; 
46 printf("APP read : %s\n", buf); 
47 } 
48 
49 close(fd); 
50 
51 return 0; 
52 } 
53 

2.4.3 测试

A. 编写驱动程序的 Makefile
驱动程序中包含了很多头文件，这些头文件来自内核，不同的 ARM 板它的某些头文件可能不同。所以编译驱动程序时，需要指定板子所用的内核的源码路径。
要编译哪个文件？这也需要指定，设置 obj-m 变量即可
怎么把.c 文件编译为驱动程序.ko？这要借助内核的顶层 Makefile。
本驱动程序的 Makefile 内容如下：

01 
02 # 1. 使用不同的开发板内核时, 一定要修改 KERN_DIR 
03 # 2. KERN_DIR 中的内核要事先配置、编译, 为了能编译内核, 要先设置下列环境变量: 
04 # 2.1 ARCH, 比如: export ARCH=arm64 
05 # 2.2 CROSS_COMPILE, 比如: export CROSS_COMPILE=aarch64-linux-gnu06
 # 2.3 PATH, 比如: export PATH=$PATH:/home/book/xxxxxx_roc-rk3399-pc/ToolChain6.3.1/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin

07 # 注意: 不同的开发板不同的编译器上述 3 个环境变量不一定相同, 
08 # 请参考各开发板的高级用户使用手册 
09 
10 KERN_DIR = /home/book/xxxxxx_roc-rk3399-pc/linux-4.4 
11 
12 all: 
13 make -C $(KERN_DIR) M=`pwd` modules 
14 $(CROSS_COMPILE)gcc -o hello_drv_test hello_drv_test.c 
15 
16 clean: 
17 make -C $(KERN_DIR) M=`pwd` modules clean 
18 rm -rf modules.order 
19 rm -f hello_drv_test 
20 
21 obj-m += hello_drv.o 

先设置好交叉编译工具链，编译好你的板子所用的内核，然后修改 Makefile 指定内核源码路径，最
后即可执行 make 命令编译驱动程序和测试程序。

B. 上机实验

注意：我们是在 Ubuntu 中编译程序，但是需要在 ARM 板子上测试。所以需要把程序放到 ARM 板子
上。
启动单板后，可以通过 NFS 挂载 Ubuntu 的某个目录，访问该目录中的程序。
测试示例：
① 在 Ubuntu 上编译好驱动，并它复制到 NFS 目录：

$ cp *.ko hello_drv_test ~/nfs_rootfs/ 

② 在 ARM 板上测试：

# echo "7 4 1 7" > /proc/sys/kernel/printk // 打开内核的打印信息，有些板子默认打开了 
# ifconfig eth0 192.168.1.10 // 配置 ARM 板 IP，下面是挂载 NFS 文件系统 
// 1.如果使用 VMware NAT 网络或 docker，假设 Windows IP 为 192.168.1.100，使用下面命令挂载 NFS 

# mount -t nfs -o nolock,vers=3,port=2049,mountport=9999 192.168.1.100:/home/book/nfs_rootfs /mnt 

// 2.如果使用 VMware 桥接网络，假设 Ubuntu IP 为 192.168.1.100，使用下面命令挂载 NFS 
# mount -t nfs -o nolock,vers=3 192.168.1.100:/home/book/nfs_rootfs /mnt 
# cd /mnt 
# insmod hello_drv.ko // 安装驱动程序 
[ 293.594910] hello_drv: loading out-of-tree module taints kernel. 
[ 293.616051] /home/book/source/01_hello_drv/hello_drv.c hello_init line 70 
# ls /dev/hello -l // 驱动程序会生成设备节点 
crw------- 1 root root 236, 0 Jan 18 08:55 /dev/hello 
# ./hello_drv_test // 查看测试程序的用法 
Usage: ./hello_drv_test -w <string> 
 ./hello_drv_test -r 
# ./hello_drv_test -w wiki.xxxxxx.net // 往驱动程序中写入字符串 
[ 318.360800] /home/book/source/01_hello_drv/hello_drv.c hello_drv_open line 45 
[ 318.372570] /home/book/source/01_hello_drv/hello_drv.c hello_drv_write line 38 
[ 318.382854] /home/book/source/01_hello_drv/hello_drv.c hello_drv_close line 51 
# ./hello_drv_test -r // 从驱动程序中读出字符串 
[ 326.177890] /home/book/source/01_hello_drv/hello_drv.c hello_drv_open line 45 
[ 326.198304] /home/book/source/01_hello_drv/hello_drv.c hello_drv_read line 30 
APP read : wiki.xxxxxx.net 
[ 326.214782] /home/book/source/01_hello_drv/hello_drv.c hello_drv_close line 51 

注意：如果安装驱动时提示 version magic 不匹配，或是污染内核(taint)，请参考这些章节更新内
核：
《第 2 篇 环境搭建、Linux 基本操作、工具使用》
《第九章 开发板的第 1 个驱动程序》

2.5 Hello 驱动中的一些补充知识

2.5.1 module_init/module_exit 的实现

2.5.2 register_chrdev 的内部实现

2.5.3 class_destroy/device_create 浅析