Linux设备驱动程序——高级字符驱动程序操作(poll机制)

5900阅读　0评论2014-01-08　wangtisheng
分类：嵌入式

                                        Linux设备驱动程序
                                  ——高级字符驱动程序操作(poll机制)
   
    阻塞与非阻塞访问是I/O 操作的两种不同模式，前者在I/O 操作暂时不可进行时会让进程睡眠，后者则不然。(可参考上一篇阻塞型I/O示例)
    在设备驱动中阻塞I/O 一般基于等待队列来实现，等待队列可用于同步驱动中事件发生的先后顺序。使用非阻塞I/O 的应用程序也可借助轮询函数来查询设备是否能立即被访问，用户空间调用select()和poll()接口，设备驱动提供poll()函数。设备驱动的poll()本身不会阻塞，但是poll()和select()系统调用则会阻塞地等待文件描述符集合中的至少一个可访问或超时。-----引自宋宝华《Linux设备驱动开发详解》。
    使用非阻塞I/O的应用程序经常使用poll、select和epoll系统调用，其本质是都允许进程决定是否可以对一个或多个打开的文件做非阻塞的读取或写入。
    当应用程序需要进行对多文件读写时，若某个文件没有准备好，则系统会处于读写阻塞的状态，并影响了其他文件的读写。为了避免这种情况，在必须使用多输入输出流又不想阻塞在它们任何一个上的应用程序常将非阻塞 I/O 和 poll（System V）、select（BSD Unix）、 epoll(linux2.5.45开始)系统调用配合使用。当poll函数返回时，会给出一个文件是否可读写的标志，应用程序根据不同的标志读写相应的文件，实现非阻塞的读写。这些系统调用功能相同: 允许进程来决定它是否可读或写一个或多个文件而不阻塞。这些调用也可阻塞进程直到任何一个给定集合的文件描述符可用来读或写。这些调用都需要来自设备驱动中poll 方法的支持，poll返回不同的标志，告诉主进程文件是否可以读写，其原型（定义在 ）------引自http://blog.chinaunix.net/uid-20543672-id-94299.html。
        unsigned int (*poll) (struct file *filp, struct poll_table *wait);
    当用户空间程序在驱动程序关联的文件描述符上执行poll、select或epoll系统调用时，该驱动方法将被调用。
    该设备方法分为两步：
    ① 在一个或多个可指示查询状态变化的等待队列上调用 poll_wait. 如果没有文件描述符可用来执行 I/O, 则内核使进程在传递到该系统调用的所有文件描述符对应的等待队列上等待。
    ② 返回一个用来描述操作是否可以立即无阻塞执行的位掩码。
    poll_table_struct结构，用于在内核中实现oll、select以及epoll系统调用，它被传递给驱动程序方法，以使每个可以唤醒进程和修改poll操作状态的等待队列都可以被驱动程序装在。驱动程序想poll_table结构添加一个等待队列用poll_wait函数：
        static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p);
    poll方法执行的第二项任务是返回描述符哪个操作可以立即执行的位掩码。例如，如果设备已经数据就绪，一个read可以立刻完成而不用休眠，位掩码的具体定义可参考《Linux设备驱动程序》。
                
    一个示例：
    该示例来自韦东山老师的视频教程第一期，下载地址，其针对JZ2440进行了讲解，我将其修改到了我的mini2440上，教程中提到了poll机制分析.pdf可供参考。完整驱动及测试例程poll.rar
    buttons_int_poll_drv.c

