【正点原子Linux连载】 第十三章 Linux按键输入实验 摘自【正点原子】ATK-DLRK3568嵌入式Linux驱动开发指南

1）实验平台：正点原子ATK-DLRK3568开发板
2）平台购买地址：https://detail.tmall.com/item.htm?id=731866264428
3）全套实验源码+手册+视频下载地址： http://www.openedv.com/docs/boards/xiaoxitongban

第十三章 Linux按键输入实验

在前几章我们都是使用的GPIO输出功能，还没有用过GPIO输入功能，本章我们就来学习一下如果在Linux下编写GPIO输入驱动程序。正点原子的ATK-DLRK3568开发板上虽然有5个按键，但是这5个按键是ADC方式驱动的，所以没法用这5个按键来做GPIO输入实验。但是开发板上JP11这个双排排针引出了19个IO，我们使用GPIO3_C5这个引出的IO来完成GPIO输入驱动程序，同时利用第十一章讲的原子操作来对按键值进行保护。

13.1 Linux下按键驱动原理
按键驱动和LED驱动原理上来讲基本都是一样的，都是操作GPIO，只不过一个是读取GPIO的高低电平，一个是从GPIO输出高低电平。本章我们实现按键输入，在驱动程序中使用一个整形变量来表示按键值，应用程序通过read函数来读取按键值，判断按键有没有按下。在这里，这个保存按键值的变量就是个共享资源，驱动程序要向其写入按键值，应用程序要读取按键值。所以我们要对其进行保护，对于整形变量而言我们首选的就是原子操作，使用原子操作对变量进行赋值以及读取。Linux下的按键驱动原理很简单，接下来开始编写驱动。
注意，本章例程只是为了演示Linux下GPIO输入驱动的编写，实际中的按键驱动并不会采用本章中所讲解的方法，Linux下的input子系统专门用于输入设备！
13.2 硬件原理图分析
开发板上的按键都是采用ADC驱动的，而RK3568的ADC引脚不能复用为GPIO。所以不能直接使用按键来完成本实验。我们可以使用JP11这个双排排针引出的GPIO来完成，这里我们使用GPIO3_C5这个引出IO，在开发板原理图上如图13.2.1所示：

图13.2.1 GPIO3_C5引脚
默认情况下GPIO3_C5是低电平，所以我们通过使用杜邦线将图13.2.1中GPIO3_C5这个引脚接到VCC上的方式来模拟按键按下。也就是模拟按键按下，GPIO3_C5为高电平，松开按键为低电平。
13.3 实验程序编写
本实验对应的例程路径为：开发板光盘 01、程序源码 Linux驱动例程源码 10_key
13.3.1 修改设备树文件
1、pinctrl设置
首先打开rk3568-pinctrl.dtsi文件，在pinctrl节点下添加GPIO3_C5的pinctrl信息，内容如下：
示例代码13.3.1.1 创建key-gpios节点

1 	key-gpios{
2   	/omit-if-no-ref/
3   	key_gpio: key-pin {
4       		rockchip,pins =
5           		<3 RK_PC5 RK_FUNC_GPIO &pcfg_pull_none>;
6   	};
7 };
1
2
3
4
5
6
7

示例代码13.3.1.1是按键所用的GPIO3_C5这个GPIO的pinctrl信息，也就是设置GPIO3_C5为GPIO模式，无上下拉。
继续打开rk3568-atk-evb1-ddr4-v10.dtsi文件，在根节点“/”下创建KEY节点，节点名为“key”，节点内容如下：
1
2

示例代码13.3.1.2 创建KEY节点

1 key {
2     compatible = "alientek,key";
3     pinctrl-0 = <&key_gpio>;
4     pinctrl-names = "alientek,key";
5     key-gpio = <&gpio3 RK_PC5 GPIO_ACTIVE_HIGH>;
6     status = "okay";
7 };
1
2
3
4
5
6
7

