自己补充:

   #define IRQF_TRIGGER_NONE 0x00000000   //这个宏定义的触发标志自己通过dma实验觉得指的是 软件触发 的中断类型中使用的,区别于 上升沿 下降沿, 高低电平触发.

 

 1.中断的实现:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

一、什么是中断

 

中断分两种:

1)中断,又叫外部中断或异步中断,它的产生是由于外设向处理器发出中断请求。其中外部中断也有两种,这是由配置寄存器设定的:普通中断请求(IRQ)和快速中断请求(FIQ)。一般地,linux下很少使用快速中断请求。

2)异常,又叫内部中断或同步中断,它的产生是由于处理器执行指令出错。

在以下的内容我是要介绍由于外部设备产生的中断。

 

这里我还有两个名词要说清楚

1)中断请求线:在后面也叫中断号,每个中断都会通过一个唯一的数值来标识,而这个值就称做中断请求线

2)在2440芯片中,有些中断是需要共享一个中断寄存器中的一位,如EINT4——EINT7,它们是共享寄存器SRCPEND的第4位。具体可以查看芯片手册。

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

二、什么是中断处理函数

 

在相应一个中断是,内核会执行该信号对应的一个函数,该函数就叫做该中断对应的中断处理函数。一般来说,中断的优先级是最高的,一但接收到中断,内核就会调用对应的中断处理函数。

中断处理函数运行在中断上下文中。中断上下文与内核上下文有一点区别:

内核上下文是指应用层调用系统调用陷入内核执行,内核代表陷入的进程执行操作。函数中可以通过current查看当前进程(即应用层的进程)的信息,并且可以睡眠。

中断上下文中,不能通过current查看调用它的应用层进程的信息,同时,处于中断上下文时,不能睡眠。

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

一、从硬件角度看中断

 

中断的产生到处理器获得中断这段过程中,还要通过中断处理器来筛选信号。

 

先温习一下S3C2440芯片手册的知识:中断是如何产生的,中断处理器本身如何处理中断。先看一下一幅经典的图,这是介绍中断控制器的工作流程:

 

中 断_中断处理

从硬件上的分类,有两种不同的中断类型:

1)自己占有SORCPND寄存器的一位(without sub-register)。

2)几个中断共同享用SRCPND寄存器的一位(with sub-register)。

 

其实两种都差不多,只是多了两步的检测。我以自己占用一位的中断来举例,如EINT1,在我的开发板,EINT1上接了一个按键。

1)当我按下按键产生电平变化,传到S3C2440的中断控制器上(即将要进入上面图的流程图)。

2)首先,信号要经过寄存器SRCPND,SRCPND是用来配置当前的处理器要接收什么中断,如果该寄存器配置成接收EINT1中断(对应位置一),则允许继续下一步。

3)然后,信号经过寄存器MASK,这是用来设置当前系统需要屏蔽的中断。注意,这里的屏蔽跟上一个寄存器的不接收中断是不一样的。这里的屏蔽是指,中断是接受了,但是由于某种原因,先暂时不屏蔽产生的中断。

4)通过INTPND寄存器,查看当前是否有相同的中断已经被请求(如果是,INTPND对应位置一)。

5)如果没有相同的中断在请求,中断处理器才会把这个信号传给处理器,这时处理器才会知道有EINT0的中断真正来了,要对信号进行处理了。

注:如果设定了EINT0是快速中断模式(FIQ),中断通过SRCPND寄存器后就会通过MODE寄存器的判断,确定是FIQ后,中断控制器优先将该中断传给CPU处理。

6)对应传来的中断类型(IRQ或FIQ),通过CPSR寄存器切换到对应的工作模式(ARM有七种工作模式)。

7)切换工作模式后,进入指定的中断处理入口执行中断处理函数。

注意:第6、7步在linux下的实现相对复杂,不像在裸板程序,只需要切换一下工作模式,执行相应的函数就可以了。迟点会介绍linux如何实现。

 

