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         printk(KERN_DEBUG " NR Dst Mask Trig IRR Pol"
1566                           " Stat Dmod Deli Vect:\n");
1567
1568         for (i = 0; i <= reg_01.bits.entries; i++) {
1569                 struct IO_APIC_route_entry entry;
1570
1571                 entry = ioapic_read_entry(apic, i);
1572
1573                 printk(KERN_DEBUG " %02x %02X  ",
1574                         i,
1575                         entry.dest
1576                 );
1577
1578                 printk("%1d    %1d    %1d   %1d   %1d    %1d    %1d    %02X\n",
1579                         entry.mask,
1580                         entry.trigger,
1581                         entry.irr,
1582                         entry.polarity,
1583                         entry.delivery_status,
1584                         entry.dest_mode,
1585                         entry.delivery_mode,
1586                         entry.vector
1587                 );
1588         }
1589         }
1590         printk(KERN_DEBUG "IRQ to pin mappings:\n");
1591         for_each_active_irq(irq) {
1592                 struct irq_pin_list *entry;
1593
1594                 cfg = irq_get_chip_data(irq);
1595                 if (!cfg)
1596                         continue;
1597                 entry = cfg->irq_2_pin;
1598                 if (!entry)
1599                         continue;
1600                 printk(KERN_DEBUG "IRQ%d ", irq);
1601                 for_each_irq_pin(entry, cfg->irq_2_pin)
1602                         printk("-> %d:%d", entry->apic, entry->pin);
1603                 printk("\n");
1604         }
1605
1606         printk(KERN_INFO ".................................... done.\n");
1607
1608         return;
1609 }
1610
1611 __apicdebuginit(void) print_APIC_field(int base)
1612 {
1613         int i;
1614
1615         printk(KERN_DEBUG);
1616
1617         for (i = 0; i < 8; i++)
1618                 printk(KERN_CONT "%08x", apic_read(base + i*0x10));
1619
1620         printk(KERN_CONT "\n");
1621 }
1622
1623 __apicdebuginit(void) print_local_APIC(void *dummy)
1624 {
1625         unsigned int i, v, ver, maxlvt;
1626         u64 icr;
1627
1628         printk(KERN_DEBUG "printing local APIC contents on CPU#%d/%d:\n",
1629                 smp_processor_id(), hard_smp_processor_id());
1630         v = apic_read(APIC_ID);
1631         printk(KERN_INFO "... APIC ID:      %08x (%01x)\n", v, read_apic_id());
1632         v = apic_read(APIC_LVR);
1633         printk(KERN_INFO "... APIC VERSION: %08x\n", v);
1634         ver = GET_APIC_VERSION(v);
1635         maxlvt = lapic_get_maxlvt();
1636
1637         v = apic_read(APIC_TASKPRI);
1638         printk(KERN_DEBUG "... APIC TASKPRI: %08x (%02x)\n", v, v & APIC_TPRI_MASK);
1639
1640         if (APIC_INTEGRATED(ver)) {                     /* !82489DX */
1641                 if (!APIC_XAPIC(ver)) {
1642                         v = apic_read(APIC_ARBPRI);
1643                         printk(KERN_DEBUG "... APIC ARBPRI: %08x (%02x)\n", v,
1644                                v & APIC_ARBPRI_MASK);
1645                 }
1646                 v = apic_read(APIC_PROCPRI);
1647                 printk(KERN_DEBUG "... APIC PROCPRI: %08x\n", v);
1648         }
1649
1650         /*
1651          * Remote read supported only in the 82489DX and local APIC for
1652          * Pentium processors.
1653          */
1654         if (!APIC_INTEGRATED(ver) || maxlvt == 3) {
1655                 v = apic_read(APIC_RRR);
1656                 printk(KERN_DEBUG "... APIC RRR: %08x\n", v);
1657         }
1658
1659         v = apic_read(APIC_LDR);
1660         printk(KERN_DEBUG "... APIC LDR: %08x\n", v);
1661         if (!x2apic_enabled()) {
1662                 v = apic_read(APIC_DFR);
1663                 printk(KERN_DEBUG "... APIC DFR: %08x\n", v);
1664         }
1665         v = apic_read(APIC_SPIV);
1666         printk(KERN_DEBUG "... APIC SPIV: %08x\n", v);
1667
1668         printk(KERN_DEBUG "... APIC ISR field:\n");
1669         print_APIC_field(APIC_ISR);
1670         printk(KERN_DEBUG "... APIC TMR field:\n");
1671         print_APIC_field(APIC_TMR);
1672         printk(KERN_DEBUG "... APIC IRR field:\n");
1673         print_APIC_field(APIC_IRR);
1674
1675         if (APIC_INTEGRATED(ver)) {             /* !82489DX */
1676                 if (maxlvt > 3)         /* Due to the Pentium erratum 3AP. */
1677                         apic_write(APIC_ESR, 0);
1678
1679                 v = apic_read(APIC_ESR);
1680                 printk(KERN_DEBUG "... APIC ESR: %08x\n", v);
1681         }
1682
1683         icr = apic_icr_read();
1684         printk(KERN_DEBUG "... APIC ICR: %08x\n", (u32)icr);
1685         printk(KERN_DEBUG "... APIC ICR2: %08x\n", (u32)(icr >> 32));
1686
1687         v = apic_read(APIC_LVTT);
1688         printk(KERN_DEBUG "... APIC LVTT: %08x\n", v);
1689
1690         if (maxlvt > 3) {                       /* PC is LVT#4. */
1691                 v = apic_read(APIC_LVTPC);
1692                 printk(KERN_DEBUG "... APIC LVTPC: %08x\n", v);
1693         }
1694         v = apic_read(APIC_LVT0);
1695         printk(KERN_DEBUG "... APIC LVT0: %08x\n", v);
1696         v = apic_read(APIC_LVT1);
1697         printk(KERN_DEBUG "... APIC LVT1: %08x\n", v);
1698
1699         if (maxlvt > 2) {                       /* ERR is LVT#3. */
1700                 v = apic_read(APIC_LVTERR);
1701                 printk(KERN_DEBUG "... APIC LVTERR: %08x\n", v);
1702         }
1703
1704         v = apic_read(APIC_TMICT);
1705         printk(KERN_DEBUG "... APIC TMICT: %08x\n", v);
1706         v = apic_read(APIC_TMCCT);
1707         printk(KERN_DEBUG "... APIC TMCCT: %08x\n", v);
1708         v = apic_read(APIC_TDCR);
1709         printk(KERN_DEBUG "... APIC TDCR: %08x\n", v);
1710
1711         if (boot_cpu_has(X86_FEATURE_EXTAPIC)) {
1712                 v = apic_read(APIC_EFEAT);
1713                 maxlvt = (v >> 16) & 0xff;
1714                 printk(KERN_DEBUG "... APIC EFEAT: %08x\n", v);
1715                 v = apic_read(APIC_ECTRL);
1716                 printk(KERN_DEBUG "... APIC ECTRL: %08x\n", v);
1717                 for (i = 0; i < maxlvt; i++) {
1718                         v = apic_read(APIC_EILVTn(i));
1719                         printk(KERN_DEBUG "... APIC EILVT%d: %08x\n", i, v);
1720                 }
1721         }
1722         printk("\n");
1723 }
1724
1725 __apicdebuginit(void) print_local_APICs(int maxcpu)
1726 {
1727         int cpu;
1728
1729         if (!maxcpu)
1730                 return;
1731
1732         preempt_disable();
1733         for_each_online_cpu(cpu) {
1734                 if (cpu >= maxcpu)
1735                         break;
1736                 smp_call_function_single(cpu, print_local_APIC, NULL, 1);
1737         }
1738         preempt_enable();
1739 }
1740
1741 __apicdebuginit(void) print_PIC(void)
1742 {
1743         unsigned int v;
1744         unsigned long flags;
1745
1746         if (!legacy_pic->nr_legacy_irqs)
1747                 return;
1748
1749         printk(KERN_DEBUG "\nprinting PIC contents\n");
1750
1751         raw_spin_lock_irqsave(&i8259A_lock, flags);
1752
1753         v = inb(0xa1) << 8 | inb(0x21);
1754         printk(KERN_DEBUG "... PIC  IMR: %04x\n", v);
1755
1756         v = inb(0xa0) << 8 | inb(0x20);
1757         printk(KERN_DEBUG "... PIC  IRR: %04x\n", v);
1758
1759         outb(0x0b,0xa0);
1760         outb(0x0b,0x20);
1761         v = inb(0xa0) << 8 | inb(0x20);
1762         outb(0x0a,0xa0);
1763         outb(0x0a,0x20);
1764
1765         raw_spin_unlock_irqrestore(&i8259A_lock, flags);
1766
1767         printk(KERN_DEBUG "... PIC  ISR: %04x\n", v);
1768
1769         v = inb(0x4d1) << 8 | inb(0x4d0);
1770         printk(KERN_DEBUG "... PIC ELCR: %04x\n", v);
1771 }
1772
1773 static int __initdata show_lapic = 1;
1774 static __init int setup_show_lapic(char *arg)
1775 {
1776         int num = -1;
1777
1778         if (strcmp(arg, "all") == 0) {
1779                 show_lapic = CONFIG_NR_CPUS;
1780         } else {
1781                 get_option(&arg, &num);
1782                 if (num >= 0)
1783                         show_lapic = num;
1784         }
1785
1786         return 1;
1787 }
1788 __setup("show_lapic=", setup_show_lapic);
1789
1790 __apicdebuginit(int) print_ICs(void)
1791 {
1792         if (apic_verbosity == APIC_QUIET)
1793                 return 0;
1794
1795         print_PIC();
1796
1797         /* don't print out if apic is not there */
1798         if (!cpu_has_apic && !apic_from_smp_config())
1799                 return 0;
1800
1801         print_local_APICs(show_lapic);
1802         print_IO_APIC();
1803
1804         return 0;
1805 }
1806
1807 late_initcall(print_ICs);
1808
1809
1810 /* Where if anywhere is the i8259 connect in external int mode */
1811 static struct { int pin, apic; } ioapic_i8259 = { -1, -1 };
1812
1813 void __init enable_IO_APIC(void)
1814 {
1815         int i8259_apic, i8259_pin;
1816         int apic;
1817
1818         if (!legacy_pic->nr_legacy_irqs)
1819                 return;
1820
1821         for(apic = 0; apic < nr_ioapics; apic++) {
1822                 int pin;
1823                 /* See if any of the pins is in ExtINT mode */
1824                 for (pin = 0; pin < ioapics[apic].nr_registers; pin++) {
1825                         struct IO_APIC_route_entry entry;
1826                         entry = ioapic_read_entry(apic, pin);
1827
1828                         /* If the interrupt line is enabled and in ExtInt mode
1829                          * I have found the pin where the i8259 is connected.
1830                          */
1831                         if ((entry.mask == 0) && (entry.delivery_mode == dest_ExtINT)) {
1832                                 ioapic_i8259.apic = apic;
1833                                 ioapic_i8259.pin  = pin;
1834                                 goto found_i8259;
1835                         }
1836                 }
1837         }
1838  found_i8259:
1839         /* Look to see what if the MP table has reported the ExtINT */
1840         /* If we could not find the appropriate pin by looking at the ioapic
1841          * the i8259 probably is not connected the ioapic but give the
1842          * mptable a chance anyway.
1843          */
1844         i8259_pin  = find_isa_irq_pin(0, mp_ExtINT);
1845         i8259_apic = find_isa_irq_apic(0, mp_ExtINT);
1846         /* Trust the MP table if nothing is setup in the hardware */
1847         if ((ioapic_i8259.pin == -1) && (i8259_pin >= 0)) {
1848                 printk(KERN_WARNING "ExtINT not setup in hardware but reported by MP table\n");
1849                 ioapic_i8259.pin  = i8259_pin;
1850                 ioapic_i8259.apic = i8259_apic;
1851         }
1852         /* Complain if the MP table and the hardware disagree */
1853         if (((ioapic_i8259.apic != i8259_apic) || (ioapic_i8259.pin != i8259_pin)) &&
1854                 (i8259_pin >= 0) && (ioapic_i8259.pin >= 0))
1855         {
1856                 printk(KERN_WARNING "ExtINT in hardware and MP table differ\n");
1857         }
1858
1859         /*
1860          * Do not trust the IO-APIC being empty at bootup
1861          */
1862         clear_IO_APIC();
1863 }
1864
1865 /*
1866  * Not an __init, needed by the reboot code
1867  */
1868 void disable_IO_APIC(void)
1869 {
1870         /*
1871          * Clear the IO-APIC before rebooting:
1872          */
1873         clear_IO_APIC();
1874
1875         if (!legacy_pic->nr_legacy_irqs)
1876                 return;
1877
1878         /*
1879          * If the i8259 is routed through an IOAPIC
1880          * Put that IOAPIC in virtual wire mode
1881          * so legacy interrupts can be delivered.
1882          *
1883          * With interrupt-remapping, for now we will use virtual wire A mode,
1884          * as virtual wire B is little complex (need to configure both
1885          * IOAPIC RTE as well as interrupt-remapping table entry).
1886          * As this gets called during crash dump, keep this simple for now.
1887          */
1888         if (ioapic_i8259.pin != -1 && !intr_remapping_enabled) {
1889                 struct IO_APIC_route_entry entry;
1890
1891                 memset(&entry, 0, sizeof(entry));
1892                 entry.mask            = 0; /* Enabled */
1893                 entry.trigger         = 0; /* Edge */
1894                 entry.irr             = 0;
1895                 entry.polarity        = 0; /* High */
1896                 entry.delivery_status = 0;
1897                 entry.dest_mode       = 0; /* Physical */
1898                 entry.delivery_mode   = dest_ExtINT; /* ExtInt */
1899                 entry.vector          = 0;
1900                 entry.dest            = read_apic_id();
1901
1902                 /*
1903                  * Add it to the IO-APIC irq-routing table:
1904                  */
1905                 ioapic_write_entry(ioapic_i8259.apic, ioapic_i8259.pin, entry);
1906         }
1907
1908         /*
1909          * Use virtual wire A mode when interrupt remapping is enabled.
1910          */
1911         if (cpu_has_apic || apic_from_smp_config())
1912                 disconnect_bsp_APIC(!intr_remapping_enabled &&
1913                                 ioapic_i8259.pin != -1);
1914 }
1915
1916 #ifdef CONFIG_X86_32
1917 /*
1918  * function to set the IO-APIC physical IDs based on the
1919  * values stored in the MPC table.
1920  *
1921  * by Matt Domsch <Matt_Domsch@dell.com>  Tue Dec 21 12:25:05 CST 1999
1922  */
1923 void __init setup_ioapic_ids_from_mpc_nocheck(void)
1924 {
1925         union IO_APIC_reg_00 reg_00;
1926         physid_mask_t phys_id_present_map;
1927         int apic_id;
1928         int i;
1929         unsigned char old_id;
1930         unsigned long flags;
1931
1932         /*
1933          * This is broken; anything with a real cpu count has to
1934          * circumvent this idiocy regardless.
1935          */
1936         apic->ioapic_phys_id_map(&phys_cpu_present_map, &phys_id_present_map);
1937
1938         /*
1939          * Set the IOAPIC ID to the value stored in the MPC table.
1940          */
1941         for (apic_id = 0; apic_id < nr_ioapics; apic_id++) {
1942
1943                 /* Read the register 0 value */
1944                 raw_spin_lock_irqsave(&ioapic_lock, flags);
1945                 reg_00.raw = io_apic_read(apic_id, 0);
1946                 raw_spin_unlock_irqrestore(&ioapic_lock, flags);
1947
1948                 old_id = mpc_ioapic_id(apic_id);
1949
1950                 if (mpc_ioapic_id(apic_id) >= get_physical_broadcast()) {
1951                         printk(KERN_ERR "BIOS bug, IO-APIC#%d ID is %d in the MPC table!...\n",
1952                                 apic_id, mpc_ioapic_id(apic_id));
1953                         printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
1954                                 reg_00.bits.ID);
1955                         ioapics[apic_id].mp_config.apicid = reg_00.bits.ID;
1956                 }
1957
1958                 /*
1959                  * Sanity check, is the ID really free? Every APIC in a
1960                  * system must have a unique ID or we get lots of nice
1961                  * 'stuck on smp_invalidate_needed IPI wait' messages.
1962                  */
1963                 if (apic->check_apicid_used(&phys_id_present_map,
1964                                             mpc_ioapic_id(apic_id))) {
1965                         printk(KERN_ERR "BIOS bug, IO-APIC#%d ID %d is already used!...\n",
1966                                 apic_id, mpc_ioapic_id(apic_id));
1967                         for (i = 0; i < get_physical_broadcast(); i++)
1968                                 if (!physid_isset(i, phys_id_present_map))
1969                                         break;
1970                         if (i >= get_physical_broadcast())
1971                                 panic("Max APIC ID exceeded!\n");
1972                         printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
1973                                 i);
1974                         physid_set(i, phys_id_present_map);
1975                         ioapics[apic_id].mp_config.apicid = i;
1976                 } else {
1977                         physid_mask_t tmp;
1978                         apic->apicid_to_cpu_present(mpc_ioapic_id(apic_id),
1979                                                     &tmp);
1980                         apic_printk(APIC_VERBOSE, "Setting %d in the "
1981                                         "phys_id_present_map\n",
1982                                         mpc_ioapic_id(apic_id));
1983                         physids_or(phys_id_present_map, phys_id_present_map, tmp);
1984                 }
1985
1986                 /*
1987                  * We need to adjust the IRQ routing table
1988                  * if the ID changed.
1989                  */
1990                 if (old_id != mpc_ioapic_id(apic_id))
1991                         for (i = 0; i < mp_irq_entries; i++)
1992                                 if (mp_irqs[i].dstapic == old_id)
1993                                         mp_irqs[i].dstapic
1994                                                 = mpc_ioapic_id(apic_id);
1995
1996                 /*
1997                  * Update the ID register according to the right value
1998                  * from the MPC table if they are different.
1999                  */
2000                 if (mpc_ioapic_id(apic_id) == reg_00.bits.ID)
2001                         continue;
2002
2003                 apic_printk(APIC_VERBOSE, KERN_INFO
2004                         "...changing IO-APIC physical APIC ID to %d ...",
2005                         mpc_ioapic_id(apic_id));
2006
2007                 reg_00.bits.ID = mpc_ioapic_id(apic_id);
2008                 raw_spin_lock_irqsave(&ioapic_lock, flags);
2009                 io_apic_write(apic_id, 0, reg_00.raw);
2010                 raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2011
2012                 /*
2013                  * Sanity check
2014                  */
2015                 raw_spin_lock_irqsave(&ioapic_lock, flags);
2016                 reg_00.raw = io_apic_read(apic_id, 0);
2017                 raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2018                 if (reg_00.bits.ID != mpc_ioapic_id(apic_id))
2019                         printk("could not set ID!\n");
2020                 else
2021                         apic_printk(APIC_VERBOSE, " ok.\n");
2022         }
2023 }
2024
2025 void __init setup_ioapic_ids_from_mpc(void)
2026 {
2027
2028         if (acpi_ioapic)
2029                 return;
2030         /*
2031          * Don't check I/O APIC IDs for xAPIC systems.  They have
2032          * no meaning without the serial APIC bus.
2033          */
2034         if (!(boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
2035                 || APIC_XAPIC(apic_version[boot_cpu_physical_apicid]))
2036                 return;
2037         setup_ioapic_ids_from_mpc_nocheck();
2038 }
2039 #endif
2040
2041 int no_timer_check __initdata;
2042
2043 static int __init notimercheck(char *s)
2044 {
2045         no_timer_check = 1;
2046         return 1;
2047 }
2048 __setup("no_timer_check", notimercheck);
2049
2050 /*
2051  * There is a nasty bug in some older SMP boards, their mptable lies
2052  * about the timer IRQ. We do the following to work around the situation:
2053  *
2054  *      - timer IRQ defaults to IO-APIC IRQ
2055  *      - if this function detects that timer IRQs are defunct, then we fall
2056  *        back to ISA timer IRQs
2057  */
2058 static int __init timer_irq_works(void)
2059 {
2060         unsigned long t1 = jiffies;
2061         unsigned long flags;
2062
2063         if (no_timer_check)
2064                 return 1;
2065
2066         local_save_flags(flags);
2067         local_irq_enable();
2068         /* Let ten ticks pass... */
2069         mdelay((10 * 1000) / HZ);
2070         local_irq_restore(flags);
2071
2072         /*
2073          * Expect a few ticks at least, to be sure some possible
2074          * glue logic does not lock up after one or two first
2075          * ticks in a non-ExtINT mode.  Also the local APIC
2076          * might have cached one ExtINT interrupt.  Finally, at
2077          * least one tick may be lost due to delays.
2078          */
2079
2080         /* jiffies wrap? */
2081         if (time_after(jiffies, t1 + 4))
2082                 return 1;
2083         return 0;
2084 }
2085
2086 /*
2087  * In the SMP+IOAPIC case it might happen that there are an unspecified
2088  * number of pending IRQ events unhandled. These cases are very rare,
2089  * so we 'resend' these IRQs via IPIs, to the same CPU. It's much
2090  * better to do it this way as thus we do not have to be aware of
2091  * 'pending' interrupts in the IRQ path, except at this point.
2092  */
2093 /*
2094  * Edge triggered needs to resend any interrupt
2095  * that was delayed but this is now handled in the device
2096  * independent code.
2097  */
2098
2099 /*
2100  * Starting up a edge-triggered IO-APIC interrupt is
2101  * nasty - we need to make sure that we get the edge.
2102  * If it is already asserted for some reason, we need
2103  * return 1 to indicate that is was pending.
2104  *
2105  * This is not complete - we should be able to fake
2106  * an edge even if it isn't on the 8259A...
2107  */
2108
2109 static unsigned int startup_ioapic_irq(struct irq_data *data)
2110 {
2111         int was_pending = 0, irq = data->irq;
2112         unsigned long flags;
2113
2114         raw_spin_lock_irqsave(&ioapic_lock, flags);
2115         if (irq < legacy_pic->nr_legacy_irqs) {
2116                 legacy_pic->mask(irq);
2117                 if (legacy_pic->irq_pending(irq))
2118                         was_pending = 1;
2119         }
2120         __unmask_ioapic(data->chip_data);
2121         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2122
2123         return was_pending;
2124 }
2125
2126 static int ioapic_retrigger_irq(struct irq_data *data)
2127 {
2128         struct irq_cfg *cfg = data->chip_data;
2129         unsigned long flags;
2130
2131         raw_spin_lock_irqsave(&vector_lock, flags);
2132         apic->send_IPI_mask(cpumask_of(cpumask_first(cfg->domain)), cfg->vector);
2133         raw_spin_unlock_irqrestore(&vector_lock, flags);
2134
2135         return 1;
2136 }
2137
2138 /*
2139  * Level and edge triggered IO-APIC interrupts need different handling,
2140  * so we use two separate IRQ descriptors. Edge triggered IRQs can be
2141  * handled with the level-triggered descriptor, but that one has slightly
2142  * more overhead. Level-triggered interrupts cannot be handled with the
2143  * edge-triggered handler, without risking IRQ storms and other ugly
2144  * races.
2145  */
2146
2147 #ifdef CONFIG_SMP
2148 void send_cleanup_vector(struct irq_cfg *cfg)
2149 {
2150         cpumask_var_t cleanup_mask;
2151
2152         if (unlikely(!alloc_cpumask_var(&cleanup_mask, GFP_ATOMIC))) {
2153                 unsigned int i;
2154                 for_each_cpu_and(i, cfg->old_domain, cpu_online_mask)
2155                         apic->send_IPI_mask(cpumask_of(i), IRQ_MOVE_CLEANUP_VECTOR);
2156         } else {
2157                 cpumask_and(cleanup_mask, cfg->old_domain, cpu_online_mask);
2158                 apic->send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
2159                 free_cpumask_var(cleanup_mask);
2160         }
2161         cfg->move_in_progress = 0;
2162 }
2163
2164 static void __target_IO_APIC_irq(unsigned int irq, unsigned int dest, struct irq_cfg *cfg)
2165 {
2166         int apic, pin;
2167         struct irq_pin_list *entry;
2168         u8 vector = cfg->vector;
2169
2170         for_each_irq_pin(entry, cfg->irq_2_pin) {
2171                 unsigned int reg;
2172
2173                 apic = entry->apic;
2174                 pin = entry->pin;
2175                 /*
2176                  * With interrupt-remapping, destination information comes
2177                  * from interrupt-remapping table entry.
2178                  */
2179                 if (!irq_remapped(cfg))
2180                         io_apic_write(apic, 0x11 + pin*2, dest);
2181                 reg = io_apic_read(apic, 0x10 + pin*2);
2182                 reg &= ~IO_APIC_REDIR_VECTOR_MASK;
2183                 reg |= vector;
2184                 io_apic_modify(apic, 0x10 + pin*2, reg);
2185         }
2186 }
2187
2188 /*
2189  * Either sets data->affinity to a valid value, and returns
2190  * ->cpu_mask_to_apicid of that in dest_id, or returns -1 and
2191  * leaves data->affinity untouched.
2192  */
2193 int __ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
2194                           unsigned int *dest_id)
2195 {
2196         struct irq_cfg *cfg = data->chip_data;
2197
2198         if (!cpumask_intersects(mask, cpu_online_mask))
2199                 return -1;
2200
2201         if (assign_irq_vector(data->irq, data->chip_data, mask))
2202                 return -1;
2203
2204         cpumask_copy(data->affinity, mask);
2205
2206         *dest_id = apic->cpu_mask_to_apicid_and(mask, cfg->domain);
2207         return 0;
2208 }
2209
2210 static int
2211 ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
2212                     bool force)
2213 {
2214         unsigned int dest, irq = data->irq;
2215         unsigned long flags;
2216         int ret;
2217
2218         raw_spin_lock_irqsave(&ioapic_lock, flags);
2219         ret = __ioapic_set_affinity(data, mask, &dest);
2220         if (!ret) {
2221                 /* Only the high 8 bits are valid. */
2222                 dest = SET_APIC_LOGICAL_ID(dest);
2223                 __target_IO_APIC_irq(irq, dest, data->chip_data);
2224         }
2225         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2226         return ret;
2227 }
2228
2229 #ifdef CONFIG_INTR_REMAP
2230
2231 /*
2232  * Migrate the IO-APIC irq in the presence of intr-remapping.
2233  *
2234  * For both level and edge triggered, irq migration is a simple atomic
2235  * update(of vector and cpu destination) of IRTE and flush the hardware cache.
2236  *
2237  * For level triggered, we eliminate the io-apic RTE modification (with the
2238  * updated vector information), by using a virtual vector (io-apic pin number).
2239  * Real vector that is used for interrupting cpu will be coming from
2240  * the interrupt-remapping table entry.
2241  */
2242 static int
2243 ir_ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
2244                        bool force)
2245 {
2246         struct irq_cfg *cfg = data->chip_data;
2247         unsigned int dest, irq = data->irq;
2248         struct irte irte;
2249
2250         if (!cpumask_intersects(mask, cpu_online_mask))
2251                 return -EINVAL;
2252
2253         if (get_irte(irq, &irte))
2254                 return -EBUSY;
2255
2256         if (assign_irq_vector(irq, cfg, mask))
2257                 return -EBUSY;
2258
2259         dest = apic->cpu_mask_to_apicid_and(cfg->domain, mask);
2260
2261         irte.vector = cfg->vector;
2262         irte.dest_id = IRTE_DEST(dest);
2263
2264         /*
2265          * Modified the IRTE and flushes the Interrupt entry cache.
2266          */
2267         modify_irte(irq, &irte);
2268
2269         if (cfg->move_in_progress)
2270                 send_cleanup_vector(cfg);
2271
2272         cpumask_copy(data->affinity, mask);
2273         return 0;
2274 }
2275
2276 #else
2277 static inline int
2278 ir_ioapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
2279                        bool force)
2280 {
2281         return 0;
2282 }
2283 #endif
2284
2285 asmlinkage void smp_irq_move_cleanup_interrupt(void)
2286 {
2287         unsigned vector, me;
2288
2289         ack_APIC_irq();
2290         exit_idle();
2291         irq_enter();
2292
2293         me = smp_processor_id();
2294         for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) {
2295                 unsigned int irq;
2296                 unsigned int irr;
2297                 struct irq_desc *desc;
2298                 struct irq_cfg *cfg;
2299                 irq = __this_cpu_read(vector_irq[vector]);
2300
2301                 if (irq == -1)
2302                         continue;
2303
2304                 desc = irq_to_desc(irq);
2305                 if (!desc)
2306                         continue;
2307
2308                 cfg = irq_cfg(irq);
2309                 raw_spin_lock(&desc->lock);
2310
2311                 /*
2312                  * Check if the irq migration is in progress. If so, we
2313                  * haven't received the cleanup request yet for this irq.
2314                  */
2315                 if (cfg->move_in_progress)
2316                         goto unlock;
2317
2318                 if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain))
2319                         goto unlock;
2320
2321                 irr = apic_read(APIC_IRR + (vector / 32 * 0x10));
2322                 /*
2323                  * Check if the vector that needs to be cleanedup is
2324                  * registered at the cpu's IRR. If so, then this is not
2325                  * the best time to clean it up. Lets clean it up in the
2326                  * next attempt by sending another IRQ_MOVE_CLEANUP_VECTOR
2327                  * to myself.
2328                  */
2329                 if (irr  & (1 << (vector % 32))) {
2330                         apic->send_IPI_self(IRQ_MOVE_CLEANUP_VECTOR);
2331                         goto unlock;
2332                 }
2333                 __this_cpu_write(vector_irq[vector], -1);
2334 unlock:
2335                 raw_spin_unlock(&desc->lock);
2336         }
2337
2338         irq_exit();
2339 }
2340
2341 static void __irq_complete_move(struct irq_cfg *cfg, unsigned vector)
2342 {
2343         unsigned me;
2344
2345         if (likely(!cfg->move_in_progress))
2346                 return;
2347
2348         me = smp_processor_id();
2349
2350         if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain))
2351                 send_cleanup_vector(cfg);
2352 }
2353
2354 static void irq_complete_move(struct irq_cfg *cfg)
2355 {
2356         __irq_complete_move(cfg, ~get_irq_regs()->orig_ax);
2357 }
2358
2359 void irq_force_complete_move(int irq)
2360 {
2361         struct irq_cfg *cfg = irq_get_chip_data(irq);
2362
2363         if (!cfg)
2364                 return;
2365
2366         __irq_complete_move(cfg, cfg->vector);
2367 }
2368 #else
2369 static inline void irq_complete_move(struct irq_cfg *cfg) { }
2370 #endif
2371
2372 static void ack_apic_edge(struct irq_data *data)
2373 {
2374         irq_complete_move(data->chip_data);
2375         irq_move_irq(data);
2376         ack_APIC_irq();
2377 }
2378
2379 atomic_t irq_mis_count;
2380
2381 /*
2382  * IO-APIC versions below 0x20 don't support EOI register.
2383  * For the record, here is the information about various versions:
2384  *     0Xh     82489DX
2385  *     1Xh     I/OAPIC or I/O(x)APIC which are not PCI 2.2 Compliant
2386  *     2Xh     I/O(x)APIC which is PCI 2.2 Compliant
2387  *     30h-FFh Reserved
2388  *
2389  * Some of the Intel ICH Specs (ICH2 to ICH5) documents the io-apic
2390  * version as 0x2. This is an error with documentation and these ICH chips
2391  * use io-apic's of version 0x20.
2392  *
2393  * For IO-APIC's with EOI register, we use that to do an explicit EOI.
2394  * Otherwise, we simulate the EOI message manually by changing the trigger
2395  * mode to edge and then back to level, with RTE being masked during this.
2396 */
2397 static void eoi_ioapic_irq(unsigned int irq, struct irq_cfg *cfg)
2398 {
2399         struct irq_pin_list *entry;
2400         unsigned long flags;
2401
2402         raw_spin_lock_irqsave(&ioapic_lock, flags);
2403         for_each_irq_pin(entry, cfg->irq_2_pin) {
2404                 if (mpc_ioapic_ver(entry->apic) >= 0x20) {
2405                         /*
2406                          * Intr-remapping uses pin number as the virtual vector
2407                          * in the RTE. Actual vector is programmed in
2408                          * intr-remapping table entry. Hence for the io-apic
2409                          * EOI we use the pin number.
2410                          */
2411                         if (irq_remapped(cfg))
2412                                 io_apic_eoi(entry->apic, entry->pin);
2413                         else
2414                                 io_apic_eoi(entry->apic, cfg->vector);
2415                 } else {
2416                         __mask_and_edge_IO_APIC_irq(entry);
2417                         __unmask_and_level_IO_APIC_irq(entry);
2418                 }
2419         }
2420         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2421 }
2422
2423 static void ack_apic_level(struct irq_data *data)
2424 {
2425         struct irq_cfg *cfg = data->chip_data;
2426         int i, do_unmask_irq = 0, irq = data->irq;
2427         unsigned long v;
2428
2429         irq_complete_move(cfg);
2430 #ifdef CONFIG_GENERIC_PENDING_IRQ
2431         /* If we are moving the irq we need to mask it */
2432         if (unlikely(irqd_is_setaffinity_pending(data))) {
2433                 do_unmask_irq = 1;
2434                 mask_ioapic(cfg);
2435         }
2436 #endif
2437
2438         /*
2439          * It appears there is an erratum which affects at least version 0x11
2440          * of I/O APIC (that's the 82093AA and cores integrated into various
2441          * chipsets).  Under certain conditions a level-triggered interrupt is
2442          * erroneously delivered as edge-triggered one but the respective IRR
2443          * bit gets set nevertheless.  As a result the I/O unit expects an EOI
2444          * message but it will never arrive and further interrupts are blocked
2445          * from the source.  The exact reason is so far unknown, but the
2446          * phenomenon was observed when two consecutive interrupt requests
2447          * from a given source get delivered to the same CPU and the source is
2448          * temporarily disabled in between.
2449          *
2450          * A workaround is to simulate an EOI message manually.  We achieve it
2451          * by setting the trigger mode to edge and then to level when the edge
2452          * trigger mode gets detected in the TMR of a local APIC for a
2453          * level-triggered interrupt.  We mask the source for the time of the
2454          * operation to prevent an edge-triggered interrupt escaping meanwhile.
2455          * The idea is from Manfred Spraul.  --macro
2456          *
2457          * Also in the case when cpu goes offline, fixup_irqs() will forward
2458          * any unhandled interrupt on the offlined cpu to the new cpu
2459          * destination that is handling the corresponding interrupt. This
2460          * interrupt forwarding is done via IPI's. Hence, in this case also
2461          * level-triggered io-apic interrupt will be seen as an edge
2462          * interrupt in the IRR. And we can't rely on the cpu's EOI
2463          * to be broadcasted to the IO-APIC's which will clear the remoteIRR
2464          * corresponding to the level-triggered interrupt. Hence on IO-APIC's
2465          * supporting EOI register, we do an explicit EOI to clear the
2466          * remote IRR and on IO-APIC's which don't have an EOI register,
2467          * we use the above logic (mask+edge followed by unmask+level) from
2468          * Manfred Spraul to clear the remote IRR.
2469          */
2470         i = cfg->vector;
2471         v = apic_read(APIC_TMR + ((i & ~0x1f) >> 1));
2472
2473         /*
2474          * We must acknowledge the irq before we move it or the acknowledge will
2475          * not propagate properly.
2476          */
2477         ack_APIC_irq();
2478
2479         /*
2480          * Tail end of clearing remote IRR bit (either by delivering the EOI
2481          * message via io-apic EOI register write or simulating it using
2482          * mask+edge followed by unnask+level logic) manually when the
2483          * level triggered interrupt is seen as the edge triggered interrupt
2484          * at the cpu.
2485          */
2486         if (!(v & (1 << (i & 0x1f)))) {
2487                 atomic_inc(&irq_mis_count);
2488
2489                 eoi_ioapic_irq(irq, cfg);
2490         }
2491
2492         /* Now we can move and renable the irq */
2493         if (unlikely(do_unmask_irq)) {
2494                 /* Only migrate the irq if the ack has been received.
2495                  *
2496                  * On rare occasions the broadcast level triggered ack gets
2497                  * delayed going to ioapics, and if we reprogram the
2498                  * vector while Remote IRR is still set the irq will never
2499                  * fire again.
2500                  *
2501                  * To prevent this scenario we read the Remote IRR bit
2502                  * of the ioapic.  This has two effects.
2503                  * - On any sane system the read of the ioapic will
2504                  *   flush writes (and acks) going to the ioapic from
2505                  *   this cpu.
2506                  * - We get to see if the ACK has actually been delivered.
2507                  *
2508                  * Based on failed experiments of reprogramming the
2509                  * ioapic entry from outside of irq context starting
2510                  * with masking the ioapic entry and then polling until
2511                  * Remote IRR was clear before reprogramming the
2512                  * ioapic I don't trust the Remote IRR bit to be
2513                  * completey accurate.
2514                  *
2515                  * However there appears to be no other way to plug
2516                  * this race, so if the Remote IRR bit is not
2517                  * accurate and is causing problems then it is a hardware bug
2518                  * and you can go talk to the chipset vendor about it.
2519                  */
2520                 if (!io_apic_level_ack_pending(cfg))
2521                         irq_move_masked_irq(data);
2522                 unmask_ioapic(cfg);
2523         }
2524 }
2525
2526 #ifdef CONFIG_INTR_REMAP
2527 static void ir_ack_apic_edge(struct irq_data *data)
2528 {
2529         ack_APIC_irq();
2530 }
2531
2532 static void ir_ack_apic_level(struct irq_data *data)
2533 {
2534         ack_APIC_irq();
2535         eoi_ioapic_irq(data->irq, data->chip_data);
2536 }
2537 #endif /* CONFIG_INTR_REMAP */
2538
2539 static struct irq_chip ioapic_chip __read_mostly = {
2540         .name                   = "IO-APIC",
2541         .irq_startup            = startup_ioapic_irq,
2542         .irq_mask               = mask_ioapic_irq,
2543         .irq_unmask             = unmask_ioapic_irq,
2544         .irq_ack                = ack_apic_edge,
2545         .irq_eoi                = ack_apic_level,
2546 #ifdef CONFIG_SMP
2547         .irq_set_affinity       = ioapic_set_affinity,
2548 #endif
2549         .irq_retrigger          = ioapic_retrigger_irq,
2550 };
2551
2552 static struct irq_chip ir_ioapic_chip __read_mostly = {
2553         .name                   = "IR-IO-APIC",
2554         .irq_startup            = startup_ioapic_irq,
2555         .irq_mask               = mask_ioapic_irq,
2556         .irq_unmask             = unmask_ioapic_irq,
2557 #ifdef CONFIG_INTR_REMAP
2558         .irq_ack                = ir_ack_apic_edge,
2559         .irq_eoi                = ir_ack_apic_level,
2560 #ifdef CONFIG_SMP
2561         .irq_set_affinity       = ir_ioapic_set_affinity,
2562 #endif
2563 #endif
2564         .irq_retrigger          = ioapic_retrigger_irq,
2565 };
2566
2567 static inline void init_IO_APIC_traps(void)
2568 {
2569         struct irq_cfg *cfg;
2570         unsigned int irq;
2571
2572         /*
2573          * NOTE! The local APIC isn't very good at handling
2574          * multiple interrupts at the same interrupt level.
2575          * As the interrupt level is determined by taking the
2576          * vector number and shifting that right by 4, we
2577          * want to spread these out a bit so that they don't
2578          * all fall in the same interrupt level.
2579          *
2580          * Also, we've got to be careful not to trash gate
2581          * 0x80, because int 0x80 is hm, kind of importantish. ;)
2582          */
2583         for_each_active_irq(irq) {
2584                 cfg = irq_get_chip_data(irq);
2585                 if (IO_APIC_IRQ(irq) && cfg && !cfg->vector) {
2586                         /*
2587                          * Hmm.. We don't have an entry for this,
2588                          * so default to an old-fashioned 8259
2589                          * interrupt if we can..
2590                          */
2591                         if (irq < legacy_pic->nr_legacy_irqs)
2592                                 legacy_pic->make_irq(irq);
2593                         else
2594                                 /* Strange. Oh, well.. */
2595                                 irq_set_chip(irq, &no_irq_chip);
2596                 }
2597         }
2598 }
2599
2600 /*
2601  * The local APIC irq-chip implementation:
2602  */
2603
2604 static void mask_lapic_irq(struct irq_data *data)
2605 {
2606         unsigned long v;
2607
2608         v = apic_read(APIC_LVT0);
2609         apic_write(APIC_LVT0, v | APIC_LVT_MASKED);
2610 }
2611
2612 static void unmask_lapic_irq(struct irq_data *data)
2613 {
2614         unsigned long v;
2615
2616         v = apic_read(APIC_LVT0);
2617         apic_write(APIC_LVT0, v & ~APIC_LVT_MASKED);
2618 }
2619
2620 static void ack_lapic_irq(struct irq_data *data)
2621 {
2622         ack_APIC_irq();
2623 }
2624
2625 static struct irq_chip lapic_chip __read_mostly = {
2626         .name           = "local-APIC",
2627         .irq_mask       = mask_lapic_irq,
2628         .irq_unmask     = unmask_lapic_irq,
2629         .irq_ack        = ack_lapic_irq,
2630 };
2631
2632 static void lapic_register_intr(int irq)
2633 {
2634         irq_clear_status_flags(irq, IRQ_LEVEL);
2635         irq_set_chip_and_handler_name(irq, &lapic_chip, handle_edge_irq,
2636                                       "edge");
2637 }
2638
2639 /*
2640  * This looks a bit hackish but it's about the only one way of sending
2641  * a few INTA cycles to 8259As and any associated glue logic.  ICR does
2642  * not support the ExtINT mode, unfortunately.  We need to send these
2643  * cycles as some i82489DX-based boards have glue logic that keeps the
2644  * 8259A interrupt line asserted until INTA.  --macro
2645  */
2646 static inline void __init unlock_ExtINT_logic(void)
2647 {
2648         int apic, pin, i;
2649         struct IO_APIC_route_entry entry0, entry1;
2650         unsigned char save_control, save_freq_select;
2651
2652         pin  = find_isa_irq_pin(8, mp_INT);
2653         if (pin == -1) {
2654                 WARN_ON_ONCE(1);
2655                 return;
2656         }
2657         apic = find_isa_irq_apic(8, mp_INT);
2658         if (apic == -1) {
2659                 WARN_ON_ONCE(1);
2660                 return;
2661         }
2662
2663         entry0 = ioapic_read_entry(apic, pin);
2664         clear_IO_APIC_pin(apic, pin);
2665
2666         memset(&entry1, 0, sizeof(entry1));
2667
2668         entry1.dest_mode = 0;                   /* physical delivery */
2669         entry1.mask = 0;                        /* unmask IRQ now */
2670         entry1.dest = hard_smp_processor_id();
2671         entry1.delivery_mode = dest_ExtINT;
2672         entry1.polarity = entry0.polarity;
2673         entry1.trigger = 0;
2674         entry1.vector = 0;
2675
2676         ioapic_write_entry(apic, pin, entry1);
2677
2678         save_control = CMOS_READ(RTC_CONTROL);
2679         save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
2680         CMOS_WRITE((save_freq_select & ~RTC_RATE_SELECT) | 0x6,
2681                    RTC_FREQ_SELECT);
2682         CMOS_WRITE(save_control | RTC_PIE, RTC_CONTROL);
2683
2684         i = 100;
2685         while (i-- > 0) {
2686                 mdelay(10);
2687                 if ((CMOS_READ(RTC_INTR_FLAGS) & RTC_PF) == RTC_PF)
2688                         i -= 10;
2689         }
2690
2691         CMOS_WRITE(save_control, RTC_CONTROL);
2692         CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
2693         clear_IO_APIC_pin(apic, pin);
2694
2695         ioapic_write_entry(apic, pin, entry0);
2696 }
2697
2698 static int disable_timer_pin_1 __initdata;
2699 /* Actually the next is obsolete, but keep it for paranoid reasons -AK */
2700 static int __init disable_timer_pin_setup(char *arg)
2701 {
2702         disable_timer_pin_1 = 1;
2703         return 0;
2704 }
2705 early_param("disable_timer_pin_1", disable_timer_pin_setup);
2706
2707 int timer_through_8259 __initdata;
2708
2709 /*
2710  * This code may look a bit paranoid, but it's supposed to cooperate with
2711  * a wide range of boards and BIOS bugs.  Fortunately only the timer IRQ
2712  * is so screwy.  Thanks to Brian Perkins for testing/hacking this beast
2713  * fanatically on his truly buggy board.
2714  *
2715  * FIXME: really need to revamp this for all platforms.
2716  */
2717 static inline void __init check_timer(void)
2718 {
2719         struct irq_cfg *cfg = irq_get_chip_data(0);
2720         int node = cpu_to_node(0);
2721         int apic1, pin1, apic2, pin2;
2722         unsigned long flags;
2723         int no_pin1 = 0;
2724
2725         local_irq_save(flags);
2726
2727         /*
2728          * get/set the timer IRQ vector:
2729          */
2730         legacy_pic->mask(0);
2731         assign_irq_vector(0, cfg, apic->target_cpus());
2732
2733         /*
2734          * As IRQ0 is to be enabled in the 8259A, the virtual
2735          * wire has to be disabled in the local APIC.  Also
2736          * timer interrupts need to be acknowledged manually in
2737          * the 8259A for the i82489DX when using the NMI
2738          * watchdog as that APIC treats NMIs as level-triggered.
2739          * The AEOI mode will finish them in the 8259A
2740          * automatically.
2741          */
2742         apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_EXTINT);
2743         legacy_pic->init(1);
2744
2745         pin1  = find_isa_irq_pin(0, mp_INT);
2746         apic1 = find_isa_irq_apic(0, mp_INT);
2747         pin2  = ioapic_i8259.pin;
2748         apic2 = ioapic_i8259.apic;
2749
2750         apic_printk(APIC_QUIET, KERN_INFO "..TIMER: vector=0x%02X "
2751                     "apic1=%d pin1=%d apic2=%d pin2=%d\n",
2752                     cfg->vector, apic1, pin1, apic2, pin2);
2753
2754         /*
2755          * Some BIOS writers are clueless and report the ExtINTA
2756          * I/O APIC input from the cascaded 8259A as the timer
2757          * interrupt input.  So just in case, if only one pin
2758          * was found above, try it both directly and through the
2759          * 8259A.
2760          */
2761         if (pin1 == -1) {
2762                 if (intr_remapping_enabled)
2763                         panic("BIOS bug: timer not connected to IO-APIC");
2764                 pin1 = pin2;
2765                 apic1 = apic2;
2766                 no_pin1 = 1;
2767         } else if (pin2 == -1) {
2768                 pin2 = pin1;
2769                 apic2 = apic1;
2770         }
2771
2772         if (pin1 != -1) {
2773                 /*
2774                  * Ok, does IRQ0 through the IOAPIC work?
2775                  */
2776                 if (no_pin1) {
2777                         add_pin_to_irq_node(cfg, node, apic1, pin1);
2778                         setup_timer_IRQ0_pin(apic1, pin1, cfg->vector);
2779                 } else {
2780                         /* for edge trigger, setup_ioapic_irq already
2781                          * leave it unmasked.
2782                          * so only need to unmask if it is level-trigger
2783                          * do we really have level trigger timer?
2784                          */
2785                         int idx;
2786                         idx = find_irq_entry(apic1, pin1, mp_INT);
2787                         if (idx != -1 && irq_trigger(idx))
2788                                 unmask_ioapic(cfg);
2789                 }
2790                 if (timer_irq_works()) {
2791                         if (disable_timer_pin_1 > 0)
2792                                 clear_IO_APIC_pin(0, pin1);
2793                         goto out;
2794                 }
2795                 if (intr_remapping_enabled)
2796                         panic("timer doesn't work through Interrupt-remapped IO-APIC");
2797                 local_irq_disable();
2798                 clear_IO_APIC_pin(apic1, pin1);
2799                 if (!no_pin1)
2800                         apic_printk(APIC_QUIET, KERN_ERR "..MP-BIOS bug: "
2801                                     "8254 timer not connected to IO-APIC\n");
2802
2803                 apic_printk(APIC_QUIET, KERN_INFO "...trying to set up timer "
2804                             "(IRQ0) through the 8259A ...\n");
2805                 apic_printk(APIC_QUIET, KERN_INFO
2806                             "..... (found apic %d pin %d) ...\n", apic2, pin2);
2807                 /*
2808                  * legacy devices should be connected to IO APIC #0
2809                  */
2810                 replace_pin_at_irq_node(cfg, node, apic1, pin1, apic2, pin2);
2811                 setup_timer_IRQ0_pin(apic2, pin2, cfg->vector);
2812                 legacy_pic->unmask(0);
2813                 if (timer_irq_works()) {
2814                         apic_printk(APIC_QUIET, KERN_INFO "....... works.\n");
2815                         timer_through_8259 = 1;
2816                         goto out;
2817                 }
2818                 /*
2819                  * Cleanup, just in case ...
2820                  */
2821                 local_irq_disable();
2822                 legacy_pic->mask(0);
2823                 clear_IO_APIC_pin(apic2, pin2);
2824                 apic_printk(APIC_QUIET, KERN_INFO "....... failed.\n");
2825         }
2826
2827         apic_printk(APIC_QUIET, KERN_INFO
2828                     "...trying to set up timer as Virtual Wire IRQ...\n");
2829
2830         lapic_register_intr(0);
2831         apic_write(APIC_LVT0, APIC_DM_FIXED | cfg->vector);     /* Fixed mode */
2832         legacy_pic->unmask(0);
2833
2834         if (timer_irq_works()) {
2835                 apic_printk(APIC_QUIET, KERN_INFO "..... works.\n");
2836                 goto out;
2837         }
2838         local_irq_disable();
2839         legacy_pic->mask(0);
2840         apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_FIXED | cfg->vector);
2841         apic_printk(APIC_QUIET, KERN_INFO "..... failed.\n");
2842
2843         apic_printk(APIC_QUIET, KERN_INFO
2844                     "...trying to set up timer as ExtINT IRQ...\n");
2845
2846         legacy_pic->init(0);
2847         legacy_pic->make_irq(0);
2848         apic_write(APIC_LVT0, APIC_DM_EXTINT);
2849
2850         unlock_ExtINT_logic();
2851
2852         if (timer_irq_works()) {
2853                 apic_printk(APIC_QUIET, KERN_INFO "..... works.\n");
2854                 goto out;
2855         }
2856         local_irq_disable();
2857         apic_printk(APIC_QUIET, KERN_INFO "..... failed :(.\n");
2858         panic("IO-APIC + timer doesn't work!  Boot with apic=debug and send a "
2859                 "report.  Then try booting with the 'noapic' option.\n");
2860 out:
2861         local_irq_restore(flags);
2862 }
2863
2864 /*
2865  * Traditionally ISA IRQ2 is the cascade IRQ, and is not available
2866  * to devices.  However there may be an I/O APIC pin available for
2867  * this interrupt regardless.  The pin may be left unconnected, but
2868  * typically it will be reused as an ExtINT cascade interrupt for
2869  * the master 8259A.  In the MPS case such a pin will normally be
2870  * reported as an ExtINT interrupt in the MP table.  With ACPI
2871  * there is no provision for ExtINT interrupts, and in the absence
2872  * of an override it would be treated as an ordinary ISA I/O APIC
2873  * interrupt, that is edge-triggered and unmasked by default.  We
2874  * used to do this, but it caused problems on some systems because
2875  * of the NMI watchdog and sometimes IRQ0 of the 8254 timer using
2876  * the same ExtINT cascade interrupt to drive the local APIC of the
2877  * bootstrap processor.  Therefore we refrain from routing IRQ2 to
2878  * the I/O APIC in all cases now.  No actual device should request
2879  * it anyway.  --macro
2880  */
2881 #define PIC_IRQS        (1UL << PIC_CASCADE_IR)
2882
2883 void __init setup_IO_APIC(void)
2884 {
2885
2886         /*
2887          * calling enable_IO_APIC() is moved to setup_local_APIC for BP
2888          */
2889         io_apic_irqs = legacy_pic->nr_legacy_irqs ? ~PIC_IRQS : ~0UL;
2890
2891         apic_printk(APIC_VERBOSE, "ENABLING IO-APIC IRQs\n");
2892         /*
2893          * Set up IO-APIC IRQ routing.
2894          */
2895         x86_init.mpparse.setup_ioapic_ids();
2896
2897         sync_Arb_IDs();
2898         setup_IO_APIC_irqs();
2899         init_IO_APIC_traps();
2900         if (legacy_pic->nr_legacy_irqs)
2901                 check_timer();
2902 }
2903
2904 /*
2905  *      Called after all the initialization is done. If we didn't find any
2906  *      APIC bugs then we can allow the modify fast path
2907  */
2908
2909 static int __init io_apic_bug_finalize(void)
2910 {
2911         if (sis_apic_bug == -1)
2912                 sis_apic_bug = 0;
2913         return 0;
2914 }
2915
2916 late_initcall(io_apic_bug_finalize);
2917
2918 static void resume_ioapic_id(int ioapic_id)
2919 {
2920         unsigned long flags;
2921         union IO_APIC_reg_00 reg_00;
2922
2923
2924         raw_spin_lock_irqsave(&ioapic_lock, flags);
2925         reg_00.raw = io_apic_read(ioapic_id, 0);
2926         if (reg_00.bits.ID != mpc_ioapic_id(ioapic_id)) {
2927                 reg_00.bits.ID = mpc_ioapic_id(ioapic_id);
2928                 io_apic_write(ioapic_id, 0, reg_00.raw);
2929         }
2930         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
2931 }
2932
2933 static void ioapic_resume(void)
2934 {
2935         int ioapic_id;
2936
2937         for (ioapic_id = nr_ioapics - 1; ioapic_id >= 0; ioapic_id--)
2938                 resume_ioapic_id(ioapic_id);
2939
2940         restore_ioapic_entries();
2941 }
2942
2943 static struct syscore_ops ioapic_syscore_ops = {
2944         .suspend = save_ioapic_entries,
2945         .resume = ioapic_resume,
2946 };
2947
2948 static int __init ioapic_init_ops(void)
2949 {
2950         register_syscore_ops(&ioapic_syscore_ops);
2951
2952         return 0;
2953 }
2954
2955 device_initcall(ioapic_init_ops);
2956
2957 /*
2958  * Dynamic irq allocate and deallocation
2959  */
2960 unsigned int create_irq_nr(unsigned int from, int node)
2961 {
2962         struct irq_cfg *cfg;
2963         unsigned long flags;
2964         unsigned int ret = 0;
2965         int irq;
2966
2967         if (from < nr_irqs_gsi)
2968                 from = nr_irqs_gsi;
2969
2970         irq = alloc_irq_from(from, node);
2971         if (irq < 0)
2972                 return 0;
2973         cfg = alloc_irq_cfg(irq, node);
2974         if (!cfg) {
2975                 free_irq_at(irq, NULL);
2976                 return 0;
2977         }
2978
2979         raw_spin_lock_irqsave(&vector_lock, flags);
2980         if (!__assign_irq_vector(irq, cfg, apic->target_cpus()))
2981                 ret = irq;
2982         raw_spin_unlock_irqrestore(&vector_lock, flags);
2983
2984         if (ret) {
2985                 irq_set_chip_data(irq, cfg);
2986                 irq_clear_status_flags(irq, IRQ_NOREQUEST);
2987         } else {
2988                 free_irq_at(irq, cfg);
2989         }
2990         return ret;
2991 }
2992
2993 int create_irq(void)
2994 {
2995         int node = cpu_to_node(0);
2996         unsigned int irq_want;
2997         int irq;
2998
2999         irq_want = nr_irqs_gsi;
3000         irq = create_irq_nr(irq_want, node);
3001
3002         if (irq == 0)
3003                 irq = -1;
3004
3005         return irq;
3006 }
3007
3008 void destroy_irq(unsigned int irq)
3009 {
3010         struct irq_cfg *cfg = irq_get_chip_data(irq);
3011         unsigned long flags;
3012
3013         irq_set_status_flags(irq, IRQ_NOREQUEST|IRQ_NOPROBE);
3014
3015         if (irq_remapped(cfg))
3016                 free_irte(irq);
3017         raw_spin_lock_irqsave(&vector_lock, flags);
3018         __clear_irq_vector(irq, cfg);
3019         raw_spin_unlock_irqrestore(&vector_lock, flags);
3020         free_irq_at(irq, cfg);
3021 }
3022
3023 /*
3024  * MSI message composition
3025  */
3026 #ifdef CONFIG_PCI_MSI
3027 static int msi_compose_msg(struct pci_dev *pdev, unsigned int irq,
3028                            struct msi_msg *msg, u8 hpet_id)
3029 {
3030         struct irq_cfg *cfg;
3031         int err;
3032         unsigned dest;
3033
3034         if (disable_apic)
3035                 return -ENXIO;
3036
3037         cfg = irq_cfg(irq);
3038         err = assign_irq_vector(irq, cfg, apic->target_cpus());
3039         if (err)
3040                 return err;
3041
3042         dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus());
3043
3044         if (irq_remapped(cfg)) {
3045                 struct irte irte;
3046                 int ir_index;
3047                 u16 sub_handle;
3048
3049                 ir_index = map_irq_to_irte_handle(irq, &sub_handle);
3050                 BUG_ON(ir_index == -1);
3051
3052                 prepare_irte(&irte, cfg->vector, dest);
3053
3054                 /* Set source-id of interrupt request */
3055                 if (pdev)
3056                         set_msi_sid(&irte, pdev);
3057                 else
3058                         set_hpet_sid(&irte, hpet_id);
3059
3060                 modify_irte(irq, &irte);
3061
3062                 msg->address_hi = MSI_ADDR_BASE_HI;
3063                 msg->data = sub_handle;
3064                 msg->address_lo = MSI_ADDR_BASE_LO | MSI_ADDR_IR_EXT_INT |
3065                                   MSI_ADDR_IR_SHV |
3066                                   MSI_ADDR_IR_INDEX1(ir_index) |
3067                                   MSI_ADDR_IR_INDEX2(ir_index);
3068         } else {
3069                 if (x2apic_enabled())
3070                         msg->address_hi = MSI_ADDR_BASE_HI |
3071                                           MSI_ADDR_EXT_DEST_ID(dest);
3072                 else
3073                         msg->address_hi = MSI_ADDR_BASE_HI;
3074
3075                 msg->address_lo =
3076                         MSI_ADDR_BASE_LO |
3077                         ((apic->irq_dest_mode == 0) ?
3078                                 MSI_ADDR_DEST_MODE_PHYSICAL:
3079                                 MSI_ADDR_DEST_MODE_LOGICAL) |
3080                         ((apic->irq_delivery_mode != dest_LowestPrio) ?
3081                                 MSI_ADDR_REDIRECTION_CPU:
3082                                 MSI_ADDR_REDIRECTION_LOWPRI) |
3083                         MSI_ADDR_DEST_ID(dest);
3084
3085                 msg->data =
3086                         MSI_DATA_TRIGGER_EDGE |
3087                         MSI_DATA_LEVEL_ASSERT |
3088                         ((apic->irq_delivery_mode != dest_LowestPrio) ?
3089                                 MSI_DATA_DELIVERY_FIXED:
3090                                 MSI_DATA_DELIVERY_LOWPRI) |
3091                         MSI_DATA_VECTOR(cfg->vector);
3092         }
3093         return err;
3094 }
3095
3096 #ifdef CONFIG_SMP
3097 static int
3098 msi_set_affinity(struct irq_data *data, const struct cpumask *mask, bool force)
3099 {
3100         struct irq_cfg *cfg = data->chip_data;
3101         struct msi_msg msg;
3102         unsigned int dest;
3103
3104         if (__ioapic_set_affinity(data, mask, &dest))
3105                 return -1;
3106
3107         __get_cached_msi_msg(data->msi_desc, &msg);
3108
3109         msg.data &= ~MSI_DATA_VECTOR_MASK;
3110         msg.data |= MSI_DATA_VECTOR(cfg->vector);
3111         msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
3112         msg.address_lo |= MSI_ADDR_DEST_ID(dest);
3113
3114         __write_msi_msg(data->msi_desc, &msg);
3115
3116         return 0;
3117 }
3118 #ifdef CONFIG_INTR_REMAP
3119 /*
3120  * Migrate the MSI irq to another cpumask. This migration is
3121  * done in the process context using interrupt-remapping hardware.
3122  */
3123 static int
3124 ir_msi_set_affinity(struct irq_data *data, const struct cpumask *mask,
3125                     bool force)
3126 {
3127         struct irq_cfg *cfg = data->chip_data;
3128         unsigned int dest, irq = data->irq;
3129         struct irte irte;
3130
3131         if (get_irte(irq, &irte))
3132                 return -1;
3133
3134         if (__ioapic_set_affinity(data, mask, &dest))
3135                 return -1;
3136
3137         irte.vector = cfg->vector;
3138         irte.dest_id = IRTE_DEST(dest);
3139
3140         /*
3141          * atomically update the IRTE with the new destination and vector.
3142          */
3143         modify_irte(irq, &irte);
3144
3145         /*
3146          * After this point, all the interrupts will start arriving
3147          * at the new destination. So, time to cleanup the previous
3148          * vector allocation.
3149          */
3150         if (cfg->move_in_progress)
3151                 send_cleanup_vector(cfg);
3152
3153         return 0;
3154 }
3155
3156 #endif
3157 #endif /* CONFIG_SMP */
3158
3159 /*
3160  * IRQ Chip for MSI PCI/PCI-X/PCI-Express Devices,
3161  * which implement the MSI or MSI-X Capability Structure.
3162  */
3163 static struct irq_chip msi_chip = {
3164         .name                   = "PCI-MSI",
3165         .irq_unmask             = unmask_msi_irq,
3166         .irq_mask               = mask_msi_irq,
3167         .irq_ack                = ack_apic_edge,
3168 #ifdef CONFIG_SMP
3169         .irq_set_affinity       = msi_set_affinity,
3170 #endif
3171         .irq_retrigger          = ioapic_retrigger_irq,
3172 };
3173
3174 static struct irq_chip msi_ir_chip = {
3175         .name                   = "IR-PCI-MSI",
3176         .irq_unmask             = unmask_msi_irq,
3177         .irq_mask               = mask_msi_irq,
3178 #ifdef CONFIG_INTR_REMAP
3179         .irq_ack                = ir_ack_apic_edge,
3180 #ifdef CONFIG_SMP
3181         .irq_set_affinity       = ir_msi_set_affinity,
3182 #endif
3183 #endif
3184         .irq_retrigger          = ioapic_retrigger_irq,
3185 };
3186
3187 /*
3188  * Map the PCI dev to the corresponding remapping hardware unit
3189  * and allocate 'nvec' consecutive interrupt-remapping table entries
3190  * in it.
3191  */
3192 static int msi_alloc_irte(struct pci_dev *dev, int irq, int nvec)
3193 {
3194         struct intel_iommu *iommu;
3195         int index;
3196
3197         iommu = map_dev_to_ir(dev);
3198         if (!iommu) {
3199                 printk(KERN_ERR
3200                        "Unable to map PCI %s to iommu\n", pci_name(dev));
3201                 return -ENOENT;
3202         }
3203
3204         index = alloc_irte(iommu, irq, nvec);
3205         if (index < 0) {
3206                 printk(KERN_ERR
3207                        "Unable to allocate %d IRTE for PCI %s\n", nvec,
3208                        pci_name(dev));
3209                 return -ENOSPC;
3210         }
3211         return index;
3212 }
3213
3214 static int setup_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc, int irq)
3215 {
3216         struct irq_chip *chip = &msi_chip;
3217         struct msi_msg msg;
3218         int ret;
3219
3220         ret = msi_compose_msg(dev, irq, &msg, -1);
3221         if (ret < 0)
3222                 return ret;
3223
3224         irq_set_msi_desc(irq, msidesc);
3225         write_msi_msg(irq, &msg);
3226
3227         if (irq_remapped(irq_get_chip_data(irq))) {
3228                 irq_set_status_flags(irq, IRQ_MOVE_PCNTXT);
3229                 chip = &msi_ir_chip;
3230         }
3231
3232         irq_set_chip_and_handler_name(irq, chip, handle_edge_irq, "edge");
3233
3234         dev_printk(KERN_DEBUG, &dev->dev, "irq %d for MSI/MSI-X\n", irq);
3235
3236         return 0;
3237 }
3238
3239 int native_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
3240 {
3241         int node, ret, sub_handle, index = 0;
3242         unsigned int irq, irq_want;
3243         struct msi_desc *msidesc;
3244         struct intel_iommu *iommu = NULL;
3245
3246         /* x86 doesn't support multiple MSI yet */
3247         if (type == PCI_CAP_ID_MSI && nvec > 1)
3248                 return 1;
3249
3250         node = dev_to_node(&dev->dev);
3251         irq_want = nr_irqs_gsi;
3252         sub_handle = 0;
3253         list_for_each_entry(msidesc, &dev->msi_list, list) {
3254                 irq = create_irq_nr(irq_want, node);
3255                 if (irq == 0)
3256                         return -1;
3257                 irq_want = irq + 1;
3258                 if (!intr_remapping_enabled)
3259                         goto no_ir;
3260
3261                 if (!sub_handle) {
3262                         /*
3263                          * allocate the consecutive block of IRTE's
3264                          * for 'nvec'
3265                          */
3266                         index = msi_alloc_irte(dev, irq, nvec);
3267                         if (index < 0) {
3268                                 ret = index;
3269                                 goto error;
3270                         }
3271                 } else {
3272                         iommu = map_dev_to_ir(dev);
3273                         if (!iommu) {
3274                                 ret = -ENOENT;
3275                                 goto error;
3276                         }
3277                         /*
3278                          * setup the mapping between the irq and the IRTE
3279                          * base index, the sub_handle pointing to the
3280                          * appropriate interrupt remap table entry.
3281                          */
3282                         set_irte_irq(irq, iommu, index, sub_handle);
3283                 }
3284 no_ir:
3285                 ret = setup_msi_irq(dev, msidesc, irq);
3286                 if (ret < 0)
3287                         goto error;
3288                 sub_handle++;
3289         }
3290         return 0;
3291
3292 error:
3293         destroy_irq(irq);
3294         return ret;
3295 }
3296
3297 void native_teardown_msi_irq(unsigned int irq)
3298 {
3299         destroy_irq(irq);
3300 }
3301
3302 #if defined (CONFIG_DMAR) || defined (CONFIG_INTR_REMAP)
3303 #ifdef CONFIG_SMP
3304 static int
3305 dmar_msi_set_affinity(struct irq_data *data, const struct cpumask *mask,
3306                       bool force)
3307 {
3308         struct irq_cfg *cfg = data->chip_data;
3309         unsigned int dest, irq = data->irq;
3310         struct msi_msg msg;
3311
3312         if (__ioapic_set_affinity(data, mask, &dest))
3313                 return -1;
3314
3315         dmar_msi_read(irq, &msg);
3316
3317         msg.data &= ~MSI_DATA_VECTOR_MASK;
3318         msg.data |= MSI_DATA_VECTOR(cfg->vector);
3319         msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
3320         msg.address_lo |= MSI_ADDR_DEST_ID(dest);
3321         msg.address_hi = MSI_ADDR_BASE_HI | MSI_ADDR_EXT_DEST_ID(dest);
3322
3323         dmar_msi_write(irq, &msg);
3324
3325         return 0;
3326 }
3327
3328 #endif /* CONFIG_SMP */
3329
3330 static struct irq_chip dmar_msi_type = {
3331         .name                   = "DMAR_MSI",
3332         .irq_unmask             = dmar_msi_unmask,
3333         .irq_mask               = dmar_msi_mask,
3334         .irq_ack                = ack_apic_edge,
3335 #ifdef CONFIG_SMP
3336         .irq_set_affinity       = dmar_msi_set_affinity,
3337 #endif
3338         .irq_retrigger          = ioapic_retrigger_irq,
3339 };
3340
3341 int arch_setup_dmar_msi(unsigned int irq)
3342 {
3343         int ret;
3344         struct msi_msg msg;
3345
3346         ret = msi_compose_msg(NULL, irq, &msg, -1);
3347         if (ret < 0)
3348                 return ret;
3349         dmar_msi_write(irq, &msg);
3350         irq_set_chip_and_handler_name(irq, &dmar_msi_type, handle_edge_irq,
3351                                       "edge");
3352         return 0;
3353 }
3354 #endif
3355
3356 #ifdef CONFIG_HPET_TIMER
3357
3358 #ifdef CONFIG_SMP
3359 static int hpet_msi_set_affinity(struct irq_data *data,
3360                                  const struct cpumask *mask, bool force)
3361 {
3362         struct irq_cfg *cfg = data->chip_data;
3363         struct msi_msg msg;
3364         unsigned int dest;
3365
3366         if (__ioapic_set_affinity(data, mask, &dest))
3367                 return -1;
3368
3369         hpet_msi_read(data->handler_data, &msg);
3370
3371         msg.data &= ~MSI_DATA_VECTOR_MASK;
3372         msg.data |= MSI_DATA_VECTOR(cfg->vector);
3373         msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
3374         msg.address_lo |= MSI_ADDR_DEST_ID(dest);
3375
3376         hpet_msi_write(data->handler_data, &msg);
3377
3378         return 0;
3379 }
3380
3381 #endif /* CONFIG_SMP */
3382
3383 static struct irq_chip ir_hpet_msi_type = {
3384         .name                   = "IR-HPET_MSI",
3385         .irq_unmask             = hpet_msi_unmask,
3386         .irq_mask               = hpet_msi_mask,
3387 #ifdef CONFIG_INTR_REMAP
3388         .irq_ack                = ir_ack_apic_edge,
3389 #ifdef CONFIG_SMP
3390         .irq_set_affinity       = ir_msi_set_affinity,
3391 #endif
3392 #endif
3393         .irq_retrigger          = ioapic_retrigger_irq,
3394 };
3395
3396 static struct irq_chip hpet_msi_type = {
3397         .name = "HPET_MSI",
3398         .irq_unmask = hpet_msi_unmask,
3399         .irq_mask = hpet_msi_mask,
3400         .irq_ack = ack_apic_edge,
3401 #ifdef CONFIG_SMP
3402         .irq_set_affinity = hpet_msi_set_affinity,
3403 #endif
3404         .irq_retrigger = ioapic_retrigger_irq,
3405 };
3406
3407 int arch_setup_hpet_msi(unsigned int irq, unsigned int id)
3408 {
3409         struct irq_chip *chip = &hpet_msi_type;
3410         struct msi_msg msg;
3411         int ret;
3412
3413         if (intr_remapping_enabled) {
3414                 struct intel_iommu *iommu = map_hpet_to_ir(id);
3415                 int index;
3416
3417                 if (!iommu)
3418                         return -1;
3419
3420                 index = alloc_irte(iommu, irq, 1);
3421                 if (index < 0)
3422                         return -1;
3423         }
3424
3425         ret = msi_compose_msg(NULL, irq, &msg, id);
3426         if (ret < 0)
3427                 return ret;
3428
3429         hpet_msi_write(irq_get_handler_data(irq), &msg);
3430         irq_set_status_flags(irq, IRQ_MOVE_PCNTXT);
3431         if (irq_remapped(irq_get_chip_data(irq)))
3432                 chip = &ir_hpet_msi_type;
3433
3434         irq_set_chip_and_handler_name(irq, chip, handle_edge_irq, "edge");
3435         return 0;
3436 }
3437 #endif
3438
3439 #endif /* CONFIG_PCI_MSI */
3440 /*
3441  * Hypertransport interrupt support
3442  */
3443 #ifdef CONFIG_HT_IRQ
3444
3445 #ifdef CONFIG_SMP
3446
3447 static void target_ht_irq(unsigned int irq, unsigned int dest, u8 vector)
3448 {
3449         struct ht_irq_msg msg;
3450         fetch_ht_irq_msg(irq, &msg);
3451
3452         msg.address_lo &= ~(HT_IRQ_LOW_VECTOR_MASK | HT_IRQ_LOW_DEST_ID_MASK);
3453         msg.address_hi &= ~(HT_IRQ_HIGH_DEST_ID_MASK);
3454
3455         msg.address_lo |= HT_IRQ_LOW_VECTOR(vector) | HT_IRQ_LOW_DEST_ID(dest);
3456         msg.address_hi |= HT_IRQ_HIGH_DEST_ID(dest);
3457
3458         write_ht_irq_msg(irq, &msg);
3459 }
3460
3461 static int
3462 ht_set_affinity(struct irq_data *data, const struct cpumask *mask, bool force)
3463 {
3464         struct irq_cfg *cfg = data->chip_data;
3465         unsigned int dest;
3466
3467         if (__ioapic_set_affinity(data, mask, &dest))
3468                 return -1;
3469
3470         target_ht_irq(data->irq, dest, cfg->vector);
3471         return 0;
3472 }
3473
3474 #endif
3475
3476 static struct irq_chip ht_irq_chip = {
3477         .name                   = "PCI-HT",
3478         .irq_mask               = mask_ht_irq,
3479         .irq_unmask             = unmask_ht_irq,
3480         .irq_ack                = ack_apic_edge,
3481 #ifdef CONFIG_SMP
3482         .irq_set_affinity       = ht_set_affinity,
3483 #endif
3484         .irq_retrigger          = ioapic_retrigger_irq,
3485 };
3486
3487 int arch_setup_ht_irq(unsigned int irq, struct pci_dev *dev)
3488 {
3489         struct irq_cfg *cfg;
3490         int err;
3491
3492         if (disable_apic)
3493                 return -ENXIO;
3494
3495         cfg = irq_cfg(irq);
3496         err = assign_irq_vector(irq, cfg, apic->target_cpus());
3497         if (!err) {
3498                 struct ht_irq_msg msg;
3499                 unsigned dest;
3500
3501                 dest = apic->cpu_mask_to_apicid_and(cfg->domain,
3502                                                     apic->target_cpus());
3503
3504                 msg.address_hi = HT_IRQ_HIGH_DEST_ID(dest);
3505
3506                 msg.address_lo =
3507                         HT_IRQ_LOW_BASE |
3508                         HT_IRQ_LOW_DEST_ID(dest) |
3509                         HT_IRQ_LOW_VECTOR(cfg->vector) |
3510                         ((apic->irq_dest_mode == 0) ?
3511                                 HT_IRQ_LOW_DM_PHYSICAL :
3512                                 HT_IRQ_LOW_DM_LOGICAL) |
3513                         HT_IRQ_LOW_RQEOI_EDGE |
3514                         ((apic->irq_delivery_mode != dest_LowestPrio) ?
3515                                 HT_IRQ_LOW_MT_FIXED :
3516                                 HT_IRQ_LOW_MT_ARBITRATED) |
3517                         HT_IRQ_LOW_IRQ_MASKED;
3518
3519                 write_ht_irq_msg(irq, &msg);
3520
3521                 irq_set_chip_and_handler_name(irq, &ht_irq_chip,
3522                                               handle_edge_irq, "edge");
3523
3524                 dev_printk(KERN_DEBUG, &dev->dev, "irq %d for HT\n", irq);
3525         }
3526         return err;
3527 }
3528 #endif /* CONFIG_HT_IRQ */
3529
3530 static int
3531 io_apic_setup_irq_pin(unsigned int irq, int node, struct io_apic_irq_attr *attr)
3532 {
3533         struct irq_cfg *cfg = alloc_irq_and_cfg_at(irq, node);
3534         int ret;
3535
3536         if (!cfg)
3537                 return -EINVAL;
3538         ret = __add_pin_to_irq_node(cfg, node, attr->ioapic, attr->ioapic_pin);
3539         if (!ret)
3540                 setup_ioapic_irq(attr->ioapic, attr->ioapic_pin, irq, cfg,
3541                                  attr->trigger, attr->polarity);
3542         return ret;
3543 }
3544
3545 int io_apic_setup_irq_pin_once(unsigned int irq, int node,
3546                                struct io_apic_irq_attr *attr)
3547 {
3548         unsigned int id = attr->ioapic, pin = attr->ioapic_pin;
3549         int ret;
3550
3551         /* Avoid redundant programming */
3552         if (test_bit(pin, ioapics[id].pin_programmed)) {
3553                 pr_debug("Pin %d-%d already programmed\n",
3554                          mpc_ioapic_id(id), pin);
3555                 return 0;
3556         }
3557         ret = io_apic_setup_irq_pin(irq, node, attr);
3558         if (!ret)
3559                 set_bit(pin, ioapics[id].pin_programmed);
3560         return ret;
3561 }
3562
3563 static int __init io_apic_get_redir_entries(int ioapic)
3564 {
3565         union IO_APIC_reg_01    reg_01;
3566         unsigned long flags;
3567
3568         raw_spin_lock_irqsave(&ioapic_lock, flags);
3569         reg_01.raw = io_apic_read(ioapic, 1);
3570         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
3571
3572         /* The register returns the maximum index redir index
3573          * supported, which is one less than the total number of redir
3574          * entries.
3575          */
3576         return reg_01.bits.entries + 1;
3577 }
3578
3579 static void __init probe_nr_irqs_gsi(void)
3580 {
3581         int nr;
3582
3583         nr = gsi_top + NR_IRQS_LEGACY;
3584         if (nr > nr_irqs_gsi)
3585                 nr_irqs_gsi = nr;
3586
3587         printk(KERN_DEBUG "nr_irqs_gsi: %d\n", nr_irqs_gsi);
3588 }
3589
3590 int get_nr_irqs_gsi(void)
3591 {
3592         return nr_irqs_gsi;
3593 }
3594
3595 #ifdef CONFIG_SPARSE_IRQ
3596 int __init arch_probe_nr_irqs(void)
3597 {
3598         int nr;
3599
3600         if (nr_irqs > (NR_VECTORS * nr_cpu_ids))
3601                 nr_irqs = NR_VECTORS * nr_cpu_ids;
3602
3603         nr = nr_irqs_gsi + 8 * nr_cpu_ids;
3604 #if defined(CONFIG_PCI_MSI) || defined(CONFIG_HT_IRQ)
3605         /*
3606          * for MSI and HT dyn irq
3607          */
3608         nr += nr_irqs_gsi * 16;
3609 #endif
3610         if (nr < nr_irqs)
3611                 nr_irqs = nr;
3612
3613         return NR_IRQS_LEGACY;
3614 }
3615 #endif
3616
3617 int io_apic_set_pci_routing(struct device *dev, int irq,
3618                             struct io_apic_irq_attr *irq_attr)
3619 {
3620         int node;
3621
3622         if (!IO_APIC_IRQ(irq)) {
3623                 apic_printk(APIC_QUIET,KERN_ERR "IOAPIC[%d]: Invalid reference to IRQ 0\n",
3624                             irq_attr->ioapic);
3625                 return -EINVAL;
3626         }
3627
3628         node = dev ? dev_to_node(dev) : cpu_to_node(0);
3629
3630         return io_apic_setup_irq_pin_once(irq, node, irq_attr);
3631 }
3632
3633 #ifdef CONFIG_X86_32
3634 static int __init io_apic_get_unique_id(int ioapic, int apic_id)
3635 {
3636         union IO_APIC_reg_00 reg_00;
3637         static physid_mask_t apic_id_map = PHYSID_MASK_NONE;
3638         physid_mask_t tmp;
3639         unsigned long flags;
3640         int i = 0;
3641
3642         /*
3643          * The P4 platform supports up to 256 APIC IDs on two separate APIC
3644          * buses (one for LAPICs, one for IOAPICs), where predecessors only
3645          * supports up to 16 on one shared APIC bus.
3646          *
3647          * TBD: Expand LAPIC/IOAPIC support on P4-class systems to take full
3648          *      advantage of new APIC bus architecture.
3649          */
3650
3651         if (physids_empty(apic_id_map))
3652                 apic->ioapic_phys_id_map(&phys_cpu_present_map, &apic_id_map);
3653
3654         raw_spin_lock_irqsave(&ioapic_lock, flags);
3655         reg_00.raw = io_apic_read(ioapic, 0);
3656         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
3657
3658         if (apic_id >= get_physical_broadcast()) {
3659                 printk(KERN_WARNING "IOAPIC[%d]: Invalid apic_id %d, trying "
3660                         "%d\n", ioapic, apic_id, reg_00.bits.ID);
3661                 apic_id = reg_00.bits.ID;
3662         }
3663
3664         /*
3665          * Every APIC in a system must have a unique ID or we get lots of nice
3666          * 'stuck on smp_invalidate_needed IPI wait' messages.
3667          */
3668         if (apic->check_apicid_used(&apic_id_map, apic_id)) {
3669
3670                 for (i = 0; i < get_physical_broadcast(); i++) {
3671                         if (!apic->check_apicid_used(&apic_id_map, i))
3672                                 break;
3673                 }
3674
3675                 if (i == get_physical_broadcast())
3676                         panic("Max apic_id exceeded!\n");
3677
3678                 printk(KERN_WARNING "IOAPIC[%d]: apic_id %d already used, "
3679                         "trying %d\n", ioapic, apic_id, i);
3680
3681                 apic_id = i;
3682         }
3683
3684         apic->apicid_to_cpu_present(apic_id, &tmp);
3685         physids_or(apic_id_map, apic_id_map, tmp);
3686
3687         if (reg_00.bits.ID != apic_id) {
3688                 reg_00.bits.ID = apic_id;
3689
3690                 raw_spin_lock_irqsave(&ioapic_lock, flags);
3691                 io_apic_write(ioapic, 0, reg_00.raw);
3692                 reg_00.raw = io_apic_read(ioapic, 0);
3693                 raw_spin_unlock_irqrestore(&ioapic_lock, flags);
3694
3695                 /* Sanity check */
3696                 if (reg_00.bits.ID != apic_id) {
3697                         printk("IOAPIC[%d]: Unable to change apic_id!\n", ioapic);
3698                         return -1;
3699                 }
3700         }
3701
3702         apic_printk(APIC_VERBOSE, KERN_INFO
3703                         "IOAPIC[%d]: Assigned apic_id %d\n", ioapic, apic_id);
3704
3705         return apic_id;
3706 }
3707
3708 static u8 __init io_apic_unique_id(u8 id)
3709 {
3710         if ((boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) &&
3711             !APIC_XAPIC(apic_version[boot_cpu_physical_apicid]))
3712                 return io_apic_get_unique_id(nr_ioapics, id);
3713         else
3714                 return id;
3715 }
3716 #else
3717 static u8 __init io_apic_unique_id(u8 id)
3718 {
3719         int i;
3720         DECLARE_BITMAP(used, 256);
3721
3722         bitmap_zero(used, 256);
3723         for (i = 0; i < nr_ioapics; i++) {
3724                 __set_bit(mpc_ioapic_id(i), used);
3725         }
3726         if (!test_bit(id, used))
3727                 return id;
3728         return find_first_zero_bit(used, 256);
3729 }
3730 #endif
3731
3732 static int __init io_apic_get_version(int ioapic)
3733 {
3734         union IO_APIC_reg_01    reg_01;
3735         unsigned long flags;
3736
3737         raw_spin_lock_irqsave(&ioapic_lock, flags);
3738         reg_01.raw = io_apic_read(ioapic, 1);
3739         raw_spin_unlock_irqrestore(&ioapic_lock, flags);
3740
3741         return reg_01.bits.version;
3742 }
3743
3744 int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity)
3745 {
3746         int ioapic, pin, idx;
3747
3748         if (skip_ioapic_setup)
3749                 return -1;
3750
3751         ioapic = mp_find_ioapic(gsi);
3752         if (ioapic < 0)
3753                 return -1;
3754
3755         pin = mp_find_ioapic_pin(ioapic, gsi);
3756         if (pin < 0)
3757                 return -1;
3758
3759         idx = find_irq_entry(ioapic, pin, mp_INT);
3760         if (idx < 0)
3761                 return -1;
3762
3763         *trigger = irq_trigger(idx);
3764         *polarity = irq_polarity(idx);
3765         return 0;
3766 }
3767
3768 /*
3769  * This function currently is only a helper for the i386 smp boot process where
3770  * we need to reprogram the ioredtbls to cater for the cpus which have come online
3771  * so mask in all cases should simply be apic->target_cpus()
3772  */
3773 #ifdef CONFIG_SMP
3774 void __init setup_ioapic_dest(void)
3775 {
3776         int pin, ioapic, irq, irq_entry;
3777         const struct cpumask *mask;
3778         struct irq_data *idata;
3779
3780         if (skip_ioapic_setup == 1)
3781                 return;
3782
3783         for (ioapic = 0; ioapic < nr_ioapics; ioapic++)
3784         for (pin = 0; pin < ioapics[ioapic].nr_registers; pin++) {
3785                 irq_entry = find_irq_entry(ioapic, pin, mp_INT);
3786                 if (irq_entry == -1)
3787                         continue;
3788                 irq = pin_2_irq(irq_entry, ioapic, pin);
3789
3790                 if ((ioapic > 0) && (irq > 16))
3791                         continue;
3792
3793                 idata = irq_get_irq_data(irq);
3794
3795                 /*
3796                  * Honour affinities which have been set in early boot
3797                  */
3798                 if (!irqd_can_balance(idata) || irqd_affinity_was_set(idata))
3799                         mask = idata->affinity;
3800                 else
3801                         mask = apic->target_cpus();
3802
3803                 if (intr_remapping_enabled)
3804                         ir_ioapic_set_affinity(idata, mask, false);
3805                 else
3806                         ioapic_set_affinity(idata, mask, false);
3807         }
3808
3809 }
3810 #endif
3811
3812 #define IOAPIC_RESOURCE_NAME_SIZE 11
3813
3814 static struct resource *ioapic_resources;
3815
3816 static struct resource * __init ioapic_setup_resources(int nr_ioapics)
3817 {
3818         unsigned long n;
3819         struct resource *res;
3820         char *mem;
3821         int i;
3822
3823         if (nr_ioapics <= 0)
3824                 return NULL;
3825
3826         n = IOAPIC_RESOURCE_NAME_SIZE + sizeof(struct resource);
3827         n *= nr_ioapics;
3828
3829         mem = alloc_bootmem(n);
3830         res = (void *)mem;
3831
3832         mem += sizeof(struct resource) * nr_ioapics;
3833
3834         for (i = 0; i < nr_ioapics; i++) {
3835                 res[i].name = mem;
3836                 res[i].flags = IORESOURCE_MEM | IORESOURCE_BUSY;
3837                 snprintf(mem, IOAPIC_RESOURCE_NAME_SIZE, "IOAPIC %u", i);
3838                 mem += IOAPIC_RESOURCE_NAME_SIZE;
3839         }
3840
3841         ioapic_resources = res;
3842
3843         return res;
3844 }
3845
3846 void __init ioapic_and_gsi_init(void)
3847 {
3848         unsigned long ioapic_phys, idx = FIX_IO_APIC_BASE_0;
3849         struct resource *ioapic_res;
3850         int i;
3851
3852         ioapic_res = ioapic_setup_resources(nr_ioapics);
3853         for (i = 0; i < nr_ioapics; i++) {
3854                 if (smp_found_config) {
3855                         ioapic_phys = mpc_ioapic_addr(i);
3856 #ifdef CONFIG_X86_32
3857                         if (!ioapic_phys) {
3858                                 printk(KERN_ERR
3859                                        "WARNING: bogus zero IO-APIC "
3860                                        "address found in MPTABLE, "
3861                                        "disabling IO/APIC support!\n");
3862                                 smp_found_config = 0;
3863                                 skip_ioapic_setup = 1;
3864                                 goto fake_ioapic_page;
3865                         }
3866 #endif
3867                 } else {
3868 #ifdef CONFIG_X86_32
3869 fake_ioapic_page:
3870 #endif
3871                         ioapic_phys = (unsigned long)alloc_bootmem_pages(PAGE_SIZE);
3872                         ioapic_phys = __pa(ioapic_phys);
3873                 }
3874                 set_fixmap_nocache(idx, ioapic_phys);
3875                 apic_printk(APIC_VERBOSE, "mapped IOAPIC to %08lx (%08lx)\n",
3876                         __fix_to_virt(idx) + (ioapic_phys & ~PAGE_MASK),
3877                         ioapic_phys);
3878                 idx++;
3879
3880                 ioapic_res->start = ioapic_phys;
3881                 ioapic_res->end = ioapic_phys + IO_APIC_SLOT_SIZE - 1;
3882                 ioapic_res++;
3883         }
3884
3885         probe_nr_irqs_gsi();
3886 }
3887
3888 void __init ioapic_insert_resources(void)
3889 {
3890         int i;
3891         struct resource *r = ioapic_resources;
3892
3893         if (!r) {
3894                 if (nr_ioapics > 0)
3895                         printk(KERN_ERR
3896                                 "IO APIC resources couldn't be allocated.\n");
3897                 return;
3898         }
3899
3900         for (i = 0; i < nr_ioapics; i++) {
3901                 insert_resource(&iomem_resource, r);
3902                 r++;
3903         }
3904 }
3905
3906 int mp_find_ioapic(u32 gsi)
3907 {
3908         int i = 0;
3909
3910         if (nr_ioapics == 0)
3911                 return -1;
3912
3913         /* Find the IOAPIC that manages this GSI. */
3914         for (i = 0; i < nr_ioapics; i++) {
3915                 struct mp_ioapic_gsi *gsi_cfg = mp_ioapic_gsi_routing(i);
3916                 if ((gsi >= gsi_cfg->gsi_base)
3917                     && (gsi <= gsi_cfg->gsi_end))
3918                         return i;
3919         }
3920
3921         printk(KERN_ERR "ERROR: Unable to locate IOAPIC for GSI %d\n", gsi);
3922         return -1;
3923 }
3924
3925 int mp_find_ioapic_pin(int ioapic, u32 gsi)
3926 {
3927         struct mp_ioapic_gsi *gsi_cfg;
3928
3929         if (WARN_ON(ioapic == -1))
3930                 return -1;
3931
3932         gsi_cfg = mp_ioapic_gsi_routing(ioapic);
3933         if (WARN_ON(gsi > gsi_cfg->gsi_end))
3934                 return -1;
3935
3936         return gsi - gsi_cfg->gsi_base;
3937 }
3938
3939 static __init int bad_ioapic(unsigned long address)
3940 {
3941         if (nr_ioapics >= MAX_IO_APICS) {
3942                 printk(KERN_WARNING "WARNING: Max # of I/O APICs (%d) exceeded "
3943                        "(found %d), skipping\n", MAX_IO_APICS, nr_ioapics);
3944                 return 1;
3945         }
3946         if (!address) {
3947                 printk(KERN_WARNING "WARNING: Bogus (zero) I/O APIC address"
3948                        " found in table, skipping!\n");
3949                 return 1;
3950         }
3951         return 0;
3952 }
3953
3954 void __init mp_register_ioapic(int id, u32 address, u32 gsi_base)
3955 {
3956         int idx = 0;
3957         int entries;
3958         struct mp_ioapic_gsi *gsi_cfg;
3959
3960         if (bad_ioapic(address))
3961                 return;
3962
3963         idx = nr_ioapics;
3964
3965         ioapics[idx].mp_config.type = MP_IOAPIC;
3966         ioapics[idx].mp_config.flags = MPC_APIC_USABLE;
3967         ioapics[idx].mp_config.apicaddr = address;
3968
3969         set_fixmap_nocache(FIX_IO_APIC_BASE_0 + idx, address);
3970         ioapics[idx].mp_config.apicid = io_apic_unique_id(id);
3971         ioapics[idx].mp_config.apicver = io_apic_get_version(idx);
3972
3973         /*
3974          * Build basic GSI lookup table to facilitate gsi->io_apic lookups
3975          * and to prevent reprogramming of IOAPIC pins (PCI GSIs).
3976          */
3977         entries = io_apic_get_redir_entries(idx);
3978         gsi_cfg = mp_ioapic_gsi_routing(idx);
3979         gsi_cfg->gsi_base = gsi_base;
3980         gsi_cfg->gsi_end = gsi_base + entries - 1;
3981
3982         /*
3983          * The number of IO-APIC IRQ registers (== #pins):
3984          */
3985         ioapics[idx].nr_registers = entries;
3986
3987         if (gsi_cfg->gsi_end >= gsi_top)
3988                 gsi_top = gsi_cfg->gsi_end + 1;
3989
3990         printk(KERN_INFO "IOAPIC[%d]: apic_id %d, version %d, address 0x%x, "
3991                "GSI %d-%d\n", idx, mpc_ioapic_id(idx),
3992                mpc_ioapic_ver(idx), mpc_ioapic_addr(idx),
3993                gsi_cfg->gsi_base, gsi_cfg->gsi_end);
3994
3995         nr_ioapics++;
3996 }
3997
3998 /* Enable IOAPIC early just for system timer */
3999 void __init pre_init_apic_IRQ0(void)
4000 {
4001         struct io_apic_irq_attr attr = { 0, 0, 0, 0 };
4002
4003         printk(KERN_INFO "Early APIC setup for system timer0\n");
4004 #ifndef CONFIG_SMP
4005         physid_set_mask_of_physid(boot_cpu_physical_apicid,
4006                                          &phys_cpu_present_map);
4007 #endif
4008         setup_local_APIC();
4009
4010         io_apic_setup_irq_pin(0, 0, &attr);
4011         irq_set_chip_and_handler_name(0, &ioapic_chip, handle_edge_irq,
4012                                       "edge");
4013 }