[PATCH] MP1.4 SPEC compliance.
[opensuse:kernel.git] / arch / i386 / kernel / mpparse.c
1 /*
2  *      Intel Multiprocessor Specificiation 1.1 and 1.4
3  *      compliant MP-table parsing routines.
4  *
5  *      (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
6  *      (c) 1998, 1999, 2000 Ingo Molnar <mingo@redhat.com>
7  *
8  *      Fixes
9  *              Erich Boleyn    :       MP v1.4 and additional changes.
10  *              Alan Cox        :       Added EBDA scanning
11  *              Ingo Molnar     :       various cleanups and rewrites
12  *      Maciej W. Rozycki       :       Bits for default MP configurations
13  */
14
15 #include <linux/mm.h>
16 #include <linux/irq.h>
17 #include <linux/acpi.h>
18 #include <linux/init.h>
19 #include <linux/delay.h>
20 #include <linux/config.h>
21 #include <linux/bootmem.h>
22 #include <linux/smp_lock.h>
23 #include <linux/kernel_stat.h>
24 #include <linux/mc146818rtc.h>
25
26 #include <asm/smp.h>
27 #include <asm/mtrr.h>
28 #include <asm/mpspec.h>
29 #include <asm/pgalloc.h>
30
31 /* Have we found an MP table */
32 int smp_found_config;
33
34 /* Have we found an ACPI MADT table */
35 int acpi_found_madt = 0;
36
37 /*
38  * Various Linux-internal data structures created from the
39  * MP-table.
40  */
41 int apic_version [MAX_APICS];
42 int mp_bus_id_to_type [MAX_MP_BUSSES];
43 int mp_bus_id_to_node [MAX_MP_BUSSES];
44 int mp_bus_id_to_local [MAX_MP_BUSSES];
45 int quad_local_to_mp_bus_id [NR_CPUS/4][4];
46 int mp_bus_id_to_pci_bus [MAX_MP_BUSSES] = { [0 ... MAX_MP_BUSSES-1] = -1 };
47 int mp_current_pci_id;
48
49 /* I/O APIC entries */
50 struct mpc_config_ioapic mp_ioapics[MAX_IO_APICS];
51
52 /* # of MP IRQ source entries */
53 struct mpc_config_intsrc mp_irqs[MAX_IRQ_SOURCES];
54
55 /* MP IRQ source entries */
56 int mp_irq_entries;
57
58 int nr_ioapics;
59
60 int pic_mode;
61 unsigned long mp_lapic_addr;
62
63 /* Processor that is doing the boot up */
64 unsigned int boot_cpu_physical_apicid = -1U;
65 unsigned int boot_cpu_logical_apicid = -1U;
66 /* Internal processor count */
67 static unsigned int num_processors;
68
69 /* Bitmask of physically existing CPUs */
70 unsigned long phys_cpu_present_map;
71
72 /* ACPI MADT entry parsing functions */
73 #ifdef CONFIG_ACPI_BOOT
74 extern struct acpi_boot_flags acpi_boot;
75 #ifdef CONFIG_X86_LOCAL_APIC
76 extern int acpi_parse_lapic (acpi_table_entry_header *header);
77 extern int acpi_parse_lapic_addr_ovr (acpi_table_entry_header *header);
78 extern int acpi_parse_lapic_nmi (acpi_table_entry_header *header);
79 #endif /*CONFIG_X86_LOCAL_APIC*/
80 #ifdef CONFIG_X86_IO_APIC
81 extern int acpi_parse_ioapic (acpi_table_entry_header *header);
82 #endif /*CONFIG_X86_IO_APIC*/
83 #endif /*CONFIG_ACPI_BOOT*/
84
85 /*
86  * Intel MP BIOS table parsing routines:
87  */
88
89 #ifndef CONFIG_X86_VISWS_APIC
90 /*
91  * Checksum an MP configuration block.
92  */
93
94 static int __init mpf_checksum(unsigned char *mp, int len)
95 {
96         int sum = 0;
97
98         while (len--)
99                 sum += *mp++;
100
101         return sum & 0xFF;
102 }
103
104 /*
105  * Processor encoding in an MP configuration block
106  */
107
108 static char __init *mpc_family(int family,int model)
109 {
110         static char n[32];
111         static char *model_defs[]=
112         {
113                 "80486DX","80486DX",
114                 "80486SX","80486DX/2 or 80487",
115                 "80486SL","80486SX/2",
116                 "Unknown","80486DX/2-WB",
117                 "80486DX/4","80486DX/4-WB"
118         };
119
120         switch (family) {
121                 case 0x04:
122                         if (model < 10)
123                                 return model_defs[model];
124                         break;
125
126                 case 0x05:
127                         return("Pentium(tm)");
128
129                 case 0x06:
130                         return("Pentium(tm) Pro");
131
132                 case 0x0F:
133                         if (model == 0x00)
134                                 return("Pentium 4(tm)");
135                         if (model == 0x0F)
136                                 return("Special controller");
137         }
138         sprintf(n,"Unknown CPU [%d:%d]",family, model);
139         return n;
140 }
141
142 /*
143  * Have to match translation table entries to main table entries by counter
144  * hence the mpc_record variable .... can't see a less disgusting way of
145  * doing this ....
146  */
147
148 static int mpc_record; 
149 static struct mpc_config_translation *translation_table[MAX_MPC_ENTRY] __initdata;
150
151 void __init MP_processor_info (struct mpc_config_processor *m)
152 {
153         int ver, quad, logical_apicid;
154         
155         if (!(m->mpc_cpuflag & CPU_ENABLED))
156                 return;
157
158         logical_apicid = m->mpc_apicid;
159         if (clustered_apic_mode) {
160                 quad = translation_table[mpc_record]->trans_quad;
161                 logical_apicid = (quad << 4) + 
162                         (m->mpc_apicid ? m->mpc_apicid << 1 : 1);
163                 printk("Processor #%d %s APIC version %d (quad %d, apic %d)\n",
164                         m->mpc_apicid,
165                         mpc_family((m->mpc_cpufeature & CPU_FAMILY_MASK)>>8 ,
166                                    (m->mpc_cpufeature & CPU_MODEL_MASK)>>4),
167                         m->mpc_apicver, quad, logical_apicid);
168         } else {
169                 printk("Processor #%d %s APIC version %d\n",
170                         m->mpc_apicid,
171                         mpc_family((m->mpc_cpufeature & CPU_FAMILY_MASK)>>8 ,
172                                    (m->mpc_cpufeature & CPU_MODEL_MASK)>>4),
173                         m->mpc_apicver);
174         }
175
176         if (m->mpc_featureflag&(1<<0))
177                 Dprintk("    Floating point unit present.\n");
178         if (m->mpc_featureflag&(1<<7))
179                 Dprintk("    Machine Exception supported.\n");
180         if (m->mpc_featureflag&(1<<8))
181                 Dprintk("    64 bit compare & exchange supported.\n");
182         if (m->mpc_featureflag&(1<<9))
183                 Dprintk("    Internal APIC present.\n");
184         if (m->mpc_featureflag&(1<<11))
185                 Dprintk("    SEP present.\n");
186         if (m->mpc_featureflag&(1<<12))
187                 Dprintk("    MTRR  present.\n");
188         if (m->mpc_featureflag&(1<<13))
189                 Dprintk("    PGE  present.\n");
190         if (m->mpc_featureflag&(1<<14))
191                 Dprintk("    MCA  present.\n");
192         if (m->mpc_featureflag&(1<<15))
193                 Dprintk("    CMOV  present.\n");
194         if (m->mpc_featureflag&(1<<16))
195                 Dprintk("    PAT  present.\n");
196         if (m->mpc_featureflag&(1<<17))
197                 Dprintk("    PSE  present.\n");
198         if (m->mpc_featureflag&(1<<18))
199                 Dprintk("    PSN  present.\n");
200         if (m->mpc_featureflag&(1<<19))
201                 Dprintk("    Cache Line Flush Instruction present.\n");
202         /* 20 Reserved */
203         if (m->mpc_featureflag&(1<<21))
204                 Dprintk("    Debug Trace and EMON Store present.\n");
205         if (m->mpc_featureflag&(1<<22))
206                 Dprintk("    ACPI Thermal Throttle Registers  present.\n");
207         if (m->mpc_featureflag&(1<<23))
208                 Dprintk("    MMX  present.\n");
209         if (m->mpc_featureflag&(1<<24))
210                 Dprintk("    FXSR  present.\n");
211         if (m->mpc_featureflag&(1<<25))
212                 Dprintk("    XMM  present.\n");
213         if (m->mpc_featureflag&(1<<26))
214                 Dprintk("    Willamette New Instructions  present.\n");
215         if (m->mpc_featureflag&(1<<27))
216                 Dprintk("    Self Snoop  present.\n");
217         if (m->mpc_featureflag&(1<<28))
218                 Dprintk("    HT  present.\n");
219         if (m->mpc_featureflag&(1<<29))
220                 Dprintk("    Thermal Monitor present.\n");
221         /* 30, 31 Reserved */
222
223
224         if (m->mpc_cpuflag & CPU_BOOTPROCESSOR) {
225                 Dprintk("    Bootup CPU\n");
226                 boot_cpu_physical_apicid = m->mpc_apicid;
227                 boot_cpu_logical_apicid = logical_apicid;
228         }
229
230         num_processors++;
231
232         if (m->mpc_apicid > MAX_APICS) {
233                 printk("Processor #%d INVALID. (Max ID: %d).\n",
234                         m->mpc_apicid, MAX_APICS);
235                 --num_processors;
236                 return;
237         }
238         ver = m->mpc_apicver;
239
240         if (clustered_apic_mode) {
241                 phys_cpu_present_map |= (logical_apicid&0xf) << (4*quad);
242         } else {
243                 phys_cpu_present_map |= 1 << m->mpc_apicid;
244         }
245         /*
246          * Validate version
247          */
248         if (ver == 0x0) {
249                 printk("BIOS bug, APIC version is 0 for CPU#%d! fixing up to 0x10. (tell your hw vendor)\n", m->mpc_apicid);
250                 ver = 0x10;
251         }
252         apic_version[m->mpc_apicid] = ver;
253 }
254
255 static void __init MP_bus_info (struct mpc_config_bus *m)
256 {
257         char str[7];
258         int quad;
259
260         memcpy(str, m->mpc_bustype, 6);
261         str[6] = 0;
262         
263         if (clustered_apic_mode) {
264                 quad = translation_table[mpc_record]->trans_quad;
265                 mp_bus_id_to_node[m->mpc_busid] = quad;
266                 mp_bus_id_to_local[m->mpc_busid] = translation_table[mpc_record]->trans_local;
267                 quad_local_to_mp_bus_id[quad][translation_table[mpc_record]->trans_local] = m->mpc_busid;
268                 printk("Bus #%d is %s (node %d)\n", m->mpc_busid, str, quad);
269         } else {
270                 Dprintk("Bus #%d is %s\n", m->mpc_busid, str);
271         }
272
273         if (strncmp(str, BUSTYPE_ISA, sizeof(BUSTYPE_ISA)-1) == 0) {
274                 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_ISA;
275         } else if (strncmp(str, BUSTYPE_EISA, sizeof(BUSTYPE_EISA)-1) == 0) {
276                 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_EISA;
277         } else if (strncmp(str, BUSTYPE_PCI, sizeof(BUSTYPE_PCI)-1) == 0) {
278                 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_PCI;
279                 mp_bus_id_to_pci_bus[m->mpc_busid] = mp_current_pci_id;
280                 mp_current_pci_id++;
281         } else if (strncmp(str, BUSTYPE_MCA, sizeof(BUSTYPE_MCA)-1) == 0) {
282                 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_MCA;
283         } else {
284                 printk("Unknown bustype %s - ignoring\n", str);
285         }
286 }
287
288 static void __init MP_ioapic_info (struct mpc_config_ioapic *m)
289 {
290         if (!(m->mpc_flags & MPC_APIC_USABLE))
291                 return;
292
293         printk("I/O APIC #%d Version %d at 0x%lX.\n",
294                 m->mpc_apicid, m->mpc_apicver, m->mpc_apicaddr);
295         if (nr_ioapics >= MAX_IO_APICS) {
296                 printk("Max # of I/O APICs (%d) exceeded (found %d).\n",
297                         MAX_IO_APICS, nr_ioapics);
298                 panic("Recompile kernel with bigger MAX_IO_APICS!.\n");
299         }
300         if (!m->mpc_apicaddr) {
301                 printk(KERN_ERR "WARNING: bogus zero I/O APIC address"
302                         " found in MP table, skipping!\n");
303                 return;
304         }
305         mp_ioapics[nr_ioapics] = *m;
306         nr_ioapics++;
307 }
308
309 static void __init MP_intsrc_info (struct mpc_config_intsrc *m)
310 {
311         mp_irqs [mp_irq_entries] = *m;
312         Dprintk("Int: type %d, pol %d, trig %d, bus %d,"
313                 " IRQ %02x, APIC ID %x, APIC INT %02x\n",
314                         m->mpc_irqtype, m->mpc_irqflag & 3,
315                         (m->mpc_irqflag >> 2) & 3, m->mpc_srcbus,
316                         m->mpc_srcbusirq, m->mpc_dstapic, m->mpc_dstirq);
317         if (++mp_irq_entries == MAX_IRQ_SOURCES)
318                 panic("Max # of irq sources exceeded!!\n");
319 }
320
321 static void __init MP_lintsrc_info (struct mpc_config_lintsrc *m)
322 {
323         Dprintk("Lint: type %d, pol %d, trig %d, bus %d,"
324                 " IRQ %02x, APIC ID %x, APIC LINT %02x\n",
325                         m->mpc_irqtype, m->mpc_irqflag & 3,
326                         (m->mpc_irqflag >> 2) &3, m->mpc_srcbusid,
327                         m->mpc_srcbusirq, m->mpc_destapic, m->mpc_destapiclint);
328         /*
329          * Well it seems all SMP boards in existence
330          * use ExtINT/LVT1 == LINT0 and
331          * NMI/LVT2 == LINT1 - the following check
332          * will show us if this assumptions is false.
333          * Until then we do not have to add baggage.
334          */
335         if ((m->mpc_irqtype == mp_ExtINT) &&
336                 (m->mpc_destapiclint != 0))
337                         BUG();
338         if ((m->mpc_irqtype == mp_NMI) &&
339                 (m->mpc_destapiclint != 1))
340                         BUG();
341 }
342
343 static void __init MP_translation_info (struct mpc_config_translation *m)
344 {
345         printk("Translation: record %d, type %d, quad %d, global %d, local %d\n", mpc_record, m->trans_type, m->trans_quad, m->trans_global, m->trans_local);
346
347         if (mpc_record >= MAX_MPC_ENTRY) 
348                 printk("MAX_MPC_ENTRY exceeded!\n");
349         else
350                 translation_table[mpc_record] = m; /* stash this for later */
351         if (m->trans_quad+1 > numnodes)
352                 numnodes = m->trans_quad+1;
353 }
354
355 /*
356  * Read/parse the MPC oem tables
357  */
358
359 static void __init smp_read_mpc_oem(struct mp_config_oemtable *oemtable, \
360         unsigned short oemsize)
361 {
362         int count = sizeof (*oemtable); /* the header size */
363         unsigned char *oemptr = ((unsigned char *)oemtable)+count;
364         
365         printk("Found an OEM MPC table at %8p - parsing it ... \n", oemtable);
366         if (memcmp(oemtable->oem_signature,MPC_OEM_SIGNATURE,4))
367         {
368                 printk("SMP mpc oemtable: bad signature [%c%c%c%c]!\n",
369                         oemtable->oem_signature[0],
370                         oemtable->oem_signature[1],
371                         oemtable->oem_signature[2],
372                         oemtable->oem_signature[3]);
373                 return;
374         }
375         if (mpf_checksum((unsigned char *)oemtable,oemtable->oem_length))
376         {
377                 printk("SMP oem mptable: checksum error!\n");
378                 return;
379         }
380         while (count < oemtable->oem_length) {
381                 switch (*oemptr) {
382                         case MP_TRANSLATION:
383                         {
384                                 struct mpc_config_translation *m=
385                                         (struct mpc_config_translation *)oemptr;
386                                 MP_translation_info(m);
387                                 oemptr += sizeof(*m);
388                                 count += sizeof(*m);
389                                 ++mpc_record;
390                                 break;
391                         }
392                         default:
393                         {
394                                 printk("Unrecognised OEM table entry type! - %d\n", (int) *oemptr);
395                                 return;
396                         }
397                 }
398        }
399 }
400
401 /*
402  * Read/parse the MPC
403  */
404
405 static int __init smp_read_mpc(struct mp_config_table *mpc)
406 {
407         char str[16];
408         int count=sizeof(*mpc);
409         unsigned char *mpt=((unsigned char *)mpc)+count;
410
411         if (memcmp(mpc->mpc_signature,MPC_SIGNATURE,4)) {
412                 panic("SMP mptable: bad signature [%c%c%c%c]!\n",
413                         mpc->mpc_signature[0],
414                         mpc->mpc_signature[1],
415                         mpc->mpc_signature[2],
416                         mpc->mpc_signature[3]);
417                 return 0;
418         }
419         if (mpf_checksum((unsigned char *)mpc,mpc->mpc_length)) {
420                 panic("SMP mptable: checksum error!\n");
421                 return 0;
422         }
423         if (mpc->mpc_spec!=0x01 && mpc->mpc_spec!=0x04) {
424                 printk(KERN_ERR "SMP mptable: bad table version (%d)!!\n",
425                         mpc->mpc_spec);
426                 return 0;
427         }
428         if (!mpc->mpc_lapic) {
429                 printk(KERN_ERR "SMP mptable: null local APIC address!\n");
430                 return 0;
431         }
432         memcpy(str,mpc->mpc_oem,8);
433         str[8]=0;
434         printk("OEM ID: %s ",str);
435
436         memcpy(str,mpc->mpc_productid,12);
437         str[12]=0;
438         printk("Product ID: %s ",str);
439
440         printk("APIC at: 0x%lX\n",mpc->mpc_lapic);
441
442         /*
443          * Save the local APIC address, it might be non-default,
444          * but only if we're not using the ACPI tables
445          */
446         if (!acpi_found_madt)
447                 mp_lapic_addr = mpc->mpc_lapic;
448
449         if (clustered_apic_mode && mpc->mpc_oemptr) {
450                 /* We need to process the oem mpc tables to tell us which quad things are in ... */
451                 mpc_record = 0;
452                 smp_read_mpc_oem((struct mp_config_oemtable *) mpc->mpc_oemptr, mpc->mpc_oemsize);
453                 mpc_record = 0;
454         }
455
456         /*
457          *      Now process the configuration blocks.
458          */
459         while (count < mpc->mpc_length) {
460                 switch(*mpt) {
461                         case MP_PROCESSOR:
462                         {
463                                 struct mpc_config_processor *m=
464                                         (struct mpc_config_processor *)mpt;
465
466                                 /* ACPI may already have provided this one for us */
467                                 if (!acpi_found_madt)
468                                         MP_processor_info(m);
469                                 mpt += sizeof(*m);
470                                 count += sizeof(*m);
471                                 break;
472                         }
473                         case MP_BUS:
474                         {
475                                 struct mpc_config_bus *m=
476                                         (struct mpc_config_bus *)mpt;
477                                 MP_bus_info(m);
478                                 mpt += sizeof(*m);
479                                 count += sizeof(*m);
480                                 break;
481                         }
482                         case MP_IOAPIC:
483                         {
484                                 struct mpc_config_ioapic *m=
485                                         (struct mpc_config_ioapic *)mpt;
486                                 MP_ioapic_info(m);
487                                 mpt+=sizeof(*m);
488                                 count+=sizeof(*m);
489                                 break;
490                         }
491                         case MP_INTSRC:
492                         {
493                                 struct mpc_config_intsrc *m=
494                                         (struct mpc_config_intsrc *)mpt;
495
496                                 MP_intsrc_info(m);
497                                 mpt+=sizeof(*m);
498                                 count+=sizeof(*m);
499                                 break;
500                         }
501                         case MP_LINTSRC:
502                         {
503                                 struct mpc_config_lintsrc *m=
504                                         (struct mpc_config_lintsrc *)mpt;
505                                 MP_lintsrc_info(m);
506                                 mpt+=sizeof(*m);
507                                 count+=sizeof(*m);
508                                 break;
509                         }
510                         default:
511                         {
512                                 count = mpc->mpc_length;
513                                 break;
514                         }
515                 }
516                 ++mpc_record;
517         }
518         if (!num_processors)
519                 printk(KERN_ERR "SMP mptable: no processors registered!\n");
520         return num_processors;
521 }
522
523 static int __init ELCR_trigger(unsigned int irq)
524 {
525         unsigned int port;
526
527         port = 0x4d0 + (irq >> 3);
528         return (inb(port) >> (irq & 7)) & 1;
529 }
530
531 static void __init construct_default_ioirq_mptable(int mpc_default_type)
532 {
533         struct mpc_config_intsrc intsrc;
534         int i;
535         int ELCR_fallback = 0;
536
537         intsrc.mpc_type = MP_INTSRC;
538         intsrc.mpc_irqflag = 0;                 /* conforming */
539         intsrc.mpc_srcbus = 0;
540         intsrc.mpc_dstapic = mp_ioapics[0].mpc_apicid;
541
542         intsrc.mpc_irqtype = mp_INT;
543
544         /*
545          *  If true, we have an ISA/PCI system with no IRQ entries
546          *  in the MP table. To prevent the PCI interrupts from being set up
547          *  incorrectly, we try to use the ELCR. The sanity check to see if
548          *  there is good ELCR data is very simple - IRQ0, 1, 2 and 13 can
549          *  never be level sensitive, so we simply see if the ELCR agrees.
550          *  If it does, we assume it's valid.
551          */
552         if (mpc_default_type == 5) {
553                 printk("ISA/PCI bus type with no IRQ information... falling back to ELCR\n");
554
555                 if (ELCR_trigger(0) || ELCR_trigger(1) || ELCR_trigger(2) || ELCR_trigger(13))
556                         printk("ELCR contains invalid data... not using ELCR\n");
557                 else {
558                         printk("Using ELCR to identify PCI interrupts\n");
559                         ELCR_fallback = 1;
560                 }
561         }
562
563         for (i = 0; i < 16; i++) {
564                 switch (mpc_default_type) {
565                 case 2:
566                         if (i == 0 || i == 13)
567                                 continue;       /* IRQ0 & IRQ13 not connected */
568                         /* fall through */
569                 default:
570                         if (i == 2)
571                                 continue;       /* IRQ2 is never connected */
572                 }
573
574                 if (ELCR_fallback) {
575                         /*
576                          *  If the ELCR indicates a level-sensitive interrupt, we
577                          *  copy that information over to the MP table in the
578                          *  irqflag field (level sensitive, active high polarity).
579                          */
580                         if (ELCR_trigger(i))
581                                 intsrc.mpc_irqflag = 13;
582                         else
583                                 intsrc.mpc_irqflag = 0;
584                 }
585
586                 intsrc.mpc_srcbusirq = i;
587                 intsrc.mpc_dstirq = i ? i : 2;          /* IRQ0 to INTIN2 */
588                 MP_intsrc_info(&intsrc);
589         }
590
591         intsrc.mpc_irqtype = mp_ExtINT;
592         intsrc.mpc_srcbusirq = 0;
593         intsrc.mpc_dstirq = 0;                          /* 8259A to INTIN0 */
594         MP_intsrc_info(&intsrc);
595 }
596
597 static inline void __init construct_default_ISA_mptable(int mpc_default_type)
598 {
599         struct mpc_config_processor processor;
600         struct mpc_config_bus bus;
601         struct mpc_config_ioapic ioapic;
602         struct mpc_config_lintsrc lintsrc;
603         int linttypes[2] = { mp_ExtINT, mp_NMI };
604         int i;
605
606         /*
607          * local APIC has default address
608          */
609         mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
610
611         /*
612          * 2 CPUs, numbered 0 & 1.
613          */
614         processor.mpc_type = MP_PROCESSOR;
615         /* Either an integrated APIC or a discrete 82489DX. */
616         processor.mpc_apicver = mpc_default_type > 4 ? 0x10 : 0x01;
617         processor.mpc_cpuflag = CPU_ENABLED;
618         processor.mpc_cpufeature = (boot_cpu_data.x86 << 8) |
619                                    (boot_cpu_data.x86_model << 4) |
620                                    boot_cpu_data.x86_mask;
621         processor.mpc_featureflag = boot_cpu_data.x86_capability[0];
622         processor.mpc_reserved[0] = 0;
623         processor.mpc_reserved[1] = 0;
624         for (i = 0; i < 2; i++) {
625                 processor.mpc_apicid = i;
626                 MP_processor_info(&processor);
627         }
628
629         bus.mpc_type = MP_BUS;
630         bus.mpc_busid = 0;
631         switch (mpc_default_type) {
632                 default:
633                         printk("???\nUnknown standard configuration %d\n",
634                                 mpc_default_type);
635                         /* fall through */
636                 case 1:
637                 case 5:
638                         memcpy(bus.mpc_bustype, "ISA   ", 6);
639                         break;
640                 case 2:
641                 case 6:
642                 case 3:
643                         memcpy(bus.mpc_bustype, "EISA  ", 6);
644                         break;
645                 case 4:
646                 case 7:
647                         memcpy(bus.mpc_bustype, "MCA   ", 6);
648         }
649         MP_bus_info(&bus);
650         if (mpc_default_type > 4) {
651                 bus.mpc_busid = 1;
652                 memcpy(bus.mpc_bustype, "PCI   ", 6);
653                 MP_bus_info(&bus);
654         }
655
656         ioapic.mpc_type = MP_IOAPIC;
657         ioapic.mpc_apicid = 2;
658         ioapic.mpc_apicver = mpc_default_type > 4 ? 0x10 : 0x01;
659         ioapic.mpc_flags = MPC_APIC_USABLE;
660         ioapic.mpc_apicaddr = 0xFEC00000;
661         MP_ioapic_info(&ioapic);
662
663         /*
664          * We set up most of the low 16 IO-APIC pins according to MPS rules.
665          */
666         construct_default_ioirq_mptable(mpc_default_type);
667
668         lintsrc.mpc_type = MP_LINTSRC;
669         lintsrc.mpc_irqflag = 0;                /* conforming */
670         lintsrc.mpc_srcbusid = 0;
671         lintsrc.mpc_srcbusirq = 0;
672         lintsrc.mpc_destapic = MP_APIC_ALL;
673         for (i = 0; i < 2; i++) {
674                 lintsrc.mpc_irqtype = linttypes[i];
675                 lintsrc.mpc_destapiclint = i;
676                 MP_lintsrc_info(&lintsrc);
677         }
678 }
679
680 static struct intel_mp_floating *mpf_found;
681
682 /*
683  * Scan the memory blocks for an SMP configuration block.
684  */
685 void __init get_smp_config (void)
686 {
687         struct intel_mp_floating *mpf = mpf_found;
688
689 #ifdef CONFIG_ACPI_BOOT
690         /*
691          * Check if the MADT exists, and if so, use it to get processor
692          * information (ACPI_MADT_LAPIC).  The MADT supports the concept
693          * of both logical (e.g. HT) and physical processor(s); where the
694          * MPS only supports physical.
695          */
696         if (acpi_boot.madt) {
697                 acpi_found_madt = acpi_table_parse(ACPI_APIC, acpi_parse_madt);
698                 if (acpi_found_madt > 0)
699                         acpi_table_parse_madt(ACPI_MADT_LAPIC, acpi_parse_lapic);
700         }
701 #endif /*CONFIG_ACPI_BOOT*/
702         
703         printk("Intel MultiProcessor Specification v1.%d\n", mpf->mpf_specification);
704         if (mpf->mpf_feature2 & (1<<7)) {
705                 printk("    IMCR and PIC compatibility mode.\n");
706                 pic_mode = 1;
707         } else {
708                 printk("    Virtual Wire compatibility mode.\n");
709                 pic_mode = 0;
710         }
711
712         /*
713          * Now see if we need to read further.
714          */
715         if (mpf->mpf_feature1 != 0) {
716
717                 printk("Default MP configuration #%d\n", mpf->mpf_feature1);
718                 construct_default_ISA_mptable(mpf->mpf_feature1);
719
720         } else if (mpf->mpf_physptr) {
721
722                 /*
723                  * Read the physical hardware table.  Anything here will
724                  * override the defaults.
725                  */
726                 if (!smp_read_mpc((void *)mpf->mpf_physptr)) {
727                         smp_found_config = 0;
728                         printk(KERN_ERR "BIOS bug, MP table errors detected!...\n");
729                         printk(KERN_ERR "... disabling SMP support. (tell your hw vendor)\n");
730                         return;
731                 }
732                 /*
733                  * If there are no explicit MP IRQ entries, then we are
734                  * broken.  We set up most of the low 16 IO-APIC pins to
735                  * ISA defaults and hope it will work.
736                  */
737                 if (!mp_irq_entries) {
738                         struct mpc_config_bus bus;
739
740                         printk("BIOS bug, no explicit IRQ entries, using default mptable. (tell your hw vendor)\n");
741
742                         bus.mpc_type = MP_BUS;
743                         bus.mpc_busid = 0;
744                         memcpy(bus.mpc_bustype, "ISA   ", 6);
745                         MP_bus_info(&bus);
746
747                         construct_default_ioirq_mptable(0);
748                 }
749
750         } else
751                 BUG();
752
753         printk("Processors: %d\n", num_processors);
754         /*
755          * Only use the first configuration found.
756          */
757 }
758
759 static int __init smp_scan_config (unsigned long base, unsigned long length)
760 {
761         unsigned long *bp = phys_to_virt(base);
762         struct intel_mp_floating *mpf;
763
764         Dprintk("Scan SMP from %p for %ld bytes.\n", bp,length);
765         if (sizeof(*mpf) != 16)
766                 printk("Error: MPF size\n");
767
768         while (length > 0) {
769                 mpf = (struct intel_mp_floating *)bp;
770                 if ((*bp == SMP_MAGIC_IDENT) &&
771                         (mpf->mpf_length == 1) &&
772                         !mpf_checksum((unsigned char *)bp, 16) &&
773                         ((mpf->mpf_specification == 1)
774                                 || (mpf->mpf_specification == 4)) ) {
775
776                         smp_found_config = 1;
777                         printk("found SMP MP-table at %08lx\n",
778                                                 virt_to_phys(mpf));
779                         reserve_bootmem(virt_to_phys(mpf), PAGE_SIZE);
780                         if (mpf->mpf_physptr)
781                                 reserve_bootmem(mpf->mpf_physptr, PAGE_SIZE);
782                         mpf_found = mpf;
783                         return 1;
784                 }
785                 bp += 4;
786                 length -= 16;
787         }
788         return 0;
789 }
790
791 void __init find_intel_smp (void)
792 {
793         unsigned int address;
794
795         /*
796          * FIXME: Linux assumes you have 640K of base ram..
797          * this continues the error...
798          *
799          * 1) Scan the bottom 1K for a signature
800          * 2) Scan the top 1K of base RAM
801          * 3) Scan the 64K of bios
802          */
803         if (smp_scan_config(0x0,0x400) ||
804                 smp_scan_config(639*0x400,0x400) ||
805                         smp_scan_config(0xF0000,0x10000))
806                 return;
807         /*
808          * If it is an SMP machine we should know now, unless the
809          * configuration is in an EISA/MCA bus machine with an
810          * extended bios data area.
811          *
812          * there is a real-mode segmented pointer pointing to the
813          * 4K EBDA area at 0x40E, calculate and scan it here.
814          *
815          * NOTE! There are Linux loaders that will corrupt the EBDA
816          * area, and as such this kind of SMP config may be less
817          * trustworthy, simply because the SMP table may have been
818          * stomped on during early boot. These loaders are buggy and
819          * should be fixed.
820          *
821          * MP1.4 SPEC states to only scan first 1K of 4K EBDA.
822          */
823
824         address = *(unsigned short *)phys_to_virt(0x40E);
825         address <<= 4;
826         smp_scan_config(address, 0x400);
827         if (smp_found_config)
828                 printk(KERN_WARNING "WARNING: MP table in the EBDA can be UNSAFE, contact linux-smp@vger.kernel.org if you experience SMP problems!\n");
829 }
830
831 #else
832
833 /*
834  * The Visual Workstation is Intel MP compliant in the hardware
835  * sense, but it doesnt have a BIOS(-configuration table).
836  * No problem for Linux.
837  */
838 void __init find_visws_smp(void)
839 {
840         smp_found_config = 1;
841
842         phys_cpu_present_map |= 2; /* or in id 1 */
843         apic_version[1] |= 0x10; /* integrated APIC */
844         apic_version[0] |= 0x10;
845
846         mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
847 }
848
849 #endif
850
851 /*
852  * - Intel MP Configuration Table
853  * - or SGI Visual Workstation configuration
854  */
855 void __init find_smp_config (void)
856 {
857 #ifdef CONFIG_X86_LOCAL_APIC
858         find_intel_smp();
859 #endif
860 #ifdef CONFIG_VISWS
861         find_visws_smp();
862 #endif
863 }
864