Merge branch 'x86-platform-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6.git] / arch / x86 / kernel / apic / io_apic.c
1 /*
2  *      Intel IO-APIC support for multi-Pentium hosts.
3  *
4  *      Copyright (C) 1997, 1998, 1999, 2000, 2009 Ingo Molnar, Hajnalka Szabo
5  *
6  *      Many thanks to Stig Venaas for trying out countless experimental
7  *      patches and reporting/debugging problems patiently!
8  *
9  *      (c) 1999, Multiple IO-APIC support, developed by
10  *      Ken-ichi Yaku <yaku@css1.kbnes.nec.co.jp> and
11  *      Hidemi Kishimoto <kisimoto@css1.kbnes.nec.co.jp>,
12  *      further tested and cleaned up by Zach Brown <zab@redhat.com>
13  *      and Ingo Molnar <mingo@redhat.com>
14  *
15  *      Fixes
16  *      Maciej W. Rozycki       :       Bits for genuine 82489DX APICs;
17  *                                      thanks to Eric Gilmore
18  *                                      and Rolf G. Tews
19  *                                      for testing these extensively
20  *      Paul Diefenbaugh        :       Added full ACPI support
21  */
22
23 #include <linux/mm.h>
24 #include <linux/interrupt.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/sched.h>
28 #include <linux/pci.h>
29 #include <linux/mc146818rtc.h>
30 #include <linux/compiler.h>
31 #include <linux/acpi.h>
32 #include <linux/module.h>
33 #include <linux/sysdev.h>
34 #include <linux/msi.h>
35 #include <linux/htirq.h>
36 #include <linux/freezer.h>
37 #include <linux/kthread.h>
38 #include <linux/jiffies.h>      /* time_after() */
39 #ifdef CONFIG_ACPI
40 #include <acpi/acpi_bus.h>
41 #endif
42 #include <linux/bootmem.h>
43 #include <linux/dmar.h>
44 #include <linux/hpet.h>
45
46 #include <asm/idle.h>
47 #include <asm/io.h>
48 #include <asm/smp.h>
49 #include <asm/cpu.h>
50 #include <asm/desc.h>
51 #include <asm/proto.h>
52 #include <asm/acpi.h>
53 #include <asm/dma.h>
54 #include <asm/timer.h>
55 #include <asm/i8259.h>
56 #include <asm/nmi.h>
57 #include <asm/msidef.h>
58 #include <asm/hypertransport.h>
59 #include <asm/setup.h>
60 #include <asm/irq_remapping.h>
61 #include <asm/hpet.h>
62 #include <asm/hw_irq.h>
63 #include <asm/uv/uv_hub.h>
64 #include <asm/uv/uv_irq.h>
65
66 #include <asm/apic.h>
67
68 #define __apicdebuginit(type) static type __init
69 #define for_each_irq_pin(entry, head) \
70         for (entry = head; entry; entry = entry->next)
71
72 /*
73  *      Is the SiS APIC rmw bug present ?
74  *      -1 = don't know, 0 = no, 1 = yes
75  */
76 int sis_apic_bug = -1;
77
78 static DEFINE_SPINLOCK(ioapic_lock);
79 static DEFINE_SPINLOCK(vector_lock);
80
81 /*
82  * # of IRQ routing registers
83  */
84 int nr_ioapic_registers[MAX_IO_APICS];
85
86 /* I/O APIC entries */
87 struct mpc_ioapic mp_ioapics[MAX_IO_APICS];
88 int nr_ioapics;
89
90 /* IO APIC gsi routing info */
91 struct mp_ioapic_gsi  mp_gsi_routing[MAX_IO_APICS];
92
93 /* MP IRQ source entries */
94 struct mpc_intsrc mp_irqs[MAX_IRQ_SOURCES];
95
96 /* # of MP IRQ source entries */
97 int mp_irq_entries;
98
99 /* Number of legacy interrupts */
100 static int nr_legacy_irqs __read_mostly = NR_IRQS_LEGACY;
101 /* GSI interrupts */
102 static int nr_irqs_gsi = NR_IRQS_LEGACY;
103
104 #if defined (CONFIG_MCA) || defined (CONFIG_EISA)
105 int mp_bus_id_to_type[MAX_MP_BUSSES];
106 #endif
107
108 DECLARE_BITMAP(mp_bus_not_pci, MAX_MP_BUSSES);
109
110 int skip_ioapic_setup;
111
112 void arch_disable_smp_support(void)
113 {
114 #ifdef CONFIG_PCI
115         noioapicquirk = 1;
116         noioapicreroute = -1;
117 #endif
118         skip_ioapic_setup = 1;
119 }
120
121 static int __init parse_noapic(char *str)
122 {
123         /* disable IO-APIC */
124         arch_disable_smp_support();
125         return 0;
126 }
127 early_param("noapic", parse_noapic);
128
129 struct irq_pin_list {
130         int apic, pin;
131         struct irq_pin_list *next;
132 };
133
134 static struct irq_pin_list *get_one_free_irq_2_pin(int node)
135 {
136         struct irq_pin_list *pin;
137
138         pin = kzalloc_node(sizeof(*pin), GFP_ATOMIC, node);
139
140         return pin;
141 }
142
143 /*
144  * This is performance-critical, we want to do it O(1)
145  *
146  * Most irqs are mapped 1:1 with pins.
147  */
148 struct irq_cfg {
149         struct irq_pin_list *irq_2_pin;
150         cpumask_var_t domain;
151         cpumask_var_t old_domain;
152         unsigned move_cleanup_count;
153         u8 vector;
154         u8 move_in_progress : 1;
155 };
156
157 /* irq_cfg is indexed by the sum of all RTEs in all I/O APICs. */
158 #ifdef CONFIG_SPARSE_IRQ
159 static struct irq_cfg irq_cfgx[] = {
160 #else
161 static struct irq_cfg irq_cfgx[NR_IRQS] = {
162 #endif
163         [0]  = { .vector = IRQ0_VECTOR,  },
164         [1]  = { .vector = IRQ1_VECTOR,  },
165         [2]  = { .vector = IRQ2_VECTOR,  },
166         [3]  = { .vector = IRQ3_VECTOR,  },
167         [4]  = { .vector = IRQ4_VECTOR,  },
168         [5]  = { .vector = IRQ5_VECTOR,  },
169         [6]  = { .vector = IRQ6_VECTOR,  },
170         [7]  = { .vector = IRQ7_VECTOR,  },
171         [8]  = { .vector = IRQ8_VECTOR,  },
172         [9]  = { .vector = IRQ9_VECTOR,  },
173         [10] = { .vector = IRQ10_VECTOR, },
174         [11] = { .vector = IRQ11_VECTOR, },
175         [12] = { .vector = IRQ12_VECTOR, },
176         [13] = { .vector = IRQ13_VECTOR, },
177         [14] = { .vector = IRQ14_VECTOR, },
178         [15] = { .vector = IRQ15_VECTOR, },
179 };
180
181 void __init io_apic_disable_legacy(void)
182 {
183         nr_legacy_irqs = 0;
184         nr_irqs_gsi = 0;
185 }
186
187 int __init arch_early_irq_init(void)
188 {
189         struct irq_cfg *cfg;
190         struct irq_desc *desc;
191         int count;
192         int node;
193         int i;
194
195         cfg = irq_cfgx;
196         count = ARRAY_SIZE(irq_cfgx);
197         node= cpu_to_node(boot_cpu_id);
198
199         for (i = 0; i < count; i++) {
200                 desc = irq_to_desc(i);
201                 desc->chip_data = &cfg[i];
202                 zalloc_cpumask_var_node(&cfg[i].domain, GFP_NOWAIT, node);
203                 zalloc_cpumask_var_node(&cfg[i].old_domain, GFP_NOWAIT, node);
204                 if (i < nr_legacy_irqs)
205                         cpumask_setall(cfg[i].domain);
206         }
207
208         return 0;
209 }
210
211 #ifdef CONFIG_SPARSE_IRQ
212 static struct irq_cfg *irq_cfg(unsigned int irq)
213 {
214         struct irq_cfg *cfg = NULL;
215         struct irq_desc *desc;
216
217         desc = irq_to_desc(irq);
218         if (desc)
219                 cfg = desc->chip_data;
220
221         return cfg;
222 }
223
224 static struct irq_cfg *get_one_free_irq_cfg(int node)
225 {
226         struct irq_cfg *cfg;
227
228         cfg = kzalloc_node(sizeof(*cfg), GFP_ATOMIC, node);
229         if (cfg) {
230                 if (!alloc_cpumask_var_node(&cfg->domain, GFP_ATOMIC, node)) {
231                         kfree(cfg);
232                         cfg = NULL;
233                 } else if (!alloc_cpumask_var_node(&cfg->old_domain,
234                                                           GFP_ATOMIC, node)) {
235                         free_cpumask_var(cfg->domain);
236                         kfree(cfg);
237                         cfg = NULL;
238                 } else {
239                         cpumask_clear(cfg->domain);
240                         cpumask_clear(cfg->old_domain);
241                 }
242         }
243
244         return cfg;
245 }
246
247 int arch_init_chip_data(struct irq_desc *desc, int node)
248 {
249         struct irq_cfg *cfg;
250
251         cfg = desc->chip_data;
252         if (!cfg) {
253                 desc->chip_data = get_one_free_irq_cfg(node);
254                 if (!desc->chip_data) {
255                         printk(KERN_ERR "can not alloc irq_cfg\n");
256                         BUG_ON(1);
257                 }
258         }
259
260         return 0;
261 }
262
263 /* for move_irq_desc */
264 static void
265 init_copy_irq_2_pin(struct irq_cfg *old_cfg, struct irq_cfg *cfg, int node)
266 {
267         struct irq_pin_list *old_entry, *head, *tail, *entry;
268
269         cfg->irq_2_pin = NULL;
270         old_entry = old_cfg->irq_2_pin;
271         if (!old_entry)
272                 return;
273
274         entry = get_one_free_irq_2_pin(node);
275         if (!entry)
276                 return;
277
278         entry->apic     = old_entry->apic;
279         entry->pin      = old_entry->pin;
280         head            = entry;
281         tail            = entry;
282         old_entry       = old_entry->next;
283         while (old_entry) {
284                 entry = get_one_free_irq_2_pin(node);
285                 if (!entry) {
286                         entry = head;
287                         while (entry) {
288                                 head = entry->next;
289                                 kfree(entry);
290                                 entry = head;
291                         }
292                         /* still use the old one */
293                         return;
294                 }
295                 entry->apic     = old_entry->apic;
296                 entry->pin      = old_entry->pin;
297                 tail->next      = entry;
298                 tail            = entry;
299                 old_entry       = old_entry->next;
300         }
301
302         tail->next = NULL;
303         cfg->irq_2_pin = head;
304 }
305
306 static void free_irq_2_pin(struct irq_cfg *old_cfg, struct irq_cfg *cfg)
307 {
308         struct irq_pin_list *entry, *next;
309
310         if (old_cfg->irq_2_pin == cfg->irq_2_pin)
311                 return;
312
313         entry = old_cfg->irq_2_pin;
314
315         while (entry) {
316                 next = entry->next;
317                 kfree(entry);
318                 entry = next;
319         }
320         old_cfg->irq_2_pin = NULL;
321 }
322
323 void arch_init_copy_chip_data(struct irq_desc *old_desc,
324                                  struct irq_desc *desc, int node)
325 {
326         struct irq_cfg *cfg;
327         struct irq_cfg *old_cfg;
328
329         cfg = get_one_free_irq_cfg(node);
330
331         if (!cfg)
332                 return;
333
334         desc->chip_data = cfg;
335
336         old_cfg = old_desc->chip_data;
337
338         memcpy(cfg, old_cfg, sizeof(struct irq_cfg));
339
340         init_copy_irq_2_pin(old_cfg, cfg, node);
341 }
342
343 static void free_irq_cfg(struct irq_cfg *old_cfg)
344 {
345         kfree(old_cfg);
346 }
347
348 void arch_free_chip_data(struct irq_desc *old_desc, struct irq_desc *desc)
349 {
350         struct irq_cfg *old_cfg, *cfg;
351
352         old_cfg = old_desc->chip_data;
353         cfg = desc->chip_data;
354
355         if (old_cfg == cfg)
356                 return;
357
358         if (old_cfg) {
359                 free_irq_2_pin(old_cfg, cfg);
360                 free_irq_cfg(old_cfg);
361                 old_desc->chip_data = NULL;
362         }
363 }
364 /* end for move_irq_desc */
365
366 #else
367 static struct irq_cfg *irq_cfg(unsigned int irq)
368 {
369         return irq < nr_irqs ? irq_cfgx + irq : NULL;
370 }
371
372 #endif
373
374 struct io_apic {
375         unsigned int index;
376         unsigned int unused[3];
377         unsigned int data;
378         unsigned int unused2[11];
379         unsigned int eoi;
380 };
381
382 static __attribute_const__ struct io_apic __iomem *io_apic_base(int idx)
383 {
384         return (void __iomem *) __fix_to_virt(FIX_IO_APIC_BASE_0 + idx)
385                 + (mp_ioapics[idx].apicaddr & ~PAGE_MASK);
386 }
387
388 static inline void io_apic_eoi(unsigned int apic, unsigned int vector)
389 {
390         struct io_apic __iomem *io_apic = io_apic_base(apic);
391         writel(vector, &io_apic->eoi);
392 }
393
394 static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg)
395 {
396         struct io_apic __iomem *io_apic = io_apic_base(apic);
397         writel(reg, &io_apic->index);
398         return readl(&io_apic->data);
399 }
400
401 static inline void io_apic_write(unsigned int apic, unsigned int reg, unsigned int value)
402 {
403         struct io_apic __iomem *io_apic = io_apic_base(apic);
404         writel(reg, &io_apic->index);
405         writel(value, &io_apic->data);
406 }
407
408 /*
409  * Re-write a value: to be used for read-modify-write
410  * cycles where the read already set up the index register.
411  *
412  * Older SiS APIC requires we rewrite the index register
413  */
414 static inline void io_apic_modify(unsigned int apic, unsigned int reg, unsigned int value)
415 {
416         struct io_apic __iomem *io_apic = io_apic_base(apic);
417
418         if (sis_apic_bug)
419                 writel(reg, &io_apic->index);
420         writel(value, &io_apic->data);
421 }
422
423 static bool io_apic_level_ack_pending(struct irq_cfg *cfg)
424 {
425         struct irq_pin_list *entry;
426         unsigned long flags;
427
428         spin_lock_irqsave(&ioapic_lock, flags);
429         for_each_irq_pin(entry, cfg->irq_2_pin) {
430                 unsigned int reg;
431                 int pin;
432
433                 pin = entry->pin;
434                 reg = io_apic_read(entry->apic, 0x10 + pin*2);
435                 /* Is the remote IRR bit set? */
436                 if (reg & IO_APIC_REDIR_REMOTE_IRR) {
437                         spin_unlock_irqrestore(&ioapic_lock, flags);
438                         return true;
439                 }
440         }
441         spin_unlock_irqrestore(&ioapic_lock, flags);
442
443         return false;
444 }
445
446 union entry_union {
447         struct { u32 w1, w2; };
448         struct IO_APIC_route_entry entry;
449 };
450
451 static struct IO_APIC_route_entry ioapic_read_entry(int apic, int pin)
452 {
453         union entry_union eu;
454         unsigned long flags;
455         spin_lock_irqsave(&ioapic_lock, flags);
456         eu.w1 = io_apic_read(apic, 0x10 + 2 * pin);
457         eu.w2 = io_apic_read(apic, 0x11 + 2 * pin);
458         spin_unlock_irqrestore(&ioapic_lock, flags);
459         return eu.entry;
460 }
461
462 /*
463  * When we write a new IO APIC routing entry, we need to write the high
464  * word first! If the mask bit in the low word is clear, we will enable
465  * the interrupt, and we need to make sure the entry is fully populated
466  * before that happens.
467  */
468 static void
469 __ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
470 {
471         union entry_union eu = {{0, 0}};
472
473         eu.entry = e;
474         io_apic_write(apic, 0x11 + 2*pin, eu.w2);
475         io_apic_write(apic, 0x10 + 2*pin, eu.w1);
476 }
477
478 void ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
479 {
480         unsigned long flags;
481         spin_lock_irqsave(&ioapic_lock, flags);
482         __ioapic_write_entry(apic, pin, e);
483         spin_unlock_irqrestore(&ioapic_lock, flags);
484 }
485
486 /*
487  * When we mask an IO APIC routing entry, we need to write the low
488  * word first, in order to set the mask bit before we change the
489  * high bits!
490  */
491 static void ioapic_mask_entry(int apic, int pin)
492 {
493         unsigned long flags;
494         union entry_union eu = { .entry.mask = 1 };
495
496         spin_lock_irqsave(&ioapic_lock, flags);
497         io_apic_write(apic, 0x10 + 2*pin, eu.w1);
498         io_apic_write(apic, 0x11 + 2*pin, eu.w2);
499         spin_unlock_irqrestore(&ioapic_lock, flags);
500 }
501
502 /*
503  * The common case is 1:1 IRQ<->pin mappings. Sometimes there are
504  * shared ISA-space IRQs, so we have to support them. We are super
505  * fast in the common case, and fast for shared ISA-space IRQs.
506  */
507 static int
508 add_pin_to_irq_node_nopanic(struct irq_cfg *cfg, int node, int apic, int pin)
509 {
510         struct irq_pin_list **last, *entry;
511
512         /* don't allow duplicates */
513         last = &cfg->irq_2_pin;
514         for_each_irq_pin(entry, cfg->irq_2_pin) {
515                 if (entry->apic == apic && entry->pin == pin)
516                         return 0;
517                 last = &entry->next;
518         }
519
520         entry = get_one_free_irq_2_pin(node);
521         if (!entry) {
522                 printk(KERN_ERR "can not alloc irq_pin_list (%d,%d,%d)\n",
523                                 node, apic, pin);
524                 return -ENOMEM;
525         }
526         entry->apic = apic;
527         entry->pin = pin;
528
529         *last = entry;
530         return 0;
531 }
532
533 static void add_pin_to_irq_node(struct irq_cfg *cfg, int node, int apic, int pin)
534 {
535         if (add_pin_to_irq_node_nopanic(cfg, node, apic, pin))
536                 panic("IO-APIC: failed to add irq-pin. Can not proceed\n");
537 }
538
539 /*
540  * Reroute an IRQ to a different pin.
541  */
542 static void __init replace_pin_at_irq_node(struct irq_cfg *cfg, int node,
543                                            int oldapic, int oldpin,
544                                            int newapic, int newpin)
545 {
546         struct irq_pin_list *entry;
547
548         for_each_irq_pin(entry, cfg->irq_2_pin) {
549                 if (entry->apic == oldapic && entry->pin == oldpin) {
550                         entry->apic = newapic;
551                         entry->pin = newpin;
552                         /* every one is different, right? */
553                         return;
554                 }
555         }
556
557         /* old apic/pin didn't exist, so just add new ones */
558         add_pin_to_irq_node(cfg, node, newapic, newpin);
559 }
560
561 static void io_apic_modify_irq(struct irq_cfg *cfg,
562                                int mask_and, int mask_or,
563                                void (*final)(struct irq_pin_list *entry))
564 {
565         int pin;
566         struct irq_pin_list *entry;
567
568         for_each_irq_pin(entry, cfg->irq_2_pin) {
569                 unsigned int reg;
570                 pin = entry->pin;
571                 reg = io_apic_read(entry->apic, 0x10 + pin * 2);
572                 reg &= mask_and;
573                 reg |= mask_or;
574                 io_apic_modify(entry->apic, 0x10 + pin * 2, reg);
575                 if (final)
576                         final(entry);
577         }
578 }
579
580 static void __unmask_IO_APIC_irq(struct irq_cfg *cfg)
581 {
582         io_apic_modify_irq(cfg, ~IO_APIC_REDIR_MASKED, 0, NULL);
583 }
584
585 static void io_apic_sync(struct irq_pin_list *entry)
586 {
587         /*
588          * Synchronize the IO-APIC and the CPU by doing
589          * a dummy read from the IO-APIC
590          */
591         struct io_apic __iomem *io_apic;
592         io_apic = io_apic_base(entry->apic);
593         readl(&io_apic->data);
594 }
595
596 static void __mask_IO_APIC_irq(struct irq_cfg *cfg)
597 {
598         io_apic_modify_irq(cfg, ~0, IO_APIC_REDIR_MASKED, &io_apic_sync);
599 }
600
601 static void __mask_and_edge_IO_APIC_irq(struct irq_cfg *cfg)
602 {
603         io_apic_modify_irq(cfg, ~IO_APIC_REDIR_LEVEL_TRIGGER,
604                         IO_APIC_REDIR_MASKED, NULL);
605 }
606
607 static void __unmask_and_level_IO_APIC_irq(struct irq_cfg *cfg)
608 {
609         io_apic_modify_irq(cfg, ~IO_APIC_REDIR_MASKED,
610                         IO_APIC_REDIR_LEVEL_TRIGGER, NULL);
611 }
612
613 static void mask_IO_APIC_irq_desc(struct irq_desc *desc)
614 {
615         struct irq_cfg *cfg = desc->chip_data;
616         unsigned long flags;
617
618         BUG_ON(!cfg);
619
620         spin_lock_irqsave(&ioapic_lock, flags);
621         __mask_IO_APIC_irq(cfg);
622         spin_unlock_irqrestore(&ioapic_lock, flags);
623 }
624
625 static void unmask_IO_APIC_irq_desc(struct irq_desc *desc)
626 {
627         struct irq_cfg *cfg = desc->chip_data;
628         unsigned long flags;
629
630         spin_lock_irqsave(&ioapic_lock, flags);
631         __unmask_IO_APIC_irq(cfg);
632         spin_unlock_irqrestore(&ioapic_lock, flags);
633 }
634
635 static void mask_IO_APIC_irq(unsigned int irq)
636 {
637         struct irq_desc *desc = irq_to_desc(irq);
638
639         mask_IO_APIC_irq_desc(desc);
640 }
641 static void unmask_IO_APIC_irq(unsigned int irq)
642 {
643         struct irq_desc *desc = irq_to_desc(irq);
644
645         unmask_IO_APIC_irq_desc(desc);
646 }
647
648 static void clear_IO_APIC_pin(unsigned int apic, unsigned int pin)
649 {
650         struct IO_APIC_route_entry entry;
651
652         /* Check delivery_mode to be sure we're not clearing an SMI pin */
653         entry = ioapic_read_entry(apic, pin);
654         if (entry.delivery_mode == dest_SMI)
655                 return;
656         /*
657          * Disable it in the IO-APIC irq-routing table:
658          */
659         ioapic_mask_entry(apic, pin);
660 }
661
662 static void clear_IO_APIC (void)
663 {
664         int apic, pin;
665
666         for (apic = 0; apic < nr_ioapics; apic++)
667                 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++)
668                         clear_IO_APIC_pin(apic, pin);
669 }
670
671 #ifdef CONFIG_X86_32
672 /*
673  * support for broken MP BIOSs, enables hand-redirection of PIRQ0-7 to
674  * specific CPU-side IRQs.
675  */
676
677 #define MAX_PIRQS 8
678 static int pirq_entries[MAX_PIRQS] = {
679         [0 ... MAX_PIRQS - 1] = -1
680 };
681
682 static int __init ioapic_pirq_setup(char *str)
683 {
684         int i, max;
685         int ints[MAX_PIRQS+1];
686
687         get_options(str, ARRAY_SIZE(ints), ints);
688
689         apic_printk(APIC_VERBOSE, KERN_INFO
690                         "PIRQ redirection, working around broken MP-BIOS.\n");
691         max = MAX_PIRQS;
692         if (ints[0] < MAX_PIRQS)
693                 max = ints[0];
694
695         for (i = 0; i < max; i++) {
696                 apic_printk(APIC_VERBOSE, KERN_DEBUG
697                                 "... PIRQ%d -> IRQ %d\n", i, ints[i+1]);
698                 /*
699                  * PIRQs are mapped upside down, usually.
700                  */
701                 pirq_entries[MAX_PIRQS-i-1] = ints[i+1];
702         }
703         return 1;
704 }
705
706 __setup("pirq=", ioapic_pirq_setup);
707 #endif /* CONFIG_X86_32 */
708
709 struct IO_APIC_route_entry **alloc_ioapic_entries(void)
710 {
711         int apic;
712         struct IO_APIC_route_entry **ioapic_entries;
713
714         ioapic_entries = kzalloc(sizeof(*ioapic_entries) * nr_ioapics,
715                                 GFP_ATOMIC);
716         if (!ioapic_entries)
717                 return 0;
718
719         for (apic = 0; apic < nr_ioapics; apic++) {
720                 ioapic_entries[apic] =
721                         kzalloc(sizeof(struct IO_APIC_route_entry) *
722                                 nr_ioapic_registers[apic], GFP_ATOMIC);
723                 if (!ioapic_entries[apic])
724                         goto nomem;
725         }
726
727         return ioapic_entries;
728
729 nomem:
730         while (--apic >= 0)
731                 kfree(ioapic_entries[apic]);
732         kfree(ioapic_entries);
733
734         return 0;
735 }
736
737 /*
738  * Saves all the IO-APIC RTE's
739  */
740 int save_IO_APIC_setup(struct IO_APIC_route_entry **ioapic_entries)
741 {
742         int apic, pin;
743
744         if (!ioapic_entries)
745                 return -ENOMEM;
746
747         for (apic = 0; apic < nr_ioapics; apic++) {
748                 if (!ioapic_entries[apic])
749                         return -ENOMEM;
750
751                 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++)
752                         ioapic_entries[apic][pin] =
753                                 ioapic_read_entry(apic, pin);
754         }
755
756         return 0;
757 }
758
759 /*
760  * Mask all IO APIC entries.
761  */
762 void mask_IO_APIC_setup(struct IO_APIC_route_entry **ioapic_entries)
763 {
764         int apic, pin;
765
766         if (!ioapic_entries)
767                 return;
768
769         for (apic = 0; apic < nr_ioapics; apic++) {
770                 if (!ioapic_entries[apic])
771                         break;
772
773                 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
774                         struct IO_APIC_route_entry entry;
775
776                         entry = ioapic_entries[apic][pin];
777                         if (!entry.mask) {
778                                 entry.mask = 1;
779                                 ioapic_write_entry(apic, pin, entry);
780                         }
781                 }
782         }
783 }
784
785 /*
786  * Restore IO APIC entries which was saved in ioapic_entries.
787  */
788 int restore_IO_APIC_setup(struct IO_APIC_route_entry **ioapic_entries)
789 {
790         int apic, pin;
791
792         if (!ioapic_entries)
793                 return -ENOMEM;
794
795         for (apic = 0; apic < nr_ioapics; apic++) {
796                 if (!ioapic_entries[apic])
797                         return -ENOMEM;
798
799                 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++)
800                         ioapic_write_entry(apic, pin,
801                                         ioapic_entries[apic][pin]);
802         }
803         return 0;
804 }
805
806 void free_ioapic_entries(struct IO_APIC_route_entry **ioapic_entries)
807 {
808         int apic;
809
810         for (apic = 0; apic < nr_ioapics; apic++)
811                 kfree(ioapic_entries[apic]);
812
813         kfree(ioapic_entries);
814 }
815
816 /*
817  * Find the IRQ entry number of a certain pin.
818  */
819 static int find_irq_entry(int apic, int pin, int type)
820 {
821         int i;
822
823         for (i = 0; i < mp_irq_entries; i++)
824                 if (mp_irqs[i].irqtype == type &&
825                     (mp_irqs[i].dstapic == mp_ioapics[apic].apicid ||
826                      mp_irqs[i].dstapic == MP_APIC_ALL) &&
827                     mp_irqs[i].dstirq == pin)
828                         return i;
829
830         return -1;
831 }
832
833 /*
834  * Find the pin to which IRQ[irq] (ISA) is connected
835  */
836 static int __init find_isa_irq_pin(int irq, int type)
837 {
838         int i;
839
840         for (i = 0; i < mp_irq_entries; i++) {
841                 int lbus = mp_irqs[i].srcbus;
842
843                 if (test_bit(lbus, mp_bus_not_pci) &&
844                     (mp_irqs[i].irqtype == type) &&
845                     (mp_irqs[i].srcbusirq == irq))
846
847                         return mp_irqs[i].dstirq;
848         }
849         return -1;
850 }
851
852 static int __init find_isa_irq_apic(int irq, int type)
853 {
854         int i;
855
856         for (i = 0; i < mp_irq_entries; i++) {
857                 int lbus = mp_irqs[i].srcbus;
858
859                 if (test_bit(lbus, mp_bus_not_pci) &&
860                     (mp_irqs[i].irqtype == type) &&
861                     (mp_irqs[i].srcbusirq == irq))
862                         break;
863         }
864         if (i < mp_irq_entries) {
865                 int apic;
866                 for(apic = 0; apic < nr_ioapics; apic++) {
867                         if (mp_ioapics[apic].apicid == mp_irqs[i].dstapic)
868                                 return apic;
869                 }
870         }
871
872         return -1;
873 }
874
875 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
876 /*
877  * EISA Edge/Level control register, ELCR
878  */
879 static int EISA_ELCR(unsigned int irq)
880 {
881         if (irq < nr_legacy_irqs) {
882                 unsigned int port = 0x4d0 + (irq >> 3);
883                 return (inb(port) >> (irq & 7)) & 1;
884         }
885         apic_printk(APIC_VERBOSE, KERN_INFO
886                         "Broken MPtable reports ISA irq %d\n", irq);
887         return 0;
888 }
889
890 #endif
891
892 /* ISA interrupts are always polarity zero edge triggered,
893  * when listed as conforming in the MP table. */
894
895 #define default_ISA_trigger(idx)        (0)
896 #define default_ISA_polarity(idx)       (0)
897
898 /* EISA interrupts are always polarity zero and can be edge or level
899  * trigger depending on the ELCR value.  If an interrupt is listed as
900  * EISA conforming in the MP table, that means its trigger type must
901  * be read in from the ELCR */
902
903 #define default_EISA_trigger(idx)       (EISA_ELCR(mp_irqs[idx].srcbusirq))
904 #define default_EISA_polarity(idx)      default_ISA_polarity(idx)
905
906 /* PCI interrupts are always polarity one level triggered,
907  * when listed as conforming in the MP table. */
908
909 #define default_PCI_trigger(idx)        (1)
910 #define default_PCI_polarity(idx)       (1)
911
912 /* MCA interrupts are always polarity zero level triggered,
913  * when listed as conforming in the MP table. */
914
915 #define default_MCA_trigger(idx)        (1)
916 #define default_MCA_polarity(idx)       default_ISA_polarity(idx)
917
918 static int MPBIOS_polarity(int idx)
919 {
920         int bus = mp_irqs[idx].srcbus;
921         int polarity;
922
923         /*
924          * Determine IRQ line polarity (high active or low active):
925          */
926         switch (mp_irqs[idx].irqflag & 3)
927         {
928                 case 0: /* conforms, ie. bus-type dependent polarity */
929                         if (test_bit(bus, mp_bus_not_pci))
930                                 polarity = default_ISA_polarity(idx);
931                         else
932                                 polarity = default_PCI_polarity(idx);
933                         break;
934                 case 1: /* high active */
935                 {
936                         polarity = 0;
937                         break;
938                 }
939                 case 2: /* reserved */
940                 {
941                         printk(KERN_WARNING "broken BIOS!!\n");
942                         polarity = 1;
943                         break;
944                 }
945                 case 3: /* low active */
946                 {
947                         polarity = 1;
948                         break;
949                 }
950                 default: /* invalid */
951                 {
952                         printk(KERN_WARNING "broken BIOS!!\n");
953                         polarity = 1;
954                         break;
955                 }
956         }
957         return polarity;
958 }
959
960 static int MPBIOS_trigger(int idx)
961 {
962         int bus = mp_irqs[idx].srcbus;
963         int trigger;
964
965         /*
966          * Determine IRQ trigger mode (edge or level sensitive):
967          */
968         switch ((mp_irqs[idx].irqflag>>2) & 3)
969         {
970                 case 0: /* conforms, ie. bus-type dependent */
971                         if (test_bit(bus, mp_bus_not_pci))
972                                 trigger = default_ISA_trigger(idx);
973                         else
974                                 trigger = default_PCI_trigger(idx);
975 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
976                         switch (mp_bus_id_to_type[bus]) {
977                                 case MP_BUS_ISA: /* ISA pin */
978                                 {
979                                         /* set before the switch */
980                                         break;
981                                 }
982                                 case MP_BUS_EISA: /* EISA pin */
983                                 {
984                                         trigger = default_EISA_trigger(idx);
985                                         break;
986                                 }
987                                 case MP_BUS_PCI: /* PCI pin */
988                                 {
989                                         /* set before the switch */
990                                         break;
991                                 }
992                                 case MP_BUS_MCA: /* MCA pin */
993                                 {
994                                         trigger = default_MCA_trigger(idx);
995                                         break;
996                                 }
997                                 default:
998                                 {
999                                         printk(KERN_WARNING "broken BIOS!!\n");
1000                                         trigger = 1;
1001                                         break;
1002                                 }
1003                         }
1004 #endif
1005                         break;
1006                 case 1: /* edge */
1007                 {
1008                         trigger = 0;
1009                         break;
1010                 }
1011                 case 2: /* reserved */
1012                 {
1013                         printk(KERN_WARNING "broken BIOS!!\n");
1014                         trigger = 1;
1015                         break;
1016                 }
1017                 case 3: /* level */
1018                 {
1019                         trigger = 1;
1020                         break;
1021                 }
1022                 default: /* invalid */
1023                 {
1024                         printk(KERN_WARNING "broken BIOS!!\n");
1025                         trigger = 0;
1026                         break;
1027                 }
1028         }
1029         return trigger;
1030 }
1031
1032 static inline int irq_polarity(int idx)
1033 {
1034         return MPBIOS_polarity(idx);
1035 }
1036
1037 static inline int irq_trigger(int idx)
1038 {
1039         return MPBIOS_trigger(idx);
1040 }
1041
1042 int (*ioapic_renumber_irq)(int ioapic, int irq);
1043 static int pin_2_irq(int idx, int apic, int pin)
1044 {
1045         int irq, i;
1046         int bus = mp_irqs[idx].srcbus;
1047
1048         /*
1049          * Debugging check, we are in big trouble if this message pops up!
1050          */
1051         if (mp_irqs[idx].dstirq != pin)
1052                 printk(KERN_ERR "broken BIOS or MPTABLE parser, ayiee!!\n");
1053
1054         if (test_bit(bus, mp_bus_not_pci)) {
1055                 irq = mp_irqs[idx].srcbusirq;
1056         } else {
1057                 /*
1058                  * PCI IRQs are mapped in order
1059                  */
1060                 i = irq = 0;
1061                 while (i < apic)
1062                         irq += nr_ioapic_registers[i++];
1063                 irq += pin;
1064                 /*
1065                  * For MPS mode, so far only needed by ES7000 platform
1066                  */
1067                 if (ioapic_renumber_irq)
1068                         irq = ioapic_renumber_irq(apic, irq);
1069         }
1070
1071 #ifdef CONFIG_X86_32
1072         /*
1073          * PCI IRQ command line redirection. Yes, limits are hardcoded.
1074          */
1075         if ((pin >= 16) && (pin <= 23)) {
1076                 if (pirq_entries[pin-16] != -1) {
1077                         if (!pirq_entries[pin-16]) {
1078                                 apic_printk(APIC_VERBOSE, KERN_DEBUG
1079                                                 "disabling PIRQ%d\n", pin-16);
1080                         } else {
1081                                 irq = pirq_entries[pin-16];
1082                                 apic_printk(APIC_VERBOSE, KERN_DEBUG
1083                                                 "using PIRQ%d -> IRQ %d\n",
1084                                                 pin-16, irq);
1085                         }
1086                 }
1087         }
1088 #endif
1089
1090         return irq;
1091 }
1092
1093 /*
1094  * Find a specific PCI IRQ entry.
1095  * Not an __init, possibly needed by modules
1096  */
1097 int IO_APIC_get_PCI_irq_vector(int bus, int slot, int pin,
1098                                 struct io_apic_irq_attr *irq_attr)
1099 {
1100         int apic, i, best_guess = -1;
1101
1102         apic_printk(APIC_DEBUG,
1103                     "querying PCI -> IRQ mapping bus:%d, slot:%d, pin:%d.\n",
1104                     bus, slot, pin);
1105         if (test_bit(bus, mp_bus_not_pci)) {
1106                 apic_printk(APIC_VERBOSE,
1107                             "PCI BIOS passed nonexistent PCI bus %d!\n", bus);
1108                 return -1;
1109         }
1110         for (i = 0; i < mp_irq_entries; i++) {
1111                 int lbus = mp_irqs[i].srcbus;
1112
1113                 for (apic = 0; apic < nr_ioapics; apic++)
1114                         if (mp_ioapics[apic].apicid == mp_irqs[i].dstapic ||
1115                             mp_irqs[i].dstapic == MP_APIC_ALL)
1116                                 break;
1117
1118                 if (!test_bit(lbus, mp_bus_not_pci) &&
1119                     !mp_irqs[i].irqtype &&
1120                     (bus == lbus) &&
1121                     (slot == ((mp_irqs[i].srcbusirq >> 2) & 0x1f))) {
1122                         int irq = pin_2_irq(i, apic, mp_irqs[i].dstirq);
1123
1124                         if (!(apic || IO_APIC_IRQ(irq)))
1125                                 continue;
1126
1127                         if (pin == (mp_irqs[i].srcbusirq & 3)) {
1128                                 set_io_apic_irq_attr(irq_attr, apic,
1129                                                      mp_irqs[i].dstirq,
1130                                                      irq_trigger(i),
1131                                                      irq_polarity(i));
1132                                 return irq;
1133                         }
1134                         /*
1135                          * Use the first all-but-pin matching entry as a
1136                          * best-guess fuzzy result for broken mptables.
1137                          */
1138                         if (best_guess < 0) {
1139                                 set_io_apic_irq_attr(irq_attr, apic,
1140                                                      mp_irqs[i].dstirq,
1141                                                      irq_trigger(i),
1142                                                      irq_polarity(i));
1143                                 best_guess = irq;
1144                         }
1145                 }
1146         }
1147         return best_guess;
1148 }
1149 EXPORT_SYMBOL(IO_APIC_get_PCI_irq_vector);
1150
1151 void lock_vector_lock(void)
1152 {
1153         /* Used to the online set of cpus does not change
1154          * during assign_irq_vector.
1155          */
1156         spin_lock(&vector_lock);
1157 }
1158
1159 void unlock_vector_lock(void)
1160 {
1161         spin_unlock(&vector_lock);
1162 }
1163
1164 static int
1165 __assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
1166 {
1167         /*
1168          * NOTE! The local APIC isn't very good at handling
1169          * multiple interrupts at the same interrupt level.
1170          * As the interrupt level is determined by taking the
1171          * vector number and shifting that right by 4, we
1172          * want to spread these out a bit so that they don't
1173          * all fall in the same interrupt level.
1174          *
1175          * Also, we've got to be careful not to trash gate
1176          * 0x80, because int 0x80 is hm, kind of importantish. ;)
1177          */
1178         static int current_vector = FIRST_DEVICE_VECTOR, current_offset = 0;
1179         unsigned int old_vector;
1180         int cpu, err;
1181         cpumask_var_t tmp_mask;
1182
1183         if ((cfg->move_in_progress) || cfg->move_cleanup_count)
1184                 return -EBUSY;
1185
1186         if (!alloc_cpumask_var(&tmp_mask, GFP_ATOMIC))
1187                 return -ENOMEM;
1188
1189         old_vector = cfg->vector;
1190         if (old_vector) {
1191                 cpumask_and(tmp_mask, mask, cpu_online_mask);
1192                 cpumask_and(tmp_mask, cfg->domain, tmp_mask);
1193                 if (!cpumask_empty(tmp_mask)) {
1194                         free_cpumask_var(tmp_mask);
1195                         return 0;
1196                 }
1197         }
1198
1199         /* Only try and allocate irqs on cpus that are present */
1200         err = -ENOSPC;
1201         for_each_cpu_and(cpu, mask, cpu_online_mask) {
1202                 int new_cpu;
1203                 int vector, offset;
1204
1205                 apic->vector_allocation_domain(cpu, tmp_mask);
1206
1207                 vector = current_vector;
1208                 offset = current_offset;
1209 next:
1210                 vector += 8;
1211                 if (vector >= first_system_vector) {
1212                         /* If out of vectors on large boxen, must share them. */
1213                         offset = (offset + 1) % 8;
1214                         vector = FIRST_DEVICE_VECTOR + offset;
1215                 }
1216                 if (unlikely(current_vector == vector))
1217                         continue;
1218
1219                 if (test_bit(vector, used_vectors))
1220                         goto next;
1221
1222                 for_each_cpu_and(new_cpu, tmp_mask, cpu_online_mask)
1223                         if (per_cpu(vector_irq, new_cpu)[vector] != -1)
1224                                 goto next;
1225                 /* Found one! */
1226                 current_vector = vector;
1227                 current_offset = offset;
1228                 if (old_vector) {
1229                         cfg->move_in_progress = 1;
1230                         cpumask_copy(cfg->old_domain, cfg->domain);
1231                 }
1232                 for_each_cpu_and(new_cpu, tmp_mask, cpu_online_mask)
1233                         per_cpu(vector_irq, new_cpu)[vector] = irq;
1234                 cfg->vector = vector;
1235                 cpumask_copy(cfg->domain, tmp_mask);
1236                 err = 0;
1237                 break;
1238         }
1239         free_cpumask_var(tmp_mask);
1240         return err;
1241 }
1242
1243 static int
1244 assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
1245 {
1246         int err;
1247         unsigned long flags;
1248
1249         spin_lock_irqsave(&vector_lock, flags);
1250         err = __assign_irq_vector(irq, cfg, mask);
1251         spin_unlock_irqrestore(&vector_lock, flags);
1252         return err;
1253 }
1254
1255 static void __clear_irq_vector(int irq, struct irq_cfg *cfg)
1256 {
1257         int cpu, vector;
1258
1259         BUG_ON(!cfg->vector);
1260
1261         vector = cfg->vector;
1262         for_each_cpu_and(cpu, cfg->domain, cpu_online_mask)
1263                 per_cpu(vector_irq, cpu)[vector] = -1;
1264
1265         cfg->vector = 0;
1266         cpumask_clear(cfg->domain);
1267
1268         if (likely(!cfg->move_in_progress))
1269                 return;
1270         for_each_cpu_and(cpu, cfg->old_domain, cpu_online_mask) {
1271                 for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS;
1272                                                                 vector++) {
1273                         if (per_cpu(vector_irq, cpu)[vector] != irq)
1274                                 continue;
1275                         per_cpu(vector_irq, cpu)[vector] = -1;
1276                         break;
1277                 }
1278         }
1279         cfg->move_in_progress = 0;
1280 }
1281
1282 void __setup_vector_irq(int cpu)
1283 {
1284         /* Initialize vector_irq on a new cpu */
1285         /* This function must be called with vector_lock held */
1286         int irq, vector;
1287         struct irq_cfg *cfg;
1288         struct irq_desc *desc;
1289
1290         /* Mark the inuse vectors */
1291         for_each_irq_desc(irq, desc) {
1292                 cfg = desc->chip_data;
1293                 if (!cpumask_test_cpu(cpu, cfg->domain))
1294                         continue;
1295                 vector = cfg->vector;
1296                 per_cpu(vector_irq, cpu)[vector] = irq;
1297         }
1298         /* Mark the free vectors */
1299         for (vector = 0; vector < NR_VECTORS; ++vector) {
1300                 irq = per_cpu(vector_irq, cpu)[vector];
1301                 if (irq < 0)
1302                         continue;
1303
1304                 cfg = irq_cfg(irq);
1305                 if (!cpumask_test_cpu(cpu, cfg->domain))
1306                         per_cpu(vector_irq, cpu)[vector] = -1;
1307         }
1308 }
1309
1310 static struct irq_chip ioapic_chip;
1311 static struct irq_chip ir_ioapic_chip;
1312
1313 #define IOAPIC_AUTO     -1
1314 #define IOAPIC_EDGE     0
1315 #define IOAPIC_LEVEL    1
1316
1317 #ifdef CONFIG_X86_32
1318 static inline int IO_APIC_irq_trigger(int irq)
1319 {
1320         int apic, idx, pin;
1321
1322         for (apic = 0; apic < nr_ioapics; apic++) {
1323                 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
1324                         idx = find_irq_entry(apic, pin, mp_INT);
1325                         if ((idx != -1) && (irq == pin_2_irq(idx, apic, pin)))
1326                                 return irq_trigger(idx);
1327                 }
1328         }
1329         /*
1330          * nonexistent IRQs are edge default
1331          */
1332         return 0;
1333 }
1334 #else
1335 static inline int IO_APIC_irq_trigger(int irq)
1336 {
1337         return 1;
1338 }
1339 #endif
1340
1341 static void ioapic_register_intr(int irq, struct irq_desc *desc, unsigned long trigger)
1342 {
1343
1344         if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) ||
1345             trigger == IOAPIC_LEVEL)
1346                 desc->status |= IRQ_LEVEL;
1347         else
1348                 desc->status &= ~IRQ_LEVEL;
1349
1350         if (irq_remapped(irq)) {
1351                 desc->status |= IRQ_MOVE_PCNTXT;
1352                 if (trigger)
1353                         set_irq_chip_and_handler_name(irq, &ir_ioapic_chip,
1354                                                       handle_fasteoi_irq,
1355                                                      "fasteoi");
1356                 else
1357                         set_irq_chip_and_handler_name(irq, &ir_ioapic_chip,
1358                                                       handle_edge_irq, "edge");
1359                 return;
1360         }
1361
1362         if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) ||
1363             trigger == IOAPIC_LEVEL)
1364                 set_irq_chip_and_handler_name(irq, &ioapic_chip,
1365                                               handle_fasteoi_irq,
1366                                               "fasteoi");
1367         else
1368                 set_irq_chip_and_handler_name(irq, &ioapic_chip,
1369                                               handle_edge_irq, "edge");
1370 }
1371
1372 int setup_ioapic_entry(int apic_id, int irq,
1373                        struct IO_APIC_route_entry *entry,
1374                        unsigned int destination, int trigger,
1375                        int polarity, int vector, int pin)
1376 {
1377         /*
1378          * add it to the IO-APIC irq-routing table:
1379          */
1380         memset(entry,0,sizeof(*entry));
1381
1382         if (intr_remapping_enabled) {
1383                 struct intel_iommu *iommu = map_ioapic_to_ir(apic_id);
1384                 struct irte irte;
1385                 struct IR_IO_APIC_route_entry *ir_entry =
1386                         (struct IR_IO_APIC_route_entry *) entry;
1387                 int index;
1388
1389                 if (!iommu)
1390                         panic("No mapping iommu for ioapic %d\n", apic_id);
1391
1392                 index = alloc_irte(iommu, irq, 1);
1393                 if (index < 0)
1394                         panic("Failed to allocate IRTE for ioapic %d\n", apic_id);
1395
1396                 memset(&irte, 0, sizeof(irte));
1397
1398                 irte.present = 1;
1399                 irte.dst_mode = apic->irq_dest_mode;
1400                 /*
1401                  * Trigger mode in the IRTE will always be edge, and the
1402                  * actual level or edge trigger will be setup in the IO-APIC
1403                  * RTE. This will help simplify level triggered irq migration.
1404                  * For more details, see the comments above explainig IO-APIC
1405                  * irq migration in the presence of interrupt-remapping.
1406                  */
1407                 irte.trigger_mode = 0;
1408                 irte.dlvry_mode = apic->irq_delivery_mode;
1409                 irte.vector = vector;
1410                 irte.dest_id = IRTE_DEST(destination);
1411
1412                 /* Set source-id of interrupt request */
1413                 set_ioapic_sid(&irte, apic_id);
1414
1415                 modify_irte(irq, &irte);
1416
1417                 ir_entry->index2 = (index >> 15) & 0x1;
1418                 ir_entry->zero = 0;
1419                 ir_entry->format = 1;
1420                 ir_entry->index = (index & 0x7fff);
1421                 /*
1422                  * IO-APIC RTE will be configured with virtual vector.
1423                  * irq handler will do the explicit EOI to the io-apic.
1424                  */
1425                 ir_entry->vector = pin;
1426         } else {
1427                 entry->delivery_mode = apic->irq_delivery_mode;
1428                 entry->dest_mode = apic->irq_dest_mode;
1429                 entry->dest = destination;
1430                 entry->vector = vector;
1431         }
1432
1433         entry->mask = 0;                                /* enable IRQ */
1434         entry->trigger = trigger;
1435         entry->polarity = polarity;
1436
1437         /* Mask level triggered irqs.
1438          * Use IRQ_DELAYED_DISABLE for edge triggered irqs.
1439          */
1440         if (trigger)
1441                 entry->mask = 1;
1442         return 0;
1443 }
1444
1445 static void setup_IO_APIC_irq(int apic_id, int pin, unsigned int irq, struct irq_desc *desc,
1446                               int trigger, int polarity)
1447 {
1448         struct irq_cfg *cfg;
1449         struct IO_APIC_route_entry entry;
1450         unsigned int dest;
1451
1452         if (!IO_APIC_IRQ(irq))
1453                 return;
1454
1455         cfg = desc->chip_data;
1456
1457         if (assign_irq_vector(irq, cfg, apic->target_cpus()))
1458                 return;
1459
1460         dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus());
1461
1462         apic_printk(APIC_VERBOSE,KERN_DEBUG
1463                     "IOAPIC[%d]: Set routing entry (%d-%d -> 0x%x -> "
1464                     "IRQ %d Mode:%i Active:%i)\n",
1465                     apic_id, mp_ioapics[apic_id].apicid, pin, cfg->vector,
1466                     irq, trigger, polarity);
1467
1468
1469         if (setup_ioapic_entry(mp_ioapics[apic_id].apicid, irq, &entry,
1470                                dest, trigger, polarity, cfg->vector, pin)) {
1471                 printk("Failed to setup ioapic entry for ioapic  %d, pin %d\n",
1472                        mp_ioapics[apic_id].apicid, pin);
1473                 __clear_irq_vector(irq, cfg);
1474                 return;
1475         }
1476
1477         ioapic_register_intr(irq, desc, trigger);
1478         if (irq < nr_legacy_irqs)
1479                 disable_8259A_irq(irq);
1480
1481         ioapic_write_entry(apic_id, pin, entry);
1482 }
1483
1484 static struct {
1485         DECLARE_BITMAP(pin_programmed, MP_MAX_IOAPIC_PIN + 1);
1486 } mp_ioapic_routing[MAX_IO_APICS];
1487
1488 static void __init setup_IO_APIC_irqs(void)
1489 {
1490         int apic_id = 0, pin, idx, irq;
1491         int notcon = 0;
1492         struct irq_desc *desc;
1493         struct irq_cfg *cfg;
1494         int node = cpu_to_node(boot_cpu_id);
1495
1496         apic_printk(APIC_VERBOSE, KERN_DEBUG "init IO_APIC IRQs\n");
1497
1498 #ifdef CONFIG_ACPI
1499         if (!acpi_disabled && acpi_ioapic) {
1500                 apic_id = mp_find_ioapic(0);
1501                 if (apic_id < 0)
1502                         apic_id = 0;
1503         }
1504 #endif
1505
1506         for (pin = 0; pin < nr_ioapic_registers[apic_id]; pin++) {
1507                 idx = find_irq_entry(apic_id, pin, mp_INT);
1508                 if (idx == -1) {
1509                         if (!notcon) {
1510                                 notcon = 1;
1511                                 apic_printk(APIC_VERBOSE,
1512                                         KERN_DEBUG " %d-%d",
1513                                         mp_ioapics[apic_id].apicid, pin);
1514                         } else
1515                                 apic_printk(APIC_VERBOSE, " %d-%d",
1516                                         mp_ioapics[apic_id].apicid, pin);
1517                         continue;
1518                 }
1519                 if (notcon) {
1520                         apic_printk(APIC_VERBOSE,
1521                                 " (apicid-pin) not connected\n");
1522                         notcon = 0;
1523                 }
1524
1525                 irq = pin_2_irq(idx, apic_id, pin);
1526
1527                 /*
1528                  * Skip the timer IRQ if there's a quirk handler
1529                  * installed and if it returns 1:
1530                  */
1531                 if (apic->multi_timer_check &&
1532                                 apic->multi_timer_check(apic_id, irq))
1533                         continue;
1534
1535                 desc = irq_to_desc_alloc_node(irq, node);
1536                 if (!desc) {
1537                         printk(KERN_INFO "can not get irq_desc for %d\n", irq);
1538                         continue;
1539                 }
1540                 cfg = desc->chip_data;
1541                 add_pin_to_irq_node(cfg, node, apic_id, pin);
1542                 /*
1543                  * don't mark it in pin_programmed, so later acpi could
1544                  * set it correctly when irq < 16
1545                  */
1546                 setup_IO_APIC_irq(apic_id, pin, irq, desc,
1547                                 irq_trigger(idx), irq_polarity(idx));
1548         }
1549
1550         if (notcon)
1551                 apic_printk(APIC_VERBOSE,
1552                         " (apicid-pin) not connected\n");
1553 }
1554
1555 /*
1556  * Set up the timer pin, possibly with the 8259A-master behind.
1557  */
1558 static void __init setup_timer_IRQ0_pin(unsigned int apic_id, unsigned int pin,
1559                                         int vector)
1560 {
1561         struct IO_APIC_route_entry entry;
1562
1563         if (intr_remapping_enabled)
1564                 return;
1565
1566         memset(&entry, 0, sizeof(entry));
1567
1568         /*
1569          * We use logical delivery to get the timer IRQ
1570          * to the first CPU.
1571          */
1572         entry.dest_mode = apic->irq_dest_mode;
1573         entry.mask = 0;                 /* don't mask IRQ for edge */
1574         entry.dest = apic->cpu_mask_to_apicid(apic->target_cpus());
1575         entry.delivery_mode = apic->irq_delivery_mode;
1576         entry.polarity = 0;
1577         entry.trigger = 0;
1578         entry.vector = vector;
1579
1580         /*
1581          * The timer IRQ doesn't have to know that behind the
1582          * scene we may have a 8259A-master in AEOI mode ...
1583          */
1584         set_irq_chip_and_handler_name(0, &ioapic_chip, handle_edge_irq, "edge");
1585
1586         /*
1587          * Add it to the IO-APIC irq-routing table:
1588          */
1589         ioapic_write_entry(apic_id, pin, entry);
1590 }
1591
1592
1593 __apicdebuginit(void) print_IO_APIC(void)
1594 {
1595         int apic, i;
1596         union IO_APIC_reg_00 reg_00;
1597         union IO_APIC_reg_01 reg_01;
1598         union IO_APIC_reg_02 reg_02;
1599         union IO_APIC_reg_03 reg_03;
1600         unsigned long flags;
1601         struct irq_cfg *cfg;
1602         struct irq_desc *desc;
1603         unsigned int irq;
1604
1605         if (apic_verbosity == APIC_QUIET)
1606                 return;
1607
1608         printk(KERN_DEBUG "number of MP IRQ sources: %d.\n", mp_irq_entries);
1609         for (i = 0; i < nr_ioapics; i++)
1610                 printk(KERN_DEBUG "number of IO-APIC #%d registers: %d.\n",
1611                        mp_ioapics[i].apicid, nr_ioapic_registers[i]);
1612
1613         /*
1614          * We are a bit conservative about what we expect.  We have to
1615          * know about every hardware change ASAP.
1616          */
1617         printk(KERN_INFO "testing the IO APIC.......................\n");
1618
1619         for (apic = 0; apic < nr_ioapics; apic++) {
1620
1621         spin_lock_irqsave(&ioapic_lock, flags);
1622         reg_00.raw = io_apic_read(apic, 0);
1623         reg_01.raw = io_apic_read(apic, 1);
1624         if (reg_01.bits.version >= 0x10)
1625                 reg_02.raw = io_apic_read(apic, 2);
1626         if (reg_01.bits.version >= 0x20)
1627                 reg_03.raw = io_apic_read(apic, 3);
1628         spin_unlock_irqrestore(&ioapic_lock, flags);
1629
1630         printk("\n");
1631         printk(KERN_DEBUG "IO APIC #%d......\n", mp_ioapics[apic].apicid);
1632         printk(KERN_DEBUG ".... register #00: %08X\n", reg_00.raw);
1633         printk(KERN_DEBUG ".......    : physical APIC id: %02X\n", reg_00.bits.ID);
1634         printk(KERN_DEBUG ".......    : Delivery Type: %X\n", reg_00.bits.delivery_type);
1635         printk(KERN_DEBUG ".......    : LTS          : %X\n", reg_00.bits.LTS);
1636
1637         printk(KERN_DEBUG ".... register #01: %08X\n", *(int *)&reg_01);
1638         printk(KERN_DEBUG ".......     : max redirection entries: %04X\n", reg_01.bits.entries);
1639
1640         printk(KERN_DEBUG ".......     : PRQ implemented: %X\n", reg_01.bits.PRQ);
1641         printk(KERN_DEBUG ".......     : IO APIC version: %04X\n", reg_01.bits.version);
1642
1643         /*
1644          * Some Intel chipsets with IO APIC VERSION of 0x1? don't have reg_02,
1645          * but the value of reg_02 is read as the previous read register
1646          * value, so ignore it if reg_02 == reg_01.
1647          */
1648         if (reg_01.bits.version >= 0x10 && reg_02.raw != reg_01.raw) {
1649                 printk(KERN_DEBUG ".... register #02: %08X\n", reg_02.raw);
1650                 printk(KERN_DEBUG ".......     : arbitration: %02X\n", reg_02.bits.arbitration);
1651         }
1652
1653         /*
1654          * Some Intel chipsets with IO APIC VERSION of 0x2? don't have reg_02
1655          * or reg_03, but the value of reg_0[23] is read as the previous read
1656          * register value, so ignore it if reg_03 == reg_0[12].
1657          */
1658         if (reg_01.bits.version >= 0x20 && reg_03.raw != reg_02.raw &&
1659             reg_03.raw != reg_01.raw) {
1660                 printk(KERN_DEBUG ".... register #03: %08X\n", reg_03.raw);
1661                 printk(KERN_DEBUG ".......     : Boot DT    : %X\n", reg_03.bits.boot_DT);
1662         }
1663
1664         printk(KERN_DEBUG ".... IRQ redirection table:\n");
1665
1666         printk(KERN_DEBUG " NR Dst Mask Trig IRR Pol"
1667                           " Stat Dmod Deli Vect:   \n");
1668
1669         for (i = 0; i <= reg_01.bits.entries; i++) {
1670                 struct IO_APIC_route_entry entry;
1671
1672                 entry = ioapic_read_entry(apic, i);
1673
1674                 printk(KERN_DEBUG " %02x %03X ",
1675                         i,
1676                         entry.dest
1677                 );
1678
1679                 printk("%1d    %1d    %1d   %1d   %1d    %1d    %1d    %02X\n",
1680                         entry.mask,
1681                         entry.trigger,
1682                         entry.irr,
1683                         entry.polarity,
1684                         entry.delivery_status,
1685                         entry.dest_mode,
1686                         entry.delivery_mode,
1687                         entry.vector
1688                 );
1689         }
1690         }
1691         printk(KERN_DEBUG "IRQ to pin mappings:\n");
1692         for_each_irq_desc(irq, desc) {
1693                 struct irq_pin_list *entry;
1694
1695                 cfg = desc->chip_data;
1696                 entry = cfg->irq_2_pin;
1697                 if (!entry)
1698                         continue;
1699                 printk(KERN_DEBUG "IRQ%d ", irq);
1700                 for_each_irq_pin(entry, cfg->irq_2_pin)
1701                         printk("-> %d:%d", entry->apic, entry->pin);
1702                 printk("\n");
1703         }
1704
1705         printk(KERN_INFO ".................................... done.\n");
1706
1707         return;
1708 }
1709
1710 __apicdebuginit(void) print_APIC_field(int base)
1711 {
1712         int i;
1713
1714         if (apic_verbosity == APIC_QUIET)
1715                 return;
1716
1717         printk(KERN_DEBUG);
1718
1719         for (i = 0; i < 8; i++)
1720                 printk(KERN_CONT "%08x", apic_read(base + i*0x10));
1721
1722         printk(KERN_CONT "\n");
1723 }
1724
1725 __apicdebuginit(void) print_local_APIC(void *dummy)
1726 {
1727         unsigned int i, v, ver, maxlvt;
1728         u64 icr;
1729
1730         if (apic_verbosity == APIC_QUIET)
1731                 return;
1732
1733         printk(KERN_DEBUG "printing local APIC contents on CPU#%d/%d:\n",
1734                 smp_processor_id(), hard_smp_processor_id());
1735         v = apic_read(APIC_ID);
1736         printk(KERN_INFO "... APIC ID:      %08x (%01x)\n", v, read_apic_id());
1737         v = apic_read(APIC_LVR);
1738         printk(KERN_INFO "... APIC VERSION: %08x\n", v);
1739         ver = GET_APIC_VERSION(v);
1740         maxlvt = lapic_get_maxlvt();
1741
1742         v = apic_read(APIC_TASKPRI);
1743         printk(KERN_DEBUG "... APIC TASKPRI: %08x (%02x)\n", v, v & APIC_TPRI_MASK);
1744
1745         if (APIC_INTEGRATED(ver)) {                     /* !82489DX */
1746                 if (!APIC_XAPIC(ver)) {
1747                         v = apic_read(APIC_ARBPRI);
1748                         printk(KERN_DEBUG "... APIC ARBPRI: %08x (%02x)\n", v,
1749                                v & APIC_ARBPRI_MASK);
1750                 }
1751                 v = apic_read(APIC_PROCPRI);
1752                 printk(KERN_DEBUG "... APIC PROCPRI: %08x\n", v);
1753         }
1754
1755         /*
1756          * Remote read supported only in the 82489DX and local APIC for
1757          * Pentium processors.
1758          */
1759         if (!APIC_INTEGRATED(ver) || maxlvt == 3) {
1760                 v = apic_read(APIC_RRR);
1761                 printk(KERN_DEBUG "... APIC RRR: %08x\n", v);
1762         }
1763
1764         v = apic_read(APIC_LDR);
1765         printk(KERN_DEBUG "... APIC LDR: %08x\n", v);
1766         if (!x2apic_enabled()) {
1767                 v = apic_read(APIC_DFR);
1768                 printk(KERN_DEBUG "... APIC DFR: %08x\n", v);
1769         }
1770         v = apic_read(APIC_SPIV);
1771         printk(KERN_DEBUG "... APIC SPIV: %08x\n", v);
1772
1773         printk(KERN_DEBUG "... APIC ISR field:\n");
1774         print_APIC_field(APIC_ISR);
1775         printk(KERN_DEBUG "... APIC TMR field:\n");
1776         print_APIC_field(APIC_TMR);
1777         printk(KERN_DEBUG "... APIC IRR field:\n");
1778         print_APIC_field(APIC_IRR);
1779
1780         if (APIC_INTEGRATED(ver)) {             /* !82489DX */
1781                 if (maxlvt > 3)         /* Due to the Pentium erratum 3AP. */
1782                         apic_write(APIC_ESR, 0);
1783
1784                 v = apic_read(APIC_ESR);
1785                 printk(KERN_DEBUG "... APIC ESR: %08x\n", v);
1786         }
1787
1788         icr = apic_icr_read();
1789         printk(KERN_DEBUG "... APIC ICR: %08x\n", (u32)icr);
1790         printk(KERN_DEBUG "... APIC ICR2: %08x\n", (u32)(icr >> 32));
1791
1792         v = apic_read(APIC_LVTT);
1793         printk(KERN_DEBUG "... APIC LVTT: %08x\n", v);
1794
1795         if (maxlvt > 3) {                       /* PC is LVT#4. */
1796                 v = apic_read(APIC_LVTPC);
1797                 printk(KERN_DEBUG "... APIC LVTPC: %08x\n", v);
1798         }
1799         v = apic_read(APIC_LVT0);
1800         printk(KERN_DEBUG "... APIC LVT0: %08x\n", v);
1801         v = apic_read(APIC_LVT1);
1802         printk(KERN_DEBUG "... APIC LVT1: %08x\n", v);
1803
1804         if (maxlvt > 2) {                       /* ERR is LVT#3. */
1805                 v = apic_read(APIC_LVTERR);
1806                 printk(KERN_DEBUG "... APIC LVTERR: %08x\n", v);
1807         }
1808
1809         v = apic_read(APIC_TMICT);
1810         printk(KERN_DEBUG "... APIC TMICT: %08x\n", v);
1811         v = apic_read(APIC_TMCCT);
1812         printk(KERN_DEBUG "... APIC TMCCT: %08x\n", v);
1813         v = apic_read(APIC_TDCR);
1814         printk(KERN_DEBUG "... APIC TDCR: %08x\n", v);
1815
1816         if (boot_cpu_has(X86_FEATURE_EXTAPIC)) {
1817                 v = apic_read(APIC_EFEAT);
1818                 maxlvt = (v >> 16) & 0xff;
1819                 printk(KERN_DEBUG "... APIC EFEAT: %08x\n", v);
1820                 v = apic_read(APIC_ECTRL);
1821                 printk(KERN_DEBUG "... APIC ECTRL: %08x\n", v);
1822                 for (i = 0; i < maxlvt; i++) {
1823                         v = apic_read(APIC_EILVTn(i));
1824                         printk(KERN_DEBUG "... APIC EILVT%d: %08x\n", i, v);
1825                 }
1826         }
1827         printk("\n");
1828 }
1829
1830 __apicdebuginit(void) print_all_local_APICs(void)
1831 {
1832         int cpu;
1833
1834         preempt_disable();
1835         for_each_online_cpu(cpu)
1836                 smp_call_function_single(cpu, print_local_APIC, NULL, 1);
1837         preempt_enable();
1838 }
1839
1840 __apicdebuginit(void) print_PIC(void)
1841 {
1842         unsigned int v;
1843         unsigned long flags;
1844
1845         if (apic_verbosity == APIC_QUIET || !nr_legacy_irqs)
1846                 return;
1847
1848         printk(KERN_DEBUG "\nprinting PIC contents\n");
1849
1850         spin_lock_irqsave(&i8259A_lock, flags);
1851
1852         v = inb(0xa1) << 8 | inb(0x21);
1853         printk(KERN_DEBUG "... PIC  IMR: %04x\n", v);
1854
1855         v = inb(0xa0) << 8 | inb(0x20);
1856         printk(KERN_DEBUG "... PIC  IRR: %04x\n", v);
1857
1858         outb(0x0b,0xa0);
1859         outb(0x0b,0x20);
1860         v = inb(0xa0) << 8 | inb(0x20);
1861         outb(0x0a,0xa0);
1862         outb(0x0a,0x20);
1863
1864         spin_unlock_irqrestore(&i8259A_lock, flags);
1865
1866         printk(KERN_DEBUG "... PIC  ISR: %04x\n", v);
1867
1868         v = inb(0x4d1) << 8 | inb(0x4d0);
1869         printk(KERN_DEBUG "... PIC ELCR: %04x\n", v);
1870 }
1871
1872 __apicdebuginit(int) print_all_ICs(void)
1873 {
1874         print_PIC();
1875
1876         /* don't print out if apic is not there */
1877         if (!cpu_has_apic || disable_apic)
1878                 return 0;
1879
1880         print_all_local_APICs();
1881         print_IO_APIC();
1882
1883         return 0;
1884 }
1885
1886 fs_initcall(print_all_ICs);
1887
1888
1889 /* Where if anywhere is the i8259 connect in external int mode */
1890 static struct { int pin, apic; } ioapic_i8259 = { -1, -1 };
1891
1892 void __init enable_IO_APIC(void)
1893 {
1894         union IO_APIC_reg_01 reg_01;
1895         int i8259_apic, i8259_pin;
1896         int apic;
1897         unsigned long flags;
1898
1899         /*
1900          * The number of IO-APIC IRQ registers (== #pins):
1901          */
1902         for (apic = 0; apic < nr_ioapics; apic++) {
1903                 spin_lock_irqsave(&ioapic_lock, flags);
1904                 reg_01.raw = io_apic_read(apic, 1);
1905                 spin_unlock_irqrestore(&ioapic_lock, flags);
1906                 nr_ioapic_registers[apic] = reg_01.bits.entries+1;
1907         }
1908
1909         if (!nr_legacy_irqs)
1910                 return;
1911
1912         for(apic = 0; apic < nr_ioapics; apic++) {
1913                 int pin;
1914                 /* See if any of the pins is in ExtINT mode */
1915                 for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
1916                         struct IO_APIC_route_entry entry;
1917                         entry = ioapic_read_entry(apic, pin);
1918
1919                         /* If the interrupt line is enabled and in ExtInt mode
1920                          * I have found the pin where the i8259 is connected.
1921                          */
1922                         if ((entry.mask == 0) && (entry.delivery_mode == dest_ExtINT)) {
1923                                 ioapic_i8259.apic = apic;
1924                                 ioapic_i8259.pin  = pin;
1925                                 goto found_i8259;
1926                         }
1927                 }
1928         }
1929  found_i8259:
1930         /* Look to see what if the MP table has reported the ExtINT */
1931         /* If we could not find the appropriate pin by looking at the ioapic
1932          * the i8259 probably is not connected the ioapic but give the
1933          * mptable a chance anyway.
1934          */
1935         i8259_pin  = find_isa_irq_pin(0, mp_ExtINT);
1936         i8259_apic = find_isa_irq_apic(0, mp_ExtINT);
1937         /* Trust the MP table if nothing is setup in the hardware */
1938         if ((ioapic_i8259.pin == -1) && (i8259_pin >= 0)) {
1939                 printk(KERN_WARNING "ExtINT not setup in hardware but reported by MP table\n");
1940                 ioapic_i8259.pin  = i8259_pin;
1941                 ioapic_i8259.apic = i8259_apic;
1942         }
1943         /* Complain if the MP table and the hardware disagree */
1944         if (((ioapic_i8259.apic != i8259_apic) || (ioapic_i8259.pin != i8259_pin)) &&
1945                 (i8259_pin >= 0) && (ioapic_i8259.pin >= 0))
1946         {
1947                 printk(KERN_WARNING "ExtINT in hardware and MP table differ\n");
1948         }
1949
1950         /*
1951          * Do not trust the IO-APIC being empty at bootup
1952          */
1953         clear_IO_APIC();
1954 }
1955
1956 /*
1957  * Not an __init, needed by the reboot code
1958  */
1959 void disable_IO_APIC(void)
1960 {
1961         /*
1962          * Clear the IO-APIC before rebooting:
1963          */
1964         clear_IO_APIC();
1965
1966         if (!nr_legacy_irqs)
1967                 return;
1968
1969         /*
1970          * If the i8259 is routed through an IOAPIC
1971          * Put that IOAPIC in virtual wire mode
1972          * so legacy interrupts can be delivered.
1973          *
1974          * With interrupt-remapping, for now we will use virtual wire A mode,
1975          * as virtual wire B is little complex (need to configure both
1976          * IOAPIC RTE aswell as interrupt-remapping table entry).
1977          * As this gets called during crash dump, keep this simple for now.
1978          */
1979         if (ioapic_i8259.pin != -1 && !intr_remapping_enabled) {
1980                 struct IO_APIC_route_entry entry;
1981
1982                 memset(&entry, 0, sizeof(entry));
1983                 entry.mask            = 0; /* Enabled */
1984                 entry.trigger         = 0; /* Edge */
1985                 entry.irr             = 0;
1986                 entry.polarity        = 0; /* High */
1987                 entry.delivery_status = 0;
1988                 entry.dest_mode       = 0; /* Physical */
1989                 entry.delivery_mode   = dest_ExtINT; /* ExtInt */
1990                 entry.vector          = 0;
1991                 entry.dest            = read_apic_id();
1992
1993                 /*
1994                  * Add it to the IO-APIC irq-routing table:
1995                  */
1996                 ioapic_write_entry(ioapic_i8259.apic, ioapic_i8259.pin, entry);
1997         }
1998
1999         /*
2000          * Use virtual wire A mode when interrupt remapping is enabled.
2001          */
2002         if (cpu_has_apic)
2003                 disconnect_bsp_APIC(!intr_remapping_enabled &&
2004                                 ioapic_i8259.pin != -1);
2005 }
2006
2007 #ifdef CONFIG_X86_32
2008 /*
2009  * function to set the IO-APIC physical IDs based on the
2010  * values stored in the MPC table.
2011  *
2012  * by Matt Domsch <Matt_Domsch@dell.com>  Tue Dec 21 12:25:05 CST 1999
2013  */
2014
2015 void __init setup_ioapic_ids_from_mpc(void)
2016 {
2017         union IO_APIC_reg_00 reg_00;
2018         physid_mask_t phys_id_present_map;
2019         int apic_id;
2020         int i;
2021         unsigned char old_id;
2022         unsigned long flags;
2023
2024         if (acpi_ioapic)
2025                 return;
2026         /*
2027          * Don't check I/O APIC IDs for xAPIC systems.  They have
2028          * no meaning without the serial APIC bus.
2029          */
2030         if (!(boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
2031                 || APIC_XAPIC(apic_version[boot_cpu_physical_apicid]))
2032                 return;
2033         /*
2034          * This is broken; anything with a real cpu count has to
2035          * circumvent this idiocy regardless.
2036          */
2037         phys_id_present_map = apic->ioapic_phys_id_map(phys_cpu_present_map);
2038
2039         /*
2040          * Set the IOAPIC ID to the value stored in the MPC table.
2041          */
2042         for (apic_id = 0; apic_id < nr_ioapics; apic_id++) {
2043
2044                 /* Read the register 0 value */
2045                 spin_lock_irqsave(&ioapic_lock, flags);
2046                 reg_00.raw = io_apic_read(apic_id, 0);
2047                 spin_unlock_irqrestore(&ioapic_lock, flags);
2048
2049                 old_id = mp_ioapics[apic_id].apicid;
2050
2051                 if (mp_ioapics[apic_id].apicid >= get_physical_broadcast()) {
2052                         printk(KERN_ERR "BIOS bug, IO-APIC#%d ID is %d in the MPC table!...\n",
2053                                 apic_id, mp_ioapics[apic_id].apicid);
2054                         printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
2055                                 reg_00.bits.ID);
2056                         mp_ioapics[apic_id].apicid = reg_00.bits.ID;
2057                 }
2058
2059                 /*
2060                  * Sanity check, is the ID really free? Every APIC in a
2061                  * system must have a unique ID or we get lots of nice
2062                  * 'stuck on smp_invalidate_needed IPI wait' messages.
2063                  */
2064                 if (apic->check_apicid_used(phys_id_present_map,
2065                                         mp_ioapics[apic_id].apicid)) {
2066                         printk(KERN_ERR "BIOS bug, IO-APIC#%d ID %d is already used!...\n",
2067                                 apic_id, mp_ioapics[apic_id].apicid);
2068                         for (i = 0; i < get_physical_broadcast(); i++)
2069                                 if (!physid_isset(i, phys_id_present_map))
2070                                         break;
2071                         if (i >= get_physical_broadcast())
2072                                 panic("Max APIC ID exceeded!\n");
2073                         printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
2074                                 i);
2075                         physid_set(i, phys_id_present_map);
2076                         mp_ioapics[apic_id].apicid = i;
2077                 } else {
2078                         physid_mask_t tmp;
2079                         tmp = apic->apicid_to_cpu_present(mp_ioapics[apic_id].apicid);
2080                         apic_printk(APIC_VERBOSE, "Setting %d in the "
2081                                         "phys_id_present_map\n",
2082                                         mp_ioapics[apic_id].apicid);
2083                         physids_or(phys_id_present_map, phys_id_present_map, tmp);
2084                 }
2085
2086
2087                 /*
2088                  * We need to adjust the IRQ routing table
2089                  * if the ID changed.
2090                  */
2091                 if (old_id != mp_ioapics[apic_id].apicid)
2092                         for (i = 0; i < mp_irq_entries; i++)
2093                                 if (mp_irqs[i].dstapic == old_id)
2094                                         mp_irqs[i].dstapic
2095                                                 = mp_ioapics[apic_id].apicid;
2096
2097                 /*
2098                  * Read the right value from the MPC table and
2099                  * write it into the ID register.
2100                  */
2101                 apic_printk(APIC_VERBOSE, KERN_INFO
2102                         "...changing IO-APIC physical APIC ID to %d ...",
2103                         mp_ioapics[apic_id].apicid);
2104
2105                 reg_00.bits.ID = mp_ioapics[apic_id].apicid;
2106                 spin_lock_irqsave(&ioapic_lock, flags);
2107                 io_apic_write(apic_id, 0, reg_00.raw);
2108                 spin_unlock_irqrestore(&ioapic_lock, flags);
2109
2110                 /*
2111                  * Sanity check
2112                  */
2113                 spin_lock_irqsave(&ioapic_lock, flags);
2114                 reg_00.raw = io_apic_read(apic_id, 0);
2115                 spin_unlock_irqrestore(&ioapic_lock, flags);
2116                 if (reg_00.bits.ID != mp_ioapics[apic_id].apicid)
2117                         printk("could not set ID!\n");
2118                 else
2119                         apic_printk(APIC_VERBOSE, " ok.\n");
2120         }
2121 }
2122 #endif
2123
2124 int no_timer_check __initdata;
2125
2126 static int __init notimercheck(char *s)
2127 {
2128         no_timer_check = 1;
2129         return 1;
2130 }
2131 __setup("no_timer_check", notimercheck);
2132
2133 /*
2134  * There is a nasty bug in some older SMP boards, their mptable lies
2135  * about the timer IRQ. We do the following to work around the situation:
2136  *
2137  *      - timer IRQ defaults to IO-APIC IRQ
2138  *      - if this function detects that timer IRQs are defunct, then we fall
2139  *        back to ISA timer IRQs
2140  */
2141 static int __init timer_irq_works(void)
2142 {
2143         unsigned long t1 = jiffies;
2144         unsigned long flags;
2145
2146         if (no_timer_check)
2147                 return 1;
2148
2149         local_save_flags(flags);
2150         local_irq_enable();
2151         /* Let ten ticks pass... */
2152         mdelay((10 * 1000) / HZ);
2153         local_irq_restore(flags);
2154
2155         /*
2156          * Expect a few ticks at least, to be sure some possible
2157          * glue logic does not lock up after one or two first
2158          * ticks in a non-ExtINT mode.  Also the local APIC
2159          * might have cached one ExtINT interrupt.  Finally, at
2160          * least one tick may be lost due to delays.
2161          */
2162
2163         /* jiffies wrap? */
2164         if (time_after(jiffies, t1 + 4))
2165                 return 1;
2166         return 0;
2167 }
2168
2169 /*
2170  * In the SMP+IOAPIC case it might happen that there are an unspecified
2171  * number of pending IRQ events unhandled. These cases are very rare,
2172  * so we 'resend' these IRQs via IPIs, to the same CPU. It's much
2173  * better to do it this way as thus we do not have to be aware of
2174  * 'pending' interrupts in the IRQ path, except at this point.
2175  */
2176 /*
2177  * Edge triggered needs to resend any interrupt
2178  * that was delayed but this is now handled in the device
2179  * independent code.
2180  */
2181
2182 /*
2183  * Starting up a edge-triggered IO-APIC interrupt is
2184  * nasty - we need to make sure that we get the edge.
2185  * If it is already asserted for some reason, we need
2186  * return 1 to indicate that is was pending.
2187  *
2188  * This is not complete - we should be able to fake
2189  * an edge even if it isn't on the 8259A...
2190  */
2191
2192 static unsigned int startup_ioapic_irq(unsigned int irq)
2193 {
2194         int was_pending = 0;
2195         unsigned long flags;
2196         struct irq_cfg *cfg;
2197
2198         spin_lock_irqsave(&ioapic_lock, flags);
2199         if (irq < nr_legacy_irqs) {
2200                 disable_8259A_irq(irq);
2201                 if (i8259A_irq_pending(irq))
2202                         was_pending = 1;
2203         }
2204         cfg = irq_cfg(irq);
2205         __unmask_IO_APIC_irq(cfg);
2206         spin_unlock_irqrestore(&ioapic_lock, flags);
2207
2208         return was_pending;
2209 }
2210
2211 static int ioapic_retrigger_irq(unsigned int irq)
2212 {
2213
2214         struct irq_cfg *cfg = irq_cfg(irq);
2215         unsigned long flags;
2216
2217         spin_lock_irqsave(&vector_lock, flags);
2218         apic->send_IPI_mask(cpumask_of(cpumask_first(cfg->domain)), cfg->vector);
2219         spin_unlock_irqrestore(&vector_lock, flags);
2220
2221         return 1;
2222 }
2223
2224 /*
2225  * Level and edge triggered IO-APIC interrupts need different handling,
2226  * so we use two separate IRQ descriptors. Edge triggered IRQs can be
2227  * handled with the level-triggered descriptor, but that one has slightly
2228  * more overhead. Level-triggered interrupts cannot be handled with the
2229  * edge-triggered handler, without risking IRQ storms and other ugly
2230  * races.
2231  */
2232
2233 #ifdef CONFIG_SMP
2234 static void send_cleanup_vector(struct irq_cfg *cfg)
2235 {
2236         cpumask_var_t cleanup_mask;
2237
2238         if (unlikely(!alloc_cpumask_var(&cleanup_mask, GFP_ATOMIC))) {
2239                 unsigned int i;
2240                 cfg->move_cleanup_count = 0;
2241                 for_each_cpu_and(i, cfg->old_domain, cpu_online_mask)
2242                         cfg->move_cleanup_count++;
2243                 for_each_cpu_and(i, cfg->old_domain, cpu_online_mask)
2244                         apic->send_IPI_mask(cpumask_of(i), IRQ_MOVE_CLEANUP_VECTOR);
2245         } else {
2246                 cpumask_and(cleanup_mask, cfg->old_domain, cpu_online_mask);
2247                 cfg->move_cleanup_count = cpumask_weight(cleanup_mask);
2248                 apic->send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
2249                 free_cpumask_var(cleanup_mask);
2250         }
2251         cfg->move_in_progress = 0;
2252 }
2253
2254 static void __target_IO_APIC_irq(unsigned int irq, unsigned int dest, struct irq_cfg *cfg)
2255 {
2256         int apic, pin;
2257         struct irq_pin_list *entry;
2258         u8 vector = cfg->vector;
2259
2260         for_each_irq_pin(entry, cfg->irq_2_pin) {
2261                 unsigned int reg;
2262
2263                 apic = entry->apic;
2264                 pin = entry->pin;
2265                 /*
2266                  * With interrupt-remapping, destination information comes
2267                  * from interrupt-remapping table entry.
2268                  */
2269                 if (!irq_remapped(irq))
2270                         io_apic_write(apic, 0x11 + pin*2, dest);
2271                 reg = io_apic_read(apic, 0x10 + pin*2);
2272                 reg &= ~IO_APIC_REDIR_VECTOR_MASK;
2273                 reg |= vector;
2274                 io_apic_modify(apic, 0x10 + pin*2, reg);
2275         }
2276 }
2277
2278 static int
2279 assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask);
2280
2281 /*
2282  * Either sets desc->affinity to a valid value, and returns
2283  * ->cpu_mask_to_apicid of that, or returns BAD_APICID and
2284  * leaves desc->affinity untouched.
2285  */
2286 static unsigned int
2287 set_desc_affinity(struct irq_desc *desc, const struct cpumask *mask)
2288 {
2289         struct irq_cfg *cfg;
2290         unsigned int irq;
2291
2292         if (!cpumask_intersects(mask, cpu_online_mask))
2293                 return BAD_APICID;
2294
2295         irq = desc->irq;
2296         cfg = desc->chip_data;
2297         if (assign_irq_vector(irq, cfg, mask))
2298                 return BAD_APICID;
2299
2300         cpumask_copy(desc->affinity, mask);
2301
2302         return apic->cpu_mask_to_apicid_and(desc->affinity, cfg->domain);
2303 }
2304
2305 static int
2306 set_ioapic_affinity_irq_desc(struct irq_desc *desc, const struct cpumask *mask)
2307 {
2308         struct irq_cfg *cfg;
2309         unsigned long flags;
2310         unsigned int dest;
2311         unsigned int irq;
2312         int ret = -1;
2313
2314         irq = desc->irq;
2315         cfg = desc->chip_data;
2316
2317         spin_lock_irqsave(&ioapic_lock, flags);
2318         dest = set_desc_affinity(desc, mask);
2319         if (dest != BAD_APICID) {
2320                 /* Only the high 8 bits are valid. */
2321                 dest = SET_APIC_LOGICAL_ID(dest);
2322                 __target_IO_APIC_irq(irq, dest, cfg);
2323                 ret = 0;
2324         }
2325         spin_unlock_irqrestore(&ioapic_lock, flags);
2326
2327         return ret;
2328 }
2329
2330 static int
2331 set_ioapic_affinity_irq(unsigned int irq, const struct cpumask *mask)
2332 {
2333         struct irq_desc *desc;
2334
2335         desc = irq_to_desc(irq);
2336
2337         return set_ioapic_affinity_irq_desc(desc, mask);
2338 }
2339
2340 #ifdef CONFIG_INTR_REMAP
2341
2342 /*
2343  * Migrate the IO-APIC irq in the presence of intr-remapping.
2344  *
2345  * For both level and edge triggered, irq migration is a simple atomic
2346  * update(of vector and cpu destination) of IRTE and flush the hardware cache.
2347  *
2348  * For level triggered, we eliminate the io-apic RTE modification (with the
2349  * updated vector information), by using a virtual vector (io-apic pin number).
2350  * Real vector that is used for interrupting cpu will be coming from
2351  * the interrupt-remapping table entry.
2352  */
2353 static int
2354 migrate_ioapic_irq_desc(struct irq_desc *desc, const struct cpumask *mask)
2355 {
2356         struct irq_cfg *cfg;
2357         struct irte irte;
2358         unsigned int dest;
2359         unsigned int irq;
2360         int ret = -1;
2361
2362         if (!cpumask_intersects(mask, cpu_online_mask))
2363                 return ret;
2364
2365         irq = desc->irq;
2366         if (get_irte(irq, &irte))
2367                 return ret;
2368
2369         cfg = desc->chip_data;
2370         if (assign_irq_vector(irq, cfg, mask))
2371                 return ret;
2372
2373         dest = apic->cpu_mask_to_apicid_and(cfg->domain, mask);
2374
2375         irte.vector = cfg->vector;
2376         irte.dest_id = IRTE_DEST(dest);
2377
2378         /*
2379          * Modified the IRTE and flushes the Interrupt entry cache.
2380          */
2381         modify_irte(irq, &irte);
2382
2383         if (cfg->move_in_progress)
2384                 send_cleanup_vector(cfg);
2385
2386         cpumask_copy(desc->affinity, mask);
2387
2388         return 0;
2389 }
2390
2391 /*
2392  * Migrates the IRQ destination in the process context.
2393  */
2394 static int set_ir_ioapic_affinity_irq_desc(struct irq_desc *desc,
2395                                             const struct cpumask *mask)
2396 {
2397         return migrate_ioapic_irq_desc(desc, mask);
2398 }
2399 static int set_ir_ioapic_affinity_irq(unsigned int irq,
2400                                        const struct cpumask *mask)
2401 {
2402         struct irq_desc *desc = irq_to_desc(irq);
2403
2404         return set_ir_ioapic_affinity_irq_desc(desc, mask);
2405 }
2406 #else
2407 static inline int set_ir_ioapic_affinity_irq_desc(struct irq_desc *desc,
2408                                                    const struct cpumask *mask)
2409 {
2410         return 0;
2411 }
2412 #endif
2413
2414 asmlinkage void smp_irq_move_cleanup_interrupt(void)
2415 {
2416         unsigned vector, me;
2417
2418         ack_APIC_irq();
2419         exit_idle();
2420         irq_enter();
2421
2422         me = smp_processor_id();
2423         for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) {
2424                 unsigned int irq;
2425                 unsigned int irr;
2426                 struct irq_desc *desc;
2427                 struct irq_cfg *cfg;
2428                 irq = __get_cpu_var(vector_irq)[vector];
2429
2430                 if (irq == -1)
2431                         continue;
2432
2433                 desc = irq_to_desc(irq);
2434                 if (!desc)
2435                         continue;
2436
2437                 cfg = irq_cfg(irq);
2438                 spin_lock(&desc->lock);
2439                 if (!cfg->move_cleanup_count)
2440                         goto unlock;
2441
2442                 if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain))
2443                         goto unlock;
2444
2445                 irr = apic_read(APIC_IRR + (vector / 32 * 0x10));
2446                 /*
2447                  * Check if the vector that needs to be cleanedup is
2448                  * registered at the cpu's IRR. If so, then this is not
2449                  * the best time to clean it up. Lets clean it up in the
2450                  * next attempt by sending another IRQ_MOVE_CLEANUP_VECTOR
2451                  * to myself.
2452                  */
2453                 if (irr  & (1 << (vector % 32))) {
2454                         apic->send_IPI_self(IRQ_MOVE_CLEANUP_VECTOR);
2455                         goto unlock;
2456                 }
2457                 __get_cpu_var(vector_irq)[vector] = -1;
2458                 cfg->move_cleanup_count--;
2459 unlock:
2460                 spin_unlock(&desc->lock);
2461         }
2462
2463         irq_exit();
2464 }
2465
2466 static void irq_complete_move(struct irq_desc **descp)
2467 {
2468         struct irq_desc *desc = *descp;
2469         struct irq_cfg *cfg = desc->chip_data;
2470         unsigned vector, me;
2471
2472         if (likely(!cfg->move_in_progress))
2473                 return;
2474
2475         vector = ~get_irq_regs()->orig_ax;
2476         me = smp_processor_id();
2477
2478         if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain))
2479                 send_cleanup_vector(cfg);
2480 }
2481 #else
2482 static inline void irq_complete_move(struct irq_desc **descp) {}
2483 #endif
2484
2485 static void ack_apic_edge(unsigned int irq)
2486 {
2487         struct irq_desc *desc = irq_to_desc(irq);
2488
2489         irq_complete_move(&desc);
2490         move_native_irq(irq);
2491         ack_APIC_irq();
2492 }
2493
2494 atomic_t irq_mis_count;
2495
2496 static void ack_apic_level(unsigned int irq)
2497 {
2498         struct irq_desc *desc = irq_to_desc(irq);
2499         unsigned long v;
2500         int i;
2501         struct irq_cfg *cfg;
2502         int do_unmask_irq = 0;
2503
2504         irq_complete_move(&desc);
2505 #ifdef CONFIG_GENERIC_PENDING_IRQ
2506         /* If we are moving the irq we need to mask it */
2507         if (unlikely(desc->status & IRQ_MOVE_PENDING)) {
2508                 do_unmask_irq = 1;
2509                 mask_IO_APIC_irq_desc(desc);
2510         }
2511 #endif
2512
2513         /*
2514          * It appears there is an erratum which affects at least version 0x11
2515          * of I/O APIC (that's the 82093AA and cores integrated into various
2516          * chipsets).  Under certain conditions a level-triggered interrupt is
2517          * erroneously delivered as edge-triggered one but the respective IRR
2518          * bit gets set nevertheless.  As a result the I/O unit expects an EOI
2519          * message but it will never arrive and further interrupts are blocked
2520          * from the source.  The exact reason is so far unknown, but the
2521          * phenomenon was observed when two consecutive interrupt requests
2522          * from a given source get delivered to the same CPU and the source is
2523          * temporarily disabled in between.
2524          *
2525          * A workaround is to simulate an EOI message manually.  We achieve it
2526          * by setting the trigger mode to edge and then to level when the edge
2527          * trigger mode gets detected in the TMR of a local APIC for a
2528          * level-triggered interrupt.  We mask the source for the time of the
2529          * operation to prevent an edge-triggered interrupt escaping meanwhile.
2530          * The idea is from Manfred Spraul.  --macro
2531          */
2532         cfg = desc->chip_data;
2533         i = cfg->vector;
2534         v = apic_read(APIC_TMR + ((i & ~0x1f) >> 1));
2535
2536         /*
2537          * We must acknowledge the irq before we move it or the acknowledge will
2538          * not propagate properly.
2539          */
2540         ack_APIC_irq();
2541
2542         /* Now we can move and renable the irq */
2543         if (unlikely(do_unmask_irq)) {
2544                 /* Only migrate the irq if the ack has been received.
2545                  *
2546                  * On rare occasions the broadcast level triggered ack gets
2547                  * delayed going to ioapics, and if we reprogram the
2548                  * vector while Remote IRR is still set the irq will never
2549                  * fire again.
2550                  *
2551                  * To prevent this scenario we read the Remote IRR bit
2552                  * of the ioapic.  This has two effects.
2553                  * - On any sane system the read of the ioapic will
2554                  *   flush writes (and acks) going to the ioapic from
2555                  *   this cpu.
2556                  * - We get to see if the ACK has actually been delivered.
2557                  *
2558                  * Based on failed experiments of reprogramming the
2559                  * ioapic entry from outside of irq context starting
2560                  * with masking the ioapic entry and then polling until
2561                  * Remote IRR was clear before reprogramming the
2562                  * ioapic I don't trust the Remote IRR bit to be
2563                  * completey accurate.
2564                  *
2565                  * However there appears to be no other way to plug
2566                  * this race, so if the Remote IRR bit is not
2567                  * accurate and is causing problems then it is a hardware bug
2568                  * and you can go talk to the chipset vendor about it.
2569                  */
2570                 cfg = desc->chip_data;
2571                 if (!io_apic_level_ack_pending(cfg))
2572                         move_masked_irq(irq);
2573                 unmask_IO_APIC_irq_desc(desc);
2574         }
2575
2576         /* Tail end of version 0x11 I/O APIC bug workaround */
2577         if (!(v & (1 << (i & 0x1f)))) {
2578                 atomic_inc(&irq_mis_count);
2579                 spin_lock(&ioapic_lock);
2580                 __mask_and_edge_IO_APIC_irq(cfg);
2581                 __unmask_and_level_IO_APIC_irq(cfg);
2582                 spin_unlock(&ioapic_lock);
2583         }
2584 }
2585
2586 #ifdef CONFIG_INTR_REMAP
2587 static void __eoi_ioapic_irq(unsigned int irq, struct irq_cfg *cfg)
2588 {
2589         struct irq_pin_list *entry;
2590
2591         for_each_irq_pin(entry, cfg->irq_2_pin)
2592                 io_apic_eoi(entry->apic, entry->pin);
2593 }
2594
2595 static void
2596 eoi_ioapic_irq(struct irq_desc *desc)
2597 {
2598         struct irq_cfg *cfg;
2599         unsigned long flags;
2600         unsigned int irq;
2601
2602         irq = desc->irq;
2603         cfg = desc->chip_data;
2604
2605         spin_lock_irqsave(&ioapic_lock, flags);
2606         __eoi_ioapic_irq(irq, cfg);
2607         spin_unlock_irqrestore(&ioapic_lock, flags);
2608 }
2609
2610 static void ir_ack_apic_edge(unsigned int irq)
2611 {
2612         ack_APIC_irq();
2613 }
2614
2615 static void ir_ack_apic_level(unsigned int irq)
2616 {
2617         struct irq_desc *desc = irq_to_desc(irq);
2618
2619         ack_APIC_irq();
2620         eoi_ioapic_irq(desc);
2621 }
2622 #endif /* CONFIG_INTR_REMAP */
2623
2624 static struct irq_chip ioapic_chip __read_mostly = {
2625         .name           = "IO-APIC",
2626         .startup        = startup_ioapic_irq,
2627         .mask           = mask_IO_APIC_irq,
2628         .unmask         = unmask_IO_APIC_irq,
2629         .ack            = ack_apic_edge,
2630         .eoi            = ack_apic_level,
2631 #ifdef CONFIG_SMP
2632         .set_affinity   = set_ioapic_affinity_irq,
2633 #endif
2634         .retrigger      = ioapic_retrigger_irq,
2635 };
2636
2637 static struct irq_chip ir_ioapic_chip __read_mostly = {
2638         .name           = "IR-IO-APIC",
2639         .startup        = startup_ioapic_irq,
2640         .mask           = mask_IO_APIC_irq,
2641         .unmask         = unmask_IO_APIC_irq,
2642 #ifdef CONFIG_INTR_REMAP
2643         .ack            = ir_ack_apic_edge,
2644         .eoi            = ir_ack_apic_level,
2645 #ifdef CONFIG_SMP
2646         .set_affinity   = set_ir_ioapic_affinity_irq,
2647 #endif
2648 #endif
2649         .retrigger      = ioapic_retrigger_irq,
2650 };
2651
2652 static inline void init_IO_APIC_traps(void)
2653 {
2654         int irq;
2655         struct irq_desc *desc;
2656         struct irq_cfg *cfg;
2657
2658         /*
2659          * NOTE! The local APIC isn't very good at handling
2660          * multiple interrupts at the same interrupt level.
2661          * As the interrupt level is determined by taking the
2662          * vector number and shifting that right by 4, we
2663          * want to spread these out a bit so that they don't
2664          * all fall in the same interrupt level.
2665          *
2666          * Also, we've got to be careful not to trash gate
2667          * 0x80, because int 0x80 is hm, kind of importantish. ;)
2668          */
2669         for_each_irq_desc(irq, desc) {
2670                 cfg = desc->chip_data;
2671                 if (IO_APIC_IRQ(irq) && cfg && !cfg->vector) {
2672                         /*
2673                          * Hmm.. We don't have an entry for this,
2674                          * so default to an old-fashioned 8259
2675                          * interrupt if we can..
2676                          */
2677                         if (irq < nr_legacy_irqs)
2678                                 make_8259A_irq(irq);
2679                         else
2680                                 /* Strange. Oh, well.. */
2681                                 desc->chip = &no_irq_chip;
2682                 }
2683         }
2684 }
2685
2686 /*
2687  * The local APIC irq-chip implementation:
2688  */
2689
2690 static void mask_lapic_irq(unsigned int irq)
2691 {
2692         unsigned long v;
2693
2694         v = apic_read(APIC_LVT0);
2695         apic_write(APIC_LVT0, v | APIC_LVT_MASKED);
2696 }
2697
2698 static void unmask_lapic_irq(unsigned int irq)
2699 {
2700         unsigned long v;
2701
2702         v = apic_read(APIC_LVT0);
2703         apic_write(APIC_LVT0, v & ~APIC_LVT_MASKED);
2704 }
2705
2706 static void ack_lapic_irq(unsigned int irq)
2707 {
2708         ack_APIC_irq();
2709 }
2710
2711 static struct irq_chip lapic_chip __read_mostly = {
2712         .name           = "local-APIC",
2713         .mask           = mask_lapic_irq,
2714         .unmask         = unmask_lapic_irq,
2715         .ack            = ack_lapic_irq,
2716 };
2717
2718 static void lapic_register_intr(int irq, struct irq_desc *desc)
2719 {
2720         desc->status &= ~IRQ_LEVEL;
2721         set_irq_chip_and_handler_name(irq, &lapic_chip, handle_edge_irq,
2722                                       "edge");
2723 }
2724
2725 static void __init setup_nmi(void)
2726 {
2727         /*
2728          * Dirty trick to enable the NMI watchdog ...
2729          * We put the 8259A master into AEOI mode and
2730          * unmask on all local APICs LVT0 as NMI.
2731          *
2732          * The idea to use the 8259A in AEOI mode ('8259A Virtual Wire')
2733          * is from Maciej W. Rozycki - so we do not have to EOI from
2734          * the NMI handler or the timer interrupt.
2735          */
2736         apic_printk(APIC_VERBOSE, KERN_INFO "activating NMI Watchdog ...");
2737
2738         enable_NMI_through_LVT0();
2739
2740         apic_printk(APIC_VERBOSE, " done.\n");
2741 }
2742
2743 /*
2744  * This looks a bit hackish but it's about the only one way of sending
2745  * a few INTA cycles to 8259As and any associated glue logic.  ICR does
2746  * not support the ExtINT mode, unfortunately.  We need to send these
2747  * cycles as some i82489DX-based boards have glue logic that keeps the
2748  * 8259A interrupt line asserted until INTA.  --macro
2749  */
2750 static inline void __init unlock_ExtINT_logic(void)
2751 {
2752         int apic, pin, i;
2753         struct IO_APIC_route_entry entry0, entry1;
2754         unsigned char save_control, save_freq_select;
2755
2756         pin  = find_isa_irq_pin(8, mp_INT);
2757         if (pin == -1) {
2758                 WARN_ON_ONCE(1);
2759                 return;
2760         }
2761         apic = find_isa_irq_apic(8, mp_INT);
2762         if (apic == -1) {
2763                 WARN_ON_ONCE(1);
2764                 return;
2765         }
2766
2767         entry0 = ioapic_read_entry(apic, pin);
2768         clear_IO_APIC_pin(apic, pin);
2769
2770         memset(&entry1, 0, sizeof(entry1));
2771
2772         entry1.dest_mode = 0;                   /* physical delivery */
2773         entry1.mask = 0;                        /* unmask IRQ now */
2774         entry1.dest = hard_smp_processor_id();
2775         entry1.delivery_mode = dest_ExtINT;
2776         entry1.polarity = entry0.polarity;
2777         entry1.trigger = 0;
2778         entry1.vector = 0;
2779
2780         ioapic_write_entry(apic, pin, entry1);
2781
2782         save_control = CMOS_READ(RTC_CONTROL);
2783         save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
2784         CMOS_WRITE((save_freq_select & ~RTC_RATE_SELECT) | 0x6,
2785                    RTC_FREQ_SELECT);
2786         CMOS_WRITE(save_control | RTC_PIE, RTC_CONTROL);
2787
2788         i = 100;
2789         while (i-- > 0) {
2790                 mdelay(10);
2791                 if ((CMOS_READ(RTC_INTR_FLAGS) & RTC_PF) == RTC_PF)
2792                         i -= 10;
2793         }
2794
2795         CMOS_WRITE(save_control, RTC_CONTROL);
2796         CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
2797         clear_IO_APIC_pin(apic, pin);
2798
2799         ioapic_write_entry(apic, pin, entry0);
2800 }
2801
2802 static int disable_timer_pin_1 __initdata;
2803 /* Actually the next is obsolete, but keep it for paranoid reasons -AK */
2804 static int __init disable_timer_pin_setup(char *arg)
2805 {
2806         disable_timer_pin_1 = 1;
2807         return 0;
2808 }
2809 early_param("disable_timer_pin_1", disable_timer_pin_setup);
2810
2811 int timer_through_8259 __initdata;
2812
2813 /*
2814  * This code may look a bit paranoid, but it's supposed to cooperate with
2815  * a wide range of boards and BIOS bugs.  Fortunately only the timer IRQ
2816  * is so screwy.  Thanks to Brian Perkins for testing/hacking this beast
2817  * fanatically on his truly buggy board.
2818  *
2819  * FIXME: really need to revamp this for all platforms.
2820  */
2821 static inline void __init check_timer(void)
2822 {
2823         struct irq_desc *desc = irq_to_desc(0);
2824         struct irq_cfg *cfg = desc->chip_data;
2825         int node = cpu_to_node(boot_cpu_id);
2826         int apic1, pin1, apic2, pin2;
2827         unsigned long flags;
2828         int no_pin1 = 0;
2829
2830         local_irq_save(flags);
2831
2832         /*
2833          * get/set the timer IRQ vector:
2834          */
2835         disable_8259A_irq(0);
2836         assign_irq_vector(0, cfg, apic->target_cpus());
2837
2838         /*
2839          * As IRQ0 is to be enabled in the 8259A, the virtual
2840          * wire has to be disabled in the local APIC.  Also
2841          * timer interrupts need to be acknowledged manually in
2842          * the 8259A for the i82489DX when using the NMI
2843          * watchdog as that APIC treats NMIs as level-triggered.
2844          * The AEOI mode will finish them in the 8259A
2845          * automatically.
2846          */
2847         apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_EXTINT);
2848         init_8259A(1);
2849 #ifdef CONFIG_X86_32
2850         {
2851                 unsigned int ver;
2852
2853                 ver = apic_read(APIC_LVR);
2854                 ver = GET_APIC_VERSION(ver);
2855                 timer_ack = (nmi_watchdog == NMI_IO_APIC && !APIC_INTEGRATED(ver));
2856         }
2857 #endif
2858
2859         pin1  = find_isa_irq_pin(0, mp_INT);
2860         apic1 = find_isa_irq_apic(0, mp_INT);
2861         pin2  = ioapic_i8259.pin;
2862         apic2 = ioapic_i8259.apic;
2863
2864         apic_printk(APIC_QUIET, KERN_INFO "..TIMER: vector=0x%02X "
2865                     "apic1=%d pin1=%d apic2=%d pin2=%d\n",
2866                     cfg->vector, apic1, pin1, apic2, pin2);
2867
2868         /*
2869          * Some BIOS writers are clueless and report the ExtINTA
2870          * I/O APIC input from the cascaded 8259A as the timer
2871          * interrupt input.  So just in case, if only one pin
2872          * was found above, try it both directly and through the
2873          * 8259A.
2874          */
2875         if (pin1 == -1) {
2876                 if (intr_remapping_enabled)
2877                         panic("BIOS bug: timer not connected to IO-APIC");
2878                 pin1 = pin2;
2879                 apic1 = apic2;
2880                 no_pin1 = 1;
2881         } else if (pin2 == -1) {
2882                 pin2 = pin1;
2883                 apic2 = apic1;
2884         }
2885
2886         if (pin1 != -1) {
2887                 /*
2888                  * Ok, does IRQ0 through the IOAPIC work?
2889                  */
2890                 if (no_pin1) {
2891                         add_pin_to_irq_node(cfg, node, apic1, pin1);
2892                         setup_timer_IRQ0_pin(apic1, pin1, cfg->vector);
2893                 } else {
2894                         /* for edge trigger, setup_IO_APIC_irq already
2895                          * leave it unmasked.
2896                          * so only need to unmask if it is level-trigger
2897                          * do we really have level trigger timer?
2898                          */
2899                         int idx;
2900                         idx = find_irq_entry(apic1, pin1, mp_INT);
2901                         if (idx != -1 && irq_trigger(idx))
2902                                 unmask_IO_APIC_irq_desc(desc);
2903                 }
2904                 if (timer_irq_works()) {
2905                         if (nmi_watchdog == NMI_IO_APIC) {
2906                                 setup_nmi();
2907                                 enable_8259A_irq(0);
2908                         }
2909                         if (disable_timer_pin_1 > 0)
2910                                 clear_IO_APIC_pin(0, pin1);
2911                         goto out;
2912                 }
2913                 if (intr_remapping_enabled)
2914                         panic("timer doesn't work through Interrupt-remapped IO-APIC");
2915                 local_irq_disable();
2916                 clear_IO_APIC_pin(apic1, pin1);
2917                 if (!no_pin1)
2918                         apic_printk(APIC_QUIET, KERN_ERR "..MP-BIOS bug: "
2919                                     "8254 timer not connected to IO-APIC\n");
2920
2921                 apic_printk(APIC_QUIET, KERN_INFO "...trying to set up timer "
2922                             "(IRQ0) through the 8259A ...\n");
2923                 apic_printk(APIC_QUIET, KERN_INFO
2924                             "..... (found apic %d pin %d) ...\n", apic2, pin2);
2925                 /*
2926                  * legacy devices should be connected to IO APIC #0
2927                  */
2928                 replace_pin_at_irq_node(cfg, node, apic1, pin1, apic2, pin2);
2929                 setup_timer_IRQ0_pin(apic2, pin2, cfg->vector);
2930                 enable_8259A_irq(0);
2931                 if (timer_irq_works()) {
2932                         apic_printk(APIC_QUIET, KERN_INFO "....... works.\n");
2933                         timer_through_8259 = 1;
2934                         if (nmi_watchdog == NMI_IO_APIC) {
2935                                 disable_8259A_irq(0);
2936                                 setup_nmi();
2937                                 enable_8259A_irq(0);
2938                         }
2939                         goto out;
2940                 }
2941                 /*
2942                  * Cleanup, just in case ...
2943                  */
2944                 local_irq_disable();
2945                 disable_8259A_irq(0);
2946                 clear_IO_APIC_pin(apic2, pin2);
2947                 apic_printk(APIC_QUIET, KERN_INFO "....... failed.\n");
2948         }
2949
2950         if (nmi_watchdog == NMI_IO_APIC) {
2951                 apic_printk(APIC_QUIET, KERN_WARNING "timer doesn't work "
2952                             "through the IO-APIC - disabling NMI Watchdog!\n");
2953                 nmi_watchdog = NMI_NONE;
2954         }
2955 #ifdef CONFIG_X86_32
2956         timer_ack = 0;
2957 #endif
2958
2959         apic_printk(APIC_QUIET, KERN_INFO
2960                     "...trying to set up timer as Virtual Wire IRQ...\n");
2961
2962         lapic_register_intr(0, desc);
2963         apic_write(APIC_LVT0, APIC_DM_FIXED | cfg->vector);     /* Fixed mode */
2964         enable_8259A_irq(0);
2965
2966         if (timer_irq_works()) {
2967                 apic_printk(APIC_QUIET, KERN_INFO "..... works.\n");
2968                 goto out;
2969         }
2970         local_irq_disable();
2971         disable_8259A_irq(0);
2972         apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_FIXED | cfg->vector);
2973         apic_printk(APIC_QUIET, KERN_INFO "..... failed.\n");
2974
2975         apic_printk(APIC_QUIET, KERN_INFO
2976                     "...trying to set up timer as ExtINT IRQ...\n");
2977
2978         init_8259A(0);
2979         make_8259A_irq(0);
2980         apic_write(APIC_LVT0, APIC_DM_EXTINT);
2981
2982         unlock_ExtINT_logic();
2983
2984         if (timer_irq_works()) {
2985                 apic_printk(APIC_QUIET, KERN_INFO "..... works.\n");
2986                 goto out;
2987         }
2988         local_irq_disable();
2989         apic_printk(APIC_QUIET, KERN_INFO "..... failed :(.\n");
2990         panic("IO-APIC + timer doesn't work!  Boot with apic=debug and send a "
2991                 "report.  Then try booting with the 'noapic' option.\n");
2992 out:
2993         local_irq_restore(flags);
2994 }
2995
2996 /*
2997  * Traditionally ISA IRQ2 is the cascade IRQ, and is not available
2998  * to devices.  However there may be an I/O APIC pin available for
2999  * this interrupt regardless.  The pin may be left unconnected, but
3000  * typically it will be reused as an ExtINT cascade interrupt for
3001  * the master 8259A.  In the MPS case such a pin will normally be
3002  * reported as an ExtINT interrupt in the MP table.  With ACPI
3003  * there is no provision for ExtINT interrupts, and in the absence
3004  * of an override it would be treated as an ordinary ISA I/O APIC
3005  * interrupt, that is edge-triggered and unmasked by default.  We
3006  * used to do this, but it caused problems on some systems because
3007  * of the NMI watchdog and sometimes IRQ0 of the 8254 timer using
3008  * the same ExtINT cascade interrupt to drive the local APIC of the
3009  * bootstrap processor.  Therefore we refrain from routing IRQ2 to
3010  * the I/O APIC in all cases now.  No actual device should request
3011  * it anyway.  --macro
3012  */
3013 #define PIC_IRQS        (1UL << PIC_CASCADE_IR)
3014
3015 void __init setup_IO_APIC(void)
3016 {
3017
3018         /*
3019          * calling enable_IO_APIC() is moved to setup_local_APIC for BP
3020          */
3021         io_apic_irqs = nr_legacy_irqs ? ~PIC_IRQS : ~0UL;
3022
3023         apic_printk(APIC_VERBOSE, "ENABLING IO-APIC IRQs\n");
3024         /*
3025          * Set up IO-APIC IRQ routing.
3026          */
3027         x86_init.mpparse.setup_ioapic_ids();
3028
3029         sync_Arb_IDs();
3030         setup_IO_APIC_irqs();
3031         init_IO_APIC_traps();
3032         if (nr_legacy_irqs)
3033                 check_timer();
3034 }
3035
3036 /*
3037  *      Called after all the initialization is done. If we didnt find any
3038  *      APIC bugs then we can allow the modify fast path
3039  */
3040
3041 static int __init io_apic_bug_finalize(void)
3042 {
3043         if (sis_apic_bug == -1)
3044                 sis_apic_bug = 0;
3045         return 0;
3046 }
3047
3048 late_initcall(io_apic_bug_finalize);
3049
3050 struct sysfs_ioapic_data {
3051         struct sys_device dev;
3052         struct IO_APIC_route_entry entry[0];
3053 };
3054 static struct sysfs_ioapic_data * mp_ioapic_data[MAX_IO_APICS];
3055
3056 static int ioapic_suspend(struct sys_device *dev, pm_message_t state)
3057 {
3058         struct IO_APIC_route_entry *entry;
3059         struct sysfs_ioapic_data *data;
3060         int i;
3061
3062         data = container_of(dev, struct sysfs_ioapic_data, dev);
3063         entry = data->entry;
3064         for (i = 0; i < nr_ioapic_registers[dev->id]; i ++, entry ++ )
3065                 *entry = ioapic_read_entry(dev->id, i);
3066
3067         return 0;
3068 }
3069
3070 static int ioapic_resume(struct sys_device *dev)
3071 {
3072         struct IO_APIC_route_entry *entry;
3073         struct sysfs_ioapic_data *data;
3074         unsigned long flags;
3075         union IO_APIC_reg_00 reg_00;
3076         int i;
3077
3078         data = container_of(dev, struct sysfs_ioapic_data, dev);
3079         entry = data->entry;
3080
3081         spin_lock_irqsave(&ioapic_lock, flags);
3082         reg_00.raw = io_apic_read(dev->id, 0);
3083         if (reg_00.bits.ID != mp_ioapics[dev->id].apicid) {
3084                 reg_00.bits.ID = mp_ioapics[dev->id].apicid;
3085                 io_apic_write(dev->id, 0, reg_00.raw);
3086         }
3087         spin_unlock_irqrestore(&ioapic_lock, flags);
3088         for (i = 0; i < nr_ioapic_registers[dev->id]; i++)
3089                 ioapic_write_entry(dev->id, i, entry[i]);
3090
3091         return 0;
3092 }
3093
3094 static struct sysdev_class ioapic_sysdev_class = {
3095         .name = "ioapic",
3096         .suspend = ioapic_suspend,
3097         .resume = ioapic_resume,
3098 };
3099
3100 static int __init ioapic_init_sysfs(void)
3101 {
3102         struct sys_device * dev;
3103         int i, size, error;
3104
3105         error = sysdev_class_register(&ioapic_sysdev_class);
3106         if (error)
3107                 return error;
3108
3109         for (i = 0; i < nr_ioapics; i++ ) {
3110                 size = sizeof(struct sys_device) + nr_ioapic_registers[i]
3111                         * sizeof(struct IO_APIC_route_entry);
3112                 mp_ioapic_data[i] = kzalloc(size, GFP_KERNEL);
3113                 if (!mp_ioapic_data[i]) {
3114                         printk(KERN_ERR "Can't suspend/resume IOAPIC %d\n", i);
3115                         continue;
3116                 }
3117                 dev = &mp_ioapic_data[i]->dev;
3118                 dev->id = i;
3119                 dev->cls = &ioapic_sysdev_class;
3120                 error = sysdev_register(dev);
3121                 if (error) {
3122                         kfree(mp_ioapic_data[i]);
3123                         mp_ioapic_data[i] = NULL;
3124                         printk(KERN_ERR "Can't suspend/resume IOAPIC %d\n", i);
3125                         continue;
3126                 }
3127         }
3128
3129         return 0;
3130 }
3131
3132 device_initcall(ioapic_init_sysfs);
3133
3134 /*
3135  * Dynamic irq allocate and deallocation
3136  */
3137 unsigned int create_irq_nr(unsigned int irq_want, int node)
3138 {
3139         /* Allocate an unused irq */
3140         unsigned int irq;
3141         unsigned int new;
3142         unsigned long flags;
3143         struct irq_cfg *cfg_new = NULL;
3144         struct irq_desc *desc_new = NULL;
3145
3146         irq = 0;
3147         if (irq_want < nr_irqs_gsi)
3148                 irq_want = nr_irqs_gsi;
3149
3150         spin_lock_irqsave(&vector_lock, flags);
3151         for (new = irq_want; new < nr_irqs; new++) {
3152                 desc_new = irq_to_desc_alloc_node(new, node);
3153                 if (!desc_new) {
3154                         printk(KERN_INFO "can not get irq_desc for %d\n", new);
3155                         continue;
3156                 }
3157                 cfg_new = desc_new->chip_data;
3158
3159                 if (cfg_new->vector != 0)
3160                         continue;
3161
3162                 desc_new = move_irq_desc(desc_new, node);
3163
3164                 if (__assign_irq_vector(new, cfg_new, apic->target_cpus()) == 0)
3165                         irq = new;
3166                 break;
3167         }
3168         spin_unlock_irqrestore(&vector_lock, flags);
3169
3170         if (irq > 0) {
3171                 dynamic_irq_init(irq);
3172                 /* restore it, in case dynamic_irq_init clear it */
3173                 if (desc_new)
3174                         desc_new->chip_data = cfg_new;
3175         }
3176         return irq;
3177 }
3178
3179 int create_irq(void)
3180 {
3181         int node = cpu_to_node(boot_cpu_id);
3182         unsigned int irq_want;
3183         int irq;
3184
3185         irq_want = nr_irqs_gsi;
3186         irq = create_irq_nr(irq_want, node);
3187
3188         if (irq == 0)
3189                 irq = -1;
3190
3191         return irq;
3192 }
3193
3194 void destroy_irq(unsigned int irq)
3195 {
3196         unsigned long flags;
3197         struct irq_cfg *cfg;
3198         struct irq_desc *desc;
3199
3200         /* store it, in case dynamic_irq_cleanup clear it */
3201         desc = irq_to_desc(irq);
3202         cfg = desc->chip_data;
3203         dynamic_irq_cleanup(irq);
3204         /* connect back irq_cfg */
3205         desc->chip_data = cfg;
3206
3207         free_irte(irq);
3208         spin_lock_irqsave(&vector_lock, flags);
3209         __clear_irq_vector(irq, cfg);
3210         spin_unlock_irqrestore(&vector_lock, flags);
3211 }
3212
3213 /*
3214  * MSI message composition
3215  */
3216 #ifdef CONFIG_PCI_MSI
3217 static int msi_compose_msg(struct pci_dev *pdev, unsigned int irq, struct msi_msg *msg)
3218 {
3219         struct irq_cfg *cfg;
3220         int err;
3221         unsigned dest;
3222
3223         if (disable_apic)
3224                 return -ENXIO;
3225
3226         cfg = irq_cfg(irq);
3227         err = assign_irq_vector(irq, cfg, apic->target_cpus());
3228         if (err)
3229                 return err;
3230
3231         dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus());
3232
3233         if (irq_remapped(irq)) {
3234                 struct irte irte;
3235                 int ir_index;
3236                 u16 sub_handle;
3237
3238                 ir_index = map_irq_to_irte_handle(irq, &sub_handle);
3239                 BUG_ON(ir_index == -1);
3240
3241                 memset (&irte, 0, sizeof(irte));
3242
3243                 irte.present = 1;
3244                 irte.dst_mode = apic->irq_dest_mode;
3245                 irte.trigger_mode = 0; /* edge */
3246                 irte.dlvry_mode = apic->irq_delivery_mode;
3247                 irte.vector = cfg->vector;
3248                 irte.dest_id = IRTE_DEST(dest);
3249
3250                 /* Set source-id of interrupt request */
3251                 set_msi_sid(&irte, pdev);
3252
3253                 modify_irte(irq, &irte);
3254
3255                 msg->address_hi = MSI_ADDR_BASE_HI;
3256                 msg->data = sub_handle;
3257                 msg->address_lo = MSI_ADDR_BASE_LO | MSI_ADDR_IR_EXT_INT |
3258                                   MSI_ADDR_IR_SHV |
3259                                   MSI_ADDR_IR_INDEX1(ir_index) |
3260                                   MSI_ADDR_IR_INDEX2(ir_index);
3261         } else {
3262                 if (x2apic_enabled())
3263                         msg->address_hi = MSI_ADDR_BASE_HI |
3264                                           MSI_ADDR_EXT_DEST_ID(dest);
3265                 else
3266                         msg->address_hi = MSI_ADDR_BASE_HI;
3267
3268                 msg->address_lo =
3269                         MSI_ADDR_BASE_LO |
3270                         ((apic->irq_dest_mode == 0) ?
3271                                 MSI_ADDR_DEST_MODE_PHYSICAL:
3272                                 MSI_ADDR_DEST_MODE_LOGICAL) |
3273                         ((apic->irq_delivery_mode != dest_LowestPrio) ?
3274                                 MSI_ADDR_REDIRECTION_CPU:
3275                                 MSI_ADDR_REDIRECTION_LOWPRI) |
3276                         MSI_ADDR_DEST_ID(dest);
3277
3278                 msg->data =
3279                         MSI_DATA_TRIGGER_EDGE |
3280                         MSI_DATA_LEVEL_ASSERT |
3281                         ((apic->irq_delivery_mode != dest_LowestPrio) ?
3282                                 MSI_DATA_DELIVERY_FIXED:
3283                                 MSI_DATA_DELIVERY_LOWPRI) |
3284                         MSI_DATA_VECTOR(cfg->vector);
3285         }
3286         return err;
3287 }
3288
3289 #ifdef CONFIG_SMP
3290 static int set_msi_irq_affinity(unsigned int irq, const struct cpumask *mask)
3291 {
3292         struct irq_desc *desc = irq_to_desc(irq);
3293         struct irq_cfg *cfg;
3294         struct msi_msg msg;
3295         unsigned int dest;
3296
3297         dest = set_desc_affinity(desc, mask);
3298         if (dest == BAD_APICID)
3299                 return -1;
3300
3301         cfg = desc->chip_data;
3302
3303         read_msi_msg_desc(desc, &msg);
3304
3305         msg.data &= ~MSI_DATA_VECTOR_MASK;
3306         msg.data |= MSI_DATA_VECTOR(cfg->vector);
3307         msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
3308         msg.address_lo |= MSI_ADDR_DEST_ID(dest);
3309
3310         write_msi_msg_desc(desc, &msg);
3311
3312         return 0;
3313 }
3314 #ifdef CONFIG_INTR_REMAP
3315 /*
3316  * Migrate the MSI irq to another cpumask. This migration is
3317  * done in the process context using interrupt-remapping hardware.
3318  */
3319 static int
3320 ir_set_msi_irq_affinity(unsigned int irq, const struct cpumask *mask)
3321 {
3322         struct irq_desc *desc = irq_to_desc(irq);
3323         struct irq_cfg *cfg = desc->chip_data;
3324         unsigned int dest;
3325         struct irte irte;
3326
3327         if (get_irte(irq, &irte))
3328                 return -1;
3329
3330         dest = set_desc_affinity(desc, mask);
3331         if (dest == BAD_APICID)
3332                 return -1;
3333
3334         irte.vector = cfg->vector;
3335         irte.dest_id = IRTE_DEST(dest);
3336
3337         /*
3338          * atomically update the IRTE with the new destination and vector.
3339          */
3340         modify_irte(irq, &irte);
3341
3342         /*
3343          * After this point, all the interrupts will start arriving
3344          * at the new destination. So, time to cleanup the previous
3345          * vector allocation.
3346          */
3347         if (cfg->move_in_progress)
3348                 send_cleanup_vector(cfg);
3349
3350         return 0;
3351 }
3352
3353 #endif
3354 #endif /* CONFIG_SMP */
3355
3356 /*
3357  * IRQ Chip for MSI PCI/PCI-X/PCI-Express Devices,
3358  * which implement the MSI or MSI-X Capability Structure.
3359  */
3360 static struct irq_chip msi_chip = {
3361         .name           = "PCI-MSI",
3362         .unmask         = unmask_msi_irq,
3363         .mask           = mask_msi_irq,
3364         .ack            = ack_apic_edge,
3365 #ifdef CONFIG_SMP
3366         .set_affinity   = set_msi_irq_affinity,
3367 #endif
3368         .retrigger      = ioapic_retrigger_irq,
3369 };
3370
3371 static struct irq_chip msi_ir_chip = {
3372         .name           = "IR-PCI-MSI",
3373         .unmask         = unmask_msi_irq,
3374         .mask           = mask_msi_irq,
3375 #ifdef CONFIG_INTR_REMAP
3376         .ack            = ir_ack_apic_edge,
3377 #ifdef CONFIG_SMP
3378         .set_affinity   = ir_set_msi_irq_affinity,
3379 #endif
3380 #endif
3381         .retrigger      = ioapic_retrigger_irq,
3382 };
3383
3384 /*
3385  * Map the PCI dev to the corresponding remapping hardware unit
3386  * and allocate 'nvec' consecutive interrupt-remapping table entries
3387  * in it.
3388  */
3389 static int msi_alloc_irte(struct pci_dev *dev, int irq, int nvec)
3390 {
3391         struct intel_iommu *iommu;
3392         int index;
3393
3394         iommu = map_dev_to_ir(dev);
3395         if (!iommu) {
3396                 printk(KERN_ERR
3397                        "Unable to map PCI %s to iommu\n", pci_name(dev));
3398                 return -ENOENT;
3399         }
3400
3401         index = alloc_irte(iommu, irq, nvec);
3402         if (index < 0) {
3403                 printk(KERN_ERR
3404                        "Unable to allocate %d IRTE for PCI %s\n", nvec,
3405                        pci_name(dev));
3406                 return -ENOSPC;
3407         }
3408         return index;
3409 }
3410
3411 static int setup_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc, int irq)
3412 {
3413         int ret;
3414         struct msi_msg msg;
3415
3416         ret = msi_compose_msg(dev, irq, &msg);
3417         if (ret < 0)
3418                 return ret;
3419
3420         set_irq_msi(irq, msidesc);
3421         write_msi_msg(irq, &msg);
3422
3423         if (irq_remapped(irq)) {
3424                 struct irq_desc *desc = irq_to_desc(irq);
3425                 /*
3426                  * irq migration in process context
3427                  */
3428                 desc->status |= IRQ_MOVE_PCNTXT;
3429                 set_irq_chip_and_handler_name(irq, &msi_ir_chip, handle_edge_irq, "edge");
3430         } else
3431                 set_irq_chip_and_handler_name(irq, &msi_chip, handle_edge_irq, "edge");
3432
3433         dev_printk(KERN_DEBUG, &dev->dev, "irq %d for MSI/MSI-X\n", irq);
3434
3435         return 0;
3436 }
3437
3438 int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
3439 {
3440         unsigned int irq;
3441         int ret, sub_handle;
3442         struct msi_desc *msidesc;
3443         unsigned int irq_want;
3444         struct intel_iommu *iommu = NULL;
3445         int index = 0;
3446         int node;
3447
3448         /* x86 doesn't support multiple MSI yet */
3449         if (type == PCI_CAP_ID_MSI && nvec > 1)
3450                 return 1;
3451
3452         node = dev_to_node(&dev->dev);
3453         irq_want = nr_irqs_gsi;
3454         sub_handle = 0;
3455         list_for_each_entry(msidesc, &dev->msi_list, list) {
3456                 irq = create_irq_nr(irq_want, node);
3457                 if (irq == 0)
3458                         return -1;
3459                 irq_want = irq + 1;
3460                 if (!intr_remapping_enabled)
3461                         goto no_ir;
3462
3463                 if (!sub_handle) {
3464                         /*
3465                          * allocate the consecutive block of IRTE's
3466                          * for 'nvec'
3467                          */
3468                         index = msi_alloc_irte(dev, irq, nvec);
3469                         if (index < 0) {
3470                                 ret = index;
3471                                 goto error;
3472                         }
3473                 } else {
3474                         iommu = map_dev_to_ir(dev);
3475                         if (!iommu) {
3476                                 ret = -ENOENT;
3477                                 goto error;
3478                         }
3479                         /*
3480                          * setup the mapping between the irq and the IRTE
3481                          * base index, the sub_handle pointing to the
3482                          * appropriate interrupt remap table entry.
3483                          */
3484                         set_irte_irq(irq, iommu, index, sub_handle);
3485                 }
3486 no_ir:
3487                 ret = setup_msi_irq(dev, msidesc, irq);
3488                 if (ret < 0)
3489                         goto error;
3490                 sub_handle++;
3491         }
3492         return 0;
3493
3494 error:
3495         destroy_irq(irq);
3496         return ret;
3497 }
3498
3499 void arch_teardown_msi_irq(unsigned int irq)
3500 {
3501         destroy_irq(irq);
3502 }
3503
3504 #if defined (CONFIG_DMAR) || defined (CONFIG_INTR_REMAP)
3505 #ifdef CONFIG_SMP
3506 static int dmar_msi_set_affinity(unsigned int irq, const struct cpumask *mask)
3507 {
3508         struct irq_desc *desc = irq_to_desc(irq);
3509         struct irq_cfg *cfg;
3510         struct msi_msg msg;
3511         unsigned int dest;
3512
3513         dest = set_desc_affinity(desc, mask);
3514         if (dest == BAD_APICID)
3515                 return -1;
3516
3517         cfg = desc->chip_data;
3518
3519         dmar_msi_read(irq, &msg);
3520
3521         msg.data &= ~MSI_DATA_VECTOR_MASK;
3522         msg.data |= MSI_DATA_VECTOR(cfg->vector);
3523         msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
3524         msg.address_lo |= MSI_ADDR_DEST_ID(dest);
3525
3526         dmar_msi_write(irq, &msg);
3527
3528         return 0;
3529 }
3530
3531 #endif /* CONFIG_SMP */
3532
3533 static struct irq_chip dmar_msi_type = {
3534         .name = "DMAR_MSI",
3535         .unmask = dmar_msi_unmask,
3536         .mask = dmar_msi_mask,
3537         .ack = ack_apic_edge,
3538 #ifdef CONFIG_SMP
3539         .set_affinity = dmar_msi_set_affinity,
3540 #endif
3541         .retrigger = ioapic_retrigger_irq,
3542 };
3543
3544 int arch_setup_dmar_msi(unsigned int irq)
3545 {
3546         int ret;
3547         struct msi_msg msg;
3548
3549         ret = msi_compose_msg(NULL, irq, &msg);
3550         if (ret < 0)
3551                 return ret;
3552         dmar_msi_write(irq, &msg);
3553         set_irq_chip_and_handler_name(irq, &dmar_msi_type, handle_edge_irq,
3554                 "edge");
3555         return 0;
3556 }
3557 #endif
3558
3559 #ifdef CONFIG_HPET_TIMER
3560
3561 #ifdef CONFIG_SMP
3562 static int hpet_msi_set_affinity(unsigned int irq, const struct cpumask *mask)
3563 {
3564         struct irq_desc *desc = irq_to_desc(irq);
3565         struct irq_cfg *cfg;
3566         struct msi_msg msg;
3567         unsigned int dest;
3568
3569         dest = set_desc_affinity(desc, mask);
3570         if (dest == BAD_APICID)
3571                 return -1;
3572
3573         cfg = desc->chip_data;
3574
3575         hpet_msi_read(irq, &msg);
3576
3577         msg.data &= ~MSI_DATA_VECTOR_MASK;
3578         msg.data |= MSI_DATA_VECTOR(cfg->vector);
3579         msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
3580         msg.address_lo |= MSI_ADDR_DEST_ID(dest);
3581
3582         hpet_msi_write(irq, &msg);
3583
3584         return 0;
3585 }
3586
3587 #endif /* CONFIG_SMP */
3588
3589 static struct irq_chip hpet_msi_type = {
3590         .name = "HPET_MSI",
3591         .unmask = hpet_msi_unmask,
3592         .mask = hpet_msi_mask,
3593         .ack = ack_apic_edge,
3594 #ifdef CONFIG_SMP
3595         .set_affinity = hpet_msi_set_affinity,
3596 #endif
3597         .retrigger = ioapic_retrigger_irq,
3598 };
3599
3600 int arch_setup_hpet_msi(unsigned int irq)
3601 {
3602         int ret;
3603         struct msi_msg msg;
3604         struct irq_desc *desc = irq_to_desc(irq);
3605
3606         ret = msi_compose_msg(NULL, irq, &msg);
3607         if (ret < 0)
3608                 return ret;
3609
3610         hpet_msi_write(irq, &msg);
3611         desc->status |= IRQ_MOVE_PCNTXT;
3612         set_irq_chip_and_handler_name(irq, &hpet_msi_type, handle_edge_irq,
3613                 "edge");
3614
3615         return 0;
3616 }
3617 #endif
3618
3619 #endif /* CONFIG_PCI_MSI */
3620 /*
3621  * Hypertransport interrupt support
3622  */
3623 #ifdef CONFIG_HT_IRQ
3624
3625 #ifdef CONFIG_SMP
3626
3627 static void target_ht_irq(unsigned int irq, unsigned int dest, u8 vector)
3628 {
3629         struct ht_irq_msg msg;
3630         fetch_ht_irq_msg(irq, &msg);
3631
3632         msg.address_lo &= ~(HT_IRQ_LOW_VECTOR_MASK | HT_IRQ_LOW_DEST_ID_MASK);
3633         msg.address_hi &= ~(HT_IRQ_HIGH_DEST_ID_MASK);
3634
3635         msg.address_lo |= HT_IRQ_LOW_VECTOR(vector) | HT_IRQ_LOW_DEST_ID(dest);
3636         msg.address_hi |= HT_IRQ_HIGH_DEST_ID(dest);
3637
3638         write_ht_irq_msg(irq, &msg);
3639 }
3640
3641 static int set_ht_irq_affinity(unsigned int irq, const struct cpumask *mask)
3642 {
3643         struct irq_desc *desc = irq_to_desc(irq);
3644         struct irq_cfg *cfg;
3645         unsigned int dest;
3646
3647         dest = set_desc_affinity(desc, mask);
3648         if (dest == BAD_APICID)
3649                 return -1;
3650
3651         cfg = desc->chip_data;
3652
3653         target_ht_irq(irq, dest, cfg->vector);
3654
3655         return 0;
3656 }
3657
3658 #endif
3659
3660 static struct irq_chip ht_irq_chip = {
3661         .name           = "PCI-HT",
3662         .mask           = mask_ht_irq,
3663         .unmask         = unmask_ht_irq,
3664         .ack            = ack_apic_edge,
3665 #ifdef CONFIG_SMP
3666         .set_affinity   = set_ht_irq_affinity,
3667 #endif
3668         .retrigger      = ioapic_retrigger_irq,
3669 };
3670
3671 int arch_setup_ht_irq(unsigned int irq, struct pci_dev *dev)
3672 {
3673         struct irq_cfg *cfg;
3674         int err;
3675
3676         if (disable_apic)
3677                 return -ENXIO;
3678
3679         cfg = irq_cfg(irq);
3680         err = assign_irq_vector(irq, cfg, apic->target_cpus());
3681         if (!err) {
3682                 struct ht_irq_msg msg;
3683                 unsigned dest;
3684
3685                 dest = apic->cpu_mask_to_apicid_and(cfg->domain,
3686                                                     apic->target_cpus());
3687
3688                 msg.address_hi = HT_IRQ_HIGH_DEST_ID(dest);
3689
3690                 msg.address_lo =
3691                         HT_IRQ_LOW_BASE |
3692                         HT_IRQ_LOW_DEST_ID(dest) |
3693                         HT_IRQ_LOW_VECTOR(cfg->vector) |
3694                         ((apic->irq_dest_mode == 0) ?
3695                                 HT_IRQ_LOW_DM_PHYSICAL :
3696                                 HT_IRQ_LOW_DM_LOGICAL) |
3697                         HT_IRQ_LOW_RQEOI_EDGE |
3698                         ((apic->irq_delivery_mode != dest_LowestPrio) ?
3699                                 HT_IRQ_LOW_MT_FIXED :
3700                                 HT_IRQ_LOW_MT_ARBITRATED) |
3701                         HT_IRQ_LOW_IRQ_MASKED;
3702
3703                 write_ht_irq_msg(irq, &msg);
3704
3705                 set_irq_chip_and_handler_name(irq, &ht_irq_chip,
3706                                               handle_edge_irq, "edge");
3707
3708                 dev_printk(KERN_DEBUG, &dev->dev, "irq %d for HT\n", irq);
3709         }
3710         return err;
3711 }
3712 #endif /* CONFIG_HT_IRQ */
3713
3714 #ifdef CONFIG_X86_UV
3715 /*
3716  * Re-target the irq to the specified CPU and enable the specified MMR located
3717  * on the specified blade to allow the sending of MSIs to the specified CPU.
3718  */
3719 int arch_enable_uv_irq(char *irq_name, unsigned int irq, int cpu, int mmr_blade,
3720                        unsigned long mmr_offset)
3721 {
3722         const struct cpumask *eligible_cpu = cpumask_of(cpu);
3723         struct irq_cfg *cfg;
3724         int mmr_pnode;
3725         unsigned long mmr_value;
3726         struct uv_IO_APIC_route_entry *entry;
3727         unsigned long flags;
3728         int err;
3729
3730         BUILD_BUG_ON(sizeof(struct uv_IO_APIC_route_entry) != sizeof(unsigned long));
3731
3732         cfg = irq_cfg(irq);
3733
3734         err = assign_irq_vector(irq, cfg, eligible_cpu);
3735         if (err != 0)
3736                 return err;
3737
3738         spin_lock_irqsave(&vector_lock, flags);
3739         set_irq_chip_and_handler_name(irq, &uv_irq_chip, handle_percpu_irq,
3740                                       irq_name);
3741         spin_unlock_irqrestore(&vector_lock, flags);
3742
3743         mmr_value = 0;
3744         entry = (struct uv_IO_APIC_route_entry *)&mmr_value;
3745         entry->vector           = cfg->vector;
3746         entry->delivery_mode    = apic->irq_delivery_mode;
3747         entry->dest_mode        = apic->irq_dest_mode;
3748         entry->polarity         = 0;
3749         entry->trigger          = 0;
3750         entry->mask             = 0;
3751         entry->dest             = apic->cpu_mask_to_apicid(eligible_cpu);
3752
3753         mmr_pnode = uv_blade_to_pnode(mmr_blade);
3754         uv_write_global_mmr64(mmr_pnode, mmr_offset, mmr_value);
3755
3756         if (cfg->move_in_progress)
3757                 send_cleanup_vector(cfg);
3758
3759         return irq;
3760 }
3761
3762 /*
3763  * Disable the specified MMR located on the specified blade so that MSIs are
3764  * longer allowed to be sent.
3765  */
3766 void arch_disable_uv_irq(int mmr_blade, unsigned long mmr_offset)
3767 {
3768         unsigned long mmr_value;
3769         struct uv_IO_APIC_route_entry *entry;
3770         int mmr_pnode;
3771
3772         BUILD_BUG_ON(sizeof(struct uv_IO_APIC_route_entry) != sizeof(unsigned long));
3773
3774         mmr_value = 0;
3775         entry = (struct uv_IO_APIC_route_entry *)&mmr_value;
3776         entry->mask = 1;
3777
3778         mmr_pnode = uv_blade_to_pnode(mmr_blade);
3779         uv_write_global_mmr64(mmr_pnode, mmr_offset, mmr_value);
3780 }
3781 #endif /* CONFIG_X86_64 */
3782
3783 int __init io_apic_get_redir_entries (int ioapic)
3784 {
3785         union IO_APIC_reg_01    reg_01;
3786         unsigned long flags;
3787
3788         spin_lock_irqsave(&ioapic_lock, flags);
3789         reg_01.raw = io_apic_read(ioapic, 1);
3790         spin_unlock_irqrestore(&ioapic_lock, flags);
3791
3792         return reg_01.bits.entries;
3793 }
3794
3795 void __init probe_nr_irqs_gsi(void)
3796 {
3797         int nr = 0;
3798
3799         nr = acpi_probe_gsi();
3800         if (nr > nr_irqs_gsi) {
3801                 nr_irqs_gsi = nr;
3802         } else {
3803                 /* for acpi=off or acpi is not compiled in */
3804                 int idx;
3805
3806                 nr = 0;
3807                 for (idx = 0; idx < nr_ioapics; idx++)
3808                         nr += io_apic_get_redir_entries(idx) + 1;
3809
3810                 if (nr > nr_irqs_gsi)
3811                         nr_irqs_gsi = nr;
3812         }
3813
3814         printk(KERN_DEBUG "nr_irqs_gsi: %d\n", nr_irqs_gsi);
3815 }
3816
3817 #ifdef CONFIG_SPARSE_IRQ
3818 int __init arch_probe_nr_irqs(void)
3819 {
3820         int nr;
3821
3822         if (nr_irqs > (NR_VECTORS * nr_cpu_ids))
3823                 nr_irqs = NR_VECTORS * nr_cpu_ids;
3824
3825         nr = nr_irqs_gsi + 8 * nr_cpu_ids;
3826 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_HT_IRQ)
3827         /*
3828          * for MSI and HT dyn irq
3829          */
3830         nr += nr_irqs_gsi * 16;
3831 #endif
3832         if (nr < nr_irqs)
3833                 nr_irqs = nr;
3834
3835         return 0;
3836 }
3837 #endif
3838
3839 static int __io_apic_set_pci_routing(struct device *dev, int irq,
3840                                 struct io_apic_irq_attr *irq_attr)
3841 {
3842         struct irq_desc *desc;
3843         struct irq_cfg *cfg;
3844         int node;
3845         int ioapic, pin;
3846         int trigger, polarity;
3847
3848         ioapic = irq_attr->ioapic;
3849         if (!IO_APIC_IRQ(irq)) {
3850                 apic_printk(APIC_QUIET,KERN_ERR "IOAPIC[%d]: Invalid reference to IRQ 0\n",
3851                         ioapic);
3852                 return -EINVAL;
3853         }
3854
3855         if (dev)
3856                 node = dev_to_node(dev);
3857         else
3858                 node = cpu_to_node(boot_cpu_id);
3859
3860         desc = irq_to_desc_alloc_node(irq, node);
3861         if (!desc) {
3862                 printk(KERN_INFO "can not get irq_desc %d\n", irq);
3863                 return 0;
3864         }
3865
3866         pin = irq_attr->ioapic_pin;
3867         trigger = irq_attr->trigger;
3868         polarity = irq_attr->polarity;
3869
3870         /*
3871          * IRQs < 16 are already in the irq_2_pin[] map
3872          */
3873         if (irq >= nr_legacy_irqs) {
3874                 cfg = desc->chip_data;
3875                 if (add_pin_to_irq_node_nopanic(cfg, node, ioapic, pin)) {
3876                         printk(KERN_INFO "can not add pin %d for irq %d\n",
3877                                 pin, irq);
3878                         return 0;
3879                 }
3880         }
3881
3882         setup_IO_APIC_irq(ioapic, pin, irq, desc, trigger, polarity);
3883
3884         return 0;
3885 }
3886
3887 int io_apic_set_pci_routing(struct device *dev, int irq,
3888                                 struct io_apic_irq_attr *irq_attr)
3889 {
3890         int ioapic, pin;
3891         /*
3892          * Avoid pin reprogramming.  PRTs typically include entries
3893          * with redundant pin->gsi mappings (but unique PCI devices);
3894          * we only program the IOAPIC on the first.
3895          */
3896         ioapic = irq_attr->ioapic;
3897         pin = irq_attr->ioapic_pin;
3898         if (test_bit(pin, mp_ioapic_routing[ioapic].pin_programmed)) {
3899                 pr_debug("Pin %d-%d already programmed\n",
3900                          mp_ioapics[ioapic].apicid, pin);
3901                 return 0;
3902         }
3903         set_bit(pin, mp_ioapic_routing[ioapic].pin_programmed);
3904
3905         return __io_apic_set_pci_routing(dev, irq, irq_attr);
3906 }
3907
3908 u8 __init io_apic_unique_id(u8 id)
3909 {
3910 #ifdef CONFIG_X86_32
3911         if ((boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) &&
3912             !APIC_XAPIC(apic_version[boot_cpu_physical_apicid]))
3913                 return io_apic_get_unique_id(nr_ioapics, id);
3914         else
3915                 return id;
3916 #else
3917         int i;
3918         DECLARE_BITMAP(used, 256);
3919
3920         bitmap_zero(used, 256);
3921         for (i = 0; i < nr_ioapics; i++) {
3922                 struct mpc_ioapic *ia = &mp_ioapics[i];
3923                 __set_bit(ia->apicid, used);
3924         }
3925         if (!test_bit(id, used))
3926                 return id;
3927         return find_first_zero_bit(used, 256);
3928 #endif
3929 }
3930
3931 #ifdef CONFIG_X86_32
3932 int __init io_apic_get_unique_id(int ioapic, int apic_id)
3933 {
3934         union IO_APIC_reg_00 reg_00;
3935         static physid_mask_t apic_id_map = PHYSID_MASK_NONE;
3936         physid_mask_t tmp;
3937         unsigned long flags;
3938         int i = 0;
3939
3940         /*
3941          * The P4 platform supports up to 256 APIC IDs on two separate APIC
3942          * buses (one for LAPICs, one for IOAPICs), where predecessors only
3943          * supports up to 16 on one shared APIC bus.
3944          *
3945          * TBD: Expand LAPIC/IOAPIC support on P4-class systems to take full
3946          *      advantage of new APIC bus architecture.
3947          */
3948
3949         if (physids_empty(apic_id_map))
3950                 apic_id_map = apic->ioapic_phys_id_map(phys_cpu_present_map);
3951
3952         spin_lock_irqsave(&ioapic_lock, flags);
3953         reg_00.raw = io_apic_read(ioapic, 0);
3954         spin_unlock_irqrestore(&ioapic_lock, flags);
3955
3956         if (apic_id >= get_physical_broadcast()) {
3957                 printk(KERN_WARNING "IOAPIC[%d]: Invalid apic_id %d, trying "
3958                         "%d\n", ioapic, apic_id, reg_00.bits.ID);
3959                 apic_id = reg_00.bits.ID;
3960         }
3961
3962         /*
3963          * Every APIC in a system must have a unique ID or we get lots of nice
3964          * 'stuck on smp_invalidate_needed IPI wait' messages.
3965          */
3966         if (apic->check_apicid_used(apic_id_map, apic_id)) {
3967
3968                 for (i = 0; i < get_physical_broadcast(); i++) {
3969                         if (!apic->check_apicid_used(apic_id_map, i))
3970                                 break;
3971                 }
3972
3973                 if (i == get_physical_broadcast())
3974                         panic("Max apic_id exceeded!\n");
3975
3976                 printk(KERN_WARNING "IOAPIC[%d]: apic_id %d already used, "
3977                         "trying %d\n", ioapic, apic_id, i);
3978
3979                 apic_id = i;
3980         }
3981
3982         tmp = apic->apicid_to_cpu_present(apic_id);
3983         physids_or(apic_id_map, apic_id_map, tmp);
3984
3985         if (reg_00.bits.ID != apic_id) {
3986                 reg_00.bits.ID = apic_id;
3987
3988                 spin_lock_irqsave(&ioapic_lock, flags);
3989                 io_apic_write(ioapic, 0, reg_00.raw);
3990                 reg_00.raw = io_apic_read(ioapic, 0);
3991                 spin_unlock_irqrestore(&ioapic_lock, flags);
3992
3993                 /* Sanity check */
3994                 if (reg_00.bits.ID != apic_id) {
3995                         printk("IOAPIC[%d]: Unable to change apic_id!\n", ioapic);
3996                         return -1;
3997                 }
3998         }
3999
4000         apic_printk(APIC_VERBOSE, KERN_INFO
4001                         "IOAPIC[%d]: Assigned apic_id %d\n", ioapic, apic_id);
4002
4003         return apic_id;
4004 }
4005 #endif
4006
4007 int __init io_apic_get_version(int ioapic)
4008 {
4009         union IO_APIC_reg_01    reg_01;
4010         unsigned long flags;
4011
4012         spin_lock_irqsave(&ioapic_lock, flags);
4013         reg_01.raw = io_apic_read(ioapic, 1);
4014         spin_unlock_irqrestore(&ioapic_lock, flags);
4015
4016         return reg_01.bits.version;
4017 }
4018
4019 int acpi_get_override_irq(int bus_irq, int *trigger, int *polarity)
4020 {
4021         int i;
4022
4023         if (skip_ioapic_setup)
4024                 return -1;
4025
4026         for (i = 0; i < mp_irq_entries; i++)
4027                 if (mp_irqs[i].irqtype == mp_INT &&
4028                     mp_irqs[i].srcbusirq == bus_irq)
4029                         break;
4030         if (i >= mp_irq_entries)
4031                 return -1;
4032
4033         *trigger = irq_trigger(i);
4034         *polarity = irq_polarity(i);
4035         return 0;
4036 }
4037
4038 /*
4039  * This function currently is only a helper for the i386 smp boot process where
4040  * we need to reprogram the ioredtbls to cater for the cpus which have come online
4041  * so mask in all cases should simply be apic->target_cpus()
4042  */
4043 #ifdef CONFIG_SMP
4044 void __init setup_ioapic_dest(void)
4045 {
4046         int pin, ioapic = 0, irq, irq_entry;
4047         struct irq_desc *desc;
4048         const struct cpumask *mask;
4049
4050         if (skip_ioapic_setup == 1)
4051                 return;
4052
4053 #ifdef CONFIG_ACPI
4054         if (!acpi_disabled && acpi_ioapic) {
4055                 ioapic = mp_find_ioapic(0);
4056                 if (ioapic < 0)
4057                         ioapic = 0;
4058         }
4059 #endif
4060
4061         for (pin = 0; pin < nr_ioapic_registers[ioapic]; pin++) {
4062                 irq_entry = find_irq_entry(ioapic, pin, mp_INT);
4063                 if (irq_entry == -1)
4064                         continue;
4065                 irq = pin_2_irq(irq_entry, ioapic, pin);
4066
4067                 desc = irq_to_desc(irq);
4068
4069                 /*
4070                  * Honour affinities which have been set in early boot
4071                  */
4072                 if (desc->status &
4073                     (IRQ_NO_BALANCING | IRQ_AFFINITY_SET))
4074                         mask = desc->affinity;
4075                 else
4076                         mask = apic->target_cpus();
4077
4078                 if (intr_remapping_enabled)
4079                         set_ir_ioapic_affinity_irq_desc(desc, mask);
4080                 else
4081                         set_ioapic_affinity_irq_desc(desc, mask);
4082         }
4083
4084 }
4085 #endif
4086
4087 #define IOAPIC_RESOURCE_NAME_SIZE 11
4088
4089 static struct resource *ioapic_resources;
4090
4091 static struct resource * __init ioapic_setup_resources(int nr_ioapics)
4092 {
4093         unsigned long n;
4094         struct resource *res;
4095         char *mem;
4096         int i;
4097
4098         if (nr_ioapics <= 0)
4099                 return NULL;
4100
4101         n = IOAPIC_RESOURCE_NAME_SIZE + sizeof(struct resource);
4102         n *= nr_ioapics;
4103
4104         mem = alloc_bootmem(n);
4105         res = (void *)mem;
4106
4107         mem += sizeof(struct resource) * nr_ioapics;
4108
4109         for (i = 0; i < nr_ioapics; i++) {
4110                 res[i].name = mem;
4111                 res[i].flags = IORESOURCE_MEM | IORESOURCE_BUSY;
4112                 sprintf(mem,  "IOAPIC %u", i);
4113                 mem += IOAPIC_RESOURCE_NAME_SIZE;
4114         }
4115
4116         ioapic_resources = res;
4117
4118         return res;
4119 }
4120
4121 void __init ioapic_init_mappings(void)
4122 {
4123         unsigned long ioapic_phys, idx = FIX_IO_APIC_BASE_0;
4124         struct resource *ioapic_res;
4125         int i;
4126
4127         ioapic_res = ioapic_setup_resources(nr_ioapics);
4128         for (i = 0; i < nr_ioapics; i++) {
4129                 if (smp_found_config) {
4130                         ioapic_phys = mp_ioapics[i].apicaddr;
4131 #ifdef CONFIG_X86_32
4132                         if (!ioapic_phys) {
4133                                 printk(KERN_ERR
4134                                        "WARNING: bogus zero IO-APIC "
4135                                        "address found in MPTABLE, "
4136                                        "disabling IO/APIC support!\n");
4137                                 smp_found_config = 0;
4138                                 skip_ioapic_setup = 1;
4139                                 goto fake_ioapic_page;
4140                         }
4141 #endif
4142                 } else {
4143 #ifdef CONFIG_X86_32
4144 fake_ioapic_page:
4145 #endif
4146                         ioapic_phys = (unsigned long)
4147                                 alloc_bootmem_pages(PAGE_SIZE);
4148                         ioapic_phys = __pa(ioapic_phys);
4149                 }
4150                 set_fixmap_nocache(idx, ioapic_phys);
4151                 apic_printk(APIC_VERBOSE,
4152                             "mapped IOAPIC to %08lx (%08lx)\n",
4153                             __fix_to_virt(idx), ioapic_phys);
4154                 idx++;
4155
4156                 ioapic_res->start = ioapic_phys;
4157                 ioapic_res->end = ioapic_phys + (4 * 1024) - 1;
4158                 ioapic_res++;
4159         }
4160 }
4161
4162 void __init ioapic_insert_resources(void)
4163 {
4164         int i;
4165         struct resource *r = ioapic_resources;
4166
4167         if (!r) {
4168                 if (nr_ioapics > 0)
4169                         printk(KERN_ERR
4170                                 "IO APIC resources couldn't be allocated.\n");
4171                 return;
4172         }
4173
4174         for (i = 0; i < nr_ioapics; i++) {
4175                 insert_resource(&iomem_resource, r);
4176                 r++;
4177         }
4178 }
4179
4180 int mp_find_ioapic(int gsi)
4181 {
4182         int i = 0;
4183
4184         /* Find the IOAPIC that manages this GSI. */
4185         for (i = 0; i < nr_ioapics; i++) {
4186                 if ((gsi >= mp_gsi_routing[i].gsi_base)
4187                     && (gsi <= mp_gsi_routing[i].gsi_end))
4188                         return i;
4189         }
4190
4191         printk(KERN_ERR "ERROR: Unable to locate IOAPIC for GSI %d\n", gsi);
4192         return -1;
4193 }
4194
4195 int mp_find_ioapic_pin(int ioapic, int gsi)
4196 {
4197         if (WARN_ON(ioapic == -1))
4198                 return -1;
4199         if (WARN_ON(gsi > mp_gsi_routing[ioapic].gsi_end))
4200                 return -1;
4201
4202         return gsi - mp_gsi_routing[ioapic].gsi_base;
4203 }
4204
4205 static int bad_ioapic(unsigned long address)
4206 {
4207         if (nr_ioapics >= MAX_IO_APICS) {
4208                 printk(KERN_WARNING "WARING: Max # of I/O APICs (%d) exceeded "
4209                        "(found %d), skipping\n", MAX_IO_APICS, nr_ioapics);
4210                 return 1;
4211         }
4212         if (!address) {
4213                 printk(KERN_WARNING "WARNING: Bogus (zero) I/O APIC address"
4214                        " found in table, skipping!\n");
4215                 return 1;
4216         }
4217         return 0;
4218 }
4219
4220 void __init mp_register_ioapic(int id, u32 address, u32 gsi_base)
4221 {
4222         int idx = 0;
4223
4224         if (bad_ioapic(address))
4225                 return;
4226
4227         idx = nr_ioapics;
4228
4229         mp_ioapics[idx].type = MP_IOAPIC;
4230         mp_ioapics[idx].flags = MPC_APIC_USABLE;
4231         mp_ioapics[idx].apicaddr = address;
4232
4233         set_fixmap_nocache(FIX_IO_APIC_BASE_0 + idx, address);
4234         mp_ioapics[idx].apicid = io_apic_unique_id(id);
4235         mp_ioapics[idx].apicver = io_apic_get_version(idx);
4236
4237         /*
4238          * Build basic GSI lookup table to facilitate gsi->io_apic lookups
4239          * and to prevent reprogramming of IOAPIC pins (PCI GSIs).
4240          */
4241         mp_gsi_routing[idx].gsi_base = gsi_base;
4242         mp_gsi_routing[idx].gsi_end = gsi_base +
4243             io_apic_get_redir_entries(idx);
4244
4245         printk(KERN_INFO "IOAPIC[%d]: apic_id %d, version %d, address 0x%x, "
4246                "GSI %d-%d\n", idx, mp_ioapics[idx].apicid,
4247                mp_ioapics[idx].apicver, mp_ioapics[idx].apicaddr,
4248                mp_gsi_routing[idx].gsi_base, mp_gsi_routing[idx].gsi_end);
4249
4250         nr_ioapics++;
4251 }