* Patch by Thomas Frieden, 13 Nov 2002:

  Add code for AmigaOne board
  (preliminary merge to U-Boot, still WIP)

* Patch by Jon Diekema, 12 Nov 2002:
  - Adding URL for IEEE OUI lookup
  - Making the autoboot #defines dependent on CONFIG_AUTOBOOT_KEYED
    being defined.
  - In the CONFIG_EXTRA_ENV_SETTINGS #define, the root-on-initrd and
    root-on-nfs macros are designed to switch how the default boot
    method gets defined.

6 files changed, 1300 insertions, 0 deletions

diff --git a/board/MAI/bios_emulator/scitech/src/pm/rttarget/cpuinfo.c b/board/MAI/bios_emulator/scitech/src/pm/rttarget/cpuinfo.c
new file mode 100644
index 0000000000..3d6dd44313
--- /dev/null
+++ b/board/MAI/bios_emulator/scitech/src/pm/rttarget/cpuinfo.c
@@ -0,0 +1,94 @@
+/****************************************************************************
+*
+*                         Ultra Long Period Timer
+*
+*  ========================================================================
+*
+*    The contents of this file are subject to the SciTech MGL Public
+*    License Version 1.0 (the "License"); you may not use this file
+*    except in compliance with the License. You may obtain a copy of
+*    the License at http://www.scitechsoft.com/mgl-license.txt
+*
+*    Software distributed under the License is distributed on an
+*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+*    implied. See the License for the specific language governing
+*    rights and limitations under the License.
+*
+*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
+*
+*    The Initial Developer of the Original Code is SciTech Software, Inc.
+*    All Rights Reserved.
+*
+*  ========================================================================
+*
+* Language:     ANSI C
+* Environment:  RTTarget-32
+*
+* Description:  Module to implement OS specific services to measure the
+*               CPU frequency.
+*
+****************************************************************************/
+
+/*---------------------------- Global variables ---------------------------*/
+
+static ibool havePerformanceCounter;
+
+/*----------------------------- Implementation ----------------------------*/
+
+/****************************************************************************
+REMARKS:
+Increase the thread priority to maximum, if possible.
+****************************************************************************/
+static int SetMaxThreadPriority(void)
+{
+    int     oldPriority;
+    HANDLE  hThread = GetCurrentThread();
+
+    oldPriority = GetThreadPriority(hThread);
+    if (oldPriority != THREAD_PRIORITY_ERROR_RETURN)
+        SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL);
+    return oldPriority;
+}
+
+/****************************************************************************
+REMARKS:
+Restore the original thread priority.
+****************************************************************************/
+static void RestoreThreadPriority(
+    int oldPriority)
+{
+    HANDLE  hThread = GetCurrentThread();
+
+    if (oldPriority != THREAD_PRIORITY_ERROR_RETURN)
+        SetThreadPriority(hThread, oldPriority);
+}
+
+/****************************************************************************
+REMARKS:
+Initialise the counter and return the frequency of the counter.
+****************************************************************************/
+static void GetCounterFrequency(
+    CPU_largeInteger *freq)
+{
+    if (!QueryPerformanceFrequency((LARGE_INTEGER*)freq)) {
+        havePerformanceCounter = false;
+        freq->low = 100000;
+        freq->high = 0;
+        }
+    else
+        havePerformanceCounter = true;
+}
+
+/****************************************************************************
+REMARKS:
+Read the counter and return the counter value.
+****************************************************************************/
+#define GetCounter(t)                                       \
+{                                                           \
+    if (havePerformanceCounter)                             \
+        QueryPerformanceCounter((LARGE_INTEGER*)t);         \
+    else {                                                  \
+        (t)->low = timeGetTime() * 100;                     \
+        (t)->high = 0;                                      \
+        }                                                   \
+}
diff --git a/board/MAI/bios_emulator/scitech/src/pm/rttarget/event.c b/board/MAI/bios_emulator/scitech/src/pm/rttarget/event.c
new file mode 100644
index 0000000000..e9aba21b9f
--- /dev/null
+++ b/board/MAI/bios_emulator/scitech/src/pm/rttarget/event.c
@@ -0,0 +1,287 @@
+/****************************************************************************
+*
+*                   SciTech Multi-platform Graphics Library
+*
+*  ========================================================================
+*
+*    The contents of this file are subject to the SciTech MGL Public
+*    License Version 1.0 (the "License"); you may not use this file
+*    except in compliance with the License. You may obtain a copy of
+*    the License at http://www.scitechsoft.com/mgl-license.txt
+*
+*    Software distributed under the License is distributed on an
+*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+*    implied. See the License for the specific language governing
+*    rights and limitations under the License.
+*
+*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
+*
+*    The Initial Developer of the Original Code is SciTech Software, Inc.
+*    All Rights Reserved.
+*
+*  ========================================================================
+*
+* Language:     ANSI C
+* Environment:  RTTarget-32
+*
+* Description:  Win32 implementation for the SciTech cross platform
+*               event library.
+*
+****************************************************************************/
+
+/*---------------------------- Global Variables ---------------------------*/
+
+static ushort   keyUpMsg[256] = {0};    /* Table of key up messages     */
+static int      rangeX,rangeY;          /* Range of mouse coordinates   */
+
+/*---------------------------- Implementation -----------------------------*/
+
+/* These are not used under Win32 */
+#define _EVT_disableInt()       1
+#define _EVT_restoreInt(flags)
+
+/****************************************************************************
+PARAMETERS:
+scanCode    - Scan code to test
+
+REMARKS:
+This macro determines if a specified key is currently down at the
+time that the call is made.
+****************************************************************************/
+#define _EVT_isKeyDown(scanCode)    (keyUpMsg[scanCode] != 0)
+
+/****************************************************************************
+REMARKS:
+This function is used to return the number of ticks since system
+startup in milliseconds. This should be the same value that is placed into
+the time stamp fields of events, and is used to implement auto mouse down
+events.
+****************************************************************************/
+ulong _EVT_getTicks(void)
+{ return timeGetTime(); }
+
+/****************************************************************************
+REMARKS:
+Pumps all messages in the message queue from Win32 into our event queue.
+****************************************************************************/
+void _EVT_pumpMessages(void)
+{
+    MSG     msg;
+    MSG     charMsg;
+    event_t evt;
+
+    while (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) {
+        memset(&evt,0,sizeof(evt));
+        switch (msg.message) {
+            case WM_MOUSEMOVE:
+                evt.what = EVT_MOUSEMOVE;
+                break;
+            case WM_LBUTTONDBLCLK:
+                evt.what = EVT_MOUSEDOWN;
+                evt.message = EVT_LEFTBMASK | EVT_DBLCLICK;
+                break;
+            case WM_LBUTTONDOWN:
+                evt.what = EVT_MOUSEDOWN;
+                evt.message = EVT_LEFTBMASK;
+                break;
+            case WM_LBUTTONUP:
+                evt.what = EVT_MOUSEUP;
+                evt.message = EVT_LEFTBMASK;
+                break;
+            case WM_RBUTTONDBLCLK:
+                evt.what = EVT_MOUSEDOWN | EVT_DBLCLICK;
+                evt.message = EVT_RIGHTBMASK;
+                break;
+            case WM_RBUTTONDOWN:
+                evt.what = EVT_MOUSEDOWN;
+                evt.message = EVT_RIGHTBMASK;
+                break;
+            case WM_RBUTTONUP:
+                evt.what = EVT_MOUSEUP;
+                evt.message = EVT_RIGHTBMASK;
+                break;
+            case WM_KEYDOWN:
+            case WM_SYSKEYDOWN:
+                if (HIWORD(msg.lParam) & KF_REPEAT) {
+                    evt.what = EVT_KEYREPEAT;
+                    }
+                else {
+                    evt.what = EVT_KEYDOWN;
+                    }
+                break;
+            case WM_KEYUP:
+            case WM_SYSKEYUP:
+                evt.what = EVT_KEYUP;
+                break;
+            }
+
+        /* Convert mouse event modifier flags */
+        if (evt.what & EVT_MOUSEEVT) {
+            evt.where_x = msg.pt.x;
+            evt.where_y = msg.pt.y;
+            if (evt.what == EVT_MOUSEMOVE) {
+                if (oldMove != -1) {
+                    evtq[oldMove].where_x = evt.where_x;/* Modify existing one  */
+                    evtq[oldMove].where_y = evt.where_y;
+                    evt.what = 0;
+                    }
+                else {
+                    oldMove = freeHead; /* Save id of this move event   */
+                    }
+                }
+            else
+                oldMove = -1;
+            if (msg.wParam & MK_LBUTTON)
+                evt.modifiers |= EVT_LEFTBUT;
+            if (msg.wParam & MK_RBUTTON)
+                evt.modifiers |= EVT_RIGHTBUT;
+            if (msg.wParam & MK_SHIFT)
+                evt.modifiers |= EVT_SHIFTKEY;
+            if (msg.wParam & MK_CONTROL)
+                evt.modifiers |= EVT_CTRLSTATE;
+            }
+
+        /* Convert keyboard codes */
+        TranslateMessage(&msg);
+        if (evt.what & EVT_KEYEVT) {
+            int scanCode = (msg.lParam >> 16) & 0xFF;
+            if (evt.what == EVT_KEYUP) {
+                /* Get message for keyup code from table of cached down values */
+                evt.message = keyUpMsg[scanCode];
+                keyUpMsg[scanCode] = 0;
+                }
+            else {
+                if (PeekMessage(&charMsg,NULL,WM_CHAR,WM_CHAR,PM_REMOVE))
+                    evt.message = charMsg.wParam;
+                if (PeekMessage(&charMsg,NULL,WM_SYSCHAR,WM_SYSCHAR,PM_REMOVE))
+                    evt.message = charMsg.wParam;
+                evt.message |= ((msg.lParam >> 8) & 0xFF00);
+                keyUpMsg[scanCode] = (ushort)evt.message;
+                }
+            if (evt.what == EVT_KEYREPEAT)
+                evt.message |= (msg.lParam << 16);
+            if (HIWORD(msg.lParam) & KF_ALTDOWN)
+                evt.modifiers |= EVT_ALTSTATE;
+            if (GetKeyState(VK_SHIFT) & 0x8000U)
+                evt.modifiers |= EVT_SHIFTKEY;
+            if (GetKeyState(VK_CONTROL) & 0x8000U)
+                evt.modifiers |= EVT_CTRLSTATE;
+            oldMove = -1;
+            }
+
+        if (evt.what != 0) {
+            /* Add time stamp and add the event to the queue */
+            evt.when = msg.time;
+            if (count < EVENTQSIZE) {
+                addEvent(&evt);
+                }
+            }
+        DispatchMessage(&msg);
+        }
+}
+
+/****************************************************************************
+REMARKS:
+This macro/function is used to converts the scan codes reported by the
+keyboard to our event libraries normalised format. We only have one scan
+code for the 'A' key, and use shift modifiers to determine if it is a
+Ctrl-F1, Alt-F1 etc. The raw scan codes from the keyboard work this way,
+but the OS gives us 'cooked' scan codes, we have to translate them back
+to the raw format.
+****************************************************************************/
+#define _EVT_maskKeyCode(evt)
+
+/****************************************************************************
+REMARKS:
+Safely abort the event module upon catching a fatal error.
+****************************************************************************/
+void _EVT_abort()
+{
+    EVT_exit();
+    PM_fatalError("Unhandled exception!");
+}
+
+/****************************************************************************
+PARAMETERS:
+mouseMove   - Callback function to call wheneve the mouse needs to be moved
+
+REMARKS:
+Initiliase the event handling module. Here we install our mouse handling ISR
+to be called whenever any button's are pressed or released. We also build
+the free list of events in the event queue.
+
+We use handler number 2 of the mouse libraries interrupt handlers for our
+event handling routines.
+****************************************************************************/
+void EVTAPI EVT_init(
+    _EVT_mouseMoveHandler mouseMove)
+{
+    /* Initialise the event queue */
+    _mouseMove = mouseMove;
+    initEventQueue();
+    memset(keyUpMsg,0,sizeof(keyUpMsg));
+
+    /* Catch program termination signals so we can clean up properly */
+    signal(SIGABRT, _EVT_abort);
+    signal(SIGFPE, _EVT_abort);
+    signal(SIGINT, _EVT_abort);
+}
+
+/****************************************************************************
+REMARKS
+Changes the range of coordinates returned by the mouse functions to the
+specified range of values. This is used when changing between graphics
+modes set the range of mouse coordinates for the new display mode.
+****************************************************************************/
+void EVTAPI EVT_setMouseRange(
+    int xRes,
+    int yRes)
+{
+    rangeX = xRes;
+    rangeY = yRes;
+}
+
+/****************************************************************************
+REMARKS
+Modifes the mouse coordinates as necessary if scaling to OS coordinates,
+and sets the OS mouse cursor position.
+****************************************************************************/
+void _EVT_setMousePos(
+    int *x,
+    int *y)
+{
+    SetCursorPos(*x,*y);
+}
+
+/****************************************************************************
+REMARKS:
+Initiailises the internal event handling modules. The EVT_suspend function
+can be called to suspend event handling (such as when shelling out to DOS),
+and this function can be used to resume it again later.
+****************************************************************************/
+void EVT_resume(void)
+{
+    // Do nothing for Win32
+}
+
+/****************************************************************************
+REMARKS
+Suspends all of our event handling operations. This is also used to
+de-install the event handling code.
+****************************************************************************/
+void EVT_suspend(void)
+{
+    // Do nothing for Win32
+}
+
+/****************************************************************************
+REMARKS
+Exits the event module for program terminatation.
+****************************************************************************/
+void EVT_exit(void)
+{
+    /* Restore signal handlers */
+    signal(SIGABRT, SIG_DFL);
+    signal(SIGFPE, SIG_DFL);
+    signal(SIGINT, SIG_DFL);
+}
diff --git a/board/MAI/bios_emulator/scitech/src/pm/rttarget/oshdr.h b/board/MAI/bios_emulator/scitech/src/pm/rttarget/oshdr.h
new file mode 100644
index 0000000000..1352dadad6
--- /dev/null
+++ b/board/MAI/bios_emulator/scitech/src/pm/rttarget/oshdr.h
@@ -0,0 +1,34 @@
+/****************************************************************************
+*
+*                   SciTech OS Portability Manager Library
+*
+*  ========================================================================
+*
+*    The contents of this file are subject to the SciTech MGL Public
+*    License Version 1.0 (the "License"); you may not use this file
+*    except in compliance with the License. You may obtain a copy of
+*    the License at http://www.scitechsoft.com/mgl-license.txt
+*
+*    Software distributed under the License is distributed on an
+*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+*    implied. See the License for the specific language governing
+*    rights and limitations under the License.
+*
+*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
+*
+*    The Initial Developer of the Original Code is SciTech Software, Inc.
+*    All Rights Reserved.
+*
+*  ========================================================================
+*
+* Language:     ANSI C
+* Environment:  RTTarget-32
+*
+* Description:  Include file to include all OS specific header files.
+*
+****************************************************************************/
+
+#define WIN32_LEAN_AND_MEAN
+#define STRICT
+#include <windows.h>
+#include <mmsystem.h>
diff --git a/board/MAI/bios_emulator/scitech/src/pm/rttarget/pm.c b/board/MAI/bios_emulator/scitech/src/pm/rttarget/pm.c
new file mode 100644
index 0000000000..e6c1fbd8b3
--- /dev/null
+++ b/board/MAI/bios_emulator/scitech/src/pm/rttarget/pm.c
@@ -0,0 +1,701 @@
+/****************************************************************************
+*
+*                   SciTech OS Portability Manager Library
+*
+*  ========================================================================
+*
+*    The contents of this file are subject to the SciTech MGL Public
+*    License Version 1.0 (the "License"); you may not use this file
+*    except in compliance with the License. You may obtain a copy of
+*    the License at http://www.scitechsoft.com/mgl-license.txt
+*
+*    Software distributed under the License is distributed on an
+*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+*    implied. See the License for the specific language governing
+*    rights and limitations under the License.
+*
+*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
+*
+*    The Initial Developer of the Original Code is SciTech Software, Inc.
+*    All Rights Reserved.
+*
+*  ========================================================================
+*
+* Language:     ANSI C
+* Environment:  RTTarget-32
+*
+* Description:  Implementation for the OS Portability Manager Library, which
+*               contains functions to implement OS specific services in a
+*               generic, cross platform API. Porting the OS Portability
+*               Manager library is the first step to porting any SciTech
+*               products to a new platform.
+*
+****************************************************************************/
+
+#include "pmapi.h"
+#include "drvlib/os/os.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define WIN32_LEAN_AND_MEAN
+#define STRICT
+#include <windows.h>
+#include <mmsystem.h>
+#ifdef  __BORLANDC__
+#pragma warn -par
+#endif
+
+/*--------------------------- Global variables ----------------------------*/
+
+static void     (PMAPIP fatalErrorCleanup)(void) = NULL;
+
+/*----------------------------- Implementation ----------------------------*/
+
+void MTRR_init(void);
+
+/****************************************************************************
+REMARKS:
+Initialise the PM library.
+****************************************************************************/
+void PMAPI PM_init(void)
+{
+    // TODO: dO any special init code in here.
+    MTRR_init();
+}
+
+/****************************************************************************
+REMARKS:
+Return the operating system type identifier.
+****************************************************************************/
+long PMAPI PM_getOSType(void)
+{
+    return _OS_RTTARGET;
+}
+
+/****************************************************************************
+REMARKS:
+Return the runtime type identifier.
+****************************************************************************/
+int PMAPI PM_getModeType(void)
+{
+    return PM_386;
+}
+
+/****************************************************************************
+REMARKS:
+Add a file directory separator to the end of the filename.
+****************************************************************************/
+void PMAPI PM_backslash(
+    char *s)
+{
+    uint pos = strlen(s);
+    if (s[pos-1] != '\\') {
+        s[pos] = '\\';
+        s[pos+1] = '\0';
+        }
+}
+
+/****************************************************************************
+REMARKS:
+Add a user defined PM_fatalError cleanup function.
+****************************************************************************/
+void PMAPI PM_setFatalErrorCleanup(
+    void (PMAPIP cleanup)(void))
+{
+    fatalErrorCleanup = cleanup;
+}
+
+/****************************************************************************
+REMARKS:
+Report a fatal error condition and halt the program.
+****************************************************************************/
+void PMAPI PM_fatalError(
+    const char *msg)
+{
+    if (fatalErrorCleanup)
+        fatalErrorCleanup();
+    // TODO: Display a fatal error message and exit!
+//  MessageBox(NULL,msg,"Fatal Error!", MB_ICONEXCLAMATION);
+    exit(1);
+}
+
+/****************************************************************************
+REMARKS:
+Allocate the real mode VESA transfer buffer for communicating with the BIOS.
+****************************************************************************/
+void * PMAPI PM_getVESABuf(
+    uint *len,
+    uint *rseg,
+    uint *roff)
+{
+    /* No BIOS access for the RTTarget */
+    return NULL;
+}
+
+/****************************************************************************
+REMARKS:
+Check if a key has been pressed.
+****************************************************************************/
+int PMAPI PM_kbhit(void)
+{
+    // TODO: Need to check if a key is waiting on the keyboard queue
+    return true;
+}
+
+/****************************************************************************
+REMARKS:
+Wait for and return the next keypress.
+****************************************************************************/
+int PMAPI PM_getch(void)
+{
+    // TODO: Need to obtain the next keypress, and block until one is hit
+    return 0xD;
+}
+
+/****************************************************************************
+REMARKS:
+Set the location of the OS console cursor.
+****************************************************************************/
+void PM_setOSCursorLocation(
+    int x,
+    int y)
+{
+    /* Nothing to do for RTTarget-32 */
+}
+
+/****************************************************************************
+REMARKS:
+Set the width of the OS console.
+****************************************************************************/
+void PM_setOSScreenWidth(
+    int width,
+    int height)
+{
+    /* Nothing to do for RTTarget-32 */
+}
+
+/****************************************************************************
+REMARKS:
+Set the real time clock handler (used for software stereo modes).
+****************************************************************************/
+ibool PMAPI PM_setRealTimeClockHandler(
+    PM_intHandler ih,
+    int frequency)
+{
+    /* Not supported for RTTarget-32 */
+    return false;
+}
+
+/****************************************************************************
+REMARKS:
+Set the real time clock frequency (for stereo modes).
+****************************************************************************/
+void PMAPI PM_setRealTimeClockFrequency(
+    int frequency)
+{
+    /* Not supported under RTTarget-32 */
+}
+
+/****************************************************************************
+REMARKS:
+Restore the original real time clock handler.
+****************************************************************************/
+void PMAPI PM_restoreRealTimeClockHandler(void)
+{
+    /* Not supported under RTTarget-32 */
+}
+
+/****************************************************************************
+REMARKS:
+Return the current operating system path or working directory.
+****************************************************************************/
+char * PMAPI PM_getCurrentPath(
+    char *path,
+    int maxLen)
+{
+    return getcwd(path,maxLen);
+}
+
+/****************************************************************************
+REMARKS:
+Return the drive letter for the boot drive.
+****************************************************************************/
+char PMAPI PM_getBootDrive(void)
+{
+    return 'c';
+}
+
+/****************************************************************************
+REMARKS:
+Return the path to the VBE/AF driver files.
+****************************************************************************/
+const char * PMAPI PM_getVBEAFPath(void)
+{
+    return "c:\\";
+}
+
+/****************************************************************************
+REMARKS:
+Return the path to the Nucleus driver files.
+****************************************************************************/
+const char * PMAPI PM_getNucleusPath(void)
+{
+    // TODO: Point this at the path when the Nucleus drivers will be found
+    return "c:\\nucleus";
+}
+
+/****************************************************************************
+REMARKS:
+Return the path to the Nucleus configuration files.
+****************************************************************************/
+const char * PMAPI PM_getNucleusConfigPath(void)
+{
+    static char path[256];
+    strcpy(path,PM_getNucleusPath());
+    PM_backslash(path);
+    strcat(path,"config");
+    return path;
+}
+
+/****************************************************************************
+REMARKS:
+Return a unique identifier for the machine if possible.
+****************************************************************************/
+const char * PMAPI PM_getUniqueID(void)
+{
+    return PM_getMachineName();
+}
+
+/****************************************************************************
+REMARKS:
+Get the name of the machine on the network.
+****************************************************************************/
+const char * PMAPI PM_getMachineName(void)
+{
+    /* Not necessary for RTTarget-32 */
+    return "Unknown";
+}
+
+/****************************************************************************
+REMARKS:
+Return a pointer to the real mode BIOS data area.
+****************************************************************************/
+void * PMAPI PM_getBIOSPointer(void)
+{
+    /* Not used for RTTarget-32 */
+    return NULL;
+}
+
+/****************************************************************************
+REMARKS:
+Return a pointer to 0xA0000 physical VGA graphics framebuffer.
+****************************************************************************/
+void * PMAPI PM_getA0000Pointer(void)
+{
+    static void *bankPtr;
+    if (!bankPtr)
+        bankPtr = PM_mapPhysicalAddr(0xA0000,0xFFFF,true);
+    return bankPtr;
+}
+
+/****************************************************************************
+REMARKS:
+Map a physical address to a linear address in the callers process.
+****************************************************************************/
+void * PMAPI PM_mapPhysicalAddr(
+    ulong base,
+    ulong limit,
+    ibool isCached)
+{
+    // TODO: Map a physical memory address to a linear address
+    return NULL;
+}
+
+/****************************************************************************
+REMARKS:
+Free a physical address mapping allocated by PM_mapPhysicalAddr.
+****************************************************************************/
+void PMAPI PM_freePhysicalAddr(
+    void *ptr,
+    ulong limit)
+{
+    // TODO: Free the physical address mapping
+}
+
+ulong PMAPI PM_getPhysicalAddr(void *p)
+{
+    // TODO: This function should find the physical address of a linear
+    //       address.
+    return 0xFFFFFFFFUL;
+}
+
+void PMAPI PM_sleep(ulong milliseconds)
+{
+    Sleep(milliseconds);
+}
+
+int PMAPI PM_getCOMPort(int port)
+{
+    // TODO: Re-code this to determine real values using the Plug and Play
+    //       manager for the OS.
+    switch (port) {
+        case 0: return 0x3F8;
+        case 1: return 0x2F8;
+        }
+    return 0;
+}
+
+int PMAPI PM_getLPTPort(int port)
+{
+    // TODO: Re-code this to determine real values using the Plug and Play
+    //       manager for the OS.
+    switch (port) {
+        case 0: return 0x3BC;
+        case 1: return 0x378;
+        case 2: return 0x278;
+        }
+    return 0;
+}
+
+/****************************************************************************
+REMARKS:
+Allocate a block of (unnamed) shared memory.
+****************************************************************************/
+void * PMAPI PM_mallocShared(
+    long size)
+{
+    return PM_malloc(size);
+}
+
+/****************************************************************************
+REMARKS:
+Free a block of shared memory.
+****************************************************************************/
+void PMAPI PM_freeShared(
+    void *ptr)
+{
+    PM_free(ptr);
+}
+
+/****************************************************************************
+REMARKS:
+Map a linear memory address to the calling process address space. The
+address will have been allocated in another process using the
+PM_mapPhysicalAddr function.
+****************************************************************************/
+void * PMAPI PM_mapToProcess(
+    void *base,
+    ulong limit)
+{
+    return base;
+}
+
+/****************************************************************************
+REMARKS:
+Map a real mode pointer to a protected mode pointer.
+****************************************************************************/
+void * PMAPI PM_mapRealPointer(
+    uint r_seg,
+    uint r_off)
+{
+    /* Not used for RTTarget-32 */
+    return NULL;
+}
+
+/****************************************************************************
+REMARKS:
+Allocate a block of real mode memory
+****************************************************************************/
+void * PMAPI PM_allocRealSeg(
+    uint size,
+    uint *r_seg,
+    uint *r_off)
+{
+    /* Not used for RTTarget-32 */
+    return NULL;
+}
+
+/****************************************************************************
+REMARKS:
+Free a block of real mode memory.
+****************************************************************************/
+void PMAPI PM_freeRealSeg(
+    void *mem)
+{
+    /* Not used for RTTarget-32 */
+}
+
+/****************************************************************************
+REMARKS:
+Issue a real mode interrupt (parameters in DPMI compatible structure)
+****************************************************************************/
+void PMAPI DPMI_int86(
+    int intno,
+    DPMI_regs *regs)
+{
+    /* Not used for RTTarget-32 */
+}
+
+/****************************************************************************
+REMARKS:
+Issue a real mode interrupt.
+****************************************************************************/
+int PMAPI PM_int86(
+    int intno,
+    RMREGS *in,
+    RMREGS *out)
+{
+    /* Not used for RTTarget-32 */
+    return 0;
+}
+
+/****************************************************************************
+REMARKS:
+Issue a real mode interrupt.
+****************************************************************************/
+int PMAPI PM_int86x(
+    int intno,
+    RMREGS *in,
+    RMREGS *out,
+    RMSREGS *sregs)
+{
+    /* Not used for RTTarget-32 */
+    return 0;
+}
+
+/****************************************************************************
+REMARKS:
+Call a real mode far function.
+****************************************************************************/
+void PMAPI PM_callRealMode(
+    uint seg,
+    uint off,
+    RMREGS *in,
+    RMSREGS *sregs)
+{
+    /* Not used for RTTarget-32 */
+}
+
+/****************************************************************************
+REMARKS:
+Return the amount of available memory.
+****************************************************************************/
+void PMAPI PM_availableMemory(
+    ulong *physical,
+    ulong *total)
+{
+    // TODO: Figure out how to determine the available memory. Not entirely
+    //       critical so returning 0 is OK.
+    *physical = *total = 0;
+}
+
+/****************************************************************************
+REMARKS:
+Allocate a block of locked, physical memory for DMA operations.
+****************************************************************************/
+void * PMAPI PM_allocLockedMem(
+    uint size,
+    ulong *physAddr,
+    ibool contiguous,
+    ibool below16M)
+{
+    // TODO: Allocate a block of locked, phsyically contigous memory for DMA
+    return 0;
+}
+
+/****************************************************************************
+REMARKS:
+Free a block of locked physical memory.
+****************************************************************************/
+void PMAPI PM_freeLockedMem(
+    void *p,
+    uint size,
+    
+    ibool contiguous)
+{
+    // TODO: Free a locked memory buffer
+}
+
+/****************************************************************************
+REMARKS:
+Call the VBE/Core software interrupt to change display banks.
+****************************************************************************/
+void PMAPI PM_setBankA(
+    int bank)
+{
+    /* Not used for RTTarget-32 */
+}
+
+/****************************************************************************
+REMARKS:
+Call the VBE/Core software interrupt to change display banks.
+****************************************************************************/
+void PMAPI PM_setBankAB(
+    int bank)
+{
+    /* Not used for RTTarget-32 */
+}
+
+/****************************************************************************
+REMARKS:
+Call the VBE/Core software interrupt to change display start address.
+****************************************************************************/
+void PMAPI PM_setCRTStart(
+    int x,
+    int y,
+    int waitVRT)
+{
+    /* Not used for RTTarget-32 */
+}
+
+/****************************************************************************
+REMARKS:
+Execute the POST on the secondary BIOS for a controller.
+****************************************************************************/
+ibool PMAPI PM_doBIOSPOST(
+    ushort axVal,
+    ulong BIOSPhysAddr,
+    void *mappedBIOS)
+{
+    /* Not used for RTTarget-32 */
+    return false;
+}
+
+PM_MODULE PMAPI PM_loadLibrary(
+    const char *szDLLName)
+{
+    // TODO: Implement this to load shared libraries!
+    (void)szDLLName;
+    return NULL;
+}
+
+void * PMAPI PM_getProcAddress(
+    PM_MODULE hModule,
+    const char *szProcName)
+{
+    // TODO: Implement this!
+    (void)hModule;
+    (void)szProcName;
+    return NULL;
+}
+
+void PMAPI PM_freeLibrary(
+    PM_MODULE hModule)
+{
+    // TODO: Implement this!
+    (void)hModule;
+}
+
+/****************************************************************************
+REMARKS:
+Function to find the first file matching a search criteria in a directory.
+****************************************************************************/
+ulong PMAPI PM_findFirstFile(
+    const char *filename,
+    PM_findData *findData)
+{
+    // TODO: This function should start a directory enumeration search
+    //       given the filename (with wildcards). The data should be
+    //       converted and returned in the findData standard form.
+    (void)filename;
+    (void)findData;
+    return PM_FILE_INVALID;
+}
+
+/****************************************************************************
+REMARKS:
+Function to find the next file matching a search criteria in a directory.
+****************************************************************************/
+ibool PMAPI PM_findNextFile(
+    ulong handle,
+    PM_findData *findData)
+{
+    // TODO: This function should find the next file in directory enumeration
+    //       search given the search criteria defined in the call to
+    //       PM_findFirstFile. The data should be converted and returned
+    //       in the findData standard form.
+    (void)handle;
+    (void)findData;
+    return false;
+}
+
+/****************************************************************************
+REMARKS:
+Function to close the find process
+****************************************************************************/
+void PMAPI PM_findClose(
+    ulong handle)
+{
+    // TODO: This function should close the find process. This may do
+    //       nothing for some OS'es.
+    (void)handle;
+}
+
+/****************************************************************************
+REMARKS:
+Function to determine if a drive is a valid drive or not. Under Unix this
+function will return false for anything except a value of 3 (considered
+the root drive, and equivalent to C: for non-Unix systems). The drive
+numbering is:
+
+    1   - Drive A:
+    2   - Drive B:
+    3   - Drive C:
+    etc
+
+****************************************************************************/
+ibool PMAPI PM_driveValid(
+    char drive)
+{
+    if (drive == 3)
+        return true;
+    return false;
+}
+
+/****************************************************************************
+REMARKS:
+Function to get the current working directory for the specififed drive.
+Under Unix this will always return the current working directory regardless
+of what the value of 'drive' is.
+****************************************************************************/
+void PMAPI PM_getdcwd(
+    int drive,
+    char *dir,
+    int len)
+{
+    (void)drive;
+    getcwd(dir,len);
+}
+
+/****************************************************************************
+REMARKS:
+Function to change the file attributes for a specific file.
+****************************************************************************/
+void PMAPI PM_setFileAttr(
+    const char *filename,
+    uint attrib)
+{
+    // TODO: Set the file attributes for a file
+    (void)filename;
+    (void)attrib;
+}
+
+/****************************************************************************
+REMARKS:
+Function to create a directory.
+****************************************************************************/
+ibool PMAPI PM_mkdir(
+    const char *filename)
+{
+    return mkdir(filename) == 0;
+}
+
+/****************************************************************************
+REMARKS:
+Function to remove a directory.
+****************************************************************************/
+ibool PMAPI PM_rmdir(
+    const char *filename)
+{
+    return rmdir(filename) == 0;
+}
diff --git a/board/MAI/bios_emulator/scitech/src/pm/rttarget/vflat.c b/board/MAI/bios_emulator/scitech/src/pm/rttarget/vflat.c
new file mode 100644
index 0000000000..dd9dfe6826
--- /dev/null
+++ b/board/MAI/bios_emulator/scitech/src/pm/rttarget/vflat.c
@@ -0,0 +1,48 @@
+/****************************************************************************
+*
+*                   SciTech OS Portability Manager Library
+*
+*  ========================================================================
+*
+*    The contents of this file are subject to the SciTech MGL Public
+*    License Version 1.0 (the "License"); you may not use this file
+*    except in compliance with the License. You may obtain a copy of
+*    the License at http://www.scitechsoft.com/mgl-license.txt
+*
+*    Software distributed under the License is distributed on an
+*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+*    implied. See the License for the specific language governing
+*    rights and limitations under the License.
+*
+*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
+*
+*    The Initial Developer of the Original Code is SciTech Software, Inc.
+*    All Rights Reserved.
+*
+*  ========================================================================
+*
+* Language:     ANSI C
+* Environment:  RTTarget-32
+*
+* Description:  Dummy module; no virtual framebuffer for this OS
+*
+****************************************************************************/
+
+#include "pmapi.h"
+#ifdef  __BORLANDC__
+#pragma warn -par
+#endif
+
+ibool PMAPI VF_available(void)
+{
+    return false;
+}
+
+void * PMAPI VF_init(ulong baseAddr,int bankSize,int codeLen,void *bankFunc)
+{
+    return NULL;
+}
+
+void PMAPI VF_exit(void)
+{
+}
diff --git a/board/MAI/bios_emulator/scitech/src/pm/rttarget/ztimer.c b/board/MAI/bios_emulator/scitech/src/pm/rttarget/ztimer.c
new file mode 100644
index 0000000000..52472c385a
--- /dev/null
+++ b/board/MAI/bios_emulator/scitech/src/pm/rttarget/ztimer.c
@@ -0,0 +1,136 @@
+/****************************************************************************
+*
+*                         Ultra Long Period Timer
+*
+*  ========================================================================
+*
+*    The contents of this file are subject to the SciTech MGL Public
+*    License Version 1.0 (the "License"); you may not use this file
+*    except in compliance with the License. You may obtain a copy of
+*    the License at http://www.scitechsoft.com/mgl-license.txt
+*
+*    Software distributed under the License is distributed on an
+*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+*    implied. See the License for the specific language governing
+*    rights and limitations under the License.
+*
+*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
+*
+*    The Initial Developer of the Original Code is SciTech Software, Inc.
+*    All Rights Reserved.
+*
+*  ========================================================================
+*
+* Language:     ANSI C
+* Environment:  RTTarget-32
+*
+* Description:  OS specific implementation for the Zen Timer functions.
+*
+****************************************************************************/
+
+/*---------------------------- Global variables ---------------------------*/
+
+static CPU_largeInteger countFreq;
+static ibool            havePerformanceCounter;
+static ulong            start,finish;
+
+/*----------------------------- Implementation ----------------------------*/
+
+/****************************************************************************
+REMARKS:
+Initialise the Zen Timer module internals.
+****************************************************************************/
+void __ZTimerInit(void)
+{
+#ifdef  NO_ASSEMBLER
+    havePerformanceCounter = false;
+#else
+    havePerformanceCounter = QueryPerformanceFrequency((LARGE_INTEGER*)&countFreq);
+#endif
+}
+
+/****************************************************************************
+REMARKS:
+Start the Zen Timer counting.
+****************************************************************************/
+static void __LZTimerOn(
+    LZTimerObject *tm)
+{
+    if (havePerformanceCounter)
+        QueryPerformanceCounter((LARGE_INTEGER*)&tm->start);
+    else
+        tm->start.low = timeGetTime();
+}
+
+/****************************************************************************
+REMARKS:
+Compute the lap time since the timer was started.
+****************************************************************************/
+static ulong __LZTimerLap(
+    LZTimerObject *tm)
+{
+    CPU_largeInteger    tmLap,tmCount;
+
+    if (havePerformanceCounter) {
+        QueryPerformanceCounter((LARGE_INTEGER*)&tmLap);
+        _CPU_diffTime64(&tm->start,&tmLap,&tmCount);
+        return _CPU_calcMicroSec(&tmCount,countFreq.low);
+        }
+    else {
+        tmLap.low = timeGetTime();
+        return (tmLap.low - tm->start.low) * 1000L;
+        }
+}
+
+/****************************************************************************
+REMARKS:
+Stop the Zen Timer counting.
+****************************************************************************/
+static void __LZTimerOff(
+    LZTimerObject *tm)
+{
+    if (havePerformanceCounter)
+        QueryPerformanceCounter((LARGE_INTEGER*)&tm->end);
+    else
+        tm->end.low = timeGetTime();
+}
+
+/****************************************************************************
+REMARKS:
+Compute the elapsed time in microseconds between start and end timings.
+****************************************************************************/
+static ulong __LZTimerCount(
+    LZTimerObject *tm)
+{
+    CPU_largeInteger    tmCount;
+
+    if (havePerformanceCounter) {
+        _CPU_diffTime64(&tm->start,&tm->end,&tmCount);
+        return _CPU_calcMicroSec(&tmCount,countFreq.low);
+        }
+    else
+        return (tm->end.low - tm->start.low) * 1000L;
+}
+
+/****************************************************************************
+REMARKS:
+Define the resolution of the long period timer as microseconds per timer tick.
+****************************************************************************/
+#define ULZTIMER_RESOLUTION     1000
+
+/****************************************************************************
+REMARKS:
+Read the Long Period timer from the OS
+****************************************************************************/
+static ulong __ULZReadTime(void)
+{ return timeGetTime(); }
+
+/****************************************************************************
+REMARKS:
+Compute the elapsed time from the BIOS timer tick. Note that we check to see
+whether a midnight boundary has passed, and if so adjust the finish time to
+account for this. We cannot detect if more that one midnight boundary has
+passed, so if this happens we will be generating erronous results.
+****************************************************************************/
+ulong __ULZElapsedTime(ulong start,ulong finish)
+{ return finish - start; }