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