来个流程图比较只在,同时来个类比,处理器是老板,中断处理器是小秘:

 

中 断_#define_02

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

四、注册和释放中断处理函数

 

上面的介绍只是讲解了一个设备产生中断后要经过怎么样的步骤才能让处理器接收到中断信号。传入处理器后,接下来的工作就是由内核来实现了,那是一个复杂的机制,我们这里先不说。但是,内核提供了相关的接口给我们,我们只要通过接口告诉内核,当来了指定中断时,内核你该执行哪个中断处理函数。

 

注册中断处理函数:

/*include */

int request_irq(unsigned int irq, irq_handler_t handler,

unsigned long irqflags, const char *devname, void *dev_id)

使用:

将中断号irq与中断处理函数handler对应

参数:

irq:指定要分配的中断号,中断号的定义在“include/mach/irqs.h”中。注意,不管是单独占有中断请求线的中断,还是共享中断请求线的每个中断,都有一个对应的中断号。,所以,调用该函数不需要考虑是哪种中断(是否共享寄存器),你想哪种中断响应,你就填对应的中断号。

handler:中断处理函数指针。

irqflags:中断处理标记,待会介绍:

devname:该字符串将显示在/proc/irq和/pro/interrupt中。

dev_id:ID 号,待会会介绍。

返回值:成功返回0,失败返回非0。

注册函数需要注意两件事:

1)该函数会睡眠。

2)必须判断返回值。

 

中断处理标志irqflags,这里先介绍几个待会要用的:

/*linux-2.6.29/include/linux/interrupt.h*/

29 #define IRQF_TRIGGER_NONE 0x00000000

30 #define IRQF_TRIGGER_RISING 0x00000001 //上升沿触发中断

31 #define IRQF_TRIGGER_FALLING 0x00000002 //下降沿触发中断

32 #define IRQF_TRIGGER_HIGH 0x00000004 //高电平触发中断

33 #define IRQF_TRIGGER_LOW 0x00000008 //低电平触发中断

34 #define IRQF_TRIGGER_MASK (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW | \

35 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)

36 #define IRQF_TRIGGER_PROBE 0x00000010

 

释放中断处理函数:

void free_irq(unsigned int irq, void *dev_id)

 

编写中断处理函数:

中断处理函数声明如下:

static irqreturn_t intr_handler(int irq, void *dev_id)

先看第一个参数irq,这是调用中断处理函数时传给它的中断号,对于新版本的内核,这个参数已经用处不大,一般只用于打印。

第二个参数dev_id,这个参数与request_irq()的参数dev_id一致,由于待会的程序我并不需要用这个参数,所以先不介绍。

再看返回值,中断处理函数的返回值有三个:

/*linux-2.6.29/include/linux/interrupt..h*/

21 #define IRQ_NONE (0) //如果产生的中断并不会执行该中断处理函数时返回该值

22 #define IRQ_HANDLED (1) //中断处理函数正确调用会返回

23 #define IRQ_RETVAL(x) ((x) != 0) //指定返回的数值,如果非0,返回IRQ_HADLER,否则

26 #ifndef IRQ_NONE //返回IRQ_NONE。

 

接下来就要写函数了,在我的开发板中,有一个按键是对应EINT1,我要实现的操作是,当我按下按键,终端打印”key down”。在这个程序中,我并没有使用dev_id。这将在会以后的章节介绍。

/*6th_irq_1/1st/test.c*/

1 #include

2 #include

3

4 #include

5

。。。省略。。。

13 irqreturn_t irq_handler(int irqno, void *dev_id) //中断处理函数

14 {

15 printk("key down\n");

16 return IRQ_HANDLED;

17 }

18

19 static int __init test_init(void) //模块初始化函数

