中断处理------文件IO模型 （三）POLL机制 基于tiny4412开发板

使用了阻塞模型，虽然把资源浪费的问题给解决了，但是又出现了新的问题，当我们没有按下按键时候，进程休眠，如果不按下按键，进程就一直休眠一直阻塞在那里，效率很明显就低了

所以就引出有一种叫做poll/select机制的模型，同时监控多个设备，即使有一个设备堵塞在那里也不会影响其他的设备

首先来看app，要监控多个设备，所以要打开多个设备

fd=open("/dev/qin",O_RDWR);
		struct mypollfd pfd[2]; 
		pfd[0].fd=fd;
		pfd[0].event=POLLIN;
		
		pfd[1].fd=0;//0代表标准输出，系统宏定义的，不用纠结
		pfd[1].event=POLLIN;

定义一个结构体，存放监控设备的信息

struct mypollfd{
	int fd;//需要打开的的设备文件
	short event;//监控的事件，读，写或者出错
	short revents;//内核自动复制，是否可以读写
	
};

POLLIN代表标准读操作
我们需要在循环里面用poll函数对设备实时监控

ret=poll(pfd,2,-1);

返回值大于0，说明监控的设备中有一个发生了相应的事件.
接下来再去判断是哪一个设备触发了事件

if(pfd[0].revents & POLLIN)
{
	//做相应的读写操作
}
if(pfd[1].revents & POLLIN)
{
	//做相应的读写操作
}

这样就能完成监控多个设备

接下来是驱动程序
在file_operations结构体中实现.poll就行了

static struct file_operations myfops={
        .owner=THIS_MODULE,
        .open=key_open,
        .release=key_close,
        .write=key_write,
        .read=key_read,
        .poll=key_poll,
};

poll函数中

unsigned int key_poll (struct file *file, struct poll_table_struct *fdpoll){
	unsigned int mask;
	poll_wait(file,&my_key.key_hand_queue,fdpoll);//加入等待队列
	if(!my_key.key_state)//判断按键是否按下
		{
			mask=0;
		}
	else{
			mask=mask | POLLIN;//当按下时候返回POLLLIN会被app捕捉到
		}
		return mask;
}

这样就完成了对多个设备的监控操作了，即使一个阻塞也不会影响其他的设备

完整驱动代码如下：

#include<linux/init.h>
#include<linux/module.h>
#include<linux/device.h>
#include<linux/fs.h>
#include <asm/uaccess.h>
#include<linux/interrupt.h> //中断注册注销头文件
#include<linux/gpio.h>   //gpio相关的头文件
#include<linux/cdev.h>
#include <linux/string.h>
#include<linux/sched.h>
#include<linux/poll.h>


struct key_event{
        int code;//按键类型
        int value;//按键状态，按下或者抬起(    0  /  1 )
};

struct key_dsc{
         int major;
         struct cdev *key_cdev;
        struct  class *key_class;
        struct  device *key_dev;
        int irq;//中断号
         unsigned long flag;
        struct key_event my_event;
		wait_queue_head_t key_hand_queue;
		int key_state;
};
#define device_name "qin_key"
#define class_name "qin_class"
#define KEY_ENTER 28

struct key_dsc my_key;


ssize_t key_read(struct file *file, const char __user *buffer, size_t count, loff_t *fpos){
        //  ****************read函数目的是将案按键的数组传到应用层，kbuf[4]   ************

		//没有数据将会休眠进行到这一步，不会再往下执行
 		wait_event_interruptible(my_key.key_hand_queue,my_key.key_state);//将进程休眠，用my_ke中的state状态判断

		//有数据将会继续往下执行
        if(copy_to_user(buffer,&my_key.my_event,sizeof(struct key_event)))//copy_to_user 返回零代表copy失败，1代表成功
                {
                        printk("\n   copy  fail!!   \n");
                }
    
                memset(&my_key.my_event,0,sizeof(struct key_event));
				my_key.key_state=0;//本次数据传送完需要将状态置0，继续休眠
        return count;
}

ssize_t key_write (struct file *file, const char __user *buf, size_t count, loff_t *fpos){
        printk("\n              key_ is write!!         \n");

}


int  key_open (struct inode *inode, struct file *file){
                printk("\n              key_ is open!!          \n");
                                return 0;
}

int key_close(struct inode *inode, struct file *file){
                printk("\n              key_ is close!!         \n");
}

