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/module.h> 32 #include <linux/dmi.h> 33 #include <linux/irq.h> 34 #include <linux/bootmem.h> 35 #include <linux/ioport.h> 36 #include <linux/pci.h> 37 38 #include <asm/pgtable.h> 39 #include <asm/io_apic.h> 40 #include <asm/apic.h> 41 #include <asm/io.h> 42 #include <asm/mpspec.h> 43 #include <asm/smp.h> 44 45 static int __initdata acpi_force = 0; 46 u32 acpi_rsdt_forced; 47 #ifdef CONFIG_ACPI 48 int acpi_disabled = 0; 49 #else 50 int acpi_disabled = 1; 51 #endif 52 EXPORT_SYMBOL(acpi_disabled); 53 54 #ifdef CONFIG_X86_64 55 # include <asm/proto.h> 56 #endif /* X86 */ 57 58 #define BAD_MADT_ENTRY(entry, end) ( \ 59 (!entry) || (unsigned long)entry + sizeof(*entry) > end || \ 60 ((struct acpi_subtable_header *)entry)->length < sizeof(*entry)) 61 62 #define PREFIX "ACPI: " 63 64 int acpi_noirq; /* skip ACPI IRQ initialization */ 65 int acpi_pci_disabled; /* skip ACPI PCI scan and IRQ initialization */ 66 EXPORT_SYMBOL(acpi_pci_disabled); 67 int acpi_ht __initdata = 1; /* enable HT */ 68 69 int acpi_lapic; 70 int acpi_ioapic; 71 int acpi_strict; 72 73 u8 acpi_sci_flags __initdata; 74 int acpi_sci_override_gsi __initdata; 75 int acpi_skip_timer_override __initdata; 76 int acpi_use_timer_override __initdata; 77 78 #ifdef CONFIG_X86_LOCAL_APIC 79 static u64 acpi_lapic_addr __initdata = APIC_DEFAULT_PHYS_BASE; 80 #endif 81 82 #ifndef __HAVE_ARCH_CMPXCHG 83 #warning ACPI uses CMPXCHG, i486 and later hardware 84 #endif 85 86 /* -------------------------------------------------------------------------- 87 Boot-time Configuration 88 -------------------------------------------------------------------------- */ 89 90 /* 91 * The default interrupt routing model is PIC (8259). This gets 92 * overridden if IOAPICs are enumerated (below). 93 */ 94 enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_PIC; 95 96 97 /* 98 * Temporarily use the virtual area starting from FIX_IO_APIC_BASE_END, 99 * to map the target physical address. The problem is that set_fixmap() 100 * provides a single page, and it is possible that the page is not 101 * sufficient. 102 * By using this area, we can map up to MAX_IO_APICS pages temporarily, 103 * i.e. until the next __va_range() call. 104 * 105 * Important Safety Note: The fixed I/O APIC page numbers are *subtracted* 106 * from the fixed base. That's why we start at FIX_IO_APIC_BASE_END and 107 * count idx down while incrementing the phys address. 108 */ 109 char *__init __acpi_map_table(unsigned long phys, unsigned long size) 110 { 111 112 if (!phys || !size) 113 return NULL; 114 115 return early_ioremap(phys, size); 116 } 117 void __init __acpi_unmap_table(char *map, unsigned long size) 118 { 119 if (!map || !size) 120 return; 121 122 early_iounmap(map, size); 123 } 124 125 #ifdef CONFIG_PCI_MMCONFIG 126 127 static int acpi_mcfg_64bit_base_addr __initdata = FALSE; 128 129 /* The physical address of the MMCONFIG aperture. Set from ACPI tables. */ 130 struct acpi_mcfg_allocation *pci_mmcfg_config; 131 int pci_mmcfg_config_num; 132 133 static int __init acpi_mcfg_oem_check(struct acpi_table_mcfg *mcfg) 134 { 135 if (!strcmp(mcfg->header.oem_id, "SGI")) 136 acpi_mcfg_64bit_base_addr = TRUE; 137 138 return 0; 139 } 140 141 int __init acpi_parse_mcfg(struct acpi_table_header *header) 142 { 143 struct acpi_table_mcfg *mcfg; 144 unsigned long i; 145 int config_size; 146 147 if (!header) 148 return -EINVAL; 149 150 mcfg = (struct acpi_table_mcfg *)header; 151 152 /* how many config structures do we have */ 153 pci_mmcfg_config_num = 0; 154 i = header->length - sizeof(struct acpi_table_mcfg); 155 while (i >= sizeof(struct acpi_mcfg_allocation)) { 156 ++pci_mmcfg_config_num; 157 i -= sizeof(struct acpi_mcfg_allocation); 158 }; 159 if (pci_mmcfg_config_num == 0) { 160 printk(KERN_ERR PREFIX "MMCONFIG has no entries\n"); 161 return -ENODEV; 162 } 163 164 config_size = pci_mmcfg_config_num * sizeof(*pci_mmcfg_config); 165 pci_mmcfg_config = kmalloc(config_size, GFP_KERNEL); 166 if (!pci_mmcfg_config) { 167 printk(KERN_WARNING PREFIX 168 "No memory for MCFG config tables\n"); 169 return -ENOMEM; 170 } 171 172 memcpy(pci_mmcfg_config, &mcfg[1], config_size); 173 174 acpi_mcfg_oem_check(mcfg); 175 176 for (i = 0; i < pci_mmcfg_config_num; ++i) { 177 if ((pci_mmcfg_config[i].address > 0xFFFFFFFF) && 178 !acpi_mcfg_64bit_base_addr) { 179 printk(KERN_ERR PREFIX 180 "MMCONFIG not in low 4GB of memory\n"); 181 kfree(pci_mmcfg_config); 182 pci_mmcfg_config_num = 0; 183 return -ENODEV; 184 } 185 } 186 187 return 0; 188 } 189 #endif /* CONFIG_PCI_MMCONFIG */ 190 191 #ifdef CONFIG_X86_LOCAL_APIC 192 static int __init acpi_parse_madt(struct acpi_table_header *table) 193 { 194 struct acpi_table_madt *madt = NULL; 195 196 if (!cpu_has_apic) 197 return -EINVAL; 198 199 madt = (struct acpi_table_madt *)table; 200 if (!madt) { 201 printk(KERN_WARNING PREFIX "Unable to map MADT\n"); 202 return -ENODEV; 203 } 204 205 if (madt->address) { 206 acpi_lapic_addr = (u64) madt->address; 207 208 printk(KERN_DEBUG PREFIX "Local APIC address 0x%08x\n", 209 madt->address); 210 } 211 212 default_acpi_madt_oem_check(madt->header.oem_id, 213 madt->header.oem_table_id); 214 215 return 0; 216 } 217 218 static void __cpuinit acpi_register_lapic(int id, u8 enabled) 219 { 220 unsigned int ver = 0; 221 222 if (!enabled) { 223 ++disabled_cpus; 224 return; 225 } 226 227 if (boot_cpu_physical_apicid != -1U) 228 ver = apic_version[boot_cpu_physical_apicid]; 229 230 generic_processor_info(id, ver); 231 } 232 233 static int __init 234 acpi_parse_x2apic(struct acpi_subtable_header *header, const unsigned long end) 235 { 236 struct acpi_madt_local_x2apic *processor = NULL; 237 238 processor = (struct acpi_madt_local_x2apic *)header; 239 240 if (BAD_MADT_ENTRY(processor, end)) 241 return -EINVAL; 242 243 acpi_table_print_madt_entry(header); 244 245 #ifdef CONFIG_X86_X2APIC 246 /* 247 * We need to register disabled CPU as well to permit 248 * counting disabled CPUs. This allows us to size 249 * cpus_possible_map more accurately, to permit 250 * to not preallocating memory for all NR_CPUS 251 * when we use CPU hotplug. 252 */ 253 acpi_register_lapic(processor->local_apic_id, /* APIC ID */ 254 processor->lapic_flags & ACPI_MADT_ENABLED); 255 #else 256 printk(KERN_WARNING PREFIX "x2apic entry ignored\n"); 257 #endif 258 259 return 0; 260 } 261 262 static int __init 263 acpi_parse_lapic(struct acpi_subtable_header * header, const unsigned long end) 264 { 265 struct acpi_madt_local_apic *processor = NULL; 266 267 processor = (struct acpi_madt_local_apic *)header; 268 269 if (BAD_MADT_ENTRY(processor, end)) 270 return -EINVAL; 271 272 acpi_table_print_madt_entry(header); 273 274 /* 275 * We need to register disabled CPU as well to permit 276 * counting disabled CPUs. This allows us to size 277 * cpus_possible_map more accurately, to permit 278 * to not preallocating memory for all NR_CPUS 279 * when we use CPU hotplug. 280 */ 281 acpi_register_lapic(processor->id, /* APIC ID */ 282 processor->lapic_flags & ACPI_MADT_ENABLED); 283 284 return 0; 285 } 286 287 static int __init 288 acpi_parse_sapic(struct acpi_subtable_header *header, const unsigned long end) 289 { 290 struct acpi_madt_local_sapic *processor = NULL; 291 292 processor = (struct acpi_madt_local_sapic *)header; 293 294 if (BAD_MADT_ENTRY(processor, end)) 295 return -EINVAL; 296 297 acpi_table_print_madt_entry(header); 298 299 acpi_register_lapic((processor->id << 8) | processor->eid,/* APIC ID */ 300 processor->lapic_flags & ACPI_MADT_ENABLED); 301 302 return 0; 303 } 304 305 static int __init 306 acpi_parse_lapic_addr_ovr(struct acpi_subtable_header * header, 307 const unsigned long end) 308 { 309 struct acpi_madt_local_apic_override *lapic_addr_ovr = NULL; 310 311 lapic_addr_ovr = (struct acpi_madt_local_apic_override *)header; 312 313 if (BAD_MADT_ENTRY(lapic_addr_ovr, end)) 314 return -EINVAL; 315 316 acpi_lapic_addr = lapic_addr_ovr->address; 317 318 return 0; 319 } 320 321 static int __init 322 acpi_parse_x2apic_nmi(struct acpi_subtable_header *header, 323 const unsigned long end) 324 { 325 struct acpi_madt_local_x2apic_nmi *x2apic_nmi = NULL; 326 327 x2apic_nmi = (struct acpi_madt_local_x2apic_nmi *)header; 328 329 if (BAD_MADT_ENTRY(x2apic_nmi, end)) 330 return -EINVAL; 331 332 acpi_table_print_madt_entry(header); 333 334 if (x2apic_nmi->lint != 1) 335 printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n"); 336 337 return 0; 338 } 339 340 static int __init 341 acpi_parse_lapic_nmi(struct acpi_subtable_header * header, const unsigned long end) 342 { 343 struct acpi_madt_local_apic_nmi *lapic_nmi = NULL; 344 345 lapic_nmi = (struct acpi_madt_local_apic_nmi *)header; 346 347 if (BAD_MADT_ENTRY(lapic_nmi, end)) 348 return -EINVAL; 349 350 acpi_table_print_madt_entry(header); 351 352 if (lapic_nmi->lint != 1) 353 printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n"); 354 355 return 0; 356 } 357 358 #endif /*CONFIG_X86_LOCAL_APIC */ 359 360 #ifdef CONFIG_X86_IO_APIC 361 362 static int __init 363 acpi_parse_ioapic(struct acpi_subtable_header * header, const unsigned long end) 364 { 365 struct acpi_madt_io_apic *ioapic = NULL; 366 367 ioapic = (struct acpi_madt_io_apic *)header; 368 369 if (BAD_MADT_ENTRY(ioapic, end)) 370 return -EINVAL; 371 372 acpi_table_print_madt_entry(header); 373 374 mp_register_ioapic(ioapic->id, 375 ioapic->address, ioapic->global_irq_base); 376 377 return 0; 378 } 379 380 /* 381 * Parse Interrupt Source Override for the ACPI SCI 382 */ 383 static void __init acpi_sci_ioapic_setup(u32 gsi, u16 polarity, u16 trigger) 384 { 385 if (trigger == 0) /* compatible SCI trigger is level */ 386 trigger = 3; 387 388 if (polarity == 0) /* compatible SCI polarity is low */ 389 polarity = 3; 390 391 /* Command-line over-ride via acpi_sci= */ 392 if (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) 393 trigger = (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2; 394 395 if (acpi_sci_flags & ACPI_MADT_POLARITY_MASK) 396 polarity = acpi_sci_flags & ACPI_MADT_POLARITY_MASK; 397 398 /* 399 * mp_config_acpi_legacy_irqs() already setup IRQs < 16 400 * If GSI is < 16, this will update its flags, 401 * else it will create a new mp_irqs[] entry. 402 */ 403 mp_override_legacy_irq(gsi, polarity, trigger, gsi); 404 405 /* 406 * stash over-ride to indicate we've been here 407 * and for later update of acpi_gbl_FADT 408 */ 409 acpi_sci_override_gsi = gsi; 410 return; 411 } 412 413 static int __init 414 acpi_parse_int_src_ovr(struct acpi_subtable_header * header, 415 const unsigned long end) 416 { 417 struct acpi_madt_interrupt_override *intsrc = NULL; 418 419 intsrc = (struct acpi_madt_interrupt_override *)header; 420 421 if (BAD_MADT_ENTRY(intsrc, end)) 422 return -EINVAL; 423 424 acpi_table_print_madt_entry(header); 425 426 if (intsrc->source_irq == acpi_gbl_FADT.sci_interrupt) { 427 acpi_sci_ioapic_setup(intsrc->global_irq, 428 intsrc->inti_flags & ACPI_MADT_POLARITY_MASK, 429 (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2); 430 return 0; 431 } 432 433 if (acpi_skip_timer_override && 434 intsrc->source_irq == 0 && intsrc->global_irq == 2) { 435 printk(PREFIX "BIOS IRQ0 pin2 override ignored.\n"); 436 return 0; 437 } 438 439 mp_override_legacy_irq(intsrc->source_irq, 440 intsrc->inti_flags & ACPI_MADT_POLARITY_MASK, 441 (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2, 442 intsrc->global_irq); 443 444 return 0; 445 } 446 447 static int __init 448 acpi_parse_nmi_src(struct acpi_subtable_header * header, const unsigned long end) 449 { 450 struct acpi_madt_nmi_source *nmi_src = NULL; 451 452 nmi_src = (struct acpi_madt_nmi_source *)header; 453 454 if (BAD_MADT_ENTRY(nmi_src, end)) 455 return -EINVAL; 456 457 acpi_table_print_madt_entry(header); 458 459 /* TBD: Support nimsrc entries? */ 460 461 return 0; 462 } 463 464 #endif /* CONFIG_X86_IO_APIC */ 465 466 /* 467 * acpi_pic_sci_set_trigger() 468 * 469 * use ELCR to set PIC-mode trigger type for SCI 470 * 471 * If a PIC-mode SCI is not recognized or gives spurious IRQ7's 472 * it may require Edge Trigger -- use "acpi_sci=edge" 473 * 474 * Port 0x4d0-4d1 are ECLR1 and ECLR2, the Edge/Level Control Registers 475 * for the 8259 PIC. bit[n] = 1 means irq[n] is Level, otherwise Edge. 476 * ECLR1 is IRQs 0-7 (IRQ 0, 1, 2 must be 0) 477 * ECLR2 is IRQs 8-15 (IRQ 8, 13 must be 0) 478 */ 479 480 void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger) 481 { 482 unsigned int mask = 1 << irq; 483 unsigned int old, new; 484 485 /* Real old ELCR mask */ 486 old = inb(0x4d0) | (inb(0x4d1) << 8); 487 488 /* 489 * If we use ACPI to set PCI IRQs, then we should clear ELCR 490 * since we will set it correctly as we enable the PCI irq 491 * routing. 492 */ 493 new = acpi_noirq ? old : 0; 494 495 /* 496 * Update SCI information in the ELCR, it isn't in the PCI 497 * routing tables.. 498 */ 499 switch (trigger) { 500 case 1: /* Edge - clear */ 501 new &= ~mask; 502 break; 503 case 3: /* Level - set */ 504 new |= mask; 505 break; 506 } 507 508 if (old == new) 509 return; 510 511 printk(PREFIX "setting ELCR to %04x (from %04x)\n", new, old); 512 outb(new, 0x4d0); 513 outb(new >> 8, 0x4d1); 514 } 515 516 int acpi_gsi_to_irq(u32 gsi, unsigned int *irq) 517 { 518 *irq = gsi; 519 return 0; 520 } 521 522 /* 523 * success: return IRQ number (>=0) 524 * failure: return < 0 525 */ 526 int acpi_register_gsi(struct device *dev, u32 gsi, int trigger, int polarity) 527 { 528 unsigned int irq; 529 unsigned int plat_gsi = gsi; 530 531 #ifdef CONFIG_PCI 532 /* 533 * Make sure all (legacy) PCI IRQs are set as level-triggered. 534 */ 535 if (acpi_irq_model == ACPI_IRQ_MODEL_PIC) { 536 if (trigger == ACPI_LEVEL_SENSITIVE) 537 eisa_set_level_irq(gsi); 538 } 539 #endif 540 541 #ifdef CONFIG_X86_IO_APIC 542 if (acpi_irq_model == ACPI_IRQ_MODEL_IOAPIC) { 543 plat_gsi = mp_register_gsi(dev, gsi, trigger, polarity); 544 } 545 #endif 546 acpi_gsi_to_irq(plat_gsi, &irq); 547 return irq; 548 } 549 550 /* 551 * ACPI based hotplug support for CPU 552 */ 553 #ifdef CONFIG_ACPI_HOTPLUG_CPU 554 555 static int __cpuinit _acpi_map_lsapic(acpi_handle handle, int *pcpu) 556 { 557 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 558 union acpi_object *obj; 559 struct acpi_madt_local_apic *lapic; 560 cpumask_var_t tmp_map, new_map; 561 u8 physid; 562 int cpu; 563 int retval = -ENOMEM; 564 565 if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer))) 566 return -EINVAL; 567 568 if (!buffer.length || !buffer.pointer) 569 return -EINVAL; 570 571 obj = buffer.pointer; 572 if (obj->type != ACPI_TYPE_BUFFER || 573 obj->buffer.length < sizeof(*lapic)) { 574 kfree(buffer.pointer); 575 return -EINVAL; 576 } 577 578 lapic = (struct acpi_madt_local_apic *)obj->buffer.pointer; 579 580 if (lapic->header.type != ACPI_MADT_TYPE_LOCAL_APIC || 581 !(lapic->lapic_flags & ACPI_MADT_ENABLED)) { 582 kfree(buffer.pointer); 583 return -EINVAL; 584 } 585 586 physid = lapic->id; 587 588 kfree(buffer.pointer); 589 buffer.length = ACPI_ALLOCATE_BUFFER; 590 buffer.pointer = NULL; 591 592 if (!alloc_cpumask_var(&tmp_map, GFP_KERNEL)) 593 goto out; 594 595 if (!alloc_cpumask_var(&new_map, GFP_KERNEL)) 596 goto free_tmp_map; 597 598 cpumask_copy(tmp_map, cpu_present_mask); 599 acpi_register_lapic(physid, lapic->lapic_flags & ACPI_MADT_ENABLED); 600 601 /* 602 * If mp_register_lapic successfully generates a new logical cpu 603 * number, then the following will get us exactly what was mapped 604 */ 605 cpumask_andnot(new_map, cpu_present_mask, tmp_map); 606 if (cpumask_empty(new_map)) { 607 printk ("Unable to map lapic to logical cpu number\n"); 608 retval = -EINVAL; 609 goto free_new_map; 610 } 611 612 cpu = cpumask_first(new_map); 613 614 *pcpu = cpu; 615 retval = 0; 616 617 free_new_map: 618 free_cpumask_var(new_map); 619 free_tmp_map: 620 free_cpumask_var(tmp_map); 621 out: 622 return retval; 623 } 624 625 /* wrapper to silence section mismatch warning */ 626 int __ref acpi_map_lsapic(acpi_handle handle, int *pcpu) 627 { 628 return _acpi_map_lsapic(handle, pcpu); 629 } 630 EXPORT_SYMBOL(acpi_map_lsapic); 631 632 int acpi_unmap_lsapic(int cpu) 633 { 634 per_cpu(x86_cpu_to_apicid, cpu) = -1; 635 set_cpu_present(cpu, false); 636 num_processors--; 637 638 return (0); 639 } 640 641 EXPORT_SYMBOL(acpi_unmap_lsapic); 642 #endif /* CONFIG_ACPI_HOTPLUG_CPU */ 643 644 int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base) 645 { 646 /* TBD */ 647 return -EINVAL; 648 } 649 650 EXPORT_SYMBOL(acpi_register_ioapic); 651 652 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base) 653 { 654 /* TBD */ 655 return -EINVAL; 656 } 657 658 EXPORT_SYMBOL(acpi_unregister_ioapic); 659 660 static int __init acpi_parse_sbf(struct acpi_table_header *table) 661 { 662 struct acpi_table_boot *sb; 663 664 sb = (struct acpi_table_boot *)table; 665 if (!sb) { 666 printk(KERN_WARNING PREFIX "Unable to map SBF\n"); 667 return -ENODEV; 668 } 669 670 sbf_port = sb->cmos_index; /* Save CMOS port */ 671 672 return 0; 673 } 674 675 #ifdef CONFIG_HPET_TIMER 676 #include <asm/hpet.h> 677 678 static struct __initdata resource *hpet_res; 679 680 static int __init acpi_parse_hpet(struct acpi_table_header *table) 681 { 682 struct acpi_table_hpet *hpet_tbl; 683 684 hpet_tbl = (struct acpi_table_hpet *)table; 685 if (!hpet_tbl) { 686 printk(KERN_WARNING PREFIX "Unable to map HPET\n"); 687 return -ENODEV; 688 } 689 690 if (hpet_tbl->address.space_id != ACPI_SPACE_MEM) { 691 printk(KERN_WARNING PREFIX "HPET timers must be located in " 692 "memory.\n"); 693 return -1; 694 } 695 696 hpet_address = hpet_tbl->address.address; 697 698 /* 699 * Some broken BIOSes advertise HPET at 0x0. We really do not 700 * want to allocate a resource there. 701 */ 702 if (!hpet_address) { 703 printk(KERN_WARNING PREFIX 704 "HPET id: %#x base: %#lx is invalid\n", 705 hpet_tbl->id, hpet_address); 706 return 0; 707 } 708 #ifdef CONFIG_X86_64 709 /* 710 * Some even more broken BIOSes advertise HPET at 711 * 0xfed0000000000000 instead of 0xfed00000. Fix it up and add 712 * some noise: 713 */ 714 if (hpet_address == 0xfed0000000000000UL) { 715 if (!hpet_force_user) { 716 printk(KERN_WARNING PREFIX "HPET id: %#x " 717 "base: 0xfed0000000000000 is bogus\n " 718 "try hpet=force on the kernel command line to " 719 "fix it up to 0xfed00000.\n", hpet_tbl->id); 720 hpet_address = 0; 721 return 0; 722 } 723 printk(KERN_WARNING PREFIX 724 "HPET id: %#x base: 0xfed0000000000000 fixed up " 725 "to 0xfed00000.\n", hpet_tbl->id); 726 hpet_address >>= 32; 727 } 728 #endif 729 printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n", 730 hpet_tbl->id, hpet_address); 731 732 /* 733 * Allocate and initialize the HPET firmware resource for adding into 734 * the resource tree during the lateinit timeframe. 735 */ 736 #define HPET_RESOURCE_NAME_SIZE 9 737 hpet_res = alloc_bootmem(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE); 738 739 hpet_res->name = (void *)&hpet_res[1]; 740 hpet_res->flags = IORESOURCE_MEM; 741 snprintf((char *)hpet_res->name, HPET_RESOURCE_NAME_SIZE, "HPET %u", 742 hpet_tbl->sequence); 743 744 hpet_res->start = hpet_address; 745 hpet_res->end = hpet_address + (1 * 1024) - 1; 746 747 return 0; 748 } 749 750 /* 751 * hpet_insert_resource inserts the HPET resources used into the resource 752 * tree. 753 */ 754 static __init int hpet_insert_resource(void) 755 { 756 if (!hpet_res) 757 return 1; 758 759 return insert_resource(&iomem_resource, hpet_res); 760 } 761 762 late_initcall(hpet_insert_resource); 763 764 #else 765 #define acpi_parse_hpet NULL 766 #endif 767 768 static int __init acpi_parse_fadt(struct acpi_table_header *table) 769 { 770 771 #ifdef CONFIG_X86_PM_TIMER 772 /* detect the location of the ACPI PM Timer */ 773 if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID) { 774 /* FADT rev. 2 */ 775 if (acpi_gbl_FADT.xpm_timer_block.space_id != 776 ACPI_ADR_SPACE_SYSTEM_IO) 777 return 0; 778 779 pmtmr_ioport = acpi_gbl_FADT.xpm_timer_block.address; 780 /* 781 * "X" fields are optional extensions to the original V1.0 782 * fields, so we must selectively expand V1.0 fields if the 783 * corresponding X field is zero. 784 */ 785 if (!pmtmr_ioport) 786 pmtmr_ioport = acpi_gbl_FADT.pm_timer_block; 787 } else { 788 /* FADT rev. 1 */ 789 pmtmr_ioport = acpi_gbl_FADT.pm_timer_block; 790 } 791 if (pmtmr_ioport) 792 printk(KERN_INFO PREFIX "PM-Timer IO Port: %#x\n", 793 pmtmr_ioport); 794 #endif 795 return 0; 796 } 797 798 #ifdef CONFIG_X86_LOCAL_APIC 799 /* 800 * Parse LAPIC entries in MADT 801 * returns 0 on success, < 0 on error 802 */ 803 804 static void __init acpi_register_lapic_address(unsigned long address) 805 { 806 mp_lapic_addr = address; 807 808 set_fixmap_nocache(FIX_APIC_BASE, address); 809 if (boot_cpu_physical_apicid == -1U) { 810 boot_cpu_physical_apicid = read_apic_id(); 811 apic_version[boot_cpu_physical_apicid] = 812 GET_APIC_VERSION(apic_read(APIC_LVR)); 813 } 814 } 815 816 static int __init early_acpi_parse_madt_lapic_addr_ovr(void) 817 { 818 int count; 819 820 if (!cpu_has_apic) 821 return -ENODEV; 822 823 /* 824 * Note that the LAPIC address is obtained from the MADT (32-bit value) 825 * and (optionally) overriden by a LAPIC_ADDR_OVR entry (64-bit value). 826 */ 827 828 count = 829 acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, 830 acpi_parse_lapic_addr_ovr, 0); 831 if (count < 0) { 832 printk(KERN_ERR PREFIX 833 "Error parsing LAPIC address override entry\n"); 834 return count; 835 } 836 837 acpi_register_lapic_address(acpi_lapic_addr); 838 839 return count; 840 } 841 842 static int __init acpi_parse_madt_lapic_entries(void) 843 { 844 int count; 845 int x2count = 0; 846 847 if (!cpu_has_apic) 848 return -ENODEV; 849 850 /* 851 * Note that the LAPIC address is obtained from the MADT (32-bit value) 852 * and (optionally) overriden by a LAPIC_ADDR_OVR entry (64-bit value). 853 */ 854 855 count = 856 acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, 857 acpi_parse_lapic_addr_ovr, 0); 858 if (count < 0) { 859 printk(KERN_ERR PREFIX 860 "Error parsing LAPIC address override entry\n"); 861 return count; 862 } 863 864 acpi_register_lapic_address(acpi_lapic_addr); 865 866 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_SAPIC, 867 acpi_parse_sapic, MAX_APICS); 868 869 if (!count) { 870 x2count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC, 871 acpi_parse_x2apic, MAX_APICS); 872 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC, 873 acpi_parse_lapic, MAX_APICS); 874 } 875 if (!count && !x2count) { 876 printk(KERN_ERR PREFIX "No LAPIC entries present\n"); 877 /* TBD: Cleanup to allow fallback to MPS */ 878 return -ENODEV; 879 } else if (count < 0 || x2count < 0) { 880 printk(KERN_ERR PREFIX "Error parsing LAPIC entry\n"); 881 /* TBD: Cleanup to allow fallback to MPS */ 882 return count; 883 } 884 885 x2count = 886 acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_X2APIC_NMI, 887 acpi_parse_x2apic_nmi, 0); 888 count = 889 acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI, acpi_parse_lapic_nmi, 0); 890 if (count < 0 || x2count < 0) { 891 printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n"); 892 /* TBD: Cleanup to allow fallback to MPS */ 893 return count; 894 } 895 return 0; 896 } 897 #endif /* CONFIG_X86_LOCAL_APIC */ 898 899 #ifdef CONFIG_X86_IO_APIC 900 #define MP_ISA_BUS 0 901 902 #ifdef CONFIG_X86_ES7000 903 extern int es7000_plat; 904 #endif 905 906 static struct { 907 int gsi_base; 908 int gsi_end; 909 } mp_ioapic_routing[MAX_IO_APICS]; 910 911 int mp_find_ioapic(int gsi) 912 { 913 int i = 0; 914 915 /* Find the IOAPIC that manages this GSI. */ 916 for (i = 0; i < nr_ioapics; i++) { 917 if ((gsi >= mp_ioapic_routing[i].gsi_base) 918 && (gsi <= mp_ioapic_routing[i].gsi_end)) 919 return i; 920 } 921 922 printk(KERN_ERR "ERROR: Unable to locate IOAPIC for GSI %d\n", gsi); 923 return -1; 924 } 925 926 int mp_find_ioapic_pin(int ioapic, int gsi) 927 { 928 if (WARN_ON(ioapic == -1)) 929 return -1; 930 if (WARN_ON(gsi > mp_ioapic_routing[ioapic].gsi_end)) 931 return -1; 932 933 return gsi - mp_ioapic_routing[ioapic].gsi_base; 934 } 935 936 static u8 __init uniq_ioapic_id(u8 id) 937 { 938 #ifdef CONFIG_X86_32 939 if ((boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) && 940 !APIC_XAPIC(apic_version[boot_cpu_physical_apicid])) 941 return io_apic_get_unique_id(nr_ioapics, id); 942 else 943 return id; 944 #else 945 int i; 946 DECLARE_BITMAP(used, 256); 947 bitmap_zero(used, 256); 948 for (i = 0; i < nr_ioapics; i++) { 949 struct mpc_ioapic *ia = &mp_ioapics[i]; 950 __set_bit(ia->apicid, used); 951 } 952 if (!test_bit(id, used)) 953 return id; 954 return find_first_zero_bit(used, 256); 955 #endif 956 } 957 958 static int bad_ioapic(unsigned long address) 959 { 960 if (nr_ioapics >= MAX_IO_APICS) { 961 printk(KERN_ERR "ERROR: Max # of I/O APICs (%d) exceeded " 962 "(found %d)\n", MAX_IO_APICS, nr_ioapics); 963 panic("Recompile kernel with bigger MAX_IO_APICS!\n"); 964 } 965 if (!address) { 966 printk(KERN_ERR "WARNING: Bogus (zero) I/O APIC address" 967 " found in table, skipping!\n"); 968 return 1; 969 } 970 return 0; 971 } 972 973 void __init mp_register_ioapic(int id, u32 address, u32 gsi_base) 974 { 975 int idx = 0; 976 977 if (bad_ioapic(address)) 978 return; 979 980 idx = nr_ioapics; 981 982 mp_ioapics[idx].type = MP_IOAPIC; 983 mp_ioapics[idx].flags = MPC_APIC_USABLE; 984 mp_ioapics[idx].apicaddr = address; 985 986 set_fixmap_nocache(FIX_IO_APIC_BASE_0 + idx, address); 987 mp_ioapics[idx].apicid = uniq_ioapic_id(id); 988 mp_ioapics[idx].apicver = io_apic_get_version(idx); 989 990 /* 991 * Build basic GSI lookup table to facilitate gsi->io_apic lookups 992 * and to prevent reprogramming of IOAPIC pins (PCI GSIs). 993 */ 994 mp_ioapic_routing[idx].gsi_base = gsi_base; 995 mp_ioapic_routing[idx].gsi_end = gsi_base + 996 io_apic_get_redir_entries(idx); 997 998 printk(KERN_INFO "IOAPIC[%d]: apic_id %d, version %d, address 0x%x, " 999 "GSI %d-%d\n", idx, mp_ioapics[idx].apicid, 1000 mp_ioapics[idx].apicver, mp_ioapics[idx].apicaddr, 1001 mp_ioapic_routing[idx].gsi_base, mp_ioapic_routing[idx].gsi_end); 1002 1003 nr_ioapics++; 1004 } 1005 1006 int __init acpi_probe_gsi(void) 1007 { 1008 int idx; 1009 int gsi; 1010 int max_gsi = 0; 1011 1012 if (acpi_disabled) 1013 return 0; 1014 1015 if (!acpi_ioapic) 1016 return 0; 1017 1018 max_gsi = 0; 1019 for (idx = 0; idx < nr_ioapics; idx++) { 1020 gsi = mp_ioapic_routing[idx].gsi_end; 1021 1022 if (gsi > max_gsi) 1023 max_gsi = gsi; 1024 } 1025 1026 return max_gsi + 1; 1027 } 1028 1029 static void assign_to_mp_irq(struct mpc_intsrc *m, 1030 struct mpc_intsrc *mp_irq) 1031 { 1032 memcpy(mp_irq, m, sizeof(struct mpc_intsrc)); 1033 } 1034 1035 static int mp_irq_cmp(struct mpc_intsrc *mp_irq, 1036 struct mpc_intsrc *m) 1037 { 1038 return memcmp(mp_irq, m, sizeof(struct mpc_intsrc)); 1039 } 1040 1041 static void save_mp_irq(struct mpc_intsrc *m) 1042 { 1043 int i; 1044 1045 for (i = 0; i < mp_irq_entries; i++) { 1046 if (!mp_irq_cmp(&mp_irqs[i], m)) 1047 return; 1048 } 1049 1050 assign_to_mp_irq(m, &mp_irqs[mp_irq_entries]); 1051 if (++mp_irq_entries == MAX_IRQ_SOURCES) 1052 panic("Max # of irq sources exceeded!!\n"); 1053 } 1054 1055 void __init mp_override_legacy_irq(u8 bus_irq, u8 polarity, u8 trigger, u32 gsi) 1056 { 1057 int ioapic; 1058 int pin; 1059 struct mpc_intsrc mp_irq; 1060 1061 /* 1062 * Convert 'gsi' to 'ioapic.pin'. 1063 */ 1064 ioapic = mp_find_ioapic(gsi); 1065 if (ioapic < 0) 1066 return; 1067 pin = mp_find_ioapic_pin(ioapic, gsi); 1068 1069 /* 1070 * TBD: This check is for faulty timer entries, where the override 1071 * erroneously sets the trigger to level, resulting in a HUGE 1072 * increase of timer interrupts! 1073 */ 1074 if ((bus_irq == 0) && (trigger == 3)) 1075 trigger = 1; 1076 1077 mp_irq.type = MP_INTSRC; 1078 mp_irq.irqtype = mp_INT; 1079 mp_irq.irqflag = (trigger << 2) | polarity; 1080 mp_irq.srcbus = MP_ISA_BUS; 1081 mp_irq.srcbusirq = bus_irq; /* IRQ */ 1082 mp_irq.dstapic = mp_ioapics[ioapic].apicid; /* APIC ID */ 1083 mp_irq.dstirq = pin; /* INTIN# */ 1084 1085 save_mp_irq(&mp_irq); 1086 } 1087 1088 void __init mp_config_acpi_legacy_irqs(void) 1089 { 1090 int i; 1091 int ioapic; 1092 unsigned int dstapic; 1093 struct mpc_intsrc mp_irq; 1094 1095 #if defined (CONFIG_MCA) || defined (CONFIG_EISA) 1096 /* 1097 * Fabricate the legacy ISA bus (bus #31). 1098 */ 1099 mp_bus_id_to_type[MP_ISA_BUS] = MP_BUS_ISA; 1100 #endif 1101 set_bit(MP_ISA_BUS, mp_bus_not_pci); 1102 pr_debug("Bus #%d is ISA\n", MP_ISA_BUS); 1103 1104 #ifdef CONFIG_X86_ES7000 1105 /* 1106 * Older generations of ES7000 have no legacy identity mappings 1107 */ 1108 if (es7000_plat == 1) 1109 return; 1110 #endif 1111 1112 /* 1113 * Locate the IOAPIC that manages the ISA IRQs (0-15). 1114 */ 1115 ioapic = mp_find_ioapic(0); 1116 if (ioapic < 0) 1117 return; 1118 dstapic = mp_ioapics[ioapic].apicid; 1119 1120 /* 1121 * Use the default configuration for the IRQs 0-15. Unless 1122 * overridden by (MADT) interrupt source override entries. 1123 */ 1124 for (i = 0; i < 16; i++) { 1125 int idx; 1126 1127 for (idx = 0; idx < mp_irq_entries; idx++) { 1128 struct mpc_intsrc *irq = mp_irqs + idx; 1129 1130 /* Do we already have a mapping for this ISA IRQ? */ 1131 if (irq->srcbus == MP_ISA_BUS && irq->srcbusirq == i) 1132 break; 1133 1134 /* Do we already have a mapping for this IOAPIC pin */ 1135 if (irq->dstapic == dstapic && irq->dstirq == i) 1136 break; 1137 } 1138 1139 if (idx != mp_irq_entries) { 1140 printk(KERN_DEBUG "ACPI: IRQ%d used by override.\n", i); 1141 continue; /* IRQ already used */ 1142 } 1143 1144 mp_irq.type = MP_INTSRC; 1145 mp_irq.irqflag = 0; /* Conforming */ 1146 mp_irq.srcbus = MP_ISA_BUS; 1147 mp_irq.dstapic = dstapic; 1148 mp_irq.irqtype = mp_INT; 1149 mp_irq.srcbusirq = i; /* Identity mapped */ 1150 mp_irq.dstirq = i; 1151 1152 save_mp_irq(&mp_irq); 1153 } 1154 } 1155 1156 static int mp_config_acpi_gsi(struct device *dev, u32 gsi, int trigger, 1157 int polarity) 1158 { 1159 #ifdef CONFIG_X86_MPPARSE 1160 struct mpc_intsrc mp_irq; 1161 struct pci_dev *pdev; 1162 unsigned char number; 1163 unsigned int devfn; 1164 int ioapic; 1165 u8 pin; 1166 1167 if (!acpi_ioapic) 1168 return 0; 1169 if (!dev) 1170 return 0; 1171 if (dev->bus != &pci_bus_type) 1172 return 0; 1173 1174 pdev = to_pci_dev(dev); 1175 number = pdev->bus->number; 1176 devfn = pdev->devfn; 1177 pin = pdev->pin; 1178 /* print the entry should happen on mptable identically */ 1179 mp_irq.type = MP_INTSRC; 1180 mp_irq.irqtype = mp_INT; 1181 mp_irq.irqflag = (trigger == ACPI_EDGE_SENSITIVE ? 4 : 0x0c) | 1182 (polarity == ACPI_ACTIVE_HIGH ? 1 : 3); 1183 mp_irq.srcbus = number; 1184 mp_irq.srcbusirq = (((devfn >> 3) & 0x1f) << 2) | ((pin - 1) & 3); 1185 ioapic = mp_find_ioapic(gsi); 1186 mp_irq.dstapic = mp_ioapics[ioapic].apicid; 1187 mp_irq.dstirq = mp_find_ioapic_pin(ioapic, gsi); 1188 1189 save_mp_irq(&mp_irq); 1190 #endif 1191 return 0; 1192 } 1193 1194 int mp_register_gsi(struct device *dev, u32 gsi, int trigger, int polarity) 1195 { 1196 int ioapic; 1197 int ioapic_pin; 1198 struct io_apic_irq_attr irq_attr; 1199 1200 if (acpi_irq_model != ACPI_IRQ_MODEL_IOAPIC) 1201 return gsi; 1202 1203 /* Don't set up the ACPI SCI because it's already set up */ 1204 if (acpi_gbl_FADT.sci_interrupt == gsi) 1205 return gsi; 1206 1207 ioapic = mp_find_ioapic(gsi); 1208 if (ioapic < 0) { 1209 printk(KERN_WARNING "No IOAPIC for GSI %u\n", gsi); 1210 return gsi; 1211 } 1212 1213 ioapic_pin = mp_find_ioapic_pin(ioapic, gsi); 1214 1215 #ifdef CONFIG_X86_32 1216 if (ioapic_renumber_irq) 1217 gsi = ioapic_renumber_irq(ioapic, gsi); 1218 #endif 1219 1220 if (ioapic_pin > MP_MAX_IOAPIC_PIN) { 1221 printk(KERN_ERR "Invalid reference to IOAPIC pin " 1222 "%d-%d\n", mp_ioapics[ioapic].apicid, 1223 ioapic_pin); 1224 return gsi; 1225 } 1226 1227 if (enable_update_mptable) 1228 mp_config_acpi_gsi(dev, gsi, trigger, polarity); 1229 1230 set_io_apic_irq_attr(&irq_attr, ioapic, ioapic_pin, 1231 trigger == ACPI_EDGE_SENSITIVE ? 0 : 1, 1232 polarity == ACPI_ACTIVE_HIGH ? 0 : 1); 1233 io_apic_set_pci_routing(dev, gsi, &irq_attr); 1234 1235 return gsi; 1236 } 1237 1238 /* 1239 * Parse IOAPIC related entries in MADT 1240 * returns 0 on success, < 0 on error 1241 */ 1242 static int __init acpi_parse_madt_ioapic_entries(void) 1243 { 1244 int count; 1245 1246 /* 1247 * ACPI interpreter is required to complete interrupt setup, 1248 * so if it is off, don't enumerate the io-apics with ACPI. 1249 * If MPS is present, it will handle them, 1250 * otherwise the system will stay in PIC mode 1251 */ 1252 if (acpi_disabled || acpi_noirq) { 1253 return -ENODEV; 1254 } 1255 1256 if (!cpu_has_apic) 1257 return -ENODEV; 1258 1259 /* 1260 * if "noapic" boot option, don't look for IO-APICs 1261 */ 1262 if (skip_ioapic_setup) { 1263 printk(KERN_INFO PREFIX "Skipping IOAPIC probe " 1264 "due to 'noapic' option.\n"); 1265 return -ENODEV; 1266 } 1267 1268 count = 1269 acpi_table_parse_madt(ACPI_MADT_TYPE_IO_APIC, acpi_parse_ioapic, 1270 MAX_IO_APICS); 1271 if (!count) { 1272 printk(KERN_ERR PREFIX "No IOAPIC entries present\n"); 1273 return -ENODEV; 1274 } else if (count < 0) { 1275 printk(KERN_ERR PREFIX "Error parsing IOAPIC entry\n"); 1276 return count; 1277 } 1278 1279 count = 1280 acpi_table_parse_madt(ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, acpi_parse_int_src_ovr, 1281 nr_irqs); 1282 if (count < 0) { 1283 printk(KERN_ERR PREFIX 1284 "Error parsing interrupt source overrides entry\n"); 1285 /* TBD: Cleanup to allow fallback to MPS */ 1286 return count; 1287 } 1288 1289 /* 1290 * If BIOS did not supply an INT_SRC_OVR for the SCI 1291 * pretend we got one so we can set the SCI flags. 1292 */ 1293 if (!acpi_sci_override_gsi) 1294 acpi_sci_ioapic_setup(acpi_gbl_FADT.sci_interrupt, 0, 0); 1295 1296 /* Fill in identity legacy mapings where no override */ 1297 mp_config_acpi_legacy_irqs(); 1298 1299 count = 1300 acpi_table_parse_madt(ACPI_MADT_TYPE_NMI_SOURCE, acpi_parse_nmi_src, 1301 nr_irqs); 1302 if (count < 0) { 1303 printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n"); 1304 /* TBD: Cleanup to allow fallback to MPS */ 1305 return count; 1306 } 1307 1308 return 0; 1309 } 1310 #else 1311 static inline int acpi_parse_madt_ioapic_entries(void) 1312 { 1313 return -1; 1314 } 1315 #endif /* !CONFIG_X86_IO_APIC */ 1316 1317 static void __init early_acpi_process_madt(void) 1318 { 1319 #ifdef CONFIG_X86_LOCAL_APIC 1320 int error; 1321 1322 if (!acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) { 1323 1324 /* 1325 * Parse MADT LAPIC entries 1326 */ 1327 error = early_acpi_parse_madt_lapic_addr_ovr(); 1328 if (!error) { 1329 acpi_lapic = 1; 1330 smp_found_config = 1; 1331 } 1332 if (error == -EINVAL) { 1333 /* 1334 * Dell Precision Workstation 410, 610 come here. 1335 */ 1336 printk(KERN_ERR PREFIX 1337 "Invalid BIOS MADT, disabling ACPI\n"); 1338 disable_acpi(); 1339 } 1340 } 1341 #endif 1342 } 1343 1344 static void __init acpi_process_madt(void) 1345 { 1346 #ifdef CONFIG_X86_LOCAL_APIC 1347 int error; 1348 1349 if (!acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) { 1350 1351 /* 1352 * Parse MADT LAPIC entries 1353 */ 1354 error = acpi_parse_madt_lapic_entries(); 1355 if (!error) { 1356 acpi_lapic = 1; 1357 1358 #ifdef CONFIG_X86_BIGSMP 1359 generic_bigsmp_probe(); 1360 #endif 1361 /* 1362 * Parse MADT IO-APIC entries 1363 */ 1364 error = acpi_parse_madt_ioapic_entries(); 1365 if (!error) { 1366 acpi_irq_model = ACPI_IRQ_MODEL_IOAPIC; 1367 acpi_ioapic = 1; 1368 1369 smp_found_config = 1; 1370 if (apic->setup_apic_routing) 1371 apic->setup_apic_routing(); 1372 } 1373 } 1374 if (error == -EINVAL) { 1375 /* 1376 * Dell Precision Workstation 410, 610 come here. 1377 */ 1378 printk(KERN_ERR PREFIX 1379 "Invalid BIOS MADT, disabling ACPI\n"); 1380 disable_acpi(); 1381 } 1382 } else { 1383 /* 1384 * ACPI found no MADT, and so ACPI wants UP PIC mode. 1385 * In the event an MPS table was found, forget it. 1386 * Boot with "acpi=off" to use MPS on such a system. 1387 */ 1388 if (smp_found_config) { 1389 printk(KERN_WARNING PREFIX 1390 "No APIC-table, disabling MPS\n"); 1391 smp_found_config = 0; 1392 } 1393 } 1394 1395 /* 1396 * ACPI supports both logical (e.g. Hyper-Threading) and physical 1397 * processors, where MPS only supports physical. 1398 */ 1399 if (acpi_lapic && acpi_ioapic) 1400 printk(KERN_INFO "Using ACPI (MADT) for SMP configuration " 1401 "information\n"); 1402 else if (acpi_lapic) 1403 printk(KERN_INFO "Using ACPI for processor (LAPIC) " 1404 "configuration information\n"); 1405 #endif 1406 return; 1407 } 1408 1409 static int __init disable_acpi_irq(const struct dmi_system_id *d) 1410 { 1411 if (!acpi_force) { 1412 printk(KERN_NOTICE "%s detected: force use of acpi=noirq\n", 1413 d->ident); 1414 acpi_noirq_set(); 1415 } 1416 return 0; 1417 } 1418 1419 static int __init disable_acpi_pci(const struct dmi_system_id *d) 1420 { 1421 if (!acpi_force) { 1422 printk(KERN_NOTICE "%s detected: force use of pci=noacpi\n", 1423 d->ident); 1424 acpi_disable_pci(); 1425 } 1426 return 0; 1427 } 1428 1429 static int __init dmi_disable_acpi(const struct dmi_system_id *d) 1430 { 1431 if (!acpi_force) { 1432 printk(KERN_NOTICE "%s detected: acpi off\n", d->ident); 1433 disable_acpi(); 1434 } else { 1435 printk(KERN_NOTICE 1436 "Warning: DMI blacklist says broken, but acpi forced\n"); 1437 } 1438 return 0; 1439 } 1440 1441 /* 1442 * Limit ACPI to CPU enumeration for HT 1443 */ 1444 static int __init force_acpi_ht(const struct dmi_system_id *d) 1445 { 1446 if (!acpi_force) { 1447 printk(KERN_NOTICE "%s detected: force use of acpi=ht\n", 1448 d->ident); 1449 disable_acpi(); 1450 acpi_ht = 1; 1451 } else { 1452 printk(KERN_NOTICE 1453 "Warning: acpi=force overrules DMI blacklist: acpi=ht\n"); 1454 } 1455 return 0; 1456 } 1457 1458 /* 1459 * Force ignoring BIOS IRQ0 pin2 override 1460 */ 1461 static int __init dmi_ignore_irq0_timer_override(const struct dmi_system_id *d) 1462 { 1463 /* 1464 * The ati_ixp4x0_rev() early PCI quirk should have set 1465 * the acpi_skip_timer_override flag already: 1466 */ 1467 if (!acpi_skip_timer_override) { 1468 WARN(1, KERN_ERR "ati_ixp4x0 quirk not complete.\n"); 1469 pr_notice("%s detected: Ignoring BIOS IRQ0 pin2 override\n", 1470 d->ident); 1471 acpi_skip_timer_override = 1; 1472 } 1473 return 0; 1474 } 1475 1476 /* 1477 * If your system is blacklisted here, but you find that acpi=force 1478 * works for you, please contact linux-acpi@vger.kernel.org 1479 */ 1480 static struct dmi_system_id __initdata acpi_dmi_table[] = { 1481 /* 1482 * Boxes that need ACPI disabled 1483 */ 1484 { 1485 .callback = dmi_disable_acpi, 1486 .ident = "IBM Thinkpad", 1487 .matches = { 1488 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1489 DMI_MATCH(DMI_BOARD_NAME, "2629H1G"), 1490 }, 1491 }, 1492 1493 /* 1494 * Boxes that need acpi=ht 1495 */ 1496 { 1497 .callback = force_acpi_ht, 1498 .ident = "FSC Primergy T850", 1499 .matches = { 1500 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 1501 DMI_MATCH(DMI_PRODUCT_NAME, "PRIMERGY T850"), 1502 }, 1503 }, 1504 { 1505 .callback = force_acpi_ht, 1506 .ident = "HP VISUALIZE NT Workstation", 1507 .matches = { 1508 DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"), 1509 DMI_MATCH(DMI_PRODUCT_NAME, "HP VISUALIZE NT Workstation"), 1510 }, 1511 }, 1512 { 1513 .callback = force_acpi_ht, 1514 .ident = "Compaq Workstation W8000", 1515 .matches = { 1516 DMI_MATCH(DMI_SYS_VENDOR, "Compaq"), 1517 DMI_MATCH(DMI_PRODUCT_NAME, "Workstation W8000"), 1518 }, 1519 }, 1520 { 1521 .callback = force_acpi_ht, 1522 .ident = "ASUS P4B266", 1523 .matches = { 1524 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1525 DMI_MATCH(DMI_BOARD_NAME, "P4B266"), 1526 }, 1527 }, 1528 { 1529 .callback = force_acpi_ht, 1530 .ident = "ASUS P2B-DS", 1531 .matches = { 1532 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1533 DMI_MATCH(DMI_BOARD_NAME, "P2B-DS"), 1534 }, 1535 }, 1536 { 1537 .callback = force_acpi_ht, 1538 .ident = "ASUS CUR-DLS", 1539 .matches = { 1540 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1541 DMI_MATCH(DMI_BOARD_NAME, "CUR-DLS"), 1542 }, 1543 }, 1544 { 1545 .callback = force_acpi_ht, 1546 .ident = "ABIT i440BX-W83977", 1547 .matches = { 1548 DMI_MATCH(DMI_BOARD_VENDOR, "ABIT <http://www.abit.com>"), 1549 DMI_MATCH(DMI_BOARD_NAME, "i440BX-W83977 (BP6)"), 1550 }, 1551 }, 1552 { 1553 .callback = force_acpi_ht, 1554 .ident = "IBM Bladecenter", 1555 .matches = { 1556 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1557 DMI_MATCH(DMI_BOARD_NAME, "IBM eServer BladeCenter HS20"), 1558 }, 1559 }, 1560 { 1561 .callback = force_acpi_ht, 1562 .ident = "IBM eServer xSeries 360", 1563 .matches = { 1564 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1565 DMI_MATCH(DMI_BOARD_NAME, "eServer xSeries 360"), 1566 }, 1567 }, 1568 { 1569 .callback = force_acpi_ht, 1570 .ident = "IBM eserver xSeries 330", 1571 .matches = { 1572 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1573 DMI_MATCH(DMI_BOARD_NAME, "eserver xSeries 330"), 1574 }, 1575 }, 1576 { 1577 .callback = force_acpi_ht, 1578 .ident = "IBM eserver xSeries 440", 1579 .matches = { 1580 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1581 DMI_MATCH(DMI_PRODUCT_NAME, "eserver xSeries 440"), 1582 }, 1583 }, 1584 1585 /* 1586 * Boxes that need ACPI PCI IRQ routing disabled 1587 */ 1588 { 1589 .callback = disable_acpi_irq, 1590 .ident = "ASUS A7V", 1591 .matches = { 1592 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC"), 1593 DMI_MATCH(DMI_BOARD_NAME, "<A7V>"), 1594 /* newer BIOS, Revision 1011, does work */ 1595 DMI_MATCH(DMI_BIOS_VERSION, 1596 "ASUS A7V ACPI BIOS Revision 1007"), 1597 }, 1598 }, 1599 { 1600 /* 1601 * Latest BIOS for IBM 600E (1.16) has bad pcinum 1602 * for LPC bridge, which is needed for the PCI 1603 * interrupt links to work. DSDT fix is in bug 5966. 1604 * 2645, 2646 model numbers are shared with 600/600E/600X 1605 */ 1606 .callback = disable_acpi_irq, 1607 .ident = "IBM Thinkpad 600 Series 2645", 1608 .matches = { 1609 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1610 DMI_MATCH(DMI_BOARD_NAME, "2645"), 1611 }, 1612 }, 1613 { 1614 .callback = disable_acpi_irq, 1615 .ident = "IBM Thinkpad 600 Series 2646", 1616 .matches = { 1617 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1618 DMI_MATCH(DMI_BOARD_NAME, "2646"), 1619 }, 1620 }, 1621 /* 1622 * Boxes that need ACPI PCI IRQ routing and PCI scan disabled 1623 */ 1624 { /* _BBN 0 bug */ 1625 .callback = disable_acpi_pci, 1626 .ident = "ASUS PR-DLS", 1627 .matches = { 1628 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1629 DMI_MATCH(DMI_BOARD_NAME, "PR-DLS"), 1630 DMI_MATCH(DMI_BIOS_VERSION, 1631 "ASUS PR-DLS ACPI BIOS Revision 1010"), 1632 DMI_MATCH(DMI_BIOS_DATE, "03/21/2003") 1633 }, 1634 }, 1635 { 1636 .callback = disable_acpi_pci, 1637 .ident = "Acer TravelMate 36x Laptop", 1638 .matches = { 1639 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 1640 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"), 1641 }, 1642 }, 1643 {} 1644 }; 1645 1646 /* second table for DMI checks that should run after early-quirks */ 1647 static struct dmi_system_id __initdata acpi_dmi_table_late[] = { 1648 /* 1649 * HP laptops which use a DSDT reporting as HP/SB400/10000, 1650 * which includes some code which overrides all temperature 1651 * trip points to 16C if the INTIN2 input of the I/O APIC 1652 * is enabled. This input is incorrectly designated the 1653 * ISA IRQ 0 via an interrupt source override even though 1654 * it is wired to the output of the master 8259A and INTIN0 1655 * is not connected at all. Force ignoring BIOS IRQ0 pin2 1656 * override in that cases. 1657 */ 1658 { 1659 .callback = dmi_ignore_irq0_timer_override, 1660 .ident = "HP nx6115 laptop", 1661 .matches = { 1662 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1663 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6115"), 1664 }, 1665 }, 1666 { 1667 .callback = dmi_ignore_irq0_timer_override, 1668 .ident = "HP NX6125 laptop", 1669 .matches = { 1670 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1671 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6125"), 1672 }, 1673 }, 1674 { 1675 .callback = dmi_ignore_irq0_timer_override, 1676 .ident = "HP NX6325 laptop", 1677 .matches = { 1678 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1679 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq nx6325"), 1680 }, 1681 }, 1682 { 1683 .callback = dmi_ignore_irq0_timer_override, 1684 .ident = "HP 6715b laptop", 1685 .matches = { 1686 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1687 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq 6715b"), 1688 }, 1689 }, 1690 {} 1691 }; 1692 1693 /* 1694 * acpi_boot_table_init() and acpi_boot_init() 1695 * called from setup_arch(), always. 1696 * 1. checksums all tables 1697 * 2. enumerates lapics 1698 * 3. enumerates io-apics 1699 * 1700 * acpi_table_init() is separate to allow reading SRAT without 1701 * other side effects. 1702 * 1703 * side effects of acpi_boot_init: 1704 * acpi_lapic = 1 if LAPIC found 1705 * acpi_ioapic = 1 if IOAPIC found 1706 * if (acpi_lapic && acpi_ioapic) smp_found_config = 1; 1707 * if acpi_blacklisted() acpi_disabled = 1; 1708 * acpi_irq_model=... 1709 * ... 1710 * 1711 * return value: (currently ignored) 1712 * 0: success 1713 * !0: failure 1714 */ 1715 1716 int __init acpi_boot_table_init(void) 1717 { 1718 int error; 1719 1720 dmi_check_system(acpi_dmi_table); 1721 1722 /* 1723 * If acpi_disabled, bail out 1724 * One exception: acpi=ht continues far enough to enumerate LAPICs 1725 */ 1726 if (acpi_disabled && !acpi_ht) 1727 return 1; 1728 1729 /* 1730 * Initialize the ACPI boot-time table parser. 1731 */ 1732 error = acpi_table_init(); 1733 if (error) { 1734 disable_acpi(); 1735 return error; 1736 } 1737 1738 acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf); 1739 1740 /* 1741 * blacklist may disable ACPI entirely 1742 */ 1743 error = acpi_blacklisted(); 1744 if (error) { 1745 if (acpi_force) { 1746 printk(KERN_WARNING PREFIX "acpi=force override\n"); 1747 } else { 1748 printk(KERN_WARNING PREFIX "Disabling ACPI support\n"); 1749 disable_acpi(); 1750 return error; 1751 } 1752 } 1753 1754 return 0; 1755 } 1756 1757 int __init early_acpi_boot_init(void) 1758 { 1759 /* 1760 * If acpi_disabled, bail out 1761 * One exception: acpi=ht continues far enough to enumerate LAPICs 1762 */ 1763 if (acpi_disabled && !acpi_ht) 1764 return 1; 1765 1766 /* 1767 * Process the Multiple APIC Description Table (MADT), if present 1768 */ 1769 early_acpi_process_madt(); 1770 1771 return 0; 1772 } 1773 1774 int __init acpi_boot_init(void) 1775 { 1776 /* those are executed after early-quirks are executed */ 1777 dmi_check_system(acpi_dmi_table_late); 1778 1779 /* 1780 * If acpi_disabled, bail out 1781 * One exception: acpi=ht continues far enough to enumerate LAPICs 1782 */ 1783 if (acpi_disabled && !acpi_ht) 1784 return 1; 1785 1786 acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf); 1787 1788 /* 1789 * set sci_int and PM timer address 1790 */ 1791 acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt); 1792 1793 /* 1794 * Process the Multiple APIC Description Table (MADT), if present 1795 */ 1796 acpi_process_madt(); 1797 1798 acpi_table_parse(ACPI_SIG_HPET, acpi_parse_hpet); 1799 1800 return 0; 1801 } 1802 1803 static int __init parse_acpi(char *arg) 1804 { 1805 if (!arg) 1806 return -EINVAL; 1807 1808 /* "acpi=off" disables both ACPI table parsing and interpreter */ 1809 if (strcmp(arg, "off") == 0) { 1810 disable_acpi(); 1811 } 1812 /* acpi=force to over-ride black-list */ 1813 else if (strcmp(arg, "force") == 0) { 1814 acpi_force = 1; 1815 acpi_ht = 1; 1816 acpi_disabled = 0; 1817 } 1818 /* acpi=strict disables out-of-spec workarounds */ 1819 else if (strcmp(arg, "strict") == 0) { 1820 acpi_strict = 1; 1821 } 1822 /* Limit ACPI just to boot-time to enable HT */ 1823 else if (strcmp(arg, "ht") == 0) { 1824 if (!acpi_force) 1825 disable_acpi(); 1826 acpi_ht = 1; 1827 } 1828 /* acpi=rsdt use RSDT instead of XSDT */ 1829 else if (strcmp(arg, "rsdt") == 0) { 1830 acpi_rsdt_forced = 1; 1831 } 1832 /* "acpi=noirq" disables ACPI interrupt routing */ 1833 else if (strcmp(arg, "noirq") == 0) { 1834 acpi_noirq_set(); 1835 } else { 1836 /* Core will printk when we return error. */ 1837 return -EINVAL; 1838 } 1839 return 0; 1840 } 1841 early_param("acpi", parse_acpi); 1842 1843 /* FIXME: Using pci= for an ACPI parameter is a travesty. */ 1844 static int __init parse_pci(char *arg) 1845 { 1846 if (arg && strcmp(arg, "noacpi") == 0) 1847 acpi_disable_pci(); 1848 return 0; 1849 } 1850 early_param("pci", parse_pci); 1851 1852 int __init acpi_mps_check(void) 1853 { 1854 #if defined(CONFIG_X86_LOCAL_APIC) && !defined(CONFIG_X86_MPPARSE) 1855 /* mptable code is not built-in*/ 1856 if (acpi_disabled || acpi_noirq) { 1857 printk(KERN_WARNING "MPS support code is not built-in.\n" 1858 "Using acpi=off or acpi=noirq or pci=noacpi " 1859 "may have problem\n"); 1860 return 1; 1861 } 1862 #endif 1863 return 0; 1864 } 1865 1866 #ifdef CONFIG_X86_IO_APIC 1867 static int __init parse_acpi_skip_timer_override(char *arg) 1868 { 1869 acpi_skip_timer_override = 1; 1870 return 0; 1871 } 1872 early_param("acpi_skip_timer_override", parse_acpi_skip_timer_override); 1873 1874 static int __init parse_acpi_use_timer_override(char *arg) 1875 { 1876 acpi_use_timer_override = 1; 1877 return 0; 1878 } 1879 early_param("acpi_use_timer_override", parse_acpi_use_timer_override); 1880 #endif /* CONFIG_X86_IO_APIC */ 1881 1882 static int __init setup_acpi_sci(char *s) 1883 { 1884 if (!s) 1885 return -EINVAL; 1886 if (!strcmp(s, "edge")) 1887 acpi_sci_flags = ACPI_MADT_TRIGGER_EDGE | 1888 (acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK); 1889 else if (!strcmp(s, "level")) 1890 acpi_sci_flags = ACPI_MADT_TRIGGER_LEVEL | 1891 (acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK); 1892 else if (!strcmp(s, "high")) 1893 acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_HIGH | 1894 (acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK); 1895 else if (!strcmp(s, "low")) 1896 acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_LOW | 1897 (acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK); 1898 else 1899 return -EINVAL; 1900 return 0; 1901 } 1902 early_param("acpi_sci", setup_acpi_sci); 1903 1904 int __acpi_acquire_global_lock(unsigned int *lock) 1905 { 1906 unsigned int old, new, val; 1907 do { 1908 old = *lock; 1909 new = (((old & ~0x3) + 2) + ((old >> 1) & 0x1)); 1910 val = cmpxchg(lock, old, new); 1911 } while (unlikely (val != old)); 1912 return (new < 3) ? -1 : 0; 1913 } 1914 1915 int __acpi_release_global_lock(unsigned int *lock) 1916 { 1917 unsigned int old, new, val; 1918 do { 1919 old = *lock; 1920 new = old & ~0x3; 1921 val = cmpxchg(lock, old, new); 1922 } while (unlikely (val != old)); 1923 return old & 0x1; 1924 } 1925