20 {

21 int ret;

22

23 /*注册中断处理函数,必须查看返回值

24 * IRQ_EINT1:中断号,定义在"include/mach/irqs.h"中

25 * irq_handler:中断处理函数

26 * IRQ_TIRGGER_FALLING:中断类型标记,下降沿触发中断

27 * ker_INT_EINT1:中断的名字,显示在/proc/interrupts等文件中

28 * NULL;现在我不使用dev_id,所以这里不传参数

29 */

30 ret = request_irq(IRQ_EINT1, irq_handler, IRQF_TRIGGER_FALLING,

31 "key INT_EINT1", NULL);

32 if(ret){

33 P_DEBUG("request irq failed!\n");

34 return -1;

35 }

36 printk("hello irq\n");

37 return 0;

38 }

39

40 static void __exit test_exit(void) //模块卸载函数

41 {

42 free_irq(IRQ_EINT1, NULL);

43 printk("good bye irq\n");

44 }

45

46 module_init(test_init);

47 module_exit(test_exit);

48

49 MODULE_LICENSE("GPL");

50 MODULE_AUTHOR("xoao bai");

51 MODULE_VERSION("v0.1");

接下来验证一下:

[root: 1st]# insmod test.ko

hello irq

[root: 1st]# key down //按下按键显示

key down

key down

key down

[root: 1st]# cat /proc/interrupts

CPU0

17: 11 s3c-ext0 key INT_EINT1 显示我注册和中断名字

30: 423482 s3c S3C2410 Timer Tick

32: 0 s3c s3c2410-lcd

51: 2782 s3c-ext eth0

70: 49 s3c-uart0 s3c2440-uart

71: 69 s3c-uart0 s3c2440-uart

79: 0 s3c-adc s3c2410_action

80: 0 s3c-adc adc, s3c2410_action

83: 0 - s3c2410-wdt

Err: 0

[root: key INT_EINT1]# rmmod test //卸载

good bye irq

[root: key INT_EINT1]# cat /proc/interrupts //卸载后,我的中断名字消失了

CPU0

30: 828977 s3c S3C2410 Timer Tick

32: 0 s3c s3c2410-lcd

51: 3202 s3c-ext eth0

70: 192 s3c-uart0 s3c2440-uart

71: 277 s3c-uart0 s3c2440-uart

79: 0 s3c-adc s3c2410_action

80: 0 s3c-adc adc, s3c2410_action

83: 0 - s3c2410-wdt

Err: 0

 

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

五、proc/interrupt

 

接下来,稍稍介绍一下proc/interrupt

[root: 1st]# cat /proc/interrupts

CPU0

17: 11 s3c-ext0 key INT_EINT1 显示我注册和中断名字

首先,第一列是中断号,之前的程序应该有人会有疑问:

中断号在哪里找的?

在S3C2440中,这些中断号定义在文件"include/mach/irqs.h"中,在这里,可以找到对应的中断:

25 /* main cpu interrupts */

26 #define IRQ_EINT0 S3C2410_IRQ(0) /* 16 */

27 #define IRQ_EINT1 S3C2410_IRQ(1)

28 #define IRQ_EINT2 S3C2410_IRQ(2)

29 #define IRQ_EINT3 S3C2410_IRQ(3)

30 #define IRQ_EINT4t7 S3C2410_IRQ(4) /* 20 */

在这里我标了两处红笔:

第一处:可以看到,S3C2440所有的中断号在原来的基值上加了16构成中断号,但不同的芯片或许有不同的定义方法。

第二处:有些中断号是共享的。在S3C2440中,EINT4---EINT7是共享寄存器SRCPND中的一位,所以,linux系统给这样的中断分配了一个共享的中断号。那就是说,如果你使用IRQ_EINT4t7,当收到这些中断时,都会调用对应的中断处理函数。这就需要在中断处理函数中通过第一个传参irq来辨别中断并执行相应的操作。如:

13 irqreturn_t irq_handler(int irqno, void *dev_id) //中断处理函数

