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