i.MX 6ULL 驱动开发 十一：按键中断(IO多路复用)

一、IO 模型

五种网络IO模型_Oh-Why_not的博客-CSDN博客_五种网络io模型

二、Linux 内核等待队列

Linux 内核等待队列_爱洋葱的博客-CSDN博客_内核等待队列

三、IO 多路复用

彻底理解 IO多路复用 - 知乎 (zhihu.com)

select()函数以及FD_ZERO、FD_SET、FD_CLR、FD_ISSET_迟到的螃蟹的博客-CSDN博客_fd_zero

四、Linux 中断基本概念

i.MX 6ULL 驱动开发 九：中断(非阻塞处理)_lqonlylove的博客-CSDN博客

五、按键原理

i.MX 6ULL 驱动开发 九：中断(非阻塞处理)_lqonlylove的博客-CSDN博客

六、设计思路

1、poll机制

韦东山：Linux驱动基石之POLL机制_韦东山的博客-CSDN博客

poll机制分析（韦东山）_Wenleon的博客-CSDN博客

linux的poll_wait函数,等待队列和poll机制_Scott Johnson的博客-CSDN博客

2、应用程序设计思路

1、使用 open 打开设备文件时，控制 fd 是否阻塞访问（使用 O_NONBLOCK 标识符，控制 fd 是否阻塞访问）。

2、使用 FD_ZERO、FD_SET、FD_ISSET 和 FD_CLR 函数设置需要操作的文件描述符。

3、使用 select 或 poll 函数触发驱动中的 poll 函数，获取按键值状态。

4、当按键可以访问时，使用 read 函数读取按键值。

3、驱动程序设计思路

1、当应用程序通过 select 或 poll 函数触发驱动中 poll 函数时，驱动 poll 函数返回当前按键状态。

2、驱动程序中 poll 函数中调用 poll_wait 函数将将等待队列注册到 poll_table 中（poll_wait 函数作用配合等待队列，可以在驱动中唤醒应用程序中 poll 函数，唤醒方法通过等待队列提供一些 API 接口）。

3、在驱动 read 函数中将按键值返回到应用程序。

4、poll 处理机制总结

1、在应用程序中通过 select 或 poll 函数触发驱动中 poll 函数，进行获取当前资源状态；

2、在资源满足情况下，使用 read 进行读取。

3、read 进行读取时，可以分为阻塞或非阻塞操作（在调用 read 时，已经确定资源满足操作状态，因此不需要阻塞）。

七、添加设备树

1、确定引脚

通过原理图可以确定 key 使用 UART1_CTS 引脚。

2、查找引脚定义是否冲突

3、添加 pinctrl 子系统相关配置

pinctrl_key: keygrp {
	fsl,pins = <
		MX6UL_PAD_UART1_CTS_B__GPIO1_IO18		0xF080	/* KEY0 */
	>;
};

4、添加 gpio 子系统相关配置

key {
	#address-cells = <1>;
	#size-cells = <1>;
	compatible = "lq-key";
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_key>;
	key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>; /* KEY0 */
	status = "okay";
};

5、添加 interrupts 相关配置

key {
	#address-cells = <1>;
	#size-cells = <1>;
	compatible = "lq-key";
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_key>;
	key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>; /* KEY0 */
	interrupt-parent = <&gpio1>;
	interrupts = <18 IRQ_TYPE_LEVEL_LOW>;  /* 低电平触发 */
	status = "okay";
};

主要添加 interrupt-parent 和 interrupts 属性。

6、测试

1、编译设备树

onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$ make dtbs
  CHK     include/config/kernel.release
  CHK     include/generated/uapi/linux/version.h
  CHK     include/generated/utsrelease.h
make[1]: 'include/generated/mach-types.h' is up to date.
  CHK     include/generated/bounds.h
  CHK     include/generated/asm-offsets.h
  CALL    scripts/checksyscalls.sh
  DTC     arch/arm/boot/dts/imx6ull-alientek-emmc.dtb
  DTC     arch/arm/boot/dts/imx6ull-alientek-nand.dtb
onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$

2、拷贝编译成功的设备树文件

onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$ ls /home/onlylove/my/tftp/ -l
total 11528
-rwxrwxr-x 1 onlylove onlylove 5901744 Sep 17 04:04 zImage
-rwxrwxr-x 1 onlylove onlylove 5901752 Aug 20 01:24 zImage.bak
onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$ cp arch/arm/boot/dts/imx6ull-alientek-emmc.dtb /home/onlylove/my/tftp
onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$ ls /home/onlylove/my/tftp/ -l
total 11568
-rw-rw-r-- 1 onlylove onlylove   39084 Sep 23 21:18 imx6ull-alientek-emmc.dtb
-rwxrwxr-x 1 onlylove onlylove 5901744 Sep 17 04:04 zImage
-rwxrwxr-x 1 onlylove onlylove 5901752 Aug 20 01:24 zImage.bak
onlylove@ubuntu:~/my/linux/linux-imx-4.1.15$

3、启动 linux 查看设备树解析是否成功

/ # cd /proc/
/proc # ls
1              41             65             driver         mounts
10             46             66             execdomains    mtd
11             47             7              fb             net
12             48             8              filesystems    pagetypeinfo
13             49             83             fs             partitions
14             5              84             interrupts     self
15             50             9              iomem          softirqs
16             51             95             ioports        stat
17             52             asound         irq            swaps
18             53             buddyinfo      kallsyms       sys
19             54             bus            key-users      sysrq-trigger
2              55             cgroups        keys           sysvipc
20             56             cmdline        kmsg           thread-self
21             57             consoles       kpagecount     timer_list
22             58             cpu            kpageflags     tty
23             59             cpuinfo        loadavg        uptime
24             6              crypto         locks          version
3              60             device-tree    meminfo        vmallocinfo
4              61             devices        misc           vmstat
40             62             diskstats      modules        zoneinfo
/proc # cd device-tree/
/sys/firmware/devicetree/base # ls
#address-cells                 key
#size-cells                    memory
aliases                        model
alphaled                       name
backlight                      pxp_v4l2
beep                           regulators
chosen                         reserved-memory
clocks                         sii902x-reset
compatible                     soc
cpus                           sound
gpioled                        spi4
interrupt-controller@00a01000
/sys/firmware/devicetree/base # cd key/
/sys/firmware/devicetree/base/key # ls
#address-cells    interrupt-parent  name              status
#size-cells       interrupts        pinctrl-0
compatible        key-gpio          pinctrl-names
/sys/firmware/devicetree/base/key # cat compatible
lq-key
/sys/firmware/devicetree/base/key #
/sys/firmware/devicetree/base/key #

八、驱动编写

#include "linux/init.h"
#include "linux/module.h"
#include "linux/kdev_t.h"
#include "linux/fs.h"
#include "linux/cdev.h"
#include "linux/device.h"
#include <linux/uaccess.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>

#define NEWCHRDEV_MAJOR 0   		/* 主设备号（如果为0则让系统自动分配，如果大于0则使用指定设备号） */
#define NEWCHRDEV_MINOR 0   		/* 次设备号 */
#define NEWCHRDEV_COUNT 1   		/* 设备号个数 */
#define NEWCHRDEV_NAME  "key"       /* 名子 */
#define TIMEOUT 1000                /* 定时器超时时间 */
#define KEY_OFF  0xFF               /* 按键未按下 */
#define KEY_ON  0x01                /* 按键按下 */

typedef struct{
    struct device_node	*nd;        /* 设备节点 */
    int gpio;                       /* key gpio */
    int irqnum;                     /* 中断号 */
    struct tasklet_struct tasklet;  /* tasklet 变量（中断下半部） */
    unsigned long tasklet_data;     /* 传递给 tasklet 处理函数的参数 */
    struct work_struct work;        /* 工作队列 变量（中断下半部） */
    struct timer_list timer;        /* key 消抖定时器 */
    atomic_t keyvalue;              /* 按键状态 */
    wait_queue_head_t rq;           /* 读等待队列头 */
}lqkey_t;

typedef struct{
    struct cdev dev;        /* cdev 结构体 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    dev_t devid;            /* 设备号 */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    lqkey_t key_data;         /* key 相关数据 */
}newchrdev_t;

newchrdev_t newchrdev;

static int keyio_read_wait_init(void)
{
    /* 初始化读等待队列头 */
    init_waitqueue_head(&newchrdev.key_data.rq);
    return 0;
}

/*
 * @description	: 按键IO初始化
 * @param 		: 无
 * @return 		: 无
 */
