1 /* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Code to handle x86 style IRQs plus some generic interrupt stuff. 7 * 8 * Copyright (C) 1992 Linus Torvalds 9 * Copyright (C) 1994 - 2000 Ralf Baechle 10 */ 11 #include <linux/kernel.h> 12 #include <linux/delay.h> 13 #include <linux/init.h> 14 #include <linux/interrupt.h> 15 #include <linux/kernel_stat.h> 16 #include <linux/proc_fs.h> 17 #include <linux/mm.h> 18 #include <linux/random.h> 19 #include <linux/sched.h> 20 #include <linux/seq_file.h> 21 #include <linux/kallsyms.h> 22 #include <linux/kgdb.h> 23 #include <linux/ftrace.h> 24 25 #include <linux/atomic.h> 26 #include <asm/uaccess.h> 27 28 static DECLARE_BITMAP(irq_map, NR_IRQS); 29 30 int allocate_irqno(void) 31 { 32 int irq; 33 34 again: 35 irq = find_first_zero_bit(irq_map, NR_IRQS); 36 37 if (irq >= NR_IRQS) 38 return -ENOSPC; 39 40 if (test_and_set_bit(irq, irq_map)) 41 goto again; 42 43 return irq; 44 } 45 46 /* 47 * Allocate the 16 legacy interrupts for i8259 devices. This happens early 48 * in the kernel initialization so treating allocation failure as BUG() is 49 * ok. 50 */ 51 void __init alloc_legacy_irqno(void) 52 { 53 int i; 54 55 for (i = 0; i <= 16; i++) 56 BUG_ON(test_and_set_bit(i, irq_map)); 57 } 58 59 void free_irqno(unsigned int irq) 60 { 61 smp_mb__before_atomic(); 62 clear_bit(irq, irq_map); 63 smp_mb__after_atomic(); 64 } 65 66 /* 67 * 'what should we do if we get a hw irq event on an illegal vector'. 68 * each architecture has to answer this themselves. 69 */ 70 void ack_bad_irq(unsigned int irq) 71 { 72 printk("unexpected IRQ # %d\n", irq); 73 } 74 75 atomic_t irq_err_count; 76 77 int arch_show_interrupts(struct seq_file *p, int prec) 78 { 79 seq_printf(p, "%*s: %10u\n", prec, "ERR", atomic_read(&irq_err_count)); 80 return 0; 81 } 82 83 asmlinkage void spurious_interrupt(void) 84 { 85 atomic_inc(&irq_err_count); 86 } 87 88 void __init init_IRQ(void) 89 { 90 int i; 91 92 for (i = 0; i < NR_IRQS; i++) 93 irq_set_noprobe(i); 94 95 arch_init_irq(); 96 } 97 98 #ifdef CONFIG_DEBUG_STACKOVERFLOW 99 static inline void check_stack_overflow(void) 100 { 101 unsigned long sp; 102 103 __asm__ __volatile__("move %0, $sp" : "=r" (sp)); 104 sp &= THREAD_MASK; 105 106 /* 107 * Check for stack overflow: is there less than STACK_WARN free? 108 * STACK_WARN is defined as 1/8 of THREAD_SIZE by default. 109 */ 110 if (unlikely(sp < (sizeof(struct thread_info) + STACK_WARN))) { 111 printk("do_IRQ: stack overflow: %ld\n", 112 sp - sizeof(struct thread_info)); 113 dump_stack(); 114 } 115 } 116 #else 117 static inline void check_stack_overflow(void) {} 118 #endif 119 120 121 /* 122 * do_IRQ handles all normal device IRQ's (the special 123 * SMP cross-CPU interrupts have their own specific 124 * handlers). 125 */ 126 void __irq_entry do_IRQ(unsigned int irq) 127 { 128 irq_enter(); 129 check_stack_overflow(); 130 generic_handle_irq(irq); 131 irq_exit(); 132 } 133 134