Linux 设备驱动--- 中断处理

中断的概念：

为什么需要中断：

1，外设的处理速度一般慢于 CPU；

2，CPU 不能一直等待外部事件；

所以设备必须有一种方法来 通知 CPU 它 的工作进度，这种方法就是中断.

中断的实现：

在 Linux 驱动程序中，为设备实现一个中断包含两个步骤：

1，向内核注册中断；

2，实现中断处理函数；

中断注册 request_irq ：

request_irq 用于实现中断的注册功能：

函数：

int request_irq ( unsigned int irq , void (*handler) (int , void *, struct pt_regs *),
unsigned long flags , const char * devname, void * dev_id )

参数：

unsigned int irq ：申请的硬件中断号；

void (*handler) (int , void *, struct pt_regs *) ：函数指针 handler ，向系统登记中断处理函数，是个回掉函数；

const char * devname ：指定设备驱动程序的名称；

void * dev_id ：传入中断处理程序的参数，可为 NULL ，也可用来指定中断服务函数需要参考的数据地址；共享中断时使用；

unsigned long flags ：(指定了 快速中断 或者
慢速中断 或者 中断共享 等中断处理属性，上升沿，下降沿等；)

在 flags 参数中，可以选择一些与中断管理有关的选项，

如：

IRQF_DISABLED (SA_INTERRUPT)

如果设置该位，表示是一个“快速”中断处理程序，如果没有设置该位，那么是一个“慢速”中断处理程序；

IRQF_SHARED (SA_SHIRQ)

该位表明中断可以在设备间共享.

返回值：

为 0 表示 成功；

快速 / 慢速中断：

区别在于：快速中断保证中断处理的
原子性(不被打断)，而慢速中断则不保证；

也就是“ 开启中断 ”标志位(处理器IF)在运行 快速中断处理程序是关闭的，因此在服务该中断时，不会被其他类型的中断打断，

而调用慢速中断处理时，其他类型的中断仍可以得到服务;

慢速中断可以中断嵌套，快速中断不可以.

共享中断：

共享中断 就是将不同的设备挂到同一个中断信号线上，Linux 对共享的支持主要是为 PCI 设备服务;

共享中断处理程序 相同的中断号， 所以需要来提供一个唯一的标志来区分到底是哪个中断;

共享中断注册 3 个特别之处：

也是通过 request_irq 函数来注册的，但是有三个特别之处：

1，申请共享中断时候，必须在 flags 参数中指定 IRQF_SHARED 位；

2，dev_id 参数必须是唯一的；

3，共享中断的处理程序中，不能使用 disable_irq ( unsigned int irq) ,

如果使用了这个函数，共享中断信号线的其他设备将同样无法使用中断，也就是无法正常工作.

中断处理程序 handler ：

void (*handler) (int , void *, struct pt_regs *) ：

handler 例子：

static irqreturn_t irq_interrupt(int irq, void *dev_id)
{
struct button_irq_desc *button_irqs = (struct button_irq_desc *)dev_id;
int down;

down = !s3c2410_gpio_getpin(button_irqs->pin);

if (down != (key_values[button_irqs->number] & 1))
{
key_values[button_irqs->number] = '0' + down;
ev_press = 1;
wake_up_interruptible(&button_waitq);
}

return IRQ_RETVAL(IRQ_HANDLED);
}

函数中 void *dev_id 参数是从 request_irq 函数里的第五个参数 void * dev_id ；

err = request_irq(button_irqs[i].irq, irq_interrupt, IRQ_TYPE_EDGE_BOTH, button_irqs[i].name, (void *)&button_irqs[i]);

struct button_irq_desc {
int irq;
int pin;
int pin_setting;
int number;
char *name;
};

static struct button_irq_desc button_irqs [] = {
{IRQ_EINT1,	S3C2410_GPF1,	S3C2410_GPF1_EINT1,	0, "KEY1"}, /* K1 */
{IRQ_EINT4,	S3C2410_GPF4,	S3C2410_GPF4_EINT4,	1, "KEY2"}, /* K2 */
{IRQ_EINT2,	S3C2410_GPF2,	S3C2410_GPF2_EINT2,	2, "KEY3"}, /* K3 */
{IRQ_EINT0,	S3C2410_GPF0,	S3C2410_GPF0_EINT0,	3, "KEY4"}, /* K4 */
};

中断处理程序 特点：

中断处理程序是普通的 C 代码，特别之处在于中断处理程序是在中断上下文 运行的，它的行为受到某些限制：

1，不能向用户空间发送或接收数据；

2，不能使用可能引起阻塞的函数；

3，不能使用可能引起调度的函数；

中断处理函数流程：

(共享中断判断具体是哪个中断)

inb 从I/O端口读取一个字节(BYTE, HALF-WORD) ;
outb 向I/O端口写入一个字节（BYTE, HALF-WORD） ;
inw 从I/O端口读取一个字（WORD，即两个字节） ;
outw 向I/O端口写入一个字（WORD，即两个字节） ;

