1 /* 2 * boot.c - Architecture-Specific Low-Level ACPI Boot Support 3 * 4 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 5 * Copyright (C) 2001 Jun Nakajima <jun.nakajima@intel.com> 6 * 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 * 23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 24 */ 25 26 #include <linux/init.h> 27 #include <linux/acpi.h> 28 #include <linux/acpi_pmtmr.h> 29 #include <linux/efi.h> 30 #include <linux/cpumask.h> 31 #include <linux/export.h> 32 #include <linux/dmi.h> 33 #include <linux/irq.h> 34 #include <linux/slab.h> 35 #include <linux/bootmem.h> 36 #include <linux/ioport.h> 37 #include <linux/pci.h> 38 39 #include <asm/irqdomain.h> 40 #include <asm/pci_x86.h> 41 #include <asm/pgtable.h> 42 #include <asm/io_apic.h> 43 #include <asm/apic.h> 44 #include <asm/io.h> 45 #include <asm/mpspec.h> 46 #include <asm/smp.h> 47 #include <asm/i8259.h> 48 49 #include "sleep.h" /* To include x86_acpi_suspend_lowlevel */ 50 static int __initdata acpi_force = 0; 51 int acpi_disabled; 52 EXPORT_SYMBOL(acpi_disabled); 53 54 #ifdef CONFIG_X86_64 55 # include <asm/proto.h> 56 #endif /* X86 */ 57 58 #define PREFIX "ACPI: " 59 60 int acpi_noirq; /* skip ACPI IRQ initialization */ 61 int acpi_pci_disabled; /* skip ACPI PCI scan and IRQ initialization */ 62 EXPORT_SYMBOL(acpi_pci_disabled); 63 64 int acpi_lapic; 65 int acpi_ioapic; 66 int acpi_strict; 67 int acpi_disable_cmcff; 68 69 u8 acpi_sci_flags __initdata; 70 int acpi_sci_override_gsi __initdata; 71 int acpi_skip_timer_override __initdata; 72 int acpi_use_timer_override __initdata; 73 int acpi_fix_pin2_polarity __initdata; 74 75 #ifdef CONFIG_X86_LOCAL_APIC 76 static u64 acpi_lapic_addr __initdata = APIC_DEFAULT_PHYS_BASE; 77 #endif 78 79 /* 80 * Locks related to IOAPIC hotplug 81 * Hotplug side: 82 * ->device_hotplug_lock 83 * ->acpi_ioapic_lock 84 * ->ioapic_lock 85 * Interrupt mapping side: 86 * ->acpi_ioapic_lock 87 * ->ioapic_mutex 88 * ->ioapic_lock 89 */ 90 static DEFINE_MUTEX(acpi_ioapic_lock); 91 92 /* -------------------------------------------------------------------------- 93 Boot-time Configuration 94 -------------------------------------------------------------------------- */ 95 96 /* 97 * The default interrupt routing model is PIC (8259). This gets 98 * overridden if IOAPICs are enumerated (below). 99 */ 100 enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_PIC; 101 102 103 /* 104 * ISA irqs by default are the first 16 gsis but can be 105 * any gsi as specified by an interrupt source override. 106 */ 107 static u32 isa_irq_to_gsi[NR_IRQS_LEGACY] __read_mostly = { 108 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 109 }; 110 111 #define ACPI_INVALID_GSI INT_MIN 112 113 /* 114 * This is just a simple wrapper around early_ioremap(), 115 * with sanity checks for phys == 0 and size == 0. 116 */ 117 char *__init __acpi_map_table(unsigned long phys, unsigned long size) 118 { 119 120 if (!phys || !size) 121 return NULL; 122 123 return early_ioremap(phys, size); 124 } 125 126 void __init __acpi_unmap_table(char *map, unsigned long size) 127 { 128 if (!map || !size) 129 return; 130 131 early_iounmap(map, size); 132 } 133 134 #ifdef CONFIG_X86_LOCAL_APIC 135 static int __init acpi_parse_madt(struct acpi_table_header *table) 136 { 137 struct acpi_table_madt *madt = NULL; 138 139 if (!boot_cpu_has(X86_FEATURE_APIC)) 140 return -EINVAL; 141 142 madt = (struct acpi_table_madt *)table; 143 if (!madt) { 144 printk(KERN_WARNING PREFIX "Unable to map MADT\n"); 145 return -ENODEV; 146 } 147 148 if (madt->address) { 149 acpi_lapic_addr = (u64) madt->address; 150 151 printk(KERN_DEBUG PREFIX "Local APIC address 0x%08x\n", 152 madt->address); 153 } 154 155 default_acpi_madt_oem_check(madt->header.oem_id, 156 madt->header.oem_table_id); 157 158 return 0; 159 } 160 161 /** 162 * acpi_register_lapic - register a local apic and generates a logic cpu number 163 * @id: local apic id to register 164 * @acpiid: ACPI id to register 165 * @enabled: this cpu is enabled or not 166 * 167 * Returns the logic cpu number which maps to the local apic 168 */ 169 static int acpi_register_lapic(int id, u32 acpiid, u8 enabled) 170 { 171 unsigned int ver = 0; 172 int cpu; 173 174 if (id >= MAX_LOCAL_APIC) { 175 printk(KERN_INFO PREFIX "skipped apicid that is too big\n"); 176 return -EINVAL; 177 } 178 179 if (!enabled) { 180 ++disabled_cpus; 181 return -EINVAL; 182 } 183 184 if (boot_cpu_physical_apicid != -1U) 185 ver = apic_version[boot_cpu_physical_apicid]; 186 187 cpu = generic_processor_info(id, ver); 188 if (cpu >= 0) 189 early_per_cpu(x86_cpu_to_acpiid, cpu) = acpiid; 190 191 return cpu; 192 } 193 194 static int __init 195 acpi_parse_x2apic(struct acpi_subtable_header *header, const unsigned long end) 196 { 197 struct acpi_madt_local_x2apic *processor = NULL; 198 int apic_id; 199 u8 enabled; 200 201 processor = (struct acpi_madt_local_x2apic *)header; 202 203 if (BAD_MADT_ENTRY(processor, end)) 204 return -EINVAL; 205 206 acpi_table_print_madt_entry(header); 207 208 apic_id = processor->local_apic_id; 209 enabled = processor->lapic_flags & ACPI_MADT_ENABLED; 210 #ifdef CONFIG_X86_X2APIC 211 /* 212 * We need to register disabled CPU as well to permit 213 * counting disabled CPUs. This allows us to size 214 * cpus_possible_map more accurately, to permit 215 * to not preallocating memory for all NR_CPUS 216 * when we use CPU hotplug. 217 */ 218 if (!apic->apic_id_valid(apic_id) && enabled) 219 printk(KERN_WARNING PREFIX "x2apic entry ignored\n"); 220 else 221 acpi_register_lapic(apic_id, processor->uid, enabled); 222 #else 223 printk(KERN_WARNING PREFIX "x2apic entry ignored\n"); 224 #endif 225 226 return 0; 227 } 228 229 static int __init 230 acpi_parse_lapic(struct acpi_subtable_header * header, const unsigned long end) 231 { 232 struct acpi_madt_local_apic *processor = NULL; 233 234 processor = (struct acpi_madt_local_apic *)header; 235 236 if (BAD_MADT_ENTRY(processor, end)) 237 return -EINVAL; 238 239 acpi_table_print_madt_entry(header); 240 241 /* 242 * We need to register disabled CPU as well to permit 243 * counting disabled CPUs. This allows us to size 244 * cpus_possible_map more accurately, to permit 245 * to not preallocating memory for all NR_CPUS 246 * when we use CPU hotplug. 247 */ 248 acpi_register_lapic(processor->id, /* APIC ID */ 249 processor->processor_id, /* ACPI ID */ 250 processor->lapic_flags & ACPI_MADT_ENABLED); 251 252 return 0; 253 } 254 255 static int __init 256 acpi_parse_sapic(struct acpi_subtable_header *header, const unsigned long end) 257 { 258 struct acpi_madt_local_sapic *processor = NULL; 259 260 processor = (struct acpi_madt_local_sapic *)header; 261 262 if (BAD_MADT_ENTRY(processor, end)) 263 return -EINVAL; 264 265 acpi_table_print_madt_entry(header); 266 267 acpi_register_lapic((processor->id << 8) | processor->eid,/* APIC ID */ 268 processor->processor_id, /* ACPI ID */ 269 processor->lapic_flags & ACPI_MADT_ENABLED); 270 271 return 0; 272 } 273 274 static int __init 275 acpi_parse_lapic_addr_ovr(struct acpi_subtable_header * header, 276 const unsigned long end) 277 { 278 struct acpi_madt_local_apic_override *lapic_addr_ovr = NULL; 279 280 lapic_addr_ovr = (struct acpi_madt_local_apic_override *)header; 281 282 if (BAD_MADT_ENTRY(lapic_addr_ovr, end)) 283 return -EINVAL; 284 285 acpi_lapic_addr = lapic_addr_ovr->address; 286 287 return 0; 288 } 289 290 static int __init 291 acpi_parse_x2apic_nmi(struct acpi_subtable_header *header, 292 const unsigned long end) 293 { 294 struct acpi_madt_local_x2apic_nmi *x2apic_nmi = NULL; 295 296 x2apic_nmi = (struct acpi_madt_local_x2apic_nmi *)header; 297 298 if (BAD_MADT_ENTRY(x2apic_nmi, end)) 299 return -EINVAL; 300 301 acpi_table_print_madt_entry(header); 302 303 if (x2apic_nmi->lint != 1) 304 printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n"); 305 306 return 0; 307 } 308 309 static int __init 310 acpi_parse_lapic_nmi(struct acpi_subtable_header * header, const unsigned long end) 311 { 312 struct acpi_madt_local_apic_nmi *lapic_nmi = NULL; 313 314 lapic_nmi = (struct acpi_madt_local_apic_nmi *)header; 315 316 if (BAD_MADT_ENTRY(lapic_nmi, end)) 317 return -EINVAL; 318 319 acpi_table_print_madt_entry(header); 320 321 if (lapic_nmi->lint != 1) 322 printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n"); 323 324 return 0; 325 } 326 327 #endif /*CONFIG_X86_LOCAL_APIC */ 328 329 #ifdef CONFIG_X86_IO_APIC 330 #define MP_ISA_BUS 0 331 332 static void __init mp_override_legacy_irq(u8 bus_irq, u8 polarity, u8 trigger, 333 u32 gsi) 334 { 335 int ioapic; 336 int pin; 337 struct mpc_intsrc mp_irq; 338 339 /* 340 * Convert 'gsi' to 'ioapic.pin'. 341 */ 342 ioapic = mp_find_ioapic(gsi); 343 if (ioapic < 0) 344 return; 345 pin = mp_find_ioapic_pin(ioapic, gsi); 346 347 /* 348 * TBD: This check is for faulty timer entries, where the override 349 * erroneously sets the trigger to level, resulting in a HUGE 350 * increase of timer interrupts! 351 */ 352 if ((bus_irq == 0) && (trigger == 3)) 353 trigger = 1; 354 355 mp_irq.type = MP_INTSRC; 356 mp_irq.irqtype = mp_INT; 357 mp_irq.irqflag = (trigger << 2) | polarity; 358 mp_irq.srcbus = MP_ISA_BUS; 359 mp_irq.srcbusirq = bus_irq; /* IRQ */ 360 mp_irq.dstapic = mpc_ioapic_id(ioapic); /* APIC ID */ 361 mp_irq.dstirq = pin; /* INTIN# */ 362 363 mp_save_irq(&mp_irq); 364 365 /* 366 * Reset default identity mapping if gsi is also an legacy IRQ, 367 * otherwise there will be more than one entry with the same GSI 368 * and acpi_isa_irq_to_gsi() may give wrong result. 369 */ 370 if (gsi < nr_legacy_irqs() && isa_irq_to_gsi[gsi] == gsi) 371 isa_irq_to_gsi[gsi] = ACPI_INVALID_GSI; 372 isa_irq_to_gsi[bus_irq] = gsi; 373 } 374 375 static int mp_config_acpi_gsi(struct device *dev, u32 gsi, int trigger, 376 int polarity) 377 { 378 #ifdef CONFIG_X86_MPPARSE 379 struct mpc_intsrc mp_irq; 380 struct pci_dev *pdev; 381 unsigned char number; 382 unsigned int devfn; 383 int ioapic; 384 u8 pin; 385 386 if (!acpi_ioapic) 387 return 0; 388 if (!dev || !dev_is_pci(dev)) 389 return 0; 390 391 pdev = to_pci_dev(dev); 392 number = pdev->bus->number; 393 devfn = pdev->devfn; 394 pin = pdev->pin; 395 /* print the entry should happen on mptable identically */ 396 mp_irq.type = MP_INTSRC; 397 mp_irq.irqtype = mp_INT; 398 mp_irq.irqflag = (trigger == ACPI_EDGE_SENSITIVE ? 4 : 0x0c) | 399 (polarity == ACPI_ACTIVE_HIGH ? 1 : 3); 400 mp_irq.srcbus = number; 401 mp_irq.srcbusirq = (((devfn >> 3) & 0x1f) << 2) | ((pin - 1) & 3); 402 ioapic = mp_find_ioapic(gsi); 403 mp_irq.dstapic = mpc_ioapic_id(ioapic); 404 mp_irq.dstirq = mp_find_ioapic_pin(ioapic, gsi); 405 406 mp_save_irq(&mp_irq); 407 #endif 408 return 0; 409 } 410 411 static int __init 412 acpi_parse_ioapic(struct acpi_subtable_header * header, const unsigned long end) 413 { 414 struct acpi_madt_io_apic *ioapic = NULL; 415 struct ioapic_domain_cfg cfg = { 416 .type = IOAPIC_DOMAIN_DYNAMIC, 417 .ops = &mp_ioapic_irqdomain_ops, 418 }; 419 420 ioapic = (struct acpi_madt_io_apic *)header; 421 422 if (BAD_MADT_ENTRY(ioapic, end)) 423 return -EINVAL; 424 425 acpi_table_print_madt_entry(header); 426 427 /* Statically assign IRQ numbers for IOAPICs hosting legacy IRQs */ 428 if (ioapic->global_irq_base < nr_legacy_irqs()) 429 cfg.type = IOAPIC_DOMAIN_LEGACY; 430 431 mp_register_ioapic(ioapic->id, ioapic->address, ioapic->global_irq_base, 432 &cfg); 433 434 return 0; 435 } 436 437 /* 438 * Parse Interrupt Source Override for the ACPI SCI 439 */ 440 static void __init acpi_sci_ioapic_setup(u8 bus_irq, u16 polarity, u16 trigger, u32 gsi) 441 { 442 if (trigger == 0) /* compatible SCI trigger is level */ 443 trigger = 3; 444 445 if (polarity == 0) /* compatible SCI polarity is low */ 446 polarity = 3; 447 448 /* Command-line over-ride via acpi_sci= */ 449 if (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) 450 trigger = (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2; 451 452 if (acpi_sci_flags & ACPI_MADT_POLARITY_MASK) 453 polarity = acpi_sci_flags & ACPI_MADT_POLARITY_MASK; 454 455 mp_override_legacy_irq(bus_irq, polarity, trigger, gsi); 456 457 /* 458 * stash over-ride to indicate we've been here 459 * and for later update of acpi_gbl_FADT 460 */ 461 acpi_sci_override_gsi = gsi; 462 return; 463 } 464 465 static int __init 466 acpi_parse_int_src_ovr(struct acpi_subtable_header * header, 467 const unsigned long end) 468 { 469 struct acpi_madt_interrupt_override *intsrc = NULL; 470 471 intsrc = (struct acpi_madt_interrupt_override *)header; 472 473 if (BAD_MADT_ENTRY(intsrc, end)) 474 return -EINVAL; 475 476 acpi_table_print_madt_entry(header); 477 478 if (intsrc->source_irq == acpi_gbl_FADT.sci_interrupt) { 479 acpi_sci_ioapic_setup(intsrc->source_irq, 480 intsrc->inti_flags & ACPI_MADT_POLARITY_MASK, 481 (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2, 482 intsrc->global_irq); 483 return 0; 484 } 485 486 if (intsrc->source_irq == 0) { 487 if (acpi_skip_timer_override) { 488 printk(PREFIX "BIOS IRQ0 override ignored.\n"); 489 return 0; 490 } 491 492 if ((intsrc->global_irq == 2) && acpi_fix_pin2_polarity 493 && (intsrc->inti_flags & ACPI_MADT_POLARITY_MASK)) { 494 intsrc->inti_flags &= ~ACPI_MADT_POLARITY_MASK; 495 printk(PREFIX "BIOS IRQ0 pin2 override: forcing polarity to high active.\n"); 496 } 497 } 498 499 mp_override_legacy_irq(intsrc->source_irq, 500 intsrc->inti_flags & ACPI_MADT_POLARITY_MASK, 501 (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2, 502 intsrc->global_irq); 503 504 return 0; 505 } 506 507 static int __init 508 acpi_parse_nmi_src(struct acpi_subtable_header * header, const unsigned long end) 509 { 510 struct acpi_madt_nmi_source *nmi_src = NULL; 511 512 nmi_src = (struct acpi_madt_nmi_source *)header; 513 514 if (BAD_MADT_ENTRY(nmi_src, end)) 515 return -EINVAL; 516 517 acpi_table_print_madt_entry(header); 518 519 /* TBD: Support nimsrc entries? */ 520 521 return 0; 522 } 523 524 #endif /* CONFIG_X86_IO_APIC */ 525 526 /* 527 * acpi_pic_sci_set_trigger() 528 * 529 * use ELCR to set PIC-mode trigger type for SCI 530 * 531 * If a PIC-mode SCI is not recognized or gives spurious IRQ7's 532 * it may require Edge Trigger -- use "acpi_sci=edge" 533 * 534 * Port 0x4d0-4d1 are ECLR1 and ECLR2, the Edge/Level Control Registers 535 * for the 8259 PIC. bit[n] = 1 means irq[n] is Level, otherwise Edge. 536 * ECLR1 is IRQs 0-7 (IRQ 0, 1, 2 must be 0) 537 * ECLR2 is IRQs 8-15 (IRQ 8, 13 must be 0) 538 */ 539 540 void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger) 541 { 542 unsigned int mask = 1 << irq; 543 unsigned int old, new; 544 545 /* Real old ELCR mask */ 546 old = inb(0x4d0) | (inb(0x4d1) << 8); 547 548 /* 549 * If we use ACPI to set PCI IRQs, then we should clear ELCR 550 * since we will set it correctly as we enable the PCI irq 551 * routing. 552 */ 553 new = acpi_noirq ? old : 0; 554 555 /* 556 * Update SCI information in the ELCR, it isn't in the PCI 557 * routing tables.. 558 */ 559 switch (trigger) { 560 case 1: /* Edge - clear */ 561 new &= ~mask; 562 break; 563 case 3: /* Level - set */ 564 new |= mask; 565 break; 566 } 567 568 if (old == new) 569 return; 570 571 printk(PREFIX "setting ELCR to %04x (from %04x)\n", new, old); 572 outb(new, 0x4d0); 573 outb(new >> 8, 0x4d1); 574 } 575 576 int acpi_gsi_to_irq(u32 gsi, unsigned int *irqp) 577 { 578 int rc, irq, trigger, polarity; 579 580 if (acpi_irq_model == ACPI_IRQ_MODEL_PIC) { 581 *irqp = gsi; 582 return 0; 583 } 584 585 rc = acpi_get_override_irq(gsi, &trigger, &polarity); 586 if (rc == 0) { 587 trigger = trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE; 588 polarity = polarity ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH; 589 irq = acpi_register_gsi(NULL, gsi, trigger, polarity); 590 if (irq >= 0) { 591 *irqp = irq; 592 return 0; 593 } 594 } 595 596 return -1; 597 } 598 EXPORT_SYMBOL_GPL(acpi_gsi_to_irq); 599 600 int acpi_isa_irq_to_gsi(unsigned isa_irq, u32 *gsi) 601 { 602 if (isa_irq < nr_legacy_irqs() && 603 isa_irq_to_gsi[isa_irq] != ACPI_INVALID_GSI) { 604 *gsi = isa_irq_to_gsi[isa_irq]; 605 return 0; 606 } 607 608 return -1; 609 } 610 611 static int acpi_register_gsi_pic(struct device *dev, u32 gsi, 612 int trigger, int polarity) 613 { 614 #ifdef CONFIG_PCI 615 /* 616 * Make sure all (legacy) PCI IRQs are set as level-triggered. 617 */ 618 if (trigger == ACPI_LEVEL_SENSITIVE) 619 elcr_set_level_irq(gsi); 620 #endif 621 622 return gsi; 623 } 624 625 #ifdef CONFIG_X86_LOCAL_APIC 626 static int acpi_register_gsi_ioapic(struct device *dev, u32 gsi, 627 int trigger, int polarity) 628 { 629 int irq = gsi; 630 #ifdef CONFIG_X86_IO_APIC 631 int node; 632 struct irq_alloc_info info; 633 634 node = dev ? dev_to_node(dev) : NUMA_NO_NODE; 635 trigger = trigger == ACPI_EDGE_SENSITIVE ? 0 : 1; 636 polarity = polarity == ACPI_ACTIVE_HIGH ? 0 : 1; 637 ioapic_set_alloc_attr(&info, node, trigger, polarity); 638 639 mutex_lock(&acpi_ioapic_lock); 640 irq = mp_map_gsi_to_irq(gsi, IOAPIC_MAP_ALLOC, &info); 641 /* Don't set up the ACPI SCI because it's already set up */ 642 if (irq >= 0 && enable_update_mptable && 643 acpi_gbl_FADT.sci_interrupt != gsi) 644 mp_config_acpi_gsi(dev, gsi, trigger, polarity); 645 mutex_unlock(&acpi_ioapic_lock); 646 #endif 647 648 return irq; 649 } 650 651 static void acpi_unregister_gsi_ioapic(u32 gsi) 652 { 653 #ifdef CONFIG_X86_IO_APIC 654 int irq; 655 656 mutex_lock(&acpi_ioapic_lock); 657 irq = mp_map_gsi_to_irq(gsi, 0, NULL); 658 if (irq > 0) 659 mp_unmap_irq(irq); 660 mutex_unlock(&acpi_ioapic_lock); 661 #endif 662 } 663 #endif 664 665 int (*__acpi_register_gsi)(struct device *dev, u32 gsi, 666 int trigger, int polarity) = acpi_register_gsi_pic; 667 void (*__acpi_unregister_gsi)(u32 gsi) = NULL; 668 669 #ifdef CONFIG_ACPI_SLEEP 670 int (*acpi_suspend_lowlevel)(void) = x86_acpi_suspend_lowlevel; 671 #else 672 int (*acpi_suspend_lowlevel)(void); 673 #endif 674 675 /* 676 * success: return IRQ number (>=0) 677 * failure: return < 0 678 */ 679 int acpi_register_gsi(struct device *dev, u32 gsi, int trigger, int polarity) 680 { 681 return __acpi_register_gsi(dev, gsi, trigger, polarity); 682 } 683 EXPORT_SYMBOL_GPL(acpi_register_gsi); 684 685 void acpi_unregister_gsi(u32 gsi) 686 { 687 if (__acpi_unregister_gsi) 688 __acpi_unregister_gsi(gsi); 689 } 690 EXPORT_SYMBOL_GPL(acpi_unregister_gsi); 691 692 #ifdef CONFIG_X86_LOCAL_APIC 693 static void __init acpi_set_irq_model_ioapic(void) 694 { 695 acpi_irq_model = ACPI_IRQ_MODEL_IOAPIC; 696 __acpi_register_gsi = acpi_register_gsi_ioapic; 697 __acpi_unregister_gsi = acpi_unregister_gsi_ioapic; 698 acpi_ioapic = 1; 699 } 700 #endif 701 702 /* 703 * ACPI based hotplug support for CPU 704 */ 705 #ifdef CONFIG_ACPI_HOTPLUG_CPU 706 #include <acpi/processor.h> 707 708 static void acpi_map_cpu2node(acpi_handle handle, int cpu, int physid) 709 { 710 #ifdef CONFIG_ACPI_NUMA 711 int nid; 712 713 nid = acpi_get_node(handle); 714 if (nid != -1) { 715 set_apicid_to_node(physid, nid); 716 numa_set_node(cpu, nid); 717 } 718 #endif 719 } 720 721 int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, int *pcpu) 722 { 723 int cpu; 724 725 cpu = acpi_register_lapic(physid, U32_MAX, ACPI_MADT_ENABLED); 726 if (cpu < 0) { 727 pr_info(PREFIX "Unable to map lapic to logical cpu number\n"); 728 return cpu; 729 } 730 731 acpi_processor_set_pdc(handle); 732 acpi_map_cpu2node(handle, cpu, physid); 733 734 *pcpu = cpu; 735 return 0; 736 } 737 EXPORT_SYMBOL(acpi_map_cpu); 738 739 int acpi_unmap_cpu(int cpu) 740 { 741 #ifdef CONFIG_ACPI_NUMA 742 set_apicid_to_node(per_cpu(x86_cpu_to_apicid, cpu), NUMA_NO_NODE); 743 #endif 744 745 per_cpu(x86_cpu_to_apicid, cpu) = -1; 746 set_cpu_present(cpu, false); 747 num_processors--; 748 749 return (0); 750 } 751 EXPORT_SYMBOL(acpi_unmap_cpu); 752 #endif /* CONFIG_ACPI_HOTPLUG_CPU */ 753 754 int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base) 755 { 756 int ret = -ENOSYS; 757 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC 758 int ioapic_id; 759 u64 addr; 760 struct ioapic_domain_cfg cfg = { 761 .type = IOAPIC_DOMAIN_DYNAMIC, 762 .ops = &mp_ioapic_irqdomain_ops, 763 }; 764 765 ioapic_id = acpi_get_ioapic_id(handle, gsi_base, &addr); 766 if (ioapic_id < 0) { 767 unsigned long long uid; 768 acpi_status status; 769 770 status = acpi_evaluate_integer(handle, METHOD_NAME__UID, 771 NULL, &uid); 772 if (ACPI_FAILURE(status)) { 773 acpi_handle_warn(handle, "failed to get IOAPIC ID.\n"); 774 return -EINVAL; 775 } 776 ioapic_id = (int)uid; 777 } 778 779 mutex_lock(&acpi_ioapic_lock); 780 ret = mp_register_ioapic(ioapic_id, phys_addr, gsi_base, &cfg); 781 mutex_unlock(&acpi_ioapic_lock); 782 #endif 783 784 return ret; 785 } 786 EXPORT_SYMBOL(acpi_register_ioapic); 787 788 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base) 789 { 790 int ret = -ENOSYS; 791 792 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC 793 mutex_lock(&acpi_ioapic_lock); 794 ret = mp_unregister_ioapic(gsi_base); 795 mutex_unlock(&acpi_ioapic_lock); 796 #endif 797 798 return ret; 799 } 800 EXPORT_SYMBOL(acpi_unregister_ioapic); 801 802 /** 803 * acpi_ioapic_registered - Check whether IOAPIC assoicatied with @gsi_base 804 * has been registered 805 * @handle: ACPI handle of the IOAPIC deivce 806 * @gsi_base: GSI base associated with the IOAPIC 807 * 808 * Assume caller holds some type of lock to serialize acpi_ioapic_registered() 809 * with acpi_register_ioapic()/acpi_unregister_ioapic(). 810 */ 811 int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base) 812 { 813 int ret = 0; 814 815 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC 816 mutex_lock(&acpi_ioapic_lock); 817 ret = mp_ioapic_registered(gsi_base); 818 mutex_unlock(&acpi_ioapic_lock); 819 #endif 820 821 return ret; 822 } 823 824 static int __init acpi_parse_sbf(struct acpi_table_header *table) 825 { 826 struct acpi_table_boot *sb = (struct acpi_table_boot *)table; 827 828 sbf_port = sb->cmos_index; /* Save CMOS port */ 829 830 return 0; 831 } 832 833 #ifdef CONFIG_HPET_TIMER 834 #include <asm/hpet.h> 835 836 static struct resource *hpet_res __initdata; 837 838 static int __init acpi_parse_hpet(struct acpi_table_header *table) 839 { 840 struct acpi_table_hpet *hpet_tbl = (struct acpi_table_hpet *)table; 841 842 if (hpet_tbl->address.space_id != ACPI_SPACE_MEM) { 843 printk(KERN_WARNING PREFIX "HPET timers must be located in " 844 "memory.\n"); 845 return -1; 846 } 847 848 hpet_address = hpet_tbl->address.address; 849 hpet_blockid = hpet_tbl->sequence; 850 851 /* 852 * Some broken BIOSes advertise HPET at 0x0. We really do not 853 * want to allocate a resource there. 854 */ 855 if (!hpet_address) { 856 printk(KERN_WARNING PREFIX 857 "HPET id: %#x base: %#lx is invalid\n", 858 hpet_tbl->id, hpet_address); 859 return 0; 860 } 861 #ifdef CONFIG_X86_64 862 /* 863 * Some even more broken BIOSes advertise HPET at 864 * 0xfed0000000000000 instead of 0xfed00000. Fix it up and add 865 * some noise: 866 */ 867 if (hpet_address == 0xfed0000000000000UL) { 868 if (!hpet_force_user) { 869 printk(KERN_WARNING PREFIX "HPET id: %#x " 870 "base: 0xfed0000000000000 is bogus\n " 871 "try hpet=force on the kernel command line to " 872 "fix it up to 0xfed00000.\n", hpet_tbl->id); 873 hpet_address = 0; 874 return 0; 875 } 876 printk(KERN_WARNING PREFIX 877 "HPET id: %#x base: 0xfed0000000000000 fixed up " 878 "to 0xfed00000.\n", hpet_tbl->id); 879 hpet_address >>= 32; 880 } 881 #endif 882 printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n", 883 hpet_tbl->id, hpet_address); 884 885 /* 886 * Allocate and initialize the HPET firmware resource for adding into 887 * the resource tree during the lateinit timeframe. 888 */ 889 #define HPET_RESOURCE_NAME_SIZE 9 890 hpet_res = alloc_bootmem(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE); 891 892 hpet_res->name = (void *)&hpet_res[1]; 893 hpet_res->flags = IORESOURCE_MEM; 894 snprintf((char *)hpet_res->name, HPET_RESOURCE_NAME_SIZE, "HPET %u", 895 hpet_tbl->sequence); 896 897 hpet_res->start = hpet_address; 898 hpet_res->end = hpet_address + (1 * 1024) - 1; 899 900 return 0; 901 } 902 903 /* 904 * hpet_insert_resource inserts the HPET resources used into the resource 905 * tree. 906 */ 907 static __init int hpet_insert_resource(void) 908 { 909 if (!hpet_res) 910 return 1; 911 912 return insert_resource(&iomem_resource, hpet_res); 913 } 914 915 late_initcall(hpet_insert_resource); 916 917 #else 918 #define acpi_parse_hpet NULL 919 #endif 920 921 static int __init acpi_parse_fadt(struct acpi_table_header *table) 922 { 923 if (!(acpi_gbl_FADT.boot_flags & ACPI_FADT_LEGACY_DEVICES)) { 924 pr_debug("ACPI: no legacy devices present\n"); 925 x86_platform.legacy.devices.pnpbios = 0; 926 } 927 928 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_CMOS_RTC) { 929 pr_debug("ACPI: not registering RTC platform device\n"); 930 x86_platform.legacy.rtc = 0; 931 } 932 933 #ifdef CONFIG_X86_PM_TIMER 934 /* detect the location of the ACPI PM Timer */ 935 if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID) { 936 /* FADT rev. 2 */ 937 if (acpi_gbl_FADT.xpm_timer_block.space_id != 938 ACPI_ADR_SPACE_SYSTEM_IO) 939 return 0; 940 941 pmtmr_ioport = acpi_gbl_FADT.xpm_timer_block.address; 942 /* 943 * "X" fields are optional extensions to the original V1.0 944 * fields, so we must selectively expand V1.0 fields if the 945 * corresponding X field is zero. 946 */ 947 if (!pmtmr_ioport) 948 pmtmr_ioport = acpi_gbl_FADT.pm_timer_block; 949 } else { 950 /* FADT rev. 1 */ 951 pmtmr_ioport = acpi_gbl_FADT.pm_timer_block; 952 } 953 if (pmtmr_ioport) 954 printk(KERN_INFO PREFIX "PM-Timer IO Port: %#x\n", 955 pmtmr_ioport); 956 #endif 957 return 0; 958 } 959 960 #ifdef CONFIG_X86_LOCAL_APIC 961 /* 962 * Parse LAPIC entries in MADT 963 * returns 0 on success, < 0 on error 964 */ 965 966 static int __init early_acpi_parse_madt_lapic_addr_ovr(void) 967 { 968 int count; 969 970 if (!boot_cpu_has(X86_FEATURE_APIC)) 971 return -ENODEV; 972 973 /* 974 * Note that the LAPIC address is obtained from the MADT (32-bit value) 975 * and (optionally) overridden by a LAPIC_ADDR_OVR entry (64-bit value). 976 */ 977 978 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, 979 acpi_parse_lapic_addr_ovr, 0); 980 if (count < 0) { 981 printk(KERN_ERR PREFIX 982 "Error parsing LAPIC address override entry\n"); 983 return count; 984 } 985 986 register_lapic_address(acpi_lapic_addr); 987 988 return count; 989 } 990 991 static int __init acpi_parse_madt_lapic_entries(void) 992 { 993 int count; 994 int x2count = 0; 995 int ret; 996 struct acpi_subtable_proc madt_proc[2]; 997 998 if (!boot_cpu_has(X86_FEATURE_APIC)) 999 return -ENODEV; 1000 1001 /* 1002 * Note that the LAPIC address is obtained from the MADT (32-bit value) 1003 * and (optionally) overridden by a LAPIC_ADDR_OVR entry (64-bit value). 1004 */ 1005 1006 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, 1007 acpi_parse_lapic_addr_ovr, 0); 1008 if (count < 0) { 1009 printk(KERN_ERR PREFIX 1010 "Error parsing LAPIC address override entry\n"); 1011 return count; 1012 } 1013 1014 register_lapic_address(acpi_lapic_addr); 1015 1016 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_SAPIC, 1017 acpi_parse_sapic, MAX_LOCAL_APIC); 1018 1019 if (!count) { 1020 memset(madt_proc, 0, sizeof(madt_proc)); 1021 madt_proc[0].id = ACPI_MADT_TYPE_LOCAL_APIC; 1022 madt_proc[0].handler = acpi_parse_lapic; 1023 madt_proc[1].id = ACPI_MADT_TYPE_LOCAL_X2APIC; 1024 madt_proc[1].handler = acpi_parse_x2apic; 1025 ret = acpi_table_parse_entries_array(ACPI_SIG_MADT, 1026 sizeof(struct acpi_table_madt), 1027 madt_proc, ARRAY_SIZE(madt_proc), MAX_LOCAL_APIC); 1028 if (ret < 0) { 1029 printk(KERN_ERR PREFIX 1030 "Error parsing LAPIC/X2APIC entries\n"); 1031 return ret; 1032 } 1033 1034 x2count = madt_proc[0].count; 1035 count = madt_proc[1].count; 1036 } 1037 if (!count && !x2count) { 1038 printk(KERN_ERR PREFIX "No LAPIC entries present\n"); 1039 /* TBD: Cleanup to allow fallback to MPS */ 1040 return -ENODEV; 1041 } else if (count < 0 || x2count < 0) { 1042 printk(KERN_ERR PREFIX "Error parsing LAPIC entry\n"); 1043 /* TBD: Cleanup to allow fallback to MPS */ 1044 return count; 1045 } 1046 1047 x2count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC_NMI, 1048 acpi_parse_x2apic_nmi, 0); 1049 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI, 1050 acpi_parse_lapic_nmi, 0); 1051 if (count < 0 || x2count < 0) { 1052 printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n"); 1053 /* TBD: Cleanup to allow fallback to MPS */ 1054 return count; 1055 } 1056 return 0; 1057 } 1058 #endif /* CONFIG_X86_LOCAL_APIC */ 1059 1060 #ifdef CONFIG_X86_IO_APIC 1061 static void __init mp_config_acpi_legacy_irqs(void) 1062 { 1063 int i; 1064 struct mpc_intsrc mp_irq; 1065 1066 #ifdef CONFIG_EISA 1067 /* 1068 * Fabricate the legacy ISA bus (bus #31). 1069 */ 1070 mp_bus_id_to_type[MP_ISA_BUS] = MP_BUS_ISA; 1071 #endif 1072 set_bit(MP_ISA_BUS, mp_bus_not_pci); 1073 pr_debug("Bus #%d is ISA\n", MP_ISA_BUS); 1074 1075 /* 1076 * Use the default configuration for the IRQs 0-15. Unless 1077 * overridden by (MADT) interrupt source override entries. 1078 */ 1079 for (i = 0; i < nr_legacy_irqs(); i++) { 1080 int ioapic, pin; 1081 unsigned int dstapic; 1082 int idx; 1083 u32 gsi; 1084 1085 /* Locate the gsi that irq i maps to. */ 1086 if (acpi_isa_irq_to_gsi(i, &gsi)) 1087 continue; 1088 1089 /* 1090 * Locate the IOAPIC that manages the ISA IRQ. 1091 */ 1092 ioapic = mp_find_ioapic(gsi); 1093 if (ioapic < 0) 1094 continue; 1095 pin = mp_find_ioapic_pin(ioapic, gsi); 1096 dstapic = mpc_ioapic_id(ioapic); 1097 1098 for (idx = 0; idx < mp_irq_entries; idx++) { 1099 struct mpc_intsrc *irq = mp_irqs + idx; 1100 1101 /* Do we already have a mapping for this ISA IRQ? */ 1102 if (irq->srcbus == MP_ISA_BUS && irq->srcbusirq == i) 1103 break; 1104 1105 /* Do we already have a mapping for this IOAPIC pin */ 1106 if (irq->dstapic == dstapic && irq->dstirq == pin) 1107 break; 1108 } 1109 1110 if (idx != mp_irq_entries) { 1111 printk(KERN_DEBUG "ACPI: IRQ%d used by override.\n", i); 1112 continue; /* IRQ already used */ 1113 } 1114 1115 mp_irq.type = MP_INTSRC; 1116 mp_irq.irqflag = 0; /* Conforming */ 1117 mp_irq.srcbus = MP_ISA_BUS; 1118 mp_irq.dstapic = dstapic; 1119 mp_irq.irqtype = mp_INT; 1120 mp_irq.srcbusirq = i; /* Identity mapped */ 1121 mp_irq.dstirq = pin; 1122 1123 mp_save_irq(&mp_irq); 1124 } 1125 } 1126 1127 /* 1128 * Parse IOAPIC related entries in MADT 1129 * returns 0 on success, < 0 on error 1130 */ 1131 static int __init acpi_parse_madt_ioapic_entries(void) 1132 { 1133 int count; 1134 1135 /* 1136 * ACPI interpreter is required to complete interrupt setup, 1137 * so if it is off, don't enumerate the io-apics with ACPI. 1138 * If MPS is present, it will handle them, 1139 * otherwise the system will stay in PIC mode 1140 */ 1141 if (acpi_disabled || acpi_noirq) 1142 return -ENODEV; 1143 1144 if (!boot_cpu_has(X86_FEATURE_APIC)) 1145 return -ENODEV; 1146 1147 /* 1148 * if "noapic" boot option, don't look for IO-APICs 1149 */ 1150 if (skip_ioapic_setup) { 1151 printk(KERN_INFO PREFIX "Skipping IOAPIC probe " 1152 "due to 'noapic' option.\n"); 1153 return -ENODEV; 1154 } 1155 1156 count = acpi_table_parse_madt(ACPI_MADT_TYPE_IO_APIC, acpi_parse_ioapic, 1157 MAX_IO_APICS); 1158 if (!count) { 1159 printk(KERN_ERR PREFIX "No IOAPIC entries present\n"); 1160 return -ENODEV; 1161 } else if (count < 0) { 1162 printk(KERN_ERR PREFIX "Error parsing IOAPIC entry\n"); 1163 return count; 1164 } 1165 1166 count = acpi_table_parse_madt(ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, 1167 acpi_parse_int_src_ovr, nr_irqs); 1168 if (count < 0) { 1169 printk(KERN_ERR PREFIX 1170 "Error parsing interrupt source overrides entry\n"); 1171 /* TBD: Cleanup to allow fallback to MPS */ 1172 return count; 1173 } 1174 1175 /* 1176 * If BIOS did not supply an INT_SRC_OVR for the SCI 1177 * pretend we got one so we can set the SCI flags. 1178 */ 1179 if (!acpi_sci_override_gsi) 1180 acpi_sci_ioapic_setup(acpi_gbl_FADT.sci_interrupt, 0, 0, 1181 acpi_gbl_FADT.sci_interrupt); 1182 1183 /* Fill in identity legacy mappings where no override */ 1184 mp_config_acpi_legacy_irqs(); 1185 1186 count = acpi_table_parse_madt(ACPI_MADT_TYPE_NMI_SOURCE, 1187 acpi_parse_nmi_src, nr_irqs); 1188 if (count < 0) { 1189 printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n"); 1190 /* TBD: Cleanup to allow fallback to MPS */ 1191 return count; 1192 } 1193 1194 return 0; 1195 } 1196 #else 1197 static inline int acpi_parse_madt_ioapic_entries(void) 1198 { 1199 return -1; 1200 } 1201 #endif /* !CONFIG_X86_IO_APIC */ 1202 1203 static void __init early_acpi_process_madt(void) 1204 { 1205 #ifdef CONFIG_X86_LOCAL_APIC 1206 int error; 1207 1208 if (!acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) { 1209 1210 /* 1211 * Parse MADT LAPIC entries 1212 */ 1213 error = early_acpi_parse_madt_lapic_addr_ovr(); 1214 if (!error) { 1215 acpi_lapic = 1; 1216 smp_found_config = 1; 1217 } 1218 if (error == -EINVAL) { 1219 /* 1220 * Dell Precision Workstation 410, 610 come here. 1221 */ 1222 printk(KERN_ERR PREFIX 1223 "Invalid BIOS MADT, disabling ACPI\n"); 1224 disable_acpi(); 1225 } 1226 } 1227 #endif 1228 } 1229 1230 static void __init acpi_process_madt(void) 1231 { 1232 #ifdef CONFIG_X86_LOCAL_APIC 1233 int error; 1234 1235 if (!acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) { 1236 1237 /* 1238 * Parse MADT LAPIC entries 1239 */ 1240 error = acpi_parse_madt_lapic_entries(); 1241 if (!error) { 1242 acpi_lapic = 1; 1243 1244 /* 1245 * Parse MADT IO-APIC entries 1246 */ 1247 mutex_lock(&acpi_ioapic_lock); 1248 error = acpi_parse_madt_ioapic_entries(); 1249 mutex_unlock(&acpi_ioapic_lock); 1250 if (!error) { 1251 acpi_set_irq_model_ioapic(); 1252 1253 smp_found_config = 1; 1254 } 1255 } 1256 if (error == -EINVAL) { 1257 /* 1258 * Dell Precision Workstation 410, 610 come here. 1259 */ 1260 printk(KERN_ERR PREFIX 1261 "Invalid BIOS MADT, disabling ACPI\n"); 1262 disable_acpi(); 1263 } 1264 } else { 1265 /* 1266 * ACPI found no MADT, and so ACPI wants UP PIC mode. 1267 * In the event an MPS table was found, forget it. 1268 * Boot with "acpi=off" to use MPS on such a system. 1269 */ 1270 if (smp_found_config) { 1271 printk(KERN_WARNING PREFIX 1272 "No APIC-table, disabling MPS\n"); 1273 smp_found_config = 0; 1274 } 1275 } 1276 1277 /* 1278 * ACPI supports both logical (e.g. Hyper-Threading) and physical 1279 * processors, where MPS only supports physical. 1280 */ 1281 if (acpi_lapic && acpi_ioapic) 1282 printk(KERN_INFO "Using ACPI (MADT) for SMP configuration " 1283 "information\n"); 1284 else if (acpi_lapic) 1285 printk(KERN_INFO "Using ACPI for processor (LAPIC) " 1286 "configuration information\n"); 1287 #endif 1288 return; 1289 } 1290 1291 static int __init disable_acpi_irq(const struct dmi_system_id *d) 1292 { 1293 if (!acpi_force) { 1294 printk(KERN_NOTICE "%s detected: force use of acpi=noirq\n", 1295 d->ident); 1296 acpi_noirq_set(); 1297 } 1298 return 0; 1299 } 1300 1301 static int __init disable_acpi_pci(const struct dmi_system_id *d) 1302 { 1303 if (!acpi_force) { 1304 printk(KERN_NOTICE "%s detected: force use of pci=noacpi\n", 1305 d->ident); 1306 acpi_disable_pci(); 1307 } 1308 return 0; 1309 } 1310 1311 static int __init dmi_disable_acpi(const struct dmi_system_id *d) 1312 { 1313 if (!acpi_force) { 1314 printk(KERN_NOTICE "%s detected: acpi off\n", d->ident); 1315 disable_acpi(); 1316 } else { 1317 printk(KERN_NOTICE 1318 "Warning: DMI blacklist says broken, but acpi forced\n"); 1319 } 1320 return 0; 1321 } 1322 1323 /* 1324 * Force ignoring BIOS IRQ0 override 1325 */ 1326 static int __init dmi_ignore_irq0_timer_override(const struct dmi_system_id *d) 1327 { 1328 if (!acpi_skip_timer_override) { 1329 pr_notice("%s detected: Ignoring BIOS IRQ0 override\n", 1330 d->ident); 1331 acpi_skip_timer_override = 1; 1332 } 1333 return 0; 1334 } 1335 1336 /* 1337 * ACPI offers an alternative platform interface model that removes 1338 * ACPI hardware requirements for platforms that do not implement 1339 * the PC Architecture. 1340 * 1341 * We initialize the Hardware-reduced ACPI model here: 1342 */ 1343 static void __init acpi_reduced_hw_init(void) 1344 { 1345 if (acpi_gbl_reduced_hardware) { 1346 /* 1347 * Override x86_init functions and bypass legacy pic 1348 * in Hardware-reduced ACPI mode 1349 */ 1350 x86_init.timers.timer_init = x86_init_noop; 1351 x86_init.irqs.pre_vector_init = x86_init_noop; 1352 legacy_pic = &null_legacy_pic; 1353 } 1354 } 1355 1356 /* 1357 * If your system is blacklisted here, but you find that acpi=force 1358 * works for you, please contact linux-acpi@vger.kernel.org 1359 */ 1360 static struct dmi_system_id __initdata acpi_dmi_table[] = { 1361 /* 1362 * Boxes that need ACPI disabled 1363 */ 1364 { 1365 .callback = dmi_disable_acpi, 1366 .ident = "IBM Thinkpad", 1367 .matches = { 1368 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1369 DMI_MATCH(DMI_BOARD_NAME, "2629H1G"), 1370 }, 1371 }, 1372 1373 /* 1374 * Boxes that need ACPI PCI IRQ routing disabled 1375 */ 1376 { 1377 .callback = disable_acpi_irq, 1378 .ident = "ASUS A7V", 1379 .matches = { 1380 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC"), 1381 DMI_MATCH(DMI_BOARD_NAME, "<A7V>"), 1382 /* newer BIOS, Revision 1011, does work */ 1383 DMI_MATCH(DMI_BIOS_VERSION, 1384 "ASUS A7V ACPI BIOS Revision 1007"), 1385 }, 1386 }, 1387 { 1388 /* 1389 * Latest BIOS for IBM 600E (1.16) has bad pcinum 1390 * for LPC bridge, which is needed for the PCI 1391 * interrupt links to work. DSDT fix is in bug 5966. 1392 * 2645, 2646 model numbers are shared with 600/600E/600X 1393 */ 1394 .callback = disable_acpi_irq, 1395 .ident = "IBM Thinkpad 600 Series 2645", 1396 .matches = { 1397 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1398 DMI_MATCH(DMI_BOARD_NAME, "2645"), 1399 }, 1400 }, 1401 { 1402 .callback = disable_acpi_irq, 1403 .ident = "IBM Thinkpad 600 Series 2646", 1404 .matches = { 1405 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1406 DMI_MATCH(DMI_BOARD_NAME, "2646"), 1407 }, 1408 }, 1409 /* 1410 * Boxes that need ACPI PCI IRQ routing and PCI scan disabled 1411 */ 1412 { /* _BBN 0 bug */ 1413 .callback = disable_acpi_pci, 1414 .ident = "ASUS PR-DLS", 1415 .matches = { 1416 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1417 DMI_MATCH(DMI_BOARD_NAME, "PR-DLS"), 1418 DMI_MATCH(DMI_BIOS_VERSION, 1419 "ASUS PR-DLS ACPI BIOS Revision 1010"), 1420 DMI_MATCH(DMI_BIOS_DATE, "03/21/2003") 1421 }, 1422 }, 1423 { 1424 .callback = disable_acpi_pci, 1425 .ident = "Acer TravelMate 36x Laptop", 1426 .matches = { 1427 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 1428 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"), 1429 }, 1430 }, 1431 {} 1432 }; 1433 1434 /* second table for DMI checks that should run after early-quirks */ 1435 static struct dmi_system_id __initdata acpi_dmi_table_late[] = { 1436 /* 1437 * HP laptops which use a DSDT reporting as HP/SB400/10000, 1438 * which includes some code which overrides all temperature 1439 * trip points to 16C if the INTIN2 input of the I/O APIC 1440 * is enabled. This input is incorrectly designated the 1441 * ISA IRQ 0 via an interrupt source override even though 1442 * it is wired to the output of the master 8259A and INTIN0 1443 * is not connected at all. Force ignoring BIOS IRQ0 1444 * override in that cases. 1445 */ 1446 { 1447 .callback = dmi_ignore_irq0_timer_override, 1448 .ident = "HP nx6115 laptop", 1449 .matches = { 1450 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1451 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6115"), 1452 }, 1453 }, 1454 { 1455 .callback = dmi_ignore_irq0_timer_override, 1456 .ident = "HP NX6125 laptop", 1457 .matches = { 1458 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1459 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6125"), 1460 }, 1461 }, 1462 { 1463 .callback = dmi_ignore_irq0_timer_override, 1464 .ident = "HP NX6325 laptop", 1465 .matches = { 1466 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1467 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6325"), 1468 }, 1469 }, 1470 { 1471 .callback = dmi_ignore_irq0_timer_override, 1472 .ident = "HP 6715b laptop", 1473 .matches = { 1474 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1475 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq 6715b"), 1476 }, 1477 }, 1478 { 1479 .callback = dmi_ignore_irq0_timer_override, 1480 .ident = "FUJITSU SIEMENS", 1481 .matches = { 1482 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 1483 DMI_MATCH(DMI_PRODUCT_NAME, "AMILO PRO V2030"), 1484 }, 1485 }, 1486 {} 1487 }; 1488 1489 /* 1490 * acpi_boot_table_init() and acpi_boot_init() 1491 * called from setup_arch(), always. 1492 * 1. checksums all tables 1493 * 2. enumerates lapics 1494 * 3. enumerates io-apics 1495 * 1496 * acpi_table_init() is separate to allow reading SRAT without 1497 * other side effects. 1498 * 1499 * side effects of acpi_boot_init: 1500 * acpi_lapic = 1 if LAPIC found 1501 * acpi_ioapic = 1 if IOAPIC found 1502 * if (acpi_lapic && acpi_ioapic) smp_found_config = 1; 1503 * if acpi_blacklisted() acpi_disabled = 1; 1504 * acpi_irq_model=... 1505 * ... 1506 */ 1507 1508 void __init acpi_boot_table_init(void) 1509 { 1510 dmi_check_system(acpi_dmi_table); 1511 1512 /* 1513 * If acpi_disabled, bail out 1514 */ 1515 if (acpi_disabled) 1516 return; 1517 1518 /* 1519 * Initialize the ACPI boot-time table parser. 1520 */ 1521 if (acpi_table_init()) { 1522 disable_acpi(); 1523 return; 1524 } 1525 1526 acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf); 1527 1528 /* 1529 * blacklist may disable ACPI entirely 1530 */ 1531 if (acpi_blacklisted()) { 1532 if (acpi_force) { 1533 printk(KERN_WARNING PREFIX "acpi=force override\n"); 1534 } else { 1535 printk(KERN_WARNING PREFIX "Disabling ACPI support\n"); 1536 disable_acpi(); 1537 return; 1538 } 1539 } 1540 } 1541 1542 int __init early_acpi_boot_init(void) 1543 { 1544 /* 1545 * If acpi_disabled, bail out 1546 */ 1547 if (acpi_disabled) 1548 return 1; 1549 1550 /* 1551 * Process the Multiple APIC Description Table (MADT), if present 1552 */ 1553 early_acpi_process_madt(); 1554 1555 /* 1556 * Hardware-reduced ACPI mode initialization: 1557 */ 1558 acpi_reduced_hw_init(); 1559 1560 return 0; 1561 } 1562 1563 int __init acpi_boot_init(void) 1564 { 1565 /* those are executed after early-quirks are executed */ 1566 dmi_check_system(acpi_dmi_table_late); 1567 1568 /* 1569 * If acpi_disabled, bail out 1570 */ 1571 if (acpi_disabled) 1572 return 1; 1573 1574 acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf); 1575 1576 /* 1577 * set sci_int and PM timer address 1578 */ 1579 acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt); 1580 1581 /* 1582 * Process the Multiple APIC Description Table (MADT), if present 1583 */ 1584 acpi_process_madt(); 1585 1586 acpi_table_parse(ACPI_SIG_HPET, acpi_parse_hpet); 1587 1588 if (!acpi_noirq) 1589 x86_init.pci.init = pci_acpi_init; 1590 1591 return 0; 1592 } 1593 1594 static int __init parse_acpi(char *arg) 1595 { 1596 if (!arg) 1597 return -EINVAL; 1598 1599 /* "acpi=off" disables both ACPI table parsing and interpreter */ 1600 if (strcmp(arg, "off") == 0) { 1601 disable_acpi(); 1602 } 1603 /* acpi=force to over-ride black-list */ 1604 else if (strcmp(arg, "force") == 0) { 1605 acpi_force = 1; 1606 acpi_disabled = 0; 1607 } 1608 /* acpi=strict disables out-of-spec workarounds */ 1609 else if (strcmp(arg, "strict") == 0) { 1610 acpi_strict = 1; 1611 } 1612 /* acpi=rsdt use RSDT instead of XSDT */ 1613 else if (strcmp(arg, "rsdt") == 0) { 1614 acpi_gbl_do_not_use_xsdt = TRUE; 1615 } 1616 /* "acpi=noirq" disables ACPI interrupt routing */ 1617 else if (strcmp(arg, "noirq") == 0) { 1618 acpi_noirq_set(); 1619 } 1620 /* "acpi=copy_dsdt" copys DSDT */ 1621 else if (strcmp(arg, "copy_dsdt") == 0) { 1622 acpi_gbl_copy_dsdt_locally = 1; 1623 } 1624 /* "acpi=nocmcff" disables FF mode for corrected errors */ 1625 else if (strcmp(arg, "nocmcff") == 0) { 1626 acpi_disable_cmcff = 1; 1627 } else { 1628 /* Core will printk when we return error. */ 1629 return -EINVAL; 1630 } 1631 return 0; 1632 } 1633 early_param("acpi", parse_acpi); 1634 1635 /* FIXME: Using pci= for an ACPI parameter is a travesty. */ 1636 static int __init parse_pci(char *arg) 1637 { 1638 if (arg && strcmp(arg, "noacpi") == 0) 1639 acpi_disable_pci(); 1640 return 0; 1641 } 1642 early_param("pci", parse_pci); 1643 1644 int __init acpi_mps_check(void) 1645 { 1646 #if defined(CONFIG_X86_LOCAL_APIC) && !defined(CONFIG_X86_MPPARSE) 1647 /* mptable code is not built-in*/ 1648 if (acpi_disabled || acpi_noirq) { 1649 printk(KERN_WARNING "MPS support code is not built-in.\n" 1650 "Using acpi=off or acpi=noirq or pci=noacpi " 1651 "may have problem\n"); 1652 return 1; 1653 } 1654 #endif 1655 return 0; 1656 } 1657 1658 #ifdef CONFIG_X86_IO_APIC 1659 static int __init parse_acpi_skip_timer_override(char *arg) 1660 { 1661 acpi_skip_timer_override = 1; 1662 return 0; 1663 } 1664 early_param("acpi_skip_timer_override", parse_acpi_skip_timer_override); 1665 1666 static int __init parse_acpi_use_timer_override(char *arg) 1667 { 1668 acpi_use_timer_override = 1; 1669 return 0; 1670 } 1671 early_param("acpi_use_timer_override", parse_acpi_use_timer_override); 1672 #endif /* CONFIG_X86_IO_APIC */ 1673 1674 static int __init setup_acpi_sci(char *s) 1675 { 1676 if (!s) 1677 return -EINVAL; 1678 if (!strcmp(s, "edge")) 1679 acpi_sci_flags = ACPI_MADT_TRIGGER_EDGE | 1680 (acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK); 1681 else if (!strcmp(s, "level")) 1682 acpi_sci_flags = ACPI_MADT_TRIGGER_LEVEL | 1683 (acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK); 1684 else if (!strcmp(s, "high")) 1685 acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_HIGH | 1686 (acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK); 1687 else if (!strcmp(s, "low")) 1688 acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_LOW | 1689 (acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK); 1690 else 1691 return -EINVAL; 1692 return 0; 1693 } 1694 early_param("acpi_sci", setup_acpi_sci); 1695 1696 int __acpi_acquire_global_lock(unsigned int *lock) 1697 { 1698 unsigned int old, new, val; 1699 do { 1700 old = *lock; 1701 new = (((old & ~0x3) + 2) + ((old >> 1) & 0x1)); 1702 val = cmpxchg(lock, old, new); 1703 } while (unlikely (val != old)); 1704 return (new < 3) ? -1 : 0; 1705 } 1706 1707 int __acpi_release_global_lock(unsigned int *lock) 1708 { 1709 unsigned int old, new, val; 1710 do { 1711 old = *lock; 1712 new = old & ~0x3; 1713 val = cmpxchg(lock, old, new); 1714 } while (unlikely (val != old)); 1715 return old & 0x1; 1716 } 1717 1718 void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size) 1719 { 1720 e820_add_region(addr, size, E820_ACPI); 1721 update_e820(); 1722 } 1723