linux 中断处理(基于linux-3.7.2 arm linux)

所有中断入口都是由异常向量，再到中断向量的
汇编到C的中断入口asm_do_IRQ

arch/arm/kernel/irq.c
 86 /*
 87  * asm_do_IRQ is the interface to be used from assembly code.
 88  */
 89 asmlinkage void __exception_irq_entry
 90 asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
 91 {
 92         handle_IRQ(irq, regs);
 93 }
 在同一文件中
 58 /*
 59  * handle_IRQ handles all hardware IRQ's.  Decoded IRQs should
 60  * not come via this function.  Instead, they should provide their
 61  * own 'handler'.  Used by platform code implementing C-based 1st
 62  * level decoding.
 63  */
 64 void handle_IRQ(unsigned int irq, struct pt_regs *regs)
 65 {
 66         struct pt_regs *old_regs = set_irq_regs(regs);
 67
 68         irq_enter();
 69
 70         /*
 71          * Some hardware gives randomly wrong interrupts.  Rather
 72          * than crashing, do something sensible.
 73          */
 74         if (unlikely(irq >= nr_irqs)) {
 75                 if (printk_ratelimit())
 76                         printk(KERN_WARNING "Bad IRQ%u\n", irq);
 77                 ack_bad_irq(irq);
 78         } else {
 79                 generic_handle_irq(irq);
 80         }
 81
 82         irq_exit();
 83         set_irq_regs(old_regs);
 84 }
可以看到调用了handle_IRQ后又调用了generic_handle_irq(irq);
kernel/irq/irqdesc.c
303 /**
304  * generic_handle_irq - Invoke the handler for a particular irq
305  * @irq:        The irq number to handle
306  *
307  */
308 int generic_handle_irq(unsigned int irq)
309 {
310         struct irq_desc *desc = irq_to_desc(irq);
311
312         if (!desc)
313                 return -EINVAL;
314         generic_handle_irq_desc(irq, desc);
315         return 0;
316 }
317 EXPORT_SYMBOL_GPL(generic_handle_irq);

include/linux/irqdesc.h
/*
 * Architectures call this to let the generic IRQ layer
 * handle an interrupt. If the descriptor is attached to an
 * irqchip-style controller then we call the ->handle_irq() handler,
 * and it calls __do_IRQ() if it's attached to an irqtype-style controller.
 */
static inline void generic_handle_irq_desc(unsigned int irq, struct irq_desc *desc)
{
        desc->handle_irq(irq, desc);
}
是通过irq_desc 结构体的handle_irq函数调用的，这个函数应该在哪里注册才对

中断初始化
115 void __init init_IRQ(void)
116 {
117         machine_desc->init_irq();
118 }

