Linux按键中断

本文是基于韦东山视频的学习笔记

实现按键驱动

定义 fileoption 结构体，并实现函数

ssize_t key_drv_read(struct file *file, char __user *buf, size_t size, loff_t *offset)
{
	unsigned char keyval[4];

	if (size != sizeof(keyval))
		return -EINVAL;

	keyval[0] = (*pGPFDAT & (1 << 0)) ? 1:0;
	keyval[1] = (*pGPFDAT & (1 << 2))? 1:0;

	keyval[2] = (*pGPGDAT & (1 << 3)) ? 1:0;
	keyval[3] = (*pGPGDAT & (1 << 11)) ? 1:0;
	 
	
	copy_to_user(buf, keyval, sizeof(keyval));	//把数据从kernel_buf读到用户空间
	
	return sizeof(keyval);
}
int key_drv_open (struct inode *node, struct file *file)
{

	*pGPFCON &= ~((3<<0) | (3<<4)); /* 把GPGCON 0~1, 4~5位置清零 */
	*pGPGCON &= ~((3<<6) | (3<<22)); /* 把GPGCON 6~7 , 22~23 位清零 */


	return 0;
}
/* 定义结构体，传参给内核 */
static const struct file_operations key_drv_fo = {
	.owner		= THIS_MODULE,
	.open		= key_drv_open,
	.read		= key_drv_read,
};

注册（初始化）驱动函数

/* 初始化（注册）驱动 */
static int __init key_drv_init(void)
{
	
	major = register_chrdev(0, "key_drv", &key_drv_fo);

	key_class = class_create(THIS_MODULE, "key_drv");
	
	key_drv_class = class_device_create(key_class, NULL, MKDEV(major, 0), NULL, "key_drv"); /* /dev/key_drv */

	pGPFCON = (unsigned int *)ioremap(0x56000050, 16);
	pGPFDAT = pGPFCON + 1;

	pGPGCON = (unsigned int *)ioremap(0X56000060, 16);
	pGPGDAT = pGPGCON + 1;

	return 0;

}

卸载驱动

/* 卸载驱动 */
static void __exit key_drv_exit(void)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	class_device_unregister(key_drv_class);
	class_destroy(key_class);
	unregister_chrdev(major, "key_drv");
	iounmap(pGPFCON);
	iounmap(pGPGCON);
}

头文件和全局变量

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/mm.h>
#include <linux/highmem.h>
#include <linux/blkdev.h>
#include <linux/module.h>
#include <linux/backing-dev.h>
#include <linux/interrupt.h>
#include <asm/uaccess.h>

static struct class *key_class;
static struct class_device	*key_drv_class;
static int major = 0;

unsigned int *pGPFCON = NULL; 
unsigned int *pGPFDAT = NULL; 
unsigned int *pGPGCON = NULL; 
unsigned int *pGPGDAT = NULL; 

完善信息

/* 7. 其他完善：提供设备信息，自动创建设备节点                                     */

module_init(key_drv_init);
module_exit(key_drv_exit);

MODULE_LICENSE("GPL");

实现应用程序

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
	unsigned char keyval[4] = {1,1,1,1};
	int fd = 0;
	
	/* 打开驱动文件 */
	fd = open("/dev/key_drv", O_RDWR);
	if (fd<0) printf("can't open file key_drv\n");

	while(1)
	{
		read(fd, keyval, sizeof(keyval));
		if ( !keyval[0] || !keyval[1] || !keyval[2] || !keyval[3] )
		{
			printf("%d %d %d %d\n", keyval[0], keyval[1], keyval[2], keyval[3]);
		}
	}
	return 0;

}

但是目前中断不会自动打开，需要手动在终端打开。
查看当前中断

cat /proc/interrupts

打开中断并设为5

exec 5</dev/key_eint_drv

关闭中断5

exec 5<&-

按键中断驱动

加入休眠，并使用内核提供的中断程序

static DECLARE_WAIT_QUEUE_HEAD(key_eint_drv_waitq);

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


struct pin_desc{
	unsigned int pin;
	unsigned int keyval;
};

struct pin_desc pins_desc[4]={
	{S3C2410_GPF0, 0x01},
	{S3C2410_GPF2, 0x02},
	{S3C2410_GPG3, 0x03},
	{S3C2410_GPG11, 0x04},
};


int buttons_irq(int irq, void *dev_id)
{	
	struct pin_desc *pindesc = (struct pin_desc *)dev_id;
	unsigned int pinval;
	
	pinval = s3c2410_gpio_getpin(pindesc->pin);

	if  (pinval)
	{
		key_val = pindesc->keyval | 0x81;
	}
	else
	{	
		key_val = pindesc->keyval;
	}
    ev_press = 1;                  /* 表示中断发生了 */
    wake_up_interruptible(&key_eint_drv_waitq);   /* 唤醒休眠的进程 */	
	
return 0;
}


ssize_t key_eint_drv_read(struct file *file, char __user *buf, size_t size, loff_t *offset)
{
	int err;

	if (size != sizeof(key_val))
		return -EINVAL;

	wait_event_interruptible(key_eint_drv_waitq, ev_press);
	
	err = copy_to_user(buf, &key_val, sizeof(key_val));	//把数据从kernel_buf读到用户空间
	ev_press = 0;
	
	return sizeof(key_val);
}

