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