系统处理 IRQ_EINT0 IRQ_EINT11 的过程

主要分析系统处理 IRQ_EINT0 IRQ_EINT11 的过程。

2440处理器的中断组织成两层：主中断 和 次中断，一共可以处理60个中断源。

主中断 和 次中断 经过中断构架的抽象之后，编写驱动程序时，我们不用考虑这两层中断，直接使用
request_irq 注册 60个中断源的某个，就可以直接使用中断了。

        err = request_irq(button_irqs[i].irq, buttons_interrupt, NULL,
                          button_irqs[i].name, (void *)&button_irqs[i]);
        set_irq_type(button_irqs[i].irq, IRQT_BOTHEDGE);
像上面这样使用中断。

下面是主中断0~31共32个中断源(32bit)

/* main cpu interrupts */
#define IRQ_EINT0      S3C2410_IRQ(0)        /* 16 */
#define IRQ_EINT1      S3C2410_IRQ(1)
#define IRQ_EINT2      S3C2410_IRQ(2)
#define IRQ_EINT3      S3C2410_IRQ(3)
#define IRQ_EINT4t7    S3C2410_IRQ(4)        /* 20 */
#define IRQ_EINT8t23   S3C2410_IRQ(5)
#define IRQ_RESERVED6  S3C2410_IRQ(6)        /* for s3c2410 */
#define IRQ_CAM        S3C2410_IRQ(6)        /* for s3c2440 */
#define IRQ_BATT_FLT   S3C2410_IRQ(7)
#define IRQ_TICK       S3C2410_IRQ(8)        /* 24 */
#define IRQ_WDT           S3C2410_IRQ(9)
#define IRQ_TIMER0     S3C2410_IRQ(10)
#define IRQ_TIMER1     S3C2410_IRQ(11)
#define IRQ_TIMER2     S3C2410_IRQ(12)
#define IRQ_TIMER3     S3C2410_IRQ(13)
#define IRQ_TIMER4     S3C2410_IRQ(14)
#define IRQ_UART2      S3C2410_IRQ(15)
#define IRQ_LCD           S3C2410_IRQ(16)        /* 32 */
#define IRQ_DMA0       S3C2410_IRQ(17)
#define IRQ_DMA1       S3C2410_IRQ(18)
#define IRQ_DMA2       S3C2410_IRQ(19)
#define IRQ_DMA3       S3C2410_IRQ(20)
#define IRQ_SDI           S3C2410_IRQ(21)
#define IRQ_SPI0       S3C2410_IRQ(22)
#define IRQ_UART1      S3C2410_IRQ(23)
#define IRQ_RESERVED24 S3C2410_IRQ(24)        /* 40 */
#define IRQ_NFCON      S3C2410_IRQ(24)        /* for s3c2440 */
#define IRQ_USBD       S3C2410_IRQ(25)
#define IRQ_USBH       S3C2410_IRQ(26)
#define IRQ_IIC           S3C2410_IRQ(27)
#define IRQ_UART0      S3C2410_IRQ(28)        /* 44 */
#define IRQ_SPI1       S3C2410_IRQ(29)
#define IRQ_RTC           S3C2410_IRQ(30)
#define IRQ_ADCPARENT  S3C2410_IRQ(31)

其中IRQ_EINT4t7，IRQ_EINT8t23，IRQ_CAM，IRQ_WDT，IRQ_LCD，IRQ_ADCPARENT，IRQ_UART0，IRQ_UART1，
IRQ_UART2，这9个主中断下面还有次中断，实际的中断源来自次中断，所以要分清到底是硬件的那个部分产生了中断，还要下
潜到次中断，才能查看到底是那里发生了中断。上面的9个主中断并不属于60个中断源之一，因为他们只是表征了次中断的发生
与否。具体的次中断才是60个中断源之一。次中断组织如下。

/* interrupts generated from the external interrupts sources */
#define IRQ_EINT4      S3C2410_IRQ(32)       /* 48 */
#define IRQ_EINT5      S3C2410_IRQ(33)
#define IRQ_EINT6      S3C2410_IRQ(34)
#define IRQ_EINT7      S3C2410_IRQ(35)
#define IRQ_EINT8      S3C2410_IRQ(36)
#define IRQ_EINT9      S3C2410_IRQ(37)
#define IRQ_EINT10     S3C2410_IRQ(38)
#define IRQ_EINT11     S3C2410_IRQ(39)
#define IRQ_EINT12     S3C2410_IRQ(40)
#define IRQ_EINT13     S3C2410_IRQ(41)
#define IRQ_EINT14     S3C2410_IRQ(42)
#define IRQ_EINT15     S3C2410_IRQ(43)
#define IRQ_EINT16     S3C2410_IRQ(44)
#define IRQ_EINT17     S3C2410_IRQ(45)
#define IRQ_EINT18     S3C2410_IRQ(46)
#define IRQ_EINT19     S3C2410_IRQ(47)
#define IRQ_EINT20     S3C2410_IRQ(48)       /* 64 */
#define IRQ_EINT21     S3C2410_IRQ(49)
#define IRQ_EINT22     S3C2410_IRQ(50)
#define IRQ_EINT23     S3C2410_IRQ(51)


