Pekka Enberg | 7788386 | 2009-04-09 11:52:26 +0300 | [diff] [blame] | 1 | #include <linux/linkage.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | #include <linux/errno.h> |
| 3 | #include <linux/signal.h> |
| 4 | #include <linux/sched.h> |
| 5 | #include <linux/ioport.h> |
| 6 | #include <linux/interrupt.h> |
Pekka Enberg | 7788386 | 2009-04-09 11:52:26 +0300 | [diff] [blame] | 7 | #include <linux/timex.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | #include <linux/slab.h> |
| 9 | #include <linux/random.h> |
Ingo Molnar | 47f16ca | 2009-04-10 14:58:05 +0200 | [diff] [blame] | 10 | #include <linux/kprobes.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | #include <linux/init.h> |
| 12 | #include <linux/kernel_stat.h> |
| 13 | #include <linux/sysdev.h> |
| 14 | #include <linux/bitops.h> |
Pekka Enberg | 7788386 | 2009-04-09 11:52:26 +0300 | [diff] [blame] | 15 | #include <linux/acpi.h> |
Jaswinder Singh Rajput | aa09e6c | 2009-01-04 16:35:17 +0530 | [diff] [blame] | 16 | #include <linux/io.h> |
| 17 | #include <linux/delay.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include <asm/atomic.h> |
| 20 | #include <asm/system.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | #include <asm/timer.h> |
Pekka Enberg | 7788386 | 2009-04-09 11:52:26 +0300 | [diff] [blame] | 22 | #include <asm/hw_irq.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | #include <asm/pgtable.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | #include <asm/desc.h> |
| 25 | #include <asm/apic.h> |
Ingo Molnar | 8e6dafd | 2009-02-23 00:34:39 +0100 | [diff] [blame] | 26 | #include <asm/setup.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | #include <asm/i8259.h> |
Jaswinder Singh Rajput | aa09e6c | 2009-01-04 16:35:17 +0530 | [diff] [blame] | 28 | #include <asm/traps.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | |
Pekka Enberg | 7788386 | 2009-04-09 11:52:26 +0300 | [diff] [blame] | 30 | /* |
| 31 | * ISA PIC or low IO-APIC triggered (INTA-cycle or APIC) interrupts: |
| 32 | * (these are usually mapped to vectors 0x30-0x3f) |
| 33 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | |
| 35 | /* |
Pekka Enberg | 7788386 | 2009-04-09 11:52:26 +0300 | [diff] [blame] | 36 | * The IO-APIC gives us many more interrupt sources. Most of these |
| 37 | * are unused but an SMP system is supposed to have enough memory ... |
| 38 | * sometimes (mostly wrt. hw bugs) we get corrupted vectors all |
| 39 | * across the spectrum, so we really want to be prepared to get all |
| 40 | * of these. Plus, more powerful systems might have more than 64 |
| 41 | * IO-APIC registers. |
| 42 | * |
| 43 | * (these are usually mapped into the 0x30-0xff vector range) |
| 44 | */ |
| 45 | |
Pekka Enberg | 320fd99 | 2009-04-09 11:52:25 +0300 | [diff] [blame] | 46 | #ifdef CONFIG_X86_32 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | /* |
| 48 | * Note that on a 486, we don't want to do a SIGFPE on an irq13 |
| 49 | * as the irq is unreliable, and exception 16 works correctly |
| 50 | * (ie as explained in the intel literature). On a 386, you |
| 51 | * can't use exception 16 due to bad IBM design, so we have to |
| 52 | * rely on the less exact irq13. |
| 53 | * |
| 54 | * Careful.. Not only is IRQ13 unreliable, but it is also |
| 55 | * leads to races. IBM designers who came up with it should |
| 56 | * be shot. |
| 57 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 59 | static irqreturn_t math_error_irq(int cpl, void *dev_id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | { |
Jaswinder Singh Rajput | aa09e6c | 2009-01-04 16:35:17 +0530 | [diff] [blame] | 61 | outb(0, 0xF0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | if (ignore_fpu_irq || !boot_cpu_data.hard_math) |
| 63 | return IRQ_NONE; |
H. Peter Anvin | 65ea5b0 | 2008-01-30 13:30:56 +0100 | [diff] [blame] | 64 | math_error((void __user *)get_irq_regs()->ip); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | return IRQ_HANDLED; |
| 66 | } |
| 67 | |
| 68 | /* |
| 69 | * New motherboards sometimes make IRQ 13 be a PCI interrupt, |
| 70 | * so allow interrupt sharing. |
| 71 | */ |
Thomas Gleixner | 6a61f6a | 2007-10-17 18:04:36 +0200 | [diff] [blame] | 72 | static struct irqaction fpu_irq = { |
| 73 | .handler = math_error_irq, |
Thomas Gleixner | 6a61f6a | 2007-10-17 18:04:36 +0200 | [diff] [blame] | 74 | .name = "fpu", |
| 75 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 78 | /* |
| 79 | * IRQ2 is cascade interrupt to second interrupt controller |
| 80 | */ |
| 81 | static struct irqaction irq2 = { |
| 82 | .handler = no_action, |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 83 | .name = "cascade", |
| 84 | }; |
| 85 | |
Yinghai Lu | 497c9a1 | 2008-08-19 20:50:28 -0700 | [diff] [blame] | 86 | DEFINE_PER_CPU(vector_irq_t, vector_irq) = { |
| 87 | [0 ... IRQ0_VECTOR - 1] = -1, |
| 88 | [IRQ0_VECTOR] = 0, |
| 89 | [IRQ1_VECTOR] = 1, |
| 90 | [IRQ2_VECTOR] = 2, |
| 91 | [IRQ3_VECTOR] = 3, |
| 92 | [IRQ4_VECTOR] = 4, |
| 93 | [IRQ5_VECTOR] = 5, |
| 94 | [IRQ6_VECTOR] = 6, |
| 95 | [IRQ7_VECTOR] = 7, |
| 96 | [IRQ8_VECTOR] = 8, |
| 97 | [IRQ9_VECTOR] = 9, |
| 98 | [IRQ10_VECTOR] = 10, |
| 99 | [IRQ11_VECTOR] = 11, |
| 100 | [IRQ12_VECTOR] = 12, |
| 101 | [IRQ13_VECTOR] = 13, |
| 102 | [IRQ14_VECTOR] = 14, |
| 103 | [IRQ15_VECTOR] = 15, |
| 104 | [IRQ15_VECTOR + 1 ... NR_VECTORS - 1] = -1 |
| 105 | }; |
| 106 | |
Yinghai Lu | b77b881 | 2008-12-19 15:23:44 -0800 | [diff] [blame] | 107 | int vector_used_by_percpu_irq(unsigned int vector) |
| 108 | { |
| 109 | int cpu; |
| 110 | |
| 111 | for_each_online_cpu(cpu) { |
| 112 | if (per_cpu(vector_irq, cpu)[vector] != -1) |
| 113 | return 1; |
| 114 | } |
| 115 | |
| 116 | return 0; |
| 117 | } |
| 118 | |
Pekka Enberg | 7371d9f | 2009-04-09 11:52:19 +0300 | [diff] [blame] | 119 | static void __init init_ISA_irqs(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | { |
| 121 | int i; |
| 122 | |
Pekka Enberg | 598c73d | 2009-04-09 11:52:24 +0300 | [diff] [blame] | 123 | #if defined(CONFIG_X86_64) || defined(CONFIG_X86_LOCAL_APIC) |
Pekka Enberg | 7371d9f | 2009-04-09 11:52:19 +0300 | [diff] [blame] | 124 | init_bsp_APIC(); |
| 125 | #endif |
| 126 | init_8259A(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | |
| 128 | /* |
Pekka Enberg | 7371d9f | 2009-04-09 11:52:19 +0300 | [diff] [blame] | 129 | * 16 old-style INTA-cycle interrupts: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | */ |
Pekka Enberg | 7371d9f | 2009-04-09 11:52:19 +0300 | [diff] [blame] | 131 | for (i = 0; i < NR_IRQS_LEGACY; i++) { |
| 132 | struct irq_desc *desc = irq_to_desc(i); |
| 133 | |
| 134 | desc->status = IRQ_DISABLED; |
| 135 | desc->action = NULL; |
| 136 | desc->depth = 1; |
| 137 | |
| 138 | set_irq_chip_and_handler_name(i, &i8259A_chip, |
| 139 | handle_level_irq, "XT"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 140 | } |
Pekka Enberg | 7371d9f | 2009-04-09 11:52:19 +0300 | [diff] [blame] | 141 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | /* Overridden in paravirt.c */ |
| 144 | void init_IRQ(void) __attribute__((weak, alias("native_init_IRQ"))); |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 145 | |
Pekka Enberg | 36290d8 | 2009-04-09 11:52:20 +0300 | [diff] [blame] | 146 | static void __init smp_intr_init(void) |
| 147 | { |
Pekka Enberg | b0096bb | 2009-04-09 11:52:23 +0300 | [diff] [blame] | 148 | #ifdef CONFIG_SMP |
| 149 | #if defined(CONFIG_X86_64) || defined(CONFIG_X86_LOCAL_APIC) |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 150 | /* |
| 151 | * The reschedule interrupt is a CPU-to-CPU reschedule-helper |
| 152 | * IPI, driven by wakeup. |
| 153 | */ |
| 154 | alloc_intr_gate(RESCHEDULE_VECTOR, reschedule_interrupt); |
| 155 | |
Tejun Heo | 02cf94c | 2009-01-21 17:26:06 +0900 | [diff] [blame] | 156 | /* IPIs for invalidation */ |
| 157 | alloc_intr_gate(INVALIDATE_TLB_VECTOR_START+0, invalidate_interrupt0); |
| 158 | alloc_intr_gate(INVALIDATE_TLB_VECTOR_START+1, invalidate_interrupt1); |
| 159 | alloc_intr_gate(INVALIDATE_TLB_VECTOR_START+2, invalidate_interrupt2); |
| 160 | alloc_intr_gate(INVALIDATE_TLB_VECTOR_START+3, invalidate_interrupt3); |
| 161 | alloc_intr_gate(INVALIDATE_TLB_VECTOR_START+4, invalidate_interrupt4); |
| 162 | alloc_intr_gate(INVALIDATE_TLB_VECTOR_START+5, invalidate_interrupt5); |
| 163 | alloc_intr_gate(INVALIDATE_TLB_VECTOR_START+6, invalidate_interrupt6); |
| 164 | alloc_intr_gate(INVALIDATE_TLB_VECTOR_START+7, invalidate_interrupt7); |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 165 | |
| 166 | /* IPI for generic function call */ |
| 167 | alloc_intr_gate(CALL_FUNCTION_VECTOR, call_function_interrupt); |
| 168 | |
Pekka Enberg | b0096bb | 2009-04-09 11:52:23 +0300 | [diff] [blame] | 169 | /* IPI for generic single function call */ |
Yinghai Lu | b77b881 | 2008-12-19 15:23:44 -0800 | [diff] [blame] | 170 | alloc_intr_gate(CALL_FUNCTION_SINGLE_VECTOR, |
Pekka Enberg | b0096bb | 2009-04-09 11:52:23 +0300 | [diff] [blame] | 171 | call_function_single_interrupt); |
Yinghai Lu | 497c9a1 | 2008-08-19 20:50:28 -0700 | [diff] [blame] | 172 | |
| 173 | /* Low priority IPI to cleanup after moving an irq */ |
| 174 | set_intr_gate(IRQ_MOVE_CLEANUP_VECTOR, irq_move_cleanup_interrupt); |
Yinghai Lu | b77b881 | 2008-12-19 15:23:44 -0800 | [diff] [blame] | 175 | set_bit(IRQ_MOVE_CLEANUP_VECTOR, used_vectors); |
Andi Kleen | 4ef702c | 2009-05-27 21:56:52 +0200 | [diff] [blame] | 176 | |
| 177 | /* IPI used for rebooting/stopping */ |
| 178 | alloc_intr_gate(REBOOT_VECTOR, reboot_interrupt); |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 179 | #endif |
Pekka Enberg | b0096bb | 2009-04-09 11:52:23 +0300 | [diff] [blame] | 180 | #endif /* CONFIG_SMP */ |
Pekka Enberg | 36290d8 | 2009-04-09 11:52:20 +0300 | [diff] [blame] | 181 | } |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 182 | |
Pekka Enberg | 22813c4 | 2009-04-09 11:52:21 +0300 | [diff] [blame] | 183 | static void __init apic_intr_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | { |
Pekka Enberg | 36290d8 | 2009-04-09 11:52:20 +0300 | [diff] [blame] | 185 | smp_intr_init(); |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 186 | |
H. Peter Anvin | 48b1fdd | 2009-06-01 15:13:02 -0700 | [diff] [blame] | 187 | #ifdef CONFIG_X86_THERMAL_VECTOR |
Pekka Enberg | ab19c25 | 2009-04-09 11:52:27 +0300 | [diff] [blame] | 188 | alloc_intr_gate(THERMAL_APIC_VECTOR, thermal_interrupt); |
H. Peter Anvin | 48b1fdd | 2009-06-01 15:13:02 -0700 | [diff] [blame] | 189 | #endif |
| 190 | #ifdef CONFIG_X86_THRESHOLD |
Pekka Enberg | ab19c25 | 2009-04-09 11:52:27 +0300 | [diff] [blame] | 191 | alloc_intr_gate(THRESHOLD_APIC_VECTOR, threshold_interrupt); |
| 192 | #endif |
Andi Kleen | ccc3c31 | 2009-05-27 21:56:54 +0200 | [diff] [blame] | 193 | #if defined(CONFIG_X86_NEW_MCE) && defined(CONFIG_X86_LOCAL_APIC) |
| 194 | alloc_intr_gate(MCE_SELF_VECTOR, mce_self_interrupt); |
| 195 | #endif |
Pekka Enberg | ab19c25 | 2009-04-09 11:52:27 +0300 | [diff] [blame] | 196 | |
| 197 | #if defined(CONFIG_X86_64) || defined(CONFIG_X86_LOCAL_APIC) |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 198 | /* self generated IPI for local APIC timer */ |
| 199 | alloc_intr_gate(LOCAL_TIMER_VECTOR, apic_timer_interrupt); |
| 200 | |
Dimitri Sivanich | acaabe7 | 2009-03-04 12:56:05 -0600 | [diff] [blame] | 201 | /* generic IPI for platform specific use */ |
| 202 | alloc_intr_gate(GENERIC_INTERRUPT_VECTOR, generic_interrupt); |
| 203 | |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 204 | /* IPI vectors for APIC spurious and error interrupts */ |
| 205 | alloc_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt); |
| 206 | alloc_intr_gate(ERROR_APIC_VECTOR, error_interrupt); |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 207 | |
Ingo Molnar | 47f16ca | 2009-04-10 14:58:05 +0200 | [diff] [blame] | 208 | /* Performance monitoring interrupts: */ |
| 209 | # ifdef CONFIG_PERF_COUNTERS |
Ingo Molnar | 47f16ca | 2009-04-10 14:58:05 +0200 | [diff] [blame] | 210 | alloc_intr_gate(LOCAL_PENDING_VECTOR, perf_pending_interrupt); |
| 211 | # endif |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 212 | |
Andi Kleen | 7856f6c | 2009-04-28 23:32:56 +0200 | [diff] [blame] | 213 | #endif |
Pekka Enberg | 22813c4 | 2009-04-09 11:52:21 +0300 | [diff] [blame] | 214 | } |
| 215 | |
Pekka Enberg | 320fd99 | 2009-04-09 11:52:25 +0300 | [diff] [blame] | 216 | /** |
| 217 | * x86_quirk_pre_intr_init - initialisation prior to setting up interrupt vectors |
| 218 | * |
| 219 | * Description: |
| 220 | * Perform any necessary interrupt initialisation prior to setting up |
| 221 | * the "ordinary" interrupt call gates. For legacy reasons, the ISA |
| 222 | * interrupts should be initialised here if the machine emulates a PC |
| 223 | * in any way. |
| 224 | **/ |
| 225 | static void __init x86_quirk_pre_intr_init(void) |
| 226 | { |
Pekka Enberg | abdb5a5 | 2009-04-09 11:52:30 +0300 | [diff] [blame] | 227 | #ifdef CONFIG_X86_32 |
Pekka Enberg | 320fd99 | 2009-04-09 11:52:25 +0300 | [diff] [blame] | 228 | if (x86_quirks->arch_pre_intr_init) { |
| 229 | if (x86_quirks->arch_pre_intr_init()) |
| 230 | return; |
| 231 | } |
Pekka Enberg | abdb5a5 | 2009-04-09 11:52:30 +0300 | [diff] [blame] | 232 | #endif |
Pekka Enberg | 320fd99 | 2009-04-09 11:52:25 +0300 | [diff] [blame] | 233 | init_ISA_irqs(); |
| 234 | } |
Pekka Enberg | 320fd99 | 2009-04-09 11:52:25 +0300 | [diff] [blame] | 235 | |
Pekka Enberg | 22813c4 | 2009-04-09 11:52:21 +0300 | [diff] [blame] | 236 | void __init native_init_IRQ(void) |
| 237 | { |
| 238 | int i; |
| 239 | |
| 240 | /* Execute any quirks before the call gates are initialised: */ |
| 241 | x86_quirk_pre_intr_init(); |
| 242 | |
Yinghai Lu | 77857dc | 2009-04-15 11:57:01 -0700 | [diff] [blame] | 243 | apic_intr_init(); |
| 244 | |
Pekka Enberg | 22813c4 | 2009-04-09 11:52:21 +0300 | [diff] [blame] | 245 | /* |
| 246 | * Cover the whole vector space, no vector can escape |
| 247 | * us. (some of these will be overridden and become |
| 248 | * 'special' SMP interrupts) |
| 249 | */ |
Pekka Enberg | d3496c8 | 2009-04-09 11:52:22 +0300 | [diff] [blame] | 250 | for (i = FIRST_EXTERNAL_VECTOR; i < NR_VECTORS; i++) { |
Yinghai Lu | 77857dc | 2009-04-15 11:57:01 -0700 | [diff] [blame] | 251 | /* IA32_SYSCALL_VECTOR could be used in trap_init already. */ |
| 252 | if (!test_bit(i, used_vectors)) |
Pekka Enberg | 320fd99 | 2009-04-09 11:52:25 +0300 | [diff] [blame] | 253 | set_intr_gate(i, interrupt[i-FIRST_EXTERNAL_VECTOR]); |
Pekka Enberg | 22813c4 | 2009-04-09 11:52:21 +0300 | [diff] [blame] | 254 | } |
Andi Kleen | 7856f6c | 2009-04-28 23:32:56 +0200 | [diff] [blame] | 255 | |
Cyrill Gorcunov | 2ae111c | 2008-08-11 18:34:08 +0400 | [diff] [blame] | 256 | if (!acpi_ioapic) |
| 257 | setup_irq(2, &irq2); |
| 258 | |
Pekka Enberg | 320fd99 | 2009-04-09 11:52:25 +0300 | [diff] [blame] | 259 | #ifdef CONFIG_X86_32 |
Ingo Molnar | 8e6dafd | 2009-02-23 00:34:39 +0100 | [diff] [blame] | 260 | /* |
| 261 | * Call quirks after call gates are initialised (usually add in |
| 262 | * the architecture specific gates): |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | */ |
Ingo Molnar | 8e6dafd | 2009-02-23 00:34:39 +0100 | [diff] [blame] | 264 | x86_quirk_intr_init(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | |
| 266 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 267 | * External FPU? Set up irq13 if so, for |
| 268 | * original braindamaged IBM FERR coupling. |
| 269 | */ |
| 270 | if (boot_cpu_data.hard_math && !cpu_has_fpu) |
| 271 | setup_irq(FPU_IRQ, &fpu_irq); |
| 272 | |
| 273 | irq_ctx_init(smp_processor_id()); |
Pekka Enberg | 320fd99 | 2009-04-09 11:52:25 +0300 | [diff] [blame] | 274 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | } |