2011-07-14 Jennifer Averett <Jennifer.Averett@OARcorp.com>

	* shared/irq/apic.h, shared/smp/README, shared/smp/smp-imps.c,
	shared/smp/smp-imps.h: New files.

1 files changed, 649 insertions, 0 deletions

diff --git a/c/src/lib/libbsp/i386/shared/smp/smp-imps.c b/c/src/lib/libbsp/i386/shared/smp/smp-imps.c
new file mode 100644
index 0000000000..6b0e2a47ce
--- /dev/null
+++ b/c/src/lib/libbsp/i386/shared/smp/smp-imps.c
@@ -0,0 +1,649 @@
+/*
+ *  <Insert copyright here : it must be BSD-like so anyone can use it>
+ *
+ *  Author:  Erich Boleyn  <erich@uruk.org>   http://www.uruk.org/~erich/
+ *
+ *  Source file implementing Intel MultiProcessor Specification (MPS)
+ *  version 1.1 and 1.4 SMP hardware control for Intel Architecture CPUs,
+ *  with hooks for running correctly on a standard PC without the hardware.
+ *
+ *  This file was created from information in the Intel MPS version 1.4
+ *  document, order number 242016-004, which can be ordered from the
+ *  Intel literature center.
+ *
+ *  General limitations of this code:
+ *
+ *   (1) : This code has never been tested on an MPS-compatible system with
+ *           486 CPUs, but is expected to work.
+ *   (2) : Presumes "int", "long", and "unsigned" are 32 bits in size, and
+ *	     that 32-bit pointers and memory addressing is used uniformly.
+ */
+
+#define _SMP_IMPS_C
+
+
+/*
+ *  XXXXX  The following absolutely must be defined!!!
+ *
+ *  The "KERNEL_PRINT" could be made a null macro with no danger, of
+ *  course, but pretty much nothing would work without the other
+ *  ones defined.
+ */
+
+#if 0
+#define KERNEL_PRINT(x)		/* some kind of print function */
+#define CMOS_WRITE_BYTE(x,y)	/* write unsigned char "y" at CMOS loc "x" */
+#define CMOS_READ_BYTE(x)	/* read unsigned char at CMOS loc "x" */
+#define PHYS_TO_VIRTUAL(x)	/* convert physical address "x" to virtual */
+#define VIRTUAL_TO_PHYS(x)	/* convert virtual address "x" to physical */
+#define UDELAY(x)		/* delay roughly at least "x" microsecs */
+#define TEST_BOOTED(x)		/* test bootaddr x to see if CPU started */
+#define READ_MSR_LO(x)		/* Read MSR low function */
+#endif
+
+
+/*
+ *  Includes here
+ */
+
+#define IMPS_DEBUG
+
+#include "apic.h"
+#include "smp-imps.h"
+
+
+/*
+ *  Defines that are here so as not to be in the global header file.
+ */
+#define EBDA_SEG_ADDR			0x40E
+#define BIOS_RESET_VECTOR		0x467
+#define LAPIC_ADDR_DEFAULT		0xFEE00000uL
+#define IOAPIC_ADDR_DEFAULT		0xFEC00000uL
+#define CMOS_RESET_CODE			0xF
+#define		CMOS_RESET_JUMP		0xa
+#define CMOS_BASE_MEMORY		0x15
+
+
+/*
+ *  Static defines here for SMP use.
+ */
+
+#define DEF_ENTRIES	23
+
+static int lapic_dummy = 0;
+static struct {
+	imps_processor proc[2];
+	imps_bus bus[2];
+	imps_ioapic ioapic;
+	imps_interrupt intin[16];
+	imps_interrupt lintin[2];
+} defconfig = {
+	{ { IMPS_BCT_PROCESSOR, 0, 0, 0, 0, 0},
+	  { IMPS_BCT_PROCESSOR, 1, 0, 0, 0, 0} },
+	{ { IMPS_BCT_BUS, 0, {'E', 'I', 'S', 'A', ' ', ' '}},
+	  { 255, 1, {'P', 'C', 'I', ' ', ' ', ' '}} },
+	{ IMPS_BCT_IOAPIC, 0, 0, IMPS_FLAG_ENABLED, IOAPIC_ADDR_DEFAULT },
+	{ { IMPS_BCT_IO_INTERRUPT, IMPS_INT_EXTINT, 0, 0, 0, 0xFF, 0},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 1, 0xFF, 1},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 0, 0xFF, 2},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 3, 0xFF, 3},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 4, 0xFF, 4},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 5, 0xFF, 5},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 6, 0xFF, 6},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 7, 0xFF, 7},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 8, 0xFF, 8},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 9, 0xFF, 9},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 10, 0xFF, 10},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 11, 0xFF, 11},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 12, 0xFF, 12},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 13, 0xFF, 13},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 14, 0xFF, 14},
+	  { IMPS_BCT_IO_INTERRUPT, IMPS_INT_INT, 0, 0, 15, 0xFF, 15} },
+	{ { IMPS_BCT_LOCAL_INTERRUPT, IMPS_INT_EXTINT, 0, 0, 15, 0xFF, 0},
+	  { IMPS_BCT_LOCAL_INTERRUPT, IMPS_INT_NMI, 0, 0, 15, 0xFF, 1} }
+};
+
+/*
+ *  Exported globals here.
+ */
+
+volatile int imps_release_cpus = 0;
+int imps_enabled = 0;
+int imps_num_cpus = 1;
+unsigned imps_lapic_addr = ((unsigned)(&lapic_dummy)) - LAPIC_ID;
+unsigned char imps_cpu_apic_map[IMPS_MAX_CPUS];
+unsigned char imps_apic_cpu_map[IMPS_MAX_CPUS];
+
+
+/*
+ *  MPS checksum function
+ *
+ *  Function finished.
+ */
+
+static int
+get_checksum(unsigned start, int length)
+{
+	unsigned sum = 0;
+
+	while (length-- > 0) {
+		sum += *((unsigned char *) (start++));
+	}
+
+	return (sum&0xFF);
+}
+
+
+/*
+ *  APIC ICR write and status check function.
+ */
+
+static int
+send_ipi(unsigned int dst, unsigned int v)
+{
+	int to, send_status;
+
+	IMPS_LAPIC_WRITE(LAPIC_ICR+0x10, (dst << 24));
+	IMPS_LAPIC_WRITE(LAPIC_ICR, v);
+
+	/* Wait for send to finish */
+	to = 0;
+	do {
+		UDELAY(100);
+		send_status = IMPS_LAPIC_READ(LAPIC_ICR) & LAPIC_ICR_STATUS_PEND;
+	} while (send_status && (to++ < 1000));
+
+	return (to < 1000);
+}
+
+
+/*
+ *  Primary function for booting individual CPUs.
+ *
+ *  This must be modified to perform whatever OS-specific initialization
+ *  that is required.
+ */
+
+static int
+boot_cpu(imps_processor *proc)
+{
+	int apicid = proc->apic_id, success = 1, to;
+	unsigned bootaddr, accept_status;
+	unsigned bios_reset_vector = PHYS_TO_VIRTUAL(BIOS_RESET_VECTOR);
+
+	/*
+	 * Copy boot code for secondary CPUs here.  Find it in between
+	 * "patch_code_start" and "patch_code_end" symbols.  The other CPUs
+	 * will start there in 16-bit real mode under the 1MB boundary.
+	 * "patch_code_start" should be placed at a 4K-aligned address
+	 * under the 1MB boundary.
+	 */
+
+	extern char patch_code_start[];
+	extern char patch_code_end[];
+	bootaddr = (512-64)*1024;
+	memcpy((char *)bootaddr, patch_code_start, patch_code_end - patch_code_start);
+
+	/*
+	 *  Generic CPU startup sequence starts here.
+	 */
+
+	/* set BIOS reset vector */
+	CMOS_WRITE_BYTE(CMOS_RESET_CODE, CMOS_RESET_JUMP);
+	*((volatile unsigned *) bios_reset_vector) = ((bootaddr & 0xFF000) << 12);
+
+	/* clear the APIC error register */
+	IMPS_LAPIC_WRITE(LAPIC_ESR, 0);
+	accept_status = IMPS_LAPIC_READ(LAPIC_ESR);
+
+	/* assert INIT IPI */
+	send_ipi(apicid, LAPIC_ICR_TM_LEVEL | LAPIC_ICR_LEVELASSERT | LAPIC_ICR_DM_INIT);
+
+	UDELAY(10000);
+
+	/* de-assert INIT IPI */
+	send_ipi(apicid, LAPIC_ICR_TM_LEVEL | LAPIC_ICR_DM_INIT);
+
+	UDELAY(10000);
+
+	/*
+	 *  Send Startup IPIs if not an old pre-integrated APIC.
+	 */
+
+	if (proc->apic_ver >= APIC_VER_NEW) {
+		int i;
+		for (i = 1; i <= 2; i++) {
+			send_ipi(apicid, LAPIC_ICR_DM_SIPI | ((bootaddr >> 12) & 0xFF));
+			UDELAY(1000);
+		}
+	}
+
+	/*
+	 *  Check to see if other processor has started.
+	 */
+	to = 0;
+	while (!TEST_BOOTED(bootaddr) && to++ < 100)
+		UDELAY(10000);
+	if (to >= 100) {
+		KERNEL_PRINT(("CPU Not Responding, DISABLED"));
+		success = 0;
+	} else {
+		KERNEL_PRINT(("#%d  Application Processor (AP)", imps_num_cpus));
+	}
+
+	/*
+	 *  Generic CPU startup sequence ends here, the rest is cleanup.
+	 */
+
+	/* clear the APIC error register */
+	IMPS_LAPIC_WRITE(LAPIC_ESR, 0);
+	accept_status = IMPS_LAPIC_READ(LAPIC_ESR);
+
+	/* clean up BIOS reset vector */
+	CMOS_WRITE_BYTE(CMOS_RESET_CODE, 0);
+	*((volatile unsigned *) bios_reset_vector) = 0;
+
+	KERNEL_PRINT(("\n"));
+
+	return success;
+}
+
+
+/*
+ *  read bios stuff and fill tables
+ */
+
+static void
+add_processor(imps_processor *proc)
+{
+	int apicid = proc->apic_id;
+
+	KERNEL_PRINT(("  Processor [APIC id %d ver %d]:  ",
+		      apicid, proc->apic_ver));
+	if (!(proc->flags & IMPS_FLAG_ENABLED)) {
+		KERNEL_PRINT(("DISABLED\n"));
+		return;
+	}
+	if (proc->flags & (IMPS_CPUFLAG_BOOT)) {
+		KERNEL_PRINT(("#0  BootStrap Processor (BSP)\n"));
+		return;
+	}
+	if (boot_cpu(proc)) {
+
+		/*  XXXXX  add OS-specific setup for secondary CPUs here */
+
+		imps_cpu_apic_map[imps_num_cpus] = apicid;
+		imps_apic_cpu_map[apicid] = imps_num_cpus;
+		imps_num_cpus++;
+	}
+}
+
+
+static void
+add_bus(imps_bus *bus)
+{
+	char str[8];
+
+	memcpy(str, bus->bus_type, 6);
+	str[6] = 0;
+	KERNEL_PRINT(("  Bus id %d is %s\n", bus->id, str));
+
+	/*  XXXXX  add OS-specific code here */
+}
+
+static void
+add_ioapic(imps_ioapic *ioapic)
+{
+	KERNEL_PRINT(("  I/O APIC id %d ver %d, address: 0x%x  ",
+		      ioapic->id, ioapic->ver, ioapic->addr));
+	if (!(ioapic->flags & IMPS_FLAG_ENABLED)) {
+		KERNEL_PRINT(("DISABLED\n"));
+		return;
+	}
+	KERNEL_PRINT(("\n"));
+
+	/*  XXXXX  add OS-specific code here */
+}
+
+
+static void
+imps_read_config_table(unsigned start, int count)
+{
+	while (count-- > 0) {
+		switch (*((unsigned char *)start)) {
+		case IMPS_BCT_PROCESSOR:
+			add_processor((imps_processor *)start);
+			start += 12;	/* 20 total */
+			break;
+		case IMPS_BCT_BUS:
+			add_bus((imps_bus *)start);
+			break;
+		case IMPS_BCT_IOAPIC:
+			add_ioapic((imps_ioapic *)start);
+			break;
+#if 0	/*  XXXXX  uncomment this if "add_io_interrupt" is implemented */
+		case IMPS_BCT_IO_INTERRUPT:
+			add_io_interrupt((imps_interrupt *)start);
+			break;
+#endif
+#if 0	/*  XXXXX  uncomment this if "add_local_interrupt" is implemented */
+		case IMPS_BCT_LOCAL_INTERRUPT:
+			add_local_interupt((imps_interrupt *)start);
+			break;
+#endif
+		default:
+			break;
+		}
+		start += 8;
+	}
+}
+
+
+static int
+imps_bad_bios(imps_fps *fps_ptr)
+{
+	int sum;
+	imps_cth *local_cth_ptr
+		= (imps_cth *) PHYS_TO_VIRTUAL(fps_ptr->cth_ptr);
+
+	if (fps_ptr->feature_info[0] > IMPS_FPS_DEFAULT_MAX) {
+		KERNEL_PRINT(("    Invalid MP System Configuration type %d\n",
+			      fps_ptr->feature_info[0]));
+		return 1;
+	}
+
+	if (fps_ptr->cth_ptr) {
+		sum = get_checksum((unsigned)local_cth_ptr,
+                                   local_cth_ptr->base_length);
+		if (local_cth_ptr->sig != IMPS_CTH_SIGNATURE || sum) {
+			KERNEL_PRINT(("    Bad MP Config Table sig 0x%x and/or checksum 0x%x\n", (unsigned)(fps_ptr->cth_ptr), sum));
+			return 1;
+		}
+		if (local_cth_ptr->spec_rev != fps_ptr->spec_rev) {
+			KERNEL_PRINT(("    Bad MP Config Table sub-revision # %d\n", local_cth_ptr->spec_rev));
+			return 1;
+		}
+		if (local_cth_ptr->extended_length) {
+			sum = (get_checksum(((unsigned)local_cth_ptr)
+					    + local_cth_ptr->base_length,
+					    local_cth_ptr->extended_length)
+			       + local_cth_ptr->extended_checksum) & 0xFF;
+			if (sum) {
+				KERNEL_PRINT(("    Bad Extended MP Config Table checksum 0x%x\n", sum));
+				return 1;
+			}
+		}
+	} else if (!fps_ptr->feature_info[0]) {
+		KERNEL_PRINT(("    Missing configuration information\n"));
+		return 1;
+	}
+
+	return 0;
+}
+
+
+static void
+imps_read_bios(imps_fps *fps_ptr)
+{
+	int apicid;
+	unsigned cth_start, cth_count;
+	imps_cth *local_cth_ptr
+		= (imps_cth *)PHYS_TO_VIRTUAL(fps_ptr->cth_ptr);
+	char *str_ptr;
+
+	KERNEL_PRINT(("Intel MultiProcessor Spec 1.%d BIOS support detected\n",
+		      fps_ptr->spec_rev));
+
+	/*
+	 *  Do all checking of errors which would definitely
+	 *  lead to failure of the SMP boot here.
+	 */
+
+	if (imps_bad_bios(fps_ptr)) {
+		KERNEL_PRINT(("    Disabling MPS support\n"));
+		return;
+	}
+
+	if (fps_ptr->feature_info[1] & IMPS_FPS_IMCRP_BIT) {
+		str_ptr = "IMCR and PIC";
+	} else {
+		str_ptr = "Virtual Wire";
+	}
+	if (fps_ptr->cth_ptr) {
+		imps_lapic_addr = local_cth_ptr->lapic_addr;
+	} else {
+		imps_lapic_addr = LAPIC_ADDR_DEFAULT;
+	}
+	KERNEL_PRINT(("    APIC config: \"%s mode\"    Local APIC address: 0x%x\n",
+		      str_ptr, imps_lapic_addr));
+	if (imps_lapic_addr != (READ_MSR_LO(0x1b) & 0xFFFFF000)) {
+		KERNEL_PRINT(("Inconsistent Local APIC address, Disabling SMP support\n"));
+		return;
+	}
+	imps_lapic_addr = PHYS_TO_VIRTUAL(imps_lapic_addr);
+
+	/*
+	 *  Setup primary CPU.
+	 */
+	apicid = IMPS_LAPIC_READ(LAPIC_SPIV);
+	IMPS_LAPIC_WRITE(LAPIC_SPIV, apicid|LAPIC_SPIV_ENABLE_APIC);
+	apicid = APIC_ID(IMPS_LAPIC_READ(LAPIC_ID));
+	imps_cpu_apic_map[0] = apicid;
+	imps_apic_cpu_map[apicid] = 0;
+
+	if (fps_ptr->cth_ptr) {
+		char str1[16], str2[16];
+		memcpy(str1, local_cth_ptr->oem_id, 8);
+		str1[8] = 0;
+		memcpy(str2, local_cth_ptr->prod_id, 12);
+		str2[12] = 0;
+		KERNEL_PRINT(("  OEM id: %s  Product id: %s\n", str1, str2));
+		cth_start = ((unsigned) local_cth_ptr) + sizeof(imps_cth);
+		cth_count = local_cth_ptr->entry_count;
+	} else {
+		*((volatile unsigned *) IOAPIC_ADDR_DEFAULT) =  IOAPIC_ID;
+		defconfig.ioapic.id
+			= APIC_ID(*((volatile unsigned *)
+				    (IOAPIC_ADDR_DEFAULT+IOAPIC_RW)));
+		*((volatile unsigned *) IOAPIC_ADDR_DEFAULT) =  IOAPIC_VER;
+		defconfig.ioapic.ver
+			= APIC_VERSION(*((volatile unsigned *)
+					 (IOAPIC_ADDR_DEFAULT+IOAPIC_RW)));
+		defconfig.proc[apicid].flags
+		  = IMPS_FLAG_ENABLED|IMPS_CPUFLAG_BOOT;
+		defconfig.proc[!apicid].flags = IMPS_FLAG_ENABLED;
+		imps_num_cpus = 2;
+		if (fps_ptr->feature_info[0] == 1
+		 || fps_ptr->feature_info[0] == 5) {
+			memcpy(defconfig.bus[0].bus_type, "ISA   ", 6);
+		}
+		if (fps_ptr->feature_info[0] == 4
+		 || fps_ptr->feature_info[0] == 7) {
+			memcpy(defconfig.bus[0].bus_type, "MCA   ", 6);
+		}
+		if (fps_ptr->feature_info[0] > 4) {
+			defconfig.proc[0].apic_ver = 0x10;
+			defconfig.proc[1].apic_ver = 0x10;
+			defconfig.bus[1].type = IMPS_BCT_BUS;
+		}
+		if (fps_ptr->feature_info[0] == 2) {
+			defconfig.intin[2].type = 255;
+			defconfig.intin[13].type = 255;
+		}
+		if (fps_ptr->feature_info[0] == 7) {
+			defconfig.intin[0].type = 255;
+		}
+		cth_start = (unsigned) &defconfig;
+		cth_count = DEF_ENTRIES;
+	}
+	imps_read_config_table(cth_start, cth_count);
+
+	/* %%%%% ESB read extended entries here */
+
+	imps_enabled = 1;
+}
+
+
+/*
+ *  Given a region to check, this actually looks for the "MP Floating
+ *  Pointer Structure".  The return value indicates if the correct
+ *  signature and checksum for a floating pointer structure of the
+ *  appropriate spec revision was found.  If so, then do not search
+ *  further.
+ *
+ *  NOTE:  The memory scan will always be in the bottom 1 MB.
+ *
+ *  This function presumes that "start" will always be aligned to a 16-bit
+ *  boundary.
+ *
+ *  Function finished.
+ */
+
+static int
+imps_scan(unsigned start, unsigned length)
+{
+	IMPS_DEBUG_PRINT(("Scanning from 0x%x for %d bytes\n",
+			  start, length));
+
+	while (length > 0) {
+		imps_fps *fps_ptr = (imps_fps *) PHYS_TO_VIRTUAL(start);
+
+		if (fps_ptr->sig == IMPS_FPS_SIGNATURE
+		 && fps_ptr->length == 1
+		 && (fps_ptr->spec_rev == 1 || fps_ptr->spec_rev == 4)
+		 && !get_checksum(start, 16)) {
+			IMPS_DEBUG_PRINT(("Found MP Floating Structure Pointer at %x\n", start));
+			imps_read_bios(fps_ptr);
+			return 1;
+		}
+
+		length -= 16;
+		start += 16;
+	}
+
+	return 0;
+}
+
+/*
+ *  This is the primary function to "force" SMP support, with
+ *  the assumption that you have consecutively numbered APIC ids.
+ */
+int
+imps_force(int ncpus)
+{
+	int apicid, i;
+	imps_processor p;
+
+	KERNEL_PRINT(("Intel MultiProcessor \"Force\" Support\n"));
+
+	imps_lapic_addr = (READ_MSR_LO(0x1b) & 0xFFFFF000);
+	imps_lapic_addr = PHYS_TO_VIRTUAL(imps_lapic_addr);
+
+	/*
+	 *  Setup primary CPU.
+	 */
+	apicid = IMPS_LAPIC_READ(LAPIC_SPIV);
+	IMPS_LAPIC_WRITE(LAPIC_SPIV, apicid|LAPIC_SPIV_ENABLE_APIC);
+	apicid = APIC_ID(IMPS_LAPIC_READ(LAPIC_ID));
+	imps_cpu_apic_map[0] = apicid;
+	imps_apic_cpu_map[apicid] = 0;
+
+	p.type = 0;
+	p.apic_ver = 0x10;
+	p.signature = p.features = 0;
+
+	for (i = 0; i < ncpus; i++) {
+		if (apicid == i) {
+			p.flags = IMPS_FLAG_ENABLED | IMPS_CPUFLAG_BOOT;
+		} else {
+			p.flags = IMPS_FLAG_ENABLED;
+		}
+		p.apic_id = i;
+		add_processor(&p);
+	}
+
+	return imps_num_cpus;
+}
+
+
+/*
+ *  This is the primary function for probing for MPS compatible hardware
+ *  and BIOS information.  Call this during the early stages of OS startup,
+ *  before memory can be messed up.
+ *
+ *  The probe looks for the "MP Floating Pointer Structure" at locations
+ *  listed at the top of page 4-2 of the spec.
+ *
+ *  Environment requirements from the OS to run:
+ *
+ *   (1) : A non-linear virtual to physical memory mapping is probably OK,
+ *	     as (I think) the structures all fall within page boundaries,
+ *	     but a linear mapping is recommended.  Currently assumes that
+ *	     the mapping will remain identical over time (which should be
+ *	     OK since it only accesses memory which shouldn't be munged
+ *	     by the OS anyway).
+ *   (2) : The OS only consumes memory which the BIOS says is OK to use,
+ *	     and not any of the BIOS standard areas (the areas 0x400 to
+ *	     0x600, the EBDA, 0xE0000 to 0xFFFFF, and unreported physical
+ *	     RAM).  Sometimes a small amount of physical RAM is not
+ *	     reported by the BIOS, to be used to store MPS and other
+ *	     information.
+ *   (3) : It must be possible to read the CMOS.
+ *   (4) : There must be between 512K and 640K of lower memory (this is a
+ *	     sanity check).
+ *
+ *  Function finished.
+ */
+
+int
+imps_probe(void)
+{
+	/*
+	 *  Determine possible address of the EBDA
+	 */
+	unsigned ebda_addr = *((unsigned short *)
+			       PHYS_TO_VIRTUAL(EBDA_SEG_ADDR)) << 4;
+
+	/*
+	 *  Determine amount of installed lower memory (not *available*
+	 *  lower memory).
+	 *
+	 *  NOTE:  This should work reliably as long as we verify the
+	 *         machine is at least a system that could possibly have
+	 *         MPS compatibility to begin with.
+	 */
+	unsigned mem_lower = ((CMOS_READ_BYTE(CMOS_BASE_MEMORY+1) << 8)
+			      | CMOS_READ_BYTE(CMOS_BASE_MEMORY))       << 10;
+
+#ifdef IMPS_DEBUG
+	imps_enabled = 0;
+	imps_num_cpus = 1;
+#endif
+
+	/*
+	 *  Sanity check : if this isn't reasonable, it is almost impossibly
+	 *    unlikely to be an MPS compatible machine, so return failure.
+	 */
+	if (mem_lower < 512*1024 || mem_lower > 640*1024) {
+		return 0;
+	}
+
+	if (ebda_addr > mem_lower - 1024
+	 || ebda_addr + *((unsigned char *) PHYS_TO_VIRTUAL(ebda_addr))
+         * 1024 > mem_lower) {
+		ebda_addr = 0;
+	}
+
+	if (((ebda_addr && imps_scan(ebda_addr, 1024))
+	 || (!ebda_addr && imps_scan(mem_lower - 1024, 1024))
+	 || imps_scan(0xF0000, 0x10000)) && imps_enabled) {
+		return imps_num_cpus;
+	}
+
+	/*
+	 *  If no BIOS info on MPS hardware is found, then return failure.
+	 */
+
+	return 0;
+}
+