#define IRQ_EINT(x)    S3C2410_IRQ((x >= 4) ? (IRQ_EINT4 + (x) - 4) : (S3C2410_IRQ(0) + (x)))

#define IRQ_LCD_FIFO   S3C2410_IRQ(52)
#define IRQ_LCD_FRAME  S3C2410_IRQ(53)

/* IRQs for the interal UARTs, and ADC
 * these need to be ordered in number of appearance in the
 * SUBSRC mask register
*/
#define IRQ_S3CUART_RX0  S3C2410_IRQ(54)   /* 70 */
#define IRQ_S3CUART_TX0  S3C2410_IRQ(55)   /* 71 */
#define IRQ_S3CUART_ERR0 S3C2410_IRQ(56)

#define IRQ_S3CUART_RX1  S3C2410_IRQ(57)
#define IRQ_S3CUART_TX1  S3C2410_IRQ(58)
#define IRQ_S3CUART_ERR1 S3C2410_IRQ(59)

#define IRQ_S3CUART_RX2  S3C2410_IRQ(60)
#define IRQ_S3CUART_TX2  S3C2410_IRQ(61)
#define IRQ_S3CUART_ERR2 S3C2410_IRQ(62)

#define IRQ_TC         S3C2410_IRQ(63)
#define IRQ_ADC         S3C2410_IRQ(64)

/* extra irqs for s3c2440 */

#define IRQ_S3C2440_CAM_C    S3C2410_IRQ(65)
#define IRQ_S3C2440_CAM_P    S3C2410_IRQ(66)
#define IRQ_S3C2440_WDT        S3C2410_IRQ(67)
#define IRQ_S3C2440_AC97    S3C2410_IRQ(68) //68＋1－9＝60，正好是60个中断源。

#define NR_IRQS (IRQ_S3C2440_AC97+1)
这里确定了中断源个数，代表着 irq_desc 的数组大小
也表征了本处理器能够处理的最多的irq中断个数。

假如现在发生了IRQ_EINT0 或者 IRQ_EINT11中断，分析下中断处理的过程。
中断向量在那里呢？
那是在 start_kernel() -> trap_init()，

memcpy((void *)0xffff0000, __vectors_start, __vectors_end - __vectors_start);
memcpy((void *)0xffff0200, __stubs_start, __stubs_end - __stubs_start);

linux用0xffff0000位置存放中断向量，所以中断向量被拷贝到了虚拟地址0xffff0000位置处。

.globl    __vectors_start
__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:

这样，当我们的IRQ_EINT0 或者 IRQ_EINT11中断发生时，    b    vector_irq + stubs_offset这条语句就被执行了。
程序跳转到了vector_irq + stubs_offset的位置。
那么vector_irq + stubs_offset在哪里？是什么内容呢？


.globl    __stubs_start
__stubs_start:
/*
 * Interrupt dispatcher
 */
    vector_stub    irq, 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

上面的.long就是跳转表，只有两个有效，用户态和系统态

......

    .globl    __stubs_end
__stubs_end:

    .equ    stubs_offset, __vectors_start + 0x200 - __stubs_start




其中vector_stub是个宏，他的作用是调整返回地址的位置，保存r0和返回地址，进入irq模式之前的cpsr到irq的堆栈中，进入管理模式，
根据进入irq模式之前的cpsr内容(中断是从用户态还是系统态发生的)，索引正确的跳转表。

假设中断发生在用户态。
那么要到__irq_usr走一趟了。

.align    5
__irq_usr:

    ...

    irq_handler

    ...

    b    ret_to_user

    .ltorg

忽略不感兴趣的部分，这段程序的主体是irq_handler。
在找irq_handler。他是个宏。

    .macro    irq_handler
1:    get_irqnr_and_base r0, r6, r5, lr
    movne    r1, sp
    @
    @ routine called with r0 = irq number, r1 = struct pt_regs *
    @
    adrne    lr, 1b
    bne    asm_do_IRQ

    .endm

