这节，我们继续上，中(以前的日志有)篇目进行分析，结合一个真实的驱动案例来描述linux内核中驱动的中断机制，首先我们先了解一下linux内核中提供的中断接口。

     这个接口我们需要包含一个头文件:#include <linux/interrupt.h>

     在中断接口中，最重要的是以下的接口函数:

1、这个是请求中断函数

int request_irq(unsigned int irq, irq_handler_t handler, 
		unsigned long irqflags, const char *devname, void *dev_id)

	irq:
		中断号 arch/arm/plat-s3c64xx/include/plat/irqs.h

	handler:
		中断处理函数 irqreturn_t handler(int irq, void *dev_id);
		irqreturn_t:
			See include/linux/irqreturn.h

	irqflags:
		See line 21-59 in include/linux/interrupt.h
		使用IRQF_SHARED共享irq时, irqflags必须相同
		如:  	request_irq(IRQ_EINT(0), handler1, 
				IRQF_TRIGGER_FALLING | IRQF_SHARED, "dev1", &dev1);

			request_irq(IRQ_EINT(0), handler2, 
				IRQF_TRIGGER_FALLING | IRQF_SHARED, "dev2", &dev2);

	devname:
		设备名, cat /proc/interrupts

	dev_id:
		发生中断时将dev_id传递给handler函数,
	       	irqflags含有IRQF_SHARED时dev_id不能为NULL, 并且要保证唯一
		dev_id一般采用当前设备的结构体指针

2、释放中断

void free_irq (	unsigned int irq, void * dev_id);
	释放匹配irq和dev_id的中断, 如果irq有多个相同的dev_id, 将释放第一个
	So, 共享中断的dev_id不是唯一时, 可能会释放到其它设备的中断

3、开启中断

void enable_irq(unsigned int irq);
	开启irq号中断	

4、关闭中断

void disable_irq(unsigned int irq);
	关闭irq号中断

5、关闭当前CPU中断并保存在flag中去

void local_irq_save(unsigned long flags);

6、恢复flag到CPU中去

void local_irq_restore(unsigned long flags);
	恢复flags到当前CPU

7、关闭当前的CPU中断

void local_irq_disable(void);

8、开始当前的CPU中断

void local_irq_enable(void);

接下来我们来看一个按键中断的例子，这个例子是基于Tiny4412按键驱动的源码:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <asm/uaccess.h>
#include <mach/hardware.h>
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#include <linux/gpio.h>

#include <mach/map.h>
#include <mach/gpio.h>
#include <mach/regs-clock.h>
#include <mach/regs-gpio.h>

//设备名称
#define DEVICE_NAME		"buttons"

struct button_desc {
	int gpio;
	int number;
	char *name;	
	struct timer_list timer;
};

//定义按键相关的寄存器
static struct button_desc buttons[] = {
	{ EXYNOS4_GPX3(2), 0, "KEY0" },
	{ EXYNOS4_GPX3(3), 1, "KEY1" },
	{ EXYNOS4_GPX3(4), 2, "KEY2" },
	{ EXYNOS4_GPX3(5), 3, "KEY3" },
};

//存储按键的键值
static volatile char key_values[] = {
	'0', '0', '0', '0', '0', '0', '0', '0'
};

//创建一个等待队列头并初始化
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

static volatile int ev_press = 0;

