struct irq_desc {
    unsigned int        irq;
    struct timer_rand_state *timer_rand_state;
    unsigned int *kstat_irqs;
#ifdef CONFIG_INTR_REMAP
    struct irq_2_iommu *irq_2_iommu;
#endif
    irq_flow_handler_t    handle_irq; // 当前中断的处理函数入口

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

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

unsigned int        status;        //IRQ状态
                ........

const char        *name; //中断的名称

} ____cacheline_internodealigned_in_smp;

struct irq_chip {
    const char    *name;
    unsigned int    (*startup)(unsigned int irq);//启动中断，如果不设置，缺省为“enable
    void        (*shutdown)(unsigned int irq);/*关闭中断，如果不设置，缺省为"disable"*/
    void        (*enable)(unsigned int irq);// 使用中断，如果不设置，缺省为"unmask"
    void        (*disable)(unsigned int irq);//禁止中断，如果不设置，缺省为“mask”
    void        (*ack)(unsigned int irq);/*响应中断，通常是清除当前中断使得可以接收下一个中断*/
    void        (*mask)(unsigned int irq); //屏蔽中断源

void        (*mask_ack)(unsigned int irq);//屏蔽和响应中断

void        (*unmask)(unsigned int irq);//开启中断源

void        (*eoi)(unsigned int irq);
    ........
    const char    *typename;
};

struct irqaction {
    irq_handler_t handler; //用户注册的中断处理函数
    unsigned long flags; //中断标志，比如是否共享中断，电平触发还是边沿触发
    const char *name; //用户注册的中断名字
    void *dev_id; //用户传给上面的handler的参数，还可以用来区分共享中断
    struct irqaction *next; //指向下一个用户注册函数的指针
    int irq; //中断号
    struct proc_dir_entry *dir;
    irq_handler_t thread_fn;
    struct task_struct *thread;
    unsigned long thread_flags;
};

153 void __init init_IRQ(void)
154 {
155 int irq;
156
157 for (irq = 0; irq < NR_IRQS; irq++)
158 irq_desc[irq].status |= IRQ_NOREQUEST | IRQ_NOPROBE;
159
160 init_arch_irq();
161 }


void __init s3c24xx_init_irq(void)
534 {
535 unsigned long pend;
536 unsigned long last;
537 int irqno;
538 int i;
........
637 for (irqno = IRQ_EINT4; irqno <= IRQ_EINT23; irqno++) {
638 irqdbf("registering irq %d (extended s3c irq)\n", irqno);
639 set_irq_chip(irqno, &s3c_irqext_chip);
640 set_irq_handler(irqno, handle_edge_irq);
641 set_irq_flags(irqno, IRQF_VALID);

...............
655 for (irqno = IRQ_S3CUART_RX1; irqno <= IRQ_S3CUART_ERR1; irqno++) {
656 irqdbf("registering irq %d (s3c uart1 irq)\n", irqno);
657 set_irq_chip(irqno, &s3c_irq_uart1);
658 set_irq_handler(irqno, handle_level_irq);
659 set_irq_flags(irqno, IRQF_VALID);
660 }
..........
676 irqdbf("s3c2410: registered interrupt handlers\n");
677 }
678

110 #ifdef CONFIG_GENERIC_HARDIRQS
111 extern int __must_check
112 request_threaded_irq(unsigned int irq, irq_handler_t handler,
113 irq_handler_t thread_fn,
114 unsigned long flags, const char *name, void *dev);
115
116 static inline int __must_check
117 request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
118 const char *name, void *dev)
119 {
120 return request_threaded_irq(irq, handler, NULL, flags, name, dev);
121 }
123 extern void exit_irq_thread(void);
124 #else
126 extern int __must_check
127 request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
128 const char *name, void *dev);
136 static inline int __must_check
137 request_threaded_irq(unsigned int irq, irq_handler_t handler,
138 irq_handler_t thread_fn,
139 unsigned long flags, const char *name, void *dev)
140 {
141 return request_irq(irq, handler, flags, name, dev);
142 }
143
144 static inline void exit_irq_thread(void) { }
145 #endif


1003 int request_threaded_irq(unsigned int irq, irq_handler_t handler,
1004 irq_handler_t thread_fn, unsigned long irqflags,
                          const char *devname, void *dev_id)
.............
1056 action->handler = handler;
1057 action->thread_fn = thread_fn;
1058 action->flags = irqflags;
1059 action->name = devname;
1060 action->dev_id = dev_id;
1061
1062 chip_bus_lock(irq, desc);
1084 local_irq_restore(flags);
1085 enable_irq(irq);
...........
1088 return retval;
1089 }
1090 EXPORT_SYMBOL(request_threaded_irq);