14 {

15 switch(irqno){

16 。。。。}

17 }

 

那肯定有人会说,这太麻烦了吧,有没有更好的办法处理共享中断号?

那当然是有,继续看文件"include/mach/irqs.h":

61 /* interrupts generated from the external interrupts sources */

62 #define IRQ_EINT4 S3C2410_IRQ(32) /* 48 */

63 #define IRQ_EINT5 S3C2410_IRQ(33)

64 #define IRQ_EINT6 S3C2410_IRQ(34)

65 #define IRQ_EINT7 S3C2410_IRQ(35)

66 #define IRQ_EINT8 S3C2410_IRQ(36)

看到了吧?内核把共享的中断分离出来,只要使用这些标记就可以了。

其实上面我只是想说明:无论在硬件上ARM是怎么实现中断的(是否共享),在内核看来所有的中断都是一样的,都可以独自获得一个中断号。

 

第二列“11”是对应处理器响应该中断的次数。

第三列“s3c-ext0”是处理这个中断的中断控制器

第四列一看就知道调用irq_request()时定义的中断名字。

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

六、总结

 

其实要实现中断,大部分的工作已经给内核包了,我们只需要做的就是告诉内核,当来了什么中断要执行怎么样的函数,这也是今天介绍的重点,其实步骤很简单:

1)调用两个函数:requesr_irq和free_irq。

2)实现中断处理函数:irq_handler()。

 

还有没讲的知识:

1)还有几个irqflag没介绍。

2)没有介绍dev_id。

可能有人会加载上面的模块失败,这也是我今天没介绍的只是,共享中断号。这里说的共享和硬件的共享不一样性质,下节会介绍。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

2.分享中断号

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

上一节介绍的内容是,调用接口request_irq(),使中断号与中断处理函数对应。但是,有时候会有这样的情况,如果开发板上按键的中断已经被另外的驱动程序注册中断了,而我现在又想再注册一次这个中断,这就出现了一个中断号不止对应一个中断函数的情况。注意,这里与硬件上的共享中断不一样,这里是指,当一个中断信号来了,基于操作系统,一个中断的到来可以调用多个中断处理程序,与硬件无关。

 

接下来从错误的代码开始讲解。

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

 

 

一、错误的产生

 

 

 

以下的代码在“6th_irq_2/1st”中。

 

假设有这样的情况,有一个人,加载了模块test.ko,模块注册了中断号EINT1。接着,我编写代码(我并不知道中断号已经被使用了),加载模块test1.c(在err目录下),模块同样注册了中断号EINT1。但这样的注册不成功的。

 

看效果:

 

[root: 1st]# insmod test.ko //某处加载第一个时成功

 

hello irq

 

[root: 1st]# key down

 

key down

 

[root: 1st]# insmod err/test1.ko //假设我并不知道已经记载了一次,加载第二次时失败

 

[test_init]request irq failed!

 

insmod: cannot insert 'err/test1.ko': Device or resource busy

 

[root: 1st]# cat /proc/interrupts //查看proc时发现,原来早就有人注册了EINT1中断号

 

CPU0

 

17: 2 s3c-ext0 key INT_EINT1

 

30: 20429 s3c S3C2410 Timer Tick

 

32: 0 s3c s3c2410-lcd

 

51: 3032 s3c-ext eth0

 

70: 252 s3c-uart0 s3c2440-uart

 

71: 277 s3c-uart0 s3c2440-uart

 

79: 0 s3c-adc s3c2410_action

 

80: 0 s3c-adc adc, s3c2410_action

 

83: 0 - s3c2410-wdt

 

Err: 0

 

 

 

这个就是两男争一妞的情况了,解决办法有两个:

 

1、动物界的规矩,干掉其中一个,谁赢谁说了算。

 

2、邪恶做法,和平解决,实现共享。

 

 

 