点击(此处)折叠或打开

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/init.h>
  5. #include <linux/device.h>
  6. #include <linux/irq.h>
  7. #include <linux/interrupt.h>
  8. #include <linux/poll.h>
  9. #include <asm/arch/regs-gpio.h>
  10. #include <asm/hardware.h>
  11. #include <linux/uaccess.h>

  13. #define        DEVICE_NAME        "mini2440_buttons" //设备名称

  15. static struct class *buttons_int_poll_drv_class;
  16. static struct class_device *buttons_int_poll_drv_class_dev;


  19. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);    //等待队列:当没有按键被按下时，如果有进程调用buttons_int_poll_drv_read函数，它将休眠

  21. static volatile int ev_press = 0;                //中断事件标志, 中断服务程序将它置1，s3c24xx_buttons_read将它清0
  22. static unsigned char key_val;                    //保存键值

  24. //引脚描述结构体
  25. struct pin_desc{
  26.     unsigned int pin;
  27.     unsigned int key_value;
  28. };
  29. //管脚数组，按键赋键值，按下时是0x01,松开是0x81(最高位为1)
  30. struct pin_desc pins_desc[6] = {
  31.         {S3C2410_GPG0, 0x01},
  32.         {S3C2410_GPG3, 0x02},
  33.         {S3C2410_GPG5, 0x03},
  34.         {S3C2410_GPG6, 0x04},
  35.         {S3C2410_GPG7, 0x05},
  36.         {S3C2410_GPG11,0x06},
  37. };

  39. //确定按键值
  40. static irqreturn_t buttons_irq(int irq, void *dev_id)
  41. {
  42.     //printk("irq = %d\n",irq);
  43.     struct pin_desc *pindesc = (struct pin_desc *)dev_id;
  44.     unsigned int pinval;
  45.     pinval = s3c2410_gpio_getpin(pindesc->pin);
  46.     if(pinval)
  47.     {
  48.         //松开
  49.         key_val = 0x80 | pindesc->key_value;
  50.     }
  51.     else
  52.     {
  53.         //按下
  54.         key_val = pindesc->key_value;
  55.     }    
  56.     ev_press = 1;     
  57.     wake_up_interruptible(&button_waitq);
  58.     return IRQ_HANDLED;
  59. }

  61. static int buttons_int_poll_drv_open(struct inode *inode, struct file *file)
  62. {
  63.     int ret;
  64.     ret = request_irq(IRQ_EINT8, buttons_irq,IRQT_BOTHEDGE,"KEY1",&pins_desc[0]);    //pins_desc[0]传递给buttons_irq
  65.     ret = request_irq(IRQ_EINT11,buttons_irq,IRQT_BOTHEDGE,"KEY2",&pins_desc[1]);
  66.     ret = request_irq(IRQ_EINT13,buttons_irq,IRQT_BOTHEDGE,"KEY3",&pins_desc[2]);
  67.     ret = request_irq(IRQ_EINT14,buttons_irq,IRQT_BOTHEDGE,"KEY4",&pins_desc[3]);
  68.     ret = request_irq(IRQ_EINT15,buttons_irq,IRQT_BOTHEDGE,"KEY5",&pins_desc[4]);
  69.     ret = request_irq(IRQ_EINT19,buttons_irq,IRQT_BOTHEDGE,"KEY6",&pins_desc[5]);
  70.     return 0;
  71. }

  73. ssize_t buttons_int_poll_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
  74. {        
  75.     int ret;
  76.     if(size != 1)            //读取单个按键
  77.         return -EINVAL;
  78.     
  79.     wait_event_interruptible(button_waitq, ev_press);    //如果没有按键动作，休眠，让出CPU
  80.     ret = copy_to_user(buf, &key_val, 1);                //返回键值
  81.     ev_press = 0;
  82.     return 1;        
  83. }

  85. int buttons_int_poll_drv_close(struct inode *inode, struct file *file)
  86. {
  87.     free_irq(IRQ_EINT8, &pins_desc[0]);
  88.     free_irq(IRQ_EINT11,&pins_desc[1]);
  89.     free_irq(IRQ_EINT13,&pins_desc[2]);
  90.     free_irq(IRQ_EINT14,&pins_desc[3]);
  91.     free_irq(IRQ_EINT15,&pins_desc[4]);
  92.     free_irq(IRQ_EINT19,&pins_desc[5]);
  93.     
  94.     return 0;
  95. }

  97. static unsigned buttons_int_poll_drv_poll(struct file *file, poll_table *wait)
  98. {
  99.     unsigned int mask = 0;
  100.     poll_wait(file, &button_waitq, wait);     // 不会立即休眠

  102.     if (ev_press)
  103.         mask |= POLLIN | POLLRDNORM;        //标识设备可以读取了

  105.     return mask;
  106. }

  108. static struct file_operations buttons_int_poll_drv_fops = {
  109.     .owner = THIS_MODULE,
  110.     .open = buttons_int_poll_drv_open,
  111.     .read = buttons_int_poll_drv_read,
  112.     .release = buttons_int_poll_drv_close,
  113.     .poll = buttons_int_poll_drv_poll,
  114. };

  116. int major;
  117. static int __init buttons_int_poll_drv_init(void)
  118. {
  119.     major = register_chrdev(0, DEVICE_NAME, &buttons_int_poll_drv_fops);
  120.     if(major < 0)
  121.     {
  122.         printk(DEVICE_NAME "\t can't register major number!\n");
  123.     }
  124.     buttons_int_poll_drv_class = class_create(THIS_MODULE, DEVICE_NAME);
  125.     buttons_int_poll_drv_class_dev = class_device_create(buttons_int_poll_drv_class, NULL, MKDEV(major, 0), NULL, DEVICE_NAME); /* /dev/mini2440_buttons */

  127.     printk(DEVICE_NAME"\t initialized!\n");
  128.     return 0;
  129. }
  130. static void __exit buttons_int_poll_drv_exit(void)
  131. {
  132.     unregister_chrdev(major, DEVICE_NAME);
  133.     class_device_unregister(buttons_int_poll_drv_class_dev);
  134.     class_destroy(buttons_int_poll_drv_class);
  135. }

  137. module_init(buttons_int_poll_drv_init);
  138. module_exit(buttons_int_poll_drv_exit);
  139. MODULE_LICENSE("GPL");
buttons_int_poll_drv_test.c

点击(此处)折叠或打开

  1. #include <fcntl.h>
  2. #include <stdio.h>
  3. #include <poll.h>

  5. //int poll(struct pollfd *fds, nfds_t nfds, int timeout);
  6. int main(int argc,char **argv)
  7. {
  8.     int fd;
  9.     unsigned char key_val;

  11.     int ret;
  12.     struct pollfd fds[1];
  13.     
  14.     fd = open("/dev/mini2440_buttons", O_RDWR);
  15.     if(fd < 0)
  16.     {
  17.         printf("can't open\n");
  18.     }
  19.     fds[0].fd = fd;
  20.     fds[0].events = POLLIN;
  21.     
  22.     while(1)
  23.     {
  24.         //ssize_t read(int fd, void *buf, size_t count);
  25.         ret = poll(fds,1,5000);
  26.         if(ret == 0)
  27.         {
  28.             printf("Time Out!\n");
  29.         }
  30.         else
  31.         {
  32.             read(fd,&key_val,1);
  33.             printf("key_val = 0x%x\n",key_val);
  34.         }
  35.     }
  36.     return 0;
  37. }
实验现象
          
    结果验证了进程被唤醒的条件有2：一是“一定时间”到了，二是被驱动程序唤醒。程序中并未加入按键防抖动。
上一篇：Linux设备驱动程序——高级字符驱动程序操作（阻塞型I/O）
下一篇：Linux设备驱动程序——高级字符驱动程序操作(异步通知)