Chinaunix首页 | 论坛 | 博客
  • 博客访问: 829164
  • 博文数量: 281
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 2770
  • 用 户 组: 普通用户
  • 注册时间: 2009-08-02 19:45
个人简介

邮箱:zhuimengcanyang@163.com 痴爱嵌入式技术的蜗牛

文章分类
文章存档

2020年(1)

2018年(1)

2017年(56)

2016年(72)

2015年(151)

分类: 嵌入式

2015-08-18 14:26:24

目的:

在上一节中实现一个中断方式的按键驱动,应用程序中的read函数一直在读取键值,如果没有按下按键,将进入睡眠模式,而且永不返回。
这一节在中断的基础上添加poll机制来实现当没有按键按下的时候,设定一个超时时间,在这个时间之内如果还没有数据可读(表示按键按下),就表示超时时间到,也要返回。
poll机制说明

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调用传入的时间到达。





1. 读硬件原理图
2. 驱动代码

点击(此处)折叠或打开

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


  13. static struct class *forthdrv_class;
  14. static struct class_device    *forthdrv_class_dev;

  15. volatile unsigned long *gpfcon;
  16. volatile unsigned long *gpfdat;

  17. volatile unsigned long *gpgcon;
  18. volatile unsigned long *gpgdat;


  19. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

  20. /* 中断事件标志, 中断服务程序将它置1,forth_drv_read将它清0 */
  21. static volatile int ev_press = 0;


  22. struct pin_desc{
  23.     unsigned int pin;
  24.     unsigned int key_val;
  25. };


  26. /* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
  27. /* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
  28. static unsigned char key_val;

  29. struct pin_desc pins_desc[4] = {
  30.     {S3C2410_GPF0, 0x01},
  31.     {S3C2410_GPF2, 0x02},
  32.     {S3C2410_GPG3, 0x03},
  33.     {S3C2410_GPG11, 0x04},
  34. };


  35. /*
  36.   * 确定按键值
  37.   */
  38. static irqreturn_t buttons_irq(int irq, void *dev_id)
  39. {
  40.     struct pin_desc * pindesc = (struct pin_desc *)dev_id;
  41.     unsigned int pinval;
  42.     
  43.     pinval = s3c2410_gpio_getpin(pindesc->pin);

  44.     if (pinval)
  45.     {
  46.         /* 松开 */
  47.         key_val = 0x80 | pindesc->key_val;
  48.     }
  49.     else
  50.     {
  51.         /* 按下 */
  52.         key_val = pindesc->key_val;
  53.     }

  54.     ev_press = 1; /* 表示中断发生了 */
  55.     wake_up_interruptible(&button_waitq); /* 唤醒休眠的进程 */

  56.     
  57.     return IRQ_RETVAL(IRQ_HANDLED);
  58. }

  59. static int forth_drv_open(struct inode *inode, struct file *file)
  60. {
  61.     /* 配置GPF0,2为输入引脚 */
  62.     /* 配置GPG3,11为输入引脚 */
  63.     request_irq(IRQ_EINT0, buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
  64.     request_irq(IRQ_EINT2, buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
  65.     request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
  66.     request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);    

  67.     return 0;
  68. }

  69. ssize_t forth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
  70. {
  71.     if (size != 1)
  72.         return -EINVAL;

  73.     /* 如果没有按键动作, 休眠 */
  74.     wait_event_interruptible(button_waitq, ev_press);

  75.     /* 运行到这里,休眠唤醒。   */
  76.     /* 如果有按键动作, 返回键值 */
  77.     copy_to_user(buf, &key_val, 1);
  78.     ev_press = 0;
  79.     
  80.     return 1;
  81. }

  82. // 这个函数什么时候调用呢???
  83. int forth_drv_close(struct inode *inode, struct file *file)
  84. {
  85.     free_irq(IRQ_EINT0, &pins_desc[0]);
  86.     free_irq(IRQ_EINT2, &pins_desc[1]);
  87.     free_irq(IRQ_EINT11, &pins_desc[2]);
  88.     free_irq(IRQ_EINT19, &pins_desc[3]);
  89.     return 0;
  90. }

  91. // 增加了这个函数。
  92. static unsigned forth_drv_poll(struct file *file, poll_table *wait)
  93. {
  94.     unsigned int mask = 0;

  95.     // 将本进程挂接到等待队列button_waitq上。
  96.     poll_wait(file, &button_waitq, wait); // 1. 这里不会立即休眠,为什么????

  97.     if (ev_press)
  98.         mask |= POLLIN | POLLRDNORM;

  99.     // 2. 这里不把ev_press标志位清掉吗???  ev_press = 0;
  100.         

  101.     return mask;
  102. }




  103. static struct file_operations sencod_drv_fops = {
  104.     .owner = THIS_MODULE, /* 这是一个宏,推向编译模块时自动创建的__this_module变量 */
  105.     .open = forth_drv_open,
  106.     .read     =    forth_drv_read,    
  107.     .release = forth_drv_close,
  108.     .poll = forth_drv_poll,
  109. };


  110. int major;
  111. static int forth_drv_init(void)
  112. {
  113.     major = register_chrdev(0, "forth_drv", &sencod_drv_fops);

  114.     forthdrv_class = class_create(THIS_MODULE, "forth_drv");

  115.     forthdrv_class_dev = class_device_create(forthdrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */

  116.     gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
  117.     gpfdat = gpfcon + 1;

  118.     gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
  119.     gpgdat = gpgcon + 1;

  120.     return 0;
  121. }

  122. static void forth_drv_exit(void)
  123. {
  124.     unregister_chrdev(major, "forth_drv");
  125.     class_device_unregister(forthdrv_class_dev);
  126.     class_destroy(forthdrv_class);
  127.     iounmap(gpfcon);
  128.     iounmap(gpgcon);
  129.     return 0;
  130. }


  131. module_init(forth_drv_init);

  132. module_exit(forth_drv_exit);

  133. MODULE_LICENSE("GPL");


3. 测试程序

点击(此处)折叠或打开

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <stdio.h>
  5. #include <poll.h>


  6. /* forthdrvtest
  7.   */
  8. int main(int argc, char **argv)
  9. {
  10.     int fd;
  11.     unsigned char key_val;
  12.     int ret;

  13.     struct pollfd fds[1];
  14.     
  15.     fd = open("/dev/buttons", O_RDWR);
  16.     if (fd < 0)
  17.     {
  18.         printf("can't open!\n");
  19.     }

  20.     fds[0].fd = fd;          // 用来指定查询的驱动程序
  21.     fds[0].events = POLLIN;  // 事件方式,表示有数据等待读取,也就是说按键按下了

  22.     while (1)
  23.     {
  24.         ret = poll(fds, 1, 5000);   //查询一个文件,超时时间为5S
  25.         if (ret == 0)
  26.         {
  27.             // 1. 表示超时唤醒
  28.             printf("time out\n");
  29.         }
  30.         else
  31.         {
  32.             // 2. 表示在超时时间里,读取按键信息。如果按键没按下,进入休眠,直到按键被按下,唤醒进程并返回按键值。
  33.             read(fd, &key_val, 1);
  34.             printf("key_val = 0x%x\n", key_val);
  35.         }
  36.     }
  37.     
  38.     return 0;
  39. }


4. 测试
        

5. 小结

poll机制作用:相当于一个定时器,时间到了还没有资源就唤醒进程。

主要用途就是:进程设置一段时间用来等待资源,如果时间到了资源还没有到来,进程就立刻从睡眠状态唤醒不再等待。当然这只是使用于:这段时间以后资源对于该进程已经无用的情况,就是说在设置的时间内,访问资源是否有效,过了这个时间点,超时返回,不再访问该资源。
(1)如果在等待的时间里面,按键没按下,则进入休眠状态,不会返回。

(2)如果在等待的时间里面,按键按下,则立刻唤醒进程,返回读取的按键值。
(3)如果等待时间到,则超时唤醒进程,返回。

思考一下下面两个问题?

  1. // 增加了这个函数。
  2. static unsigned forth_drv_poll(struct file *file, poll_table *wait)
  3. {
  4.     unsigned int mask = 0;

  5.     // 将本进程挂接到等待队列button_waitq上。
  6.     poll_wait(file, &button_waitq, wait); // 1. 这里不会立即休眠,为什么????

  7.     if (ev_press)
  8.         mask |= POLLIN | POLLRDNORM;

  9.     // 2. 这里不把ev_press标志位清掉吗???,为什么?ev_press = 0;
  10.         

  11.     return mask;
  12. }



阅读(610) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~