static int keyio_init(void)
{
    int ret = 0;
    /***** 处理设备树 *****/
    /* 1、获取设备树节点 */
    newchrdev.key_data.nd = of_find_node_by_path("/key");
	if (newchrdev.key_data.nd== NULL){
		printk("key node not find!\r\n");
		goto keyio_init_error1;
	}else {
		printk("beep node find!\r\n");
	}
    /* 1、获取设备树中的gpio属性 */
    newchrdev.key_data.gpio = of_get_named_gpio(newchrdev.key_data.nd, "key-gpio", 0);
	if(newchrdev.key_data.gpio < 0) {
		printk("can't get key-gpio");
		goto keyio_init_error1;
	}
	printk("key num = %d\r\n", newchrdev.key_data.gpio);

    /***** 使用gpio子系统设置引脚 *****/
    /* 1、向 gpio 子系统申请 GPIO 管脚 */
    ret = gpio_request(newchrdev.key_data.gpio,"key");
    if(ret){
        printk("can't request key-gpio!\r\n");
        goto keyio_init_error1;
    }
    /* 2、设置key-gpio为输入 */
    gpio_direction_input(newchrdev.key_data.gpio);
    if(ret < 0) {
		printk("can't set key-gpio!\r\n");
        goto keyio_init_error2;
	}
    return 0;

keyio_init_error2:
    gpio_free(newchrdev.key_data.gpio);
keyio_init_error1:
    return 1;
}

static int keyio_exit(void)
{
    /* 1、向gpio子系统请求释放gpio */
    gpio_free(newchrdev.key_data.gpio);
    return 0;
}

static void key_tasklet(unsigned long data)
{
    printk("key_tasklet\r\n");
}

static void key_work(struct work_struct *work)
{
    printk("key_work\r\n");
    mod_timer(&newchrdev.key_data.timer, jiffies + msecs_to_jiffies(TIMEOUT));
}

/* @description		: 中断服务函数
 *				  	  定时器用于按键消抖
 * @param - irq 	: 中断号 
 * @param - dev_id	: 设备结构
 * @return 			: 中断执行结果
 */
static irqreturn_t key0_handler(int irq, void *dev_id)
{
    printk("key0_handler\r\n");
//    tasklet_schedule(&newchrdev.key_data.tasklet);
    schedule_work(&newchrdev.key_data.work);
	return IRQ_RETVAL(IRQ_HANDLED);
}

/*
 * @description	: key中断初始化
 * @param 		: 无
 * @return 		: 无
 */
static int keyirq_init(void)
{
    int ret = 0;
    /***** 使用中断子系统设置 *****/
    /* 1、从设备树获取key-gpio对于中断号 */
    newchrdev.key_data.irqnum = irq_of_parse_and_map(newchrdev.key_data.nd, 0);
    if (!newchrdev.key_data.irqnum){
        goto keyirq_init_error1;
    }
    /* 2、向中断子系统请求中断号 */
    ret = request_irq(newchrdev.key_data.irqnum, key0_handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,"KEY0",&newchrdev);
    if(ret < 0){
        printk("can't request irq!\r\n");
        goto keyirq_init_error1;
    }
    /***** 使用中断上下部（tasklet和工作队列选择一个） *****/
    /* 1、初始化中断下半部 */
//    tasklet_init(&newchrdev.key_data.tasklet,key_tasklet,newchrdev.key_data.tasklet_data);
    INIT_WORK(&newchrdev.key_data.work, key_work);
    return 0;
keyirq_init_error1:
    return 1;
}

static int keyirq_exit(void)
{
    /* 1、向中断子系统请求释放中断号 */
    free_irq(newchrdev.key_data.irqnum,&newchrdev);
    /***** 使用中断上下部（tasklet和工作队列选择一个） *****/
    /* 1、销毁中断下半部 */
//    tasklet_kill(&newchrdev.key_data.tasklet);
    flush_work(&newchrdev.key_data.work);
    return 0;
}

void key_timer_function(unsigned long arg)
{
    printk("key_timer_function\r\n");
    /* 1、设置按键状态（按键按下） */
    atomic_set(&newchrdev.key_data.keyvalue,0x01);
    /* 2、唤醒等待队列 */
    wake_up_interruptible(&newchrdev.key_data.rq);
}

/*
 * @description	: key消抖定时器初始化
 * @param 		: 无
 * @return 		: 无
 */
