exynos4412中断处理流程详解(代码片段)

　【arch/arm/kernel/entry-armv.S】

　　__vectors_start:---------------〉在中断向量表被拷贝后，该地址就是0xffff0000.

　　ARM( swi SYS_ERROR0 )

　　THUMB( svc #0 )

　　THUMB( nop )

　　W(b) vector_und + stubs_offset

　　W(ldr) pc, .LCvswi + stubs_offset

　　W(b) vector_pabt + stubs_offset

　　W(b) vector_dabt + stubs_offset

　　W(b) vector_addrexcptn + stubs_offset

　　W(b)vector_irq + stubs_offset----------〉当外部中断产生时，pc直接指向这个地址。

　　W(b) vector_fiq + stubs_offset

　　.globl __vectors_end

　/*

　　* Vector stubs.

　　*

　　* This code is copied to 0xffff0200 so we can use branches in the

　　* vectors, rather than ldr‘s. Note that this code must not

　　* exceed 0x300 bytes.

　　*

　　* Common stub entry macro:

　　* Enter in IRQ mode, spsr = SVC/USR CPSR, lr = SVC/USR PC

　　*

　　* SP points to a minimal amount of processor-private memory, the address

　　* of which is copied into r0 for the mode specific abort handler.

　　*/

　　.macro vector_stub, name, mode, correction=0

　　.align 5

　　vector_
ame:

　　.if correction

　　sub lr, lr, #correction //因为硬件处理器是将当前指令的下两条指令的地址存储在lr寄存器中，所以这里需要减4，让他指向被中断指令的下一条，这样当中断被恢复时，可以继续被中断的指令继续执行。

　　.endif //需要注意的是，这个时候的lr寄存器，已经是irq模式下的私有寄存器了，在中断产生时，硬件处理器已经自动为他赋了值。

　　@

　　@ Save r0, lr_ (parent PC) and spsr_

　　@ (parent CPSR)

　　@

　　stmia sp, r0, lr @ save r0, lr//保存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 | PSR_ISETSTATE)

　　msr spsr_cxsf, r0

　　@

　　@ the branch table must immediately follow this code

　　@

　　and lr, lr, #0x0f //获取被中断前，处理器所处的模式

　　THUMB( adr r0, 1f )

　　THUMB( ldr lr, [r0, lr, lsl #2] )

　　mov r0, sp //让r0寄存器指向中断模式下堆栈的基地址

　　ARM( ldr lr, [pc, lr, lsl #2] )

　　movs pc, lr @ branch to handler in SVC mode，同时将中断模式下的spsr_irq(irq私有的)赋值给cpsr(该寄存器所有模式共享)

　　ENDPROC(vector_
ame)

　　从这可以看出 vector_stub 的使用方法：

　　vector_stub, name, mode, correction=0

　__stubs_start:

　　/*

　　* Interrupt dispatcher

　　*/

　　vector_stub irq, IRQ_MODE, 4 //减去4，确保返回发生中断之后的那条指令

　　.long __irq_usr@ 0 (USR_26 / USR_32) //从用户态进入中断的处理函数 base address + 0

　　.long __irq_invalid@ 1 (FIQ_26 / FIQ_32)

　　.long __irq_invalid@ 2 (IRQ_26 / IRQ_32)

　　.long __irq_svc@ 3 (SVC_26 / SVC_32) //从SVC进入中断的处理函数 base address + 12

　　.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

　　__irq_usr:

　　usr_entry //进行中断前的硬件上下文的保存

　　kuser_cmpxchg_check

　　irq_handler

　　get_thread_info tsk//获取被中断的用户进程或内核线程所对应的内核栈所对应的thread info结构。

　　mov why, #0

　　b ret_to_user_from_irq//恢复被中断时的上下文，然后继续被中断的进程或线程的执行

　　UNWIND(.fnend )

　　ENDPROC(__irq_usr)

usr_entry展开如下：

　　.macro usr_entry

　　UNWIND(.fnstart )

　　UNWIND(.cantunwind ) @ don‘t unwind the user space

　　sub sp, sp, #S_FRAME_SIZE // #S_FRAME_SIZE的值为72

　　ARM( stmib sp, r1 - r12 ) //尽管当前是处于管理模式，但由于svc和usr的r0-r12是公共的，所以相当于保存用户模式的r1-r12寄存器

　　THUMB( stmia sp, r0 - r12 )

　　ldmia r0, r3 - r5 //将之前保存在中断模式堆栈中的r0_usr，lr，spsr分别存储到r3-r5中

　　add r0, sp, #S_PC @ here for interlock avoidance #S_PC=60

　　mov r6, #-1 @ "" "" "" ""

　　str r3, [sp] @ save the "real" r0 copied

　　@ from the exception stack

　　@

　　@ We are now ready to fill in the remaining blanks on the stack:

　　@

　　@ r4 - lr_, already fixed up for correct return/restart

　　@ r5 - spsr_

　　@ r6 - orig_r0 (see pt_regs definition in ptrace.h)

　　@

　　@ Also, separately save sp_usr and lr_usr

　　@

　　stmia r0, r4 - r6

　　ARM( stmdb r0, sp, lr^ )//保存用户模式下的sp_usr,lr_usr

　　THUMB( store_user_sp_lr r0, r1, S_SP - S_PC )

　　@

　　@ Enable the alignment trap while in kernel mode

　　@

　　alignment_trap r0

　　@

　　@ Clear FP to mark the first stack frame

　　@

　　zero_fp

　　ifdef CONFIG_IRQSOFF_TRACER

　　bl trace_hardirqs_off

　　endif

　　.endm

　usr_entry 结束后，会执行 irq_handler

　　irq_handler的实现过程 archarmkernelentry-armv.S

　　.macro irq_handler

　　get_irqnr_preamble r5, lr

　　@在include/asm/arch-s3c2410/entry-macro.s中定义了宏get_irqnr_preamble为空操作，什么都不做

　　1: get_irqnr_and_base r0, r6, r5, lr @判断中断号，通过R0返回，3.5节有实现过程

　　movne r1, sp

　　@

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

　　@

　　adrne lr, 1b

　　bne asm_do_IRQ @进入中断处理。

　　……

　　.endm

　　* asm_do_IRQ is the interface to be used from assembly code.

　　*/

　　asmlinkage void __exception_irq_entry

　　asm_do_IRQ(unsigned int irq, struct pt_regs *regs)

　　

　　handle_IRQ(irq, regs);

　　

　/*

　　* handle_IRQ handles all hardware IRQ‘s. Decoded IRQs should

　　* not come via this function. Instead, they should provide their

　　* own ‘handler‘. Used by platform code implementing C-based 1st

　　* level decoding.

　　*/

　　void handle_IRQ(unsigned int irq, struct pt_regs *regs)

　　

　　struct pt_regs *old_regs = set_irq_regs(regs);

　　irq_enter();

　　/*

　　* Some hardware gives randomly wrong interrupts. Rather

　　* than crashing, do something sensible.

　　*/

　　if (unlikely(irq >= nr_irqs)) 

　　if (printk_ratelimit())

　　printk(KERN_WARNING "Bad IRQ%u
", irq);

　　ack_bad_irq(irq);

　　 else 

　　generic_handle_irq(irq);

　　

　　irq_exit();

　　set_irq_regs(old_regs);

　　

　　主要调用generic_handle_irq(irq)

　include/linux/irq.h

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

　　

　　#ifdef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ

　　desc->handle_irq(irq, desc);

　　#else

　　if (likely(desc->handle_irq))

　　desc->handle_irq(irq, desc);

　　else

　　__do_IRQ(irq);

　　#endif

　　

　　static inline void generic_handle_irq(unsigned int irq)

　　

　　generic_handle_irq_desc(irq, irq_to_desc(irq));

　　

　　generic_handle_irq调用前面定义的generic_handle_irq_desc

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

　　

　　desc->handle_irq(irq, desc);

　　

　　include/linux/irq.h

　　

　　.........

　　irq_flow_handler_t handle_irq; //当前的中断处理函数入口

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

　　..........

　　struct irqaction *action; //用户提供的中断处理函数链表

　　unsigned int status; //IRQ状态

　　...........

　　const char *name; //中断名称

　　 ____cacheline_internodealigned_in_smp;

　　Handle_irq是这个或者这组中断的处理函数入口

　for (irqno = IRQ_EINT0; irqno <= IRQ_EINT3; irqno++) 

　　irqdbf("registering irq %d (ext int)
", irqno);

　　set_irq_chip(irqno, &s3c_irq_eint0t4);

　　set_irq_handler(irqno, handle_edge_irq);

　　set_irq_flags(irqno, IRQF_VALID);

　　

kernel/irq/chip.c

　　void

　　handle_edge_irq(unsigned int irq, struct irq_desc *desc)

　　

　　spin_lock(&desc->lock); 上锁

　　desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);

　　/*

　　* If we‘re currently running this IRQ, or its disabled,

　　* we shouldn‘t process the IRQ. Mark it pending, handle

　　* the necessary masking and go out

　　*/

　　if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) || 判断

　　!desc->action)) 

　　desc->status |= (IRQ_PENDING | IRQ_MASKED);

　　mask_ack_irq(desc, irq); 屏蔽并清除中断

　　goto out_unlock;

　　

　　kstat_incr_irqs_this_cpu(irq, desc); 中断统计计数

　　/* Start handling the irq */

　　if (desc->chip->ack) 应答中断

　　desc->chip->ack(irq);

　　/* Mark the IRQ currently in progress.*/

　　desc->status |= IRQ_INPROGRESS; 标记中断状态

　　do 

　　struct irqaction *action = desc->action;

　　irqreturn_t action_ret;

　　if (unlikely(!action)) 

　　desc->chip->mask(irq);

　　goto out_unlock;

　　

　　/*

　　* When another irq arrived while we were handling

　　* one, we could have masked the irq.

　　* Renable it, if it was not disabled in meantime.

　　*/

　　if (unlikely((desc->status &

　　(IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==

　　(IRQ_PENDING | IRQ_MASKED))) 

　　desc->chip->unmask(irq);

　　desc->status &= ~IRQ_MASKED;

　　

　　desc->status &= ~IRQ_PENDING;

　　spin_unlock(&desc->lock);

　　action_ret = handle_IRQ_event(irq, action); 处理中断，最重要的函数，注意参数，action这个参数将联系到我们的用户中断处理函数

　　if (!noirqdebug)

　　note_interrupt(irq, desc, action_ret);

　　spin_lock(&desc->lock);

　　 while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);

　　desc->status &= ~IRQ_INPROGRESS;

　　out_unlock:

　　spin_unlock(&desc->lock);

　　

　　进行追踪handle_IRQ_event()

　　kernel/irq/handle.c

　　trace_irq_handler_entry(irq, action);

　　ret = action->handler(irq, action->dev_id);

　　trace_irq_handler_exit(irq, action, ret);