异常向量表
arch/arm/kernel/entry-armv.S
1163         .globl  __vectors_start
1164 __vectors_start:
1165  ARM(   swi     SYS_ERROR0      )
1166  THUMB( svc     #0              )
1167  THUMB( nop                     )
1168         W(b)    vector_und + stubs_offset
1169         W(ldr)  pc, .LCvswi + stubs_offset
1170         W(b)    vector_pabt + stubs_offset
1171         W(b)    vector_dabt + stubs_offset
1172         W(b)    vector_addrexcptn + stubs_offset
1173         W(b)    vector_irq + stubs_offset
1174         W(b)    vector_fiq + stubs_offset
中断向量的拷贝
arch/arm/kernel/traps.c
820 void __init early_trap_init(void *vectors_base)
821 {
822         unsigned long vectors = (unsigned long)vectors_base;
823         extern char __stubs_start[], __stubs_end[];
824         extern char __vectors_start[], __vectors_end[];
825         extern char __kuser_helper_start[], __kuser_helper_end[];
826         int kuser_sz = __kuser_helper_end - __kuser_helper_start;
827
828         vectors_page = vectors_base;
829
830         /*
831          * Copy the vectors, stubs and kuser helpers (in entry-armv.S)
832          * into the vector page, mapped at 0xffff0000, and ensure these
833          * are visible to the instruction stream.
834          */
835         memcpy((void *)vectors, __vectors_start, __vectors_end - __vectors_start);
836         memcpy((void *)vectors + 0x200, __stubs_start, __stubs_end - __stubs_start);
837         memcpy((void *)vectors + 0x1000 - kuser_sz, __kuser_helper_start, kuser_sz);
838
839         /*
840          * Do processor specific fixups for the kuser helpers
841          */
842         kuser_get_tls_init(vectors);
843
844         /*
845          * Copy signal return handlers into the vector page, and
846          * set sigreturn to be a pointer to these.
847          */
848         memcpy((void *)(vectors + KERN_SIGRETURN_CODE - CONFIG_VECTORS_BASE),
849                sigreturn_codes, sizeof(sigreturn_codes));
850
851         flush_icache_range(vectors, vectors + PAGE_SIZE);
852         modify_domain(DOMAIN_USER, DOMAIN_CLIENT);
853 }

arch/arm/mm/mmu.c
1085 /*
1086  * Set up the device mappings.  Since we clear out the page tables for all
1087  * mappings above VMALLOC_START, we will remove any debug device mappings.
1088  * This means you have to be careful how you debug this function, or any
1089  * called function.  This means you can't use any function or debugging
1090  * method which may touch any device, otherwise the kernel _will_ crash.
1091  */
1092 static void __init devicemaps_init(struct machine_desc *mdesc)
1093 {
1094         struct map_desc map;
1095         unsigned long addr;
1096         void *vectors;
1097
1098         /*
1099          * Allocate the vector page early.
1100          */
1101         vectors = early_alloc(PAGE_SIZE);
1102
1103         early_trap_init(vectors);
…………
由这里调用early_trap_init
在同一文件中paging_init调用 devicemaps_init
1207 /*
1208  * paging_init() sets up the page tables, initialises the zone memory
1209  * maps, and sets up the zero page, bad page and bad page tables.
1210  */
1211 void __init paging_init(struct machine_desc *mdesc)
1212 {
1213         void *zero_page;
1214
1215         memblock_set_current_limit(arm_lowmem_limit);
1216
1217         build_mem_type_table();
1218         prepare_page_table();
1219         map_lowmem();
1220         dma_contiguous_remap();
1221         devicemaps_init(mdesc);
1222         kmap_init();
1223
1224         top_pmd = pmd_off_k(0xffff0000);
1225
1226         /* allocate the zero page. */
1227         zero_page = early_alloc(PAGE_SIZE);
1228
1229         bootmem_init();
1230
1231         empty_zero_page = virt_to_page(zero_page);
1232         __flush_dcache_page(NULL, empty_zero_page);
1233 }

arch/arm/kernel/setup.c
722 void __init setup_arch(char **cmdline_p)
723 {
724         struct machine_desc *mdesc;
725
726         setup_processor();
727         mdesc = setup_machine_fdt(__atags_pointer);
728         if (!mdesc)
729                 mdesc = setup_machine_tags(__atags_pointer, machine_arch_type);
730         machine_desc = mdesc;
731         machine_name = mdesc->name;
732
733         setup_dma_zone(mdesc);
734
735         if (mdesc->restart_mode)
736                 reboot_setup(&mdesc->restart_mode);
737
738         init_mm.start_code = (unsigned long) _text;
739         init_mm.end_code   = (unsigned long) _etext;
740         init_mm.end_data   = (unsigned long) _edata;
741         init_mm.brk        = (unsigned long) _end;
742
743         /* populate cmd_line too for later use, preserving boot_command_line */
744         strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
745         *cmdline_p = cmd_line;
746
747         parse_early_param();
748
749         sort(&meminfo.bank, meminfo.nr_banks, sizeof(meminfo.bank[0]), meminfo_cmp, NULL);
750         sanity_check_meminfo();
751         arm_memblock_init(&meminfo, mdesc);
752
753         paging_init(mdesc);  
在setup_arch调用了 paging_init

setup_arch由start_kernel调用
init/main.c
468 asmlinkage void __init start_kernel(void)
469 {
……
499         setup_arch(&command_line);
…………
}

include/linux/interrupt.h
中断注册函数
129 static inline int __must_check
130 request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
131             const char *name, void *dev)
132 {
133         return request_threaded_irq(irq, handler, NULL, flags, name, dev);
134 }
kernel/irq/manage.c
1376 int request_threaded_irq(unsigned int irq, irq_handler_t handler,
1377                          irq_handler_t thread_fn, unsigned long irqflags,
1378                          const char *devname, void *dev_id)
1379 {
1380         struct irqaction *action;
1381         struct irq_desc *desc;
1382         int retval;
1383
1384         /*
1385          * Sanity-check: shared interrupts must pass in a real dev-ID,
1386          * otherwise we'll have trouble later trying to figure out
1387          * which interrupt is which (messes up the interrupt freeing
1388          * logic etc).
1389          */
1390         if ((irqflags & IRQF_SHARED) && !dev_id)
1391                 return -EINVAL;
1392
1393         desc = irq_to_desc(irq);
1394         if (!desc)
1395                 return -EINVAL;
1396
1397         if (!irq_settings_can_request(desc) ||
1398             WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1399                 return -EINVAL;
1400
1401         if (!handler) {
1402                 if (!thread_fn)
1403                         return -EINVAL;
1404                 handler = irq_default_primary_handler;
1405         }
1406
1407         action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
1408         if (!action)
1409                 return -ENOMEM;
1410
1411         action->handler = handler;
1412         action->thread_fn = thread_fn;
1413         action->flags = irqflags;
1414         action->name = devname;
1415         action->dev_id = dev_id;
1416
1417         chip_bus_lock(desc);
1418         retval = __setup_irq(irq, desc, action);
1419         chip_bus_sync_unlock(desc);

在这里，将申请的中断与struct irqaction *action;关联
__setup_irq将action与desc中的irq_handler进行关联
111 struct irq_desc *irq_to_desc(unsigned int irq)
112 {
113         return radix_tree_lookup(&irq_desc_tree, irq);
114 }
115 EXPORT_SYMBOL(irq_to_desc);
include/linux/irqnr.h
 14 #define irq_to_desc(irq)        (&irq_desc[irq])
kernel/irq/irqdesc.c
243 struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
244         [0 ... NR_IRQS-1] = {
245                 .handle_irq     = handle_bad_irq,
246                 .depth          = 1,
247                 .lock           = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),
248         }
249 };

include/linux/interrupt.h
106 struct irqaction {
107         irq_handler_t           handler;
108         void                    *dev_id;
109         void __percpu           *percpu_dev_id;
110         struct irqaction        *next;
111         irq_handler_t           thread_fn;
112         struct task_struct      *thread;
113         unsigned int            irq;
114         unsigned int            flags;
115         unsigned long           thread_flags;
116         unsigned long           thread_mask;
117         const char              *name;
118         struct proc_dir_entry   *dir;
119 } ____cacheline_internodealigned_in_smp;
这个结构体就是用户中断处理函数关联入的地方
例子:定时器中就是利用setup_irq(irq_number, &s5p_clock_event_irq);函数将用户中断链入
252 static struct irqaction s5p_clock_event_irq = {
253         .name           = "s5p_time_irq",
254         .flags          = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
255         .handler        = s5p_clock_event_isr,
256         .dev_id         = &time_event_device,
257 };

 

kernel/irq/chip.c
462 /**
463  *      handle_edge_irq - edge type IRQ handler
464  *      @irq:   the interrupt number
465  *      @desc:  the interrupt description structure for this irq
466  *
467  *      Interrupt occures on the falling and/or rising edge of a hardware
468  *      signal. The occurrence is latched into the irq controller hardware
469  *      and must be acked in order to be reenabled. After the ack another
470  *      interrupt can happen on the same source even before the first one
471  *      is handled by the associated event handler. If this happens it
472  *      might be necessary to disable (mask) the interrupt depending on the
473  *      controller hardware. This requires to reenable the interrupt inside
474  *      of the loop which handles the interrupts which have arrived while
475  *      the handler was running. If all pending interrupts are handled, the
476  *      loop is left.
477  */
478 void
479 handle_edge_irq(unsigned int irq, struct irq_desc *desc)
480 {
…………
519                 handle_irq_event(desc);
…………
359 /**
360  *      handle_level_irq - Level type irq handler
361  *      @irq:   the interrupt number
362  *      @desc:  the interrupt description structure for this irq
363  *
364  *      Level type interrupts are active as long as the hardware line has
365  *      the active level. This may require to mask the interrupt and unmask
366  *      it after the associated handler has acknowledged the device, so the
367  *      interrupt line is back to inactive.
368  */
369 void
370 handle_level_irq(unsigned int irq, struct irq_desc *desc)
371 {
372         raw_spin_lock(&desc->lock);
373         mask_ack_irq(desc);
374
375         if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
376                 if (!irq_check_poll(desc))
377                         goto out_unlock;
378
379         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
380         kstat_incr_irqs_this_cpu(irq, desc);
381
382         /*
383          * If its disabled or no action available
384          * keep it masked and get out of here
385          */
386         if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
387                 desc->istate |= IRQS_PENDING;
388                 goto out_unlock;
389         }
390
391         handle_irq_event(desc);
392
393         cond_unmask_irq(desc);
394
395 out_unlock:
396         raw_spin_unlock(&desc->lock);
397 }
398 EXPORT_SYMBOL_GPL(handle_level_irq);

kernel/irq/handle.c
182 irqreturn_t handle_irq_event(struct irq_desc *desc)
183 {
184         struct irqaction *action = desc->action;
185         irqreturn_t ret;
186
187         desc->istate &= ~IRQS_PENDING;
188         irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
189         raw_spin_unlock(&desc->lock);
190
191         ret = handle_irq_event_percpu(desc, action);
192
193         raw_spin_lock(&desc->lock);
194         irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
195         return ret;
196 }

kernel/irq/handle.c
132 irqreturn_t
133 handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
134 {
135         irqreturn_t retval = IRQ_NONE;
136         unsigned int flags = 0, irq = desc->irq_data.irq;
137
138         do {
139                 irqreturn_t res;
140
141                 trace_irq_handler_entry(irq, action);
142                 res = action->handler(irq, action->dev_id);
143                 trace_irq_handler_exit(irq, action, res);
144
145                 if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
146                               irq, action->handler))
147                         local_irq_disable();
148
149                 switch (res) {
150                 case IRQ_WAKE_THREAD:
151                         /*
152                          * Catch drivers which return WAKE_THREAD but
153                          * did not set up a thread function
154                          */
155                         if (unlikely(!action->thread_fn)) {
156                                 warn_no_thread(irq, action);
157                                 break;
158                         }
159
160                         irq_wake_thread(desc, action);
161
162                         /* Fall through to add to randomness */
163                 case IRQ_HANDLED:
164                         flags |= action->flags;
165                         break;
166
167                 default:
168                         break;
169                 }
170
171                 retval |= res;
172                 action = action->next;
173         } while (action);
174
最终会调用到142行的res = action->handler(irq, action->dev_id);

include/linux/irqdesc.h
38 struct irq_desc {
 39         struct irq_data         irq_data;
 40         unsigned int __percpu   *kstat_irqs;
 41         irq_flow_handler_t      handle_irq;
 42 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI
 43         irq_preflow_handler_t   preflow_handler;
 44 #endif
 45         struct irqaction        *action;        /* IRQ action list */
 46         unsigned int            status_use_accessors;
 47         unsigned int            core_internal_state__do_not_mess_with_it;
 48         unsigned int            depth;          /* nested irq disables */
 49         unsigned int            wake_depth;     /* nested wake enables */
 50         unsigned int            irq_count;      /* For detecting broken IRQs */
 51         unsigned long           last_unhandled; /* Aging timer for unhandled count */
 52         unsigned int            irqs_unhandled;
 53         raw_spinlock_t          lock;
 54         struct cpumask          *percpu_enabled;
 55 #ifdef CONFIG_SMP
 56         const struct cpumask    *affinity_hint;
 57         struct irq_affinity_notify *affinity_notify;
 58 #ifdef CONFIG_GENERIC_PENDING_IRQ
 59         cpumask_var_t           pending_mask;
 60 #endif
 61 #endif
 62         unsigned long           threads_oneshot;
 63         atomic_t                threads_active;
 64         wait_queue_head_t       wait_for_threads;
 65 #ifdef CONFIG_PROC_FS
 66         struct proc_dir_entry   *dir;
 67 #endif
 68         struct module           *owner;
 69         const char              *name;
 70 } ____cacheline_internodealigned_in_smp;

arch/arm/plat-samsung/s5p-irq-eint.c
202 static int __init s5p_init_irq_eint(void)
203 {
204         int irq;
205
206         for (irq = IRQ_EINT(0); irq <= IRQ_EINT(15); irq++)
207                 irq_set_chip(irq, &s5p_irq_vic_eint);
208
209         for (irq = IRQ_EINT(16); irq <= IRQ_EINT(31); irq++) {
210                 irq_set_chip_and_handler(irq, &s5p_irq_eint, handle_level_irq);
211                 set_irq_flags(irq, IRQF_VALID);
212         }
213
214         irq_set_chained_handler(IRQ_EINT16_31, s5p_irq_demux_eint16_31);
215         return 0;
216 }
217
218 arch_initcall(s5p_init_irq_eint);

s5pv210通过irq_set_chip_and_handler来设置外部中断为电平触发
irq_set_chained_handler用来设置s5p_irq_demux_eint16_31为中断处理函数