linuxBSPmini2440中断管理

 

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)


#define IRQ_EINT0      S3C2410_IRQ(0)       
#define IRQ_EINT1      S3C2410_IRQ(1)
#define IRQ_EINT2      S3C2410_IRQ(2)
#define IRQ_EINT3      S3C2410_IRQ(3)
#define IRQ_EINT4t7    S3C2410_IRQ(4)       
#define IRQ_EINT8t23   S3C2410_IRQ(5)
#define IRQ_RESERVED6  S3C2410_IRQ(6)       
#define IRQ_CAM        S3C2410_IRQ(6)       
#define IRQ_BATT_FLT   S3C2410_IRQ(7)
#define IRQ_TICK       S3C2410_IRQ(8)       
#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)       
#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)       
#define IRQ_NFCON      S3C2410_IRQ(24)       
#define IRQ_USBD       S3C2410_IRQ(25)
#define IRQ_USBH       S3C2410_IRQ(26)
#define IRQ_IIC           S3C2410_IRQ(27)
#define IRQ_UART0      S3C2410_IRQ(28)       
#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个中断源之一。次中断组织如下。


#define IRQ_EINT4      S3C2410_IRQ(32)      
#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)      
#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)


#define IRQ_S3CUART_RX0  S3C2410_IRQ(54)  
#define IRQ_S3CUART_TX0  S3C2410_IRQ(55)  
#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)



#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:

    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：有。

       
#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=x, srcpnd=x\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()

start_kernel()函数 (在文件init/main.c中定义)中可以看到：

asmlinkage void __init start_kernel(void)

{

……

   trap_init();

……

   early_irq_init();

   init_IRQ();

……

}

start_kernel()函数调用trap_init()、early_irq_init()和init_IRQ()三个函数来初始化中断管理系统。对于我们的ARM平台来说trap_init()在arch/arm/kernel/traps.c中定义，为一个空函数。

early_irq_init()函数

在start_kernel()函数中调用了early_irq_init()函数，这个函数在kernel/handle.c文件中定义。kernel/handle.c文件中，根据内核配置时是否选择了CONFIG_SPARSE_IRQ，而可以选择两个不同版本的该函数early_irq_init()中的一个进行编译。CONFIG_SPARSE_IRQ配置项，用于支持稀疏irq号，对于发行版的内核很有用，它允许定义一个高CONFIG_NR_CPUS值，但仍然不希望消耗太多内存的情况。对于我们的开发板来说，自然不需要打开这个配置项。

early_irq_init()函数定义如下：

---------------------------------------------------------------------

int __init early_irq_init(void)

{

   struct irq_desc *desc;

   int count;

   int i;

   init_irq_default_affinity();

   printk(KERN_INFO "NR_IRQS:%d\n", NR_IRQS);

   desc = irq_desc;

   count = ARRAY_SIZE(irq_desc);

   for (i = 0; i < count; i++) {

      desc[i].irq = i;

      alloc_desc_masks(&desc[i], 0, true);

      init_desc_masks(&desc[i]);

      desc[i].kstat_irqs = kstat_irqs_all[i];

   }

   return arch_early_irq_init();

}

---------------------------------------------------------------------

主要工作即为初始化用于管理中断的irq_desc[NR_IRQS]数组的每个元素，它主要设置数组中每一个成员的中断号，使得数组中每一个元素的kstat_irqs字段（irq stats per cpu），指向定义的二维数组中的对应的行。alloc_desc_masks(&desc[i], 0, true)和init_desc_masks(&desc[i])函数在非SMP平台上为空函数。arch_early_irq_init()在主要用于x86平台和PPC平台，其他平台上为空函数。

init_IRQ()函数

init_IRQ(void)函数是一个特定于体系结构的函数，对于ARM体系结构来说该函数定义如下：

---------------------------------------------------------------------

arch/arm/kernel/irq.c

void __init init_IRQ(void)
{
 int irq;

 for (irq = 0; irq < NR_IRQS; irq++)
  irq_desc[irq].status |= IRQ_NOREQUEST | IRQ_NOPROBE;

 init_arch_irq();
}

---------------------------------------------------------------------

我们看到这个函数将irq_desc[NR_IRQS]结构数组各个元素的状态字段设置为IRQ_NOREQUEST | IRQ_NOPROBE，也就是未请求和未探测状态。然后调用特定机器平台的中断初始化init_arch_irq()函数。而init_arch_irq()实际上是一个函数指针，其定义如下：