第一个解决办法很简单,查阅内核代码,找到注册该中断的模块,并且想办法卸载该模块。但是,如果那个模块实在是太重要的,不能卸载,那只能共享了。

 

 

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

 

 

二、共享中断号的标记

 

 

 

在上一节的内容,注册中断处理函数接口request_irq()的参数irqflags还没完全介绍完毕,除了IRQ_TIRGGER_FALLING这类指明中断触发的条件的标志外,下面还介绍三个:

 

SA_INTERRUPT:这个标志表明该中断处理程序是一个快速中断处理程序。过去,linux系统会区分快速我慢速中断,但现在这个标志只有这样的效果:当响应这个中断时,禁止所有的中断,是该中断处理函数不会被其他中断打断,迅速执行。

 

SA_SAMPLE_RANDOM:这个标志表明产生的中断会对内核的entropy pool有贡献。Entropy pool负责产生随机数。

 

SA_SHIRQ:这个标志表明多个中断处理程序可以共享一个中断号。

 

 

 

相对其他两个,SA_SHIRQ是常用的标记。也就是说,我的中断注册失败,原因是我没有共享标记。也就是说,我需要在我的注册中断函数添加共享标记。但再回想一下两男争一妞的场景,需要共享前提是两个男的都同意共享,所以,原来的中断注册函数也需要共享标记。需要修改原来的函数test.c和我新写的test1.c,都加上共享标记SA_SHIRQ,表示它们两都同意共享。

 

 

 

在ARM下SA_SHIRQ相当于标志IRQF_SHARED:

 

/*iclude/linux/interrupt.h*/

 

53 #define IRQF_DISABLED 0x00000020 //SA_INTERRUPT

 

54 #define IRQF_SAMPLE_RANDOM 0x00000040 //SA_SAMPLE_RANDOM

 

55 #define IRQF_SHARED 0x00000080 //SA_SHIRQ

 

 

 

看修改后的代码:

 

/*6th_irq_2/1st/test.c*/

 

30 ret = request_irq(IRQ_EINT1, irq_handler,

 

31 IRQF_TRIGGER_FALLING | IRQF_SHARED, "key INT_EINT1", NULL);

 

32 if(ret){

 

33 P_DEBUG("request irq failed!\n");

 

34 return ret;

 

35 }

 

另外一个一模一样

 

/*6th_irq_2/1st/err/test1.c*/

 

30 ret = request_irq(IRQ_EINT1, irq_handler,

 

31 IRQF_TRIGGER_FALLING | IRQF_SHARED, "key INT_EINT1", NULL);

 

32 if(ret){

 

33 P_DEBUG("request irq failed!\n");

 

34 return ret;

 

35 }

 

 

 

再加载一次,发现还是不行。

 

[root: /]# cd review_driver/6th_irq/6th_irq_2/2nd/

 

[root: 2nd]# insmod test.ko //加载第一个时就已经不行了

 

[test_init]request irq failed!

 

insmod: cannot insert 'test.ko': invalid parameter //提示参数错误

 

[root: 2nd]# insmod err/test1.ko

 

[test_init]request irq failed!

 

insmod: cannot insert 'err/test1.ko': invalid parameter

 

 

 

那到底是哪个参数错了?

 

 

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

 

 

三、设备号ID——dev_id

 

 

 

话说两个难得已经同意共享,但为什么还是只能加载一个呢?女的说:“你们是同意了,但我不能分辨不你们吖!”

 

中断函数同时一样的道理,实现共享中断号的情况下,在调用free_irq()时,通过对应的标记,内核才会知道该释放哪个中断处理函数。

 

此时,最有一个没讲的参数dev_id就有他的用处了——内核通过dev_id对应中断处理函数handler。另外,也可以通过它来传参给中断处理函数。

 

 

 

再次修改两个程序,给每个程序就加上一个不同的dev_id:

 

/*6h_irq_2/1st/test.c*/

 

