linux/arch/ia64/kernel/acpi.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  acpi.c - Architecture-Specific Low-Level ACPI Support
   4 *
   5 *  Copyright (C) 1999 VA Linux Systems
   6 *  Copyright (C) 1999,2000 Walt Drummond <drummond@valinux.com>
   7 *  Copyright (C) 2000, 2002-2003 Hewlett-Packard Co.
   8 *      David Mosberger-Tang <davidm@hpl.hp.com>
   9 *  Copyright (C) 2000 Intel Corp.
  10 *  Copyright (C) 2000,2001 J.I. Lee <jung-ik.lee@intel.com>
  11 *  Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
  12 *  Copyright (C) 2001 Jenna Hall <jenna.s.hall@intel.com>
  13 *  Copyright (C) 2001 Takayoshi Kochi <t-kochi@bq.jp.nec.com>
  14 *  Copyright (C) 2002 Erich Focht <efocht@ess.nec.de>
  15 *  Copyright (C) 2004 Ashok Raj <ashok.raj@intel.com>
  16 */
  17
  18#include <linux/module.h>
  19#include <linux/init.h>
  20#include <linux/kernel.h>
  21#include <linux/sched.h>
  22#include <linux/smp.h>
  23#include <linux/string.h>
  24#include <linux/types.h>
  25#include <linux/irq.h>
  26#include <linux/acpi.h>
  27#include <linux/efi.h>
  28#include <linux/mmzone.h>
  29#include <linux/nodemask.h>
  30#include <linux/slab.h>
  31#include <acpi/processor.h>
  32#include <asm/io.h>
  33#include <asm/iosapic.h>
  34#include <asm/page.h>
  35#include <asm/numa.h>
  36#include <asm/sal.h>
  37#include <asm/cyclone.h>
  38
  39#define PREFIX                  "ACPI: "
  40
  41int acpi_lapic;
  42unsigned int acpi_cpei_override;
  43unsigned int acpi_cpei_phys_cpuid;
  44
  45#define ACPI_MAX_PLATFORM_INTERRUPTS    256
  46
  47/* Array to record platform interrupt vectors for generic interrupt routing. */
  48int platform_intr_list[ACPI_MAX_PLATFORM_INTERRUPTS] = {
  49        [0 ... ACPI_MAX_PLATFORM_INTERRUPTS - 1] = -1
  50};
  51
  52enum acpi_irq_model_id acpi_irq_model = ACPI_IRQ_MODEL_IOSAPIC;
  53
  54/*
  55 * Interrupt routing API for device drivers.  Provides interrupt vector for
  56 * a generic platform event.  Currently only CPEI is implemented.
  57 */
  58int acpi_request_vector(u32 int_type)
  59{
  60        int vector = -1;
  61
  62        if (int_type < ACPI_MAX_PLATFORM_INTERRUPTS) {
  63                /* corrected platform error interrupt */
  64                vector = platform_intr_list[int_type];
  65        } else
  66                printk(KERN_ERR
  67                       "acpi_request_vector(): invalid interrupt type\n");
  68        return vector;
  69}
  70
  71void __init __iomem *__acpi_map_table(unsigned long phys, unsigned long size)
  72{
  73        return __va(phys);
  74}
  75
  76void __init __acpi_unmap_table(void __iomem *map, unsigned long size)
  77{
  78}
  79
  80/* --------------------------------------------------------------------------
  81                            Boot-time Table Parsing
  82   -------------------------------------------------------------------------- */
  83
  84static int available_cpus __initdata;
  85struct acpi_table_madt *acpi_madt __initdata;
  86static u8 has_8259;
  87
  88static int __init
  89acpi_parse_lapic_addr_ovr(union acpi_subtable_headers * header,
  90                          const unsigned long end)
  91{
  92        struct acpi_madt_local_apic_override *lapic;
  93
  94        lapic = (struct acpi_madt_local_apic_override *)header;
  95
  96        if (BAD_MADT_ENTRY(lapic, end))
  97                return -EINVAL;
  98
  99        if (lapic->address) {
 100                iounmap(ipi_base_addr);
 101                ipi_base_addr = ioremap(lapic->address, 0);
 102        }
 103        return 0;
 104}
 105
 106static int __init
 107acpi_parse_lsapic(union acpi_subtable_headers *header, const unsigned long end)
 108{
 109        struct acpi_madt_local_sapic *lsapic;
 110
 111        lsapic = (struct acpi_madt_local_sapic *)header;
 112
 113        /*Skip BAD_MADT_ENTRY check, as lsapic size could vary */
 114
 115        if (lsapic->lapic_flags & ACPI_MADT_ENABLED) {
 116#ifdef CONFIG_SMP
 117                smp_boot_data.cpu_phys_id[available_cpus] =
 118                    (lsapic->id << 8) | lsapic->eid;
 119#endif
 120                ++available_cpus;
 121        }
 122
 123        total_cpus++;
 124        return 0;
 125}
 126
 127static int __init
 128acpi_parse_lapic_nmi(union acpi_subtable_headers * header, const unsigned long end)
 129{
 130        struct acpi_madt_local_apic_nmi *lacpi_nmi;
 131
 132        lacpi_nmi = (struct acpi_madt_local_apic_nmi *)header;
 133
 134        if (BAD_MADT_ENTRY(lacpi_nmi, end))
 135                return -EINVAL;
 136
 137        /* TBD: Support lapic_nmi entries */
 138        return 0;
 139}
 140
 141static int __init
 142acpi_parse_iosapic(union acpi_subtable_headers * header, const unsigned long end)
 143{
 144        struct acpi_madt_io_sapic *iosapic;
 145
 146        iosapic = (struct acpi_madt_io_sapic *)header;
 147
 148        if (BAD_MADT_ENTRY(iosapic, end))
 149                return -EINVAL;
 150
 151        return iosapic_init(iosapic->address, iosapic->global_irq_base);
 152}
 153
 154static unsigned int __initdata acpi_madt_rev;
 155
 156static int __init
 157acpi_parse_plat_int_src(union acpi_subtable_headers * header,
 158                        const unsigned long end)
 159{
 160        struct acpi_madt_interrupt_source *plintsrc;
 161        int vector;
 162
 163        plintsrc = (struct acpi_madt_interrupt_source *)header;
 164
 165        if (BAD_MADT_ENTRY(plintsrc, end))
 166                return -EINVAL;
 167
 168        /*
 169         * Get vector assignment for this interrupt, set attributes,
 170         * and program the IOSAPIC routing table.
 171         */
 172        vector = iosapic_register_platform_intr(plintsrc->type,
 173                                                plintsrc->global_irq,
 174                                                plintsrc->io_sapic_vector,
 175                                                plintsrc->eid,
 176                                                plintsrc->id,
 177                                                ((plintsrc->inti_flags & ACPI_MADT_POLARITY_MASK) ==
 178                                                 ACPI_MADT_POLARITY_ACTIVE_HIGH) ?
 179                                                IOSAPIC_POL_HIGH : IOSAPIC_POL_LOW,
 180                                                ((plintsrc->inti_flags & ACPI_MADT_TRIGGER_MASK) ==
 181                                                 ACPI_MADT_TRIGGER_EDGE) ?
 182                                                IOSAPIC_EDGE : IOSAPIC_LEVEL);
 183
 184        platform_intr_list[plintsrc->type] = vector;
 185        if (acpi_madt_rev > 1) {
 186                acpi_cpei_override = plintsrc->flags & ACPI_MADT_CPEI_OVERRIDE;
 187        }
 188
 189        /*
 190         * Save the physical id, so we can check when its being removed
 191         */
 192        acpi_cpei_phys_cpuid = ((plintsrc->id << 8) | (plintsrc->eid)) & 0xffff;
 193
 194        return 0;
 195}
 196
 197#ifdef CONFIG_HOTPLUG_CPU
 198unsigned int can_cpei_retarget(void)
 199{
 200        extern int cpe_vector;
 201        extern unsigned int force_cpei_retarget;
 202
 203        /*
 204         * Only if CPEI is supported and the override flag
 205         * is present, otherwise return that its re-targettable
 206         * if we are in polling mode.
 207         */
 208        if (cpe_vector > 0) {
 209                if (acpi_cpei_override || force_cpei_retarget)
 210                        return 1;
 211                else
 212                        return 0;
 213        }
 214        return 1;
 215}
 216
 217unsigned int is_cpu_cpei_target(unsigned int cpu)
 218{
 219        unsigned int logical_id;
 220
 221        logical_id = cpu_logical_id(acpi_cpei_phys_cpuid);
 222
 223        if (logical_id == cpu)
 224                return 1;
 225        else
 226                return 0;
 227}
 228
 229void set_cpei_target_cpu(unsigned int cpu)
 230{
 231        acpi_cpei_phys_cpuid = cpu_physical_id(cpu);
 232}
 233#endif
 234
 235unsigned int get_cpei_target_cpu(void)
 236{
 237        return acpi_cpei_phys_cpuid;
 238}
 239
 240static int __init
 241acpi_parse_int_src_ovr(union acpi_subtable_headers * header,
 242                       const unsigned long end)
 243{
 244        struct acpi_madt_interrupt_override *p;
 245
 246        p = (struct acpi_madt_interrupt_override *)header;
 247
 248        if (BAD_MADT_ENTRY(p, end))
 249                return -EINVAL;
 250
 251        iosapic_override_isa_irq(p->source_irq, p->global_irq,
 252                                 ((p->inti_flags & ACPI_MADT_POLARITY_MASK) ==
 253                                  ACPI_MADT_POLARITY_ACTIVE_LOW) ?
 254                                 IOSAPIC_POL_LOW : IOSAPIC_POL_HIGH,
 255                                 ((p->inti_flags & ACPI_MADT_TRIGGER_MASK) ==
 256                                 ACPI_MADT_TRIGGER_LEVEL) ?
 257                                 IOSAPIC_LEVEL : IOSAPIC_EDGE);
 258        return 0;
 259}
 260
 261static int __init
 262acpi_parse_nmi_src(union acpi_subtable_headers * header, const unsigned long end)
 263{
 264        struct acpi_madt_nmi_source *nmi_src;
 265
 266        nmi_src = (struct acpi_madt_nmi_source *)header;
 267
 268        if (BAD_MADT_ENTRY(nmi_src, end))
 269                return -EINVAL;
 270
 271        /* TBD: Support nimsrc entries */
 272        return 0;
 273}
 274
 275static void __init acpi_madt_oem_check(char *oem_id, char *oem_table_id)
 276{
 277        if (!strncmp(oem_id, "IBM", 3) && (!strncmp(oem_table_id, "SERMOW", 6))) {
 278
 279                /*
 280                 * Unfortunately ITC_DRIFT is not yet part of the
 281                 * official SAL spec, so the ITC_DRIFT bit is not
 282                 * set by the BIOS on this hardware.
 283                 */
 284                sal_platform_features |= IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT;
 285
 286                cyclone_setup();
 287        }
 288}
 289
 290static int __init acpi_parse_madt(struct acpi_table_header *table)
 291{
 292        acpi_madt = (struct acpi_table_madt *)table;
 293
 294        acpi_madt_rev = acpi_madt->header.revision;
 295
 296        /* remember the value for reference after free_initmem() */
 297#ifdef CONFIG_ITANIUM
 298        has_8259 = 1;           /* Firmware on old Itanium systems is broken */
 299#else
 300        has_8259 = acpi_madt->flags & ACPI_MADT_PCAT_COMPAT;
 301#endif
 302        iosapic_system_init(has_8259);
 303
 304        /* Get base address of IPI Message Block */
 305
 306        if (acpi_madt->address)
 307                ipi_base_addr = ioremap(acpi_madt->address, 0);
 308
 309        printk(KERN_INFO PREFIX "Local APIC address %p\n", ipi_base_addr);
 310
 311        acpi_madt_oem_check(acpi_madt->header.oem_id,
 312                            acpi_madt->header.oem_table_id);
 313
 314        return 0;
 315}
 316
 317#ifdef CONFIG_ACPI_NUMA
 318
 319#undef SLIT_DEBUG
 320
 321#define PXM_FLAG_LEN ((MAX_PXM_DOMAINS + 1)/32)
 322
 323static int __initdata srat_num_cpus;    /* number of cpus */
 324static u32 pxm_flag[PXM_FLAG_LEN];
 325#define pxm_bit_set(bit)        (set_bit(bit,(void *)pxm_flag))
 326#define pxm_bit_test(bit)       (test_bit(bit,(void *)pxm_flag))
 327static struct acpi_table_slit __initdata *slit_table;
 328cpumask_t early_cpu_possible_map = CPU_MASK_NONE;
 329
 330static int __init
 331get_processor_proximity_domain(struct acpi_srat_cpu_affinity *pa)
 332{
 333        int pxm;
 334
 335        pxm = pa->proximity_domain_lo;
 336        if (acpi_srat_revision >= 2)
 337                pxm += pa->proximity_domain_hi[0] << 8;
 338        return pxm;
 339}
 340
 341static int __init
 342get_memory_proximity_domain(struct acpi_srat_mem_affinity *ma)
 343{
 344        int pxm;
 345
 346        pxm = ma->proximity_domain;
 347        if (acpi_srat_revision <= 1)
 348                pxm &= 0xff;
 349
 350        return pxm;
 351}
 352
 353/*
 354 * ACPI 2.0 SLIT (System Locality Information Table)
 355 * http://devresource.hp.com/devresource/Docs/TechPapers/IA64/slit.pdf
 356 */
 357void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
 358{
 359        u32 len;
 360
 361        len = sizeof(struct acpi_table_header) + 8
 362            + slit->locality_count * slit->locality_count;
 363        if (slit->header.length != len) {
 364                printk(KERN_ERR
 365                       "ACPI 2.0 SLIT: size mismatch: %d expected, %d actual\n",
 366                       len, slit->header.length);
 367                return;
 368        }
 369        slit_table = slit;
 370}
 371
 372void __init
 373acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
 374{
 375        int pxm;
 376
 377        if (!(pa->flags & ACPI_SRAT_CPU_ENABLED))
 378                return;
 379
 380        if (srat_num_cpus >= ARRAY_SIZE(node_cpuid)) {
 381                printk_once(KERN_WARNING
 382                            "node_cpuid[%ld] is too small, may not be able to use all cpus\n",
 383                            ARRAY_SIZE(node_cpuid));
 384                return;
 385        }
 386        pxm = get_processor_proximity_domain(pa);
 387
 388        /* record this node in proximity bitmap */
 389        pxm_bit_set(pxm);
 390
 391        node_cpuid[srat_num_cpus].phys_id =
 392            (pa->apic_id << 8) | (pa->local_sapic_eid);
 393        /* nid should be overridden as logical node id later */
 394        node_cpuid[srat_num_cpus].nid = pxm;
 395        cpumask_set_cpu(srat_num_cpus, &early_cpu_possible_map);
 396        srat_num_cpus++;
 397}
 398
 399int __init
 400acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 401{
 402        unsigned long paddr, size;
 403        int pxm;
 404        struct node_memblk_s *p, *q, *pend;
 405
 406        pxm = get_memory_proximity_domain(ma);
 407
 408        /* fill node memory chunk structure */
 409        paddr = ma->base_address;
 410        size = ma->length;
 411
 412        /* Ignore disabled entries */
 413        if (!(ma->flags & ACPI_SRAT_MEM_ENABLED))
 414                return -1;
 415
 416        if (num_node_memblks >= NR_NODE_MEMBLKS) {
 417                pr_err("NUMA: too many memblk ranges\n");
 418                return -EINVAL;
 419        }
 420
 421        /* record this node in proximity bitmap */
 422        pxm_bit_set(pxm);
 423
 424        /* Insertion sort based on base address */
 425        pend = &node_memblk[num_node_memblks];
 426        for (p = &node_memblk[0]; p < pend; p++) {
 427                if (paddr < p->start_paddr)
 428                        break;
 429        }
 430        if (p < pend) {
 431                for (q = pend - 1; q >= p; q--)
 432                        *(q + 1) = *q;
 433        }
 434        p->start_paddr = paddr;
 435        p->size = size;
 436        p->nid = pxm;
 437        num_node_memblks++;
 438        return 0;
 439}
 440
 441void __init acpi_numa_fixup(void)
 442{
 443        int i, j, node_from, node_to;
 444
 445        /* If there's no SRAT, fix the phys_id and mark node 0 online */
 446        if (srat_num_cpus == 0) {
 447                node_set_online(0);
 448                node_cpuid[0].phys_id = hard_smp_processor_id();
 449                return;
 450        }
 451
 452        /*
 453         * MCD - This can probably be dropped now.  No need for pxm ID to node ID
 454         * mapping with sparse node numbering iff MAX_PXM_DOMAINS <= MAX_NUMNODES.
 455         */
 456        nodes_clear(node_online_map);
 457        for (i = 0; i < MAX_PXM_DOMAINS; i++) {
 458                if (pxm_bit_test(i)) {
 459                        int nid = acpi_map_pxm_to_node(i);
 460                        node_set_online(nid);
 461                }
 462        }
 463
 464        /* set logical node id in memory chunk structure */
 465        for (i = 0; i < num_node_memblks; i++)
 466                node_memblk[i].nid = pxm_to_node(node_memblk[i].nid);
 467
 468        /* assign memory bank numbers for each chunk on each node */
 469        for_each_online_node(i) {
 470                int bank;
 471
 472                bank = 0;
 473                for (j = 0; j < num_node_memblks; j++)
 474                        if (node_memblk[j].nid == i)
 475                                node_memblk[j].bank = bank++;
 476        }
 477
 478        /* set logical node id in cpu structure */
 479        for_each_possible_early_cpu(i)
 480                node_cpuid[i].nid = pxm_to_node(node_cpuid[i].nid);
 481
 482        printk(KERN_INFO "Number of logical nodes in system = %d\n",
 483               num_online_nodes());
 484        printk(KERN_INFO "Number of memory chunks in system = %d\n",
 485               num_node_memblks);
 486
 487        if (!slit_table) {
 488                for (i = 0; i < MAX_NUMNODES; i++)
 489                        for (j = 0; j < MAX_NUMNODES; j++)
 490                                slit_distance(i, j) = i == j ?
 491                                        LOCAL_DISTANCE : REMOTE_DISTANCE;
 492                return;
 493        }
 494
 495        memset(numa_slit, -1, sizeof(numa_slit));
 496        for (i = 0; i < slit_table->locality_count; i++) {
 497                if (!pxm_bit_test(i))
 498                        continue;
 499                node_from = pxm_to_node(i);
 500                for (j = 0; j < slit_table->locality_count; j++) {
 501                        if (!pxm_bit_test(j))
 502                                continue;
 503                        node_to = pxm_to_node(j);
 504                        slit_distance(node_from, node_to) =
 505                            slit_table->entry[i * slit_table->locality_count + j];
 506                }
 507        }
 508
 509#ifdef SLIT_DEBUG
 510        printk("ACPI 2.0 SLIT locality table:\n");
 511        for_each_online_node(i) {
 512                for_each_online_node(j)
 513                    printk("%03d ", node_distance(i, j));
 514                printk("\n");
 515        }
 516#endif
 517}
 518#endif                          /* CONFIG_ACPI_NUMA */
 519
 520/*
 521 * success: return IRQ number (>=0)
 522 * failure: return < 0
 523 */
 524int acpi_register_gsi(struct device *dev, u32 gsi, int triggering, int polarity)
 525{
 526        if (acpi_irq_model == ACPI_IRQ_MODEL_PLATFORM)
 527                return gsi;
 528
 529        if (has_8259 && gsi < 16)
 530                return isa_irq_to_vector(gsi);
 531
 532        return iosapic_register_intr(gsi,
 533                                     (polarity ==
 534                                      ACPI_ACTIVE_HIGH) ? IOSAPIC_POL_HIGH :
 535                                     IOSAPIC_POL_LOW,
 536                                     (triggering ==
 537                                      ACPI_EDGE_SENSITIVE) ? IOSAPIC_EDGE :
 538                                     IOSAPIC_LEVEL);
 539}
 540EXPORT_SYMBOL_GPL(acpi_register_gsi);
 541
 542void acpi_unregister_gsi(u32 gsi)
 543{
 544        if (acpi_irq_model == ACPI_IRQ_MODEL_PLATFORM)
 545                return;
 546
 547        if (has_8259 && gsi < 16)
 548                return;
 549
 550        iosapic_unregister_intr(gsi);
 551}
 552EXPORT_SYMBOL_GPL(acpi_unregister_gsi);
 553
 554static int __init acpi_parse_fadt(struct acpi_table_header *table)
 555{
 556        struct acpi_table_header *fadt_header;
 557        struct acpi_table_fadt *fadt;
 558
 559        fadt_header = (struct acpi_table_header *)table;
 560        if (fadt_header->revision != 3)
 561                return -ENODEV; /* Only deal with ACPI 2.0 FADT */
 562
 563        fadt = (struct acpi_table_fadt *)fadt_header;
 564
 565        acpi_register_gsi(NULL, fadt->sci_interrupt, ACPI_LEVEL_SENSITIVE,
 566                                 ACPI_ACTIVE_LOW);
 567        return 0;
 568}
 569
 570int __init early_acpi_boot_init(void)
 571{
 572        int ret;
 573
 574        /*
 575         * do a partial walk of MADT to determine how many CPUs
 576         * we have including offline CPUs
 577         */
 578        if (acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) {
 579                printk(KERN_ERR PREFIX "Can't find MADT\n");
 580                return 0;
 581        }
 582
 583        ret = acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_SAPIC,
 584                acpi_parse_lsapic, NR_CPUS);
 585        if (ret < 1)
 586                printk(KERN_ERR PREFIX
 587                       "Error parsing MADT - no LAPIC entries\n");
 588        else
 589                acpi_lapic = 1;
 590
 591#ifdef CONFIG_SMP
 592        if (available_cpus == 0) {
 593                printk(KERN_INFO "ACPI: Found 0 CPUS; assuming 1\n");
 594                printk(KERN_INFO "CPU 0 (0x%04x)", hard_smp_processor_id());
 595                smp_boot_data.cpu_phys_id[available_cpus] =
 596                    hard_smp_processor_id();
 597                available_cpus = 1;     /* We've got at least one of these, no? */
 598        }
 599        smp_boot_data.cpu_count = available_cpus;
 600#endif
 601        /* Make boot-up look pretty */
 602        printk(KERN_INFO "%d CPUs available, %d CPUs total\n", available_cpus,
 603               total_cpus);
 604
 605        return 0;
 606}
 607
 608int __init acpi_boot_init(void)
 609{
 610
 611        /*
 612         * MADT
 613         * ----
 614         * Parse the Multiple APIC Description Table (MADT), if exists.
 615         * Note that this table provides platform SMP configuration
 616         * information -- the successor to MPS tables.
 617         */
 618
 619        if (acpi_table_parse(ACPI_SIG_MADT, acpi_parse_madt)) {
 620                printk(KERN_ERR PREFIX "Can't find MADT\n");
 621                goto skip_madt;
 622        }
 623
 624        /* Local APIC */
 625
 626        if (acpi_table_parse_madt
 627            (ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, acpi_parse_lapic_addr_ovr, 0) < 0)
 628                printk(KERN_ERR PREFIX
 629                       "Error parsing LAPIC address override entry\n");
 630
 631        if (acpi_table_parse_madt(ACPI_MADT_TYPE_LOCAL_APIC_NMI, acpi_parse_lapic_nmi, 0)
 632            < 0)
 633                printk(KERN_ERR PREFIX "Error parsing LAPIC NMI entry\n");
 634
 635        /* I/O APIC */
 636
 637        if (acpi_table_parse_madt
 638            (ACPI_MADT_TYPE_IO_SAPIC, acpi_parse_iosapic, NR_IOSAPICS) < 1) {
 639                printk(KERN_ERR PREFIX
 640                       "Error parsing MADT - no IOSAPIC entries\n");
 641        }
 642
 643        /* System-Level Interrupt Routing */
 644
 645        if (acpi_table_parse_madt
 646            (ACPI_MADT_TYPE_INTERRUPT_SOURCE, acpi_parse_plat_int_src,
 647             ACPI_MAX_PLATFORM_INTERRUPTS) < 0)
 648                printk(KERN_ERR PREFIX
 649                       "Error parsing platform interrupt source entry\n");
 650
 651        if (acpi_table_parse_madt
 652            (ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, acpi_parse_int_src_ovr, 0) < 0)
 653                printk(KERN_ERR PREFIX
 654                       "Error parsing interrupt source overrides entry\n");
 655
 656        if (acpi_table_parse_madt(ACPI_MADT_TYPE_NMI_SOURCE, acpi_parse_nmi_src, 0) < 0)
 657                printk(KERN_ERR PREFIX "Error parsing NMI SRC entry\n");
 658      skip_madt:
 659
 660        /*
 661         * FADT says whether a legacy keyboard controller is present.
 662         * The FADT also contains an SCI_INT line, by which the system
 663         * gets interrupts such as power and sleep buttons.  If it's not
 664         * on a Legacy interrupt, it needs to be setup.
 665         */
 666        if (acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt))
 667                printk(KERN_ERR PREFIX "Can't find FADT\n");
 668
 669#ifdef CONFIG_ACPI_NUMA
 670#ifdef CONFIG_SMP
 671        if (srat_num_cpus == 0) {
 672                int cpu, i = 1;
 673                for (cpu = 0; cpu < smp_boot_data.cpu_count; cpu++)
 674                        if (smp_boot_data.cpu_phys_id[cpu] !=
 675                            hard_smp_processor_id())
 676                                node_cpuid[i++].phys_id =
 677                                    smp_boot_data.cpu_phys_id[cpu];
 678        }
 679#endif
 680        build_cpu_to_node_map();
 681#endif
 682        return 0;
 683}
 684
 685int acpi_gsi_to_irq(u32 gsi, unsigned int *irq)
 686{
 687        int tmp;
 688
 689        if (has_8259 && gsi < 16)
 690                *irq = isa_irq_to_vector(gsi);
 691        else {
 692                tmp = gsi_to_irq(gsi);
 693                if (tmp == -1)
 694                        return -1;
 695                *irq = tmp;
 696        }
 697        return 0;
 698}
 699
 700int acpi_isa_irq_to_gsi(unsigned isa_irq, u32 *gsi)
 701{
 702        if (isa_irq >= 16)
 703                return -1;
 704        *gsi = isa_irq;
 705        return 0;
 706}
 707
 708/*
 709 *  ACPI based hotplug CPU support
 710 */
 711#ifdef CONFIG_ACPI_HOTPLUG_CPU
 712int acpi_map_cpu2node(acpi_handle handle, int cpu, int physid)
 713{
 714#ifdef CONFIG_ACPI_NUMA
 715        /*
 716         * We don't have cpu-only-node hotadd. But if the system equips
 717         * SRAT table, pxm is already found and node is ready.
 718         * So, just pxm_to_nid(pxm) is OK.
 719         * This code here is for the system which doesn't have full SRAT
 720         * table for possible cpus.
 721         */
 722        node_cpuid[cpu].phys_id = physid;
 723        node_cpuid[cpu].nid = acpi_get_node(handle);
 724#endif
 725        return 0;
 726}
 727
 728int additional_cpus __initdata = -1;
 729
 730static __init int setup_additional_cpus(char *s)
 731{
 732        if (s)
 733                additional_cpus = simple_strtol(s, NULL, 0);
 734
 735        return 0;
 736}
 737
 738early_param("additional_cpus", setup_additional_cpus);
 739
 740/*
 741 * cpu_possible_mask should be static, it cannot change as CPUs
 742 * are onlined, or offlined. The reason is per-cpu data-structures
 743 * are allocated by some modules at init time, and dont expect to
 744 * do this dynamically on cpu arrival/departure.
 745 * cpu_present_mask on the other hand can change dynamically.
 746 * In case when cpu_hotplug is not compiled, then we resort to current
 747 * behaviour, which is cpu_possible == cpu_present.
 748 * - Ashok Raj
 749 *
 750 * Three ways to find out the number of additional hotplug CPUs:
 751 * - If the BIOS specified disabled CPUs in ACPI/mptables use that.
 752 * - The user can overwrite it with additional_cpus=NUM
 753 * - Otherwise don't reserve additional CPUs.
 754 */
 755__init void prefill_possible_map(void)
 756{
 757        int i;
 758        int possible, disabled_cpus;
 759
 760        disabled_cpus = total_cpus - available_cpus;
 761
 762        if (additional_cpus == -1) {
 763                if (disabled_cpus > 0)
 764                        additional_cpus = disabled_cpus;
 765                else
 766                        additional_cpus = 0;
 767        }
 768
 769        possible = available_cpus + additional_cpus;
 770
 771        if (possible > nr_cpu_ids)
 772                possible = nr_cpu_ids;
 773
 774        printk(KERN_INFO "SMP: Allowing %d CPUs, %d hotplug CPUs\n",
 775                possible, max((possible - available_cpus), 0));
 776
 777        for (i = 0; i < possible; i++)
 778                set_cpu_possible(i, true);
 779}
 780
 781static int _acpi_map_lsapic(acpi_handle handle, int physid, int *pcpu)
 782{
 783        cpumask_t tmp_map;
 784        int cpu;
 785
 786        cpumask_complement(&tmp_map, cpu_present_mask);
 787        cpu = cpumask_first(&tmp_map);
 788        if (cpu >= nr_cpu_ids)
 789                return -EINVAL;
 790
 791        acpi_map_cpu2node(handle, cpu, physid);
 792
 793        set_cpu_present(cpu, true);
 794        ia64_cpu_to_sapicid[cpu] = physid;
 795
 796        acpi_processor_set_pdc(handle);
 797
 798        *pcpu = cpu;
 799        return (0);
 800}
 801
 802/* wrapper to silence section mismatch warning */
 803int __ref acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, u32 acpi_id,
 804                       int *pcpu)
 805{
 806        return _acpi_map_lsapic(handle, physid, pcpu);
 807}
 808EXPORT_SYMBOL(acpi_map_cpu);
 809
 810int acpi_unmap_cpu(int cpu)
 811{
 812        ia64_cpu_to_sapicid[cpu] = -1;
 813        set_cpu_present(cpu, false);
 814
 815#ifdef CONFIG_ACPI_NUMA
 816        /* NUMA specific cleanup's */
 817#endif
 818
 819        return (0);
 820}
 821EXPORT_SYMBOL(acpi_unmap_cpu);
 822#endif                          /* CONFIG_ACPI_HOTPLUG_CPU */
 823
 824#ifdef CONFIG_ACPI_NUMA
 825static acpi_status acpi_map_iosapic(acpi_handle handle, u32 depth,
 826                                    void *context, void **ret)
 827{
 828        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 829        union acpi_object *obj;
 830        struct acpi_madt_io_sapic *iosapic;
 831        unsigned int gsi_base;
 832        int node;
 833
 834        /* Only care about objects w/ a method that returns the MADT */
 835        if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
 836                return AE_OK;
 837
 838        if (!buffer.length || !buffer.pointer)
 839                return AE_OK;
 840
 841        obj = buffer.pointer;
 842        if (obj->type != ACPI_TYPE_BUFFER ||
 843            obj->buffer.length < sizeof(*iosapic)) {
 844                kfree(buffer.pointer);
 845                return AE_OK;
 846        }
 847
 848        iosapic = (struct acpi_madt_io_sapic *)obj->buffer.pointer;
 849
 850        if (iosapic->header.type != ACPI_MADT_TYPE_IO_SAPIC) {
 851                kfree(buffer.pointer);
 852                return AE_OK;
 853        }
 854
 855        gsi_base = iosapic->global_irq_base;
 856
 857        kfree(buffer.pointer);
 858
 859        /* OK, it's an IOSAPIC MADT entry; associate it with a node */
 860        node = acpi_get_node(handle);
 861        if (node == NUMA_NO_NODE || !node_online(node) ||
 862            cpumask_empty(cpumask_of_node(node)))
 863                return AE_OK;
 864
 865        /* We know a gsi to node mapping! */
 866        map_iosapic_to_node(gsi_base, node);
 867        return AE_OK;
 868}
 869
 870static int __init
 871acpi_map_iosapics (void)
 872{
 873        acpi_get_devices(NULL, acpi_map_iosapic, NULL, NULL);
 874        return 0;
 875}
 876
 877fs_initcall(acpi_map_iosapics);
 878#endif                          /* CONFIG_ACPI_NUMA */
 879
 880int __ref acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base)
 881{
 882        int err;
 883
 884        if ((err = iosapic_init(phys_addr, gsi_base)))
 885                return err;
 886
 887#ifdef CONFIG_ACPI_NUMA
 888        acpi_map_iosapic(handle, 0, NULL, NULL);
 889#endif                          /* CONFIG_ACPI_NUMA */
 890
 891        return 0;
 892}
 893
 894EXPORT_SYMBOL(acpi_register_ioapic);
 895
 896int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base)
 897{
 898        return iosapic_remove(gsi_base);
 899}
 900
 901EXPORT_SYMBOL(acpi_unregister_ioapic);
 902
 903/*
 904 * acpi_suspend_lowlevel() - save kernel state and suspend.
 905 *
 906 * TBD when when IA64 starts to support suspend...
 907 */
 908int acpi_suspend_lowlevel(void) { return 0; }
 909