---------------------------------------------------------------------

arch/arm/kernel/irq.c

50 void (*init_arch_irq)(void) __initdata = NULL;

---------------------------------------------------------------------

setup_arch()函数初始化init_arch_irq函数指针变量我们知道，对于我们的mini2440开发板，这个函数指针指向的函数为s3c24xx_init_irq()函数，该函数定义如下在arch/arm/plat-s3c24xx/irq.c中定义：

---------------------------------------------------------------------

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

#ifdef CONFIG_FIQ
 init_FIQ();
#endif

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

 

 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 x\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 x\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 x\n", (int)pend);
  __raw_writel(pend, S3C2410_SUBSRCPND);
  last = pend;
 }

 

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

 for (irqno = IRQ_EINT4t7; irqno <= IRQ_ADCPARENT; irqno++) {
  

  switch (irqno) {
   

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

  case IRQ_RESERVED6:
  case IRQ_RESERVED24:
   
   break;

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

 

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

 

 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, handle_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, handle_edge_irq);
  set_irq_flags(irqno, IRQF_VALID);
 }

 

 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);
  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, handle_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, handle_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, handle_edge_irq);
  set_irq_flags(irqno, IRQF_VALID);
 }

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

---------------------------------------------------------------------

话说这个函数看上去挺长的，但好像没有什么难以理解的地方，它完成对的主要工作如下：

1、清除外部中断的中断挂起位。读取中断挂起寄存器的内容，并将该内容重新写入中断挂起寄存器（将相应位写入1，可以清除相应的位，更详细的情况可以参考手册）

2、清除中断的中断挂起位。

3、清除子中断源的中断挂起位。

4、进一步的完成irq_desc[NR_IRQS]结构数组的初始化，主要为设置元素的chip字段和handle_irq字段（高层中断处理程序）和标志字段。设置的内容，则因中断类型的不同而不同。

s3c24xx_init_irq()函数调用的用于设置irq_desc结构体的许多相关的函数。先看set_irq_chip()函数，在文件kernel/irq/chip.c中定义：

---------------------------------------------------------------------

kernel/irq/chip.c

128 int set_irq_chip(unsigned int irq, struct irq_chip *chip)

129 {

130   struct irq_desc *desc = irq_to_desc(irq);

131   unsigned long flags;

132

133   if (!desc) {

134        WARN(1, KERN_ERR "Trying to install chip for IRQ%d\n", irq);

135        return -EINVAL;

136   }

137

138   if (!chip)

139        chip = &no_irq_chip;

140

141   raw_spin_lock_irqsave(&desc->lock, flags);

142   irq_chip_set_defaults(chip);

143   desc->chip = chip;

144   raw_spin_unlock_irqrestore(&desc->lock, flags);

145

146   return 0;

147 }

148 EXPORT_SYMBOL(set_irq_chip);

---------------------------------------------------------------------

这个函数为一个irq设置irq chip。它接收两个参数，irq为中断号，chip则为指向irq chip描述结构的指针。这个函数会首先调用irq_to_desc(irq)来获得相应中断号的中断描述符的指针，然后调用irq_chip_set_defaults(chip)来对做进一步的完善，即对于某些不能为空的成员，则使其指向默认的处理函数。最后设置中断描述符的chip字段为传进来的chip参数，以在中断发生或者管理中断时可以完成对于PIC的操作。

对于IRQ_EINT4t7、IRQ_EINT8t23、IRQ_UART0、IRQ_UART1、IRQ_UART2和IRQ_ADCPARENT等有多个子中断源的中断，其chip设置为s3c_irq_level_chip，其定义如下：

arch/arm/plat-s3c24xx/irq.c

struct irq_chip s3c_irq_level_chip = {
 .name  = "s3c-level",
 .ack  = s3c_irq_maskack,
 .mask  = s3c_irq_mask,
 .unmask  = s3c_irq_unmask,
 .set_wake = s3c_irq_wake
};

对于其他中断线，这其chip被设为s3c_irq_chip：

struct irq_chip s3c_irq_chip = {
 .name  = "s3c",
 .ack  = s3c_irq_ack,
 .mask  = s3c_irq_mask,
 .unmask  = s3c_irq_unmask,
 .set_wake = s3c_irq_wake
};

接着看set_irq_handler()函数，其定义如下：

include/linux/irq.h

static inline void
set_irq_handler(unsigned int irq, irq_flow_handler_t handle)
{
 __set_irq_handler(irq, handle, 0, NULL);
}