第5行，key-gpio属性指定了KEY所使用的GPIO，高电平有效。
13.3.2 按键驱动程序编写
设备树准备好以后就可以编写驱动程序了，新建名为“10_key”的文件夹，然后在10_key文件夹里面创建vscode工程，工作区命名为“key”。工程创建好以后新建key.c文件，在key.c里面输入如下内容：
示例代码13.3.2.1 key.c文件代码

1   #include <linux/types.h>
2   #include <linux/kernel.h>
3   #include <linux/delay.h>
4   #include <linux/ide.h>
5   #include <linux/init.h>
6   #include <linux/module.h>
7   #include <linux/errno.h>
8   #include <linux/gpio.h>
9   #include <linux/cdev.h>
10  #include <linux/device.h>
11  #include <linux/of.h>
12  #include <linux/of_address.h>
13  #include <linux/of_gpio.h>
14  #include <linux/semaphore.h>
15  //#include <asm/mach/map.h>
16  #include <asm/uaccess.h>
17  #include <asm/io.h>
18  /***************************************************************
19  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
20  文件名       : key.c
21  作者      : 正点原子Linux团队
22  版本      : V1.0
23  描述      : Linux按键输入驱动实验
24  其他      : 无
25  论坛      : www.openedv.com
26  日志      : 初版V1.0 2022/12/23 正点原子Linux团队创建
27  ***************************************************************/
28  #define KEY_CNT     	1       	/* 设备号个数  	*/
29  #define KEY_NAME    	"key" 	/* 名字       	*/
30  
31  /* 定义按键值 */
32  #define KEY0VALUE   	0XF0    /* 按键值      	*/
33  #define INVAKEY     	0X00    /* 无效的按键值	*/
34  
35  /* key设备结构体 */
36  struct key_dev{
37      dev_t devid;            	/* 设备号     	*/
38      struct cdev cdev;       	/* cdev     	*/
39      struct class *class;   	/* 类      		*/
40      struct device *device;  	/* 设备    		*/
41      int major;              	/* 主设备号   	*/
42      int minor;              	/* 次设备号   	*/
43      struct device_node  *nd; /* 设备节点 	*/
44      int key_gpio;           	/* key所使用的GPIO编号        */
45      atomic_t keyvalue;      	/* 按键值      	*/  
46  };
47  
48  static struct key_dev keydev;       /* key设备 */
49  
50  /*
51   * @description 	: 初始化按键IO，open函数打开驱动的时候初始化按键所使用
52   *                    的GPIO引脚。
53   * @param     		: 无
54   * @return      	: 无
55   */
56  static int keyio_init(void)
57  {
58      int ret;
59      const char *str;
60      
61      /* 设置LED所使用的GPIO */
62      /* 1、获取设备节点：keydev */
63      keydev.nd = of_find_node_by_path("/key");
64      if(keydev.nd == NULL) {
65          printk("keydev node not find!\r\n");
66          return -EINVAL;
67      }
68  
69      /* 2.读取status属性 */
70      ret = of_property_read_string(keydev.nd, "status", &str);
71      if(ret < 0) 
72          return -EINVAL;
73  
74      if (strcmp(str, "okay"))
75          return -EINVAL;
76      
77      /* 3、获取compatible属性值并进行匹配 */
78      ret = of_property_read_string(keydev.nd, "compatible", &str);
79      if(ret < 0) {
80          printk("keydev: Failed to get compatible property\n");
81          return -EINVAL;
82      }
83  
84      if (strcmp(str, "alientek,key")) {
85          printk("keydev: Compatible match failed\n");
86          return -EINVAL;
87      }
88  
89      /* 4、 获取设备树中的gpio属性，得到KEY0所使用的KYE编号 */
90      keydev.key_gpio = of_get_named_gpio(keydev.nd, "key-gpio", 0);
91      if(keydev.key_gpio < 0) {
92          printk("can't get key-gpio");
93          return -EINVAL;
94      }
95      printk("key-gpio num = %d\r\n", keydev.key_gpio);
96  
97      /* 5.向gpio子系统申请使用GPIO */
98      ret = gpio_request(keydev.key_gpio, "KEY0");
99      if (ret) {
100         printk(KERN_ERR "keydev: Failed to request key-gpio\n");
101         return ret;
102     }
103 
104     /* 6、设置GPIO3_C5输入模式 */
105     ret = gpio_direction_input(keydev.key_gpio);
106     if(ret < 0) {
107         printk("can't set gpio!\r\n");
108         return ret;
109     }
110     return 0;
111 }
112 
113 /*
114  * @description  	: 打开设备
115  * @param – inode	: 传递给驱动的inode
116  * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
117  *                    一般在open的时候将private_data指向设备结构体。
118  * @return       	: 0 成功;其他 失败
119  */
120 static int key_open(struct inode *inode, struct file *filp)
121 {
122     int ret = 0;
123     filp->private_data = &keydev;   /* 设置私有数据 */
124 
125     ret = keyio_init();             	/* 初始化按键IO */
126     if (ret < 0) {
127         return ret;
128     }
129 
130     return 0;
131 }
132 
133 /*
134  * @description 	: 从设备读取数据 
135  * @param - filp 	: 要打开的设备文件(文件描述符)
136  * @param - buf  	: 返回给用户空间的数据缓冲区
137  * @param - cnt  	: 要读取的数据长度
138  * @param - offt 	: 相对于文件首地址的偏移
139  * @return        	: 读取的字节数，如果为负值，表示读取失败
140  */
141 static ssize_t key_read(struct file *filp, char __user *buf, 
size_t cnt, loff_t *offt)
142 {
143     int ret = 0;
144     int value;
145     struct key_dev *dev = filp->private_data;
146 
147     if (gpio_get_value(dev->key_gpio) == 1) {       /* key0按下 */
148         while(gpio_get_value(dev->key_gpio));       /* 等待按键释放 */
149         atomic_set(&dev->keyvalue, KEY0VALUE);  
150     } else {    
151         atomic_set(&dev->keyvalue, INVAKEY);        /* 无效的按键值 */
152     }
153 
154     value = atomic_read(&dev->keyvalue);
155     ret = copy_to_user(buf, &value, sizeof(value));
156     return ret;
157 }
158 
159 /*
160  * @description  	: 向设备写数据 
161  * @param - filp 	: 设备文件，表示打开的文件描述符
162  * @param - buf  	: 要写给设备写入的数据
163  * @param - cnt  	: 要写入的数据长度
164  * @param - offt 	: 相对于文件首地址的偏移
165  * @return        	: 写入的字节数，如果为负值，表示写入失败
166  */
167 static ssize_t key_write(struct file *filp, const char __user *buf, 
size_t cnt, loff_t *offt)
168 {
169     return 0;
170 }
171 
172 /*
173  * @description  	: 关闭/释放设备
174  * @param – filp	: 要关闭的设备文件(文件描述符)
175  * @return        	: 0 成功;其他 失败
176  */
177 static int key_release(struct inode *inode, struct file *filp)
178 {
179     struct key_dev *dev = filp->private_data;
180     gpio_free(dev->key_gpio);
181     
182     return 0;
183 }
184 
185 /* 设备操作函数 */
186 static struct file_operations key_fops = {
187     .owner = THIS_MODULE,
188     .open = key_open,
189     .read = key_read,
190     .write = key_write,
191     .release =  key_release,
192 };
193 
194 /*
195  * @description 	: 驱动入口函数
196  * @param       	: 无
197  * @return      	: 无
198  */
199 static int __init mykey_init(void)
200 {
201     int ret;
202     /* 1、初始化原子变量    */
203     keydev.keyvalue= (atomic_t)ATOMIC_INIT(0);
204 
205     /* 2、原子变量初始值为INVAKEY */
206     atomic_set(&keydev.keyvalue, INVAKEY);
207 
208     /* 注册字符设备驱动 */
209     /* 1、创建设备号 */
210     if (keydev.major) {     /*  定义了设备号 */
211         keydev.devid = MKDEV(keydev.major, 0);
212         ret = register_chrdev_region(keydev.devid, KEY_CNT, 
KEY_NAME);
213         if(ret < 0) {
214             pr_err("cannot register %s char driver [ret=%d]\n", 
							KEY_NAME, KEY_CNT);
215             return -EIO;
216         }
217     } else {                        /* 没有定义设备号 */
218         ret = alloc_chrdev_region(&keydev.devid, 0, KEY_CNT, 
KEY_NAME); /* 申请设备号 */
219         if(ret < 0) {
220             pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", 
KEY_NAME, ret);
221             return -EIO;
222         }
223         keydev.major = MAJOR(keydev.devid); /* 获取分配号的主设备号 */
224         keydev.minor = MINOR(keydev.devid); /* 获取分配号的次设备号 */
225     }
226     printk("keydev major=%d,minor=%d\r\n",keydev.major, 
keydev.minor);  
227     
228     /* 2、初始化cdev */
229     keydev.cdev.owner = THIS_MODULE;
230     cdev_init(&keydev.cdev, &key_fops);
231     
232     /* 3、添加一个cdev */
233     cdev_add(&keydev.cdev, keydev.devid, KEY_CNT);
234     if(ret < 0)
235         goto del_unregister;
236         
237     /* 4、创建类 */
238     keydev.class = class_create(THIS_MODULE, KEY_NAME);
239     if (IS_ERR(keydev.class)) {
240         goto del_cdev;
241     }
242 
243     /* 5、创建设备 */
244     keydev.device = device_create(keydev.class, NULL, keydev.devid, 
NULL, KEY_NAME);
245     if (IS_ERR(keydev.device)) {
246         goto destroy_class;
247     }
248     return 0;
249 
250 destroy_class:
251     device_destroy(keydev.class, keydev.devid);
252 del_cdev:
253     cdev_del(&keydev.cdev);
254 del_unregister:
255     unregister_chrdev_region(keydev.devid, KEY_CNT);
256     return -EIO;
257 }
258 
259 /*
260  * @description 	: 驱动出口函数
261  * @param       	: 无
262  * @return      	: 无
263  */
264 static void __exit mykey_exit(void)
265 {
266     /* 注销字符设备驱动 */
267     cdev_del(&keydev.cdev);/*  删除cdev */
268     unregister_chrdev_region(keydev.devid, KEY_CNT); /* 注销设备号 */
269 
270     device_destroy(keydev.class, keydev.devid);
271     class_destroy(keydev.class);
272 }
273 
274 module_init(mykey_init);
275 module_exit(mykey_exit);
276 MODULE_LICENSE("GPL");
277 MODULE_AUTHOR("ALIENTEK");
278 MODULE_INFO(intree, "Y");
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286

