arch/x86/kernel/apic/io_apic.c

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