int key_eint_drv_open (struct inode *node, struct file *file)
{
	int ret;

	ret = request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "s2", &pins_desc[0]);
	ret = request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "s3", &pins_desc[1]);
	ret = request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "s4", &pins_desc[2]);
	ret = request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "s5", &pins_desc[3]);

	return 0;
}

int key_eint_drv_close(struct inode *node, struct file *file)
{

	free_irq(IRQ_EINT0, &pins_desc[0]);
	free_irq(IRQ_EINT2, &pins_desc[1]);
	free_irq(IRQ_EINT11, &pins_desc[2]);
	free_irq(IRQ_EINT19, &pins_desc[3]);

	
return 0;
}


/* 定义结构体，传参给内核 */
static const struct file_operations key_eint_drv_fo = {
	.owner		= THIS_MODULE,
	.open		= key_eint_drv_open,
	.read		= key_eint_drv_read,
	.release	= key_eint_drv_close, 
};

poll

实现 poll 函数

.poll		= key_poll_drv_poll,

static unsigned key_poll_drv_poll(struct file *file, poll_table *wait)
{
	unsigned int mask = 0;
	poll_wait(file, &key_poll_drv_waitq, wait); // 不会立即休眠

	if (ev_press)
		mask |= POLLIN | POLLRDNORM;	//POLLIN = 0x01,  POLLRDNORM = 0x40

	return mask;
}

在应用程序里加入

struct pollfd fds[1];

fds[0].fd = fd;
fds[0].events = POLLIN;	//输入时唤醒
while(1)
{
	if ( ! poll(fds, 1, 5000) )
	{
		printf("time out, ret = 0 \n");
	
}
	else{
		read(fd, &keyval, 1);
		printf("keyval:0x%x\n", keyval);
	}	
}

异步

定义结构体

static struct fasync_struct *button_async;

实现 fasync 函数

.fasync     = key_async_drv_fasync,

static int key_async_drv_fasync (int fd, struct file *filp, int on)
{
	printk("driver: key_async_drv_fasync\n");
	return fasync_helper (fd, filp, on, &button_async);
}

在 buttons_irq 中断函数中，在唤醒后加入

kill_fasync (&button_async, SIGIO, POLL_IN);	//中断程序发信号

在应用程序里加入

void my_signal_fun(int signum)
{
	unsigned char key_val;
	
	read(fd, &key_val, 1);
	printf("key_val: 0x%x\n", key_val);
}

signal(SIGIO, my_signal_fun);

fcntl(fd, F_SETOWN, getpid());

Oflags = fcntl(fd, F_GETFL); 

fcntl(fd, F_SETFL, Oflags | FASYNC);

同步

定义全局变量

atomic_t canopen = ATOMIC_INIT(1); 	//原子操作

在 open 函数里加入

if ( !atomic_dec_and_test(&canopen) ) //自减操作后测试其是否为0，为0则返回true，否则返回false。为0时执行后面程序
{
	atomic_inc(&canopen);	//原子操作，canopen自加1
	return -EBUSY;

}

在 close 函数里加入

atomic_inc(&canopen); //原子操作，canopen自加1

互斥

定义结构体

static DECLARE_MUTEX(button_lock); //定义互斥锁

在 open 函数里加入

down(&button_lock);

在 close 函数里加入

up(&button_lock);

阻塞与非阻塞

在 open 函数里加入

if (file->f_flags & O_NONBLOCK)
{
	/* 非阻塞 */
	if (down_trylock(&button_lock))
		return -EBUSY;
}
else
{
	/* 获取信号量 */
	down(&button_lock);
}

在 read 函数里加入

if (file->f_flags & O_NONBLOCK)
{
	if (!ev_press)
		return -EAGAIN;
}
else
{
	wait_event_interruptible(key_poll_drv_waitq, ev_press);
}

在应用程序里面改成

fd = open("/dev/buttons", O_RDWR | O_NONBLOCK);

ret = read(fd, &key_val, 1);
printf("key_val: 0x%x, ret = %d\n", key_val, ret);
sleep(5);

定时器防抖

在初始化函数里加上这几句初始化。

	init_timer(&buttons_timer);
	buttons_timer.function = buttons_timer_function; 
	add_timer(&buttons_timer);

改一下按键中断函数，每次按键动作发生，就会启动定时器计算10ms，10ms后再往后进行，这就避免了按键抖动的10ms。

irqreturn_t buttons_irq(int irq, void *dev_id)
{	
	irq_pd = (struct pin_desc *)dev_id;
	mod_timer(&buttons_timer, jiffies+1);

	return IRQ_HANDLED;
		
}

把本来的按键中断函数，改为定时器中断函数，等定时器10ms到了再执行。

void buttons_timer_function(unsigned long data)
{
	struct pin_desc *pindesc = irq_pd;
	unsigned int pinval;
	
	pinval = s3c2410_gpio_getpin(pindesc->pin);

	if  (pinval)
	{
		key_val = pindesc->keyval | 0x80;
	}
	else
	{	
		key_val = pindesc->keyval;
	}
    ev_press = 1;                  /* 表示中断发生了 */
    wake_up_interruptible(&key_poll_drv_waitq);   /* 唤醒休眠的进程 */	

	kill_fasync (&button_async, SIGIO, POLL_IN);	//中断程序发信号

}