2 * Intel Multiprocessor Specification 1.1 and 1.4
3 * compliant MP-table parsing routines.
5 * (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
6 * (c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
7 * (c) 2008 Alexey Starikovskiy <astarikovskiy@suse.de>
11 #include <linux/init.h>
12 #include <linux/delay.h>
13 #include <linux/bootmem.h>
14 #include <linux/kernel_stat.h>
15 #include <linux/mc146818rtc.h>
16 #include <linux/bitops.h>
17 #include <linux/acpi.h>
18 #include <linux/module.h>
22 #include <asm/mpspec.h>
23 #include <asm/pgalloc.h>
24 #include <asm/io_apic.h>
25 #include <asm/proto.h>
27 #include <asm/bios_ebda.h>
29 #include <asm/trampoline.h>
31 #include <mach_apic.h>
33 #include <mach_apicdef.h>
34 #include <mach_mpparse.h>
38 * Checksum an MP configuration block.
41 static int __init mpf_checksum(unsigned char *mp, int len)
51 #ifdef CONFIG_X86_NUMAQ
54 * Have to match translation table entries to main table entries by counter
55 * hence the mpc_record variable .... can't see a less disgusting way of
58 struct mpc_config_translation {
59 unsigned char mpc_type;
60 unsigned char trans_len;
61 unsigned char trans_type;
62 unsigned char trans_quad;
63 unsigned char trans_global;
64 unsigned char trans_local;
65 unsigned short trans_reserved;
69 static int mpc_record;
70 static struct mpc_config_translation *translation_table[MAX_MPC_ENTRY]
73 static inline int generate_logical_apicid(int quad, int phys_apicid)
75 return (quad << 4) + (phys_apicid ? phys_apicid << 1 : 1);
79 static inline int mpc_apic_id(struct mpc_config_processor *m,
80 struct mpc_config_translation *translation_record)
82 int quad = translation_record->trans_quad;
83 int logical_apicid = generate_logical_apicid(quad, m->mpc_apicid);
85 printk(KERN_DEBUG "Processor #%d %u:%u APIC version %d (quad %d, apic %d)\n",
87 (m->mpc_cpufeature & CPU_FAMILY_MASK) >> 8,
88 (m->mpc_cpufeature & CPU_MODEL_MASK) >> 4,
89 m->mpc_apicver, quad, logical_apicid);
90 return logical_apicid;
93 int mp_bus_id_to_node[MAX_MP_BUSSES];
95 int mp_bus_id_to_local[MAX_MP_BUSSES];
97 static void mpc_oem_bus_info(struct mpc_config_bus *m, char *name,
98 struct mpc_config_translation *translation)
100 int quad = translation->trans_quad;
101 int local = translation->trans_local;
103 mp_bus_id_to_node[m->mpc_busid] = quad;
104 mp_bus_id_to_local[m->mpc_busid] = local;
105 printk(KERN_INFO "Bus #%d is %s (node %d)\n",
106 m->mpc_busid, name, quad);
109 int quad_local_to_mp_bus_id [NR_CPUS/4][4];
110 static void mpc_oem_pci_bus(struct mpc_config_bus *m,
111 struct mpc_config_translation *translation)
113 int quad = translation->trans_quad;
114 int local = translation->trans_local;
116 quad_local_to_mp_bus_id[quad][local] = m->mpc_busid;
121 static void __cpuinit MP_processor_info(struct mpc_config_processor *m)
124 char *bootup_cpu = "";
126 if (!(m->mpc_cpuflag & CPU_ENABLED)) {
130 #ifdef CONFIG_X86_NUMAQ
132 apicid = mpc_apic_id(m, translation_table[mpc_record]);
134 apicid = m->mpc_apicid;
136 apicid = m->mpc_apicid;
138 if (m->mpc_cpuflag & CPU_BOOTPROCESSOR) {
139 bootup_cpu = " (Bootup-CPU)";
140 boot_cpu_physical_apicid = m->mpc_apicid;
143 printk(KERN_INFO "Processor #%d%s\n", m->mpc_apicid, bootup_cpu);
144 generic_processor_info(apicid, m->mpc_apicver);
147 #ifdef CONFIG_X86_IO_APIC
148 static void __init MP_bus_info(struct mpc_config_bus *m)
151 memcpy(str, m->mpc_bustype, 6);
154 #ifdef CONFIG_X86_NUMAQ
156 mpc_oem_bus_info(m, str, translation_table[mpc_record]);
158 printk(KERN_INFO "Bus #%d is %s\n", m->mpc_busid, str);
161 #if MAX_MP_BUSSES < 256
162 if (m->mpc_busid >= MAX_MP_BUSSES) {
163 printk(KERN_WARNING "MP table busid value (%d) for bustype %s "
164 " is too large, max. supported is %d\n",
165 m->mpc_busid, str, MAX_MP_BUSSES - 1);
170 if (strncmp(str, BUSTYPE_ISA, sizeof(BUSTYPE_ISA) - 1) == 0) {
171 set_bit(m->mpc_busid, mp_bus_not_pci);
172 #if defined(CONFIG_EISA) || defined (CONFIG_MCA)
173 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_ISA;
175 } else if (strncmp(str, BUSTYPE_PCI, sizeof(BUSTYPE_PCI) - 1) == 0) {
176 #ifdef CONFIG_X86_NUMAQ
178 mpc_oem_pci_bus(m, translation_table[mpc_record]);
180 clear_bit(m->mpc_busid, mp_bus_not_pci);
181 #if defined(CONFIG_EISA) || defined (CONFIG_MCA)
182 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_PCI;
183 } else if (strncmp(str, BUSTYPE_EISA, sizeof(BUSTYPE_EISA) - 1) == 0) {
184 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_EISA;
185 } else if (strncmp(str, BUSTYPE_MCA, sizeof(BUSTYPE_MCA) - 1) == 0) {
186 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_MCA;
189 printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str);
193 #ifdef CONFIG_X86_IO_APIC
195 static int bad_ioapic(unsigned long address)
197 if (nr_ioapics >= MAX_IO_APICS) {
198 printk(KERN_ERR "ERROR: Max # of I/O APICs (%d) exceeded "
199 "(found %d)\n", MAX_IO_APICS, nr_ioapics);
200 panic("Recompile kernel with bigger MAX_IO_APICS!\n");
203 printk(KERN_ERR "WARNING: Bogus (zero) I/O APIC address"
204 " found in table, skipping!\n");
210 static void __init MP_ioapic_info(struct mpc_config_ioapic *m)
212 if (!(m->mpc_flags & MPC_APIC_USABLE))
215 printk(KERN_INFO "I/O APIC #%d Version %d at 0x%X.\n",
216 m->mpc_apicid, m->mpc_apicver, m->mpc_apicaddr);
218 if (bad_ioapic(m->mpc_apicaddr))
221 mp_ioapics[nr_ioapics].mp_apicaddr = m->mpc_apicaddr;
222 mp_ioapics[nr_ioapics].mp_apicid = m->mpc_apicid;
223 mp_ioapics[nr_ioapics].mp_type = m->mpc_type;
224 mp_ioapics[nr_ioapics].mp_apicver = m->mpc_apicver;
225 mp_ioapics[nr_ioapics].mp_flags = m->mpc_flags;
229 static void print_MP_intsrc_info(struct mpc_config_intsrc *m)
231 printk(KERN_CONT "Int: type %d, pol %d, trig %d, bus %02x,"
232 " IRQ %02x, APIC ID %x, APIC INT %02x\n",
233 m->mpc_irqtype, m->mpc_irqflag & 3,
234 (m->mpc_irqflag >> 2) & 3, m->mpc_srcbus,
235 m->mpc_srcbusirq, m->mpc_dstapic, m->mpc_dstirq);
238 static void __init print_mp_irq_info(struct mp_config_intsrc *mp_irq)
240 printk(KERN_CONT "Int: type %d, pol %d, trig %d, bus %02x,"
241 " IRQ %02x, APIC ID %x, APIC INT %02x\n",
242 mp_irq->mp_irqtype, mp_irq->mp_irqflag & 3,
243 (mp_irq->mp_irqflag >> 2) & 3, mp_irq->mp_srcbus,
244 mp_irq->mp_srcbusirq, mp_irq->mp_dstapic, mp_irq->mp_dstirq);
247 static void __init assign_to_mp_irq(struct mpc_config_intsrc *m,
248 struct mp_config_intsrc *mp_irq)
250 mp_irq->mp_dstapic = m->mpc_dstapic;
251 mp_irq->mp_type = m->mpc_type;
252 mp_irq->mp_irqtype = m->mpc_irqtype;
253 mp_irq->mp_irqflag = m->mpc_irqflag;
254 mp_irq->mp_srcbus = m->mpc_srcbus;
255 mp_irq->mp_srcbusirq = m->mpc_srcbusirq;
256 mp_irq->mp_dstirq = m->mpc_dstirq;
259 static void __init assign_to_mpc_intsrc(struct mp_config_intsrc *mp_irq,
260 struct mpc_config_intsrc *m)
262 m->mpc_dstapic = mp_irq->mp_dstapic;
263 m->mpc_type = mp_irq->mp_type;
264 m->mpc_irqtype = mp_irq->mp_irqtype;
265 m->mpc_irqflag = mp_irq->mp_irqflag;
266 m->mpc_srcbus = mp_irq->mp_srcbus;
267 m->mpc_srcbusirq = mp_irq->mp_srcbusirq;
268 m->mpc_dstirq = mp_irq->mp_dstirq;
271 static int __init mp_irq_mpc_intsrc_cmp(struct mp_config_intsrc *mp_irq,
272 struct mpc_config_intsrc *m)
274 if (mp_irq->mp_dstapic != m->mpc_dstapic)
276 if (mp_irq->mp_type != m->mpc_type)
278 if (mp_irq->mp_irqtype != m->mpc_irqtype)
280 if (mp_irq->mp_irqflag != m->mpc_irqflag)
282 if (mp_irq->mp_srcbus != m->mpc_srcbus)
284 if (mp_irq->mp_srcbusirq != m->mpc_srcbusirq)
286 if (mp_irq->mp_dstirq != m->mpc_dstirq)
292 static void __init MP_intsrc_info(struct mpc_config_intsrc *m)
296 print_MP_intsrc_info(m);
298 for (i = 0; i < mp_irq_entries; i++) {
299 if (!mp_irq_mpc_intsrc_cmp(&mp_irqs[i], m))
303 assign_to_mp_irq(m, &mp_irqs[mp_irq_entries]);
304 if (++mp_irq_entries == MAX_IRQ_SOURCES)
305 panic("Max # of irq sources exceeded!!\n");
310 static void __init MP_lintsrc_info(struct mpc_config_lintsrc *m)
312 printk(KERN_INFO "Lint: type %d, pol %d, trig %d, bus %02x,"
313 " IRQ %02x, APIC ID %x, APIC LINT %02x\n",
314 m->mpc_irqtype, m->mpc_irqflag & 3,
315 (m->mpc_irqflag >> 2) & 3, m->mpc_srcbusid,
316 m->mpc_srcbusirq, m->mpc_destapic, m->mpc_destapiclint);
319 #ifdef CONFIG_X86_NUMAQ
320 static void __init MP_translation_info(struct mpc_config_translation *m)
323 "Translation: record %d, type %d, quad %d, global %d, local %d\n",
324 mpc_record, m->trans_type, m->trans_quad, m->trans_global,
327 if (mpc_record >= MAX_MPC_ENTRY)
328 printk(KERN_ERR "MAX_MPC_ENTRY exceeded!\n");
330 translation_table[mpc_record] = m; /* stash this for later */
331 if (m->trans_quad < MAX_NUMNODES && !node_online(m->trans_quad))
332 node_set_online(m->trans_quad);
336 * Read/parse the MPC oem tables
339 static void __init smp_read_mpc_oem(struct mp_config_oemtable *oemtable,
340 unsigned short oemsize)
342 int count = sizeof(*oemtable); /* the header size */
343 unsigned char *oemptr = ((unsigned char *)oemtable) + count;
346 printk(KERN_INFO "Found an OEM MPC table at %8p - parsing it ... \n",
348 if (memcmp(oemtable->oem_signature, MPC_OEM_SIGNATURE, 4)) {
350 "SMP mpc oemtable: bad signature [%c%c%c%c]!\n",
351 oemtable->oem_signature[0], oemtable->oem_signature[1],
352 oemtable->oem_signature[2], oemtable->oem_signature[3]);
355 if (mpf_checksum((unsigned char *)oemtable, oemtable->oem_length)) {
356 printk(KERN_WARNING "SMP oem mptable: checksum error!\n");
359 while (count < oemtable->oem_length) {
363 struct mpc_config_translation *m =
364 (struct mpc_config_translation *)oemptr;
365 MP_translation_info(m);
366 oemptr += sizeof(*m);
374 "Unrecognised OEM table entry type! - %d\n",
382 void numaq_mps_oem_check(struct mp_config_table *mpc, char *oem,
385 if (strncmp(oem, "IBM NUMA", 8))
386 printk("Warning! Not a NUMA-Q system!\n");
391 smp_read_mpc_oem((struct mp_config_oemtable *)mpc->mpc_oemptr,
394 #endif /* CONFIG_X86_NUMAQ */
400 static int __init smp_check_mpc(struct mp_config_table *mpc, char *oem,
404 if (memcmp(mpc->mpc_signature, MPC_SIGNATURE, 4)) {
405 printk(KERN_ERR "MPTABLE: bad signature [%c%c%c%c]!\n",
406 mpc->mpc_signature[0], mpc->mpc_signature[1],
407 mpc->mpc_signature[2], mpc->mpc_signature[3]);
410 if (mpf_checksum((unsigned char *)mpc, mpc->mpc_length)) {
411 printk(KERN_ERR "MPTABLE: checksum error!\n");
414 if (mpc->mpc_spec != 0x01 && mpc->mpc_spec != 0x04) {
415 printk(KERN_ERR "MPTABLE: bad table version (%d)!!\n",
419 if (!mpc->mpc_lapic) {
420 printk(KERN_ERR "MPTABLE: null local APIC address!\n");
423 memcpy(oem, mpc->mpc_oem, 8);
425 printk(KERN_INFO "MPTABLE: OEM ID: %s\n", oem);
427 memcpy(str, mpc->mpc_productid, 12);
430 printk(KERN_INFO "MPTABLE: Product ID: %s\n", str);
432 printk(KERN_INFO "MPTABLE: APIC at: 0x%X\n", mpc->mpc_lapic);
437 static int __init smp_read_mpc(struct mp_config_table *mpc, unsigned early)
442 int count = sizeof(*mpc);
443 unsigned char *mpt = ((unsigned char *)mpc) + count;
445 if (!smp_check_mpc(mpc, oem, str))
450 * need to make sure summit and es7000's mps_oem_check is safe to be
451 * called early via genericarch 's mps_oem_check
454 #ifdef CONFIG_X86_NUMAQ
455 numaq_mps_oem_check(mpc, oem, str);
458 mps_oem_check(mpc, oem, str);
461 /* save the local APIC address, it might be non-default */
463 mp_lapic_addr = mpc->mpc_lapic;
469 * Now process the configuration blocks.
471 #ifdef CONFIG_X86_NUMAQ
474 while (count < mpc->mpc_length) {
478 struct mpc_config_processor *m =
479 (struct mpc_config_processor *)mpt;
480 /* ACPI may have already provided this data */
482 MP_processor_info(m);
489 struct mpc_config_bus *m =
490 (struct mpc_config_bus *)mpt;
491 #ifdef CONFIG_X86_IO_APIC
500 #ifdef CONFIG_X86_IO_APIC
501 struct mpc_config_ioapic *m =
502 (struct mpc_config_ioapic *)mpt;
505 mpt += sizeof(struct mpc_config_ioapic);
506 count += sizeof(struct mpc_config_ioapic);
511 #ifdef CONFIG_X86_IO_APIC
512 struct mpc_config_intsrc *m =
513 (struct mpc_config_intsrc *)mpt;
517 mpt += sizeof(struct mpc_config_intsrc);
518 count += sizeof(struct mpc_config_intsrc);
523 struct mpc_config_lintsrc *m =
524 (struct mpc_config_lintsrc *)mpt;
532 printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n");
533 printk(KERN_ERR "type %x\n", *mpt);
534 print_hex_dump(KERN_ERR, " ", DUMP_PREFIX_ADDRESS, 16,
535 1, mpc, mpc->mpc_length, 1);
536 count = mpc->mpc_length;
539 #ifdef CONFIG_X86_NUMAQ
544 #ifdef CONFIG_X86_GENERICARCH
545 generic_bigsmp_probe();
549 setup_apic_routing();
552 printk(KERN_ERR "MPTABLE: no processors registered!\n");
553 return num_processors;
556 #ifdef CONFIG_X86_IO_APIC
558 static int __init ELCR_trigger(unsigned int irq)
562 port = 0x4d0 + (irq >> 3);
563 return (inb(port) >> (irq & 7)) & 1;
566 static void __init construct_default_ioirq_mptable(int mpc_default_type)
568 struct mpc_config_intsrc intsrc;
570 int ELCR_fallback = 0;
572 intsrc.mpc_type = MP_INTSRC;
573 intsrc.mpc_irqflag = 0; /* conforming */
574 intsrc.mpc_srcbus = 0;
575 intsrc.mpc_dstapic = mp_ioapics[0].mp_apicid;
577 intsrc.mpc_irqtype = mp_INT;
580 * If true, we have an ISA/PCI system with no IRQ entries
581 * in the MP table. To prevent the PCI interrupts from being set up
582 * incorrectly, we try to use the ELCR. The sanity check to see if
583 * there is good ELCR data is very simple - IRQ0, 1, 2 and 13 can
584 * never be level sensitive, so we simply see if the ELCR agrees.
585 * If it does, we assume it's valid.
587 if (mpc_default_type == 5) {
588 printk(KERN_INFO "ISA/PCI bus type with no IRQ information... "
589 "falling back to ELCR\n");
591 if (ELCR_trigger(0) || ELCR_trigger(1) || ELCR_trigger(2) ||
593 printk(KERN_ERR "ELCR contains invalid data... "
597 "Using ELCR to identify PCI interrupts\n");
602 for (i = 0; i < 16; i++) {
603 switch (mpc_default_type) {
605 if (i == 0 || i == 13)
606 continue; /* IRQ0 & IRQ13 not connected */
610 continue; /* IRQ2 is never connected */
615 * If the ELCR indicates a level-sensitive interrupt, we
616 * copy that information over to the MP table in the
617 * irqflag field (level sensitive, active high polarity).
620 intsrc.mpc_irqflag = 13;
622 intsrc.mpc_irqflag = 0;
625 intsrc.mpc_srcbusirq = i;
626 intsrc.mpc_dstirq = i ? i : 2; /* IRQ0 to INTIN2 */
627 MP_intsrc_info(&intsrc);
630 intsrc.mpc_irqtype = mp_ExtINT;
631 intsrc.mpc_srcbusirq = 0;
632 intsrc.mpc_dstirq = 0; /* 8259A to INTIN0 */
633 MP_intsrc_info(&intsrc);
637 static void construct_ioapic_table(int mpc_default_type)
639 struct mpc_config_ioapic ioapic;
640 struct mpc_config_bus bus;
642 bus.mpc_type = MP_BUS;
644 switch (mpc_default_type) {
646 printk(KERN_ERR "???\nUnknown standard configuration %d\n",
651 memcpy(bus.mpc_bustype, "ISA ", 6);
656 memcpy(bus.mpc_bustype, "EISA ", 6);
660 memcpy(bus.mpc_bustype, "MCA ", 6);
663 if (mpc_default_type > 4) {
665 memcpy(bus.mpc_bustype, "PCI ", 6);
669 ioapic.mpc_type = MP_IOAPIC;
670 ioapic.mpc_apicid = 2;
671 ioapic.mpc_apicver = mpc_default_type > 4 ? 0x10 : 0x01;
672 ioapic.mpc_flags = MPC_APIC_USABLE;
673 ioapic.mpc_apicaddr = 0xFEC00000;
674 MP_ioapic_info(&ioapic);
677 * We set up most of the low 16 IO-APIC pins according to MPS rules.
679 construct_default_ioirq_mptable(mpc_default_type);
682 static inline void construct_ioapic_table(int mpc_default_type) { }
685 static inline void __init construct_default_ISA_mptable(int mpc_default_type)
687 struct mpc_config_processor processor;
688 struct mpc_config_lintsrc lintsrc;
689 int linttypes[2] = { mp_ExtINT, mp_NMI };
693 * local APIC has default address
695 mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
698 * 2 CPUs, numbered 0 & 1.
700 processor.mpc_type = MP_PROCESSOR;
701 /* Either an integrated APIC or a discrete 82489DX. */
702 processor.mpc_apicver = mpc_default_type > 4 ? 0x10 : 0x01;
703 processor.mpc_cpuflag = CPU_ENABLED;
704 processor.mpc_cpufeature = (boot_cpu_data.x86 << 8) |
705 (boot_cpu_data.x86_model << 4) | boot_cpu_data.x86_mask;
706 processor.mpc_featureflag = boot_cpu_data.x86_capability[0];
707 processor.mpc_reserved[0] = 0;
708 processor.mpc_reserved[1] = 0;
709 for (i = 0; i < 2; i++) {
710 processor.mpc_apicid = i;
711 MP_processor_info(&processor);
714 construct_ioapic_table(mpc_default_type);
716 lintsrc.mpc_type = MP_LINTSRC;
717 lintsrc.mpc_irqflag = 0; /* conforming */
718 lintsrc.mpc_srcbusid = 0;
719 lintsrc.mpc_srcbusirq = 0;
720 lintsrc.mpc_destapic = MP_APIC_ALL;
721 for (i = 0; i < 2; i++) {
722 lintsrc.mpc_irqtype = linttypes[i];
723 lintsrc.mpc_destapiclint = i;
724 MP_lintsrc_info(&lintsrc);
728 static struct intel_mp_floating *mpf_found;
731 * Machine specific quirk for finding the SMP config before other setup
732 * activities destroy the table:
734 int (*mach_get_smp_config_quirk)(unsigned int early);
737 * Scan the memory blocks for an SMP configuration block.
739 static void __init __get_smp_config(unsigned int early)
741 struct intel_mp_floating *mpf = mpf_found;
743 if (mach_get_smp_config_quirk) {
744 if (mach_get_smp_config_quirk(early))
747 if (acpi_lapic && early)
750 * ACPI supports both logical (e.g. Hyper-Threading) and physical
751 * processors, where MPS only supports physical.
753 if (acpi_lapic && acpi_ioapic) {
754 printk(KERN_INFO "Using ACPI (MADT) for SMP configuration "
757 } else if (acpi_lapic)
758 printk(KERN_INFO "Using ACPI for processor (LAPIC) "
759 "configuration information\n");
761 printk(KERN_INFO "Intel MultiProcessor Specification v1.%d\n",
762 mpf->mpf_specification);
763 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86_32)
764 if (mpf->mpf_feature2 & (1 << 7)) {
765 printk(KERN_INFO " IMCR and PIC compatibility mode.\n");
768 printk(KERN_INFO " Virtual Wire compatibility mode.\n");
773 * Now see if we need to read further.
775 if (mpf->mpf_feature1 != 0) {
778 * local APIC has default address
780 mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
784 printk(KERN_INFO "Default MP configuration #%d\n",
786 construct_default_ISA_mptable(mpf->mpf_feature1);
788 } else if (mpf->mpf_physptr) {
791 * Read the physical hardware table. Anything here will
792 * override the defaults.
794 if (!smp_read_mpc(phys_to_virt(mpf->mpf_physptr), early)) {
795 #ifdef CONFIG_X86_LOCAL_APIC
796 smp_found_config = 0;
799 "BIOS bug, MP table errors detected!...\n");
800 printk(KERN_ERR "... disabling SMP support. "
801 "(tell your hw vendor)\n");
807 #ifdef CONFIG_X86_IO_APIC
809 * If there are no explicit MP IRQ entries, then we are
810 * broken. We set up most of the low 16 IO-APIC pins to
811 * ISA defaults and hope it will work.
813 if (!mp_irq_entries) {
814 struct mpc_config_bus bus;
816 printk(KERN_ERR "BIOS bug, no explicit IRQ entries, "
817 "using default mptable. "
818 "(tell your hw vendor)\n");
820 bus.mpc_type = MP_BUS;
822 memcpy(bus.mpc_bustype, "ISA ", 6);
825 construct_default_ioirq_mptable(0);
832 printk(KERN_INFO "Processors: %d\n", num_processors);
834 * Only use the first configuration found.
838 void __init early_get_smp_config(void)
843 void __init get_smp_config(void)
848 static int __init smp_scan_config(unsigned long base, unsigned long length,
851 unsigned int *bp = phys_to_virt(base);
852 struct intel_mp_floating *mpf;
854 printk(KERN_DEBUG "Scan SMP from %p for %ld bytes.\n", bp, length);
855 BUILD_BUG_ON(sizeof(*mpf) != 16);
858 mpf = (struct intel_mp_floating *)bp;
859 if ((*bp == SMP_MAGIC_IDENT) &&
860 (mpf->mpf_length == 1) &&
861 !mpf_checksum((unsigned char *)bp, 16) &&
862 ((mpf->mpf_specification == 1)
863 || (mpf->mpf_specification == 4))) {
864 #ifdef CONFIG_X86_LOCAL_APIC
865 smp_found_config = 1;
869 printk(KERN_INFO "found SMP MP-table at [%p] %08lx\n",
870 mpf, virt_to_phys(mpf));
874 reserve_bootmem_generic(virt_to_phys(mpf), PAGE_SIZE,
876 if (mpf->mpf_physptr) {
877 unsigned long size = PAGE_SIZE;
880 * We cannot access to MPC table to compute
881 * table size yet, as only few megabytes from
882 * the bottom is mapped now.
883 * PC-9800's MPC table places on the very last
884 * of physical memory; so that simply reserving
885 * PAGE_SIZE from mpg->mpf_physptr yields BUG()
886 * in reserve_bootmem.
888 unsigned long end = max_low_pfn * PAGE_SIZE;
889 if (mpf->mpf_physptr + size > end)
890 size = end - mpf->mpf_physptr;
892 reserve_bootmem_generic(mpf->mpf_physptr, size,
904 int (*mach_find_smp_config_quirk)(unsigned int reserve);
906 static void __init __find_smp_config(unsigned int reserve)
908 unsigned int address;
910 if (mach_find_smp_config_quirk) {
911 if (mach_find_smp_config_quirk(reserve))
915 * FIXME: Linux assumes you have 640K of base ram..
916 * this continues the error...
918 * 1) Scan the bottom 1K for a signature
919 * 2) Scan the top 1K of base RAM
920 * 3) Scan the 64K of bios
922 if (smp_scan_config(0x0, 0x400, reserve) ||
923 smp_scan_config(639 * 0x400, 0x400, reserve) ||
924 smp_scan_config(0xF0000, 0x10000, reserve))
927 * If it is an SMP machine we should know now, unless the
928 * configuration is in an EISA/MCA bus machine with an
929 * extended bios data area.
931 * there is a real-mode segmented pointer pointing to the
932 * 4K EBDA area at 0x40E, calculate and scan it here.
934 * NOTE! There are Linux loaders that will corrupt the EBDA
935 * area, and as such this kind of SMP config may be less
936 * trustworthy, simply because the SMP table may have been
937 * stomped on during early boot. These loaders are buggy and
940 * MP1.4 SPEC states to only scan first 1K of 4K EBDA.
943 address = get_bios_ebda();
945 smp_scan_config(address, 0x400, reserve);
948 void __init early_find_smp_config(void)
950 __find_smp_config(0);
953 void __init find_smp_config(void)
955 __find_smp_config(1);
958 #ifdef CONFIG_X86_IO_APIC
959 static u8 __initdata irq_used[MAX_IRQ_SOURCES];
961 static int __init get_MP_intsrc_index(struct mpc_config_intsrc *m)
965 if (m->mpc_irqtype != mp_INT)
968 if (m->mpc_irqflag != 0x0f)
973 for (i = 0; i < mp_irq_entries; i++) {
974 if (mp_irqs[i].mp_irqtype != mp_INT)
977 if (mp_irqs[i].mp_irqflag != 0x0f)
980 if (mp_irqs[i].mp_srcbus != m->mpc_srcbus)
982 if (mp_irqs[i].mp_srcbusirq != m->mpc_srcbusirq)
985 /* already claimed */
996 #define SPARE_SLOT_NUM 20
998 static struct mpc_config_intsrc __initdata *m_spare[SPARE_SLOT_NUM];
1001 static int __init replace_intsrc_all(struct mp_config_table *mpc,
1002 unsigned long mpc_new_phys,
1003 unsigned long mpc_new_length)
1005 #ifdef CONFIG_X86_IO_APIC
1010 int count = sizeof(*mpc);
1011 unsigned char *mpt = ((unsigned char *)mpc) + count;
1013 printk(KERN_INFO "mpc_length %x\n", mpc->mpc_length);
1014 while (count < mpc->mpc_length) {
1018 struct mpc_config_processor *m =
1019 (struct mpc_config_processor *)mpt;
1021 count += sizeof(*m);
1026 struct mpc_config_bus *m =
1027 (struct mpc_config_bus *)mpt;
1029 count += sizeof(*m);
1034 mpt += sizeof(struct mpc_config_ioapic);
1035 count += sizeof(struct mpc_config_ioapic);
1040 #ifdef CONFIG_X86_IO_APIC
1041 struct mpc_config_intsrc *m =
1042 (struct mpc_config_intsrc *)mpt;
1044 printk(KERN_INFO "OLD ");
1045 print_MP_intsrc_info(m);
1046 i = get_MP_intsrc_index(m);
1048 assign_to_mpc_intsrc(&mp_irqs[i], m);
1049 printk(KERN_INFO "NEW ");
1050 print_mp_irq_info(&mp_irqs[i]);
1052 /* legacy, do nothing */
1053 } else if (nr_m_spare < SPARE_SLOT_NUM) {
1055 * not found (-1), or duplicated (-2)
1056 * are invalid entries,
1057 * we need to use the slot later
1059 m_spare[nr_m_spare] = m;
1063 mpt += sizeof(struct mpc_config_intsrc);
1064 count += sizeof(struct mpc_config_intsrc);
1069 struct mpc_config_lintsrc *m =
1070 (struct mpc_config_lintsrc *)mpt;
1072 count += sizeof(*m);
1077 printk(KERN_ERR "Your mptable is wrong, contact your HW vendor!\n");
1078 printk(KERN_ERR "type %x\n", *mpt);
1079 print_hex_dump(KERN_ERR, " ", DUMP_PREFIX_ADDRESS, 16,
1080 1, mpc, mpc->mpc_length, 1);
1085 #ifdef CONFIG_X86_IO_APIC
1086 for (i = 0; i < mp_irq_entries; i++) {
1090 if (mp_irqs[i].mp_irqtype != mp_INT)
1093 if (mp_irqs[i].mp_irqflag != 0x0f)
1096 if (nr_m_spare > 0) {
1097 printk(KERN_INFO "*NEW* found ");
1099 assign_to_mpc_intsrc(&mp_irqs[i], m_spare[nr_m_spare]);
1100 m_spare[nr_m_spare] = NULL;
1102 struct mpc_config_intsrc *m =
1103 (struct mpc_config_intsrc *)mpt;
1104 count += sizeof(struct mpc_config_intsrc);
1105 if (!mpc_new_phys) {
1106 printk(KERN_INFO "No spare slots, try to append...take your risk, new mpc_length %x\n", count);
1108 if (count <= mpc_new_length)
1109 printk(KERN_INFO "No spare slots, try to append..., new mpc_length %x\n", count);
1111 printk(KERN_ERR "mpc_new_length %lx is too small\n", mpc_new_length);
1115 assign_to_mpc_intsrc(&mp_irqs[i], m);
1116 mpc->mpc_length = count;
1117 mpt += sizeof(struct mpc_config_intsrc);
1119 print_mp_irq_info(&mp_irqs[i]);
1123 /* update checksum */
1124 mpc->mpc_checksum = 0;
1125 mpc->mpc_checksum -= mpf_checksum((unsigned char *)mpc,
1131 static int __initdata enable_update_mptable;
1133 static int __init update_mptable_setup(char *str)
1135 enable_update_mptable = 1;
1138 early_param("update_mptable", update_mptable_setup);
1140 static unsigned long __initdata mpc_new_phys;
1141 static unsigned long mpc_new_length __initdata = 4096;
1143 /* alloc_mptable or alloc_mptable=4k */
1144 static int __initdata alloc_mptable;
1145 static int __init parse_alloc_mptable_opt(char *p)
1147 enable_update_mptable = 1;
1151 mpc_new_length = memparse(p, &p);
1154 early_param("alloc_mptable", parse_alloc_mptable_opt);
1156 void __init early_reserve_e820_mpc_new(void)
1158 if (enable_update_mptable && alloc_mptable) {
1160 #ifdef CONFIG_X86_TRAMPOLINE
1161 startt = TRAMPOLINE_BASE;
1163 mpc_new_phys = early_reserve_e820(startt, mpc_new_length, 4);
1167 static int __init update_mp_table(void)
1171 struct intel_mp_floating *mpf;
1172 struct mp_config_table *mpc;
1173 struct mp_config_table *mpc_new;
1175 if (!enable_update_mptable)
1183 * Now see if we need to go further.
1185 if (mpf->mpf_feature1 != 0)
1188 if (!mpf->mpf_physptr)
1191 mpc = phys_to_virt(mpf->mpf_physptr);
1193 if (!smp_check_mpc(mpc, oem, str))
1196 printk(KERN_INFO "mpf: %lx\n", virt_to_phys(mpf));
1197 printk(KERN_INFO "mpf_physptr: %x\n", mpf->mpf_physptr);
1199 if (mpc_new_phys && mpc->mpc_length > mpc_new_length) {
1201 printk(KERN_INFO "mpc_new_length is %ld, please use alloc_mptable=8k\n",
1205 if (!mpc_new_phys) {
1206 unsigned char old, new;
1207 /* check if we can change the postion */
1208 mpc->mpc_checksum = 0;
1209 old = mpf_checksum((unsigned char *)mpc, mpc->mpc_length);
1210 mpc->mpc_checksum = 0xff;
1211 new = mpf_checksum((unsigned char *)mpc, mpc->mpc_length);
1213 printk(KERN_INFO "mpc is readonly, please try alloc_mptable instead\n");
1216 printk(KERN_INFO "use in-positon replacing\n");
1218 mpf->mpf_physptr = mpc_new_phys;
1219 mpc_new = phys_to_virt(mpc_new_phys);
1220 memcpy(mpc_new, mpc, mpc->mpc_length);
1222 /* check if we can modify that */
1223 if (mpc_new_phys - mpf->mpf_physptr) {
1224 struct intel_mp_floating *mpf_new;
1225 /* steal 16 bytes from [0, 1k) */
1226 printk(KERN_INFO "mpf new: %x\n", 0x400 - 16);
1227 mpf_new = phys_to_virt(0x400 - 16);
1228 memcpy(mpf_new, mpf, 16);
1230 mpf->mpf_physptr = mpc_new_phys;
1232 mpf->mpf_checksum = 0;
1233 mpf->mpf_checksum -= mpf_checksum((unsigned char *)mpf, 16);
1234 printk(KERN_INFO "mpf_physptr new: %x\n", mpf->mpf_physptr);
1238 * only replace the one with mp_INT and
1239 * MP_IRQ_TRIGGER_LEVEL|MP_IRQ_POLARITY_LOW,
1240 * already in mp_irqs , stored by ... and mp_config_acpi_gsi,
1241 * may need pci=routeirq for all coverage
1243 replace_intsrc_all(mpc, mpc_new_phys, mpc_new_length);
1248 late_initcall(update_mp_table);