驱动开发 —— 多路复用（select 和 poll）

多路复用

1、概念

假设：在单进程与单线程情况下，应用程序要同时处理多路IO流（多个设备）

如果在应用程序中采用while(1) { read()  ... }进行处理，那么每次只能处理一个设备，其他设备有请求时，则会被延迟，甚至丢失数据。如果在一个设备处理中阻塞，则不会接着执行，也不能处理其他设备的数据。因此，可以采用多路复用的方法：select 、 poll

　　阻塞模式下会有两种情况：等待 、对数据进行操作。多路复用就是实现了等待的动作。

2、多路复用的思想

　　—先构造一张有关描述符的表，然后调用一个函数（select/poll）。当这些文件描述符中的一个或多个已经准备好进行IO时，函数才返回。

　　—函数返回时，告诉进程那个描述符已经就绪，可以进行IO操作。　

3、实现步骤

1. 把关心的文件描述符加入到fd_set集合中
2. 调用select / poll函数去监控集合fd_set中的文件描述符（阻塞等待集合中一个或多个文件描述符有数据）
3. 当有数据时，退出select（）阻塞
4. 依次判断哪个文件描述符有数据
5. 依次处理有数据的文件描述符的数据

 4、poll的应用

1， 需要打开多个文件(多个设备)

2， 利用poll来实现监控fd的读，写，出错
    #include <poll.h>

   int poll(struct pollfd *fds, nfds_t nfds, int timeout);
   参数1： 表示多个文件描述符集合
        struct pollfd描述的是文件描述符的信息
        struct pollfd {
           int   fd;  //文件描述符
           short events;   //希望监控fd的什么事件：读，写，出错
                        POLLIN 读，
                        POLLOUT 写，
                        POLLERR出错
           short revents;    //结果描述，表示当前的fd是否有读，写，出错
                        //用于判断，是内核自动赋值
                        POLLIN 读，
                        POLLOUT 写，
                        POLLERR出错
        };
    参数2：被监控的fd的个数
    参数3： 监控的时间：
                正： 表示监控多少ms
                负数： 无限的时间去监控
                0： 等待0ms，类似于非阻赛
    返回值： 负数：出错
            大于0，表示fd中有数据
            等于0： 时间到

5、在驱动代码中实现poll接口

　　如果应用中使用poll对设备文件进行了监控，那么设备驱动就必须实现poll接口

unsigned int key_drv_poll(struct file *filp, struct poll_table_struct *pts)
{
    
    // 返回一个mask值
    unsigned int mask;
    // 调用poll_wait,将当前到等待队列注册系统中
    poll_wait(filp, &key_dev->wq_head, pts);
    
    // 1，当没有数据到时候返回一个0
    if(!key_dev->key_state)
        mask = 0;

    // 2，有数据返回一个POLLIN
    if(key_dev->key_state)
        mask |= POLLIN;

    return mask;
}

const struct file_operations key_fops = {
    .poll = key_drv_poll,   
};

6、示例--多路复用poll实现

#include <linux/init.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/kdev_t.h>
#include <linux/err.h>
#include <linux/device.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>


#define GPXCON_REG 0X11000C20   //不可以从数据寄存器开始映射，要配置寄存器
#define KEY_ENTER  28

//0、设计一个描述按键的数据的对象
struct key_event{
    int code;    //按键类型：home，esc,enter
    int value;   //表状态，按下，松开
};

//1、设计一个全局对象——— 描述key的信息
struct key_desc{
    unsigned int dev_major;
    int irqno;  //中断号
    struct class  *cls;
    struct device *dev;
    void *reg_base;
    struct key_event event;
    wait_queue_head_t wq_head;
    int key_state;   //表示是否有数据
};

struct key_desc *key_dev;