irqreturn_t key_handle_t(int irq,void *dev_id){
        int dn=0;
        dn=gpio_get_value(EXYNOS4_GPX3(2));//根据这个函数获取GPX3_2的按键状态
        if(!dn)
                {
                        printk("\n key   down !! \n");
                                                my_key.my_event.code=KEY_ENTER;
                                                my_key.my_event.value=1;
                }
        else
                {
                        printk("\n key   up !! \n");
                                                my_key.my_event.code=KEY_ENTER;
                                                my_key.my_event.value=0;
                }
		wake_up_interruptible(&my_key.key_hand_queue);//唤醒进程
		my_key.key_state=1;//此时有数据，将状态置1

        return IRQ_HANDLED;

}

unsigned int key_poll (struct file *file, struct poll_table_struct *fdpoll){
	unsigned int mask;
	poll_wait(file,&my_key.key_hand_queue,fdpoll);
	if(!my_key.key_state)
		{
			mask=0;
		}
	else{
			mask=mask | POLLIN;
		}
		return mask;
}

static struct file_operations myfops={
        .owner=THIS_MODULE,
        .open=key_open,
        .release=key_close,
        .write=key_write,
        .read=key_read,
        .poll=key_poll,
};

static int __init mykey_init(void)
{
                my_key.irq=0;
        my_key.major=250;

        my_key.flag=IRQF_DISABLED |
                    IRQF_TRIGGER_FALLING |
                    IRQF_TRIGGER_RISING;//设置属性，上升，下降沿触发

        my_key.irq=gpio_to_irq(EXYNOS4_GPX3(2));//获取中断号
        request_irq(my_key.irq,key_handle_t,my_key.flag,"key1",NULL);//将这个按键注册到内核，这样才能识别
                if(register_chrdev(my_key.major,"qin",&myfops))//返回值为1则失败
                        {
                                        printk("\nregister is faile !\n");
                        }
                else
                        {
                                                printk("\nregister is ok !\n");
                        }

        my_key.key_class=class_create(THIS_MODULE,"class");
        my_key.key_dev=device_create(my_key.key_class,NULL,MKDEV(my_key.major,0),NULL,"qin");
        printk("\nI am key_dev\n");

		my_key.key_state=0;
		init_waitqueue_head(&my_key.key_hand_queue);//初始化等待队列头

		
        return 0;
}
static int __exit mykey_exit(void)
{
        free_irq(my_key.irq,NULL); //注销key1中断
                device_destroy(my_key.key_class,MKDEV(my_key.major,0));//注销dev
                class_destroy(my_key.key_class);//注销class
        unregister_chrdev(my_key.major,"qin");

        printk("\n   bye      bye~~~~~~~\n");
        return 0;
}
module_init(mykey_init);
module_exit(mykey_exit);
MODULE_LICENSE("GPL");

app：

#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<string.h>
#include<poll.h>
#define KEY_ENTER 28

struct key_event{
        int code;//按键类型
        int value;//按键状态，按下或者抬起(    0  /  1 )
};

struct mypollfd{
	int fd;
	short event;
	short revents;//内核自动复制，是否可以读写
	
};
int main()
{
		char buf[12];
        struct key_event key;
		int ret=0;
        int fd=0;
        fd=open("/dev/qin",O_RDWR);
        if(fd<0)
                {       printf("open file fail!");
    
                }
        else
                {
                        printf("\n   open file success !!\n");
                }
		
		struct mypollfd pfd[2]; 
		pfd[0].fd=fd;
		pfd[0].event=POLLIN;
		
		pfd[1].fd=0;
		pfd[1].event=POLLIN;
		while(1)
		{
		//printf("\n-------------------------------start poll------------------\n");
				ret=poll(pfd,2,-1);
				if(ret>0)
					{
						if(pfd[0].revents & POLLIN)
							{
								read(pfd[0].fd,&key,sizeof(struct key_event));
		                 if(key.code==KEY_ENTER)
		                        {
		                        if(key.value==0)
		                                {
		                                        printf("\n              key value   is %d       \n",key.code);  
		                                        printf("\n              key value   is %d       \n",key.value); 
		                                        printf("\n              key up!!!!!!!!!!        \n");   
		                                }
		                        if(key.value==1)
		                                {
		                                        printf("\n              key value   is %d       \n",key.code);
		                                        printf("\n              key value   is %d       \n",key.value); 
		                                        printf("\n              key down!!!!!!!!!!      \n");    
		                                }
		                        }
							}
						if(pfd[1].revents & POLLIN)
							{
								fgets(buf,128,stdin);
								printf("\nstdin　！！！！！！！！！！！！n");
							}
					}
				else
					{
						perror("\npoll!\n");
						return -1;
					}
				//printf("\n-------------------------------end poll------------------\n");
		}


		close(fd);
		
        return 0;
}