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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
mpparse.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：21k
源码类别：

嵌入式Linux

开发平台：

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