十、【等待队列】按键中断程序更新
一、概述
linux驱动中，阻塞一般就是用等待队列来实现，将进程停止在此处并睡眠下，直到条件满足时，才可通过此处，继续运行。在睡眠等待期间，wake up时，唤起来检查条件，条件满足解除阻塞，不满足继续睡下去。
上一个按键中断程序中，在读取按键键值时，应用层在read时一直返回键值，并不会阻塞在read,等待有按键按下的时候再返回，在这里我们使用等待队列来进行阻塞。
二、等待队列相关接口
1、等待队列的定义
（1）静态定义
#define DECLARE_WAIT_QUEUE_HEAD(name) \
wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
（2）动态定义
wait_queue_head_t key_wq;
init_waitqueue_head(key_wq);
#define init_waitqueue_head(q) \
do { \
static struct lock_class_key __key; \
\
__init_waitqueue_head((q), #q, &__key); \
} while (0)
2、等待
wait_event(wq, condition) -----------------深睡眠，不可被信号打断
wait_event_interruptible(wq, condition)----浅睡眠，可以被信号打断
#define wait_event_interruptible(wq, condition) \
({ \
int __ret = 0; \
if (!(condition)) \
__wait_event_interruptible(wq, condition, __ret); \
__ret; \
})
参数:
- wq:等待队列名字
- condition：等待的条件，condition假时一直阻塞等待，为真时执行。
3、唤醒
wake_up(x) //和wait_event配套使用
wake_up_interruptible(x) //和wait_event_interruptible配套使用
三、按键中断中使用等待队列
key_drv.c
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/gpio.h>
#include <cfg_type.h>
#include <linux/interrupt.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <linux/sched.h>
struct key_gpio_t{
unsigned int irq;
char irqname[20];
unsigned char keyvalue;
};
static DECLARE_WAIT_QUEUE_HEAD(key_wq) ; //静态定义等待队列
static bool flag = false;
static struct key_gpio_t key_gpio[]=
{
{IRQ_GPIO_A_START+28,"KEY2_GPIOA28",2},
{IRQ_GPIO_B_START+30,"KEY3_GPIOB30",3},
{IRQ_GPIO_B_START+31,"KEY4_GPIOB31",4},
{IRQ_GPIO_B_START+9, "KEY6_GPIOB9",6},
};
static char keyvalue = 0;
ssize_t gec6818_key_read(struct file *filp, char __user * buf, size_t size, loff_t *oft)
{
int ret;
wait_event_interruptible(key_wq, flag);
flag = false; //唤醒一次队列后要复位flag的值
if(size !=1)
{
return -EINVAL;
}
ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));
if(ret != 0)
{
return (size -ret);
}
keyvalue=0;
return size;
}
static irqreturn_t gec6818_key_handler(int irq, void * dev)
{
struct key_gpio_t keytmp=*(struct key_gpio_t *)dev;
keyvalue =keytmp.keyvalue;
mdelay(400); //按键防抖
flag = true; //设置flag为true
wake_up_interruptible(&key_wq); //按键按下时，唤醒等待队列
return IRQ_HANDLED;
}
struct file_operations key_misc_fops=
{
.read = gec6818_key_read,
};
static struct miscdevice key_misc={
.minor = MISC_DYNAMIC_MINOR,
.name = "key_misc",
.fops = &key_misc_fops,
};
static int __init gec6818_key_init(void)
{
int ret,i;
printk(KERN_INFO"gec6818_key_init\n");
ret = misc_register(&key_misc);
if(ret < 0)
{
printk(KERN_INFO"key misc register fail.\n");
goto misc_register_err;
}
for(i=0;i<4;i++)
{
ret = request_irq(key_gpio[i].irq, gec6818_key_handler,IRQF_TRIGGER_FALLING,key_gpio[i].irqname,(void*)&key_gpio[i]);
if(ret < 0)
{
printk(KERN_INFO"request_irq fail.\n");
goto irq_request_err;
}
}
return 0;
irq_request_err:
while(i--)
{
free_irq(key_gpio[i].irq,NULL);
}
misc_register_err:
return 0;
}
static void __exit gec6818_key_exit(void)
{
int i;
printk(KERN_INFO"gec6818_key_exit\n");
misc_deregister(&key_misc);
for(i=0;i<4;i++)
{
free_irq(key_gpio[i].irq,(void *)&key_gpio[i]);
}
}
module_init(gec6818_key_init);
module_exit(gec6818_key_exit);
MODULE_LICENSE("GPL");
main.c
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/ioctl.h>
int main()
{
int fd,ret;
char keyvalue=0;
fd = open("/dev/key_misc",O_RDWR);
if(fd<0)
{
perror("open key_misc error!");
}
while(1)
{
ret=read(fd,&keyvalue,1);
if(ret !=1)
{
perror("read error");
continue;
}
printf("keyvalue=key%d\n",keyvalue);
}
close(fd);
}
相关链接：linux中的阻塞机制和等待队列