见到希望了，可以肯定是get_irqnr_and_base确定的具体中断号。然后调用asm_do_IRQ来完成我们在驱动程序中
request_irq()注册的中断处理函数的调用。asm_do_IRQ()在《嵌入式开发详解》里有详细的介绍了。

去看看get_irqnr_and_base是怎么得到我们想要的 IRQ_EINT0 IRQ_EINT11对应的中断号的？
它都能识别出那些中断源发出的中断？


.macro    get_irqnr_and_base, irqnr, irqstat, base, tmp

        mov    \tmp, #S3C24XX_VA_IRQ 取得中断控制寄存器(mem IO)的虚拟地址
        ldr    \irqnr, [ \tmp, #0x14 ]        @ get irq no 取得INTOFFSET寄存器的值，取值范围是0～31哦(其实他的值就代表了主中断号)。
30000:
        teq    \irqnr, #4
        teqne    \irqnr, #5
        beq    1002f                @ external irq reg

EINT4_7  4
EINT8_23 5
主中断号4，5 分别是扩展io主中断，这两个bit之一置位，说明有外io中断发生(我的按键中断就在EINT8_23里)，跳到前面
标号1002处，如果没有，代码向下继续运行。假设  IRQ_EINT0中断(不是EINT4_7，EINT8_23)，那么继续往下走。

        @ debug check to see if interrupt reported is the same
        @ as the offset....

        teq    \irqnr, #0 检查是不是真的有中断发生，如果IRQ_EINT0中断，这里感知不到的
        beq    20002f

如果没有中断发生，跳到前面20002标号处，假如EINT8_23中断，代码继续往下运行。

        ldr    \irqstat, [ \tmp, #0x10 ]    @ INTPND
        mov    \irqstat, \irqstat, lsr \irqnr
        tst    \irqstat, #1
        bne    20002f

取得INTPND寄存器的值，这个寄存器表征了主中断的发生与否，经过以 INTOFFSET右移，测试他的第INTOFFSET bit，看看是不是
真的有中断发生有中断发生，如果第INTOFFSET bit 为1，那么tst的结果为真，也就是不等于0，bne有效，跳到了前面20002出口处，
现在的irqstat表示有无中断了，0：无，1：有。

        /* debug/warning if we get an invalud response from the
         * INTOFFSET register */
#if 1
        stmfd    r13!, { r0 - r4 , r8-r12, r14 }
        ldr    r1,    [ \tmp, #0x14 ]        @ INTOFFSET
        ldr    r2,    [ \tmp, #0x10 ]        @ INTPND
        ldr    r3,    [ \tmp, #0x00 ]        @ SRCPND
        adr    r0, 20003f
        bl    printk
        b    20004f

20003:
        .ascii    "<7>irq: err - bad offset %d, intpnd=%08x, srcpnd=%08x\n"
        .byte    0
        .align    4
20004:
        mov    r1, #1
        mov    \tmp, #S3C24XX_VA_IRQ
        ldmfd    r13!, { r0 - r4 , r8-r12, r14 }
#endif

        @ try working out interrupt number for ourselves
        mov    \irqnr, #0
        ldr    \irqstat, [ \tmp, #0x10 ]    @ INTPND
10021:
        movs    \irqstat, \irqstat, lsr#1
        bcs    30000b        @ try and re-start the proccess
        add    \irqnr, \irqnr, #1
        cmp    \irqnr, #32
        ble    10021b

        @ found no interrupt, set Z flag and leave
        movs    \irqnr, #0
        b    1001f

上面这段是对中断寄存器INTOFFSET指示出错的处理，代码很健壮阿，不感兴趣。

20005:
20002:        @ exit
        @ we base the s3c2410x interrupts at 16 and above to allow
        @ isa peripherals to have their standard interrupts, also
        @ ensure that Z flag is un-set on exit

        @ note, we cannot be sure if we get IRQ_EINT0 (0) that
        @ there is simply no interrupt pending, so in all other
        @ cases we jump to say we have found something, otherwise
        @ we check to see if the interrupt really is assrted
        adds    \irqnr, \irqnr, #IRQ_EINT0
        teq    \irqnr, #IRQ_EINT0
        bne    1001f                @ exit

只要irqnr(INTOFFSET)不是0，就是说有中断发生，那么这里就表示已经找到了中断了，并且将中断号在intoffset的基础上＋16。
16是中断偏移，前16个中断是留给isa peripherals的，然后就出去。

当程序运行到这里时，表示irqnr(INTOFFSET)是0，也就说可能是IRQ_EINT0中断。
        ldr    \irqstat, [ \tmp, #0x10 ]    @ INTPND
        teq    \irqstat, #0
        moveq    \irqnr, #0
        b    1001f
如果这时INTPND为0，表示没有IRQ_EINT0中断，那么将irqnr设为0，退出。否则就表示是IRQ_EINT0中断，这时的中断号为16哦，退出。
其实这里应该总是不相等的，也就是说 “irqnr设为0，退出” 的机会很渺茫的。

        @ we get here from no main or external interrupts pending
1002:

如果到了这里，说明有外io中断(EINT4～EINT23)发生(我的按键中断就在EINT8_23里)，那么识别子中断的过程在这里完成，
现在的内核代码已经不再这样作了。

        add    \tmp, \tmp, #S3C24XX_VA_GPIO - S3C24XX_VA_IRQ @取得gpio IO mem的虚拟地址
        ldr    \irqstat, [ \tmp, # 0xa8 ]    @ EXTINTPEND
        ldr    \irqnr, [ \tmp, # 0xa4 ]    @ EXTINTMASK

        bic    \irqstat, \irqstat, \irqnr    @ clear masked irqs

        mov    \irqnr, #IRQ_EINT4        @ start extint nos
        mov    \irqstat, \irqstat, lsr#4    @ ignore bottom 4 bits
10021:
        movs    \irqstat, \irqstat, lsr#1
        bcs    1004f
        add    \irqnr, \irqnr, #1
        cmp    \irqnr, #IRQ_EINT23
        ble    10021b

        @ found no interrupt, set Z flag and leave
        movs    \irqnr, #0

1004:        @ ensure Z flag clear in case our MOVS shifted out the last bit
        teq    \irqnr, #0
1001:
        @ exit irq routine
        .endm
到这里，子中断(EINT4～EINT23)的识别过程就结束了。可见在这个宏里，中断的识别过程分成了两部分
1。主中断的识别过程
2。EINT4～EINT23次中断的识别过程。

从此以后，系统就调用do_asm_IRQ()来处理中断了，do_asm_IRQ()会根据上面这个宏识别出来的中断号，去调用具体的中断处理例程
比如do_level_IRQ()，do_edge_IRQ()，s3c_irq_demux_uart0()，s3c_irq_demux_adc()等等。中断号可以是0～51（包括
主中断号 和 EINT4～EINT23），而51～68之间的中断号在主中断号上的识别就要靠主中断中的相应demux handler了，他们的识别是第2级识别，
不是在上面的宏里能识别的。

系统的irq中断就是这么给安装的。
调用路径为：start_kernel() -> init_IRQ() -> init_arch_irq() -> s3c24xx_init_irq()


/* s3c24xx_init_irq
 *
 * Initialise S3C2410 IRQ system
*/

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(S3C2410_EINTPEND);

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

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

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

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

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

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

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

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

    /* register the main interrupts */

    irqdbf("s3c2410_init_irq: registering s3c2410 interrupt handlers\n");

    for (irqno = IRQ_BATT_FLT; irqno <= IRQ_ADCPARENT; irqno++) {
        /* set all the s3c2410 internal irqs */

        switch (irqno) {
            /* deal with the special IRQs (cascaded) */

        case IRQ_UART0:
        case IRQ_UART1:
        case IRQ_UART2:
        case IRQ_ADCPARENT:
            set_irq_chip(irqno, &s3c_irq_level_chip);
            set_irq_handler(irqno, do_level_IRQ);
            break;

        case IRQ_RESERVED6:
        case IRQ_RESERVED24:
            /* no IRQ here */
            break;

        default:
            //irqdbf("registering irq %d (s3c irq)\n", irqno);
            set_irq_chip(irqno, &s3c_irq_chip);
            set_irq_handler(irqno, do_edge_IRQ);
            set_irq_flags(irqno, IRQF_VALID);
        }
    }

    /* setup the cascade irq handlers */
//这里就是可以识别的级联的次中断所在的主中断号。asm_do_IRQ()会调用这些函数，以便先识别出来到底是那个中断源发出的次中断
    set_irq_chained_handler(IRQ_UART0, s3c_irq_demux_uart0);
    set_irq_chained_handler(IRQ_UART1, s3c_irq_demux_uart1);
    set_irq_chained_handler(IRQ_UART2, s3c_irq_demux_uart2);
    set_irq_chained_handler(IRQ_ADCPARENT, s3c_irq_demux_adc);


    /* external interrupts */

    for (irqno = IRQ_EINT0; irqno <= IRQ_EINT3; irqno++) {
        irqdbf("registering irq %d (ext int)\n", irqno);
        set_irq_chip(irqno, &s3c_irq_eint0t4);
        set_irq_handler(irqno, do_edge_IRQ);
        set_irq_flags(irqno, IRQF_VALID);
    }

    for (irqno = IRQ_EINT4; irqno <= IRQ_EINT23; irqno++) {
        irqdbf("registering irq %d (extended s3c irq)\n", irqno);
        set_irq_chip(irqno, &s3c_irqext_chip);
        set_irq_handler(irqno, do_edge_IRQ);
        set_irq_flags(irqno, IRQF_VALID);
    }

    /* 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, do_level_IRQ);
        set_irq_flags(irqno, IRQF_VALID);
    }

    for (irqno = IRQ_S3CUART_RX1; irqno <= IRQ_S3CUART_ERR1; irqno++) {
        irqdbf("registering irq %d (s3c uart1 irq)\n", irqno);
        set_irq_chip(irqno, &s3c_irq_uart1);
        set_irq_handler(irqno, do_level_IRQ);
        set_irq_flags(irqno, IRQF_VALID);
    }

    for (irqno = IRQ_S3CUART_RX2; irqno <= IRQ_S3CUART_ERR2; irqno++) {
        irqdbf("registering irq %d (s3c uart2 irq)\n", irqno);
        set_irq_chip(irqno, &s3c_irq_uart2);
        set_irq_handler(irqno, do_level_IRQ);
        set_irq_flags(irqno, IRQF_VALID);
    }

    for (irqno = IRQ_TC; irqno <= IRQ_ADC; irqno++) {
        irqdbf("registering irq %d (s3c adc irq)\n", irqno);
        set_irq_chip(irqno, &s3c_irq_adc);
        set_irq_handler(irqno, do_edge_IRQ);
        set_irq_flags(irqno, IRQF_VALID);
    }

    irqdbf("s3c2410: registered interrupt handlers\n");
}

可以发现，这里没有安装IRQ_EINT4t7，IRQ_EINT8t23，IRQ_CAM 主中断对应的中断handler，
而且对应的handler全是do_level_IRQ，和do_edge_IRQ。
其中
        IRQ_UART0
        IRQ_UART1:
        IRQ_UART2:
        IRQ_ADCPARENT:
用的是电平触发，其他的全是边缘触发。
刚才分析过了IRQ_EINT4t7，IRQ_EINT8t23，可以在get_irqnr_and_base中直接识别出来具体的中断源，
所以IRQ_EINT4t7，IRQ_EINT8t23对应的那个irq_desc[]可以没有handler函数，而IRQ_CAM也没有，这将导致
linux系统不能识别IRQ_CAM中断，从而无法服务camera中断？？？那么当camera需要中断的时候，应该怎么半呢？
这里留下了个疑问。 看晕了，原来
    set_irq_chained_handler(IRQ_UART0, s3c_irq_demux_uart0);
    set_irq_chained_handler(IRQ_UART1, s3c_irq_demux_uart1);
    set_irq_chained_handler(IRQ_UART2, s3c_irq_demux_uart2);
    set_irq_chained_handler(IRQ_ADCPARENT, s3c_irq_demux_adc);
上面的四个句子，会覆盖掉switch语句设置的主中断handler，
这使
switch (irqno) {
            /* deal with the special IRQs (cascaded) */

        case IRQ_UART0:
        case IRQ_UART1:
        case IRQ_UART2:
        case IRQ_ADCPARENT:
            set_irq_chip(irqno, &s3c_irq_level_chip);
            set_irq_handler(irqno, do_level_IRQ);
            break;
这个分支的set_irq_handler显得罗嗦。
而且现在的内核已经把外io中断的具体识别过程放到了demux函数中
    set_irq_chained_handler(IRQ_EINT4t7, s3c_irq_demux_extint4t7);
    set_irq_chained_handler(IRQ_EINT8t23, s3c_irq_demux_extint8);

    set_irq_chained_handler(IRQ_UART0, s3c_irq_demux_uart0);
    set_irq_chained_handler(IRQ_UART1, s3c_irq_demux_uart1);
    set_irq_chained_handler(IRQ_UART2, s3c_irq_demux_uart2);
    set_irq_chained_handler(IRQ_ADCPARENT, s3c_irq_demux_adc);

IRQ_CAM，IRQ_WDT，IRQ_LCD的下面不也是有子中断吗，为什么没有
demux函数呢，以后碰到这个问题在分析了。