开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
mpparse.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：22k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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