arch/i386/kernel/acpi/boot.c

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