static int keytimer_init(void)
{
    /* 1、创建定时器 */
    init_timer(&newchrdev.key_data.timer);
    newchrdev.key_data.timer.function = key_timer_function;
    newchrdev.key_data.timer.expires = jiffies + msecs_to_jiffies(TIMEOUT);
    newchrdev.key_data.timer.data = (unsigned long)&newchrdev;
    return 0;
}

static int keytimer_exit(void)
{
    /* 删除、创建定时器 */
    del_timer(&newchrdev.key_data.timer);
    return 0;
}

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int newchrdev_open(struct inode *inode, struct file *filp)
{
    printk("newchrdev_open!\r\n");
    filp->private_data = &newchrdev; /* 设置私有数据 */
    return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t newchrdev_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char keystatus = 0;
//    printk("newchrdev_read!\r\n");
    newchrdev_t *dev = (newchrdev_t *)filp->private_data;
    /* 1、获取按键值 */
    keystatus = atomic_read(&dev->key_data.keyvalue);

    if(filp->f_flags & O_NONBLOCK){
        /***** 处理非阻塞情况 *****/
        /* 2、如果没有按下，返回异常 */
        if(keystatus == KEY_OFF){
            return -EAGAIN;
        }
    }
    /* 3、获取按键值返回到应用程序 */
    if(keystatus == KEY_ON){
        ret = copy_to_user(buf, &keystatus, sizeof(keystatus));
        atomic_set(&dev->key_data.keyvalue,0xFF);
    }else{
        ret = -EINVAL;
        goto data_error;
    }
	return 0;

data_error:
	return ret;
}

/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t newchrdev_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    printk("newchrdev_write!\r\n");
    return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int newchrdev_release(struct inode *inode, struct file *filp)
{
    printk("newchrdev_release!\r\n");
	return 0;
}

/*
 * @description		: 监控文件描述符
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @param - wait    : 等待列表(poll_table)
 * @return 			: 设备或者资源状态
 */
static unsigned int newchrdev_poll(struct file *filp, struct poll_table_struct *wait)
{
    unsigned int mask = 0;
    newchrdev_t *dev = (newchrdev_t *)filp->private_data;
//    printk("newchrdev_poll!\r\n");

    /* 1、将等待队列注册到poll_table中 */
    poll_wait(filp, &dev->key_data.rq, wait);
    /* 2、获取按键状态 */
    if(atomic_read(&newchrdev.key_data.keyvalue)==KEY_ON){
        /* 3、按键按下 */
        mask = POLLIN | POLLRDNORM;
    }
    return mask;
}

static const struct file_operations newchrdevops = {
    .owner   = THIS_MODULE,
    .open = newchrdev_open,
	.read = newchrdev_read,
	.write = newchrdev_write,
	.release = newchrdev_release,
    .poll = newchrdev_poll,
};

/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    /* 驱动入口函数具体内容 */
    /* 1、字符设备号分配 */
    int ret;
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
    }else{
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
    }
    if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev major=%d,minor=%d\r\n",newchrdev.major,newchrdev.minor);

    /* 2、注册字符设备 */
    newchrdev.dev.owner = THIS_MODULE;
    cdev_init(&newchrdev.dev,&newchrdevops);
    ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
    if(ret < 0){
        printk("newchrdev cdev_add failed!\r\n");
        goto newchrdev_cdev_add_failed;
    }

    /* 3、创建类 */
    newchrdev.class = class_create(THIS_MODULE,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.class)) {
        printk("newchrdev class_create failed!\r\n");
        goto newchrdev_class_create_failed;
    }

    /* 4、创建设备 */
    newchrdev.device = device_create(newchrdev.class,NULL,newchrdev.devid,NULL,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.device)){
        printk("newchrdev device_create failed!\r\n");
        goto neschrdev_device_creat_failed;
    }

    ret = keyio_init();
    if(ret != 0){
        goto keyio_init_failed;
    }

    ret = keyirq_init();
    if(ret != 0){
        goto keyirq_init_failed;
    }

    keytimer_init();
    /* 初始化按键状态值 */
    atomic_set(&newchrdev.key_data.keyvalue,KEY_OFF);

    keyio_read_wait_init();

    return 0;
keyirq_init_failed:
    keyio_exit();
keyio_init_failed:
neschrdev_device_creat_failed:
    class_destroy(newchrdev.class);
newchrdev_class_create_failed:
    cdev_del(&newchrdev.dev);
