异常中断处理

一、中断的方式获取键值的流程（单片机的处理方法：）：
1.按键按下
2.CPU发生中断->跳到异常向量的入口执行
3.b 函数,跳转到相关异常的函数中执行相关操作，

异常函数所要做的事情：
1.保存被中断的现场
2.执行中断处理函数
3.恢复现场

下面举个例子：
假如出现的IRQ中断，就会跳转到0x18的地址（这个地址是由arm920t处理器定死的）去执行

相关的操作

@ 0x18: 中断模式的向量地址
    
b   HandleIRQ
接着：
HandleIRQ:    
	sub lr, lr, #4                  @ 计算返回地址    
	stmdb   sp!,    { r0-r12,lr }   @ 保存使用到的寄存器，r0-r12 和lr                     
                                                @ 注意，此时的sp是中断模式的sp          
                                         @ 初始值是上面设置的3072        
	ldr lr, =int_return             @ 设置调用ISR即EINT_Handle函数后的返回地址     	
	ldr pc, =EINT_Handle            @ 调用中断服务函数，在interrupt.c中
int_return:    
	ldmia   sp!,    { r0-r12,pc }^  @ 中断返回, ^表示将spsr的值复制到cpsr

 

sub lr, lr, #4                  @ 计算返回地址

原因：在执行每条指令之前（前提是已经走到了当前指令的地址），就会判断有无中断发生，有中断发生就会跳转到中断的地址去执行（结果当前指令没有被执行），而lr存放的是当前指令的下一条指令的地址。如果要从中断子程序中返回的话，就要将lr = lr - 4（当前指令的地址）。

ARM体系的CPU有7种工作模式：
1.用户模式(usr):ARM处理器正常的程序执行状态
2.快速中断模式（fiq）：用于高速数据传输或通道处理
3.中断模式（irq）：用于通用的中断处理
4.管理模式（svc）：操作系统使用的保护模式
5.数据访问终止模式（abt）：当数据或指令预取终止时进入该模式，可用于虚拟存储及存储保护

6.系统模式（sys）：运行具有特权的操作系统任务

7.未定义指令中止模式（und）：当未定义的指令执行时进入该模式，可用于支持硬件协处理器的软件仿真

 

几个特殊的寄存器：
R13(sp):栈指针寄存器，通常被用于保存栈指针
R14（lr）：程序连接寄存器或连接寄存器，当执行bl子程序调用指令的时候，R14（lr）会得到R15（PC程序计数器）的备份。当发生中断或异常的时候，对应的R14_svc，R14_irq,R14_fiq,R14_abt，R14_und中会保存前一工作模式下的R15（PC）的值
R15（PC）：程序计数器，是用于存放下一条指令所在单元的地址的地方。单片机及汇编语言中常称作PC（Program Counter）。
CPSR（当前程序状态寄存器）：标示了当前处于什么的状态的工作模式
SPSR（保存的程序状态寄存器）：保存了当前工作模式的前一个工作模式的cpsr的值。比如当前工作模式是svc，前面一个工作模式是usr，则SPSR_svc的值就是usr模式下载CPSR值，这样当svc模式想恢复到usr模式的话，只需要将SPSR的值恢复到CPSR中即可

总结一下：
当一个异常发生的时候，CPU将切换到相应的工作模式，

以arm920t cpu为例，它所要做的事情为：
1.将异常工作模式的连接寄存器R14（lr）中保存之前工作模式下一条即将执行的指令的地址。（由于发生中断，当前指令没有执行，就要将R14中保存之前工作模式的当前指令地址）
2.将CPSR的值复制到异常模式下的SPSR
3.将CPSR的工作模式位设置为这个异常对应的工作模式
4.PC的值等于这个异常模式在异常向量表中的地址，即跳转去执行异常向量表中的相应指令

相反，从异常工作模式退出回到之前的工作模式时，需要的工作为：
1.前面进入异常模式时，连接寄存器中保存了前一工作模式的一个指令地址，将它减去一个适当的值（参考下表）后付给PC寄存器
2.将SPSR的值复制回CPSR

 

 二、中断在内核中的处理方式（参考开发手册第20章）
