异常中断处理

一、中断的方式获取键值的流程（单片机的处理方法：）：
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_alignmentcr_alignment: .space 4cr_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_SMPbad_irq_desc.affinity = CPU_MASK_ALL;bad_irq_desc.cpu = smp_processor_id();#endifinit_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 <[e-mail]> */.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 5vector_\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 5vector_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, lr1: 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，对中断号一一的比对，成功比对后退出

.macroget_irqnr_and_base, irqnr, irqstat, base, tmpmov\base, #S3C24XX_VA_IRQ@@ try the interrupt offset register, since it is thereldr\irqstat, [ \base, #INTPND ]teq\irqstat, #0beq1002fldr\irqnr, [ \base, #INTOFFSET ]mov\tmp, #1tst\irqstat, \tmp, lsl \irqnrbne1001f@@ the number specified is not a valid irq, so try@@ and work it out for ourselvesmov\irqnr, #0@@ start here@@ work out which irq (if any) we gotmovs\tmp, \irqstat, lsl#16addeq\irqnr, \irqnr, #16moveq\irqstat, \irqstat, lsr#16tst\irqstat, #0xffaddeq\irqnr, \irqnr, #8moveq\irqstat, \irqstat, lsr#8tst\irqstat, #0xfaddeq\irqnr, \irqnr, #4moveq\irqstat, \irqstat, lsr#4tst\irqstat, #0x3addeq\irqnr, \irqnr, #2moveq\irqstat, \irqstat, lsr#2tst\irqstat, #0x1addeq\irqnr, \irqnr, #1@@ we have the value1001:adds\irqnr, \irqnr, #IRQ_EINT01002:@@ 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_thandle_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.禁止中断