🎬 渡水无言 ：个人主页渡水无言
❄专栏传送门 ： 《linux专栏》《嵌入式linux驱动开发》《linux系统移植专栏》
❄专栏传送门 ： 《freertos专栏》 《STM32 HAL库专栏》《linux裸机开发专栏》
❄专栏传送门 ：《产品测评专栏》
⭐️流水不争先，争的是滔滔不绝
📚博主简介：第二十届中国研究生电子设计竞赛全国二等奖 |国家奖学金 | 省级三好学生
| 省级优秀毕业生获得者 | csdn新星杯TOP18 | 半导纵横专栏博主 | 211在读研究生
在这里主要分享自己学习的linux嵌入式领域知识；有分享错误或者不足的地方欢迎大佬指导，也欢迎各位大佬互相三连
目录
前言
上一期博客我们对阻塞与非阻塞IO的机制进行了详解，这一期博客我们来进行一个阻塞IO的实验。
一、回顾按键中断实验
在之前的博客里我们完成了基本的按键中断实验，我们直接在应用程序中通过 read 函数不断的读取按键状态，当按键有效的时候就打印出按键值，这种方法有个缺点，那就是 imx6uirqApp 这个测试应用程序拥有很高的 CPU 占用率，大家可以在开发板中加载上一章的驱动程序模块 imx6uirq.ko，然后以后台运行模式打开 imx6uirqApp 这个测试软件，命令如下：
cpp
./imx6uirqApp /dev/imx6uirq &测试驱动是否正常工作，如果驱动工作正常的话输入"top"命令查看 imx6uirqApp 这个应用程序的 CPU 使用率，结果如下图所示：
从上图可以看出，imx6uirqApp 这个应用程序的 CPU 使用率竟然高达 99.6，原因就在于我们是直接 在 while 循环中通过 read 函数读取按键值，因此 imx6uirqApp 这个软件会一直运行，一直读取
按键值，CPU 使用率肯定就会很高。
理想情况应该是：
没有按键事件发生的时候， imx6uirqApp 这个应用程序应该处于休眠状态。
当有按键事件发生以后 应用程序才运行，打印出按键值，这样就会降低 CPU 使用率。
这种实验方式就可以使用阻塞 IO 来实现。
二、硬件原理图分析
按键 KEY0 的原理图如下：
图中可以看出，按键 KEY0 是连接到 I.MX6U 的 UART1_CTS 这个 IO 上的，KEY0接了一个 10K 的上拉电阻，因此 KEY0 没有按下的时候 UART1_CTS 应该是高电平，当 KEY0按下以后 UART1_CTS 就是低电平。
三、实验程序编写
本节实验核心是在原有中断驱动的基础上，添加等待队列 相关代码，实现阻塞IO。新建文件夹"14_blockio"，将上一章的imx6uirq.c复制过来，重命名为blockio.c，然后逐步修改。
3.1、驱动代码编写
核心修改点：添加等待队列头、初始化等待队列、在中断（定时器）中唤醒等待队列、在read函数中实现进程休眠。完整代码如下：
cpp
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 <linux/timer.h>
16 #include <linux/of_irq.h>
17 #include <linux/irq.h>
18 #include <asm/mach/map.h>
19 #include <asm/uaccess.h>
20 #include <asm/io.h>
21 /***************************************************************
22 文件名 : block.c
23 描述 : 阻塞IO访问
24 其他 : 无
25 ***************************************************************/
26 #define IMX6UIRQ_CNT 1 /* 设备号个数 */
27 #define IMX6UIRQ_NAME "blockio" /* 名字 */
28 #define KEY0VALUE 0X01 /* KEY0按键值 */
29 #define INVAKEY 0XFF /* 无效的按键值 */
30 #define KEY_NUM 1 /* 按键数量 */
31
32 /* 中断IO描述结构体 */
33 struct irq_keydesc {
34 int gpio; /* gpio */
35 int irqnum; /* 中断号 */
36 unsigned char value; /* 按键对应的键值 */
37 char name[10]; /* 名字 */
38 irqreturn_t (*handler)(int, void *); /* 中断服务函数 */
39 };
40
41 /* imx6uirq设备结构体 */
42 struct imx6uirq_dev{
43 dev_t devid; /* 设备号 */
44 struct cdev cdev; /* cdev */
45 struct class *class; /* 类 */
46 struct device *device; /* 设备 */
47 int major; /* 主设备号 */
48 int minor; /* 次设备号 */
49 struct device_node *nd; /* 设备节点 */
50 atomic_t keyvalue; /* 有效的按键键值 */
51 atomic_t releasekey; /* 标记是否完成一次完成的按键，包括按下和释放 */
52 struct timer_list timer;/* 定义一个定时器*/
53 struct irq_keydesc irqkeydesc[KEY_NUM]; /* 按键init述数组 */
54 unsigned char curkeynum; /* 当前init按键号 */
55
56 wait_queue_head_t r_wait; /* 读等待队列头 */
57 };
58
59 struct imx6uirq_dev imx6uirq; /* irq设备 */
60
61 /* @description : 中断服务函数，开启定时器
62 * 定时器用于按键消抖。
63 * @param - irq : 中断号
64 * @param - dev_id : 设备结构。
65 * @return : 中断执行结果
66 */
67 static irqreturn_t key0_handler(int irq, void *dev_id)
68 {
69 struct imx6uirq_dev *dev = (struct imx6uirq_dev*)dev_id;
70
71 dev->curkeynum = 0;
72 dev->timer.data = (volatile long)dev_id;
73 mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10)); /* 10ms定时 */
74 return IRQ_RETVAL(IRQ_HANDLED);
75 }
76
77 /* @description : 定时器服务函数，用于按键消抖，定时器到了以后
78 * 再次读取按键值，如果按键还是处于按下状态就表示按键有效。
79 * @param - arg : 设备结构变量
80 * @return : 无
81 */
82 void timer_function(unsigned long arg)
83 {
84 unsigned char value;
85 unsigned char num;
86 struct irq_keydesc *keydesc;
87 struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;
88
89 num = dev->curkeynum;
90 keydesc = &dev->irqkeydesc[num];
91
92 value = gpio_get_value(keydesc->gpio); /* 读取IO值 */
93 if(value == 0){ /* 按下按键 */
94 atomic_set(&dev->keyvalue, keydesc->value);
95 }
96 else{ /* 按键松开 */
97 atomic_set(&dev->keyvalue, 0x80 | keydesc->value);
98 atomic_set(&dev->releasekey, 1); /* 标记松开按键，即完成一次完整的按键过程 */
99 }
100
101 /* 唤醒进程 */
102 if(atomic_read(&dev->releasekey)) { /* 完成一次按键过程 */
103 /* wake_up(&dev->r_wait); */
104 wake_up_interruptible(&dev->r_wait);
105 }
106 }
107
108 /*
109 * @description : 按键IO初始化
110 * @param : 无
111 * @return : 无
112 */
113 static int keyio_init(void)
114 {
115 unsigned char i = 0;
116 char name[10];
117 int ret = 0;
118
119 imx6uirq.nd = of_find_node_by_path("/key");
120 if (imx6uirq.nd== NULL){
121 printk("key node not find!\r\n");
122 return -EINVAL;
123 }
124
125 /* 提取GPIO */
126 for (i = 0; i < KEY_NUM; i++) {
127 imx6uirq.irqkeydesc[i].gpio = of_get_named_gpio(imx6uirq.nd ,"key-gpio", i);
128 if (imx6uirq.irqkeydesc[i].gpio < 0) {
129 printk("can't get key%d\r\n", i);
130 }
131 }
132
133 /* 初始化key所使用的IO，并且设置成中断模式 */
134 for (i = 0; i < KEY_NUM; i++) {
135 memset(imx6uirq.irqkeydesc[i].name, 0, sizeof(name)); /* 缓冲区清零 */
136 sprintf(imx6uirq.irqkeydesc[i].name, "KEY%d", i); /* 组合名字 */
137 gpio_request(imx6uirq.irqkeydesc[i].gpio, name);
138 gpio_direction_input(imx6uirq.irqkeydesc[i].gpio);
139 imx6uirq.irqkeydesc[i].irqnum = irq_of_parse_and_map(imx6uirq.nd, i);
140 #if 0
141 imx6uirq.irqkeydesc[i].irqnum = gpio_to_irq(imx6uirq.irqkeydesc[i].gpio);
142 #endif
143 }
144
145 /* 申请中断 */
146 imx6uirq.irqkeydesc[0].handler = key0_handler;
147 imx6uirq.irqkeydesc[0].value = KEY0VALUE;
148
149 for (i = 0; i < KEY_NUM; i++) {
150 ret = request_irq(imx6uirq.irqkeydesc[i].irqnum, imx6uirq.irqkeydesc[i].handler,
151 IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, imx6uirq.irqkeydesc[i].name, &imx6uirq);
152 if(ret < 0){
153 printk("irq %d request failed!\r\n", imx6uirq.irqkeydesc[i].irqnum);
154 return -EFAULT;
155 }
156 }
157
158 /* 创建定时器 */
159 init_timer(&imx6uirq.timer);
160 imx6uirq.timer.function = timer_function;
161
162 /* 初始化等待队列头 */
163 init_waitqueue_head(&imx6uirq.r_wait);
164 return 0;
165 }
166
167 /*
168 * @description : 打开设备
169 * @param - inode : 传递给驱动的inode
170 * @param - filp : 设备文件，file结构体有个叫做private_data的成员变量
171 * 一般在open的时候将private_data指向设备结构体。
172 * @return : 0 成功;其他 失败
173 */
174 static int imx6uirq_open(struct inode *inode, struct file *filp)
175 {
176 filp->private_data = &imx6uirq; /* 设置私有数据 */
177 return 0;
178 }
179
180 /*
181 * @description : 从设备读取数据
182 * @param - filp : 要打开的设备文件(文件描述符)
183 * @param - buf : 返回给用户空间的数据缓冲区
184 * @param - cnt : 要读取的数据长度
185 * @param - offt : 相对于文件首地址的偏移
186 * @return : 读取的字节数，如果为负值，表示读取失败
187 */
188 static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
189 {
190 int ret = 0;
191 unsigned char keyvalue = 0;
192 unsigned char releasekey = 0;
193 struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;
194
195 #if 0
196 /* 加入等待队列，等待被唤醒,也就是有按键按下 */
197 ret = wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey));
198 if (ret) {
199 goto wait_error;
200 }
201 #endif
202
203 DECLARE_WAITQUEUE(wait, current); /* 定义一个等待队列 */
204 if(atomic_read(&dev->releasekey) == 0) { /* 没有按键按下 */
205 add_wait_queue(&dev->r_wait, &wait); /* 将等待队列添加到等待队列头 */
206 __set_current_state(TASK_INTERRUPTIBLE);/* 设置任务状态 */
207 schedule(); /* 进行一次任务切换 */
208 if(signal_pending(current)) { /* 判断是否为信号引起的唤醒 */
209 ret = -ERESTARTSYS;
210 goto wait_error;
211 }
212 __set_current_state(TASK_RUNNING); /* 将当前任务设置为运行状态 */
213 remove_wait_queue(&dev->r_wait, &wait); /* 将对应的队列项从等待队列头删除 */
214 }
215
216 keyvalue = atomic_read(&dev->keyvalue);
217 releasekey = atomic_read(&dev->releasekey);
218
219 if (releasekey) { /* 有按键按下 */
220 if (keyvalue & 0x80) {
221 keyvalue &= ~0x80;
222 ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));
223 } else {
224 goto data_error;
225 }
226 atomic_set(&dev->releasekey, 0);/* 按下标志清零 */
227 } else {
228 goto data_error;
229 }
230 return 0;
231
232 wait_error:
233 set_current_state(TASK_RUNNING); /* 设置任务为运行态 */
234 remove_wait_queue(&dev->r_wait, &wait); /* 将等待队列移除 */
235 return ret;
236
237 data_error:
238 return -EINVAL;
239 }
240
241 /* 设备操作函数 */
242 static struct file_operations imx6uirq_fops = {
243 .owner = THIS_MODULE,
244 .open = imx6uirq_open,
245 .read = imx6uirq_read,
246 };
247
248 /*
249 * @description : 驱动入口函数
250 * @param : 无
251 * @return : 无
252 */
253 static int __init imx6uirq_init(void)
254 {
255 /* 1、构建设备号 */
256 if (imx6uirq.major) {
257 imx6uirq.devid = MKDEV(imx6uirq.major, 0);
258 register_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME);
259 } else {
260 alloc_chrdev_region(&imx6uirq.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME);
261 imx6uirq.major = MAJOR(imx6uirq.devid);
262 imx6uirq.minor = MINOR(imx6uirq.devid);
263 }
264
265 /* 2、注册字符设备 */
266 cdev_init(&imx6uirq.cdev, &imx6uirq_fops);
267 cdev_add(&imx6uirq.cdev, imx6uirq.devid, IMX6UIRQ_CNT);
268
269 /* 3、创建类 */
270 imx6uirq.class = class_create(THIS_MODULE, IMX6UIRQ_NAME);
271 if (IS_ERR(imx6uirq.class)) {
272 return PTR_ERR(imx6uirq.class);
273 }
274
275 /* 4、创建设备 */
276 imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL, IMX6UIRQ_NAME);
277 if (IS_ERR(imx6uirq.device)) {
278 return PTR_ERR(imx6uirq.device);
279 }
280
281 /* 5、始化按键 */
282 atomic_set(&imx6uirq.keyvalue, INVAKEY);
283 atomic_set(&imx6uirq.releasekey, 0);
284 keyio_init();
285 return 0;
286 }
287
288 /*
289 * @description : 驱动出口函数
290 * @param : 无
291 * @return : 无
292 */
293 static void __exit imx6uirq_exit(void)
294 {
295 unsigned i = 0;
296 /* 删除定时器 */
297 del_timer_sync(&imx6uirq.timer); /* 删除定时器 */
298
299 /* 释放中断 */
300 for (i = 0; i < KEY_NUM; i++) {
301 free_irq(imx6uirq.irqkeydesc[i].irqnum, &imx6uirq);
302 gpio_free(imx6uirq.irqkeydesc[i].gpio);
303 }
304 cdev_del(&imx6uirq.cdev);
305 unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);
306 device_destroy(imx6uirq.class, imx6uirq.devid);
307 class_destroy(imx6uirq.class);
308 }
309
310 module_init(imx6uirq_init);
311 module_exit(imx6uirq_exit);
312 MODULE_LICENSE("GPL");关键代码解析（重点！）
- 头文件补充（第16行）：新增 #include <linux/of_irq.h>，用于解析设备树中的中断信息，适配代码中irq_of_parse_and_map函数的使用。
2.第27行，修改设备树文件的名字为：blockio，当驱动程序加载成功以后就会在根文件系统中出现一个名为"/dev/blockio"的文件。
等待队列头定义（第56行）：在设备结构体中添加 wait_queue_head_t r_wait，这是阻塞IO的核心，用于管理休眠的进程。
唤醒等待队列（第102~105行）：先在102行判断一下是否是一次有效的按键，如果是的话就通过 wake_up 或者 wake_up_interruptible 函数来唤醒等待队列r_wait。
5.**初始化等待队列头（第163行），**调用init_waitqueue_head函数初始化等待队列头r_wait。
6、**实现阻塞方式1：**第196-200行，采用等待事件来处理 read 的阻塞访问，wait_event_interruptible 函数等待releasekey有效，也就是有按键按下。如果按键没有按下的话进程就会进入休眠状态（wait event_interruptible函数，进入休眠态的进程可以被信号打断。）
- 实现阻塞方式2：（第203~214行）：
首先用 DECLARE_WAITQUEUE 定义一个等待队列，关联当前进程。
如果没有按键事件（releasekey == 0），将当前进程加入等待队列，设置进程状态为可中断休眠（TASK_INTERRUPTIBLE）。
然后调用 schedule() 进行任务切换，进程进入休眠。
当有按键事件（或信号）唤醒进程后，判断唤醒原因，若为信号则返回错误，否则重置进程状态为运行态，并从等待队列中移除。
3.2、测试 APP 代码
本节实验的测试 APP 直接使用中断实验 所编写的 imx6uirqApp.c ，将 imx6uirqApp.c 复
制到本节实验文件夹下，并且重命名为 blockioApp.c ，不需要修改任何内容。
I.MX6U Linux 驱动开发篇---零基础必看！中断实验（按键中断 + 定时器消抖 + 设备树配置实战教程）--- Ubuntu20.04-CSDN博客
cpp
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include "linux/ioctl.h"
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
描述 : 阻塞访问测试APP
描述 : 定时器测试应用程序
其他 : 无
使用方法 ：./blockApp /dev/blockio 打开测试App
***************************************************************/
/*
* @description : main主程序
* @param - argc : argv数组元素个数
* @param - argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
int fd;
int ret = 0;
char *filename;
unsigned char data;
if (argc != 2) {
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;
}
while (1) {
ret = read(fd, &data, sizeof(data));
if (ret < 0) { /* 数据读取错误或者无效 */
} else { /* 数据读取正确 */
if (data) /* 读取到数据 */
printf("key value = %#X\r\n", data);
}
}
close(fd);
return ret;
}四、运行测试
4.1、编译驱动程序和测试 APP
编写 Makefile 文件，本次实验的 Makefile 文件和中断实验之前的实验基本一样，只是将 obj-m 变量的值改为blockio.o，Makefile 内容如下所示：
cpp
KERNELDIR := /home/duan/linux/linux-imx-rel_imx_4.1.15_2.1.1_ga_alientek_v2.2
CURRENT_PATH := $(shell pwd)
obj-m := blockio.o
build: kernel_modules
kernel_modules:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean第 4 行，设置 obj-m 变量的值为blockio.o。
输入如下命令编译出驱动模块文件：
cpp
make -j32编译成功以后就会生成一个名为"blockio.ko"的驱动模块文件。
编译测试 APP
输入如下命令编译测试blockioApp这个测试程序：
cpp
arm-linux-gnueabihf-gcc blockioApp.c -o blockioApp编译成功以后就会生成blockioApp这个应用程序。
5.2、运行测试
将上一小节编译出来的blockio.ko 和 blockioApp这两个文件拷贝到 rootfs/lib/modules/4.1.15 目录中。
cpp
sudo cp blockio.ko /home/duan/linux/nfs/rootfs/lib/modules/4.1.15/ -f
cpp
sudo cp blockioApp /home/duan/linux/nfs/rootfs/lib/modules/4.1.15/ -f进入到目录 lib/modules/4.1.15 中，输入如下命令加载blockio.ko 驱动模块：
cpp
depmod //第一次加载驱动的时候需要运行此命令
modprobe blockio.ko //加载驱动驱动加载成功以后使用如下命令打开 blockioApp 这个测试 APP，并且以后台模式运行
cpp
./blockioApp /dev/blockio &按下开发板上的 KEY0 键，终端就会输出按键值，如下图所示：
当按下 KEY0 按键以后 blockioApp 这个测试 APP 就会打印出按键值。输入" top "命令，
查看 blockioAPP 这个应用 APP 的 CPU 使用率，如下图 所示：
从上图可以看出，当我们在按键驱动程序里面加入阻塞访问以后，blockioApp 这个应用程序的 CPU 使用率从之前的 99.6%降低到了 0.0%。大家注意，这里的 0.0%并不是说 blockioApp 这个应用程序不使用 CPU 了，只是因为使用率太小了，CPU 使用率可能为0.00001%，但是上图只能显示出小数点后一位，因此就显示成了 0.0%。
我们可以使用"kill"命令关闭后台运行的应用程序，比如我们关闭掉 blockioApp 这个后台运行的应用程序。首先输出"Ctrl+C"关闭 top 命令界面，进入到命令行模式。然后使用"ps"命令查看一下 blockioApp这个应用程序的PID，如图所示：
从上图可以看出，blockioApp 这个应用程序的 PID 为87，使用"kill -9 PID"即可"杀死"指定 PID 的进程，比如我们现在要"杀死"PID87为的blockioApp 应用程序，可是使用如下命令：
cpp
kill -9 87输入上述命令以后终端显示如下图 所示：
从上图可以看出，"./blockioApp /dev/blockio"这个应用程序已经被"杀掉"了，在此输入"ps"命令查看当前系统运行的进程，会发现 blockioApp 已经不见了。这个就是使用 kill命令"杀掉"指定进程的方法。
总结
本次阻塞IO实验基于之前的按键中断实验优化，核心解决了原中断驱动中测试APP 的CPU占用率过高的问题。通过在驱动中添加等待队列机制，实现了进程的休眠与唤醒：无按键事件时，测试APP进入休眠状态，不占用CPU资源；当按键触发中断并完成消抖后，驱动唤醒休眠进程，执行按键值读取与打印操作。实验结果清晰显示，APP的CPU使用率从99.6%降至近乎0%，充分验证了阻塞IO在资源节约上的优势。