【学习日记】【第五十二章 Linux阻塞IO实验】【流程图】——正点原子I.MX6U嵌入式Linux驱动开发

1 概述

本文主要是笔者根据《正点原子I.MX6U嵌入式Linux驱动开发》中 “第五十二章 Linux阻塞和非阻塞IO实验” 的程序绘制的流程图，该程序使用非阻塞IO实现了和五十一章实验同样的功能，并对函数流程进行了分析。
《【学习日记】【第五十一章 Linux中断实验】【流程图】——正点原子I.MX6U嵌入式Linux驱动开发》

2 流程图

3 驱动关键代码分析

3.1 关键代码 imx6uirq_read()

/* 从设备读取数据 */
static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) {int ret = 0;unsigned char keyvalue = 0;unsigned char releasekey = 0;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;#if 0/* 加入等待队列，等待被唤醒,也就是有按键按下 */ret = wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey));if (ret) {goto wait_error;}
#endifDECLARE_WAITQUEUE(wait, current); /* 定义一个等待队列 */if (atomic_read(&dev->releasekey) == 0) { /* 没有按键按下 */add_wait_queue(&dev->r_wait, &wait); /* 添加到等待队列头 */__set_current_state(TASK_INTERRUPTIBLE); /* 设置任务状态 */schedule(); /* 进行一次任务切换 */if (signal_pending(current)) { /* 判断是否为信号引起的唤醒 */ret = -ERESTARTSYS;goto wait_error;}__set_current_state(TASK_RUNNING); /* 设置为运行状态 */remove_wait_queue(&dev->r_wait, &wait); /* 将等待队列移除 */}keyvalue = atomic_read(&dev->keyvalue);releasekey = atomic_read(&dev->releasekey);if (releasekey) { /* 有按键按下 */if (keyvalue & 0x80) {keyvalue &= ~0x80;ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));} else {goto data_error;}atomic_set(&dev->releasekey, 0); /* 按下标志清零 */} else {goto data_error;}return 0;wait_error:set_current_state(TASK_RUNNING); /* 设置任务为运行态 */remove_wait_queue(&dev->r_wait, &wait); /* 将等待队列移除 */return ret;data_error:return -EINVAL;
}

3.2 关键代码流程分析

在驱动代码中，当没有按键按下时，imx6uirq_read 函数中的当前进程会进入休眠态，而当有按键按下时，休眠态的进程会被唤醒，并从休眠点继续运行。这是因为 Linux 内核中提供了一个机制，允许进程在等待某个事件发生时进入休眠，当事件发生时，内核会负责唤醒这些休眠的进程。具体在这段代码中的机制如下：

3.2.1 等待队列和进程调度

在 imx6uirq_read 函数中，代码创建了一个等待队列项：

DECLARE_WAITQUEUE(wait, current);

current 是一个指针，指向当前执行的进程结构体。这个等待队列项 wait 包含了指向当前进程的指针。

然后，代码检查是否没有按键按下：

if (atomic_read(&dev->releasekey) == 0) {add_wait_queue(&dev->r_wait, &wait); /* 添加到等待队列头 */__set_current_state(TASK_INTERRUPTIBLE); /* 设置任务状态 */schedule(); /* 进行一次任务切换 */...
}

• add_wait_queue(&dev->r_wait, &wait); ：将当前进程加入到等待队列 dev->r_wait 中。
• __set_current_state(TASK_INTERRUPTIBLE); ：将当前进程的状态设置为 TASK_INTERRUPTIBLE，表示这个进程可以被信号或其他事件唤醒。
• schedule(); ：调用调度函数，当前进程会让出 CPU，进入休眠态，并等待被唤醒。

3.2.2 唤醒机制

当按键按下时，触发中断，执行中断服务函数 key0_handler，然后启动定时器，延时 10 毫秒，用于按键消抖。消抖结束后，定时器服务函数 timer_function 会被调用：

void timer_function(unsigned long arg) {...if (atomic_read(&dev->releasekey)) { /* 完成一次按键过程 */wake_up_interruptible(&dev->r_wait); /* 唤醒进程 */}
}

• wake_up_interruptible(&dev->r_wait); ：唤醒等待队列 dev->r_wait 上的所有进程。这些进程的状态会从 TASK_INTERRUPTIBLE 改为 TASK_RUNNING，然后重新进入调度队列。