第36~46行，结构体key_dev为按键的设备结构体，第45行的原子变量keyvalue用于记录按键值。
第56~111行，函数keyio_init用于初始化按键，从设备树中获取按键的gpio信息，然后设置为输入。这里将按键的初始化代码提取出来，将其作为独立的一个函数有利于提高程序的模块化设计。
第120~131行，key_open函数通过调用keyio_init函数来始化按键所使用的IO，应用程序每次打开按键驱动文件的时候都会初始化一次按键IO。
第141~157行，key_read函数，应用程序通过read函数读取按键值的时候此函数就会执行。第147行读取按键IO的电平，如果为1的话就表示按键按下了，如果按键按下的话第148等待按键释放。按键释放以后标记按键值为0XF0。
第199~257行，驱动入口函数，第206行调用atomic_set函数初始化原子变量默认为无效值。
第264~272行，驱动出口函数。
key.c文件代码很简单，重点就是key_read函数读取按键值，要对keyvalue进行保护。
13.3.3 编写测试APP
新建名为keyApp.c的文件，然后输入如下所示内容：
示例代码13.3.3.1 keyApp.c文件代码

1  #include "stdio.h"
2  #include "unistd.h"
3  #include "sys/types.h"
4  #include "sys/stat.h"
5  #include "fcntl.h"
6  #include "stdlib.h"
7  #include "string.h"
8  /***************************************************************
9  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
10 文件名    	: keyApp.c
11 作者       	: 正点原子Linux团队
12 版本       	: V1.0
13 描述       	: 按键输入测试应用程序
14 其他       	: 无
15 使用方法 	 	：./keyApp /dev/key  
16 论坛       	: www.openedv.com
17 日志       	: 初版V1.0 2021/01/5 正点原子Linux团队创建
18 ***************************************************************/
19 
20 /* 定义按键值 */
21 #define KEY0VALUE  	0XF0
22 #define INVAKEY      	0X00
23 
24 /*
25  * @description  	: main主程序
26  * @param - argc  	: argv数组元素个数
27  * @param - argv  	: 具体参数
28  * @return        	: 0 成功;其他 失败
29  */
30 int main(int argc, char *argv[])
31 {
32  	int fd, ret;
33  	char *filename;
34  	int keyvalue;
35  
36  	if(argc != 2){
37     	 	printf("Error Usage!\r\n");
38      	return -1;
39  	}
40 
41  	filename = argv[1];
42 
43  	/* 打开key驱动 */
44  	fd = open(filename, O_RDWR);
45  	if(fd < 0){
46      	printf("file %s open failed!\r\n", argv[1]);
47      	return -1;
48  	}
49 
50  	/* 循环读取按键值数据！ */
51  	while(1) {
52      	read(fd, &keyvalue, sizeof(keyvalue));
53      	if (keyvalue == KEY0VALUE) {    /* KEY0 */
54          		printf("KEY0 Press, value = %#X\r\n", keyvalue);/* 按下 */
55      	}
56  	}
57 
58  	ret= close(fd); /* 关闭文件 */
59  	if(ret < 0){
60      	printf("file %s close failed!\r\n", argv[1]);
61      	return -1;
62  	}
63  	return 0;
64 }
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