1.异常向量（由trap_init构造），这个函数将中断向量表放在了一个固定的地方。 b vector_irq + offset
2.vector_irq，由宏vector_stub irq实现，保存现场
3.执行c函数do-asm_IRQ

下面具体分析一下：

linux内核对异常的设置：
内核在start_kernel函数（init/Main处理函数.c）中调用trap_init,init_IRQ两个函数来设置异常的

trap_init

asmlinkage void __init start_kernel(void)
{
...
 trap_init();
 init_IRQ();
...
}

trap_init的实现如下：

void __init trap_init(void)
{
...
 unsigned long vectors = CONFIG_VECTORS_BASE;//#define CONFIG_VECTORS_BASE 0xffff0000，这个地址用于存放中断向量表的地址
 extern char __stubs_start[], __stubs_end[];
 extern char __vectors_start[], __vectors_end[];
 extern char __kuser_helper_start[], __kuser_helper_end[];
 int kuser_sz = __kuser_helper_end - __kuser_helper_start;
 /*
  * Copy the vectors, stubs and kuser helpers (in entry-armv.S)
  * into the vector page, mapped at 0xffff0000, and ensure these
  * are visible to the instruction stream.
  */
 memcpy((void *)vectors, __vectors_start, __vectors_end - __vectors_start);//这个就是对中断向量进行放置的操作
 memcpy((void *)vectors + 0x200, __stubs_start, __stubs_end - __stubs_start);
 memcpy((void *)vectors + 0x1000 - kuser_sz, __kuser_helper_start, kuser_sz);
...
}
}

这个函数被用来设置各种异常的处理向量，其中就包括了中断向量（ _vectors_start到_vector_end之间的变量）。

所谓"向量"，就是一些安放在固定位置的代码，当发生异常的时候，CPU会自动执行这些固定位置上的指令。ARM架构CPU的异常向量的基址可以是0x00000000,也可以是0xffff0000,在linux内核中使用0xffff0000.trap_init函数的作用就将异常向量复制到了0xffff0000.
如下：

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

使用si搜索：__vectors_start发现在arch\arm\kernel\entry-armv.S里面定义如下：

 .globl __vectors_start
__vectors_start:
 swi SYS_ERROR0                        ////复位时，CPU将执行这条指令
 b vector_und + stubs_offset            //未定义异常时，CPU将执行这条指令
 ldr pc, .LCvswi + stubs_offset          // swi异常
 b vector_pabt + stubs_offset            // 指令预取中止
 b vector_dabt + stubs_offset             // 数据访问中止
 b vector_addrexcptn + stubs_offset      //没使用到
 b vector_irq + stubs_offset             //irq异常
 b vector_fiq + stubs_offset              //fiq异常
 .globl __vectors_end
__vectors_end:
 .data
 .globl cr_alignment
 .globl cr_no_alignment
cr_alignment:
 .space 4
cr_no_alignment:
 .space 4

上面的注释就是中断向量表，如果cpu发生了中断就会跳转到相应的地址去执行相应的操作，下表显示了arm架构在linux中的异常处理体系结构：

init_IRQ

用来初始化中断处理体系结构，定义在 arch\arm\kernel\Irq.c

void __init init_IRQ(void)
{
	int irq;

	for (irq = 0; irq < NR_IRQS; irq++)  //初始化irq_desc结构数组中的每一项的中断状态
		irq_desc[irq].status |= IRQ_NOREQUEST | IRQ_NOPROBE;

#ifdef CONFIG_SMP
	bad_irq_desc.affinity = CPU_MASK_ALL;
	bad_irq_desc.cpu = smp_processor_id();
#endif
	init_arch_irq();//这个函数是和架构相关的中断初始化函数，
}

init_arch_irq在 arch\arm\kernel\Setup.c中指向了mdesx->init_irq

