嵌入式

嵌入式linux:字符设备驱动-----按键驱动（中断+poll机制）

2019-07-13 02:48发布

站内文章 / 嵌入式Linux
14585 0 1270
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   
  2. #include   
  3. #include   
  4. #include   
  5. #include   
  6. #include   
  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. ");  
  29.         }else{  
  30.             read(fd, &val, sizeof(val));  
  31.             printf("key value = %d ", 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, 所以不用等待就可以将数据返回给用户。

附录：
 ====================poll机制分析======================= 韦东山2009.12.10 所有的系统调用，基于都可以在它的名字前加上“sys_”前缀，这就是它在内核中对应的函数。比如系统调用open、read、write、poll，与之对应的内核函数为：sys_open、sys_read、sys_write、sys_poll。
一、内核框架： 对于系统调用poll或select，它们对应的内核函数都是sys_poll。分析sys_poll，即可理解poll机制。
  1. sys_poll函数位于fs/select.c文件中，代码如下： asmlinkagelong sys_poll(struct pollfd __user *ufds, unsigned int nfds, longtimeout_msecs) { s64timeout_jiffies; if(timeout_msecs > 0) { #if HZ >1000 /* We canonly overflow if HZ > 1000 */ if(timeout_msecs / 1000 > (s64)0x7fffffffffffffffULL / (s64)HZ) timeout_jiffies= -1; else #endif timeout_jiffies= msecs_to_jiffies(timeout_msecs); } else { /*Infinite (< 0) or no (0) timeout */ timeout_jiffies= timeout_msecs; } returndo_sys_poll(ufds, nfds,&timeout_jiffies); }
它对超时参数稍作处理后，直接调用do_sys_poll。
  1. do_sys_poll函数也位于位于fs/select.c文件中，我们忽略其他代码：
intdo_sys_poll(struct pollfd __user *ufds, unsigned int nfds, s64*timeout) { …… poll_initwait(&table); …… fdcount =do_poll(nfds, head, &table, timeout); …… }


poll_initwait函数非常简单，它初始化一个poll_wqueues变量table： poll_initwait> init_poll_funcptr(&pwq->pt, __pollwait); > pt->qproc= qproc;
即table->pt->qproc=__pollwait，__pollwait将在驱动的poll函数里用到。

  1. do_sys_poll函数位于fs/select.c文件中，代码如下： static int do_poll(unsigned intnfds, struct poll_list *list, struct poll_wqueues *wait, s64*timeout) { 01 …… 02 for (;;) { 03 …… 04 if (do_pollfd(pfd, pt)) { 05 count++; 06 pt = NULL; 07 } 08 …… 09 if (count || !*timeout ||signal_pending(current)) 10 break; 11 count = wait->error; 12 if (count) 13 break; 14 15 if (*timeout < 0) { 16 /* Wait indefinitely */ 17 __timeout =MAX_SCHEDULE_TIMEOUT; 18 } else if (unlikely(*timeout >=(s64)MAX_SCHEDULE_TIMEOUT-1)) { 19 /* 20 * Wait for longer thanMAX_SCHEDULE_TIMEOUT. Do it in 21 * a loop 22 */ 23 __timeout =MAX_SCHEDULE_TIMEOUT - 1; 24 *timeout -= __timeout; 25 } else { 26 __timeout = *timeout; 27 *timeout = 0; 28 } 29 30 __timeout =schedule_timeout(__timeout); 31 if (*timeout >= 0) 32 *timeout += __timeout; 33 } 34 __set_current_state(TASK_RUNNING); 35 return count; 36 }分析其中的代码，可以发现，它的作用如下：
  1. 从02行可以知道，这是个循环，它退出的条件为：
    1. 09行的3个条件之一(count非0，超时、有信号等待处理)
count非0表示04行的do_pollfd至少有一个成功。
    1. 11、12行：发生错误
  2. 重点在do_pollfd函数，后面再分析
  3. 第30行，让本进程休眠一段时间，注意：应用程序执行poll调用后，如果①②的条件不满足，进程就会进入休眠。那么，谁唤醒呢？除了休眠到指定时间被系统唤醒外，还可以被驱动程序唤醒──记住这点，这就是为什么驱动的poll里要调用poll_wait的原因，后面分析。

  1. do_pollfd函数位于fs/select.c文件中，代码如下： static inline unsigned intdo_pollfd(struct pollfd *pollfd, poll_table *pwait) { …… if (file->f_op &&file->f_op->poll) mask = file->f_op->poll(file,pwait); …… }
    可见，它就是调用我们的驱动程序里注册的poll函数。

二、驱动程序： 驱动程序里与poll相关的地方有两处：一是构造file_operation结构时，要定义自己的poll函数。二是通过poll_wait来调用上面说到的__pollwait函数，pollwait的代码如下： staticinline void poll_wait(struct file * filp, wait_queue_head_t *wait_address, poll_table *p) { if (p &&wait_address) p->qproc(filp,wait_address, p); }

p->qproc就是__pollwait函数，从它的代码可知，它只是把当前进程挂入我们驱动程序里定义的一个队列里而已。它的代码如下：

static void__pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table*p) { structpoll_table_entry *entry = poll_get_entry(p); if(!entry) return; get_file(filp); entry->filp= filp; entry->wait_address= wait_address; init_waitqueue_entry(&entry->wait,current); add_wait_queue(wait_address,&entry->wait); }

执行到驱动程序的poll_wait函数时，进程并没有休眠，我们的驱动程序里实现的poll函数是不会引起休眠的。让进程进入休眠，是前面分析的do_sys_poll函数的30行“__timeout= schedule_timeout(__timeout)”。 poll_wait只是把本进程挂入某个队列，应用程序调用poll> sys_poll > do_sys_poll > poll_initwait，do_poll> do_pollfd >我们自己写的poll函数后，再调用schedule_timeout进入休眠。如果我们的驱动程序发现情况就绪，可以把这个队列上挂着的进程唤醒。可见，poll_wait的作用，只是为了让驱动程序能找到要唤醒的进程。即使不用poll_wait，我们的程序也有机会被唤醒：chedule_timeout(__timeout)，只是要休眠__time_out这段时间。
现在来总结一下poll机制： 1. poll > sys_poll >do_sys_poll >poll_initwait，poll_initwait函数注册一下回调函数__pollwait，它就是我们的驱动程序执行poll_wait时，真正被调用的函数。
2.接下来执行file->f_op->poll，即我们驱动程序里自己实现的poll函数 它会调用poll_wait把自己挂入某个队列，这个队列也是我们的驱动自己定义的； 它还判断一下设备是否就绪。
3.如果设备未就绪，do_sys_poll里会让进程休眠一定时间
4.进程被唤醒的条件有2：一是上面说的“一定时间”到了，二是被驱动程序唤醒。驱动程序发现条件就绪时，就把“某个队列”上挂着的进程唤醒，这个队列，就是前面通过poll_wait把本进程挂过去的队列。
5.如果驱动程序没有去唤醒进程，那么chedule_timeout(__timeou)超时后，会重复2、3动作，直到应用程序的poll调用传入的时间到达。

热门文章