第51~56行，循环读取/dev/key文件，也就是循环读取按键值，并且将按键值打印出来。
13.4 运行测试
13.4.1 编译驱动程序和测试APP
1、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第五章实验基本一样，只是将obj-m变量的值改为key.o，Makefile内容如下所示：
示例代码13.4.1.1 Makefile文件

1  KERNELDIR := /home/alientek/rk3568_linux_sdk/kernel
...... 
4  obj-m := key.o
......
11 clean:
12  $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
1
2
3
4
5
6

第4行，设置obj-m变量的值为key.o。
输入如下命令编译出驱动模块文件：
1
2

make ARCH=arm64 //ARCH=arm64必须指定，否则编译会失败
编译成功以后就会生成一个名为“key.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试keyApp.c这个测试程序：
/opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-gcc keyApp.c -o keyApp
编译成功以后就会生成keyApp这个应用程序。
13.4.2 运行测试
在Ubuntu中将上一小节编译出来的key.ko和keyApp这两个文件通过adb命令发送到开发板的/lib/modules/4.19.232目录下，命令如下：
adb push key.ko keyApp /lib/modules/4.19.232
发送成功以后进入到开发板目录lib/modules/4.19.232中，输入如下命令加载key.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe key //加载驱动
驱动加载成功以后如下命令来测试：
./keyApp /dev/key
输入上述命令以后终端显示如图13.4.2.1所示：

图13.4.2.1测试APP运行界面
从图13.4.2.1可以看出，GPIO3_C5对应的编号是117，GPIO0和GPIO1和GPIO2这三组每个都有32个IO，GPIO3_C5这个IO在GPIO3这一组里面是21号。所以GPIO3_C5在整个GPIO里面的编号就是32*2+21=117号。
使用杜邦线将图13.2.1中GPIO3_C5这个IO接到开发板的3.3V电压上，模拟按键被按下，keyApp就会获取并且输出按键信息，如图13.4.2.2所示：

图13.4.2.2 按键运行结果
从图13.4.2.2可以看出，当我们按下“按键”以后就会打印出“KEY0 Press, value = 0XF0”，表示按键按下。但是大家可能会发现，有时候按下一次“按键”但是会输出好几行“KEY0 Press, value = 0XF0”，这是因为我们的代码没有做按键消抖处理。
如果要卸载驱动的话输入如下命令即可：
rmmod key.ko