字符设备驱动程序之按键——中断机制

要想用中断方式编写应用程序，首先需要理解中断的流程。之前我们分析过中断流程的，现在再来分析一边，以便加深印象。

内核在start_kernel函数中调用trap_init、init_IRQ两个函数来设置异常的处理函数，首先我们想来看看trap_init函数，部分代码如下：

void __init trap_init(void)

{

.......................................................

memcpy((void *)vectors, __vectors_start, __vectors_end - __vectors_start);

memcpy((void *)vectors + 0x200, __stubs_start, __stubs_end - __stubs_start);

.......................................................

}

分析：ARM构架CPU的异常向量基址可以是0x00000000，也可以是0xffff0000，linux内核使用后者。而trap_init函数就是用于将异常向量拷贝到0xffff0000处。上面的代码里，vectors为0xffff0000，__vectors_start和__vector_end之间存放的就是异常向量，他们被拷贝到地址 0xffff0000处， 但那只是一些简单的跳转指令，更加复杂的指令存放在__stubs_start和__stubs_end之间，他们被拷贝到 0xffff0000+200处。

下面我们把目光转到 __vectors_start处(arch/arm/kernel文件里)，看一下代码：

__vectors_start:

swi SYS_ERROR0

b vector_und + stubs_offset

ldr pc, .LCvswi + stubs_offset

b vector_pabt + stubs_offset

b vector_dabt + stubs_offset

b vector_addrexcptn + stubs_offset

b vector_irq + stubs_offset

b vector_fiq + stubs_offset

.globl __vectors_end

__vectors_end: 

其中：.equ stubs_offset, __vectors_start + 0x200 - __stubs_start

分析：当相应的某个异常发生的时候，他会根据上面对应的异常向量跳转指令跳转到相应的位置进行处理。以b vector_irq + stubs_offset为例，当发生中断时，会执行它，然后跳转到vector_irq处（sut bs_offset用于从定位跳转的位置，暂时忽略也没有关系 ），可是我们搜遍代码页没有发现vector_irq这个标号。不过我们发现了如下代码：

vector_stub irq, IRQ_MODE, 4

经分析我们发现这是一条宏定义，相关代码如下：

.macro vector_stub, name, mode, correction=0   @ vector_stub irq, IRQ_MODE, 4

.align 5

vector_\name:                                                                    @ vector_irq

.if \correction

sub lr, lr, #\correction

.endif

stmia sp, {r0, lr} @ save r0, lr

mrs lr, spsr