void __init setup_arch(char **cmdline_p)
{...
init_arch_irq = mdesc->init_irq;//这个init_irq对应于：MACHINE_START(S3C2440, "SMDK2440")中的.init_irq
...
}

setup_arch在start_kernel中被调用：

asmlinkage void __init start_kernel(void)
{...
	setup_arch(&command_line);
...
}

.init_irq所在的地方：

MACHINE_START(S3C2440, "SMDK2440")
	/* Maintainer: Ben Dooks <ben@fluff.org> */
	.phys_io	= S3C2410_PA_UART,
	.io_pg_offst	= (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
	.boot_params	= S3C2410_SDRAM_PA + 0x100,

	.init_irq	= s3c24xx_init_irq,
	.map_io		= smdk2440_map_io,
	.init_machine	= smdk2440_machine_init,
	.timer		= &s3c24xx_timer,
MACHINE_END

下面看下s3c24xx_init_irq是如何进行初始化的：

在单片机中，中断处理有如下过程：

1.分辨是哪个中断

2.调用处理函数

3.清中断

在linux中也是如此：

1.首先清中断

2.注册中断处理函数

3.调用处理函数，在do_asm_IRQ中实现

void __init s3c24xx_init_irq(void)
{
	unsigned long pend;
	unsigned long last;
	int irqno;
	int i;

	irqdbf("s3c2410_init_irq: clearing interrupt status flags\n");

	/* first, clear all interrupts pending... 首先清中断*/

	last = 0;
	for (i = 0; i < 4; i++) {
		pend = __raw_readl(S3C24XX_EINTPEND);

		if (pend == 0 || pend == last)
			break;

		__raw_writel(pend, S3C24XX_EINTPEND);
		printk("irq: clearing pending ext status %08x\n", (int)pend);
		last = pend;
	}

	。。。。

	/* register the main interrupts 然后注册中断处理函数*/

         。。。。。
	/* register the uart interrupts */

	irqdbf("s3c2410: registering external interrupts\n");

	for (irqno = IRQ_S3CUART_RX0; irqno <= IRQ_S3CUART_ERR0; irqno++) {
		irqdbf("registering irq %d (s3c uart0 irq)\n", irqno);
		set_irq_chip(irqno, &s3c_irq_uart0);//设置底层硬件
		set_irq_handler(irqno, handle_level_irq);//设置中断处理函数，就是将相应的handle付接到desc上
		set_irq_flags(irqno, IRQF_VALID);//设置flags
	}
  
。。。。
	irqdbf("s3c2410: registered interrupt handlers\n");
}

二、假如有个按键按下，则会触发中断向量表，执行跳转动作：

b vector_irq + stubs_offset 

以vector_irq（ 这就是中断处理）为例：

它是通过vector_stub来定义的,先看下这个宏的定义：

 .macro vector_stub, name, mode, correction=0
 .align 5
vector_\name:
 .if \correction
 sub lr, lr, #\correction
 .endif
 @
 @ Save r0, lr_<exception> (parent PC) and spsr_<exception>
 @ (parent CPSR)
 @
 stmia sp, {r0, lr}  @ save r0, lr
 mrs lr, spsr
 str lr, [sp, #8]  @ save spsr
 @
 @ Prepare for SVC32 mode.  IRQs remain disabled.
 @
 mrs r0, cpsr
 eor r0, r0, #(\mode ^ SVC_MODE)
 msr spsr_cxsf, r0
 @
 @ the branch table must immediately follow this code
 @
 and lr, lr, #0x0f
 mov r0, sp
 ldr lr, [pc, lr, lsl #2]
 movs pc, lr   @ branch to handler in SVC mode
 .endm

中断的处理：

/*
 * Interrupt dispatcher
 */
 vector_stub irq, IRQ_MODE, 4
 .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

展开如下： 

vector_stub irq, IRQ_MODE, 4
 .macro vector_stub, name, mode, correction=0
 .align 5
vector_irq:
 .if 4
 sub lr, lr, #4   //计算中断返回地址
 .endif
 @
 @ Save r0, lr_<exception> (parent PC) and spsr_<exception>
 @ (parent CPSR)
 @

//保存中断返回的地址和之前工作模式的spsr
 stmia sp, {r0, lr}  @ save r0, lr
 mrs lr, spsr
 str lr, [sp, #8]  @ save spsr
 @
 @ Prepare for SVC32 mode.  IRQs remain disabled.
 @

//设置svc32模式
 mrs r0, cpsr
 eor r0, r0, #(\mode ^ SVC_MODE)
 msr spsr_cxsf, r0
 @
 @ the branch table must immediately follow this code
 @
 and lr, lr, #0x0f
 mov r0, sp
 ldr lr, [pc, lr, lsl #2]
 movs pc, lr   @ branch to handler in SVC mode
 .endm
 /*下面是中断向量表*/
 //在用户模式执行了irq指令
 .long __irq_usr   @  0  (USR_26 / USR_32)
 //在FIQ模式下执行irq指令
 .long __irq_invalid   @  1  (FIQ_26 / FIQ_32)
 //在IRQ模式下执行了irq指令
 .long __irq_invalid   @  2  (IRQ_26 / IRQ_32)
 //在管理模式下执行了irq指令
 .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

vector_stub宏的功能是：计算处理完异常后的返回地址，保存一些寄存器，然后进入管理模式，最后根据被中断的工作模式调用上面的某个分支。
假如进入其中一个分支__irq_usr

__irq_usr:
 usr_entry           //对栈进行设置，来调用c函数
#ifdef CONFIG_TRACE_IRQFLAGS
 bl trace_hardirqs_off
#endif
 get_thread_info tsk
#ifdef CONFIG_PREEMPT
 ldr r8, [tsk, #TI_PREEMPT]  @ get preempt count
 add r7, r8, #1   @ increment it
 str r7, [tsk, #TI_PREEMPT]
#endif

 irq_handler   //这是一个宏

#ifdef CONFIG_PREEMPT
 ldr r0, [tsk, #TI_PREEMPT]
 str r8, [tsk, #TI_PREEMPT]
 teq r0, r7
 strne r0, [r0, -r0]
#endif
#ifdef CONFIG_TRACE_IRQFLAGS
 bl trace_hardirqs_on
#endif
 mov why, #0
 b ret_to_user
 .ltorg

irq_handler的定义：

 .macro irq_handler
 get_irqnr_preamble r5, lr
1: get_irqnr_and_base r0, r6, r5, lr
 movne r1, sp
 @
 @ routine called with r0 = irq number, r1 = struct pt_regs *
 @// 获取中断号，pt_regs结构体指针
 adrne lr, 1b
 bne asm_do_IRQ  //调用c函数asm_do_IRQ

#ifdef CONFIG_SMP
 /*
  * XXX
  *
  * this macro assumes that irqstat (r6) and base (r5) are
  * preserved from get_irqnr_and_base above
  */
 test_for_ipi r0, r6, r5, lr
 movne r0, sp
 adrne lr, 1b
 bne do_IPI
#ifdef CONFIG_LOCAL_TIMERS
 test_for_ltirq r0, r6, r5, lr
 movne r0, sp
 adrne lr, 1b
 bne do_local_timer
#endif
#endif
 .endm

get_irqnr_preamble和get_irqnr_and_base是个宏（这个是和具体的平台有关， include\asm-arm\arch-s3c2410\entry-macro.S）：

定义如下：

	.macro  get_irqnr_preamble, base, tmp
	.endm

宏get_irqnr_preamble没有做任何事

get_irqnr_and_base获取了中断号，中断状态flag，对中断号一一的比对，成功比对后退出

.macro	get_irqnr_and_base, irqnr, irqstat, base, tmp

		mov	\base, #S3C24XX_VA_IRQ

		@@ try the interrupt offset register, since it is there

		ldr	\irqstat, [ \base, #INTPND ]
		teq	\irqstat, #0
		beq	1002f
		ldr	\irqnr, [ \base, #INTOFFSET ]
		mov	\tmp, #1
		tst	\irqstat, \tmp, lsl \irqnr
		bne	1001f

		@@ the number specified is not a valid irq, so try
		@@ and work it out for ourselves

		mov	\irqnr, #0		@@ start here

		@@ work out which irq (if any) we got

		movs	\tmp, \irqstat, lsl#16
		addeq	\irqnr, \irqnr, #16
		moveq	\irqstat, \irqstat, lsr#16
		tst	\irqstat, #0xff
		addeq	\irqnr, \irqnr, #8
		moveq	\irqstat, \irqstat, lsr#8
		tst	\irqstat, #0xf
		addeq	\irqnr, \irqnr, #4
		moveq	\irqstat, \irqstat, lsr#4
		tst	\irqstat, #0x3
		addeq	\irqnr, \irqnr, #2
		moveq	\irqstat, \irqstat, lsr#2
		tst	\irqstat, #0x1
		addeq	\irqnr, \irqnr, #1

		@@ we have the value
1001:
		adds	\irqnr, \irqnr, #IRQ_EINT0
1002:
		@@ exit here, Z flag unset if IRQ

	.endm

中断号获取后，就调用asm_do_IRQ了
下面了解下 asm_do_IRQ 

/*
 * do_IRQ handles all hardware IRQ's.  Decoded IRQs should not
 * come via this function.  Instead, they should provide their
 * own 'handler'
 */
asmlinkage void __exception asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
{
	struct pt_regs *old_regs = set_irq_regs(regs);
	struct irq_desc *desc = irq_desc + irq;//根据发生中断的中断号找到对应的irq_desc

	/*
	 * Some hardware gives randomly wrong interrupts.  Rather
	 * than crashing, do something sensible.
	 */
	if (irq >= NR_IRQS)
		desc = &bad_irq_desc;

	irq_enter();

	desc_handle_irq(irq, desc); //找到desc后，对发出的中断进行处理，下面分析

	/* AT91 specific workaround */
	irq_finish(irq);

	irq_exit();
	set_irq_regs(old_regs);
}

先看下irq_desc的定义：

struct irq_desc {
	irq_flow_handler_t	handle_irq;      //当前中断的处理函数入口
	struct irq_chip		*chip;           //底层的硬件访问
。。。
	const char		*name;           //中断的名称
} ____cacheline_internodealigned_in_smp;

desc_handle_irq的实现：

static inline void desc_handle_irq(unsigned int irq, struct irq_desc *desc)
{
	desc->handle_irq(irq, desc);//调用desc中的handle_irq进行处理
}

Linux：
1.asm_do_IRQ
2.desc->handle_irq()
3.irq_desc[] s3c24xx_init_irq
参考网址：http://minano-notebook.wikidot.com/linux-interrupt

handle_edge_irq
1.desc->chip->ack(irq) :清中断
2.handle_IRQ_event :处理中断
取出action链表中的成员
执行action->handler

按下按键
1.CPU进入异常模式：  b vector_irq + 偏移
2.最终调用到__irq_usr --> irq_handler -->asm_do_IRQ
3.irq_desc[irq] -> handle_irq,其中：handle_irq在s3c24xx_init_irq进行初始化

如何自己分配一个中断和其中断处理函数

request_irq(irq,handle,irqflags,devname,dev_id)
1.分配一个irqaction结构
2.setup_irq（irq，action）：
a.在irq_desc[irq]->action链表中加入action
b.desc->chip->settype()
c.desc->chip->startup/enable

free_irq(irq,dev-id)
dev_id：用于共享中断，因为有可能很多中断源共享一个中断号

总结：
1.request_irq(irq,handler,flags,name,dev_id)
a.分配一个irqaction
b.把这个结构放入irq-desc[irq]
action链表
c. 设置引脚，使能中断
2.free_irq(irq,dev-id)
a.出链表
b.禁止中断