字符设备驱动-----按键驱动（中断+poll机制）

http://blog.csdn.net/huntinux/article/details/8699611

1）中断

在驱动中注册中断使用request_irq函数。参数依次为：中断号，中断处理函数， 中断触发方式和处理方式， 中断名字， 传递给中断处理函数的参数。

[cpp] view plain copy print ?

1. static int key_drv_open(struct inode *inode, struct file *file)  
2. {  
3.     printk("key_drv_open-interrupt-poll");  
4.       
5.     request_irq(IRQ_EINT8,  key_irq, IRQF_TRIGGER_FALLING, "k1", (void *)&keys[0]); //k1  
6.     request_irq(IRQ_EINT11, key_irq, IRQF_TRIGGER_FALLING, "k2", (void *)&keys[1]); //k2  
7.   
8.     return 0;  
9. }  

其中key_irq：

[cpp] view plain copy print ?

1. irqreturn_t key_irq(int irq, void * dev_id)  
2. {  
3.     struct key_desc *p = (struct key_desc *)dev_id;  
4.   
5.     key_val = p->val;  
6.     ev_press = 1;                 
7.        wake_up_interruptible(&key_waitq);     
8.   
9.     return 0;  
10. }  

ev_press是一个全局变量，用来记录是否有按键按下; key_waitq 是一个等待队列，当某事件没有发生的时候将进程加入这个队列，当某事件发生（在这里事件就是按键是否按下），然后进入中断处理函数key_irq, 从对应中断的dev_id中取出有用的信息，并记录下来（这里是记录按键数值），然后唤醒进程。

在程序退出的时候不要忘记将中断还回，这要用到free_irq函数，对于这个例子释放IRQ的代码为：

[cpp] view plain copy print ?

1. free_irq(IRQ_EINT8, (void *)&keys[0]);  
2. free_irq(IRQ_EINT11, (void *)&keys[1]);  

用户使用read函数的时候会调用驱动的相应函数，这里为

[cpp] view plain copy print ?

1. static int key_drv_read(struct file *file, char __user *buf, size_t count, loff_t *loff)  
2. {  
3.   
4.     wait_event_interruptible(key_waitq, ev_press);  
5.     ev_press = 0;  
6.   
7.     copy_to_user(buf, &key_val, sizeof(key_val));  
8.   
9.     return 0;  
10. }  

可以发现，用户在调用read函数的时候，驱动中对应的函数key_drv_read函数会使用wait_event_interruptible函数将进程挂起， 直到用户按下按键，ev_press变成1的时候（这个过程为： 用户按下按键--》发生中断--》进入中断处理函数key_irq--》将进程唤醒，并设置ev_press为1， 记录按键数值---》key_drv_read将按键数值返回），这时数据就绪，返回给用户即可。

2）poll

关于poll机制： 见文章最下面

首先， 在file_operation结构中填写驱动自己的poll函数

[cpp] view plain copy print ?

1. static unsigned key_drv_poll(struct file *file, struct poll_table_struct *wait)  
2. {  
3.     unsigned int mask = 0;  
4.   
5.     poll_wait(file, &key_waitq, wait);  
6.   
7.     if(ev_press)  
8.         mask |= POLLIN | POLLRDNORM;  
9.   
10.     return mask;  
11. }  
12.   
13.   
14. //file_operations   
15. static struct file_operations key_drv_fops = {  
16.     .owner = THIS_MODULE,  
17.     .open  = key_drv_open,  
18.     .read  = key_drv_read,  
19.     .release = key_drv_close,  
20.     .poll   = key_drv_poll,  
21. };  

我们驱动中的poll函数会调用poll_wait函数将当前进程加入到key_waitq中（这个与中断中用到的队列为同一个）

用户程序使用poll函数来等待我们的程序一段时间，如果在指定事件内没有发生指定事件（这里为按键是否按下），那么就返回一个数值，这里为mask。

如果在等待事件内用户按下了按键，那么就进入中断处理函数，将en_press改为1, 然后key_drv_poll将返回数值改为： mask |= POLLIN | POLLRDNORM。

这样用户程序就可以根据不同的返回值来判断是否可以从设备中读取数据。

3）用户程序 或 测试程序：

[cpp] view plain copy print ?

1. #include <stdio.h>   
2. #include <unistd.h>   
3. #include <sys/types.h>   
4. #include <sys/stat.h>   
5. #include <fcntl.h>   
6. #include <poll.h>   
7.   
8. #define DEVNAME "/dev/keysintpoll"   
9.   
10.    
11. int main(){  
12.     int fd;  
13.     int val;  
14.     struct pollfd fds[1];  
15.     int ret;  
16.       
17.     fd = open(DEVNAME, O_RDWR);  
18.     if(fd < 0){  
19.         perror(DEVNAME);  
20.         return -1;  
21.     }  
22.   
23.     fds[0].fd = fd;  
24.     fds[0].events = POLLIN;  
25.     while(1){  
26.         ret = poll(fds, 1, 5000);  
27.         if(0 == ret){  
28.             printf("time out.\n");  
29.         }else{  
30.             read(fd, &val, sizeof(val));  
31.             printf("key value = %d\n", val);  
32.         }  
33.     }  
34.   
35.     return 0;  
36. }  

从用户执行程序开始进行分析：

用户程序调用poll

......  省略若干过程

---->驱动程序的poll函数，这里为 key_drv_poll

---->poll_wait 将进程放入到队列key_waitq中（注意这里并没有将进程挂起， 真正的挂起操作在内核的do_sys_poll中完成，详细情况见下面的poll机制分析）

---->如果指定时间内用户没有按下按键（即ev_press没有变成1, 那么就返回0给用户程序，然后用户程序就打印 "time out" ）

---->如果指定时间内用户按下了按键，那么就会发生中断，进入中断处理函数，记录相关信息，然后将进程唤醒，并将ev_press设置为1, 中断返回，key_drv_poll

       将返回数值改为： POLLIN | POLLRDNORM，即用户程序执行poll得到的返回值不是0 ， 表示设备就绪，可以对设备进行读操作

---->用户调用read，会进入驱动相应的read函数，这里为key_drv_read。此时，ev_press已经变成1, 所以不用等待就可以将数据返回给用户。