str lr, [sp, #8] @ save spsr

mrs r0, cpsr

eor r0, r0, #(\mode ^ SVC_MODE)

msr spsr_cxsf, r0

and lr, lr, #0x0f

mov r0, sp

ldr lr, [pc, lr, lsl #2]

movs pc, lr @ branch to handler in SVC mode

.endm

我们进行一下置换就得到了： vector_irq这个标号，其中最后一段代码是跳转指令，用于跳转到具体的中断入口。我们可以看看这个标号下面的内容：

vector_irq:

.long __irq_usr @  0  (USR_26 / USR_32)

.long __irq_invalid @  1  (FIQ_26 / FIQ_32)

.long __irq_invalid @  2  (IRQ_26 / IRQ_32)

.long __irq_svc @  3  (SVC_26 / SVC_32)

.long __irq_invalid @  4

.long __irq_invalid @  5

.long __irq_invalid @  6

.long __irq_invalid @  7

.long __irq_invalid @  8

.long __irq_invalid @  9

.long __irq_invalid @  a

.long __irq_invalid @  b

.long __irq_invalid @  c

.long __irq_invalid @  d

.long __irq_invalid @  e

.long __irq_invalid @  f

我们以.long __irq_usr为例进一步分析：

我们找到__irq_usr 这个标号，看一下其下面的代码：

__irq_usr:

usr_entry  @ 保存寄存器

................................................................................

irq_handler@ 这也是一个宏，它会最终调用函数asm_do_IRQ，这是个c函数

...............................................................................

接下来是c语言了，我们列出主要框架：

asm_do_IRQ

struct irq_desc *desc = irq_desc + irq; //以中断号为下标得到中断描述结构体数组中的一项

desc_handle_irq(irq, desc); //进入中断处理

desc->handle_irq(irq, desc); //要想知道这个函数是怎么回事，我们可以反推回去，不过为了便于分析，我们采取正叙的方法

void __init s3c24xx_init_irq(void)//初始化中断

set_irq_chip(irqno, &s3c_irqext_chip);

desc = irq_desc + irq;

desc->chip = chip; //设置一些底层硬件操作函数

  set_irq_handler(irqno, handle_edge_irq); 

__set_irq_handler(irq, handle, 0, NULL);

desc = irq_desc + irq;

desc->handle_irq = handle;

到这一步我们将desc->handle_irq=handle_edge_irq，在结合上面的desc->handle_irq(irq, desc)，我们知道上面就是执行handle_edge_irq这条指令，那么handle_edge_irq有做了什么呢？我们接着看代码，搭建框架：

handle_edge_irq

handle_IRQ_event(irq, action);

do {

ret = action->handler(irq, action->dev_id); //这就是中断处理函数

action = action->next; //这是中断链表

} while (action);

由此我们看出发生中断后会跳转到入口函数 asm_do_IRQ，之后会根据中断号找到中断处理函数来执行。关于上面提到的三个结构体，我们还要在来分析一下：

struct irq_desc {

irq_flow_handler_t handle_irq; //当前中断的处理入口函数，我们会将中断处理函数赋给它

struct irq_chip *chip; //底层的硬件访问

.................................

struct irqaction *action; //中断处理函数列表

unsigned int status; //中断状态

................................

const char *name; //中断名称

} 

struct irq_chip {

const char *name;

unsigned int (*startup)(unsigned int irq); //启动中断，默认是enable

void (*shutdown)(unsigned int irq); //关闭中断，默认是disable

void (*enable)(unsigned int irq); //使能中断，默认是unmask

void (*disable)(unsigned int irq);/ /禁止中断，默认是mask

void (*ack)(unsigned int irq); //响应中断，通常是清除当前中断使得可以接收下一个中断

void (*mask)(unsigned int irq); //屏蔽中断源

void (*mask_ack)(unsigned int irq); //屏蔽和响应中断

void (*unmask)(unsigned int irq); //开启中断

..................................................

};

struct irqaction {

irq_handler_t handler; //用户注册的中断处理函数

unsigned long flags; //中断标志

cpumask_t mask; //用于SMP(对称多处理器系统)

const char *name; //用户注册的中断名称

void *dev_id; //用户上面传过来的handler参数，还可以用来区分共享中断

struct irqaction *next;

int irq;                 //中断号

struct proc_dir_entry *dir;

};

通过上面的分析我们知道了中断发生后最终调用到desc->action->handler，于是我们就知道注册中断的话必须根据中断号将中断处理函数赋给

desc->action->handler，那么到底是不是呢？我们来查看代码：

以一个中断注册函数为例：

request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);

action->handler = handler; //中断处理函数放在这里了

retval = setup_irq(irq, action); //设置中断

struct irq_desc *desc = irq_desc + irq; //以中断号为下标构造中断描述结构体数组中的一项，发生中断的时候我们会根据中断号取出相应 //的结构体

到此为止，中断的大体流程我们就分析明白了，下面我们就以中断方式来编写按键驱动，请看代码：

驱动程序代码如下：

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/fs.h>

#include <linux/init.h>

#include <linux/irq.h>

#include <linux/delay.h>

#include <asm/uaccess.h>

#include <asm/irq.h>

#include <asm/io.h>

#include <asm/arch/regs-gpio.h>

#include <asm/hardware.h>

#define DEVICE_NAME "keys"

volatile unsigned long *gpfcon=NULL;

volatile unsigned long *gpfdat=NULL;

volatile unsigned long *gpgcon=NULL;

volatile unsigned long *gpgdat=NULL;

static struct class *keys_class;

static struct class_device *keys_class_devs;

struct pin_desc{

unsigned int pin;

unsigned int key_val;

};

static unsigned char key_val;

struct pin_desc pins_desc[4] = {

{S3C2410_GPF0, 0x01},

{S3C2410_GPF2, 0x02},

{S3C2410_GPG3, 0x03},

{S3C2410_GPG11, 0x04},

};

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

static volatile int ev_press = 0;

static irqreturn_t 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 = 0x80 | pindesc->key_val;

}