//按键定时器
static void tiny4412_buttons_timer(unsigned long _data)
{
	struct button_desc *bdata = (struct button_desc *)_data;
	int down;
	int number;
	unsigned tmp;
	//获取按键的值
	tmp = gpio_get_value(bdata->gpio);
	//判断是否为低电平
	down = !tmp;
	printk(KERN_DEBUG "KEY %d: %08x\n", bdata->number, down);

	number = bdata->number;
	//如果此时不为低电平，中断处理进入休眠状态，一般有事件产生就会立即被唤醒
	if (down != (key_values[number] & 1)) {
		key_values[number] = '0' + down;

		ev_press = 1;
		//中断休眠
		wake_up_interruptible(&button_waitq);
	}
}
//按键中断处理函数
//irq：中断号
//dev_id:设备ID号
static irqreturn_t button_interrupt(int irq, void *dev_id)
{
	struct button_desc *bdata = (struct button_desc *)dev_id;
	//注册一个定时器
	mod_timer(&bdata->timer, jiffies + msecs_to_jiffies(40));
	//返回一个中断句柄
	return IRQ_HANDLED; 
}
//按键打开函数
//inode : 节点
//file : 打开文件的形式
static int tiny4412_buttons_open(struct inode *inode, struct file *file)
{
	int irq;
	int i;
	int err = 0;
	//循环遍历四个IO口，看看有哪个按键被按下了
	for (i = 0; i < ARRAY_SIZE(buttons); i++) {
		if (!buttons[i].gpio)
			continue;
		//初始化定时器
		setup_timer(&buttons[i].timer, tiny4412_buttons_timer,
				(unsigned long)&buttons[i]);
		//设置GPIO为中断引脚，也就是对应那四个按键
		irq = gpio_to_irq(buttons[i].gpio);
		err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_BOTH,  //请求中断处理函数
				buttons[i].name, (void *)&buttons[i]);
		if (err)
			break;
	}

	if (err) {
		i--;
		for (; i >= 0; i--) {
			if (!buttons[i].gpio)
				continue;

			irq = gpio_to_irq(buttons[i].gpio);
			disable_irq(irq); //关中断
			free_irq(irq, (void *)&buttons[i]);//释放中断

			del_timer_sync(&buttons[i].timer);//删除一个定时器
		}

		return -EBUSY;
	}

	ev_press = 1;
	return 0;
}
//按键关闭处理函数
static int tiny4412_buttons_close(struct inode *inode, struct file *file)
{
	int irq, i;

	for (i = 0; i < ARRAY_SIZE(buttons); i++) {
		if (!buttons[i].gpio)
			continue;
		//同样的，这里也是释放
		irq = gpio_to_irq(buttons[i].gpio);
		free_irq(irq, (void *)&buttons[i]);
<span style="white-space:pre">		</span>//删除一个定时器
		del_timer_sync(&buttons[i].timer);
	}

	return 0;
}
//读取按键的键值函数
static int tiny4412_buttons_read(struct file *filp, char __user *buff,
		size_t count, loff_t *offp)
{
	unsigned long err;

	if (!ev_press) {
		if (filp->f_flags & O_NONBLOCK)
			return -EAGAIN;
		else	//等待中断的事件产生
			wait_event_interruptible(button_waitq, ev_press);
	}

	ev_press = 0;
	//将获取到的键值返回到用户空间
	err = copy_to_user((void *)buff, (const void *)(&key_values),
			min(sizeof(key_values), count));

	return err ? -EFAULT : min(sizeof(key_values), count);
}

//按键非阻塞型接口设计
static unsigned int tiny4412_buttons_poll( struct file *file,
		struct poll_table_struct *wait)
{
	unsigned int mask = 0;
<span style="white-space:pre">	</span>//非阻塞型等待
	poll_wait(file, &button_waitq, wait);
	if (ev_press)
		mask |= POLLIN | POLLRDNORM;

	return mask;
}

//驱动文件操作结构体成员初始化
static struct file_operations dev_fops = {
	.owner		= THIS_MODULE,
	.open		= tiny4412_buttons_open,
	.release	= tiny4412_buttons_close, 
	.read		= tiny4412_buttons_read,
	.poll		= tiny4412_buttons_poll,
};
//注册杂类设备的结构体成员初始化
static struct miscdevice misc = {
	.minor		= MISC_DYNAMIC_MINOR,
	.name		= DEVICE_NAME,
	.fops		= &dev_fops, //这里就是把上面那个文件操作结构体的成员注册到杂类操作这里
};
//按键驱动初始化
static int __init button_dev_init(void)
{
	int ret;
	//先注册一个杂类设备
	//这相当于让misc去管理open ,read,write,close这些接口
	ret = misc_register(&misc);
	//
	printk(DEVICE_NAME"\tinitialized\n");

	return ret;
}
//按键驱动注销
static void __exit button_dev_exit(void)
{
	//注销一个杂类设备驱动
	misc_deregister(&misc);
}

module_init(button_dev_init);
module_exit(button_dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Yang.yuanxin");

运行结果: