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