else

{

key_val = pindesc->key_val;

}

    ev_press=1;

    wake_up_interruptible(&button_waitq); 

    return IRQ_RETVAL(IRQ_HANDLED);

}

static int s3c24xx_keys_open(struct inode *inode, struct file *file)

{

    request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2",&pins_desc[0]);

    request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3",&pins_desc[1]);

    request_irq(IRQ_EINT11,buttons_irq, IRQT_BOTHEDGE, "S4",&pins_desc[2]);

    request_irq(IRQ_EINT19,buttons_irq, IRQT_BOTHEDGE, "S5",&pins_desc[3]);

    return 0;

}

static int s3c24xx_keys_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)

{

wait_event_interruptible(button_waitq, ev_press);

       copy_to_user(buff, &key_val, 1);

        ev_press=0;

        return 1;

}

int s3c24xx_keys_close(struct inode *inode, 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 struct file_operations s3c24xx_keys_fops = {

    .owner  =   THIS_MODULE,   

    .open   =   s3c24xx_keys_open,     

    .read = s3c24xx_keys_read,   

    .release = s3c24xx_keys_close,

};

int major;

static int __init s3c24xx_keys_init(void)

{

    major=register_chrdev(0, DEVICE_NAME, &s3c24xx_keys_fops);//auto distribute major

    keys_class = class_create(THIS_MODULE, "keys_class");

    keys_class_devs = class_device_create(keys_class, NULL, MKDEV(major, 0), NULL, "keys");

    gpfcon=(volatile unsigned long *)ioremap(0x56000050,16);

    gpfdat=gpfcon+1;

    gpgcon=(volatile unsigned long *)ioremap(0x56000060,16);

    gpgdat=gpgcon+1;

     printk(DEVICE_NAME " initialized\n");

     return 0;

}

static void __exit s3c24xx_keys_exit(void)

{

    unregister_chrdev(major, DEVICE_NAME);

    class_device_unregister(keys_class_devs);

    class_destroy(keys_class);

    iounmap(gpfcon);

    iounmap(gpgcon);

}

module_init(s3c24xx_keys_init);

module_exit(s3c24xx_keys_exit);

MODULE_LICENSE("GPL");

测试程序代码如下：

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdio.h>

int main(int argc, char **argv)

{

int fd;

unsigned char key_val;

fd = open("/dev/keys", O_RDWR);

if (fd < 0)

{

printf("can't open!\n");

}

while (1)

{

read(fd, &key_val, 1);

printf("key_val = 0x%x\n", key_val);

}

return 0;

}

关于这个程序我们简单讲解一下它的功能：当没有按键按下的时候，会进入休眠，当有按键按下的时候，会进入中断服务程序，在中断服务程序里把进程唤醒。这样的话就不会老是查询，以致cpu占用过多。

有几个小知识点要讲解一下：

（1） DECLARE_WAIT_QUEUE_HEAD(button_waitq)，用于定义一个等待队列

（2）wait_event_interruptible(button_waitq, ev_press)：当ev_press为0时将当前进程加入等待队列button_waitq中，进入休眠，否则不休眠

（3）wake_up_interruptible(&button_waitq)：唤醒等待队列button_waitq中的成员

（4） s3c2410_gpio_getpin(pindesc->pin)：获取引脚状态

（5）命令行：./keytest &   ：表示在后台运行keytest程序

（6）命令行：kill -9 xxx     ：表示强制杀死进程号为xxx的进程