释放中断 free_irq ：

当设备不再需要使用中断时( 通常在驱动卸载时 )，应当把它们返回给系统，
使用：
void free_irq ( unsigned int irq ,void *dev_id )

实例程序：

/*************************************

NAME:EmbedSky_hello.c
COPYRIGHT:www.embedsky.net

*************************************/

#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/irq.h>
#include <asm/irq.h>
#include <linux/interrupt.h>
#include <asm/uaccess.h>
#include <mach/regs-gpio.h>
#include <mach/hardware.h>
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>

#define DEVICE_NAME     "IRQ-Test"

struct button_irq_desc {
int irq;
int pin;
int pin_setting;
int number;
char *name;
};
/*
err = request_irq(button_irqs[i].irq, irq_interrupt, IRQ_TYPE_EDGE_BOTH,
button_irqs[i].name, (void *)&button_irqs[i]);
*/
#if !defined (CONFIG_SKY2440_IRQ_TEST)
static struct button_irq_desc button_irqs [] = {
{IRQ_EINT1,	S3C2410_GPF1,	S3C2410_GPF1_EINT1,	0, "KEY1"}, /* K1 */
{IRQ_EINT4,	S3C2410_GPF4,	S3C2410_GPF4_EINT4,	1, "KEY2"}, /* K2 */
{IRQ_EINT2,	S3C2410_GPF2,	S3C2410_GPF2_EINT2,	2, "KEY3"}, /* K3 */
{IRQ_EINT0,	S3C2410_GPF0,	S3C2410_GPF0_EINT0,	3, "KEY4"}, /* K4 */
};
#else
static struct button_irq_desc button_irqs [] = {
{IRQ_EINT9,	S3C2410_GPG1,	S3C2410_GPG1_EINT9,	0, "KEY1"}, /* K1 */
{IRQ_EINT11,	S3C2410_GPG3,	S3C2410_GPG3_EINT11,	1, "KEY2"}, /* K2 */
{IRQ_EINT2,	S3C2410_GPF2,	S3C2410_GPF2_EINT2,	2, "KEY3"}, /* K3 */
{IRQ_EINT0,	S3C2410_GPF0,	S3C2410_GPF0_EINT0,	3, "KEY4"}, /* K4 */
};
#endif
static volatile char key_values [] = {'0', '0', '0', '0'};

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

static volatile int ev_press = 0;

static irqreturn_t irq_interrupt(int irq, void *dev_id)
{
struct button_irq_desc *button_irqs = (struct button_irq_desc *)dev_id;
int down;

down = !s3c2410_gpio_getpin(button_irqs->pin);

if (down != (key_values[button_irqs->number] & 1))
{
key_values[button_irqs->number] = '0' + down;
ev_press = 1;
wake_up_interruptible(&button_waitq);
}

return IRQ_RETVAL(IRQ_HANDLED);
}

static int tq2440_irq_open(struct inode *inode, struct file *file)
{
int i;
int err = 0;

for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++)
{
if (button_irqs[i].irq < 0)
continue;
err = request_irq(button_irqs[i].irq, irq_interrupt, IRQ_TYPE_EDGE_BOTH,
button_irqs[i].name, (void *)&button_irqs[i]);
if (err)
break;
}

if (err)
{
i--;
for (; i >= 0; i--)
{
if (button_irqs[i].irq < 0)
continue;
disable_irq(button_irqs[i].irq);
free_irq(button_irqs[i].irq, (void *)&button_irqs[i]);
}
return -EBUSY;
}

ev_press = 1;

return 0;
}

static int tq2440_irq_close(struct inode *inode, struct file *file)
{
int i;

for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++)
{
if (button_irqs[i].irq < 0)
continue;
free_irq(button_irqs[i].irq, (void *)&button_irqs[i]);
}

return 0;
}

static int tq2440_irq_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(buff, (const void *)key_values, min(sizeof(key_values), count));

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

static unsigned int tq2440_irq_poll( struct file *file, struct poll_table_struct *wait)
{
unsigned int mask = 0;
poll_wait(file, &button_waitq, wait);
if (ev_press)
mask |= POLLIN | POLLRDNORM;
return mask;
}

static struct file_operations dev_fops = {
.owner	=   THIS_MODULE,
.open	=   tq2440_irq_open,
.release	=   tq2440_irq_close,
.read	=   tq2440_irq_read,
.poll	=   tq2440_irq_poll,
};

static struct miscdevice misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = DEVICE_NAME,
.fops = &dev_fops,
};

static int __init dev_init(void)
{
int ret;

ret = misc_register(&misc);

printk (DEVICE_NAME" initialized\n");

return ret;
}

static void __exit dev_exit(void)
{
misc_deregister(&misc);
}

module_init(dev_init);
module_exit(dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("www.embedsky.net");
MODULE_DESCRIPTION("IRQ Test for EmbedSky SKY2440/TQ2440 Board");