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

文章目录

[1 概述](#1 概述)
[2 流程图](#2 流程图)
[3 驱动关键代码分析](#3 驱动关键代码分析)
- [3.1 关键代码 imx6uirq_read()](#3.1 关键代码 imx6uirq_read())
- [3.2 关键代码流程分析](#3.2 关键代码流程分析)
- - [3.2.1 等待队列和进程调度](#3.2.1 等待队列和进程调度)
  - [3.2.2 唤醒机制](#3.2.2 唤醒机制)
  - [3.2.3 从休眠点继续运行](#3.2.3 从休眠点继续运行)
[4 应用程序不断循环调用 read() 函数时的执行情况](#4 应用程序不断循环调用 read() 函数时的执行情况)
- [4.1 应用程序关键代码](#4.1 应用程序关键代码)
- [4.2 执行情况分析](#4.2 执行情况分析)
- - [4.2.1 `read` 函数在应用程序中的调用](#4.2.1 read 函数在应用程序中的调用)
  - [4.2.2 驱动中的 `imx6uirq_read` 函数行为分析](#4.2.2 驱动中的 imx6uirq_read 函数行为分析)
  - [4.2.3 `read` 函数的返回值](#4.2.3 read 函数的返回值)
  - [4.2.4 应用程序的行为](#4.2.4 应用程序的行为)
  - [4.2.5 总结](#4.2.5 总结)
[5 完整代码](#5 完整代码)
- [5.1 应用代码](#5.1 应用代码)
- [5.2 驱动代码](#5.2 驱动代码)

1 概述

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

2 流程图

应用程序驱动程序是否按下松开否是否是否是否是否是是打开设备文件读取数据参数个数是否正确? main 打印错误信息打开设备文件文件是否打开成功? 打印打开失败信息进入循环读取数据读取数据是否成功? 处理错误数据是否有效? 打印按键值是否有主设备号? imx6uirq_init 创建设备号分配设备号注册字符设备创建类创建设备初始化按键返回初始化状态开启定时器中断处理函数 key0_handler 返回中断处理状态按键状态? 定时器服务函数 timer_function 设置按键值设置释放按键标记唤醒等待进程设置私有数据 imx6uirq_open 是否有按键按下? imx6uirq_read 进入等待队列任务切换信号唤醒? 处理错误读取按键值是否完成? 传输数据到用户空间清零按键标志

3 驱动关键代码分析

3.1 关键代码 imx6uirq_read()

c 复制代码

/* 从设备读取数据 */
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;
    }
#endif

    DECLARE_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 函数中，代码创建了一个等待队列项：

c 复制代码

DECLARE_WAITQUEUE(wait, current);

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

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

c 复制代码

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 会被调用：

c 复制代码

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() 之后的代码）开始执行：

c 复制代码

__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() 试图读取按键值：

c 复制代码

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 函数被放在一个无限循环中：

c 复制代码

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

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

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

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

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

c 复制代码

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

等待按键事件 ：如果没有按键事件发生，schedule() 会使当前进程进入休眠状态，read 函数不会立即返回，而是阻塞在这一行代码处。
按键事件发生后 ：当按键按下，中断处理程序会唤醒进程，进程恢复运行，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 应用代码

c 复制代码

#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 驱动代码

c 复制代码

#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;
    }
#endif

    DECLARE_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");

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

文章目录

1 概述

2 流程图

3 驱动关键代码分析

3.1 关键代码 imx6uirq_read()

3.2 关键代码流程分析

3.2.1 等待队列和进程调度

3.2.2 唤醒机制

3.2.3 从休眠点继续运行

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

4.1 应用程序关键代码

4.2 执行情况分析

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

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

4.2.3 read 函数的返回值

4.2.4 应用程序的行为

4.2.5 总结

5 完整代码

5.1 应用代码

5.2 驱动代码

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

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

4.2.3 `read` 函数的返回值