Merge branch 'x86-apic-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[pandora-kernel.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/syscore_ops.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 #include <linux/slab.h>
40 #ifdef CONFIG_ACPI
41 #include <acpi/acpi_bus.h>
42 #endif
43 #include <linux/bootmem.h>
44 #include <linux/dmar.h>
45 #include <linux/hpet.h>
46
47 #include <asm/idle.h>
48 #include <asm/io.h>
49 #include <asm/smp.h>
50 #include <asm/cpu.h>
51 #include <asm/desc.h>
52 #include <asm/proto.h>
53 #include <asm/acpi.h>
54 #include <asm/dma.h>
55 #include <asm/timer.h>
56 #include <asm/i8259.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
64 #include <asm/apic.h>
65
66 #define __apicdebuginit(type) static type __init
67 #define for_each_irq_pin(entry, head) \
68         for (entry = head; entry; entry = entry->next)
69
70 /*
71  *      Is the SiS APIC rmw bug present ?
72  *      -1 = don't know, 0 = no, 1 = yes
73  */
74 int sis_apic_bug = -1;
75
76 static DEFINE_RAW_SPINLOCK(ioapic_lock);
77 static DEFINE_RAW_SPINLOCK(vector_lock);
78
79 static struct ioapic {
80         /*
81          * # of IRQ routing registers
82          */
83         int nr_registers;
84         /*
85          * Saved state during suspend/resume, or while enabling intr-remap.
86          */
87         struct IO_APIC_route_entry *saved_registers;
88         /* I/O APIC config */
89         struct mpc_ioapic mp_config;
90         /* IO APIC gsi routing info */
91         struct mp_ioapic_gsi  gsi_config;
92         DECLARE_BITMAP(pin_programmed, MP_MAX_IOAPIC_PIN + 1);
93 } ioapics[MAX_IO_APICS];
94
95 #define mpc_ioapic_ver(id)              ioapics[id].mp_config.apicver
96
97 int mpc_ioapic_id(int id)
98 {
99         return ioapics[id].mp_config.apicid;
100 }
101
102 unsigned int mpc_ioapic_addr(int id)
103 {
104         return ioapics[id].mp_config.apicaddr;
105 }
106
107 struct mp_ioapic_gsi *mp_ioapic_gsi_routing(int id)
108 {
109         return &ioapics[id].gsi_config;
110 }
111
112 int nr_ioapics;
113
114 /* The one past the highest gsi number used */
115 u32 gsi_top;
116
117 /* MP IRQ source entries */
118 struct mpc_intsrc mp_irqs[MAX_IRQ_SOURCES];
119
120 /* # of MP IRQ source entries */
121 int mp_irq_entries;
122
123 /* GSI interrupts */
124 static int nr_irqs_gsi = NR_IRQS_LEGACY;
125
126 #if defined (CONFIG_MCA) || defined (CONFIG_EISA)
127 int mp_bus_id_to_type[MAX_MP_BUSSES];
128 #endif
129
130 DECLARE_BITMAP(mp_bus_not_pci, MAX_MP_BUSSES);
131
132 int skip_ioapic_setup;
133
134 /**
135  * disable_ioapic_support() - disables ioapic support at runtime
136  */
137 void disable_ioapic_support(void)
138 {
139 #ifdef CONFIG_PCI
140         noioapicquirk = 1;
141         noioapicreroute = -1;
142 #endif
143         skip_ioapic_setup = 1;
144 }
145
146 static int __init parse_noapic(char *str)
147 {
148         /* disable IO-APIC */
149         disable_ioapic_support();
150         return 0;
151 }
152 early_param("noapic", parse_noapic);
153
154 static int io_apic_setup_irq_pin(unsigned int irq, int node,
155                                  struct io_apic_irq_attr *attr);
156
157 /* Will be called in mpparse/acpi/sfi codes for saving IRQ info */
158 void mp_save_irq(struct mpc_intsrc *m)
159 {
160         int i;
161
162         apic_printk(APIC_VERBOSE, "Int: type %d, pol %d, trig %d, bus %02x,"
163                 " IRQ %02x, APIC ID %x, APIC INT %02x\n",
164                 m->irqtype, m->irqflag & 3, (m->irqflag >> 2) & 3, m->srcbus,
165                 m->srcbusirq, m->dstapic, m->dstirq);
166
167         for (i = 0; i < mp_irq_entries; i++) {
168                 if (!memcmp(&mp_irqs[i], m, sizeof(*m)))
169                         return;
170         }
171
172         memcpy(&mp_irqs[mp_irq_entries], m, sizeof(*m));
173         if (++mp_irq_entries == MAX_IRQ_SOURCES)
174                 panic("Max # of irq sources exceeded!!\n");
175 }
176
177 struct irq_pin_list {
178         int apic, pin;
179         struct irq_pin_list *next;
180 };
181
182 static struct irq_pin_list *alloc_irq_pin_list(int node)
183 {
184         return kzalloc_node(sizeof(struct irq_pin_list), GFP_KERNEL, node);
185 }
186
187
188 /* irq_cfg is indexed by the sum of all RTEs in all I/O APICs. */
189 #ifdef CONFIG_SPARSE_IRQ
190 static struct irq_cfg irq_cfgx[NR_IRQS_LEGACY];
191 #else
192 static struct irq_cfg irq_cfgx[NR_IRQS];
193 #endif
194
195 int __init arch_early_irq_init(void)
196 {
197         struct irq_cfg *cfg;
198         int count, node, i;
199
200         if (!legacy_pic->nr_legacy_irqs) {
201                 nr_irqs_gsi = 0;
202                 io_apic_irqs = ~0UL;
203         }
204
205         for (i = 0; i < nr_ioapics; i++) {
206                 ioapics[i].saved_registers =
207                         kzalloc(sizeof(struct IO_APIC_route_entry) *
208                                 ioapics[i].nr_registers, GFP_KERNEL);
209                 if (!ioapics[i].saved_registers)
210                         pr_err("IOAPIC %d: suspend/resume impossible!\n", i);
211         }
212
213         cfg = irq_cfgx;
214         count = ARRAY_SIZE(irq_cfgx);
215         node = cpu_to_node(0);
216
217         /* Make sure the legacy interrupts are marked in the bitmap */
218         irq_reserve_irqs(0, legacy_pic->nr_legacy_irqs);
219
220         for (i = 0; i < count; i++) {
221                 irq_set_chip_data(i, &cfg[i]);
222                 zalloc_cpumask_var_node(&cfg[i].domain, GFP_KERNEL, node);
223                 zalloc_cpumask_var_node(&cfg[i].old_domain, GFP_KERNEL, node);
224                 /*
225                  * For legacy IRQ's, start with assigning irq0 to irq15 to
226                  * IRQ0_VECTOR to IRQ15_VECTOR on cpu 0.
227                  */
228                 if (i < legacy_pic->nr_legacy_irqs) {
229                         cfg[i].vector = IRQ0_VECTOR + i;
230                         cpumask_set_cpu(0, cfg[i].domain);
231                 }
232         }
233
234         return 0;
235 }
236
237 #ifdef CONFIG_SPARSE_IRQ
238 static struct irq_cfg *irq_cfg(unsigned int irq)
239 {
240         return irq_get_chip_data(irq);
241 }
242
243 static struct irq_cfg *alloc_irq_cfg(unsigned int irq, int node)
244 {
245         struct irq_cfg *cfg;
246
247         cfg = kzalloc_node(sizeof(*cfg), GFP_KERNEL, node);
248         if (!cfg)
249                 return NULL;
250         if (!zalloc_cpumask_var_node(&cfg->domain, GFP_KERNEL, node))
251                 goto out_cfg;
252         if (!zalloc_cpumask_var_node(&cfg->old_domain, GFP_KERNEL, node))
253                 goto out_domain;
254         return cfg;
255 out_domain:
256         free_cpumask_var(cfg->domain);
257 out_cfg:
258         kfree(cfg);
259         return NULL;
260 }
261
262 static void free_irq_cfg(unsigned int at, struct irq_cfg *cfg)
263 {
264         if (!cfg)
265                 return;
266         irq_set_chip_data(at, NULL);
267         free_cpumask_var(cfg->domain);
268         free_cpumask_var(cfg->old_domain);
269         kfree(cfg);
270 }
271
272 #else
273
274 struct irq_cfg *irq_cfg(unsigned int irq)
275 {
276         return irq < nr_irqs ? irq_cfgx + irq : NULL;
277 }
278
279 static struct irq_cfg *alloc_irq_cfg(unsigned int irq, int node)
280 {
281         return irq_cfgx + irq;
282 }
283
284 static inline void free_irq_cfg(unsigned int at, struct irq_cfg *cfg) { }
285
286 #endif
287
288 static struct irq_cfg *alloc_irq_and_cfg_at(unsigned int at, int node)
289 {
290         int res = irq_alloc_desc_at(at, node);
291         struct irq_cfg *cfg;
292
293         if (res < 0) {
294                 if (res != -EEXIST)
295                         return NULL;
296                 cfg = irq_get_chip_data(at);
297                 if (cfg)
298                         return cfg;
299         }
300
301         cfg = alloc_irq_cfg(at, node);
302         if (cfg)
303                 irq_set_chip_data(at, cfg);
304         else
305                 irq_free_desc(at);
306         return cfg;
307 }
308
309 static int alloc_irq_from(unsigned int from, int node)
310 {
311         return irq_alloc_desc_from(from, node);
312 }
313
314 static void free_irq_at(unsigned int at, struct irq_cfg *cfg)
315 {
316         free_irq_cfg(at, cfg);
317         irq_free_desc(at);
318 }
319
320 struct io_apic {
321         unsigned int index;
322         unsigned int unused[3];
323         unsigned int data;
324         unsigned int unused2[11];
325         unsigned int eoi;
326 };
327
328 static __attribute_const__ struct io_apic __iomem *io_apic_base(int idx)
329 {
330         return (void __iomem *) __fix_to_virt(FIX_IO_APIC_BASE_0 + idx)
331                 + (mpc_ioapic_addr(idx) & ~PAGE_MASK);
332 }
333
334 static inline void io_apic_eoi(unsigned int apic, unsigned int vector)
335 {
336         struct io_apic __iomem *io_apic = io_apic_base(apic);
337         writel(vector, &io_apic->eoi);
338 }
339
340 static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg)
341 {
342         struct io_apic __iomem *io_apic = io_apic_base(apic);
343         writel(reg, &io_apic->index);
344         return readl(&io_apic->data);
345 }
346
347 static inline void io_apic_write(unsigned int apic, unsigned int reg, unsigned int value)
348 {
349         struct io_apic __iomem *io_apic = io_apic_base(apic);
350         writel(reg, &io_apic->index);
351         writel(value, &io_apic->data);
352 }
353
354 /*
355  * Re-write a value: to be used for read-modify-write
356  * cycles where the read already set up the index register.
357  *
358  * Older SiS APIC requires we rewrite the index register
359  */
360 static inline void io_apic_modify(unsigned int apic, unsigned int reg, unsigned int value)
361 {
362         struct io_apic __iomem *io_apic = io_apic_base(apic);
363
364         if (sis_apic_bug)
365                 writel(reg, &io_apic->index);
366         writel(value, &io_apic->data);
367 }
368
369 static bool io_apic_level_ack_pending(struct irq_cfg *cfg)
370 {
371         struct irq_pin_list *entry;
372         unsigned long flags;
373
374         raw_spin_lock_irqsave(&ioapic_lock, flags);
375         for_each_irq_pin(entry, cfg->irq_2_pin) {
376                 unsigned int reg;
377                 int pin;
378
379                 pin = entry->pin;
380                 reg = io_apic_read(entry->apic, 0x10 + pin*2);
381                 /* Is the remote IRR bit set? */
382                 if (reg & IO_APIC_REDIR_REMOTE_IRR) {
383                         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
384                         return true;
385                 }
386         }
387         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
388
389         return false;
390 }
391
392 union entry_union {
393         struct { u32 w1, w2; };
394         struct IO_APIC_route_entry entry;
395 };
396
397 static struct IO_APIC_route_entry ioapic_read_entry(int apic, int pin)
398 {
399         union entry_union eu;
400         unsigned long flags;
401         raw_spin_lock_irqsave(&ioapic_lock, flags);
402         eu.w1 = io_apic_read(apic, 0x10 + 2 * pin);
403         eu.w2 = io_apic_read(apic, 0x11 + 2 * pin);
404         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
405         return eu.entry;
406 }
407
408 /*
409  * When we write a new IO APIC routing entry, we need to write the high
410  * word first! If the mask bit in the low word is clear, we will enable
411  * the interrupt, and we need to make sure the entry is fully populated
412  * before that happens.
413  */
414 static void
415 __ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
416 {
417         union entry_union eu = {{0, 0}};
418
419         eu.entry = e;
420         io_apic_write(apic, 0x11 + 2*pin, eu.w2);
421         io_apic_write(apic, 0x10 + 2*pin, eu.w1);
422 }
423
424 static void ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
425 {
426         unsigned long flags;
427         raw_spin_lock_irqsave(&ioapic_lock, flags);
428         __ioapic_write_entry(apic, pin, e);
429         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
430 }
431
432 /*
433  * When we mask an IO APIC routing entry, we need to write the low
434  * word first, in order to set the mask bit before we change the
435  * high bits!
436  */
437 static void ioapic_mask_entry(int apic, int pin)
438 {
439         unsigned long flags;
440         union entry_union eu = { .entry.mask = 1 };
441
442         raw_spin_lock_irqsave(&ioapic_lock, flags);
443         io_apic_write(apic, 0x10 + 2*pin, eu.w1);
444         io_apic_write(apic, 0x11 + 2*pin, eu.w2);
445         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
446 }
447
448 /*
449  * The common case is 1:1 IRQ<->pin mappings. Sometimes there are
450  * shared ISA-space IRQs, so we have to support them. We are super
451  * fast in the common case, and fast for shared ISA-space IRQs.
452  */
453 static int
454 __add_pin_to_irq_node(struct irq_cfg *cfg, int node, int apic, int pin)
455 {
456         struct irq_pin_list **last, *entry;
457
458         /* don't allow duplicates */
459         last = &cfg->irq_2_pin;
460         for_each_irq_pin(entry, cfg->irq_2_pin) {
461                 if (entry->apic == apic && entry->pin == pin)
462                         return 0;
463                 last = &entry->next;
464         }
465
466         entry = alloc_irq_pin_list(node);
467         if (!entry) {
468                 printk(KERN_ERR "can not alloc irq_pin_list (%d,%d,%d)\n",
469                                 node, apic, pin);
470                 return -ENOMEM;
471         }
472         entry->apic = apic;
473         entry->pin = pin;
474
475         *last = entry;
476         return 0;
477 }
478
479 static void add_pin_to_irq_node(struct irq_cfg *cfg, int node, int apic, int pin)
480 {
481         if (__add_pin_to_irq_node(cfg, node, apic, pin))
482                 panic("IO-APIC: failed to add irq-pin. Can not proceed\n");
483 }
484
485 /*
486  * Reroute an IRQ to a different pin.
487  */
488 static void __init replace_pin_at_irq_node(struct irq_cfg *cfg, int node,
489                                            int oldapic, int oldpin,
490                                            int newapic, int newpin)
491 {
492         struct irq_pin_list *entry;
493
494         for_each_irq_pin(entry, cfg->irq_2_pin) {
495                 if (entry->apic == oldapic && entry->pin == oldpin) {
496                         entry->apic = newapic;
497                         entry->pin = newpin;
498                         /* every one is different, right? */
499                         return;
500                 }
501         }
502
503         /* old apic/pin didn't exist, so just add new ones */
504         add_pin_to_irq_node(cfg, node, newapic, newpin);
505 }
506
507 static void __io_apic_modify_irq(struct irq_pin_list *entry,
508                                  int mask_and, int mask_or,
509                                  void (*final)(struct irq_pin_list *entry))
510 {
511         unsigned int reg, pin;
512
513         pin = entry->pin;
514         reg = io_apic_read(entry->apic, 0x10 + pin * 2);
515         reg &= mask_and;
516         reg |= mask_or;
517         io_apic_modify(entry->apic, 0x10 + pin * 2, reg);
518         if (final)
519                 final(entry);
520 }
521
522 static void io_apic_modify_irq(struct irq_cfg *cfg,
523                                int mask_and, int mask_or,
524                                void (*final)(struct irq_pin_list *entry))
525 {
526         struct irq_pin_list *entry;
527
528         for_each_irq_pin(entry, cfg->irq_2_pin)
529                 __io_apic_modify_irq(entry, mask_and, mask_or, final);
530 }
531
532 static void __mask_and_edge_IO_APIC_irq(struct irq_pin_list *entry)
533 {
534         __io_apic_modify_irq(entry, ~IO_APIC_REDIR_LEVEL_TRIGGER,
535                              IO_APIC_REDIR_MASKED, NULL);
536 }
537
538 static void __unmask_and_level_IO_APIC_irq(struct irq_pin_list *entry)
539 {
540         __io_apic_modify_irq(entry, ~IO_APIC_REDIR_MASKED,
541                              IO_APIC_REDIR_LEVEL_TRIGGER, NULL);
542 }
543
544 static void io_apic_sync(struct irq_pin_list *entry)
545 {
546         /*
547          * Synchronize the IO-APIC and the CPU by doing
548          * a dummy read from the IO-APIC
549          */
550         struct io_apic __iomem *io_apic;
551         io_apic = io_apic_base(entry->apic);
552         readl(&io_apic->data);
553 }
554
555 static void mask_ioapic(struct irq_cfg *cfg)
556 {
557         unsigned long flags;
558
559         raw_spin_lock_irqsave(&ioapic_lock, flags);
560         io_apic_modify_irq(cfg, ~0, IO_APIC_REDIR_MASKED, &io_apic_sync);
561         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
562 }
563
564 static void mask_ioapic_irq(struct irq_data *data)
565 {
566         mask_ioapic(data->chip_data);
567 }
568
569 static void __unmask_ioapic(struct irq_cfg *cfg)
570 {
571         io_apic_modify_irq(cfg, ~IO_APIC_REDIR_MASKED, 0, NULL);
572 }
573
574 static void unmask_ioapic(struct irq_cfg *cfg)
575 {
576         unsigned long flags;
577
578         raw_spin_lock_irqsave(&ioapic_lock, flags);
579         __unmask_ioapic(cfg);
580         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
581 }
582
583 static void unmask_ioapic_irq(struct irq_data *data)
584 {
585         unmask_ioapic(data->chip_data);
586 }
587
588 static void clear_IO_APIC_pin(unsigned int apic, unsigned int pin)
589 {
590         struct IO_APIC_route_entry entry;
591
592         /* Check delivery_mode to be sure we're not clearing an SMI pin */
593         entry = ioapic_read_entry(apic, pin);
594         if (entry.delivery_mode == dest_SMI)
595                 return;
596         /*
597          * Disable it in the IO-APIC irq-routing table:
598          */
599         ioapic_mask_entry(apic, pin);
600 }
601
602 static void clear_IO_APIC (void)
603 {
604         int apic, pin;
605
606         for (apic = 0; apic < nr_ioapics; apic++)
607                 for (pin = 0; pin < ioapics[apic].nr_registers; pin++)
608                         clear_IO_APIC_pin(apic, pin);
609 }
610
611 #ifdef CONFIG_X86_32
612 /*
613  * support for broken MP BIOSs, enables hand-redirection of PIRQ0-7 to
614  * specific CPU-side IRQs.
615  */
616
617 #define MAX_PIRQS 8
618 static int pirq_entries[MAX_PIRQS] = {
619         [0 ... MAX_PIRQS - 1] = -1
620 };
621
622 static int __init ioapic_pirq_setup(char *str)
623 {
624         int i, max;
625         int ints[MAX_PIRQS+1];
626
627         get_options(str, ARRAY_SIZE(ints), ints);
628
629         apic_printk(APIC_VERBOSE, KERN_INFO
630                         "PIRQ redirection, working around broken MP-BIOS.\n");
631         max = MAX_PIRQS;
632         if (ints[0] < MAX_PIRQS)
633                 max = ints[0];
634
635         for (i = 0; i < max; i++) {
636                 apic_printk(APIC_VERBOSE, KERN_DEBUG
637                                 "... PIRQ%d -> IRQ %d\n", i, ints[i+1]);
638                 /*
639                  * PIRQs are mapped upside down, usually.
640                  */
641                 pirq_entries[MAX_PIRQS-i-1] = ints[i+1];
642         }
643         return 1;
644 }
645
646 __setup("pirq=", ioapic_pirq_setup);
647 #endif /* CONFIG_X86_32 */
648
649 /*
650  * Saves all the IO-APIC RTE's
651  */
652 int save_ioapic_entries(void)
653 {
654         int apic, pin;
655         int err = 0;
656
657         for (apic = 0; apic < nr_ioapics; apic++) {
658                 if (!ioapics[apic].saved_registers) {
659                         err = -ENOMEM;
660                         continue;
661                 }
662
663                 for (pin = 0; pin < ioapics[apic].nr_registers; pin++)
664                         ioapics[apic].saved_registers[pin] =
665                                 ioapic_read_entry(apic, pin);
666         }
667
668         return err;
669 }
670
671 /*
672  * Mask all IO APIC entries.
673  */
674 void mask_ioapic_entries(void)
675 {
676         int apic, pin;
677
678         for (apic = 0; apic < nr_ioapics; apic++) {
679                 if (!ioapics[apic].saved_registers)
680                         continue;
681
682                 for (pin = 0; pin < ioapics[apic].nr_registers; pin++) {
683                         struct IO_APIC_route_entry entry;
684
685                         entry = ioapics[apic].saved_registers[pin];
686                         if (!entry.mask) {
687                                 entry.mask = 1;
688                                 ioapic_write_entry(apic, pin, entry);
689                         }
690                 }
691         }
692 }
693
694 /*
695  * Restore IO APIC entries which was saved in the ioapic structure.
696  */
697 int restore_ioapic_entries(void)
698 {
699         int apic, pin;
700
701         for (apic = 0; apic < nr_ioapics; apic++) {
702                 if (!ioapics[apic].saved_registers)
703                         continue;
704
705                 for (pin = 0; pin < ioapics[apic].nr_registers; pin++)
706                         ioapic_write_entry(apic, pin,
707                                            ioapics[apic].saved_registers[pin]);
708         }
709         return 0;
710 }
711
712 /*
713  * Find the IRQ entry number of a certain pin.
714  */
715 static int find_irq_entry(int apic, int pin, int type)
716 {
717         int i;
718
719         for (i = 0; i < mp_irq_entries; i++)
720                 if (mp_irqs[i].irqtype == type &&
721                     (mp_irqs[i].dstapic == mpc_ioapic_id(apic) ||
722                      mp_irqs[i].dstapic == MP_APIC_ALL) &&
723                     mp_irqs[i].dstirq == pin)
724                         return i;
725
726         return -1;
727 }
728
729 /*
730  * Find the pin to which IRQ[irq] (ISA) is connected
731  */
732 static int __init find_isa_irq_pin(int irq, int type)
733 {
734         int i;
735
736         for (i = 0; i < mp_irq_entries; i++) {
737                 int lbus = mp_irqs[i].srcbus;
738
739                 if (test_bit(lbus, mp_bus_not_pci) &&
740                     (mp_irqs[i].irqtype == type) &&
741                     (mp_irqs[i].srcbusirq == irq))
742
743                         return mp_irqs[i].dstirq;
744         }
745         return -1;
746 }
747
748 static int __init find_isa_irq_apic(int irq, int type)
749 {
750         int i;
751
752         for (i = 0; i < mp_irq_entries; i++) {
753                 int lbus = mp_irqs[i].srcbus;
754
755                 if (test_bit(lbus, mp_bus_not_pci) &&
756                     (mp_irqs[i].irqtype == type) &&
757                     (mp_irqs[i].srcbusirq == irq))
758                         break;
759         }
760         if (i < mp_irq_entries) {
761                 int apic;
762                 for(apic = 0; apic < nr_ioapics; apic++) {
763                         if (mpc_ioapic_id(apic) == mp_irqs[i].dstapic)
764                                 return apic;
765                 }
766         }
767
768         return -1;
769 }
770
771 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
772 /*
773  * EISA Edge/Level control register, ELCR
774  */
775 static int EISA_ELCR(unsigned int irq)
776 {
777         if (irq < legacy_pic->nr_legacy_irqs) {
778                 unsigned int port = 0x4d0 + (irq >> 3);
779                 return (inb(port) >> (irq & 7)) & 1;
780         }
781         apic_printk(APIC_VERBOSE, KERN_INFO
782                         "Broken MPtable reports ISA irq %d\n", irq);
783         return 0;
784 }
785
786 #endif
787
788 /* ISA interrupts are always polarity zero edge triggered,
789  * when listed as conforming in the MP table. */
790
791 #define default_ISA_trigger(idx)        (0)
792 #define default_ISA_polarity(idx)       (0)
793
794 /* EISA interrupts are always polarity zero and can be edge or level
795  * trigger depending on the ELCR value.  If an interrupt is listed as
796  * EISA conforming in the MP table, that means its trigger type must
797  * be read in from the ELCR */
798
799 #define default_EISA_trigger(idx)       (EISA_ELCR(mp_irqs[idx].srcbusirq))
800 #define default_EISA_polarity(idx)      default_ISA_polarity(idx)
801
802 /* PCI interrupts are always polarity one level triggered,
803  * when listed as conforming in the MP table. */
804
805 #define default_PCI_trigger(idx)        (1)
806 #define default_PCI_polarity(idx)       (1)
807
808 /* MCA interrupts are always polarity zero level triggered,
809  * when listed as conforming in the MP table. */
810
811 #define default_MCA_trigger(idx)        (1)
812 #define default_MCA_polarity(idx)       default_ISA_polarity(idx)
813
814 static int irq_polarity(int idx)
815 {
816         int bus = mp_irqs[idx].srcbus;
817         int polarity;
818
819         /*
820          * Determine IRQ line polarity (high active or low active):
821          */
822         switch (mp_irqs[idx].irqflag & 3)
823         {
824                 case 0: /* conforms, ie. bus-type dependent polarity */
825                         if (test_bit(bus, mp_bus_not_pci))
826                                 polarity = default_ISA_polarity(idx);
827                         else
828                                 polarity = default_PCI_polarity(idx);
829                         break;
830                 case 1: /* high active */
831                 {
832                         polarity = 0;
833                         break;
834                 }
835                 case 2: /* reserved */
836                 {
837                         printk(KERN_WARNING "broken BIOS!!\n");
838                         polarity = 1;
839                         break;
840                 }
841                 case 3: /* low active */
842                 {
843                         polarity = 1;
844                         break;
845                 }
846                 default: /* invalid */
847                 {
848                         printk(KERN_WARNING "broken BIOS!!\n");
849                         polarity = 1;
850                         break;
851                 }
852         }
853         return polarity;
854 }
855
856 static int irq_trigger(int idx)
857 {
858         int bus = mp_irqs[idx].srcbus;
859         int trigger;
860
861         /*
862          * Determine IRQ trigger mode (edge or level sensitive):
863          */
864         switch ((mp_irqs[idx].irqflag>>2) & 3)
865         {
866                 case 0: /* conforms, ie. bus-type dependent */
867                         if (test_bit(bus, mp_bus_not_pci))
868                                 trigger = default_ISA_trigger(idx);
869                         else
870                                 trigger = default_PCI_trigger(idx);
871 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
872                         switch (mp_bus_id_to_type[bus]) {
873                                 case MP_BUS_ISA: /* ISA pin */
874                                 {
875                                         /* set before the switch */
876                                         break;
877                                 }
878                                 case MP_BUS_EISA: /* EISA pin */
879                                 {
880                                         trigger = default_EISA_trigger(idx);
881                                         break;
882                                 }
883                                 case MP_BUS_PCI: /* PCI pin */
884                                 {
885                                         /* set before the switch */
886                                         break;
887                                 }
888                                 case MP_BUS_MCA: /* MCA pin */
889                                 {
890                                         trigger = default_MCA_trigger(idx);
891                                         break;
892                                 }
893                                 default:
894                                 {
895                                         printk(KERN_WARNING "broken BIOS!!\n");
896                                         trigger = 1;
897                                         break;
898                                 }
899                         }
900 #endif
901                         break;
902                 case 1: /* edge */
903                 {
904                         trigger = 0;
905                         break;
906                 }
907                 case 2: /* reserved */
908                 {
909                         printk(KERN_WARNING "broken BIOS!!\n");
910                         trigger = 1;
911                         break;
912                 }
913                 case 3: /* level */
914                 {
915                         trigger = 1;
916                         break;
917                 }
918                 default: /* invalid */
919                 {
920                         printk(KERN_WARNING "broken BIOS!!\n");
921                         trigger = 0;
922                         break;
923                 }
924         }
925         return trigger;
926 }
927
928 static int pin_2_irq(int idx, int apic, int pin)
929 {
930         int irq;
931         int bus = mp_irqs[idx].srcbus;
932         struct mp_ioapic_gsi *gsi_cfg = mp_ioapic_gsi_routing(apic);
933
934         /*
935          * Debugging check, we are in big trouble if this message pops up!
936          */
937         if (mp_irqs[idx].dstirq != pin)
938                 printk(KERN_ERR "broken BIOS or MPTABLE parser, ayiee!!\n");
939
940         if (test_bit(bus, mp_bus_not_pci)) {
941                 irq = mp_irqs[idx].srcbusirq;
942         } else {
943                 u32 gsi = gsi_cfg->gsi_base + pin;
944
945                 if (gsi >= NR_IRQS_LEGACY)
946                         irq = gsi;
947                 else
948                         irq = gsi_top + gsi;
949         }
950
951 #ifdef CONFIG_X86_32
952         /*
953          * PCI IRQ command line redirection. Yes, limits are hardcoded.
954          */
955         if ((pin >= 16) && (pin <= 23)) {
956                 if (pirq_entries[pin-16] != -1) {
957                         if (!pirq_entries[pin-16]) {
958                                 apic_printk(APIC_VERBOSE, KERN_DEBUG
959                                                 "disabling PIRQ%d\n", pin-16);
960                         } else {
961                                 irq = pirq_entries[pin-16];
962                                 apic_printk(APIC_VERBOSE, KERN_DEBUG
963                                                 "using PIRQ%d -> IRQ %d\n",
964                                                 pin-16, irq);
965                         }
966                 }
967         }
968 #endif
969
970         return irq;
971 }
972
973 /*
974  * Find a specific PCI IRQ entry.
975  * Not an __init, possibly needed by modules
976  */
977 int IO_APIC_get_PCI_irq_vector(int bus, int slot, int pin,
978                                 struct io_apic_irq_attr *irq_attr)
979 {
980         int apic, i, best_guess = -1;
981
982         apic_printk(APIC_DEBUG,
983                     "querying PCI -> IRQ mapping bus:%d, slot:%d, pin:%d.\n",
984                     bus, slot, pin);
985         if (test_bit(bus, mp_bus_not_pci)) {
986                 apic_printk(APIC_VERBOSE,
987                             "PCI BIOS passed nonexistent PCI bus %d!\n", bus);
988                 return -1;
989         }
990         for (i = 0; i < mp_irq_entries; i++) {
991                 int lbus = mp_irqs[i].srcbus;
992
993                 for (apic = 0; apic < nr_ioapics; apic++)
994                         if (mpc_ioapic_id(apic) == mp_irqs[i].dstapic ||
995                             mp_irqs[i].dstapic == MP_APIC_ALL)
996                                 break;
997
998                 if (!test_bit(lbus, mp_bus_not_pci) &&
999                     !mp_irqs[i].irqtype &&
1000                     (bus == lbus) &&
1001                     (slot == ((mp_irqs[i].srcbusirq >> 2) & 0x1f))) {
1002                         int irq = pin_2_irq(i, apic, mp_irqs[i].dstirq);
1003
1004                         if (!(apic || IO_APIC_IRQ(irq)))
1005                                 continue;
1006
1007                         if (pin == (mp_irqs[i].srcbusirq & 3)) {
1008                                 set_io_apic_irq_attr(irq_attr, apic,
1009                                                      mp_irqs[i].dstirq,
1010                                                      irq_trigger(i),
1011                                                      irq_polarity(i));
1012                                 return irq;
1013                         }
1014                         /*
1015                          * Use the first all-but-pin matching entry as a
1016                          * best-guess fuzzy result for broken mptables.
1017                          */
1018                         if (best_guess < 0) {
1019                                 set_io_apic_irq_attr(irq_attr, apic,
1020                                                      mp_irqs[i].dstirq,
1021                                                      irq_trigger(i),
1022                                                      irq_polarity(i));
1023                                 best_guess = irq;
1024                         }
1025                 }
1026         }
1027         return best_guess;
1028 }
1029 EXPORT_SYMBOL(IO_APIC_get_PCI_irq_vector);
1030
1031 void lock_vector_lock(void)
1032 {
1033         /* Used to the online set of cpus does not change
1034          * during assign_irq_vector.
1035          */
1036         raw_spin_lock(&vector_lock);
1037 }
1038
1039 void unlock_vector_lock(void)
1040 {
1041         raw_spin_unlock(&vector_lock);
1042 }
1043
1044 static int
1045 __assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
1046 {
1047         /*
1048          * NOTE! The local APIC isn't very good at handling
1049          * multiple interrupts at the same interrupt level.
1050          * As the interrupt level is determined by taking the
1051          * vector number and shifting that right by 4, we
1052          * want to spread these out a bit so that they don't
1053          * all fall in the same interrupt level.
1054          *
1055          * Also, we've got to be careful not to trash gate
1056          * 0x80, because int 0x80 is hm, kind of importantish. ;)
1057          */
1058         static int current_vector = FIRST_EXTERNAL_VECTOR + VECTOR_OFFSET_START;
1059         static int current_offset = VECTOR_OFFSET_START % 8;
1060         unsigned int old_vector;
1061         int cpu, err;
1062         cpumask_var_t tmp_mask;
1063
1064         if (cfg->move_in_progress)
1065                 return -EBUSY;
1066
1067         if (!alloc_cpumask_var(&tmp_mask, GFP_ATOMIC))
1068                 return -ENOMEM;
1069
1070         old_vector = cfg->vector;
1071         if (old_vector) {
1072                 cpumask_and(tmp_mask, mask, cpu_online_mask);
1073                 cpumask_and(tmp_mask, cfg->domain, tmp_mask);
1074                 if (!cpumask_empty(tmp_mask)) {
1075                         free_cpumask_var(tmp_mask);
1076                         return 0;
1077                 }
1078         }
1079
1080         /* Only try and allocate irqs on cpus that are present */
1081         err = -ENOSPC;
1082         for_each_cpu_and(cpu, mask, cpu_online_mask) {
1083                 int new_cpu;
1084                 int vector, offset;
1085
1086                 apic->vector_allocation_domain(cpu, tmp_mask);
1087
1088                 vector = current_vector;
1089                 offset = current_offset;
1090 next:
1091                 vector += 8;
1092                 if (vector >= first_system_vector) {
1093                         /* If out of vectors on large boxen, must share them. */
1094                         offset = (offset + 1) % 8;
1095                         vector = FIRST_EXTERNAL_VECTOR + offset;
1096                 }
1097                 if (unlikely(current_vector == vector))
1098                         continue;
1099
1100                 if (test_bit(vector, used_vectors))
1101                         goto next;
1102
1103                 for_each_cpu_and(new_cpu, tmp_mask, cpu_online_mask)
1104                         if (per_cpu(vector_irq, new_cpu)[vector] != -1)
1105                                 goto next;
1106                 /* Found one! */
1107                 current_vector = vector;
1108                 current_offset = offset;
1109                 if (old_vector) {
1110                         cfg->move_in_progress = 1;
1111                         cpumask_copy(cfg->old_domain, cfg->domain);
1112                 }
1113                 for_each_cpu_and(new_cpu, tmp_mask, cpu_online_mask)
1114                         per_cpu(vector_irq, new_cpu)[vector] = irq;
1115                 cfg->vector = vector;
1116                 cpumask_copy(cfg->domain, tmp_mask);
1117                 err = 0;
1118                 break;
1119         }
1120         free_cpumask_var(tmp_mask);
1121         return err;
1122 }
1123
1124 int assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
1125 {
1126         int err;
1127         unsigned long flags;
1128
1129         raw_spin_lock_irqsave(&vector_lock, flags);
1130         err = __assign_irq_vector(irq, cfg, mask);
1131         raw_spin_unlock_irqrestore(&vector_lock, flags);
1132         return err;
1133 }
1134
1135 static void __clear_irq_vector(int irq, struct irq_cfg *cfg)
1136 {
1137         int cpu, vector;
1138
1139         BUG_ON(!cfg->vector);
1140
1141         vector = cfg->vector;
1142         for_each_cpu_and(cpu, cfg->domain, cpu_online_mask)
1143                 per_cpu(vector_irq, cpu)[vector] = -1;
1144
1145         cfg->vector = 0;
1146         cpumask_clear(cfg->domain);
1147
1148         if (likely(!cfg->move_in_progress))
1149                 return;
1150         for_each_cpu_and(cpu, cfg->old_domain, cpu_online_mask) {
1151                 for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS;
1152                                                                 vector++) {
1153                         if (per_cpu(vector_irq, cpu)[vector] != irq)
1154                                 continue;
1155                         per_cpu(vector_irq, cpu)[vector] = -1;
1156                         break;
1157                 }
1158         }
1159         cfg->move_in_progress = 0;
1160 }
1161
1162 void __setup_vector_irq(int cpu)
1163 {
1164         /* Initialize vector_irq on a new cpu */
1165         int irq, vector;
1166         struct irq_cfg *cfg;
1167
1168         /*
1169          * vector_lock will make sure that we don't run into irq vector
1170          * assignments that might be happening on another cpu in parallel,
1171          * while we setup our initial vector to irq mappings.
1172          */
1173         raw_spin_lock(&vector_lock);
1174         /* Mark the inuse vectors */
1175         for_each_active_irq(irq) {
1176                 cfg = irq_get_chip_data(irq);
1177                 if (!cfg)
1178                         continue;
1179                 /*
1180                  * If it is a legacy IRQ handled by the legacy PIC, this cpu
1181                  * will be part of the irq_cfg's domain.
1182                  */
1183                 if (irq < legacy_pic->nr_legacy_irqs && !IO_APIC_IRQ(irq))
1184                         cpumask_set_cpu(cpu, cfg->domain);
1185
1186                 if (!cpumask_test_cpu(cpu, cfg->domain))
1187                         continue;
1188                 vector = cfg->vector;
1189                 per_cpu(vector_irq, cpu)[vector] = irq;
1190         }
1191         /* Mark the free vectors */
1192         for (vector = 0; vector < NR_VECTORS; ++vector) {
1193                 irq = per_cpu(vector_irq, cpu)[vector];
1194                 if (irq < 0)
1195                         continue;
1196
1197                 cfg = irq_cfg(irq);
1198                 if (!cpumask_test_cpu(cpu, cfg->domain))
1199                         per_cpu(vector_irq, cpu)[vector] = -1;
1200         }
1201         raw_spin_unlock(&vector_lock);
1202 }
1203
1204 static struct irq_chip ioapic_chip;
1205 static struct irq_chip ir_ioapic_chip;
1206
1207 #ifdef CONFIG_X86_32
1208 static inline int IO_APIC_irq_trigger(int irq)
1209 {
1210         int apic, idx, pin;
1211
1212         for (apic = 0; apic < nr_ioapics; apic++) {
1213                 for (pin = 0; pin < ioapics[apic].nr_registers; pin++) {
1214                         idx = find_irq_entry(apic, pin, mp_INT);
1215                         if ((idx != -1) && (irq == pin_2_irq(idx, apic, pin)))
1216                                 return irq_trigger(idx);
1217                 }
1218         }
1219         /*
1220          * nonexistent IRQs are edge default
1221          */
1222         return 0;
1223 }
1224 #else
1225 static inline int IO_APIC_irq_trigger(int irq)
1226 {
1227         return 1;
1228 }
1229 #endif
1230
1231 static void ioapic_register_intr(unsigned int irq, struct irq_cfg *cfg,
1232                                  unsigned long trigger)
1233 {
1234         struct irq_chip *chip = &ioapic_chip;
1235         irq_flow_handler_t hdl;
1236         bool fasteoi;
1237
1238         if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) ||
1239             trigger == IOAPIC_LEVEL) {
1240                 irq_set_status_flags(irq, IRQ_LEVEL);
1241                 fasteoi = true;
1242         } else {
1243                 irq_clear_status_flags(irq, IRQ_LEVEL);
1244                 fasteoi = false;
1245         }
1246
1247         if (irq_remapped(cfg)) {
1248                 irq_set_status_flags(irq, IRQ_MOVE_PCNTXT);
1249                 chip = &ir_ioapic_chip;
1250                 fasteoi = trigger != 0;
1251         }
1252
1253         hdl = fasteoi ? handle_fasteoi_irq : handle_edge_irq;
1254         irq_set_chip_and_handler_name(irq, chip, hdl,
1255                                       fasteoi ? "fasteoi" : "edge");
1256 }
1257
1258 static int setup_ioapic_entry(int apic_id, int irq,
1259                               struct IO_APIC_route_entry *entry,
1260                               unsigned int destination, int trigger,
1261                               int polarity, int vector, int pin)
1262 {
1263         /*
1264          * add it to the IO-APIC irq-routing table:
1265          */
1266         memset(entry,0,sizeof(*entry));
1267
1268         if (intr_remapping_enabled) {
1269                 struct intel_iommu *iommu = map_ioapic_to_ir(apic_id);
1270                 struct irte irte;
1271                 struct IR_IO_APIC_route_entry *ir_entry =
1272                         (struct IR_IO_APIC_route_entry *) entry;
1273                 int index;
1274
1275                 if (!iommu)
1276                         panic("No mapping iommu for ioapic %d\n", apic_id);
1277
1278                 index = alloc_irte(iommu, irq, 1);
1279                 if (index < 0)
1280                         panic("Failed to allocate IRTE for ioapic %d\n", apic_id);
1281
1282                 prepare_irte(&irte, vector, destination);
1283
1284                 /* Set source-id of interrupt request */
1285                 set_ioapic_sid(&irte, apic_id);
1286
1287                 modify_irte(irq, &irte);
1288
1289                 ir_entry->index2 = (index >> 15) & 0x1;
1290                 ir_entry->zero = 0;
1291                 ir_entry->format = 1;
1292                 ir_entry->index = (index & 0x7fff);
1293                 /*
1294                  * IO-APIC RTE will be configured with virtual vector.
1295                  * irq handler will do the explicit EOI to the io-apic.
1296                  */
1297                 ir_entry->vector = pin;
1298
1299                 apic_printk(APIC_VERBOSE, KERN_DEBUG "IOAPIC[%d]: "
1300                         "Set IRTE entry (P:%d FPD:%d Dst_Mode:%d "
1301                         "Redir_hint:%d Trig_Mode:%d Dlvry_Mode:%X "
1302                         "Avail:%X Vector:%02X Dest:%08X "
1303                         "SID:%04X SQ:%X SVT:%X)\n",
1304                         apic_id, irte.present, irte.fpd, irte.dst_mode,
1305                         irte.redir_hint, irte.trigger_mode, irte.dlvry_mode,
1306                         irte.avail, irte.vector, irte.dest_id,
1307                         irte.sid, irte.sq, irte.svt);
1308         } else {
1309                 entry->delivery_mode = apic->irq_delivery_mode;
1310                 entry->dest_mode = apic->irq_dest_mode;
1311                 entry->dest = destination;
1312                 entry->vector = vector;
1313         }
1314
1315         entry->mask = 0;                                /* enable IRQ */
1316         entry->trigger = trigger;
1317         entry->polarity = polarity;
1318
1319         /* Mask level triggered irqs.
1320          * Use IRQ_DELAYED_DISABLE for edge triggered irqs.
1321          */
1322         if (trigger)
1323                 entry->mask = 1;
1324         return 0;
1325 }
1326
1327 static void setup_ioapic_irq(int apic_id, int pin, unsigned int irq,
1328                              struct irq_cfg *cfg, int trigger, int polarity)
1329 {
1330         struct IO_APIC_route_entry entry;
1331         unsigned int dest;
1332
1333         if (!IO_APIC_IRQ(irq))
1334                 return;
1335         /*
1336          * For legacy irqs, cfg->domain starts with cpu 0 for legacy
1337          * controllers like 8259. Now that IO-APIC can handle this irq, update
1338          * the cfg->domain.
1339          */
1340         if (irq < legacy_pic->nr_legacy_irqs && cpumask_test_cpu(0, cfg->domain))
1341                 apic->vector_allocation_domain(0, cfg->domain);
1342
1343         if (assign_irq_vector(irq, cfg, apic->target_cpus()))
1344                 return;
1345
1346         dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus());
1347
1348         apic_printk(APIC_VERBOSE,KERN_DEBUG
1349                     "IOAPIC[%d]: Set routing entry (%d-%d -> 0x%x -> "
1350                     "IRQ %d Mode:%i Active:%i Dest:%d)\n",
1351                     apic_id, mpc_ioapic_id(apic_id), pin, cfg->vector,
1352                     irq, trigger, polarity, dest);
1353
1354
1355         if (setup_ioapic_entry(mpc_ioapic_id(apic_id), irq, &entry,
1356                                dest, trigger, polarity, cfg->vector, pin)) {
1357                 printk("Failed to setup ioapic entry for ioapic  %d, pin %d\n",
1358                        mpc_ioapic_id(apic_id), pin);
1359                 __clear_irq_vector(irq, cfg);
1360                 return;
1361         }
1362
1363         ioapic_register_intr(irq, cfg, trigger);
1364         if (irq < legacy_pic->nr_legacy_irqs)
1365                 legacy_pic->mask(irq);
1366
1367         ioapic_write_entry(apic_id, pin, entry);
1368 }
1369
1370 static bool __init io_apic_pin_not_connected(int idx, int apic_id, int pin)
1371 {
1372         if (idx != -1)
1373                 return false;
1374
1375         apic_printk(APIC_VERBOSE, KERN_DEBUG " apic %d pin %d not connected\n",
1376                     mpc_ioapic_id(apic_id), pin);
1377         return true;
1378 }
1379
1380 static void __init __io_apic_setup_irqs(unsigned int apic_id)
1381 {
1382         int idx, node = cpu_to_node(0);
1383         struct io_apic_irq_attr attr;
1384         unsigned int pin, irq;
1385
1386         for (pin = 0; pin < ioapics[apic_id].nr_registers; pin++) {
1387                 idx = find_irq_entry(apic_id, pin, mp_INT);
1388                 if (io_apic_pin_not_connected(idx, apic_id, pin))
1389                         continue;
1390
1391                 irq = pin_2_irq(idx, apic_id, pin);
1392
1393                 if ((apic_id > 0) && (irq > 16))
1394                         continue;
1395
1396                 /*
1397                  * Skip the timer IRQ if there's a quirk handler
1398                  * installed and if it returns 1:
1399                  */
1400                 if (apic->multi_timer_check &&
1401                     apic->multi_timer_check(apic_id, irq))
1402                         continue;
1403
1404                 set_io_apic_irq_attr(&attr, apic_id, pin, irq_trigger(idx),
1405                                      irq_polarity(idx));
1406
1407                 io_apic_setup_irq_pin(irq, node, &attr);
1408         }
1409 }
1410
1411 static void __init setup_IO_APIC_irqs(void)
1412 {
1413         unsigned int apic_id;
1414
1415         apic_printk(APIC_VERBOSE, KERN_DEBUG "init IO_APIC IRQs\n");
1416
1417         for (apic_id = 0; apic_id < nr_ioapics; apic_id++)
1418                 __io_apic_setup_irqs(apic_id);
1419 }
1420
1421 /*
1422  * for the gsit that is not in first ioapic
1423  * but could not use acpi_register_gsi()
1424  * like some special sci in IBM x3330
1425  */
1426 void setup_IO_APIC_irq_extra(u32 gsi)
1427 {
1428         int apic_id = 0, pin, idx, irq, node = cpu_to_node(0);
1429         struct io_apic_irq_attr attr;
1430
1431         /*
1432          * Convert 'gsi' to 'ioapic.pin'.
1433          */
1434         apic_id = mp_find_ioapic(gsi);
1435         if (apic_id < 0)
1436                 return;
1437
1438         pin = mp_find_ioapic_pin(apic_id, gsi);
1439         idx = find_irq_entry(apic_id, pin, mp_INT);
1440         if (idx == -1)
1441                 return;
1442
1443         irq = pin_2_irq(idx, apic_id, pin);
1444
1445         /* Only handle the non legacy irqs on secondary ioapics */
1446         if (apic_id == 0 || irq < NR_IRQS_LEGACY)
1447                 return;
1448
1449         set_io_apic_irq_attr(&attr, apic_id, pin, irq_trigger(idx),
1450                              irq_polarity(idx));
1451
1452         io_apic_setup_irq_pin_once(irq, node, &attr);
1453 }
1454
1455 /*
1456  * Set up the timer pin, possibly with the 8259A-master behind.
1457  */
1458 static void __init setup_timer_IRQ0_pin(unsigned int apic_id, unsigned int pin,
1459                                         int vector)
1460 {
1461         struct IO_APIC_route_entry entry;
1462
1463         if (intr_remapping_enabled)
1464                 return;
1465
1466         memset(&entry, 0, sizeof(entry));
1467
1468         /*
1469          * We use logical delivery to get the timer IRQ
1470          * to the first CPU.
1471          */
1472         entry.dest_mode = apic->irq_dest_mode;
1473         entry.mask = 0;                 /* don't mask IRQ for edge */
1474         entry.dest = apic->cpu_mask_to_apicid(apic->target_cpus());
1475         entry.delivery_mode = apic->irq_delivery_mode;
1476         entry.polarity = 0;
1477         entry.trigger = 0;
1478         entry.vector = vector;
1479
1480         /*
1481          * The timer IRQ doesn't have to know that behind the
1482          * scene we may have a 8259A-master in AEOI mode ...
1483          */
1484         irq_set_chip_and_handler_name(0, &ioapic_chip, handle_edge_irq,
1485                                       "edge");
1486
1487         /*
1488          * Add it to the IO-APIC irq-routing table:
1489          */
1490         ioapic_write_entry(apic_id, pin, entry);
1491 }
1492
1493
1494 __apicdebuginit(void) print_IO_APIC(void)
1495 {
1496         int apic, i;
1497         union IO_APIC_reg_00 reg_00;
1498         union IO_APIC_reg_01 reg_01;
1499         union IO_APIC_reg_02 reg_02;
1500         union IO_APIC_reg_03 reg_03;
1501         unsigned long flags;
1502         struct irq_cfg *cfg;
1503         unsigned int irq;
1504
1505         printk(KERN_DEBUG "number of MP IRQ sources: %d.\n", mp_irq_entries);
1506         for (i = 0; i < nr_ioapics; i++)
1507                 printk(KERN_DEBUG "number of IO-APIC #%d registers: %d.\n",
1508                        mpc_ioapic_id(i), ioapics[i].nr_registers);
1509
1510         /*
1511          * We are a bit conservative about what we expect.  We have to
1512          * know about every hardware change ASAP.
1513          */
1514         printk(KERN_INFO "testing the IO APIC.......................\n");
1515
1516         for (apic = 0; apic < nr_ioapics; apic++) {
1517
1518         raw_spin_lock_irqsave(&ioapic_lock, flags);
1519         reg_00.raw = io_apic_read(apic, 0);
1520         reg_01.raw = io_apic_read(apic, 1);
1521         if (reg_01.bits.version >= 0x10)
1522                 reg_02.raw = io_apic_read(apic, 2);
1523         if (reg_01.bits.version >= 0x20)
1524                 reg_03.raw = io_apic_read(apic, 3);
1525         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
1526
1527         printk("\n");
1528         printk(KERN_DEBUG "IO APIC #%d......\n", mpc_ioapic_id(apic));
1529         printk(KERN_DEBUG ".... register #00: %08X\n", reg_00.raw);
1530         printk(KERN_DEBUG ".......    : physical APIC id: %02X\n", reg_00.bits.ID);
1531         printk(KERN_DEBUG ".......    : Delivery Type: %X\n", reg_00.bits.delivery_type);
1532         printk(KERN_DEBUG ".......    : LTS          : %X\n", reg_00.bits.LTS);
1533
1534         printk(KERN_DEBUG ".... register #01: %08X\n", *(int *)&reg_01);
1535         printk(KERN_DEBUG ".......     : max redirection entries: %02X\n",
1536                 reg_01.bits.entries);
1537
1538         printk(KERN_DEBUG ".......     : PRQ implemented: %X\n", reg_01.bits.PRQ);
1539         printk(KERN_DEBUG ".......     : IO APIC version: %02X\n",
1540                 reg_01.bits.version);
1541
1542         /*
1543          * Some Intel chipsets with IO APIC VERSION of 0x1? don't have reg_02,
1544          * but the value of reg_02 is read as the previous read register
1545          * value, so ignore it if reg_02 == reg_01.
1546          */
1547         if (reg_01.bits.version >= 0x10 && reg_02.raw != reg_01.raw) {
1548                 printk(KERN_DEBUG ".... register #02: %08X\n", reg_02.raw);
1549                 printk(KERN_DEBUG ".......     : arbitration: %02X\n", reg_02.bits.arbitration);
1550         }
1551
1552         /*
1553          * Some Intel chipsets with IO APIC VERSION of 0x2? don't have reg_02
1554          * or reg_03, but the value of reg_0[23] is read as the previous read
1555          * register value, so ignore it if reg_03 == reg_0[12].
1556          */
1557         if (reg_01.bits.version >= 0x20 && reg_03.raw != reg_02.raw &&
1558             reg_03.raw != reg_01.raw) {
1559                 printk(KERN_DEBUG ".... register #03: %08X\n", reg_03.raw);
1560                 printk(KERN_DEBUG ".......     : Boot DT    : %X\n", reg_03.bits.boot_DT);
1561         }
1562
1563         printk(KERN_DEBUG ".... IRQ redirection table:\n");
1564
1565         if (intr_remapping_enabled) {
1566                 printk(KERN_DEBUG " NR Indx Fmt Mask Trig IRR"
1567                         " Pol Stat Indx2 Zero Vect:\n");
1568         } else {
1569                 printk(KERN_DEBUG " NR Dst Mask Trig IRR Pol"
1570                         " Stat Dmod Deli Vect:\n");
1571         }
1572
1573         for (i = 0; i <= reg_01.bits.entries; i++) {
1574                 if (intr_remapping_enabled) {
1575                         struct IO_APIC_route_entry entry;
1576                         struct IR_IO_APIC_route_entry *ir_entry;
1577
1578                         entry = ioapic_read_entry(apic, i);
1579                         ir_entry = (struct IR_IO_APIC_route_entry *) &entry;
1580                         printk(KERN_DEBUG " %02x %04X ",
1581                                 i,
1582                                 ir_entry->index
1583                         );
1584                         printk("%1d   %1d    %1d    %1d   %1d   "
1585                                 "%1d    %1d     %X    %02X\n",
1586                                 ir_entry->format,
1587                                 ir_entry->mask,
1588                                 ir_entry->trigger,
1589                                 ir_entry->irr,
1590                                 ir_entry->polarity,
1591                                 ir_entry->delivery_status,
1592                                 ir_entry->index2,
1593                                 ir_entry->zero,
1594                                 ir_entry->vector
1595                         );
1596                 } else {
1597                         struct IO_APIC_route_entry entry;
1598
1599                         entry = ioapic_read_entry(apic, i);
1600                         printk(KERN_DEBUG " %02x %02X  ",
1601                                 i,
1602                                 entry.dest
1603                         );
1604                         printk("%1d    %1d    %1d   %1d   %1d    "
1605                                 "%1d    %1d    %02X\n",
1606                                 entry.mask,
1607                                 entry.trigger,
1608                                 entry.irr,
1609                                 entry.polarity,
1610                                 entry.delivery_status,
1611                                 entry.dest_mode,
1612                                 entry.delivery_mode,
1613                                 entry.vector
1614                         );
1615                 }
1616         }
1617         }
1618
1619         printk(KERN_DEBUG "IRQ to pin mappings:\n");
1620         for_each_active_irq(irq) {
1621                 struct irq_pin_list *entry;
1622
1623                 cfg = irq_get_chip_data(irq);
1624                 if (!cfg)
1625                         continue;
1626                 entry = cfg->irq_2_pin;
1627                 if (!entry)
1628                         continue;
1629                 printk(KERN_DEBUG "IRQ%d ", irq);
1630                 for_each_irq_pin(entry, cfg->irq_2_pin)
1631                         printk("-> %d:%d", entry->apic, entry->pin);
1632                 printk("\n");
1633         }
1634
1635         printk(KERN_INFO ".................................... done.\n");
1636
1637         return;
1638 }
1639
1640 __apicdebuginit(void) print_APIC_field(int base)
1641 {
1642         int i;
1643
1644         printk(KERN_DEBUG);
1645
1646         for (i = 0; i < 8; i++)
1647                 printk(KERN_CONT "%08x", apic_read(base + i*0x10));
1648
1649         printk(KERN_CONT "\n");
1650 }
1651
1652 __apicdebuginit(void) print_local_APIC(void *dummy)
1653 {
1654         unsigned int i, v, ver, maxlvt;
1655         u64 icr;
1656
1657         printk(KERN_DEBUG "printing local APIC contents on CPU#%d/%d:\n",
1658                 smp_processor_id(), hard_smp_processor_id());
1659         v = apic_read(APIC_ID);
1660         printk(KERN_INFO "... APIC ID:      %08x (%01x)\n", v, read_apic_id());
1661         v = apic_read(APIC_LVR);
1662         printk(KERN_INFO "... APIC VERSION: %08x\n", v);
1663         ver = GET_APIC_VERSION(v);
1664         maxlvt = lapic_get_maxlvt();
1665
1666         v = apic_read(APIC_TASKPRI);
1667         printk(KERN_DEBUG "... APIC TASKPRI: %08x (%02x)\n", v, v & APIC_TPRI_MASK);
1668
1669         if (APIC_INTEGRATED(ver)) {                     /* !82489DX */
1670                 if (!APIC_XAPIC(ver)) {
1671                         v = apic_read(APIC_ARBPRI);
1672                         printk(KERN_DEBUG "... APIC ARBPRI: %08x (%02x)\n", v,
1673                                v & APIC_ARBPRI_MASK);
1674                 }
1675                 v = apic_read(APIC_PROCPRI);
1676                 printk(KERN_DEBUG "... APIC PROCPRI: %08x\n", v);
1677         }
1678
1679         /*
1680          * Remote read supported only in the 82489DX and local APIC for
1681          * Pentium processors.
1682          */
1683         if (!APIC_INTEGRATED(ver) || maxlvt == 3) {
1684                 v = apic_read(APIC_RRR);
1685                 printk(KERN_DEBUG "... APIC RRR: %08x\n", v);
1686         }
1687
1688         v = apic_read(APIC_LDR);
1689         printk(KERN_DEBUG "... APIC LDR: %08x\n", v);
1690         if (!x2apic_enabled()) {
1691                 v = apic_read(APIC_DFR);
1692                 printk(KERN_DEBUG "... APIC DFR: %08x\n", v);
1693         }
1694         v = apic_read(APIC_SPIV);
1695         printk(KERN_DEBUG "... APIC SPIV: %08x\n", v);
1696
1697         printk(KERN_DEBUG "... APIC ISR field:\n");
1698         print_APIC_field(APIC_ISR);
1699         printk(KERN_DEBUG "... APIC TMR field:\n");
1700         print_APIC_field(APIC_TMR);
1701         printk(KERN_DEBUG "... APIC IRR field:\n");
1702         print_APIC_field(APIC_IRR);
1703
1704         if (APIC_INTEGRATED(ver)) {             /* !82489DX */
1705                 if (maxlvt > 3)         /* Due to the Pentium erratum 3AP. */
1706                         apic_write(APIC_ESR, 0);
1707
1708                 v = apic_read(APIC_ESR);
1709                 printk(KERN_DEBUG "... APIC ESR: %08x\n", v);
1710         }
1711
1712         icr = apic_icr_read();
1713         printk(KERN_DEBUG "... APIC ICR: %08x\n", (u32)icr);
1714         printk(KERN_DEBUG "... APIC ICR2: %08x\n", (u32)(icr >> 32));
1715
1716         v = apic_read(APIC_LVTT);
1717         printk(KERN_DEBUG "... APIC LVTT: %08x\n", v);
1718
1719         if (maxlvt > 3) {                       /* PC is LVT#4. */
1720                 v = apic_read(APIC_LVTPC);
1721                 printk(KERN_DEBUG "... APIC LVTPC: %08x\n", v);
1722         }
1723         v = apic_read(APIC_LVT0);
1724         printk(KERN_DEBUG "... APIC LVT0: %08x\n", v);
1725         v = apic_read(APIC_LVT1);
1726         printk(KERN_DEBUG "... APIC LVT1: %08x\n", v);
1727
1728         if (maxlvt > 2) {                       /* ERR is LVT#3. */
1729                 v = apic_read(APIC_LVTERR);
1730                 printk(KERN_DEBUG "... APIC LVTERR: %08x\n", v);
1731         }
1732
1733         v = apic_read(APIC_TMICT);
1734         printk(KERN_DEBUG "... APIC TMICT: %08x\n", v);
1735         v = apic_read(APIC_TMCCT);
1736         printk(KERN_DEBUG "... APIC TMCCT: %08x\n", v);
1737         v = apic_read(APIC_TDCR);
1738         printk(KERN_DEBUG "... APIC TDCR: %08x\n", v);
1739
1740         if (boot_cpu_has(X86_FEATURE_EXTAPIC)) {
1741                 v = apic_read(APIC_EFEAT);
1742                 maxlvt = (v >> 16) & 0xff;
1743                 printk(KERN_DEBUG "... APIC EFEAT: %08x\n", v);
1744                 v = apic_read(APIC_ECTRL);
1745                 printk(KERN_DEBUG "... APIC ECTRL: %08x\n", v);
1746                 for (i = 0; i < maxlvt; i++) {
1747                         v = apic_read(APIC_EILVTn(i));
1748                         printk(KERN_DEBUG "... APIC EILVT%d: %08x\n", i, v);
1749                 }
1750         }
1751         printk("\n");
1752 }
1753
1754 __apicdebuginit(void) print_local_APICs(int maxcpu)
1755 {
1756         int cpu;
1757
1758         if (!maxcpu)
1759                 return;
1760
1761         preempt_disable();
1762         for_each_online_cpu(cpu) {
1763                 if (cpu >= maxcpu)
1764                         break;
1765                 smp_call_function_single(cpu, print_local_APIC, NULL, 1);
1766         }
1767         preempt_enable();
1768 }
1769
1770 __apicdebuginit(void) print_PIC(void)
1771 {
1772         unsigned int v;
1773         unsigned long flags;
1774
1775         if (!legacy_pic->nr_legacy_irqs)
1776                 return;
1777
1778         printk(KERN_DEBUG "\nprinting PIC contents\n");
1779
1780         raw_spin_lock_irqsave(&i8259A_lock, flags);
1781
1782         v = inb(0xa1) << 8 | inb(0x21);
1783         printk(KERN_DEBUG "... PIC  IMR: %04x\n", v);
1784
1785         v = inb(0xa0) << 8 | inb(0x20);
1786         printk(KERN_DEBUG "... PIC  IRR: %04x\n", v);
1787
1788         outb(0x0b,0xa0);
1789         outb(0x0b,0x20);
1790         v = inb(0xa0) << 8 | inb(0x20);
1791         outb(0x0a,0xa0);
1792         outb(0x0a,0x20);
1793
1794         raw_spin_unlock_irqrestore(&i8259A_lock, flags);
1795
1796         printk(KERN_DEBUG "... PIC  ISR: %04x\n", v);
1797
1798         v = inb(0x4d1) << 8 | inb(0x4d0);
1799         printk(KERN_DEBUG "... PIC ELCR: %04x\n", v);
1800 }
1801
1802 static int __initdata show_lapic = 1;
1803 static __init int setup_show_lapic(char *arg)
1804 {
1805         int num = -1;
1806
1807         if (strcmp(arg, "all") == 0) {
1808                 show_lapic = CONFIG_NR_CPUS;
1809         } else {
1810                 get_option(&arg, &num);
1811                 if (num >= 0)
1812                         show_lapic = num;
1813         }
1814
1815         return 1;
1816 }
1817 __setup("show_lapic=", setup_show_lapic);
1818
1819 __apicdebuginit(int) print_ICs(void)
1820 {
1821         if (apic_verbosity == APIC_QUIET)
1822                 return 0;
1823
1824         print_PIC();
1825
1826         /* don't print out if apic is not there */
1827         if (!cpu_has_apic && !apic_from_smp_config())
1828                 return 0;
1829
1830         print_local_APICs(show_lapic);
1831         print_IO_APIC();
1832
1833         return 0;
1834 }
1835
1836 late_initcall(print_ICs);
1837
1838
1839 /* Where if anywhere is the i8259 connect in external int mode */
1840 static struct { int pin, apic; } ioapic_i8259 = { -1, -1 };
1841
1842 void __init enable_IO_APIC(void)
1843 {
1844         int i8259_apic, i8259_pin;
1845         int apic;
1846
1847         if (!legacy_pic->nr_legacy_irqs)
1848                 return;
1849
1850         for(apic = 0; apic < nr_ioapics; apic++) {
1851                 int pin;
1852                 /* See if any of the pins is in ExtINT mode */
1853                 for (pin = 0; pin < ioapics[apic].nr_registers; pin++) {
1854                         struct IO_APIC_route_entry entry;
1855                         entry = ioapic_read_entry(apic, pin);
1856
1857                         /* If the interrupt line is enabled and in ExtInt mode
1858                          * I have found the pin where the i8259 is connected.
1859                          */
1860                         if ((entry.mask == 0) && (entry.delivery_mode == dest_ExtINT)) {
1861                                 ioapic_i8259.apic = apic;
1862                                 ioapic_i8259.pin  = pin;
1863                                 goto found_i8259;
1864                         }
1865                 }
1866         }
1867  found_i8259:
1868         /* Look to see what if the MP table has reported the ExtINT */
1869         /* If we could not find the appropriate pin by looking at the ioapic
1870          * the i8259 probably is not connected the ioapic but give the
1871          * mptable a chance anyway.
1872          */
1873         i8259_pin  = find_isa_irq_pin(0, mp_ExtINT);
1874         i8259_apic = find_isa_irq_apic(0, mp_ExtINT);
1875         /* Trust the MP table if nothing is setup in the hardware */
1876         if ((ioapic_i8259.pin == -1) && (i8259_pin >= 0)) {
1877                 printk(KERN_WARNING "ExtINT not setup in hardware but reported by MP table\n");
1878                 ioapic_i8259.pin  = i8259_pin;
1879                 ioapic_i8259.apic = i8259_apic;
1880         }
1881         /* Complain if the MP table and the hardware disagree */
1882         if (((ioapic_i8259.apic != i8259_apic) || (ioapic_i8259.pin != i8259_pin)) &&
1883                 (i8259_pin >= 0) && (ioapic_i8259.pin >= 0))
1884         {
1885                 printk(KERN_WARNING "ExtINT in hardware and MP table differ\n");
1886         }
1887
1888         /*
1889          * Do not trust the IO-APIC being empty at bootup
1890          */
1891         clear_IO_APIC();
1892 }
1893
1894 /*
1895  * Not an __init, needed by the reboot code
1896  */
1897 void disable_IO_APIC(void)
1898 {
1899         /*
1900          * Clear the IO-APIC before rebooting:
1901          */
1902         clear_IO_APIC();
1903
1904         if (!legacy_pic->nr_legacy_irqs)
1905                 return;
1906
1907         /*
1908          * If the i8259 is routed through an IOAPIC
1909          * Put that IOAPIC in virtual wire mode
1910          * so legacy interrupts can be delivered.
1911          *
1912          * With interrupt-remapping, for now we will use virtual wire A mode,
1913          * as virtual wire B is little complex (need to configure both
1914          * IOAPIC RTE as well as interrupt-remapping table entry).
1915          * As this gets called during crash dump, keep this simple for now.
1916          */
1917         if (ioapic_i8259.pin != -1 && !intr_remapping_enabled) {
1918                 struct IO_APIC_route_entry entry;
1919
1920                 memset(&entry, 0, sizeof(entry));
1921                 entry.mask            = 0; /* Enabled */
1922                 entry.trigger         = 0; /* Edge */
1923                 entry.irr             = 0;
1924                 entry.polarity        = 0; /* High */
1925                 entry.delivery_status = 0;
1926                 entry.dest_mode       = 0; /* Physical */
1927                 entry.delivery_mode   = dest_ExtINT; /* ExtInt */
1928                 entry.vector          = 0;
1929                 entry.dest            = read_apic_id();
1930
1931                 /*
1932                  * Add it to the IO-APIC irq-routing table:
1933                  */
1934                 ioapic_write_entry(ioapic_i8259.apic, ioapic_i8259.pin, entry);
1935         }
1936
1937         /*
1938          * Use virtual wire A mode when interrupt remapping is enabled.
1939          */
1940         if (cpu_has_apic || apic_from_smp_config())
1941                 disconnect_bsp_APIC(!intr_remapping_enabled &&
1942                                 ioapic_i8259.pin != -1);
1943 }
1944
1945 #ifdef CONFIG_X86_32
1946 /*
1947  * function to set the IO-APIC physical IDs based on the
1948  * values stored in the MPC table.
1949  *
1950  * by Matt Domsch <Matt_Domsch@dell.com>  Tue Dec 21 12:25:05 CST 1999
1951  */
1952 void __init setup_ioapic_ids_from_mpc_nocheck(void)
1953 {
1954         union IO_APIC_reg_00 reg_00;
1955         physid_mask_t phys_id_present_map;
1956         int apic_id;
1957         int i;
1958         unsigned char old_id;
1959         unsigned long flags;
1960
1961         /*
1962          * This is broken; anything with a real cpu count has to
1963          * circumvent this idiocy regardless.
1964          */
1965         apic->ioapic_phys_id_map(&phys_cpu_present_map, &phys_id_present_map);
1966
1967         /*
1968          * Set the IOAPIC ID to the value stored in the MPC table.
1969          */
1970         for (apic_id = 0; apic_id < nr_ioapics; apic_id++) {
1971
1972                 /* Read the register 0 value */
1973                 raw_spin_lock_irqsave(&ioapic_lock, flags);
1974                 reg_00.raw = io_apic_read(apic_id, 0);
1975                 raw_spin_unlock_irqrestore(&ioapic_lock, flags);
1976
1977                 old_id = mpc_ioapic_id(apic_id);
1978
1979                 if (mpc_ioapic_id(apic_id) >= get_physical_broadcast()) {
1980                         printk(KERN_ERR "BIOS bug, IO-APIC#%d ID is %d in the MPC table!...\n",
1981                                 apic_id, mpc_ioapic_id(apic_id));
1982                         printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
1983                                 reg_00.bits.ID);
1984                         ioapics[apic_id].mp_config.apicid = reg_00.bits.ID;
1985                 }
1986
1987                 /*
1988                  * Sanity check, is the ID really free? Every APIC in a
1989                  * system must have a unique ID or we get lots of nice
1990                  * 'stuck on smp_invalidate_needed IPI wait' messages.
1991                  */
1992                 if (apic->check_apicid_used(&phys_id_present_map,
1993                                             mpc_ioapic_id(apic_id))) {
1994                         printk(KERN_ERR "BIOS bug, IO-APIC#%d ID %d is already used!...\n",
1995                                 apic_id, mpc_ioapic_id(apic_id));
1996                         for (i = 0; i < get_physical_broadcast(); i++)
1997                                 if (!physid_isset(i, phys_id_present_map))
1998                                         break;
1999                         if (i >= get_physical_broadcast())
2000                                 panic("Max APIC ID exceeded!\n");
2001                         printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
2002                                 i);
2003                         physid_set(i, phys_id_present_map);
2004                         ioapics[apic_id].mp_config.apicid = i;
2005                 } else {
2006                         physid_mask_t tmp;
2007                         apic->apicid_to_cpu_present(mpc_ioapic_id(apic_id),
2008                                                     &tmp);
2009                         apic_printk(APIC_VERBOSE, "Setting %d in the "
2010                                         "phys_id_present_map\n",
2011                                         mpc_ioapic_id(apic_id));
2012                         physids_or(phys_id_present_map, phys_id_present_map, tmp);
2013                 }
2014
2015                 /*
2016                  * We need to adjust the IRQ routing table
2017                  * if the ID changed.
2018                  */
2019                 if (old_id != mpc_ioapic_id(apic_id))
2020                         for (i = 0; i < mp_irq_entries; i++)
2021                                 if (mp_irqs[i].dstapic == old_id)
2022                                         mp_irqs[i].dstapic
2023                                                 = mpc_ioapic_id(apic_id);
2024
2025                 /*
2026                  * Update the ID register according to the right value
2027                  * from the MPC table if they are different.
2028                  */
2029                 if (mpc_ioapic_id(apic_id) == reg_00.bits.ID)
2030                         continue;
2031
2032                 apic_printk(APIC_VERBOSE, KERN_INFO
2033                         "...changing IO-APIC physical APIC ID to %d ...",
2034                         mpc_ioapic_id(apic_id));
2035
2036                 reg_00.bits.ID = mpc_ioapic_id(apic_id);
2037                 raw_spin_lock_irqsave(&ioapic_lock, flags);
2038                 io_apic_write(apic_id, 0, reg_00.raw);
2039                 raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2040
2041                 /*
2042                  * Sanity check
2043                  */
2044                 raw_spin_lock_irqsave(&ioapic_lock, flags);
2045                 reg_00.raw = io_apic_read(apic_id, 0);
2046                 raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2047                 if (reg_00.bits.ID != mpc_ioapic_id(apic_id))
2048                         printk("could not set ID!\n");
2049                 else
2050                         apic_printk(APIC_VERBOSE, " ok.\n");
2051         }
2052 }
2053
2054 void __init setup_ioapic_ids_from_mpc(void)
2055 {
2056
2057         if (acpi_ioapic)
2058                 return;
2059         /*
2060          * Don't check I/O APIC IDs for xAPIC systems.  They have
2061          * no meaning without the serial APIC bus.
2062          */
2063         if (!(boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
2064                 || APIC_XAPIC(apic_version[boot_cpu_physical_apicid]))
2065                 return;
2066         setup_ioapic_ids_from_mpc_nocheck();
2067 }
2068 #endif
2069
2070 int no_timer_check __initdata;
2071
2072 static int __init notimercheck(char *s)
2073 {
2074         no_timer_check = 1;
2075         return 1;
2076 }
2077 __setup("no_timer_check", notimercheck);
2078
2079 /*
2080  * There is a nasty bug in some older SMP boards, their mptable lies
2081  * about the timer IRQ. We do the following to work around the situation:
2082  *
2083  *      - timer IRQ defaults to IO-APIC IRQ
2084  *      - if this function detects that timer IRQs are defunct, then we fall
2085  *        back to ISA timer IRQs
2086  */
2087 static int __init timer_irq_works(void)
2088 {
2089         unsigned long t1 = jiffies;
2090         unsigned long flags;
2091
2092         if (no_timer_check)
2093                 return 1;
2094
2095         local_save_flags(flags);
2096         local_irq_enable();
2097         /* Let ten ticks pass... */
2098         mdelay((10 * 1000) / HZ);
2099         local_irq_restore(flags);
2100
2101         /*
2102          * Expect a few ticks at least, to be sure some possible
2103          * glue logic does not lock up after one or two first
2104          * ticks in a non-ExtINT mode.  Also the local APIC
2105          * might have cached one ExtINT interrupt.  Finally, at
2106          * least one tick may be lost due to delays.
2107          */
2108
2109         /* jiffies wrap? */
2110         if (time_after(jiffies, t1 + 4))
2111                 return 1;
2112         return 0;
2113 }
2114
2115 /*
2116  * In the SMP+IOAPIC case it might happen that there are an unspecified
2117  * number of pending IRQ events unhandled. These cases are very rare,
2118  * so we 'resend' these IRQs via IPIs, to the same CPU. It's much
2119  * better to do it this way as thus we do not have to be aware of
2120  * 'pending' interrupts in the IRQ path, except at this point.
2121  */
2122 /*
2123  * Edge triggered needs to resend any interrupt
2124  * that was delayed but this is now handled in the device
2125  * independent code.
2126  */
2127
2128 /*
2129  * Starting up a edge-triggered IO-APIC interrupt is
2130  * nasty - we need to make sure that we get the edge.
2131  * If it is already asserted for some reason, we need
2132  * return 1 to indicate that is was pending.
2133  *
2134  * This is not complete - we should be able to fake
2135  * an edge even if it isn't on the 8259A...
2136  */
2137
2138 static unsigned int startup_ioapic_irq(struct irq_data *data)
2139 {
2140         int was_pending = 0, irq = data->irq;
2141         unsigned long flags;
2142
2143         raw_spin_lock_irqsave(&ioapic_lock, flags);
2144         if (irq < legacy_pic->nr_legacy_irqs) {
2145                 legacy_pic->mask(irq);
2146                 if (legacy_pic->irq_pending(irq))
2147                         was_pending = 1;
2148         }
2149         __unmask_ioapic(data->chip_data);
2150         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2151
2152         return was_pending;
2153 }
2154
2155 static int ioapic_retrigger_irq(struct irq_data *data)
2156 {
2157         struct irq_cfg *cfg = data->chip_data;
2158         unsigned long flags;
2159
2160         raw_spin_lock_irqsave(&vector_lock, flags);
2161         apic->send_IPI_mask(cpumask_of(cpumask_first(cfg->domain)), cfg->vector);
2162         raw_spin_unlock_irqrestore(&vector_lock, flags);
2163
2164         return 1;
2165 }
2166
2167 /*
2168  * Level and edge triggered IO-APIC interrupts need different handling,
2169  * so we use two separate IRQ descriptors. Edge triggered IRQs can be
2170  * handled with the level-triggered descriptor, but that one has slightly
2171  * more overhead. Level-triggered interrupts cannot be handled with the
2172  * edge-triggered handler, without risking IRQ storms and other ugly
2173  * races.
2174  */
2175
2176 #ifdef CONFIG_SMP
2177 void send_cleanup_vector(struct irq_cfg *cfg)
2178 {
2179         cpumask_var_t cleanup_mask;
2180
2181         if (unlikely(!alloc_cpumask_var(&cleanup_mask, GFP_ATOMIC))) {
2182                 unsigned int i;
2183                 for_each_cpu_and(i, cfg->old_domain, cpu_online_mask)
2184                         apic->send_IPI_mask(cpumask_of(i), IRQ_MOVE_CLEANUP_VECTOR);
2185         } else {
2186                 cpumask_and(cleanup_mask, cfg->old_domain, cpu_online_mask);
2187                 apic->send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
2188                 free_cpumask_var(cleanup_mask);
2189         }
2190         cfg->move_in_progress = 0;
2191 }
2192
2193 static void __target_IO_APIC_irq(unsigned int irq, unsigned int dest, struct irq_cfg *cfg)
2194 {
2195         int apic, pin;
2196         struct irq_pin_list *entry;
2197         u8 vector = cfg->vector;
2198
2199         for_each_irq_pin(entry, cfg->irq_2_pin) {
2200                 unsigned int reg;
2201
2202                 apic = entry->apic;
2203                 pin = entry->pin;
2204                 /*
2205                  * With interrupt-remapping, destination information comes
2206                  * from interrupt-remapping table entry.
2207                  */
2208                 if (!irq_remapped(cfg))
2209                         io_apic_write(apic, 0x11 + pin*2, dest);
2210                 reg = io_apic_read(apic, 0x10 + pin*2);
2211                 reg &= ~IO_APIC_REDIR_VECTOR_MASK;
2212                 reg |= vector;
2213                 io_apic_modify(apic, 0x10 + pin*2, reg);
2214         }
2215 }
2216
2217 /*
2218  * Either sets data->affinity to a valid value, and returns
2219  * ->cpu_mask_to_apicid of that in dest_id, or returns -1 and
2220  * leaves data->affinity untouched.
2221  */
2222 int __ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
2223                           unsigned int *dest_id)
2224 {
2225         struct irq_cfg *cfg = data->chip_data;
2226
2227         if (!cpumask_intersects(mask, cpu_online_mask))
2228                 return -1;
2229
2230         if (assign_irq_vector(data->irq, data->chip_data, mask))
2231                 return -1;
2232
2233         cpumask_copy(data->affinity, mask);
2234
2235         *dest_id = apic->cpu_mask_to_apicid_and(mask, cfg->domain);
2236         return 0;
2237 }
2238
2239 static int
2240 ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
2241                     bool force)
2242 {
2243         unsigned int dest, irq = data->irq;
2244         unsigned long flags;
2245         int ret;
2246
2247         raw_spin_lock_irqsave(&ioapic_lock, flags);
2248         ret = __ioapic_set_affinity(data, mask, &dest);
2249         if (!ret) {
2250                 /* Only the high 8 bits are valid. */
2251                 dest = SET_APIC_LOGICAL_ID(dest);
2252                 __target_IO_APIC_irq(irq, dest, data->chip_data);
2253         }
2254         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2255         return ret;
2256 }
2257
2258 #ifdef CONFIG_INTR_REMAP
2259
2260 /*
2261  * Migrate the IO-APIC irq in the presence of intr-remapping.
2262  *
2263  * For both level and edge triggered, irq migration is a simple atomic
2264  * update(of vector and cpu destination) of IRTE and flush the hardware cache.
2265  *
2266  * For level triggered, we eliminate the io-apic RTE modification (with the
2267  * updated vector information), by using a virtual vector (io-apic pin number).
2268  * Real vector that is used for interrupting cpu will be coming from
2269  * the interrupt-remapping table entry.
2270  */
2271 static int
2272 ir_ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
2273                        bool force)
2274 {
2275         struct irq_cfg *cfg = data->chip_data;
2276         unsigned int dest, irq = data->irq;
2277         struct irte irte;
2278
2279         if (!cpumask_intersects(mask, cpu_online_mask))
2280                 return -EINVAL;
2281
2282         if (get_irte(irq, &irte))
2283                 return -EBUSY;
2284
2285         if (assign_irq_vector(irq, cfg, mask))
2286                 return -EBUSY;
2287
2288         dest = apic->cpu_mask_to_apicid_and(cfg->domain, mask);
2289
2290         irte.vector = cfg->vector;
2291         irte.dest_id = IRTE_DEST(dest);
2292
2293         /*
2294          * Modified the IRTE and flushes the Interrupt entry cache.
2295          */
2296         modify_irte(irq, &irte);
2297
2298         if (cfg->move_in_progress)
2299                 send_cleanup_vector(cfg);
2300
2301         cpumask_copy(data->affinity, mask);
2302         return 0;
2303 }
2304
2305 #else
2306 static inline int
2307 ir_ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
2308                        bool force)
2309 {
2310         return 0;
2311 }
2312 #endif
2313
2314 asmlinkage void smp_irq_move_cleanup_interrupt(void)
2315 {
2316         unsigned vector, me;
2317
2318         ack_APIC_irq();
2319         exit_idle();
2320         irq_enter();
2321
2322         me = smp_processor_id();
2323         for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) {
2324                 unsigned int irq;
2325                 unsigned int irr;
2326                 struct irq_desc *desc;
2327                 struct irq_cfg *cfg;
2328                 irq = __this_cpu_read(vector_irq[vector]);
2329
2330                 if (irq == -1)
2331                         continue;
2332
2333                 desc = irq_to_desc(irq);
2334                 if (!desc)
2335                         continue;
2336
2337                 cfg = irq_cfg(irq);
2338                 raw_spin_lock(&desc->lock);
2339
2340                 /*
2341                  * Check if the irq migration is in progress. If so, we
2342                  * haven't received the cleanup request yet for this irq.
2343                  */
2344                 if (cfg->move_in_progress)
2345                         goto unlock;
2346
2347                 if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain))
2348                         goto unlock;
2349
2350                 irr = apic_read(APIC_IRR + (vector / 32 * 0x10));
2351                 /*
2352                  * Check if the vector that needs to be cleanedup is
2353                  * registered at the cpu's IRR. If so, then this is not
2354                  * the best time to clean it up. Lets clean it up in the
2355                  * next attempt by sending another IRQ_MOVE_CLEANUP_VECTOR
2356                  * to myself.
2357                  */
2358                 if (irr  & (1 << (vector % 32))) {
2359                         apic->send_IPI_self(IRQ_MOVE_CLEANUP_VECTOR);
2360                         goto unlock;
2361                 }
2362                 __this_cpu_write(vector_irq[vector], -1);
2363 unlock:
2364                 raw_spin_unlock(&desc->lock);
2365         }
2366
2367         irq_exit();
2368 }
2369
2370 static void __irq_complete_move(struct irq_cfg *cfg, unsigned vector)
2371 {
2372         unsigned me;
2373
2374         if (likely(!cfg->move_in_progress))
2375                 return;
2376
2377         me = smp_processor_id();
2378
2379         if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain))
2380                 send_cleanup_vector(cfg);
2381 }
2382
2383 static void irq_complete_move(struct irq_cfg *cfg)
2384 {
2385         __irq_complete_move(cfg, ~get_irq_regs()->orig_ax);
2386 }
2387
2388 void irq_force_complete_move(int irq)
2389 {
2390         struct irq_cfg *cfg = irq_get_chip_data(irq);
2391
2392         if (!cfg)
2393                 return;
2394
2395         __irq_complete_move(cfg, cfg->vector);
2396 }
2397 #else
2398 static inline void irq_complete_move(struct irq_cfg *cfg) { }
2399 #endif
2400
2401 static void ack_apic_edge(struct irq_data *data)
2402 {
2403         irq_complete_move(data->chip_data);
2404         irq_move_irq(data);
2405         ack_APIC_irq();
2406 }
2407
2408 atomic_t irq_mis_count;
2409
2410 /*
2411  * IO-APIC versions below 0x20 don't support EOI register.
2412  * For the record, here is the information about various versions:
2413  *     0Xh     82489DX
2414  *     1Xh     I/OAPIC or I/O(x)APIC which are not PCI 2.2 Compliant
2415  *     2Xh     I/O(x)APIC which is PCI 2.2 Compliant
2416  *     30h-FFh Reserved
2417  *
2418  * Some of the Intel ICH Specs (ICH2 to ICH5) documents the io-apic
2419  * version as 0x2. This is an error with documentation and these ICH chips
2420  * use io-apic's of version 0x20.
2421  *
2422  * For IO-APIC's with EOI register, we use that to do an explicit EOI.
2423  * Otherwise, we simulate the EOI message manually by changing the trigger
2424  * mode to edge and then back to level, with RTE being masked during this.
2425 */
2426 static void eoi_ioapic_irq(unsigned int irq, struct irq_cfg *cfg)
2427 {
2428         struct irq_pin_list *entry;
2429         unsigned long flags;
2430
2431         raw_spin_lock_irqsave(&ioapic_lock, flags);
2432         for_each_irq_pin(entry, cfg->irq_2_pin) {
2433                 if (mpc_ioapic_ver(entry->apic) >= 0x20) {
2434                         /*
2435                          * Intr-remapping uses pin number as the virtual vector
2436                          * in the RTE. Actual vector is programmed in
2437                          * intr-remapping table entry. Hence for the io-apic
2438                          * EOI we use the pin number.
2439                          */
2440                         if (irq_remapped(cfg))
2441                                 io_apic_eoi(entry->apic, entry->pin);
2442                         else
2443                                 io_apic_eoi(entry->apic, cfg->vector);
2444                 } else {
2445                         __mask_and_edge_IO_APIC_irq(entry);
2446                         __unmask_and_level_IO_APIC_irq(entry);
2447                 }
2448         }
2449         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2450 }
2451
2452 static void ack_apic_level(struct irq_data *data)
2453 {
2454         struct irq_cfg *cfg = data->chip_data;
2455         int i, do_unmask_irq = 0, irq = data->irq;
2456         unsigned long v;
2457
2458         irq_complete_move(cfg);
2459 #ifdef CONFIG_GENERIC_PENDING_IRQ
2460         /* If we are moving the irq we need to mask it */
2461         if (unlikely(irqd_is_setaffinity_pending(data))) {
2462                 do_unmask_irq = 1;
2463                 mask_ioapic(cfg);
2464         }
2465 #endif
2466
2467         /*
2468          * It appears there is an erratum which affects at least version 0x11
2469          * of I/O APIC (that's the 82093AA and cores integrated into various
2470          * chipsets).  Under certain conditions a level-triggered interrupt is
2471          * erroneously delivered as edge-triggered one but the respective IRR
2472          * bit gets set nevertheless.  As a result the I/O unit expects an EOI
2473          * message but it will never arrive and further interrupts are blocked
2474          * from the source.  The exact reason is so far unknown, but the
2475          * phenomenon was observed when two consecutive interrupt requests
2476          * from a given source get delivered to the same CPU and the source is
2477          * temporarily disabled in between.
2478          *
2479          * A workaround is to simulate an EOI message manually.  We achieve it
2480          * by setting the trigger mode to edge and then to level when the edge
2481          * trigger mode gets detected in the TMR of a local APIC for a
2482          * level-triggered interrupt.  We mask the source for the time of the
2483          * operation to prevent an edge-triggered interrupt escaping meanwhile.
2484          * The idea is from Manfred Spraul.  --macro
2485          *
2486          * Also in the case when cpu goes offline, fixup_irqs() will forward
2487          * any unhandled interrupt on the offlined cpu to the new cpu
2488          * destination that is handling the corresponding interrupt. This
2489          * interrupt forwarding is done via IPI's. Hence, in this case also
2490          * level-triggered io-apic interrupt will be seen as an edge
2491          * interrupt in the IRR. And we can't rely on the cpu's EOI
2492          * to be broadcasted to the IO-APIC's which will clear the remoteIRR
2493          * corresponding to the level-triggered interrupt. Hence on IO-APIC's
2494          * supporting EOI register, we do an explicit EOI to clear the
2495          * remote IRR and on IO-APIC's which don't have an EOI register,
2496          * we use the above logic (mask+edge followed by unmask+level) from
2497          * Manfred Spraul to clear the remote IRR.
2498          */
2499         i = cfg->vector;
2500         v = apic_read(APIC_TMR + ((i & ~0x1f) >> 1));
2501
2502         /*
2503          * We must acknowledge the irq before we move it or the acknowledge will
2504          * not propagate properly.
2505          */
2506         ack_APIC_irq();
2507
2508         /*
2509          * Tail end of clearing remote IRR bit (either by delivering the EOI
2510          * message via io-apic EOI register write or simulating it using
2511          * mask+edge followed by unnask+level logic) manually when the
2512          * level triggered interrupt is seen as the edge triggered interrupt
2513          * at the cpu.
2514          */
2515         if (!(v & (1 << (i & 0x1f)))) {
2516                 atomic_inc(&irq_mis_count);
2517
2518                 eoi_ioapic_irq(irq, cfg);
2519         }
2520
2521         /* Now we can move and renable the irq */
2522         if (unlikely(do_unmask_irq)) {
2523                 /* Only migrate the irq if the ack has been received.
2524                  *
2525                  * On rare occasions the broadcast level triggered ack gets
2526                  * delayed going to ioapics, and if we reprogram the
2527                  * vector while Remote IRR is still set the irq will never
2528                  * fire again.
2529                  *
2530                  * To prevent this scenario we read the Remote IRR bit
2531                  * of the ioapic.  This has two effects.
2532                  * - On any sane system the read of the ioapic will
2533                  *   flush writes (and acks) going to the ioapic from
2534                  *   this cpu.
2535                  * - We get to see if the ACK has actually been delivered.
2536                  *
2537                  * Based on failed experiments of reprogramming the
2538                  * ioapic entry from outside of irq context starting
2539                  * with masking the ioapic entry and then polling until
2540                  * Remote IRR was clear before reprogramming the
2541                  * ioapic I don't trust the Remote IRR bit to be
2542                  * completey accurate.
2543                  *
2544                  * However there appears to be no other way to plug
2545                  * this race, so if the Remote IRR bit is not
2546                  * accurate and is causing problems then it is a hardware bug
2547                  * and you can go talk to the chipset vendor about it.
2548                  */
2549                 if (!io_apic_level_ack_pending(cfg))
2550                         irq_move_masked_irq(data);
2551                 unmask_ioapic(cfg);
2552         }
2553 }
2554
2555 #ifdef CONFIG_INTR_REMAP
2556 static void ir_ack_apic_edge(struct irq_data *data)
2557 {
2558         ack_APIC_irq();
2559 }
2560
2561 static void ir_ack_apic_level(struct irq_data *data)
2562 {
2563         ack_APIC_irq();
2564         eoi_ioapic_irq(data->irq, data->chip_data);
2565 }
2566 #endif /* CONFIG_INTR_REMAP */
2567
2568 static struct irq_chip ioapic_chip __read_mostly = {
2569         .name                   = "IO-APIC",
2570         .irq_startup            = startup_ioapic_irq,
2571         .irq_mask               = mask_ioapic_irq,
2572         .irq_unmask             = unmask_ioapic_irq,
2573         .irq_ack                = ack_apic_edge,
2574         .irq_eoi                = ack_apic_level,
2575 #ifdef CONFIG_SMP
2576         .irq_set_affinity       = ioapic_set_affinity,
2577 #endif
2578         .irq_retrigger          = ioapic_retrigger_irq,
2579 };
2580
2581 static struct irq_chip ir_ioapic_chip __read_mostly = {
2582         .name                   = "IR-IO-APIC",
2583         .irq_startup            = startup_ioapic_irq,
2584         .irq_mask               = mask_ioapic_irq,
2585         .irq_unmask             = unmask_ioapic_irq,
2586 #ifdef CONFIG_INTR_REMAP
2587         .irq_ack                = ir_ack_apic_edge,
2588         .irq_eoi                = ir_ack_apic_level,
2589 #ifdef CONFIG_SMP
2590         .irq_set_affinity       = ir_ioapic_set_affinity,
2591 #endif
2592 #endif
2593         .irq_retrigger          = ioapic_retrigger_irq,
2594 };
2595
2596 static inline void init_IO_APIC_traps(void)
2597 {
2598         struct irq_cfg *cfg;
2599         unsigned int irq;
2600
2601         /*
2602          * NOTE! The local APIC isn't very good at handling
2603          * multiple interrupts at the same interrupt level.
2604          * As the interrupt level is determined by taking the
2605          * vector number and shifting that right by 4, we
2606          * want to spread these out a bit so that they don't
2607          * all fall in the same interrupt level.
2608          *
2609          * Also, we've got to be careful not to trash gate
2610          * 0x80, because int 0x80 is hm, kind of importantish. ;)
2611          */
2612         for_each_active_irq(irq) {
2613                 cfg = irq_get_chip_data(irq);
2614                 if (IO_APIC_IRQ(irq) && cfg && !cfg->vector) {
2615                         /*
2616                          * Hmm.. We don't have an entry for this,
2617                          * so default to an old-fashioned 8259
2618                          * interrupt if we can..
2619                          */
2620                         if (irq < legacy_pic->nr_legacy_irqs)
2621                                 legacy_pic->make_irq(irq);
2622                         else
2623                                 /* Strange. Oh, well.. */
2624                                 irq_set_chip(irq, &no_irq_chip);
2625                 }
2626         }
2627 }
2628
2629 /*
2630  * The local APIC irq-chip implementation:
2631  */
2632
2633 static void mask_lapic_irq(struct irq_data *data)
2634 {
2635         unsigned long v;
2636
2637         v = apic_read(APIC_LVT0);
2638         apic_write(APIC_LVT0, v | APIC_LVT_MASKED);
2639 }
2640
2641 static void unmask_lapic_irq(struct irq_data *data)
2642 {
2643         unsigned long v;
2644
2645         v = apic_read(APIC_LVT0);
2646         apic_write(APIC_LVT0, v & ~APIC_LVT_MASKED);
2647 }
2648
2649 static void ack_lapic_irq(struct irq_data *data)
2650 {
2651         ack_APIC_irq();
2652 }
2653
2654 static struct irq_chip lapic_chip __read_mostly = {
2655         .name           = "local-APIC",
2656         .irq_mask       = mask_lapic_irq,
2657         .irq_unmask     = unmask_lapic_irq,
2658         .irq_ack        = ack_lapic_irq,
2659 };
2660
2661 static void lapic_register_intr(int irq)
2662 {
2663         irq_clear_status_flags(irq, IRQ_LEVEL);
2664         irq_set_chip_and_handler_name(irq, &lapic_chip, handle_edge_irq,
2665                                       "edge");
2666 }
2667
2668 /*
2669  * This looks a bit hackish but it's about the only one way of sending
2670  * a few INTA cycles to 8259As and any associated glue logic.  ICR does
2671  * not support the ExtINT mode, unfortunately.  We need to send these
2672  * cycles as some i82489DX-based boards have glue logic that keeps the
2673  * 8259A interrupt line asserted until INTA.  --macro
2674  */
2675 static inline void __init unlock_ExtINT_logic(void)
2676 {
2677         int apic, pin, i;
2678         struct IO_APIC_route_entry entry0, entry1;
2679         unsigned char save_control, save_freq_select;
2680
2681         pin  = find_isa_irq_pin(8, mp_INT);
2682         if (pin == -1) {
2683                 WARN_ON_ONCE(1);
2684                 return;
2685         }
2686         apic = find_isa_irq_apic(8, mp_INT);
2687         if (apic == -1) {
2688                 WARN_ON_ONCE(1);
2689                 return;
2690         }
2691
2692         entry0 = ioapic_read_entry(apic, pin);
2693         clear_IO_APIC_pin(apic, pin);
2694
2695         memset(&entry1, 0, sizeof(entry1));
2696
2697         entry1.dest_mode = 0;                   /* physical delivery */
2698         entry1.mask = 0;                        /* unmask IRQ now */
2699         entry1.dest = hard_smp_processor_id();
2700         entry1.delivery_mode = dest_ExtINT;
2701         entry1.polarity = entry0.polarity;
2702         entry1.trigger = 0;
2703         entry1.vector = 0;
2704
2705         ioapic_write_entry(apic, pin, entry1);
2706
2707         save_control = CMOS_READ(RTC_CONTROL);
2708         save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
2709         CMOS_WRITE((save_freq_select & ~RTC_RATE_SELECT) | 0x6,
2710                    RTC_FREQ_SELECT);
2711         CMOS_WRITE(save_control | RTC_PIE, RTC_CONTROL);
2712
2713         i = 100;
2714         while (i-- > 0) {
2715                 mdelay(10);
2716                 if ((CMOS_READ(RTC_INTR_FLAGS) & RTC_PF) == RTC_PF)
2717                         i -= 10;
2718         }
2719
2720         CMOS_WRITE(save_control, RTC_CONTROL);
2721         CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
2722         clear_IO_APIC_pin(apic, pin);
2723
2724         ioapic_write_entry(apic, pin, entry0);
2725 }
2726
2727 static int disable_timer_pin_1 __initdata;
2728 /* Actually the next is obsolete, but keep it for paranoid reasons -AK */
2729 static int __init disable_timer_pin_setup(char *arg)
2730 {
2731         disable_timer_pin_1 = 1;
2732         return 0;
2733 }
2734 early_param("disable_timer_pin_1", disable_timer_pin_setup);
2735
2736 int timer_through_8259 __initdata;
2737
2738 /*
2739  * This code may look a bit paranoid, but it's supposed to cooperate with
2740  * a wide range of boards and BIOS bugs.  Fortunately only the timer IRQ
2741  * is so screwy.  Thanks to Brian Perkins for testing/hacking this beast
2742  * fanatically on his truly buggy board.
2743  *
2744  * FIXME: really need to revamp this for all platforms.
2745  */
2746 static inline void __init check_timer(void)
2747 {
2748         struct irq_cfg *cfg = irq_get_chip_data(0);
2749         int node = cpu_to_node(0);
2750         int apic1, pin1, apic2, pin2;
2751         unsigned long flags;
2752         int no_pin1 = 0;
2753
2754         local_irq_save(flags);
2755
2756         /*
2757          * get/set the timer IRQ vector:
2758          */
2759         legacy_pic->mask(0);
2760         assign_irq_vector(0, cfg, apic->target_cpus());
2761
2762         /*
2763          * As IRQ0 is to be enabled in the 8259A, the virtual
2764          * wire has to be disabled in the local APIC.  Also
2765          * timer interrupts need to be acknowledged manually in
2766          * the 8259A for the i82489DX when using the NMI
2767          * watchdog as that APIC treats NMIs as level-triggered.
2768          * The AEOI mode will finish them in the 8259A
2769          * automatically.
2770          */
2771         apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_EXTINT);
2772         legacy_pic->init(1);
2773
2774         pin1  = find_isa_irq_pin(0, mp_INT);
2775         apic1 = find_isa_irq_apic(0, mp_INT);
2776         pin2  = ioapic_i8259.pin;
2777         apic2 = ioapic_i8259.apic;
2778
2779         apic_printk(APIC_QUIET, KERN_INFO "..TIMER: vector=0x%02X "
2780                     "apic1=%d pin1=%d apic2=%d pin2=%d\n",
2781                     cfg->vector, apic1, pin1, apic2, pin2);
2782
2783         /*
2784          * Some BIOS writers are clueless and report the ExtINTA
2785          * I/O APIC input from the cascaded 8259A as the timer
2786          * interrupt input.  So just in case, if only one pin
2787          * was found above, try it both directly and through the
2788          * 8259A.
2789          */
2790         if (pin1 == -1) {
2791                 if (intr_remapping_enabled)
2792                         panic("BIOS bug: timer not connected to IO-APIC");
2793                 pin1 = pin2;
2794                 apic1 = apic2;
2795                 no_pin1 = 1;
2796         } else if (pin2 == -1) {
2797                 pin2 = pin1;
2798                 apic2 = apic1;
2799         }
2800
2801         if (pin1 != -1) {
2802                 /*
2803                  * Ok, does IRQ0 through the IOAPIC work?
2804                  */
2805                 if (no_pin1) {
2806                         add_pin_to_irq_node(cfg, node, apic1, pin1);
2807                         setup_timer_IRQ0_pin(apic1, pin1, cfg->vector);
2808                 } else {
2809                         /* for edge trigger, setup_ioapic_irq already
2810                          * leave it unmasked.
2811                          * so only need to unmask if it is level-trigger
2812                          * do we really have level trigger timer?
2813                          */
2814                         int idx;
2815                         idx = find_irq_entry(apic1, pin1, mp_INT);
2816                         if (idx != -1 && irq_trigger(idx))
2817                                 unmask_ioapic(cfg);
2818                 }
2819                 if (timer_irq_works()) {
2820                         if (disable_timer_pin_1 > 0)
2821                                 clear_IO_APIC_pin(0, pin1);
2822                         goto out;
2823                 }
2824                 if (intr_remapping_enabled)
2825                         panic("timer doesn't work through Interrupt-remapped IO-APIC");
2826                 local_irq_disable();
2827                 clear_IO_APIC_pin(apic1, pin1);
2828                 if (!no_pin1)
2829                         apic_printk(APIC_QUIET, KERN_ERR "..MP-BIOS bug: "
2830                                     "8254 timer not connected to IO-APIC\n");
2831
2832                 apic_printk(APIC_QUIET, KERN_INFO "...trying to set up timer "
2833                             "(IRQ0) through the 8259A ...\n");
2834                 apic_printk(APIC_QUIET, KERN_INFO
2835                             "..... (found apic %d pin %d) ...\n", apic2, pin2);
2836                 /*
2837                  * legacy devices should be connected to IO APIC #0
2838                  */
2839                 replace_pin_at_irq_node(cfg, node, apic1, pin1, apic2, pin2);
2840                 setup_timer_IRQ0_pin(apic2, pin2, cfg->vector);
2841                 legacy_pic->unmask(0);
2842                 if (timer_irq_works()) {
2843                         apic_printk(APIC_QUIET, KERN_INFO "....... works.\n");
2844                         timer_through_8259 = 1;
2845                         goto out;
2846                 }
2847                 /*
2848                  * Cleanup, just in case ...
2849                  */
2850                 local_irq_disable();
2851                 legacy_pic->mask(0);
2852                 clear_IO_APIC_pin(apic2, pin2);
2853                 apic_printk(APIC_QUIET, KERN_INFO "....... failed.\n");
2854         }
2855
2856         apic_printk(APIC_QUIET, KERN_INFO
2857                     "...trying to set up timer as Virtual Wire IRQ...\n");
2858
2859         lapic_register_intr(0);
2860         apic_write(APIC_LVT0, APIC_DM_FIXED | cfg->vector);     /* Fixed mode */
2861         legacy_pic->unmask(0);
2862
2863         if (timer_irq_works()) {
2864                 apic_printk(APIC_QUIET, KERN_INFO "..... works.\n");
2865                 goto out;
2866         }
2867         local_irq_disable();
2868         legacy_pic->mask(0);
2869         apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_FIXED | cfg->vector);
2870         apic_printk(APIC_QUIET, KERN_INFO "..... failed.\n");
2871
2872         apic_printk(APIC_QUIET, KERN_INFO
2873                     "...trying to set up timer as ExtINT IRQ...\n");
2874
2875         legacy_pic->init(0);
2876         legacy_pic->make_irq(0);
2877         apic_write(APIC_LVT0, APIC_DM_EXTINT);
2878
2879         unlock_ExtINT_logic();
2880
2881         if (timer_irq_works()) {
2882                 apic_printk(APIC_QUIET, KERN_INFO "..... works.\n");
2883                 goto out;
2884         }
2885         local_irq_disable();
2886         apic_printk(APIC_QUIET, KERN_INFO "..... failed :(.\n");
2887         panic("IO-APIC + timer doesn't work!  Boot with apic=debug and send a "
2888                 "report.  Then try booting with the 'noapic' option.\n");
2889 out:
2890         local_irq_restore(flags);
2891 }
2892
2893 /*
2894  * Traditionally ISA IRQ2 is the cascade IRQ, and is not available
2895  * to devices.  However there may be an I/O APIC pin available for
2896  * this interrupt regardless.  The pin may be left unconnected, but
2897  * typically it will be reused as an ExtINT cascade interrupt for
2898  * the master 8259A.  In the MPS case such a pin will normally be
2899  * reported as an ExtINT interrupt in the MP table.  With ACPI
2900  * there is no provision for ExtINT interrupts, and in the absence
2901  * of an override it would be treated as an ordinary ISA I/O APIC
2902  * interrupt, that is edge-triggered and unmasked by default.  We
2903  * used to do this, but it caused problems on some systems because
2904  * of the NMI watchdog and sometimes IRQ0 of the 8254 timer using
2905  * the same ExtINT cascade interrupt to drive the local APIC of the
2906  * bootstrap processor.  Therefore we refrain from routing IRQ2 to
2907  * the I/O APIC in all cases now.  No actual device should request
2908  * it anyway.  --macro
2909  */
2910 #define PIC_IRQS        (1UL << PIC_CASCADE_IR)
2911
2912 void __init setup_IO_APIC(void)
2913 {
2914
2915         /*
2916          * calling enable_IO_APIC() is moved to setup_local_APIC for BP
2917          */
2918         io_apic_irqs = legacy_pic->nr_legacy_irqs ? ~PIC_IRQS : ~0UL;
2919
2920         apic_printk(APIC_VERBOSE, "ENABLING IO-APIC IRQs\n");
2921         /*
2922          * Set up IO-APIC IRQ routing.
2923          */
2924         x86_init.mpparse.setup_ioapic_ids();
2925
2926         sync_Arb_IDs();
2927         setup_IO_APIC_irqs();
2928         init_IO_APIC_traps();
2929         if (legacy_pic->nr_legacy_irqs)
2930                 check_timer();
2931 }
2932
2933 /*
2934  *      Called after all the initialization is done. If we didn't find any
2935  *      APIC bugs then we can allow the modify fast path
2936  */
2937
2938 static int __init io_apic_bug_finalize(void)
2939 {
2940         if (sis_apic_bug == -1)
2941                 sis_apic_bug = 0;
2942         return 0;
2943 }
2944
2945 late_initcall(io_apic_bug_finalize);
2946
2947 static void resume_ioapic_id(int ioapic_id)
2948 {
2949         unsigned long flags;
2950         union IO_APIC_reg_00 reg_00;
2951
2952
2953         raw_spin_lock_irqsave(&ioapic_lock, flags);
2954         reg_00.raw = io_apic_read(ioapic_id, 0);
2955         if (reg_00.bits.ID != mpc_ioapic_id(ioapic_id)) {
2956                 reg_00.bits.ID = mpc_ioapic_id(ioapic_id);
2957                 io_apic_write(ioapic_id, 0, reg_00.raw);
2958         }
2959         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2960 }
2961
2962 static void ioapic_resume(void)
2963 {
2964         int ioapic_id;
2965
2966         for (ioapic_id = nr_ioapics - 1; ioapic_id >= 0; ioapic_id--)
2967                 resume_ioapic_id(ioapic_id);
2968
2969         restore_ioapic_entries();
2970 }
2971
2972 static struct syscore_ops ioapic_syscore_ops = {
2973         .suspend = save_ioapic_entries,
2974         .resume = ioapic_resume,
2975 };
2976
2977 static int __init ioapic_init_ops(void)
2978 {
2979         register_syscore_ops(&ioapic_syscore_ops);
2980
2981         return 0;
2982 }
2983
2984 device_initcall(ioapic_init_ops);
2985
2986 /*
2987  * Dynamic irq allocate and deallocation
2988  */
2989 unsigned int create_irq_nr(unsigned int from, int node)
2990 {
2991         struct irq_cfg *cfg;
2992         unsigned long flags;
2993         unsigned int ret = 0;
2994         int irq;
2995
2996         if (from < nr_irqs_gsi)
2997                 from = nr_irqs_gsi;
2998
2999         irq = alloc_irq_from(from, node);
3000         if (irq < 0)
3001                 return 0;
3002         cfg = alloc_irq_cfg(irq, node);
3003         if (!cfg) {
3004                 free_irq_at(irq, NULL);
3005                 return 0;
3006         }
3007
3008         raw_spin_lock_irqsave(&vector_lock, flags);
3009         if (!__assign_irq_vector(irq, cfg, apic->target_cpus()))
3010                 ret = irq;
3011         raw_spin_unlock_irqrestore(&vector_lock, flags);
3012
3013         if (ret) {
3014                 irq_set_chip_data(irq, cfg);
3015                 irq_clear_status_flags(irq, IRQ_NOREQUEST);
3016         } else {
3017                 free_irq_at(irq, cfg);
3018         }
3019         return ret;
3020 }
3021
3022 int create_irq(void)
3023 {
3024         int node = cpu_to_node(0);
3025         unsigned int irq_want;
3026         int irq;
3027
3028         irq_want = nr_irqs_gsi;
3029         irq = create_irq_nr(irq_want, node);
3030
3031         if (irq == 0)
3032                 irq = -1;
3033
3034         return irq;
3035 }
3036
3037 void destroy_irq(unsigned int irq)
3038 {
3039         struct irq_cfg *cfg = irq_get_chip_data(irq);
3040         unsigned long flags;
3041
3042         irq_set_status_flags(irq, IRQ_NOREQUEST|IRQ_NOPROBE);
3043
3044         if (irq_remapped(cfg))
3045                 free_irte(irq);
3046         raw_spin_lock_irqsave(&vector_lock, flags);
3047         __clear_irq_vector(irq, cfg);
3048         raw_spin_unlock_irqrestore(&vector_lock, flags);
3049         free_irq_at(irq, cfg);
3050 }
3051
3052 /*
3053  * MSI message composition
3054  */
3055 #ifdef CONFIG_PCI_MSI
3056 static int msi_compose_msg(struct pci_dev *pdev, unsigned int irq,
3057                            struct msi_msg *msg, u8 hpet_id)
3058 {
3059         struct irq_cfg *cfg;
3060         int err;
3061         unsigned dest;
3062
3063         if (disable_apic)
3064                 return -ENXIO;
3065
3066         cfg = irq_cfg(irq);
3067         err = assign_irq_vector(irq, cfg, apic->target_cpus());
3068         if (err)
3069                 return err;
3070
3071         dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus());
3072
3073         if (irq_remapped(cfg)) {
3074                 struct irte irte;
3075                 int ir_index;
3076                 u16 sub_handle;
3077
3078                 ir_index = map_irq_to_irte_handle(irq, &sub_handle);
3079                 BUG_ON(ir_index == -1);
3080
3081                 prepare_irte(&irte, cfg->vector, dest);
3082
3083                 /* Set source-id of interrupt request */
3084                 if (pdev)
3085                         set_msi_sid(&irte, pdev);
3086                 else
3087                         set_hpet_sid(&irte, hpet_id);
3088
3089                 modify_irte(irq, &irte);
3090
3091                 msg->address_hi = MSI_ADDR_BASE_HI;
3092                 msg->data = sub_handle;
3093                 msg->address_lo = MSI_ADDR_BASE_LO | MSI_ADDR_IR_EXT_INT |
3094                                   MSI_ADDR_IR_SHV |
3095                                   MSI_ADDR_IR_INDEX1(ir_index) |
3096                                   MSI_ADDR_IR_INDEX2(ir_index);
3097         } else {
3098                 if (x2apic_enabled())
3099                         msg->address_hi = MSI_ADDR_BASE_HI |
3100                                           MSI_ADDR_EXT_DEST_ID(dest);
3101                 else
3102                         msg->address_hi = MSI_ADDR_BASE_HI;
3103
3104                 msg->address_lo =
3105                         MSI_ADDR_BASE_LO |
3106                         ((apic->irq_dest_mode == 0) ?
3107                                 MSI_ADDR_DEST_MODE_PHYSICAL:
3108                                 MSI_ADDR_DEST_MODE_LOGICAL) |
3109                         ((apic->irq_delivery_mode != dest_LowestPrio) ?
3110                                 MSI_ADDR_REDIRECTION_CPU:
3111                                 MSI_ADDR_REDIRECTION_LOWPRI) |
3112                         MSI_ADDR_DEST_ID(dest);
3113
3114                 msg->data =
3115                         MSI_DATA_TRIGGER_EDGE |
3116                         MSI_DATA_LEVEL_ASSERT |
3117                         ((apic->irq_delivery_mode != dest_LowestPrio) ?
3118                                 MSI_DATA_DELIVERY_FIXED:
3119                                 MSI_DATA_DELIVERY_LOWPRI) |
3120                         MSI_DATA_VECTOR(cfg->vector);
3121         }
3122         return err;
3123 }
3124
3125 #ifdef CONFIG_SMP
3126 static int
3127 msi_set_affinity(struct irq_data *data, const struct cpumask *mask, bool force)
3128 {
3129         struct irq_cfg *cfg = data->chip_data;