嵌入式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 
1
2
3
4

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 
1
2

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 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

阅读一个驱动程序，从它的入口函数开始，第 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 
1
2

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 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

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 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

B. 上机实验

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

$ cp *.ko hello_drv_test ~/nfs_rootfs/ 
1

② 在 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 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

注意：如果安装驱动时提示 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 浅析