newchrdev_cdev_add_failed:
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);

newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    return ret;
}

/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    keytimer_exit();
    keyirq_exit();
    keyio_exit();
    /* 驱动卸载函数具体内容 */
    /* 4、删除设备 */
    device_destroy(newchrdev.class,newchrdev.devid);
    /* 3、删除类 */
    class_destroy(newchrdev.class);
    /* 2、注销字符设备 */
    cdev_del(&newchrdev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
}

module_init(newchrdev_init);
module_exit(newchrdev_exit);

MODULE_LICENSE("GPL");

九、应用程序编写

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "stdio.h"
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
    int fd = 0, retvalue = 0;
    char readbuf = 0;
    fd_set readfds;
	struct timeval timeout;

    if(argc != 2){
		printf("Error Usage!\r\n");
		return -1;
	}

    fd = open(argv[1],O_RDWR|O_NONBLOCK);
    if(fd < 0){
        printf("Can't open file %s\r\n", argv[1]);
        return -1;
    }
    while(1){
        FD_ZERO(&readfds);
		FD_SET(fd, &readfds);
        /* 构造超时时间 */
		timeout.tv_sec = 0;
		timeout.tv_usec = 500000; /* 500ms */
		retvalue = select(fd + 1, &readfds, NULL, NULL, &timeout);
        switch (retvalue) {
            case 0: /* 超时 */
                break;
            case -1: /* 错误 */
                break;
            default: /* 可以读取数据 */
                retvalue = read(fd, &readbuf, sizeof(readbuf));
                if (retvalue < 0){
                
                }else{
                    if (readbuf)
                        printf("key value = %#X\r\n", readbuf);
        }
        }
    }
    close(fd);
    return 0;
}

十、特别说明

1、wait_event_interruptible 函数使用说明

/**
 * wait_event_interruptible - sleep until a condition gets true
 * wait_event_interruptible - 一直睡到条件变为真
 * @wq: the waitqueue to wait on 等待队列
 * @condition: a C expression for the event to wait for 等待事件的C表达式
 *
 * The process is put to sleep (TASK_INTERRUPTIBLE) until the
 * @condition evaluates to true or a signal is received.
 * 进程将进入睡眠状态(TASK INTERRUPTIBLE)，直到@condition的计算结果为true或接收到信号。
 * The @condition is checked each time the waitqueue @wq is woken up.
 * 每次唤醒等待队列@wq时，都会检查@condition。
 *
 * wake_up() has to be called after changing any variable that could
 * change the result of the wait condition.
 * wake_up（） 必须在更改任何可能更改等待条件结果的变量后调用。
 *
 * The function will return -ERESTARTSYS if it was interrupted by a
 * signal and 0 if @condition evaluated to true.
 * 如果该函数被信号中断，则该函数将返回 -ERESTARTSYS，如果@condition计算结果为 true，则该函数将返回 0。
 */
#define wait_event_interruptible(wq, condition)				\
({									\
	int __ret = 0;							\
	might_sleep();							\
	if (!(condition))						\
		__ret = __wait_event_interruptible(wq, condition);	\
	__ret;								\
})

通过 if (!(condition)) 语句可以确定，当 condition 为 0 时 __wait_event_interruptible 函数被调用。因此，condition 值定义如下：

• 0：条件不满足；
• 非0：添加满足；

2、poll_wait 函数说明

static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
{
	if (p && p->_qproc && wait_address)
		p->_qproc(filp, wait_address, p);
}

驱动中 poll 函数中最核心是 poll_wait 函数，poll_wait 是一个非阻塞函数。

poll_wait 函数需要和等待队列配合使用，poll_wait 函数**将对应的等待队列头添加到 poll_table **中。

poll_wait 作用：通过等待队列，在驱动中将应用程序 poll 函数唤醒，不需要等待应用程序中 poll 函数超时返回。

特别说明：

1、如果驱动中不调用 poll_wait 函数，应用程中 poll 一直等到超时事件结束，才进行返回。

2、如果驱动中调用 poll_wait 函数，应用程序中 poll 函数可以被驱动进行唤醒，提前返回，可以有效实施处理数据。

参考：poll、poll_wait函数与等待队列DECLARE_WAIT_QUEUE_HEAD、wake_up_interruptible()、wait_event_interruptible()使用_面朝大海0902的博客-CSDN博客_declare_wait_queue_head

十一、系统资源使用情况