copy from ：https://blog.csdn.net/weixin_42462202/article/details/100017339
文章目录
Linux驱动入门（六）poll机制实现按键驱动
一、poll应用编程
二、驱动poll机制的实现
三、源码
四、测试
如何使用read阻塞去读取按键驱动，那么就意味着一个线程只能监听一个按键，如果想要监听多个按键，就需要启动多个线程，开启线程会耗费资源，并且多线程会增加编程难度，那么有没有一种机制，使得一个线程可以监听多路IO呢？
Linux提供的select、poll、epoll机制，select、poll、epoll可以监听多路IO的状态，直到有IO满足条件（可读或可写等）时返回
其中select、poll系统调用的实现原理是类似的，epoll有别于这两者
但是对于底层驱动的实现都是一样的，都是实现驱动的poll函数
本文将介绍如何实现一个支持多路IO复用的驱动程序
一、poll应用编程
这里以poll为例，编写一个应用程序
poll函数原型
/*
* fds：这是一个数组，每一个数组元素表示要监听的文件描述符以及相应的事件
* nfds：数组的个数
* timeout：超时时间
* 返回值：成功返回准备好的事件个数，超时放回0，出错放回-1
*/
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
struct pollfd结构体
struct pollfd {
int fd; //要监听的文件描述符
short events; //要监听的事件
short revents; //放回结果
};
对于events和revents部分取值如下
POLLIN //可读
POLLOUT //可写
示例
#include <stdio.h>
#include <poll.h>
#include <string.h>
#define MAX_FD 100
int main(int argc, char* argv[])
{
struct pollfd fds[MAX_FD];
int nfds;
char buf[1024];
int len;
int i;
memset(fds, 0, sizeof(fds));
/* 添加要监听的事件 */
fds[0].fd = 0; //标准输入
fds[0].events = POLLIN; //可读
/* 添加其他要监听的事件 */
while(1)
{
nfds = poll(fds, MAX_FD, -1); //阻塞等待
if(nfds < 0)
{
printf("poll err.
");
return -1;
}
for(i = 0; i < MAX_FD; i++)
{
if(fds[i].revents | POLLIN) //可读
{
len = read(fds[i].fd, buf, 1024);
if(len < 0)
{
printf("read err.
");
return -1;
}
buf[len] = ' ';
printf("read buf: %s
", buf);
}
}
}
return 0;
}
上述例子中只是监听了一路IO（标准输入），你可以编译运行查看运行效果
二、驱动poll机制的实现
实际上select、poll、epoll的实现都是利用等待队列机制，将执行select、poll、epoll的进程挂到每一个驱动程序的等待队列中，然后睡眠等待，直到被唤醒
驱动程序的poll函数至少会被select、poll、epoll系统调用调用两次
第一次是将select、poll、epoll所在的进程调用驱动程序的poll函数，将自己挂到驱动程序的等待队列中
第二次是select、poll、epoll所在的进程被驱动程序唤醒，再次驱动程序的poll函数，获取驱动程序满足的条件（可读或可写）
Linux内核给驱动程序实现poll机制提供了一个函数
/*
* wait_address：驱动程序的等待队列头
* p：有select、poll、epoll传递过来的参数
*/
void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p);
该函数的作用就是将调用select、poll、epoll的进程挂到驱动程序的等待队列中
驱动程序一般如下面实现poll机制
static DECLARE_WAIT_QUEUE_HEAD(button_wq_head); //定义并初始化一个等待队列头
static unsigned int button_poll(struct file *file, struct poll_table_struct *poll_table)
{
unsigned int mask = 0;
/* 第一次被调用时，将调用select、poll、epoll的进程加入驱动的等待队列中 */
poll_wait(file, &button_wq_head, poll_table);
/* 第二次被调用时，如果条件满足，返回状态，之后poll会返回 */
if(conditon)
mask = POLLIN | POLLRDNORM;
return mask;
}
实现一个支持多路复用的驱动程序很简单，只需要加入上述几行代码
但是要弄清除这里面的来龙去脉并不是一件容易的事，至少你需要熟悉内核的等待队列，然后分析poll、select、epoll的源码，如果你有这个兴趣的话，可以看一下下面几篇文章
Linux poll内核源码剖析
Linux select内核源码剖析
Linux epoll内核源码剖析
三、源码
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/poll.h>
#include <asm/io.h>
#include <asm/uaccess.h>
static dev_t dev_id;
static struct cdev *button_dev;
static struct class *button_class;
/* 定义并初始化一个等待队列头 */
static DECLARE_WAIT_QUEUE_HEAD(button_wq_head);
static int button_val;
static int button_press;
static irqreturn_t button_irq(int irq, void *data)
{
/* 判断等待队列中是否有等待元素 */
if(!waitqueue_active(&button_wq_head))
return IRQ_HANDLED;
/* 读取按键值 */
button_val = gpio_get_value(S5PV210_GPH0(2));
button_press = 1;
/* 唤醒等待队列 */
wake_up_interruptible(&button_wq_head);
return IRQ_HANDLED;
}
static int button_open(struct inode *inode, struct file *file)
{
int ret;
ret = request_irq(IRQ_EINT2, button_irq, IRQF_TRIGGER_FALLING, "button_irq", NULL);
return 0;
}
static ssize_t button_read(struct file *file, char __user *data, size_t size, loff_t *loff)
{
int ret;
int val;
val = button_val;
ret = copy_to_user(data, &val, sizeof(val));
return sizeof(val);
}
static int button_release(struct inode *inode, struct file *file)
{
free_irq(IRQ_EINT2, NULL);
return 0;
}
static unsigned int button_poll(struct file *file, struct poll_table_struct *poll_table)
{
unsigned int mask = 0;
if (!button_press)
{
poll_wait(file, &button_wq_head, poll_table);
}
else
{
button_press = 0;
mask = POLLIN | POLLRDNORM;
}
return mask;
}
static struct file_operations button_fops = {
.owner = THIS_MODULE,
.open = button_open,
.read = button_read,
.release = button_release,
.poll = button_poll,
};
static __init int button_init(void)
{
/* 申请设备号 */
alloc_chrdev_region(&dev_id, 1, 1, "button");
/* 分配字符设备 */
button_dev = cdev_alloc();
/* 设置字符设备 */
cdev_init(button_dev, &button_fops);
/* 注册字符设备 */
cdev_add(button_dev, dev_id, 1);
/* 创建设备节点 */
button_class = class_create(THIS_MODULE, "button"); //创建类
device_create(button_class, NULL, dev_id, NULL, "button"); //创建设备节点
gpio_request(S5PV210_GPH0(2), "button");
return 0;
}
static __exit void button_exit(void)
{
/* 注销设备节点 */
device_destroy(button_class, dev_id);
class_destroy(button_class);
/* 注销字符设备 */
cdev_del(button_dev);
kfree(button_dev);
/* 注销注册的设备号 */
unregister_chrdev_region(dev_id, 1);
gpio_free(S5PV210_GPH0(2));
}
module_init(button_init);
module_exit(button_exit);
MODULE_LICENSE("GPL");
四、测试
将上述驱动保存为button_drv.c，执行Makefile，加载驱动模块
测试应用程序
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <poll.h>
#define BUTTON_DEV "/dev/button"
int main(int argc, char* argv[])
{
int val;
struct pollfd fds[1];
int fd = open(BUTTON_DEV, O_RDONLY);
if(fd < 0)
{
printf("failed to open %s
", BUTTON_DEV);
return -1;
}
fds[0].fd = fd;
fds[0].events = POLLIN;
while(1)
{
poll(fds, 1, -1);
printf("poll return
");
if(fds[0].revents & POLLIN)
{
read(fd, &val, sizeof(val));
if(val == 0)
{
printf("button press
");
}
}
}
close(fd);
return 0;
}
编译运行
运行效果，只有按键按下时，poll才会放回
————————————————
版权声明：本文为CSDN博主「JT同学」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_42462202/article/details/100017339