Pileus Git - ~andy/linux/blob - arch/x86/kernel/apic/io_apic.c

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