13 irqreturn_t irq_handler(int irqno, void *dev_id) //中断处理函数

 

14 {

 

15 printk("key down, dev_id[%d]\n", *(int *)dev_id);

 

16 return IRQ_HANDLED;

 

17 }

 

18

 

19 int id = 321;

 

20

 

。。。。

 

32 ret = request_irq(IRQ_EINT1, irq_handler,

 

33 IRQF_TRIGGER_FALLING | IRQF_SHARED, "key INT_EINT1", &id);

 

。。。。

 

44 free_irq(IRQ_EINT1, &id);

 

另外一个一模一样

 

6th_irq_2/1st/err/test.c

 

/*6h_irq_2/1st/test.c*/

 

13 irqreturn_t irq_handler(int irqno, void *dev_id) //中断处理函数

 

14 {

 

15 printk("hello xiaobai!, dev_id[%d]\n", *(int *)dev_id);

 

16 return IRQ_HANDLED;

 

17 }

 

18

 

19 int id = 123;

 

20

 

。。。。

 

32 ret = request_irq(IRQ_EINT1, irq_handler,

 

33 IRQF_TRIGGER_FALLING | IRQF_SHARED, "key INT_EINT1", &id);

 

。。。。

 

44 free_irq(IRQ_EINT1, &id);

 

 

 

验证一下,共享成功!

 

[root: 3rd]# insmod test.ko //加载第一个成功

 

hello irq

 

[root: 3rd]# key down, dev_id[321]

 

key down, dev_id[321]

 

key down, dev_id[321]

 

[root: 3rd]# insmod err/test1.ko //加载第二个也成功

 

hello irq

 

[root: 3rd]# key down, dev_id[321] //当我按下按键时,两个中断处理函数都调用了。

 

hello xiaobai!, dev_id[123]

 

key down, dev_id[321]

 

hello xiaobai!, dev_id[123]

 

key down, dev_id[321]

 

hello xiaobai!, dev_id[123]

 

 

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

 

 

四、介绍完了中断接口函数,下面简单讲一下一个中断产生后的流程:

 

 

 

以下的图是《linux内核设计与实现》上的插图,基于x86体系的,所以有些函数我在ARM下找不到。

 

 

 

中 断_中断处理_03

 

先看前三步,这三步是我在《linux设备驱动归纳总结(六):1.中断的实现》的“从硬件角度看中断”有详细描述,当硬件(Hardware)产生中断,传给中断处理器(Interrupt controller),经过中断处理器的一轮筛选后,把中断传给处理器(Processer)。

 

 

 

接下来就要讲解处理器接收到中断之后干什么:

 

1、处理器中断内核(processor interrupts the kernel):这步骤如下:

 

1.1、处理器会立即停止它正在进行的事情。

 

1.2、处理器关闭中断。

 

1.3、保存原来寄存器的值(这些值属于被中断的任务),切换工作模式至IRQ(S3C2440有7种工作模式,芯片手册有讲解,切换工作模式之前需要保存原来部分寄存器上的值,具体请看S3C2440芯片手册)。

 

 

 

2、do_IRQ:(这个部分说得可能有错,因为我把内核的源代码仔细看过,这部分主要是为了引出下一个的函数handle_IRQ_event())

 

在ARM相关的内核代码我没找到do_IRQ函数,但我找到一个相关的——asm_do_IRQ。看看大概做了些什么事情:

 

2.1、把中断号和一个在内核中存放对应的相关数据的结构体(这个结构体就是存放处理器中寄存器的值)作为参数,传参给asm_do_IRQ。

 

/*linux-2.6.29/arch/arm/kernel/entry-armv.S*/

 

29 .macro irq_handler

 

30 get_irqnr_preamble r5, lr

 

31 1: get_irqnr_and_base r0, r6, r5, lr

 

32 movne r1, sp

 

33 @

 

34 @ routine called with r0 = irq number, r1 = struct pt_regs *

 