296 void irq_chip_set_defaults(struct irq_chip *chip)
297 {
298 if (!chip->enable)
299 chip->enable = default_enable;//调用chip->unmask
300 if (!chip->disable)
301 chip->disable = default_disable;//此函数为空
302 if (!chip->startup)
303 chip->startup = default_startup;//调用chip->enable
310 if (!chip->shutdown)
311 chip->shutdown = chip->disable != default_disable ?
312 chip->disable : default_shutdown;
313 if (!chip->name)
314 chip->name = chip->typename;
315 if (!chip->end)
316 chip->end = dummy_irq_chip.end;
317 }


106 asmlinkage void __exception asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
107 {
108 struct pt_regs *old_regs = set_irq_regs(regs);
109
110 irq_enter();
111
112 /*
113 * Some hardware gives randomly wrong interrupts. Rather
114 * than crashing, do something sensible.
115 */
116 if (unlikely(irq >= NR_IRQS)) {
117 if (printk_ratelimit())
118 printk(KERN_WARNING "Bad IRQ%u\n", irq);
119 ack_bad_irq(irq);
120 } else {
121 generic_handle_irq(irq);
122 }
123
124 /* AT91 specific workaround */
125 irq_finish(irq);
126
127 irq_exit();
128 set_irq_regs(old_regs);
129 }


453 s3c_irq_demux_extint8(unsigned int irq,
454 struct irq_desc *desc)
455 {
456 unsigned long eintpnd = __raw_readl(S3C24XX_EINTPEND); //EINT8-EINT23 发生时，相应位被置1

457 unsigned long eintmsk = __raw_readl(S3C24XX_EINTMASK);//屏蔽寄存器

458
459 eintpnd &= ~eintmsk; //清除被屏蔽的位

460 eintpnd &= ~0xff; /* 清除低8位（EINT8对应位8）ignore lower irqs */
461
462 /* 循环处理所有子中断*/
463
464 while (eintpnd) {
465 irq = __ffs(eintpnd); //确定eintpnd中为1的最高位

466 eintpnd &= ~(1<<irq); //将此们清0

467
468 irq += (IRQ_EINT4 - 4);//重新计算中断号，前面计算出irq等于8时，中断号为

IRQ_EINT8
469 generic_handle_irq(irq);//调用这中断的真正的处理函数

470 }
471
472 }
void


531 handle_edge_irq(unsigned int irq, struct irq_desc *desc)
532 {
533 spin_lock(&desc->lock);
534
535 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
536
537 /*
538 * If we're currently running this IRQ, or its disabled,
539 * we shouldn't process the IRQ. Mark it pending, handle
540 * the necessary masking and go out
541 */
542 if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
543 !desc->action)) {
544 desc->status |= (IRQ_PENDING | IRQ_MASKED);
545 mask_ack_irq(desc, irq);
546 goto out_unlock;
547 }
548 kstat_incr_irqs_this_cpu(irq, desc);
549
550 /* Start handling the irq */
551 if (desc->chip->ack)
552 desc->chip->ack(irq);
553
554 /* Mark the IRQ currently in progress.*/
555 desc->status |= IRQ_INPROGRESS;
556
557 do {
558 struct irqaction *action = desc->action;
559 irqreturn_t action_ret;
560
561 if (unlikely(!action)) {
562 desc->chip->mask(irq);
563 goto out_unlock;
564 }
565
566 /*
567 * When another irq arrived while we were handling
568 * one, we could have masked the irq.
569 * Renable it, if it was not disabled in meantime.
570 */
571 if (unlikely((desc->status &
572 (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
573 (IRQ_PENDING | IRQ_MASKED))) {
574 desc->chip->unmask(irq);
575 desc->status &= ~IRQ_MASKED;
576 }
577
578 desc->status &= ~IRQ_PENDING;
579 spin_unlock(&desc->lock);
580 action_ret = handle_IRQ_event(irq, action);
581 if (!noirqdebug)
582 note_interrupt(irq, desc, action_ret);
583 spin_lock(&desc->lock);
584
585 } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
586
587 desc->status &= ~IRQ_INPROGRESS;
588 out_unlock:
589 spin_unlock(&desc->lock);
590 }
591


do {
379 trace_irq_handler_entry(irq, action);
380 ret = action->handler(irq, action->dev_id);//执行用户注册的中断处理函数

381 trace_irq_handler_exit(irq, action, ret);
382
383 switch (ret) {
384 case IRQ_WAKE_THREAD:
385 /*
386 * Set result to handled so the spurious check
387 * does not trigger.
388 */
389 ret = IRQ_HANDLED;
390
391 /*
392 * Catch drivers which return WAKE_THREAD but
393 * did not set up a thread function
394 */
395 if (unlikely(!action->thread_fn)) {
396 warn_no_thread(irq, action);
397 break;
398 }
399
400 /*
408 if (likely(!test_bit(IRQTF_DIED,
409 &action->thread_flags))) {
410 set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
411 wake_up_process(action->thread);
412 }
413
414 /* Fall through to add to randomness */
415 case IRQ_HANDLED:
416 status |= action->flags;
417 break;
418
419 default:
420 break;
421 }
422
423 retval |= ret;
424 action = action->next; //下一个

425 } while (action);