_set_irq_handler()只是对set_irq_handler()的封装。

这个函数用于设置给定的IRQ的高层处理程序。它仅仅是对于__set_irq_handler()函数的一个封装。__set_irq_handler()函数定义如下：

include/linux/irq.h

void
__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
    const char *name)
{
 struct irq_desc *desc = irq_to_desc(irq);
 unsigned long flags;

 if (!desc) {
  printk(KERN_ERR
         "Trying to install type control for IRQ%d\n", irq);
  return;
 }

 if (!handle)
  handle = handle_bad_irq;
 else if (desc->chip == &no_irq_chip) {
  printk(KERN_WARNING "Trying to install %sinterrupt handler "
         "for IRQ%d\n", is_chained ? "chained " : "", irq);
  
  desc->chip = &dummy_irq_chip;
 }

 chip_bus_lock(irq, desc);
 spin_lock_irqsave(&desc->lock, flags);

 
 if (handle == handle_bad_irq) {
  if (desc->chip != &no_irq_chip)
   mask_ack_irq(desc, irq);
  desc->status |= IRQ_DISABLED;
  desc->depth = 1;
 }
 desc->handle_irq = handle;
 desc->name = name;

 if (handle != handle_bad_irq && is_chained) {
  desc->status &= ~IRQ_DISABLED;
  desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
  desc->depth = 0;
  desc->chip->startup(irq);
 }
 spin_unlock_irqrestore(&desc->lock, flags);
 chip_bus_sync_unlock(irq, desc);
}

这个函数就是为特定的中断线设置好一个高层的中断处理例程，这里的处理例程可不是我们调用request_irq()时注册的中断处理例程。这个函数完成如下工作：

1、调用irq_to_desc(irq)获得相应中断号对应的irq_desc结构体的指针。

2、检查传递进来的handle参数，若为空，则设为handle_bad_irq；检查中断描述符的chip字段，若未设置，则设为dummy_irq_chip。

3、获取自旋锁，并在局部变量flags中保存标志。

4、检查handle，若为handle_bad_irq，即未安装，则屏蔽该中断，设置中断描述符状态字段的IRQ_DISABLED位，并设置中断描述符的depth为1。

5、设置中断描述符的handle_irq为handle，并设置中断描述符的name字段为传递进来的name参数。

6、如果传递进来的handle为有效值，同时传递进来的is_chained非零，则清除中断描述符status字段的IRQ_DISABLED，并设置IRQ_NOREQUEST、IRQ_NOPROBE位。设置中断描述符的depth为0。并对中断号调用desc->chip->startup(irq)。

7、释放自旋锁并恢复保存的标志flags。

该函数主要是为特定的中断号对应的中断描述符设置相应的状态标记，而s3c24xx_init_irq()函数里我们调用它的主要目的就是清掉IRQ_NOREQUEST标记，告诉系，该中断已经可以被申请使用了，中断在申请的时候会查看是否有IRQ_NOREQUEST标记，如有则表面该中断还不能使用。而初始化的时候所有的中断都有这个标记。

最后来看set_irq_chained_handler，其定义如下：

tatic inline void
set_irq_chained_handler(unsigned int irq,
   irq_flow_handler_t handle)
{
 __set_irq_handler(irq, handle, 1, NULL);
}

这个函数同样也是__set_irq_handler()函数的封装，所不同的是，这个封装在调用__set_irq_handler()函数时第三个参数is_chained传递的是1，而不是0。在前面我们看到，其差别就是set_irq_chained_handler()在handle参数有效时，会直接清除中断描述符的status字段的IRQ_DISABLED位，以表示相应的中断线可用。

在s3c24xx_init_irq()函数中，我们看到只有为几个中断线设置高层中断处理程序时使用的是set_irq_chained_handler()以使相应的中断线直接可用，这几个中断线分别是 IRQ_EINT4t7、IRQ_EINT8t23、IRQ_UART0、IRQ_UART1、IRQ_UART2和IRQ_ADCPARENT，这与中断控制器有关，这几个中断线的每一个都关联着好几个子中断源。另外，也只有为这几个中断线设置时传递的handle参数为比较独特，因为这几个中断线有几个中断源，当IRQ_EINT4t7、IRQ_EINT8t23、IRQ_UART0、IRQ_UART1、IRQ_UART2和IRQ_ADCPARENT中的一个或几个发生了中断时，还需通过handle传递的函数判断具体的中断源。而其他的则均为handle_edge_irq。