irqreturn_t key_irq_handler(int irqno, void *devid)
{
    printk("----------%s---------",__FUNCTION__);

    int value;
    //读取按键状态
    value = readl(key_dev->reg_base + 4) & (0x01<<2);
    
    if(value){
        printk("key3 up
");
        key_dev->event.code  = KEY_ENTER;
        key_dev->event.value = 0;
    }else{
        printk("key3 down
");
        key_dev->event.code  = KEY_ENTER;
        key_dev->event.value = 1;
    }

    //表示有数据,唤醒等待队列中的等待项
    wake_up_interruptible(&key_dev->wq_head);
    
    //同时设置标志位,表示有数据
    key_dev->key_state = 1;
    
    return IRQ_HANDLED;
}


//获取中断号
int get_irqno_from_node(void)
{
    int irqno;
    //获取设备树中的节点
    struct device_node *np = of_find_node_by_path("/key_int_node");
    if(np){
        printk("find node success
");
    }else{
        printk("find node failed
");
    }

    //通过节点去获取中断号
    irqno = irq_of_parse_and_map(np, 0);
    printk("iqrno = %d",key_dev->irqno);

    return irqno;
}

ssize_t key_drv_read (struct file * filp, char __user * buf, size_t count, loff_t * fops)
{
    //printk("----------%s---------",__FUNCTION__);
    int ret;

    //在没有数据时，进行休眠
        //key_state在zalloc初始化空间后，为0，则阻塞
    wait_event_interruptible(key_dev->wq_head, key_dev->key_state);
    
    ret = copy_to_user(buf, &key_dev->event, count);
    if(ret > 0)
    {
        printk("copy_to_user error
");
        return -EFAULT;
    }

    
    //传递给用户数据后，将数据清除,否则APP每次读都是第一次的数据
    memset(&key_dev->event, 0, sizeof(key_dev->event));
    key_dev->key_state = 0;
    
    return count;
}

ssize_t key_drv_write (struct file *filp, const char __user * buf, size_t count, loff_t * fops)
{
    printk("----------%s---------",__FUNCTION__);
    return 0;
}

int key_drv_open (struct inode * inode, struct file *filp)
{
    printk("----------%s---------",__FUNCTION__);
    return 0;
}

int key_drv_close (struct inode *inode, struct file *filp)
{
    printk("----------%s---------",__FUNCTION__);
    return 0;
}

unsigned int key_drv_poll (struct file * filp, struct poll_table_struct *pts)
{
    //返回一个mask值
    unsigned int mask = 0;
    
    //调用poll_wait,将当前的等待队列注册到系统中
    poll_wait(filp, &key_dev->wq_head, pts);
    //1、当没有数据的时候返回0
    if(!key_dev->key_state)
    {
        mask = 0;
    }
    //2、当有数据的时候返回POLLIN
    if(key_dev->key_state)
        mask |= POLLIN;

    return mask;
}


const struct file_operations key_fops = {
    .open    = key_drv_open,
    .read    = key_drv_read,
    .write   = key_drv_write,
    .release = key_drv_close,
    .poll    = key_drv_poll,

};



static int __init key_drv_init(void)
{
    //演示如何获取到中断号
    int ret;
    
    //1、设定全局设备对象并分配空间
    key_dev = kzalloc(sizeof(struct key_desc), GFP_KERNEL);  //GFP_KERNEL表正常分配内存
                          //kzalloc相比于kmalloc，不仅分配连续空间，还会将内存初始化清零

    //2、动态申请设备号
    key_dev->dev_major = register_chrdev(0, "key_drv", &key_fops);

    //3、创建设备节点文件
    key_dev->cls = class_create(THIS_MODULE, "key_cls");
    key_dev->dev = device_create(key_dev->cls, NULL, MKDEV(key_dev->dev_major, 0), NULL, "key0");

    //4、硬件初始化 -- 地址映射或中断申请    
    
    key_dev->reg_base = ioremap(GPXCON_REG,8);

    key_dev->irqno = get_irqno_from_node();
    
    ret = request_irq(key_dev->irqno, key_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, 
        "key3_eint10", NULL);
    if(ret != 0)
    {
        printk("request_irq error
");
        return ret;
    }

    //初始化等待队列头
    init_waitqueue_head(&key_dev->wq_head);  //wait_queue_head_t *q
    
    
    
    return 0;
}

static void __exit key_drv_exit(void)
{
    iounmap(GPXCON_REG);
    free_irq(key_dev->irqno, NULL);  //free_irq与request_irq的最后一个参数一致
    device_destroy(key_dev->cls, MKDEV(key_dev->dev_major, 0));
    class_destroy(key_dev->cls);
    unregister_chrdev(key_dev->dev_major, "key_drv");
    kfree(key_dev);
}


module_init(key_drv_init);
module_exit(key_drv_exit);

MODULE_LICENSE("GPL");

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <poll.h>


#define KEY_ENTER  28

//0、设计一个描述按键的数据的对象
struct key_event{
    int code;    //按键类型：home，esc,enter
    int value;   //表状态，按下，松开
};


int main(int argc, char *argv[])
{
    struct key_event event;
    int ret;
    char in_buf[128];
    
    int fd;
    fd = open("/dev/key0", O_RDWR);
    if(fd < 0)
    {
        perror("open");
        exit(1);
    }

    //监控多个文件fd
    struct pollfd pfd[2];
    pfd[0].fd = fd;  //监控按键输入
    pfd[0].events = POLLIN;

    pfd[1].fd = 0; //标准输入：0，标准输出：1，标准出错：2
    pfd[1].events = POLLIN;

    while(1)
    {
        printf("-----------------start to poll--------------------
");
        ret = poll(pfd, 2, -1);  //在驱动中fops要实现poll接口
        
        if(ret > 0)
        {
            //表示2个fd中至少一个发生读事件
            if(pfd[0].revents & POLLIN)  //revents用于判断，会由内核自动填充
            {
                read(pfd[0].fd, &event, sizeof(struct key_event));  //每次读必有数据
                if(event.code == KEY_ENTER)
                {
                    if(event.value)
                    {
                        printf("APP__ key enter down
");
                    }else{

                        printf("APP__ key enter up
");
                    }
                }
            }

            if(pfd[1].revents & POLLIN)
            {
                fgets(in_buf, 128, stdin);  //从标准输入中获取128字节存入in_buf
                printf("in_buf = %s
",in_buf);
            }
        }
        else{
                perror("poll");
                exit(1);
            }
        printf("----------------------End poll----------------------
");
    }
    
    
    close(pfd[0].fd);

    return 0;
}