3.2.3 从休眠点继续运行

当等待队列中的进程被唤醒时，schedule() 函数返回，进程会继续从休眠点（即 schedule() 之后的代码）开始执行：

__set_current_state(TASK_RUNNING); /* 设置为运行状态 */
remove_wait_queue(&dev->r_wait, &wait); /* 将等待队列移除 */

• __set_current_state(TASK_RUNNING); ：将进程的状态重新设置为 TASK_RUNNING，表示进程现在处于可运行状态。
• remove_wait_queue(&dev->r_wait, &wait); ：将进程从等待队列中移除，因为它已经被唤醒。

4 应用程序不断循环调用 read() 函数时的执行情况

4.1 应用程序关键代码

可以看到，应用程序中，在一个循环中不断使用 read() 试图读取按键值：

while (1) {ret = read(fd, &data, sizeof(data));if (ret < 0) { /* 数据读取错误或者无效 */// 处理错误} else { /* 数据读取正确 */if (data) /* 读取到数据 */printf("key value = %#X\r\n", data);}
}

4.2 执行情况分析

4.2.1 read 函数在应用程序中的调用

在应用程序中，read 函数被放在一个无限循环中：

while (1) {ret = read(fd, &data, sizeof(data));// 根据 ret 的值执行不同操作
}

read 函数的调用是阻塞的，也就是说，调用 read 函数的进程会在 read 函数中等待，直到有数据可读或者发生错误。这意味着在第一段驱动代码中，如果没有按键按下，应用程序中的 read 调用会阻塞，直到驱动唤醒进程。

4.2.2 驱动中的 imx6uirq_read 函数行为分析

在本章驱动代码中，如果没有按键按下，imx6uirq_read 函数会做以下事情：

1. 检查标志位：imx6uirq_read 会首先检查 releasekey 标志位，如果标志位为 0（表示没有按键事件），代码将进程加入等待队列并进入休眠：

   DECLARE_WAITQUEUE(wait, current); /* 定义一个等待队列 */
   if (atomic_read(&dev->releasekey) == 0) { /* 没有按键按下 */add_wait_queue(&dev->r_wait, &wait); /* 添加到等待队列头 */__set_current_state(TASK_INTERRUPTIBLE); /* 设置任务状态 */schedule(); /* 进行一次任务切换 */// 直到按键中断发生，进程才会被唤醒
   }
   

2. 等待按键事件：如果没有按键事件发生，schedule() 会使当前进程进入休眠状态，read 函数不会立即返回，而是阻塞在这一行代码处。

3. 按键事件发生后：当按键按下，中断处理程序会唤醒进程，进程恢复运行，read 函数会继续执行并返回按键值。

4.2.3 read 函数的返回值

• 在没有按键按下时：read 会阻塞，直到有数据可读或发生中断（如信号）。因此，此时应用程序不会立即获得 read 的返回值，进程会暂停在 read 调用的位置。也就是说，没有返回值，因为 read 函数在阻塞等待按键事件。

• 按键按下并松开后：read 函数会返回读取的字节数（通常是 sizeof(data)，即 1），并将读取到的按键值存放在 data 中。

在应用程序中，read 函数的返回值在 ret 中存储。通常情况下，如果 read 成功读取到数据，ret 会是读取的字节数（例如 1），如果发生错误，ret 会是负值。

4.2.4 应用程序的行为

• 正常情况下：当按键事件发生时，read 函数会返回读取到的数据。如果数据有效，ret 会是正值，应用程序可以根据这个返回值执行不同的操作。

• 在没有按键按下时：read 函数会阻塞，应用程序会在 read 函数调用处停顿，等待按键事件发生。因此，应用程序不会进入到 read 之后的代码执行任何操作，直到 read 返回。

4.2.5 总结

因此，虽然 read 函数在应用程序中被不断循环调用，但在第一段驱动代码中，当没有按键按下时，imx6uirq_read 函数不会真正执行，read 函数会阻塞，等待按键事件发生。当按键事件发生时，read 函数会返回读取到的数据，应用程序可以根据 ret 的值正常执行不同的操作。

这种阻塞机制使得应用程序在没有新的按键事件时不会消耗 CPU 资源，从而降低了 CPU 占用率。

5 完整代码

5.1 应用代码

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

5.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>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>#define IMX6UIRQ_CNT 1 /* 设备号个数 */
#define IMX6UIRQ_NAME "blockio" /* 名字 */
#define KEY0VALUE 0X01 /* KEY0 按键值 */
#define INVAKEY 0XFF /* 无效的按键值 */
#define KEY_NUM 1 /* 按键数量 *//* 中断 IO 描述结构体 */
struct irq_keydesc {int gpio; /* gpio */int irqnum; /* 中断号 */unsigned char value; /* 按键对应的键值 */char name[10]; /* 名字 */irqreturn_t (*handler)(int, void *); /* 中断服务函数 */
};/* imx6uirq 设备结构体 */
struct imx6uirq_dev {dev_t devid; /* 设备号 */struct cdev cdev; /* cdev */struct class *class; /* 类 */struct device *device; /* 设备 */int major; /* 主设备号 */int minor; /* 次设备号 */struct device_node *nd; /* 设备节点 */atomic_t keyvalue; /* 有效的按键键值 */atomic_t releasekey; /* 标记是否完成一次完成的按键 */struct timer_list timer; /* 定义一个定时器 */struct irq_keydesc irqkeydesc[KEY_NUM]; /* 按键描述数组 */unsigned char curkeynum; /* 当前的按键号 */wait_queue_head_t r_wait; /* 读等待队列头 */
};struct imx6uirq_dev imx6uirq; /* irq 设备 *//* 中断服务函数，开启定时器，延时 10ms，定时器用于按键消抖。 */
static irqreturn_t key0_handler(int irq, void *dev_id) {struct imx6uirq_dev *dev = (struct imx6uirq_dev *)dev_id;dev->curkeynum = 0;dev->timer.data = (volatile long)dev_id;mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10));return IRQ_RETVAL(IRQ_HANDLED);
}/* 定时器服务函数，用于按键消抖 */
void timer_function(unsigned long arg) {unsigned char value;unsigned char num;struct irq_keydesc *keydesc;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;num = dev->curkeynum;keydesc = &dev->irqkeydesc[num];value = gpio_get_value(keydesc->gpio); /* 读取 IO 值 */if (value == 0) { /* 按下按键 */atomic_set(&dev->keyvalue, keydesc->value);} else { /* 按键松开 */atomic_set(&dev->keyvalue, 0x80 | keydesc->value);atomic_set(&dev->releasekey, 1); /* 标记松开按键 */}/* 唤醒进程 */if (atomic_read(&dev->releasekey)) { /* 完成一次按键过程 */wake_up_interruptible(&dev->r_wait);}
}/* 按键 IO 初始化 */
static int keyio_init(void) {unsigned char i = 0;int ret = 0;imx6uirq.nd = of_find_node_by_path("/key");if (imx6uirq.nd == NULL) {printk("key node not find!\r\n");return -EINVAL;}/* 提取 GPIO */for (i = 0; i < KEY_NUM; i++) {imx6uirq.irqkeydesc[i].gpio = of_get_named_gpio(imx6uirq.nd, "key-gpio", i);if (imx6uirq.irqkeydesc[i].gpio < 0) {printk("can't get key%d\r\n", i);}}/* 初始化 key 所使用的 IO，并且设置成中断模式 */for (i = 0; i < KEY_NUM; i++) {memset(imx6uirq.irqkeydesc[i].name, 0, sizeof(imx6uirq.irqkeydesc[i].name));sprintf(imx6uirq.irqkeydesc[i].name, "KEY%d", i);gpio_request(imx6uirq.irqkeydesc[i].gpio, imx6uirq.irqkeydesc[i].name);gpio_direction_input(imx6uirq.irqkeydesc[i].gpio);imx6uirq.irqkeydesc[i].irqnum = irq_of_parse_and_map(imx6uirq.nd, i);printk("key%d:gpio=%d, irqnum=%d\r\n", i, imx6uirq.irqkeydesc[i].gpio, imx6uirq.irqkeydesc[i].irqnum);}/* 申请中断 */imx6uirq.irqkeydesc[0].handler = key0_handler;imx6uirq.irqkeydesc[0].value = KEY0VALUE;for (i = 0; i < KEY_NUM; i++) {ret = request_irq(imx6uirq.irqkeydesc[i].irqnum, imx6uirq.irqkeydesc[i].handler,IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,imx6uirq.irqkeydesc[i].name, &imx6uirq);if (ret < 0) {printk("irq %d request failed!\r\n", imx6uirq.irqkeydesc[i].irqnum);return -EFAULT;}}/* 创建定时器 */init_timer(&imx6uirq.timer);imx6uirq.timer.function = timer_function;/* 初始化等待队列头 */init_waitqueue_head(&imx6uirq.r_wait);return 0;
}/* 打开设备 */
static int imx6uirq_open(struct inode *inode, struct file *filp) {filp->private_data = &imx6uirq; /* 设置私有数据 */return 0;
}/* 从设备读取数据 */
static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) {int ret = 0;unsigned char keyvalue = 0;unsigned char releasekey = 0;struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;#if 0/* 加入等待队列，等待被唤醒,也就是有按键按下 */ret = wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey));if (ret) {goto wait_error;}
#endifDECLARE_WAITQUEUE(wait, current); /* 定义一个等待队列 */if (atomic_read(&dev->releasekey) == 0) { /* 没有按键按下 */add_wait_queue(&dev->r_wait, &wait); /* 添加到等待队列头 */__set_current_state(TASK_INTERRUPTIBLE); /* 设置任务状态 */schedule(); /* 进行一次任务切换 */if (signal_pending(current)) { /* 判断是否为信号引起的唤醒 */ret = -ERESTARTSYS;goto wait_error;}__set_current_state(TASK_RUNNING); /* 设置为运行状态 */remove_wait_queue(&dev->r_wait, &wait); /* 将等待队列移除 */}keyvalue = atomic_read(&dev->keyvalue);releasekey = atomic_read(&dev->releasekey);if (releasekey) { /* 有按键按下 */if (keyvalue & 0x80) {keyvalue &= ~0x80;ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));} else {goto data_error;}atomic_set(&dev->releasekey, 0); /* 按下标志清零 */} else {goto data_error;}return 0;wait_error:set_current_state(TASK_RUNNING); /* 设置任务为运行态 */remove_wait_queue(&dev->r_wait, &wait); /* 将等待队列移除 */return ret;data_error:return -EINVAL;
}/* 设备操作函数 */
static struct file_operations imx6uirq_fops = {.owner = THIS_MODULE,.open = imx6uirq_open,.read = imx6uirq_read,
};/* 驱动入口函数 */
static int __init imx6uirq_init(void) {/* 1、构建设备号 */if (imx6uirq.major) {imx6uirq.devid = MKDEV(imx6uirq.major, 0);register_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME);} else {alloc_chrdev_region(&imx6uirq.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME);imx6uirq.major = MAJOR(imx6uirq.devid);imx6uirq.minor = MINOR(imx6uirq.devid);}/* 2、注册字符设备 */cdev_init(&imx6uirq.cdev, &imx6uirq_fops);cdev_add(&imx6uirq.cdev, imx6uirq.devid, IMX6UIRQ_CNT);/* 3、创建类 */imx6uirq.class = class_create(THIS_MODULE, IMX6UIRQ_NAME);if (IS_ERR(imx6uirq.class)) {return PTR_ERR(imx6uirq.class);}/* 4、创建设备 */imx6uirq.device = device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL, IMX6UIRQ_NAME);if (IS_ERR(imx6uirq.device)) {return PTR_ERR(imx6uirq.device);}/* 5、 初始化按键 */atomic_set(&imx6uirq.keyvalue, INVAKEY);atomic_set(&imx6uirq.releasekey, 0);keyio_init();return 0;
}/* 驱动出口函数 */
static void __exit imx6uirq_exit(void) {unsigned int i = 0;/* 删除定时器 */del_timer_sync(&imx6uirq.timer);/* 释放中断 */for (i = 0; i < KEY_NUM; i++) {free_irq(imx6uirq.irqkeydesc[i].irqnum, &imx6uirq);gpio_free(imx6uirq.irqkeydesc[i].gpio);}cdev_del(&imx6uirq.cdev);unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);device_destroy(imx6uirq.class, imx6uirq.devid);class_destroy(imx6uirq.class);
}module_init(imx6uirq_init);
module_exit(imx6uirq_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zuozhongkai");