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 37 #include <asm/pgtable.h> 38 #include <asm/io_apic.h> 39 #include <asm/apic.h> 40 #include <asm/io.h> 41 #include <asm/mpspec.h> 42 43 static int __initdata acpi_force = 0; 44 45 #ifdef CONFIG_ACPI 46 int acpi_disabled = 0; 47 #else 48 int acpi_disabled = 1; 49 #endif 50 EXPORT_SYMBOL(acpi_disabled); 51 52 #ifdef CONFIG_X86_64 53 54 #include <asm/proto.h> 55 56 static inline int acpi_madt_oem_check(char *oem_id, char *oem_table_id) { return 0; } 57 58 59 #else /* X86 */ 60 61 #ifdef CONFIG_X86_LOCAL_APIC 62 #include <mach_apic.h> 63 #include <mach_mpparse.h> 64 #endif /* CONFIG_X86_LOCAL_APIC */ 65 66 #endif /* X86 */ 67 68 #define BAD_MADT_ENTRY(entry, end) ( \ 69 (!entry) || (unsigned long)entry + sizeof(*entry) > end || \ 70 ((struct acpi_subtable_header *)entry)->length < sizeof(*entry)) 71 72 #define PREFIX "ACPI: " 73 74 int acpi_noirq; /* skip ACPI IRQ initialization */ 75 int acpi_pci_disabled __initdata; /* skip ACPI PCI scan and IRQ initialization */ 76 int acpi_ht __initdata = 1; /* enable HT */ 77 78 int acpi_lapic; 79 int acpi_ioapic; 80 int acpi_strict; 81 82 u8 acpi_sci_flags __initdata; 83 int acpi_sci_override_gsi __initdata; 84 int acpi_skip_timer_override __initdata; 85 int acpi_use_timer_override __initdata; 86 87 #ifdef CONFIG_X86_LOCAL_APIC 88 static u64 acpi_lapic_addr __initdata = APIC_DEFAULT_PHYS_BASE; 89 #endif 90 91 #ifndef __HAVE_ARCH_CMPXCHG 92 #warning ACPI uses CMPXCHG, i486 and later hardware 93 #endif 94 95 /* -------------------------------------------------------------------------- 96 Boot-time Configuration 97 -------------------------------------------------------------------------- */ 98 99 /* 100 * The default interrupt routing model is PIC (8259). This gets 101 * overridden if IOAPICs are enumerated (below). 102 */ 103 enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_PIC; 104 105 #ifdef CONFIG_X86_64 106 107 /* rely on all ACPI tables being in the direct mapping */ 108 char *__init __acpi_map_table(unsigned long phys_addr, unsigned long size) 109 { 110 if (!phys_addr || !size) 111 return NULL; 112 113 if (phys_addr+size <= (end_pfn_map << PAGE_SHIFT) + PAGE_SIZE) 114 return __va(phys_addr); 115 116 return NULL; 117 } 118 119 #else 120 121 /* 122 * Temporarily use the virtual area starting from FIX_IO_APIC_BASE_END, 123 * to map the target physical address. The problem is that set_fixmap() 124 * provides a single page, and it is possible that the page is not 125 * sufficient. 126 * By using this area, we can map up to MAX_IO_APICS pages temporarily, 127 * i.e. until the next __va_range() call. 128 * 129 * Important Safety Note: The fixed I/O APIC page numbers are *subtracted* 130 * from the fixed base. That's why we start at FIX_IO_APIC_BASE_END and 131 * count idx down while incrementing the phys address. 132 */ 133 char *__init __acpi_map_table(unsigned long phys, unsigned long size) 134 { 135 unsigned long base, offset, mapped_size; 136 int idx; 137 138 if (phys + size < 8 * 1024 * 1024) 139 return __va(phys); 140 141 offset = phys & (PAGE_SIZE - 1); 142 mapped_size = PAGE_SIZE - offset; 143 set_fixmap(FIX_ACPI_END, phys); 144 base = fix_to_virt(FIX_ACPI_END); 145 146 /* 147 * Most cases can be covered by the below. 148 */ 149 idx = FIX_ACPI_END; 150 while (mapped_size < size) { 151 if (--idx < FIX_ACPI_BEGIN) 152 return NULL; /* cannot handle this */ 153 phys += PAGE_SIZE; 154 set_fixmap(idx, phys); 155 mapped_size += PAGE_SIZE; 156 } 157 158 return ((unsigned char *)base + offset); 159 } 160 #endif 161 162 #ifdef CONFIG_PCI_MMCONFIG 163 /* The physical address of the MMCONFIG aperture. Set from ACPI tables. */ 164 struct acpi_mcfg_allocation *pci_mmcfg_config; 165 int pci_mmcfg_config_num; 166 167 int __init acpi_parse_mcfg(struct acpi_table_header *header) 168 { 169 struct acpi_table_mcfg *mcfg; 170 unsigned long i; 171 int config_size; 172 173 if (!header) 174 return -EINVAL; 175 176 mcfg = (struct acpi_table_mcfg *)header; 177 178 /* how many config structures do we have */ 179 pci_mmcfg_config_num = 0; 180 i = header->length - sizeof(struct acpi_table_mcfg); 181 while (i >= sizeof(struct acpi_mcfg_allocation)) { 182 ++pci_mmcfg_config_num; 183 i -= sizeof(struct acpi_mcfg_allocation); 184 }; 185 if (pci_mmcfg_config_num == 0) { 186 printk(KERN_ERR PREFIX "MMCONFIG has no entries\n"); 187 return -ENODEV; 188 } 189 190 config_size = pci_mmcfg_config_num * sizeof(*pci_mmcfg_config); 191 pci_mmcfg_config = kmalloc(config_size, GFP_KERNEL); 192 if (!pci_mmcfg_config) { 193 printk(KERN_WARNING PREFIX 194 "No memory for MCFG config tables\n"); 195 return -ENOMEM; 196 } 197 198 memcpy(pci_mmcfg_config, &mcfg[1], config_size); 199 for (i = 0; i < pci_mmcfg_config_num; ++i) { 200 if (pci_mmcfg_config[i].address > 0xFFFFFFFF) { 201 printk(KERN_ERR PREFIX 202 "MMCONFIG not in low 4GB of memory\n"); 203 kfree(pci_mmcfg_config); 204 pci_mmcfg_config_num = 0; 205 return -ENODEV; 206 } 207 } 208 209 return 0; 210 } 211 #endif /* CONFIG_PCI_MMCONFIG */ 212 213 #ifdef CONFIG_X86_LOCAL_APIC 214 static int __init acpi_parse_madt(struct acpi_table_header *table) 215 { 216 struct acpi_table_madt *madt = NULL; 217 218 if (!cpu_has_apic) 219 return -EINVAL; 220 221 madt = (struct acpi_table_madt *)table; 222 if (!madt) { 223 printk(KERN_WARNING PREFIX "Unable to map MADT\n"); 224 return -ENODEV; 225 } 226 227 if (madt->address) { 228 acpi_lapic_addr = (u64) madt->address; 229 230 printk(KERN_DEBUG PREFIX "Local APIC address 0x%08x\n", 231 madt->address); 232 } 233 234 acpi_madt_oem_check(madt->header.oem_id, madt->header.oem_table_id); 235 236 return 0; 237 } 238 239 static int __init 240 acpi_parse_lapic(struct acpi_subtable_header * header, const unsigned long end) 241 { 242 struct acpi_madt_local_apic *processor = NULL; 243 244 processor = (struct acpi_madt_local_apic *)header; 245 246 if (BAD_MADT_ENTRY(processor, end)) 247 return -EINVAL; 248 249 acpi_table_print_madt_entry(header); 250 251 /* 252 * We need to register disabled CPU as well to permit 253 * counting disabled CPUs. This allows us to size 254 * cpus_possible_map more accurately, to permit 255 * to not preallocating memory for all NR_CPUS 256 * when we use CPU hotplug. 257 */ 258 mp_register_lapic(processor->id, /* APIC ID */ 259 processor->lapic_flags & ACPI_MADT_ENABLED); /* Enabled? */ 260 261 return 0; 262 } 263 264 static int __init 265 acpi_parse_lapic_addr_ovr(struct acpi_subtable_header * header, 266 const unsigned long end) 267 { 268 struct acpi_madt_local_apic_override *lapic_addr_ovr = NULL; 269 270 lapic_addr_ovr = (struct acpi_madt_local_apic_override *)header; 271 272 if (BAD_MADT_ENTRY(lapic_addr_ovr, end)) 273 return -EINVAL; 274 275 acpi_lapic_addr = lapic_addr_ovr->address; 276 277 return 0; 278 } 279 280 static int __init 281 acpi_parse_lapic_nmi(struct acpi_subtable_header * header, const unsigned long end) 282 { 283 struct acpi_madt_local_apic_nmi *lapic_nmi = NULL; 284 285 lapic_nmi = (struct acpi_madt_local_apic_nmi *)header; 286 287 if (BAD_MADT_ENTRY(lapic_nmi, end)) 288 return -EINVAL; 289 290 acpi_table_print_madt_entry(header); 291 292 if (lapic_nmi->lint != 1) 293 printk(KERN_WARNING PREFIX "NMI not connected to LINT 1!\n"); 294 295 return 0; 296 } 297 298 #endif /*CONFIG_X86_LOCAL_APIC */ 299 300 #ifdef CONFIG_X86_IO_APIC 301 302 static int __init 303 acpi_parse_ioapic(struct acpi_subtable_header * header, const unsigned long end) 304 { 305 struct acpi_madt_io_apic *ioapic = NULL; 306 307 ioapic = (struct acpi_madt_io_apic *)header; 308 309 if (BAD_MADT_ENTRY(ioapic, end)) 310 return -EINVAL; 311 312 acpi_table_print_madt_entry(header); 313 314 mp_register_ioapic(ioapic->id, 315 ioapic->address, ioapic->global_irq_base); 316 317 return 0; 318 } 319 320 /* 321 * Parse Interrupt Source Override for the ACPI SCI 322 */ 323 static void __init acpi_sci_ioapic_setup(u32 gsi, u16 polarity, u16 trigger) 324 { 325 if (trigger == 0) /* compatible SCI trigger is level */ 326 trigger = 3; 327 328 if (polarity == 0) /* compatible SCI polarity is low */ 329 polarity = 3; 330 331 /* Command-line over-ride via acpi_sci= */ 332 if (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) 333 trigger = (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2; 334 335 if (acpi_sci_flags & ACPI_MADT_POLARITY_MASK) 336 polarity = acpi_sci_flags & ACPI_MADT_POLARITY_MASK; 337 338 /* 339 * mp_config_acpi_legacy_irqs() already setup IRQs < 16 340 * If GSI is < 16, this will update its flags, 341 * else it will create a new mp_irqs[] entry. 342 */ 343 mp_override_legacy_irq(gsi, polarity, trigger, gsi); 344 345 /* 346 * stash over-ride to indicate we've been here 347 * and for later update of acpi_gbl_FADT 348 */ 349 acpi_sci_override_gsi = gsi; 350 return; 351 } 352 353 static int __init 354 acpi_parse_int_src_ovr(struct acpi_subtable_header * header, 355 const unsigned long end) 356 { 357 struct acpi_madt_interrupt_override *intsrc = NULL; 358 359 intsrc = (struct acpi_madt_interrupt_override *)header; 360 361 if (BAD_MADT_ENTRY(intsrc, end)) 362 return -EINVAL; 363 364 acpi_table_print_madt_entry(header); 365 366 if (intsrc->source_irq == acpi_gbl_FADT.sci_interrupt) { 367 acpi_sci_ioapic_setup(intsrc->global_irq, 368 intsrc->inti_flags & ACPI_MADT_POLARITY_MASK, 369 (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2); 370 return 0; 371 } 372 373 if (acpi_skip_timer_override && 374 intsrc->source_irq == 0 && intsrc->global_irq == 2) { 375 printk(PREFIX "BIOS IRQ0 pin2 override ignored.\n"); 376 return 0; 377 } 378 379 mp_override_legacy_irq(intsrc->source_irq, 380 intsrc->inti_flags & ACPI_MADT_POLARITY_MASK, 381 (intsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2, 382 intsrc->global_irq); 383 384 return 0; 385 } 386 387 static int __init 388 acpi_parse_nmi_src(struct acpi_subtable_header * header, const unsigned long end) 389 { 390 struct acpi_madt_nmi_source *nmi_src = NULL; 391 392 nmi_src = (struct acpi_madt_nmi_source *)header; 393 394 if (BAD_MADT_ENTRY(nmi_src, end)) 395 return -EINVAL; 396 397 acpi_table_print_madt_entry(header); 398 399 /* TBD: Support nimsrc entries? */ 400 401 return 0; 402 } 403 404 #endif /* CONFIG_X86_IO_APIC */ 405 406 /* 407 * acpi_pic_sci_set_trigger() 408 * 409 * use ELCR to set PIC-mode trigger type for SCI 410 * 411 * If a PIC-mode SCI is not recognized or gives spurious IRQ7's 412 * it may require Edge Trigger -- use "acpi_sci=edge" 413 * 414 * Port 0x4d0-4d1 are ECLR1 and ECLR2, the Edge/Level Control Registers 415 * for the 8259 PIC. bit[n] = 1 means irq[n] is Level, otherwise Edge. 416 * ECLR1 is IRQs 0-7 (IRQ 0, 1, 2 must be 0) 417 * ECLR2 is IRQs 8-15 (IRQ 8, 13 must be 0) 418 */ 419 420 void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger) 421 { 422 unsigned int mask = 1 << irq; 423 unsigned int old, new; 424 425 /* Real old ELCR mask */ 426 old = inb(0x4d0) | (inb(0x4d1) << 8); 427 428 /* 429 * If we use ACPI to set PCI IRQs, then we should clear ELCR 430 * since we will set it correctly as we enable the PCI irq 431 * routing. 432 */ 433 new = acpi_noirq ? old : 0; 434 435 /* 436 * Update SCI information in the ELCR, it isn't in the PCI 437 * routing tables.. 438 */ 439 switch (trigger) { 440 case 1: /* Edge - clear */ 441 new &= ~mask; 442 break; 443 case 3: /* Level - set */ 444 new |= mask; 445 break; 446 } 447 448 if (old == new) 449 return; 450 451 printk(PREFIX "setting ELCR to %04x (from %04x)\n", new, old); 452 outb(new, 0x4d0); 453 outb(new >> 8, 0x4d1); 454 } 455 456 int acpi_gsi_to_irq(u32 gsi, unsigned int *irq) 457 { 458 *irq = gsi; 459 return 0; 460 } 461 462 /* 463 * success: return IRQ number (>=0) 464 * failure: return < 0 465 */ 466 int acpi_register_gsi(u32 gsi, int triggering, int polarity) 467 { 468 unsigned int irq; 469 unsigned int plat_gsi = gsi; 470 471 #ifdef CONFIG_PCI 472 /* 473 * Make sure all (legacy) PCI IRQs are set as level-triggered. 474 */ 475 if (acpi_irq_model == ACPI_IRQ_MODEL_PIC) { 476 extern void eisa_set_level_irq(unsigned int irq); 477 478 if (triggering == ACPI_LEVEL_SENSITIVE) 479 eisa_set_level_irq(gsi); 480 } 481 #endif 482 483 #ifdef CONFIG_X86_IO_APIC 484 if (acpi_irq_model == ACPI_IRQ_MODEL_IOAPIC) { 485 plat_gsi = mp_register_gsi(gsi, triggering, polarity); 486 } 487 #endif 488 acpi_gsi_to_irq(plat_gsi, &irq); 489 return irq; 490 } 491 492 /* 493 * ACPI based hotplug support for CPU 494 */ 495 #ifdef CONFIG_ACPI_HOTPLUG_CPU 496 497 static int __cpuinit _acpi_map_lsapic(acpi_handle handle, int *pcpu) 498 { 499 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 500 union acpi_object *obj; 501 struct acpi_madt_local_apic *lapic; 502 cpumask_t tmp_map, new_map; 503 u8 physid; 504 int cpu; 505 506 if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer))) 507 return -EINVAL; 508 509 if (!buffer.length || !buffer.pointer) 510 return -EINVAL; 511 512 obj = buffer.pointer; 513 if (obj->type != ACPI_TYPE_BUFFER || 514 obj->buffer.length < sizeof(*lapic)) { 515 kfree(buffer.pointer); 516 return -EINVAL; 517 } 518 519 lapic = (struct acpi_madt_local_apic *)obj->buffer.pointer; 520 521 if (lapic->header.type != ACPI_MADT_TYPE_LOCAL_APIC || 522 !(lapic->lapic_flags & ACPI_MADT_ENABLED)) { 523 kfree(buffer.pointer); 524 return -EINVAL; 525 } 526 527 physid = lapic->id; 528 529 kfree(buffer.pointer); 530 buffer.length = ACPI_ALLOCATE_BUFFER; 531 buffer.pointer = NULL; 532 533 tmp_map = cpu_present_map; 534 mp_register_lapic(physid, lapic->lapic_flags & ACPI_MADT_ENABLED); 535 536 /* 537 * If mp_register_lapic successfully generates a new logical cpu 538 * number, then the following will get us exactly what was mapped 539 */ 540 cpus_andnot(new_map, cpu_present_map, tmp_map); 541 if (cpus_empty(new_map)) { 542 printk ("Unable to map lapic to logical cpu number\n"); 543 return -EINVAL; 544 } 545 546 cpu = first_cpu(new_map); 547 548 *pcpu = cpu; 549 return 0; 550 } 551 552 /* wrapper to silence section mismatch warning */ 553 int __ref acpi_map_lsapic(acpi_handle handle, int *pcpu) 554 { 555 return _acpi_map_lsapic(handle, pcpu); 556 } 557 EXPORT_SYMBOL(acpi_map_lsapic); 558 559 int acpi_unmap_lsapic(int cpu) 560 { 561 per_cpu(x86_cpu_to_apicid, cpu) = -1; 562 cpu_clear(cpu, cpu_present_map); 563 num_processors--; 564 565 return (0); 566 } 567 568 EXPORT_SYMBOL(acpi_unmap_lsapic); 569 #endif /* CONFIG_ACPI_HOTPLUG_CPU */ 570 571 int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base) 572 { 573 /* TBD */ 574 return -EINVAL; 575 } 576 577 EXPORT_SYMBOL(acpi_register_ioapic); 578 579 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base) 580 { 581 /* TBD */ 582 return -EINVAL; 583 } 584 585 EXPORT_SYMBOL(acpi_unregister_ioapic); 586 587 static int __init acpi_parse_sbf(struct acpi_table_header *table) 588 { 589 struct acpi_table_boot *sb; 590 591 sb = (struct acpi_table_boot *)table; 592 if (!sb) { 593 printk(KERN_WARNING PREFIX "Unable to map SBF\n"); 594 return -ENODEV; 595 } 596 597 sbf_port = sb->cmos_index; /* Save CMOS port */ 598 599 return 0; 600 } 601 602 #ifdef CONFIG_HPET_TIMER 603 #include <asm/hpet.h> 604 605 static struct __initdata resource *hpet_res; 606 607 static int __init acpi_parse_hpet(struct acpi_table_header *table) 608 { 609 struct acpi_table_hpet *hpet_tbl; 610 611 hpet_tbl = (struct acpi_table_hpet *)table; 612 if (!hpet_tbl) { 613 printk(KERN_WARNING PREFIX "Unable to map HPET\n"); 614 return -ENODEV; 615 } 616 617 if (hpet_tbl->address.space_id != ACPI_SPACE_MEM) { 618 printk(KERN_WARNING PREFIX "HPET timers must be located in " 619 "memory.\n"); 620 return -1; 621 } 622 623 hpet_address = hpet_tbl->address.address; 624 625 /* 626 * Some broken BIOSes advertise HPET at 0x0. We really do not 627 * want to allocate a resource there. 628 */ 629 if (!hpet_address) { 630 printk(KERN_WARNING PREFIX 631 "HPET id: %#x base: %#lx is invalid\n", 632 hpet_tbl->id, hpet_address); 633 return 0; 634 } 635 #ifdef CONFIG_X86_64 636 /* 637 * Some even more broken BIOSes advertise HPET at 638 * 0xfed0000000000000 instead of 0xfed00000. Fix it up and add 639 * some noise: 640 */ 641 if (hpet_address == 0xfed0000000000000UL) { 642 if (!hpet_force_user) { 643 printk(KERN_WARNING PREFIX "HPET id: %#x " 644 "base: 0xfed0000000000000 is bogus\n " 645 "try hpet=force on the kernel command line to " 646 "fix it up to 0xfed00000.\n", hpet_tbl->id); 647 hpet_address = 0; 648 return 0; 649 } 650 printk(KERN_WARNING PREFIX 651 "HPET id: %#x base: 0xfed0000000000000 fixed up " 652 "to 0xfed00000.\n", hpet_tbl->id); 653 hpet_address >>= 32; 654 } 655 #endif 656 printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n", 657 hpet_tbl->id, hpet_address); 658 659 /* 660 * Allocate and initialize the HPET firmware resource for adding into 661 * the resource tree during the lateinit timeframe. 662 */ 663 #define HPET_RESOURCE_NAME_SIZE 9 664 hpet_res = alloc_bootmem(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE); 665 666 if (!hpet_res) 667 return 0; 668 669 memset(hpet_res, 0, sizeof(*hpet_res)); 670 hpet_res->name = (void *)&hpet_res[1]; 671 hpet_res->flags = IORESOURCE_MEM; 672 snprintf((char *)hpet_res->name, HPET_RESOURCE_NAME_SIZE, "HPET %u", 673 hpet_tbl->sequence); 674 675 hpet_res->start = hpet_address; 676 hpet_res->end = hpet_address + (1 * 1024) - 1; 677 678 return 0; 679 } 680 681 /* 682 * hpet_insert_resource inserts the HPET resources used into the resource 683 * tree. 684 */ 685 static __init int hpet_insert_resource(void) 686 { 687 if (!hpet_res) 688 return 1; 689 690 return insert_resource(&iomem_resource, hpet_res); 691 } 692 693 late_initcall(hpet_insert_resource); 694 695 #else 696 #define acpi_parse_hpet NULL 697 #endif 698 699 static int __init acpi_parse_fadt(struct acpi_table_header *table) 700 { 701 702 #ifdef CONFIG_X86_PM_TIMER 703 /* detect the location of the ACPI PM Timer */ 704 if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID) { 705 /* FADT rev. 2 */ 706 if (acpi_gbl_FADT.xpm_timer_block.space_id != 707 ACPI_ADR_SPACE_SYSTEM_IO) 708 return 0; 709 710 pmtmr_ioport = acpi_gbl_FADT.xpm_timer_block.address; 711 /* 712 * "X" fields are optional extensions to the original V1.0 713 * fields, so we must selectively expand V1.0 fields if the 714 * corresponding X field is zero. 715 */ 716 if (!pmtmr_ioport) 717 pmtmr_ioport = acpi_gbl_FADT.pm_timer_block; 718 } else { 719 /* FADT rev. 1 */ 720 pmtmr_ioport = acpi_gbl_FADT.pm_timer_block; 721 } 722 if (pmtmr_ioport) 723 printk(KERN_INFO PREFIX "PM-Timer IO Port: %#x\n", 724 pmtmr_ioport); 725 #endif 726 return 0; 727 } 728 729 #ifdef CONFIG_X86_LOCAL_APIC 730 /* 731 * Parse LAPIC entries in MADT 732 * returns 0 on success, < 0 on error 733 */ 734 static int __init acpi_parse_madt_lapic_entries(void) 735 { 736 int count; 737 738 if (!cpu_has_apic) 739 return -ENODEV; 740 741 /* 742 * Note that the LAPIC address is obtained from the MADT (32-bit value) 743 * and (optionally) overriden by a LAPIC_ADDR_OVR entry (64-bit value). 744 */ 745 746 count = 747 acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, 748 acpi_parse_lapic_addr_ovr, 0); 749 if (count < 0) { 750 printk(KERN_ERR PREFIX 751 "Error parsing LAPIC address override entry\n"); 752 return count; 753 } 754 755 mp_register_lapic_address(acpi_lapic_addr); 756 757 count = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC, acpi_parse_lapic, 758 MAX_APICS); 759 if (!count) { 760 printk(KERN_ERR PREFIX "No LAPIC entries present\n"); 761 /* TBD: Cleanup to allow fallback to MPS */ 762 return -ENODEV; 763 } else if (count < 0) { 764 printk(KERN_ERR PREFIX "Error parsing LAPIC entry\n"); 765 /* TBD: Cleanup to allow fallback to MPS */ 766 return count; 767 } 768 769 count = 770 acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI, acpi_parse_lapic_nmi, 0); 771 if (count < 0) { 772 printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n"); 773 /* TBD: Cleanup to allow fallback to MPS */ 774 return count; 775 } 776 return 0; 777 } 778 #endif /* CONFIG_X86_LOCAL_APIC */ 779 780 #ifdef CONFIG_X86_IO_APIC 781 /* 782 * Parse IOAPIC related entries in MADT 783 * returns 0 on success, < 0 on error 784 */ 785 static int __init acpi_parse_madt_ioapic_entries(void) 786 { 787 int count; 788 789 /* 790 * ACPI interpreter is required to complete interrupt setup, 791 * so if it is off, don't enumerate the io-apics with ACPI. 792 * If MPS is present, it will handle them, 793 * otherwise the system will stay in PIC mode 794 */ 795 if (acpi_disabled || acpi_noirq) { 796 return -ENODEV; 797 } 798 799 if (!cpu_has_apic) 800 return -ENODEV; 801 802 /* 803 * if "noapic" boot option, don't look for IO-APICs 804 */ 805 if (skip_ioapic_setup) { 806 printk(KERN_INFO PREFIX "Skipping IOAPIC probe " 807 "due to 'noapic' option.\n"); 808 return -ENODEV; 809 } 810 811 count = 812 acpi_table_parse_madt(ACPI_MADT_TYPE_IO_APIC, acpi_parse_ioapic, 813 MAX_IO_APICS); 814 if (!count) { 815 printk(KERN_ERR PREFIX "No IOAPIC entries present\n"); 816 return -ENODEV; 817 } else if (count < 0) { 818 printk(KERN_ERR PREFIX "Error parsing IOAPIC entry\n"); 819 return count; 820 } 821 822 count = 823 acpi_table_parse_madt(ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, acpi_parse_int_src_ovr, 824 NR_IRQ_VECTORS); 825 if (count < 0) { 826 printk(KERN_ERR PREFIX 827 "Error parsing interrupt source overrides entry\n"); 828 /* TBD: Cleanup to allow fallback to MPS */ 829 return count; 830 } 831 832 /* 833 * If BIOS did not supply an INT_SRC_OVR for the SCI 834 * pretend we got one so we can set the SCI flags. 835 */ 836 if (!acpi_sci_override_gsi) 837 acpi_sci_ioapic_setup(acpi_gbl_FADT.sci_interrupt, 0, 0); 838 839 /* Fill in identity legacy mapings where no override */ 840 mp_config_acpi_legacy_irqs(); 841 842 count = 843 acpi_table_parse_madt(ACPI_MADT_TYPE_NMI_SOURCE, acpi_parse_nmi_src, 844 NR_IRQ_VECTORS); 845 if (count < 0) { 846 printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n"); 847 /* TBD: Cleanup to allow fallback to MPS */ 848 return count; 849 } 850 851 return 0; 852 } 853 #else 854 static inline int acpi_parse_madt_ioapic_entries(void) 855 { 856 return -1; 857 } 858 #endif /* !CONFIG_X86_IO_APIC */ 859 860 static void __init acpi_process_madt(void) 861 { 862 #ifdef CONFIG_X86_LOCAL_APIC 863 int error; 864 865 if (!acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) { 866 867 /* 868 * Parse MADT LAPIC entries 869 */ 870 error = acpi_parse_madt_lapic_entries(); 871 if (!error) { 872 acpi_lapic = 1; 873 874 #ifdef CONFIG_X86_GENERICARCH 875 generic_bigsmp_probe(); 876 #endif 877 /* 878 * Parse MADT IO-APIC entries 879 */ 880 error = acpi_parse_madt_ioapic_entries(); 881 if (!error) { 882 acpi_irq_model = ACPI_IRQ_MODEL_IOAPIC; 883 acpi_irq_balance_set(NULL); 884 acpi_ioapic = 1; 885 886 smp_found_config = 1; 887 setup_apic_routing(); 888 } 889 } 890 if (error == -EINVAL) { 891 /* 892 * Dell Precision Workstation 410, 610 come here. 893 */ 894 printk(KERN_ERR PREFIX 895 "Invalid BIOS MADT, disabling ACPI\n"); 896 disable_acpi(); 897 } 898 } 899 #endif 900 return; 901 } 902 903 #ifdef __i386__ 904 905 static int __init disable_acpi_irq(const struct dmi_system_id *d) 906 { 907 if (!acpi_force) { 908 printk(KERN_NOTICE "%s detected: force use of acpi=noirq\n", 909 d->ident); 910 acpi_noirq_set(); 911 } 912 return 0; 913 } 914 915 static int __init disable_acpi_pci(const struct dmi_system_id *d) 916 { 917 if (!acpi_force) { 918 printk(KERN_NOTICE "%s detected: force use of pci=noacpi\n", 919 d->ident); 920 acpi_disable_pci(); 921 } 922 return 0; 923 } 924 925 static int __init dmi_disable_acpi(const struct dmi_system_id *d) 926 { 927 if (!acpi_force) { 928 printk(KERN_NOTICE "%s detected: acpi off\n", d->ident); 929 disable_acpi(); 930 } else { 931 printk(KERN_NOTICE 932 "Warning: DMI blacklist says broken, but acpi forced\n"); 933 } 934 return 0; 935 } 936 937 /* 938 * Limit ACPI to CPU enumeration for HT 939 */ 940 static int __init force_acpi_ht(const struct dmi_system_id *d) 941 { 942 if (!acpi_force) { 943 printk(KERN_NOTICE "%s detected: force use of acpi=ht\n", 944 d->ident); 945 disable_acpi(); 946 acpi_ht = 1; 947 } else { 948 printk(KERN_NOTICE 949 "Warning: acpi=force overrules DMI blacklist: acpi=ht\n"); 950 } 951 return 0; 952 } 953 954 /* 955 * If your system is blacklisted here, but you find that acpi=force 956 * works for you, please contact acpi-devel@sourceforge.net 957 */ 958 static struct dmi_system_id __initdata acpi_dmi_table[] = { 959 /* 960 * Boxes that need ACPI disabled 961 */ 962 { 963 .callback = dmi_disable_acpi, 964 .ident = "IBM Thinkpad", 965 .matches = { 966 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 967 DMI_MATCH(DMI_BOARD_NAME, "2629H1G"), 968 }, 969 }, 970 971 /* 972 * Boxes that need acpi=ht 973 */ 974 { 975 .callback = force_acpi_ht, 976 .ident = "FSC Primergy T850", 977 .matches = { 978 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), 979 DMI_MATCH(DMI_PRODUCT_NAME, "PRIMERGY T850"), 980 }, 981 }, 982 { 983 .callback = force_acpi_ht, 984 .ident = "HP VISUALIZE NT Workstation", 985 .matches = { 986 DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"), 987 DMI_MATCH(DMI_PRODUCT_NAME, "HP VISUALIZE NT Workstation"), 988 }, 989 }, 990 { 991 .callback = force_acpi_ht, 992 .ident = "Compaq Workstation W8000", 993 .matches = { 994 DMI_MATCH(DMI_SYS_VENDOR, "Compaq"), 995 DMI_MATCH(DMI_PRODUCT_NAME, "Workstation W8000"), 996 }, 997 }, 998 { 999 .callback = force_acpi_ht, 1000 .ident = "ASUS P4B266", 1001 .matches = { 1002 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1003 DMI_MATCH(DMI_BOARD_NAME, "P4B266"), 1004 }, 1005 }, 1006 { 1007 .callback = force_acpi_ht, 1008 .ident = "ASUS P2B-DS", 1009 .matches = { 1010 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1011 DMI_MATCH(DMI_BOARD_NAME, "P2B-DS"), 1012 }, 1013 }, 1014 { 1015 .callback = force_acpi_ht, 1016 .ident = "ASUS CUR-DLS", 1017 .matches = { 1018 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1019 DMI_MATCH(DMI_BOARD_NAME, "CUR-DLS"), 1020 }, 1021 }, 1022 { 1023 .callback = force_acpi_ht, 1024 .ident = "ABIT i440BX-W83977", 1025 .matches = { 1026 DMI_MATCH(DMI_BOARD_VENDOR, "ABIT <http://www.abit.com>"), 1027 DMI_MATCH(DMI_BOARD_NAME, "i440BX-W83977 (BP6)"), 1028 }, 1029 }, 1030 { 1031 .callback = force_acpi_ht, 1032 .ident = "IBM Bladecenter", 1033 .matches = { 1034 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1035 DMI_MATCH(DMI_BOARD_NAME, "IBM eServer BladeCenter HS20"), 1036 }, 1037 }, 1038 { 1039 .callback = force_acpi_ht, 1040 .ident = "IBM eServer xSeries 360", 1041 .matches = { 1042 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1043 DMI_MATCH(DMI_BOARD_NAME, "eServer xSeries 360"), 1044 }, 1045 }, 1046 { 1047 .callback = force_acpi_ht, 1048 .ident = "IBM eserver xSeries 330", 1049 .matches = { 1050 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1051 DMI_MATCH(DMI_BOARD_NAME, "eserver xSeries 330"), 1052 }, 1053 }, 1054 { 1055 .callback = force_acpi_ht, 1056 .ident = "IBM eserver xSeries 440", 1057 .matches = { 1058 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1059 DMI_MATCH(DMI_PRODUCT_NAME, "eserver xSeries 440"), 1060 }, 1061 }, 1062 1063 /* 1064 * Boxes that need ACPI PCI IRQ routing disabled 1065 */ 1066 { 1067 .callback = disable_acpi_irq, 1068 .ident = "ASUS A7V", 1069 .matches = { 1070 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC"), 1071 DMI_MATCH(DMI_BOARD_NAME, "<A7V>"), 1072 /* newer BIOS, Revision 1011, does work */ 1073 DMI_MATCH(DMI_BIOS_VERSION, 1074 "ASUS A7V ACPI BIOS Revision 1007"), 1075 }, 1076 }, 1077 { 1078 /* 1079 * Latest BIOS for IBM 600E (1.16) has bad pcinum 1080 * for LPC bridge, which is needed for the PCI 1081 * interrupt links to work. DSDT fix is in bug 5966. 1082 * 2645, 2646 model numbers are shared with 600/600E/600X 1083 */ 1084 .callback = disable_acpi_irq, 1085 .ident = "IBM Thinkpad 600 Series 2645", 1086 .matches = { 1087 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1088 DMI_MATCH(DMI_BOARD_NAME, "2645"), 1089 }, 1090 }, 1091 { 1092 .callback = disable_acpi_irq, 1093 .ident = "IBM Thinkpad 600 Series 2646", 1094 .matches = { 1095 DMI_MATCH(DMI_BOARD_VENDOR, "IBM"), 1096 DMI_MATCH(DMI_BOARD_NAME, "2646"), 1097 }, 1098 }, 1099 /* 1100 * Boxes that need ACPI PCI IRQ routing and PCI scan disabled 1101 */ 1102 { /* _BBN 0 bug */ 1103 .callback = disable_acpi_pci, 1104 .ident = "ASUS PR-DLS", 1105 .matches = { 1106 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 1107 DMI_MATCH(DMI_BOARD_NAME, "PR-DLS"), 1108 DMI_MATCH(DMI_BIOS_VERSION, 1109 "ASUS PR-DLS ACPI BIOS Revision 1010"), 1110 DMI_MATCH(DMI_BIOS_DATE, "03/21/2003") 1111 }, 1112 }, 1113 { 1114 .callback = disable_acpi_pci, 1115 .ident = "Acer TravelMate 36x Laptop", 1116 .matches = { 1117 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 1118 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"), 1119 }, 1120 }, 1121 {} 1122 }; 1123 1124 #endif /* __i386__ */ 1125 1126 /* 1127 * acpi_boot_table_init() and acpi_boot_init() 1128 * called from setup_arch(), always. 1129 * 1. checksums all tables 1130 * 2. enumerates lapics 1131 * 3. enumerates io-apics 1132 * 1133 * acpi_table_init() is separate to allow reading SRAT without 1134 * other side effects. 1135 * 1136 * side effects of acpi_boot_init: 1137 * acpi_lapic = 1 if LAPIC found 1138 * acpi_ioapic = 1 if IOAPIC found 1139 * if (acpi_lapic && acpi_ioapic) smp_found_config = 1; 1140 * if acpi_blacklisted() acpi_disabled = 1; 1141 * acpi_irq_model=... 1142 * ... 1143 * 1144 * return value: (currently ignored) 1145 * 0: success 1146 * !0: failure 1147 */ 1148 1149 int __init acpi_boot_table_init(void) 1150 { 1151 int error; 1152 1153 #ifdef __i386__ 1154 dmi_check_system(acpi_dmi_table); 1155 #endif 1156 1157 /* 1158 * If acpi_disabled, bail out 1159 * One exception: acpi=ht continues far enough to enumerate LAPICs 1160 */ 1161 if (acpi_disabled && !acpi_ht) 1162 return 1; 1163 1164 /* 1165 * Initialize the ACPI boot-time table parser. 1166 */ 1167 error = acpi_table_init(); 1168 if (error) { 1169 disable_acpi(); 1170 return error; 1171 } 1172 1173 acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf); 1174 1175 /* 1176 * blacklist may disable ACPI entirely 1177 */ 1178 error = acpi_blacklisted(); 1179 if (error) { 1180 if (acpi_force) { 1181 printk(KERN_WARNING PREFIX "acpi=force override\n"); 1182 } else { 1183 printk(KERN_WARNING PREFIX "Disabling ACPI support\n"); 1184 disable_acpi(); 1185 return error; 1186 } 1187 } 1188 1189 return 0; 1190 } 1191 1192 int __init acpi_boot_init(void) 1193 { 1194 /* 1195 * If acpi_disabled, bail out 1196 * One exception: acpi=ht continues far enough to enumerate LAPICs 1197 */ 1198 if (acpi_disabled && !acpi_ht) 1199 return 1; 1200 1201 acpi_table_parse(ACPI_SIG_BOOT, acpi_parse_sbf); 1202 1203 /* 1204 * set sci_int and PM timer address 1205 */ 1206 acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt); 1207 1208 /* 1209 * Process the Multiple APIC Description Table (MADT), if present 1210 */ 1211 acpi_process_madt(); 1212 1213 acpi_table_parse(ACPI_SIG_HPET, acpi_parse_hpet); 1214 1215 return 0; 1216 } 1217 1218 static int __init parse_acpi(char *arg) 1219 { 1220 if (!arg) 1221 return -EINVAL; 1222 1223 /* "acpi=off" disables both ACPI table parsing and interpreter */ 1224 if (strcmp(arg, "off") == 0) { 1225 disable_acpi(); 1226 } 1227 /* acpi=force to over-ride black-list */ 1228 else if (strcmp(arg, "force") == 0) { 1229 acpi_force = 1; 1230 acpi_ht = 1; 1231 acpi_disabled = 0; 1232 } 1233 /* acpi=strict disables out-of-spec workarounds */ 1234 else if (strcmp(arg, "strict") == 0) { 1235 acpi_strict = 1; 1236 } 1237 /* Limit ACPI just to boot-time to enable HT */ 1238 else if (strcmp(arg, "ht") == 0) { 1239 if (!acpi_force) 1240 disable_acpi(); 1241 acpi_ht = 1; 1242 } 1243 /* "acpi=noirq" disables ACPI interrupt routing */ 1244 else if (strcmp(arg, "noirq") == 0) { 1245 acpi_noirq_set(); 1246 } else { 1247 /* Core will printk when we return error. */ 1248 return -EINVAL; 1249 } 1250 return 0; 1251 } 1252 early_param("acpi", parse_acpi); 1253 1254 /* FIXME: Using pci= for an ACPI parameter is a travesty. */ 1255 static int __init parse_pci(char *arg) 1256 { 1257 if (arg && strcmp(arg, "noacpi") == 0) 1258 acpi_disable_pci(); 1259 return 0; 1260 } 1261 early_param("pci", parse_pci); 1262 1263 #ifdef CONFIG_X86_IO_APIC 1264 static int __init parse_acpi_skip_timer_override(char *arg) 1265 { 1266 acpi_skip_timer_override = 1; 1267 return 0; 1268 } 1269 early_param("acpi_skip_timer_override", parse_acpi_skip_timer_override); 1270 1271 static int __init parse_acpi_use_timer_override(char *arg) 1272 { 1273 acpi_use_timer_override = 1; 1274 return 0; 1275 } 1276 early_param("acpi_use_timer_override", parse_acpi_use_timer_override); 1277 #endif /* CONFIG_X86_IO_APIC */ 1278 1279 static int __init setup_acpi_sci(char *s) 1280 { 1281 if (!s) 1282 return -EINVAL; 1283 if (!strcmp(s, "edge")) 1284 acpi_sci_flags = ACPI_MADT_TRIGGER_EDGE | 1285 (acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK); 1286 else if (!strcmp(s, "level")) 1287 acpi_sci_flags = ACPI_MADT_TRIGGER_LEVEL | 1288 (acpi_sci_flags & ~ACPI_MADT_TRIGGER_MASK); 1289 else if (!strcmp(s, "high")) 1290 acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_HIGH | 1291 (acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK); 1292 else if (!strcmp(s, "low")) 1293 acpi_sci_flags = ACPI_MADT_POLARITY_ACTIVE_LOW | 1294 (acpi_sci_flags & ~ACPI_MADT_POLARITY_MASK); 1295 else 1296 return -EINVAL; 1297 return 0; 1298 } 1299 early_param("acpi_sci", setup_acpi_sci); 1300 1301 int __acpi_acquire_global_lock(unsigned int *lock) 1302 { 1303 unsigned int old, new, val; 1304 do { 1305 old = *lock; 1306 new = (((old & ~0x3) + 2) + ((old >> 1) & 0x1)); 1307 val = cmpxchg(lock, old, new); 1308 } while (unlikely (val != old)); 1309 return (new < 3) ? -1 : 0; 1310 } 1311 1312 int __acpi_release_global_lock(unsigned int *lock) 1313 { 1314 unsigned int old, new, val; 1315 do { 1316 old = *lock; 1317 new = old & ~0x3; 1318 val = cmpxchg(lock, old, new); 1319 } while (unlikely (val != old)); 1320 return old & 0x1; 1321 } 1322