1 /* 2 * Intel Multiprocessor Specification 1.1 and 1.4 3 * compliant MP-table parsing routines. 4 * 5 * (c) 1995 Alan Cox, Building #3 <alan@lxorguk.ukuu.org.uk> 6 * (c) 1998, 1999, 2000, 2009 Ingo Molnar <mingo@redhat.com> 7 * (c) 2008 Alexey Starikovskiy <astarikovskiy@suse.de> 8 */ 9 10 #include <linux/mm.h> 11 #include <linux/init.h> 12 #include <linux/delay.h> 13 #include <linux/bootmem.h> 14 #include <linux/memblock.h> 15 #include <linux/kernel_stat.h> 16 #include <linux/mc146818rtc.h> 17 #include <linux/bitops.h> 18 #include <linux/acpi.h> 19 #include <linux/module.h> 20 #include <linux/smp.h> 21 #include <linux/pci.h> 22 23 #include <asm/mtrr.h> 24 #include <asm/mpspec.h> 25 #include <asm/pgalloc.h> 26 #include <asm/io_apic.h> 27 #include <asm/proto.h> 28 #include <asm/bios_ebda.h> 29 #include <asm/e820.h> 30 #include <asm/trampoline.h> 31 #include <asm/setup.h> 32 #include <asm/smp.h> 33 34 #include <asm/apic.h> 35 /* 36 * Checksum an MP configuration block. 37 */ 38 39 static int __init mpf_checksum(unsigned char *mp, int len) 40 { 41 int sum = 0; 42 43 while (len--) 44 sum += *mp++; 45 46 return sum & 0xFF; 47 } 48 49 int __init default_mpc_apic_id(struct mpc_cpu *m) 50 { 51 return m->apicid; 52 } 53 54 static void __init MP_processor_info(struct mpc_cpu *m) 55 { 56 int apicid; 57 char *bootup_cpu = ""; 58 59 if (!(m->cpuflag & CPU_ENABLED)) { 60 disabled_cpus++; 61 return; 62 } 63 64 apicid = x86_init.mpparse.mpc_apic_id(m); 65 66 if (m->cpuflag & CPU_BOOTPROCESSOR) { 67 bootup_cpu = " (Bootup-CPU)"; 68 boot_cpu_physical_apicid = m->apicid; 69 } 70 71 printk(KERN_INFO "Processor #%d%s\n", m->apicid, bootup_cpu); 72 generic_processor_info(apicid, m->apicver); 73 } 74 75 #ifdef CONFIG_X86_IO_APIC 76 void __init default_mpc_oem_bus_info(struct mpc_bus *m, char *str) 77 { 78 memcpy(str, m->bustype, 6); 79 str[6] = 0; 80 apic_printk(APIC_VERBOSE, "Bus #%d is %s\n", m->busid, str); 81 } 82 83 static void __init MP_bus_info(struct mpc_bus *m) 84 { 85 char str[7]; 86 87 x86_init.mpparse.mpc_oem_bus_info(m, str); 88 89 #if MAX_MP_BUSSES < 256 90 if (m->busid >= MAX_MP_BUSSES) { 91 printk(KERN_WARNING "MP table busid value (%d) for bustype %s " 92 " is too large, max. supported is %d\n", 93 m->busid, str, MAX_MP_BUSSES - 1); 94 return; 95 } 96 #endif 97 98 set_bit(m->busid, mp_bus_not_pci); 99 if (strncmp(str, BUSTYPE_ISA, sizeof(BUSTYPE_ISA) - 1) == 0) { 100 #ifdef CONFIG_EISA 101 mp_bus_id_to_type[m->busid] = MP_BUS_ISA; 102 #endif 103 } else if (strncmp(str, BUSTYPE_PCI, sizeof(BUSTYPE_PCI) - 1) == 0) { 104 if (x86_init.mpparse.mpc_oem_pci_bus) 105 x86_init.mpparse.mpc_oem_pci_bus(m); 106 107 clear_bit(m->busid, mp_bus_not_pci); 108 #ifdef CONFIG_EISA 109 mp_bus_id_to_type[m->busid] = MP_BUS_PCI; 110 } else if (strncmp(str, BUSTYPE_EISA, sizeof(BUSTYPE_EISA) - 1) == 0) { 111 mp_bus_id_to_type[m->busid] = MP_BUS_EISA; 112 #endif 113 } else 114 printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str); 115 } 116 117 static void __init MP_ioapic_info(struct mpc_ioapic *m) 118 { 119 if (m->flags & MPC_APIC_USABLE) 120 mp_register_ioapic(m->apicid, m->apicaddr, gsi_top); 121 } 122 123 static void __init print_mp_irq_info(struct mpc_intsrc *mp_irq) 124 { 125 apic_printk(APIC_VERBOSE, "Int: type %d, pol %d, trig %d, bus %02x," 126 " IRQ %02x, APIC ID %x, APIC INT %02x\n", 127 mp_irq->irqtype, mp_irq->irqflag & 3, 128 (mp_irq->irqflag >> 2) & 3, mp_irq->srcbus, 129 mp_irq->srcbusirq, mp_irq->dstapic, mp_irq->dstirq); 130 } 131 132 #else /* CONFIG_X86_IO_APIC */ 133 static inline void __init MP_bus_info(struct mpc_bus *m) {} 134 static inline void __init MP_ioapic_info(struct mpc_ioapic *m) {} 135 #endif /* CONFIG_X86_IO_APIC */ 136 137 static void __init MP_lintsrc_info(struct mpc_lintsrc *m) 138 { 139 apic_printk(APIC_VERBOSE, "Lint: type %d, pol %d, trig %d, bus %02x," 140 " IRQ %02x, APIC ID %x, APIC LINT %02x\n", 141 m->irqtype, m->irqflag & 3, (m->irqflag >> 2) & 3, m->srcbusid, 142 m->srcbusirq, m->destapic, m->destapiclint); 143 } 144 145 /* 146 * Read/parse the MPC 147 */ 148 static int __init smp_check_mpc(struct mpc_table *mpc, char *oem, char *str) 149 { 150 151 if (memcmp(mpc->signature, MPC_SIGNATURE, 4)) { 152 printk(KERN_ERR "MPTABLE: bad signature [%c%c%c%c]!\n", 153 mpc->signature[0], mpc->signature[1], 154 mpc->signature[2], mpc->signature[3]); 155 return 0; 156 } 157 if (mpf_checksum((unsigned char *)mpc, mpc->length)) { 158 printk(KERN_ERR "MPTABLE: checksum error!\n"); 159 return 0; 160 } 161 if (mpc->spec != 0x01 && mpc->spec != 0x04) { 162 printk(KERN_ERR "MPTABLE: bad table version (%d)!!\n", 163 mpc->spec); 164 return 0; 165 } 166 if (!mpc->lapic) { 167 printk(KERN_ERR "MPTABLE: null local APIC address!\n"); 168 return 0; 169 } 170 memcpy(oem, mpc->oem, 8); 171 oem[8] = 0; 172 printk(KERN_INFO "MPTABLE: OEM ID: %s\n", oem); 173 174 memcpy(str, mpc->productid, 12); 175 str[12] = 0; 176 177 printk(KERN_INFO "MPTABLE: Product ID: %s\n", str); 178 179 printk(KERN_INFO "MPTABLE: APIC at: 0x%X\n", mpc->lapic); 180 181 return 1; 182 } 183 184 static void skip_entry(unsigned char **ptr, int *count, int size) 185 { 186 *ptr += size; 187 *count += size; 188 } 189 190 static void __init smp_dump_mptable(struct mpc_table *mpc, unsigned char *mpt) 191 { 192 printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n" 193 "type %x\n", *mpt); 194 print_hex_dump(KERN_ERR, " ", DUMP_PREFIX_ADDRESS, 16, 195 1, mpc, mpc->length, 1); 196 } 197 198 void __init default_smp_read_mpc_oem(struct mpc_table *mpc) { } 199 200 static int __init smp_read_mpc(struct mpc_table *mpc, unsigned early) 201 { 202 char str[16]; 203 char oem[10]; 204 205 int count = sizeof(*mpc); 206 unsigned char *mpt = ((unsigned char *)mpc) + count; 207 208 if (!smp_check_mpc(mpc, oem, str)) 209 return 0; 210 211 #ifdef CONFIG_X86_32 212 generic_mps_oem_check(mpc, oem, str); 213 #endif 214 /* Initialize the lapic mapping */ 215 if (!acpi_lapic) 216 register_lapic_address(mpc->lapic); 217 218 if (early) 219 return 1; 220 221 if (mpc->oemptr) 222 x86_init.mpparse.smp_read_mpc_oem(mpc); 223 224 /* 225 * Now process the configuration blocks. 226 */ 227 x86_init.mpparse.mpc_record(0); 228 229 while (count < mpc->length) { 230 switch (*mpt) { 231 case MP_PROCESSOR: 232 /* ACPI may have already provided this data */ 233 if (!acpi_lapic) 234 MP_processor_info((struct mpc_cpu *)mpt); 235 skip_entry(&mpt, &count, sizeof(struct mpc_cpu)); 236 break; 237 case MP_BUS: 238 MP_bus_info((struct mpc_bus *)mpt); 239 skip_entry(&mpt, &count, sizeof(struct mpc_bus)); 240 break; 241 case MP_IOAPIC: 242 MP_ioapic_info((struct mpc_ioapic *)mpt); 243 skip_entry(&mpt, &count, sizeof(struct mpc_ioapic)); 244 break; 245 case MP_INTSRC: 246 mp_save_irq((struct mpc_intsrc *)mpt); 247 skip_entry(&mpt, &count, sizeof(struct mpc_intsrc)); 248 break; 249 case MP_LINTSRC: 250 MP_lintsrc_info((struct mpc_lintsrc *)mpt); 251 skip_entry(&mpt, &count, sizeof(struct mpc_lintsrc)); 252 break; 253 default: 254 /* wrong mptable */ 255 smp_dump_mptable(mpc, mpt); 256 count = mpc->length; 257 break; 258 } 259 x86_init.mpparse.mpc_record(1); 260 } 261 262 if (!num_processors) 263 printk(KERN_ERR "MPTABLE: no processors registered!\n"); 264 return num_processors; 265 } 266 267 #ifdef CONFIG_X86_IO_APIC 268 269 static int __init ELCR_trigger(unsigned int irq) 270 { 271 unsigned int port; 272 273 port = 0x4d0 + (irq >> 3); 274 return (inb(port) >> (irq & 7)) & 1; 275 } 276 277 static void __init construct_default_ioirq_mptable(int mpc_default_type) 278 { 279 struct mpc_intsrc intsrc; 280 int i; 281 int ELCR_fallback = 0; 282 283 intsrc.type = MP_INTSRC; 284 intsrc.irqflag = 0; /* conforming */ 285 intsrc.srcbus = 0; 286 intsrc.dstapic = mpc_ioapic_id(0); 287 288 intsrc.irqtype = mp_INT; 289 290 /* 291 * If true, we have an ISA/PCI system with no IRQ entries 292 * in the MP table. To prevent the PCI interrupts from being set up 293 * incorrectly, we try to use the ELCR. The sanity check to see if 294 * there is good ELCR data is very simple - IRQ0, 1, 2 and 13 can 295 * never be level sensitive, so we simply see if the ELCR agrees. 296 * If it does, we assume it's valid. 297 */ 298 if (mpc_default_type == 5) { 299 printk(KERN_INFO "ISA/PCI bus type with no IRQ information... " 300 "falling back to ELCR\n"); 301 302 if (ELCR_trigger(0) || ELCR_trigger(1) || ELCR_trigger(2) || 303 ELCR_trigger(13)) 304 printk(KERN_ERR "ELCR contains invalid data... " 305 "not using ELCR\n"); 306 else { 307 printk(KERN_INFO 308 "Using ELCR to identify PCI interrupts\n"); 309 ELCR_fallback = 1; 310 } 311 } 312 313 for (i = 0; i < 16; i++) { 314 switch (mpc_default_type) { 315 case 2: 316 if (i == 0 || i == 13) 317 continue; /* IRQ0 & IRQ13 not connected */ 318 /* fall through */ 319 default: 320 if (i == 2) 321 continue; /* IRQ2 is never connected */ 322 } 323 324 if (ELCR_fallback) { 325 /* 326 * If the ELCR indicates a level-sensitive interrupt, we 327 * copy that information over to the MP table in the 328 * irqflag field (level sensitive, active high polarity). 329 */ 330 if (ELCR_trigger(i)) 331 intsrc.irqflag = 13; 332 else 333 intsrc.irqflag = 0; 334 } 335 336 intsrc.srcbusirq = i; 337 intsrc.dstirq = i ? i : 2; /* IRQ0 to INTIN2 */ 338 mp_save_irq(&intsrc); 339 } 340 341 intsrc.irqtype = mp_ExtINT; 342 intsrc.srcbusirq = 0; 343 intsrc.dstirq = 0; /* 8259A to INTIN0 */ 344 mp_save_irq(&intsrc); 345 } 346 347 348 static void __init construct_ioapic_table(int mpc_default_type) 349 { 350 struct mpc_ioapic ioapic; 351 struct mpc_bus bus; 352 353 bus.type = MP_BUS; 354 bus.busid = 0; 355 switch (mpc_default_type) { 356 default: 357 printk(KERN_ERR "???\nUnknown standard configuration %d\n", 358 mpc_default_type); 359 /* fall through */ 360 case 1: 361 case 5: 362 memcpy(bus.bustype, "ISA ", 6); 363 break; 364 case 2: 365 case 6: 366 case 3: 367 memcpy(bus.bustype, "EISA ", 6); 368 break; 369 } 370 MP_bus_info(&bus); 371 if (mpc_default_type > 4) { 372 bus.busid = 1; 373 memcpy(bus.bustype, "PCI ", 6); 374 MP_bus_info(&bus); 375 } 376 377 ioapic.type = MP_IOAPIC; 378 ioapic.apicid = 2; 379 ioapic.apicver = mpc_default_type > 4 ? 0x10 : 0x01; 380 ioapic.flags = MPC_APIC_USABLE; 381 ioapic.apicaddr = IO_APIC_DEFAULT_PHYS_BASE; 382 MP_ioapic_info(&ioapic); 383 384 /* 385 * We set up most of the low 16 IO-APIC pins according to MPS rules. 386 */ 387 construct_default_ioirq_mptable(mpc_default_type); 388 } 389 #else 390 static inline void __init construct_ioapic_table(int mpc_default_type) { } 391 #endif 392 393 static inline void __init construct_default_ISA_mptable(int mpc_default_type) 394 { 395 struct mpc_cpu processor; 396 struct mpc_lintsrc lintsrc; 397 int linttypes[2] = { mp_ExtINT, mp_NMI }; 398 int i; 399 400 /* 401 * local APIC has default address 402 */ 403 mp_lapic_addr = APIC_DEFAULT_PHYS_BASE; 404 405 /* 406 * 2 CPUs, numbered 0 & 1. 407 */ 408 processor.type = MP_PROCESSOR; 409 /* Either an integrated APIC or a discrete 82489DX. */ 410 processor.apicver = mpc_default_type > 4 ? 0x10 : 0x01; 411 processor.cpuflag = CPU_ENABLED; 412 processor.cpufeature = (boot_cpu_data.x86 << 8) | 413 (boot_cpu_data.x86_model << 4) | boot_cpu_data.x86_mask; 414 processor.featureflag = boot_cpu_data.x86_capability[0]; 415 processor.reserved[0] = 0; 416 processor.reserved[1] = 0; 417 for (i = 0; i < 2; i++) { 418 processor.apicid = i; 419 MP_processor_info(&processor); 420 } 421 422 construct_ioapic_table(mpc_default_type); 423 424 lintsrc.type = MP_LINTSRC; 425 lintsrc.irqflag = 0; /* conforming */ 426 lintsrc.srcbusid = 0; 427 lintsrc.srcbusirq = 0; 428 lintsrc.destapic = MP_APIC_ALL; 429 for (i = 0; i < 2; i++) { 430 lintsrc.irqtype = linttypes[i]; 431 lintsrc.destapiclint = i; 432 MP_lintsrc_info(&lintsrc); 433 } 434 } 435 436 static struct mpf_intel *mpf_found; 437 438 static unsigned long __init get_mpc_size(unsigned long physptr) 439 { 440 struct mpc_table *mpc; 441 unsigned long size; 442 443 mpc = early_ioremap(physptr, PAGE_SIZE); 444 size = mpc->length; 445 early_iounmap(mpc, PAGE_SIZE); 446 apic_printk(APIC_VERBOSE, " mpc: %lx-%lx\n", physptr, physptr + size); 447 448 return size; 449 } 450 451 static int __init check_physptr(struct mpf_intel *mpf, unsigned int early) 452 { 453 struct mpc_table *mpc; 454 unsigned long size; 455 456 size = get_mpc_size(mpf->physptr); 457 mpc = early_ioremap(mpf->physptr, size); 458 /* 459 * Read the physical hardware table. Anything here will 460 * override the defaults. 461 */ 462 if (!smp_read_mpc(mpc, early)) { 463 #ifdef CONFIG_X86_LOCAL_APIC 464 smp_found_config = 0; 465 #endif 466 printk(KERN_ERR "BIOS bug, MP table errors detected!...\n" 467 "... disabling SMP support. (tell your hw vendor)\n"); 468 early_iounmap(mpc, size); 469 return -1; 470 } 471 early_iounmap(mpc, size); 472 473 if (early) 474 return -1; 475 476 #ifdef CONFIG_X86_IO_APIC 477 /* 478 * If there are no explicit MP IRQ entries, then we are 479 * broken. We set up most of the low 16 IO-APIC pins to 480 * ISA defaults and hope it will work. 481 */ 482 if (!mp_irq_entries) { 483 struct mpc_bus bus; 484 485 printk(KERN_ERR "BIOS bug, no explicit IRQ entries, " 486 "using default mptable. (tell your hw vendor)\n"); 487 488 bus.type = MP_BUS; 489 bus.busid = 0; 490 memcpy(bus.bustype, "ISA ", 6); 491 MP_bus_info(&bus); 492 493 construct_default_ioirq_mptable(0); 494 } 495 #endif 496 497 return 0; 498 } 499 500 /* 501 * Scan the memory blocks for an SMP configuration block. 502 */ 503 void __init default_get_smp_config(unsigned int early) 504 { 505 struct mpf_intel *mpf = mpf_found; 506 507 if (!mpf) 508 return; 509 510 if (acpi_lapic && early) 511 return; 512 513 /* 514 * MPS doesn't support hyperthreading, aka only have 515 * thread 0 apic id in MPS table 516 */ 517 if (acpi_lapic && acpi_ioapic) 518 return; 519 520 printk(KERN_INFO "Intel MultiProcessor Specification v1.%d\n", 521 mpf->specification); 522 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86_32) 523 if (mpf->feature2 & (1 << 7)) { 524 printk(KERN_INFO " IMCR and PIC compatibility mode.\n"); 525 pic_mode = 1; 526 } else { 527 printk(KERN_INFO " Virtual Wire compatibility mode.\n"); 528 pic_mode = 0; 529 } 530 #endif 531 /* 532 * Now see if we need to read further. 533 */ 534 if (mpf->feature1 != 0) { 535 if (early) { 536 /* 537 * local APIC has default address 538 */ 539 mp_lapic_addr = APIC_DEFAULT_PHYS_BASE; 540 return; 541 } 542 543 printk(KERN_INFO "Default MP configuration #%d\n", 544 mpf->feature1); 545 construct_default_ISA_mptable(mpf->feature1); 546 547 } else if (mpf->physptr) { 548 if (check_physptr(mpf, early)) 549 return; 550 } else 551 BUG(); 552 553 if (!early) 554 printk(KERN_INFO "Processors: %d\n", num_processors); 555 /* 556 * Only use the first configuration found. 557 */ 558 } 559 560 static void __init smp_reserve_memory(struct mpf_intel *mpf) 561 { 562 memblock_reserve(mpf->physptr, get_mpc_size(mpf->physptr)); 563 } 564 565 static int __init smp_scan_config(unsigned long base, unsigned long length) 566 { 567 unsigned int *bp = phys_to_virt(base); 568 struct mpf_intel *mpf; 569 unsigned long mem; 570 571 apic_printk(APIC_VERBOSE, "Scan for SMP in [mem %#010lx-%#010lx]\n", 572 base, base + length - 1); 573 BUILD_BUG_ON(sizeof(*mpf) != 16); 574 575 while (length > 0) { 576 mpf = (struct mpf_intel *)bp; 577 if ((*bp == SMP_MAGIC_IDENT) && 578 (mpf->length == 1) && 579 !mpf_checksum((unsigned char *)bp, 16) && 580 ((mpf->specification == 1) 581 || (mpf->specification == 4))) { 582 #ifdef CONFIG_X86_LOCAL_APIC 583 smp_found_config = 1; 584 #endif 585 mpf_found = mpf; 586 587 printk(KERN_INFO "found SMP MP-table at [mem %#010llx-%#010llx] mapped at [%p]\n", 588 (unsigned long long) virt_to_phys(mpf), 589 (unsigned long long) virt_to_phys(mpf) + 590 sizeof(*mpf) - 1, mpf); 591 592 mem = virt_to_phys(mpf); 593 memblock_reserve(mem, sizeof(*mpf)); 594 if (mpf->physptr) 595 smp_reserve_memory(mpf); 596 597 return 1; 598 } 599 bp += 4; 600 length -= 16; 601 } 602 return 0; 603 } 604 605 void __init default_find_smp_config(void) 606 { 607 unsigned int address; 608 609 /* 610 * FIXME: Linux assumes you have 640K of base ram.. 611 * this continues the error... 612 * 613 * 1) Scan the bottom 1K for a signature 614 * 2) Scan the top 1K of base RAM 615 * 3) Scan the 64K of bios 616 */ 617 if (smp_scan_config(0x0, 0x400) || 618 smp_scan_config(639 * 0x400, 0x400) || 619 smp_scan_config(0xF0000, 0x10000)) 620 return; 621 /* 622 * If it is an SMP machine we should know now, unless the 623 * configuration is in an EISA bus machine with an 624 * extended bios data area. 625 * 626 * there is a real-mode segmented pointer pointing to the 627 * 4K EBDA area at 0x40E, calculate and scan it here. 628 * 629 * NOTE! There are Linux loaders that will corrupt the EBDA 630 * area, and as such this kind of SMP config may be less 631 * trustworthy, simply because the SMP table may have been 632 * stomped on during early boot. These loaders are buggy and 633 * should be fixed. 634 * 635 * MP1.4 SPEC states to only scan first 1K of 4K EBDA. 636 */ 637 638 address = get_bios_ebda(); 639 if (address) 640 smp_scan_config(address, 0x400); 641 } 642 643 #ifdef CONFIG_X86_IO_APIC 644 static u8 __initdata irq_used[MAX_IRQ_SOURCES]; 645 646 static int __init get_MP_intsrc_index(struct mpc_intsrc *m) 647 { 648 int i; 649 650 if (m->irqtype != mp_INT) 651 return 0; 652 653 if (m->irqflag != 0x0f) 654 return 0; 655 656 /* not legacy */ 657 658 for (i = 0; i < mp_irq_entries; i++) { 659 if (mp_irqs[i].irqtype != mp_INT) 660 continue; 661 662 if (mp_irqs[i].irqflag != 0x0f) 663 continue; 664 665 if (mp_irqs[i].srcbus != m->srcbus) 666 continue; 667 if (mp_irqs[i].srcbusirq != m->srcbusirq) 668 continue; 669 if (irq_used[i]) { 670 /* already claimed */ 671 return -2; 672 } 673 irq_used[i] = 1; 674 return i; 675 } 676 677 /* not found */ 678 return -1; 679 } 680 681 #define SPARE_SLOT_NUM 20 682 683 static struct mpc_intsrc __initdata *m_spare[SPARE_SLOT_NUM]; 684 685 static void __init check_irq_src(struct mpc_intsrc *m, int *nr_m_spare) 686 { 687 int i; 688 689 apic_printk(APIC_VERBOSE, "OLD "); 690 print_mp_irq_info(m); 691 692 i = get_MP_intsrc_index(m); 693 if (i > 0) { 694 memcpy(m, &mp_irqs[i], sizeof(*m)); 695 apic_printk(APIC_VERBOSE, "NEW "); 696 print_mp_irq_info(&mp_irqs[i]); 697 return; 698 } 699 if (!i) { 700 /* legacy, do nothing */ 701 return; 702 } 703 if (*nr_m_spare < SPARE_SLOT_NUM) { 704 /* 705 * not found (-1), or duplicated (-2) are invalid entries, 706 * we need to use the slot later 707 */ 708 m_spare[*nr_m_spare] = m; 709 *nr_m_spare += 1; 710 } 711 } 712 713 static int __init 714 check_slot(unsigned long mpc_new_phys, unsigned long mpc_new_length, int count) 715 { 716 if (!mpc_new_phys || count <= mpc_new_length) { 717 WARN(1, "update_mptable: No spare slots (length: %x)\n", count); 718 return -1; 719 } 720 721 return 0; 722 } 723 #else /* CONFIG_X86_IO_APIC */ 724 static 725 inline void __init check_irq_src(struct mpc_intsrc *m, int *nr_m_spare) {} 726 #endif /* CONFIG_X86_IO_APIC */ 727 728 static int __init replace_intsrc_all(struct mpc_table *mpc, 729 unsigned long mpc_new_phys, 730 unsigned long mpc_new_length) 731 { 732 #ifdef CONFIG_X86_IO_APIC 733 int i; 734 #endif 735 int count = sizeof(*mpc); 736 int nr_m_spare = 0; 737 unsigned char *mpt = ((unsigned char *)mpc) + count; 738 739 printk(KERN_INFO "mpc_length %x\n", mpc->length); 740 while (count < mpc->length) { 741 switch (*mpt) { 742 case MP_PROCESSOR: 743 skip_entry(&mpt, &count, sizeof(struct mpc_cpu)); 744 break; 745 case MP_BUS: 746 skip_entry(&mpt, &count, sizeof(struct mpc_bus)); 747 break; 748 case MP_IOAPIC: 749 skip_entry(&mpt, &count, sizeof(struct mpc_ioapic)); 750 break; 751 case MP_INTSRC: 752 check_irq_src((struct mpc_intsrc *)mpt, &nr_m_spare); 753 skip_entry(&mpt, &count, sizeof(struct mpc_intsrc)); 754 break; 755 case MP_LINTSRC: 756 skip_entry(&mpt, &count, sizeof(struct mpc_lintsrc)); 757 break; 758 default: 759 /* wrong mptable */ 760 smp_dump_mptable(mpc, mpt); 761 goto out; 762 } 763 } 764 765 #ifdef CONFIG_X86_IO_APIC 766 for (i = 0; i < mp_irq_entries; i++) { 767 if (irq_used[i]) 768 continue; 769 770 if (mp_irqs[i].irqtype != mp_INT) 771 continue; 772 773 if (mp_irqs[i].irqflag != 0x0f) 774 continue; 775 776 if (nr_m_spare > 0) { 777 apic_printk(APIC_VERBOSE, "*NEW* found\n"); 778 nr_m_spare--; 779 memcpy(m_spare[nr_m_spare], &mp_irqs[i], sizeof(mp_irqs[i])); 780 m_spare[nr_m_spare] = NULL; 781 } else { 782 struct mpc_intsrc *m = (struct mpc_intsrc *)mpt; 783 count += sizeof(struct mpc_intsrc); 784 if (check_slot(mpc_new_phys, mpc_new_length, count) < 0) 785 goto out; 786 memcpy(m, &mp_irqs[i], sizeof(*m)); 787 mpc->length = count; 788 mpt += sizeof(struct mpc_intsrc); 789 } 790 print_mp_irq_info(&mp_irqs[i]); 791 } 792 #endif 793 out: 794 /* update checksum */ 795 mpc->checksum = 0; 796 mpc->checksum -= mpf_checksum((unsigned char *)mpc, mpc->length); 797 798 return 0; 799 } 800 801 int enable_update_mptable; 802 803 static int __init update_mptable_setup(char *str) 804 { 805 enable_update_mptable = 1; 806 #ifdef CONFIG_PCI 807 pci_routeirq = 1; 808 #endif 809 return 0; 810 } 811 early_param("update_mptable", update_mptable_setup); 812 813 static unsigned long __initdata mpc_new_phys; 814 static unsigned long mpc_new_length __initdata = 4096; 815 816 /* alloc_mptable or alloc_mptable=4k */ 817 static int __initdata alloc_mptable; 818 static int __init parse_alloc_mptable_opt(char *p) 819 { 820 enable_update_mptable = 1; 821 #ifdef CONFIG_PCI 822 pci_routeirq = 1; 823 #endif 824 alloc_mptable = 1; 825 if (!p) 826 return 0; 827 mpc_new_length = memparse(p, &p); 828 return 0; 829 } 830 early_param("alloc_mptable", parse_alloc_mptable_opt); 831 832 void __init early_reserve_e820_mpc_new(void) 833 { 834 if (enable_update_mptable && alloc_mptable) 835 mpc_new_phys = early_reserve_e820(mpc_new_length, 4); 836 } 837 838 static int __init update_mp_table(void) 839 { 840 char str[16]; 841 char oem[10]; 842 struct mpf_intel *mpf; 843 struct mpc_table *mpc, *mpc_new; 844 845 if (!enable_update_mptable) 846 return 0; 847 848 mpf = mpf_found; 849 if (!mpf) 850 return 0; 851 852 /* 853 * Now see if we need to go further. 854 */ 855 if (mpf->feature1 != 0) 856 return 0; 857 858 if (!mpf->physptr) 859 return 0; 860 861 mpc = phys_to_virt(mpf->physptr); 862 863 if (!smp_check_mpc(mpc, oem, str)) 864 return 0; 865 866 printk(KERN_INFO "mpf: %llx\n", (u64)virt_to_phys(mpf)); 867 printk(KERN_INFO "physptr: %x\n", mpf->physptr); 868 869 if (mpc_new_phys && mpc->length > mpc_new_length) { 870 mpc_new_phys = 0; 871 printk(KERN_INFO "mpc_new_length is %ld, please use alloc_mptable=8k\n", 872 mpc_new_length); 873 } 874 875 if (!mpc_new_phys) { 876 unsigned char old, new; 877 /* check if we can change the position */ 878 mpc->checksum = 0; 879 old = mpf_checksum((unsigned char *)mpc, mpc->length); 880 mpc->checksum = 0xff; 881 new = mpf_checksum((unsigned char *)mpc, mpc->length); 882 if (old == new) { 883 printk(KERN_INFO "mpc is readonly, please try alloc_mptable instead\n"); 884 return 0; 885 } 886 printk(KERN_INFO "use in-position replacing\n"); 887 } else { 888 mpf->physptr = mpc_new_phys; 889 mpc_new = phys_to_virt(mpc_new_phys); 890 memcpy(mpc_new, mpc, mpc->length); 891 mpc = mpc_new; 892 /* check if we can modify that */ 893 if (mpc_new_phys - mpf->physptr) { 894 struct mpf_intel *mpf_new; 895 /* steal 16 bytes from [0, 1k) */ 896 printk(KERN_INFO "mpf new: %x\n", 0x400 - 16); 897 mpf_new = phys_to_virt(0x400 - 16); 898 memcpy(mpf_new, mpf, 16); 899 mpf = mpf_new; 900 mpf->physptr = mpc_new_phys; 901 } 902 mpf->checksum = 0; 903 mpf->checksum -= mpf_checksum((unsigned char *)mpf, 16); 904 printk(KERN_INFO "physptr new: %x\n", mpf->physptr); 905 } 906 907 /* 908 * only replace the one with mp_INT and 909 * MP_IRQ_TRIGGER_LEVEL|MP_IRQ_POLARITY_LOW, 910 * already in mp_irqs , stored by ... and mp_config_acpi_gsi, 911 * may need pci=routeirq for all coverage 912 */ 913 replace_intsrc_all(mpc, mpc_new_phys, mpc_new_length); 914 915 return 0; 916 } 917 918 late_initcall(update_mp_table); 919