35 @ //获得中断号和一个结构体,作为参数传给asm_do_IRQ

 

36 adrne lr, 1b

 

37 bne asm_do_IRQ

 

2.2、asm_do_IRQ进行一系列的准备工作之后,调用函数generic_handle_irq():

 

/*linux-2.6.29/arch/arm/kernel/irq.c*/

 

112 asmlinkage void __exception asm_do_IRQ(unsigned int irq, struct pt_regs *regs)

 

113 {

 

114 struct pt_regs *old_regs = set_irq_regs(regs); //保存并设置寄存器上的值,还没弄懂操作的原因

 

115

 

116 irq_enter(); //一系列准备操作,没细看

 

117

 

118 /*

 

119 * Some hardware gives randomly wrong interrupts. Rather

 

120 * than crashing, do something sensible.

 

121 */

 

122 if (irq >= NR_IRQS)

 

123 handle_bad_irq(irq, &bad_irq_desc);

 

124 else

 

125 generic_handle_irq(irq); //调用该函数,开始处理中断。

 

126

 

127 /* AT91 specific workaround */

 

128 irq_finish(irq);

 

129

 

130 irq_exit();

 

131 set_irq_regs(old_regs);

 

132 }

 

2.3、generic_handle_irq中调用函数_do_IRQ:

 

/*linux-2.6.29/include/linux/irq.h*/

 

309 static inline void generic_handle_irq_desc(unsigned int irq, struct irq_desc *desc)

 

310 {

 

311 #ifdef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ

 

312 desc->handle_irq(irq, desc);

 

313 #else

 

314 if (likely(desc->handle_irq))

 

315 desc->handle_irq(irq, desc);

 

316 else

 

317 __do_IRQ(irq);

 

318 #endif

 

319 }

 

320

 

321 static inline void generic_handle_irq(unsigned int irq)

 

322 {

 

323 generic_handle_irq_desc(irq, irq_to_desc(irq));

 

324 }

 

2.4、在__do_IRQ中,会判断该中断号是否已经注册了中断处理函数,如果没有则退出中断,切换至原来的工作模式。如果有,__do_IRQ会调用函数handle_IRQ_event()。

 

 

 

3、irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action) 干了些什么:

 

上面说的内容可能都不太详细,因为我也不太明白有些函数的作用和具体的内核代码,但下面的函数大家应该都会看得懂:

 

/*linux-2.6.29/kernel/irq/handle.c*/

 

326 irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)

 

327 {

 

328 irqreturn_t ret, retval = IRQ_NONE;

 

329 unsigned int status = 0;

 

330

 

331 if (!(action->flags & IRQF_DISABLED)) //在切换工作模式时内核是禁止了中断的,如果

 

332 local_irq_enable_in_hardirq(); //注册时使用标记IRQF_DISABLED,则开启中断

 

333

 

334 do {

 

335 ret = action->handler(irq, action->dev_id); //调用我们注册的中断处理函数

 

336 if (ret == IRQ_HANDLED)

 

337 status |= action->flags;

 

338 retval |= ret;

 

339 action = action->next;

 

340 } while (action); //这是个循环,那就说,如果我们使用的IRQF_SHARED标识,

 

341 //它会轮流执行该中断号对应的所有注册的中断处理函数

 

342 if (status & IRQF_SAMPLE_RANDOM) //如果使用该标记时相应的操作

 

343 add_interrupt_randomness(irq);

 

344 local_irq_disable(); //再次关上中断

 

345

 

346 return retval;

 

347 }

 

 

 

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

 

 

 

五、总结

 

 

 

总结一下中断注册的几个注意事项:

 

1、调用request_irq必须通过返回值判断是否成功。

 

2、共享中断号时,所有共享这个中断号的request_irq都必须添加标记IRQF_SHARED,另外还需要使用一个独特的设备好dev_id,让内核能够通过dev_id对应注册时的中断处理函数。