1 files changed, 539 insertions, 0 deletions
diff --git a/board/MAI/bios_emulator/scitech/src/pm/beos/pm.c b/board/MAI/bios_emulator/scitech/src/pm/beos/pm.c
new file mode 100644
index 0000000000..c57d82ab68
--- /dev/null
+++ b/board/MAI/bios_emulator/scitech/src/pm/beos/pm.c
@@ -0,0 +1,539 @@
+/****************************************************************************
+*
+*                   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:  BeOS
+*
+* 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>
+
+// TODO: Include any BeOS specific headers here!
+
+/*--------------------------- Global variables ----------------------------*/
+
+static void (PMAPIP fatalErrorCleanup)(void) = NULL;
+
+/*----------------------------- Implementation ----------------------------*/
+
+void PMAPI PM_init(void)
+{
+    // TODO: Do any initialisation in here. This includes getting IOPL
+    //       access for the process calling PM_init. This will get called
+    //       more than once.
+
+    // TODO: If you support the supplied MTRR register stuff (you need to
+    //       be at ring 0 for this!), you should initialise it in here.
+
+/* MTRR_init(); */
+}
+
+long PMAPI PM_getOSType(void)
+{ return _OS_BEOS; }
+
+int PMAPI PM_getModeType(void)
+{ return PM_386; }
+
+void PMAPI PM_backslash(char *s)
+{
+    uint pos = strlen(s);
+    if (s[pos-1] != '/') {
+        s[pos] = '/';
+        s[pos+1] = '\0';
+        }
+}
+
+void PMAPI PM_setFatalErrorCleanup(
+    void (PMAPIP cleanup)(void))
+{
+    fatalErrorCleanup = cleanup;
+}
+
+void PMAPI PM_fatalError(const char *msg)
+{
+    // TODO: If you are running in a GUI environment without a console,
+    //       this needs to be changed to bring up a fatal error message
+    //       box and terminate the program.
+    if (fatalErrorCleanup)
+        fatalErrorCleanup();
+    fprintf(stderr,"%s\n", msg);
+    exit(1);
+}
+
+void * PMAPI PM_getVESABuf(uint *len,uint *rseg,uint *roff)
+{
+    // No BIOS access for the BeOS
+    return NULL;
+}
+
+int PMAPI PM_kbhit(void)
+{
+    // TODO: This function checks if a key is available to be read. This
+    //       should be implemented, but is mostly used by the test programs
+    //       these days.
+    return true;
+}
+
+int PMAPI PM_getch(void)
+{
+    // TODO: This returns the ASCII code of the key pressed. This
+    //       should be implemented, but is mostly used by the test programs
+    //       these days.
+    return 0xD;
+}
+
+int PMAPI PM_openConsole(void)
+{
+    // TODO: Opens up a fullscreen console for graphics output. If your
+    //       console does not have graphics/text modes, this can be left
+    //       empty. The main purpose of this is to disable console switching
+    //       when in graphics modes if you can switch away from fullscreen
+    //       consoles (if you want to allow switching, this can be done
+    //       elsewhere with a full save/restore state of the graphics mode).
+    return 0;
+}
+
+int PMAPI PM_getConsoleStateSize(void)
+{
+    // TODO: Returns the size of the console state buffer used to save the
+    //       state of the console before going into graphics mode. This is
+    //       used to restore the console back to normal when we are done.
+    return 1;
+}
+
+void PMAPI PM_saveConsoleState(void *stateBuf,int console_id)
+{
+    // TODO: Saves the state of the console into the state buffer. This is
+    //       used to restore the console back to normal when we are done.
+    //       We will always restore 80x25 text mode after being in graphics
+    //       mode, so if restoring text mode is all you need to do this can
+    //       be left empty.
+}
+
+void PMAPI PM_restoreConsoleState(const void *stateBuf,int console_id)
+{
+    // TODO: Restore the state of the console from the state buffer. This is
+    //       used to restore the console back to normal when we are done.
+    //       We will always restore 80x25 text mode after being in graphics
+    //       mode, so if restoring text mode is all you need to do this can
+    //       be left empty.
+}
+
+void PMAPI PM_closeConsole(int console_id)
+{
+    // TODO: Close the console when we are done, going back to text mode.
+}
+
+void PM_setOSCursorLocation(int x,int y)
+{
+    // TODO: Set the OS console cursor location to the new value. This is
+    //       generally used for new OS ports (used mostly for DOS).
+}
+
+void PM_setOSScreenWidth(int width,int height)
+{
+    // TODO: Set the OS console screen width. This is generally unused for
+    //       new OS ports.
+}
+
+ibool PMAPI PM_setRealTimeClockHandler(PM_intHandler ih, int frequency)
+{
+    // TODO: Install a real time clock interrupt handler. Normally this
+    //       will not be supported from most OS'es in user land, so an
+    //       alternative mechanism is needed to enable software stereo.
+    //       Hence leave this unimplemented unless you have a high priority
+    //       mechanism to call the 32-bit callback when the real time clock
+    //       interrupt fires.
+    return false;
+}
+
+void PMAPI PM_setRealTimeClockFrequency(int frequency)
+{
+    // TODO: Set the real time clock interrupt frequency. Used for stereo
+    //       LC shutter glasses when doing software stereo. Usually sets
+    //       the frequency to around 2048 Hz.
+}
+
+void PMAPI PM_restoreRealTimeClockHandler(void)
+{
+    // TODO: Restores the real time clock handler.
+}
+
+char * PMAPI PM_getCurrentPath(
+    char *path,
+    int maxLen)
+{
+    return getcwd(path,maxLen);
+}
+
+char PMAPI PM_getBootDrive(void)
+{ return '/'; }
+
+const char * PMAPI PM_getVBEAFPath(void)
+{ return PM_getNucleusConfigPath(); }
+
+const char * PMAPI PM_getNucleusPath(void)
+{
+    char *env = getenv("NUCLEUS_PATH");
+    return env ? env : "/usr/lib/nucleus";
+}
+
+const char * PMAPI PM_getNucleusConfigPath(void)
+{
+    static char path[256];
+    strcpy(path,PM_getNucleusPath());
+    PM_backslash(path);
+    strcat(path,"config");
+    return path;
+}
+
+const char * PMAPI PM_getUniqueID(void)
+{
+    // TODO: Return a unique ID for the machine. If a unique ID is not
+    //       available, return the machine name.
+    static char buf[128];
+    gethostname(buf, 128);
+    return buf;
+}
+
+const char * PMAPI PM_getMachineName(void)
+{
+    // TODO: Return the network machine name for the machine.
+    static char buf[128];
+    gethostname(buf, 128);
+    return buf;
+}
+
+void * PMAPI PM_getBIOSPointer(void)
+{
+    // No BIOS access on the BeOS
+    return NULL;
+}
+
+void * PMAPI PM_getA0000Pointer(void)
+{
+    static void *bankPtr;
+    if (!bankPtr)
+        bankPtr = PM_mapPhysicalAddr(0xA0000,0xFFFF,true);
+    return bankPtr;
+}
+
+void * PMAPI PM_mapPhysicalAddr(ulong base,ulong limit,ibool isCached)
+{
+    // TODO: This function maps a physical memory address to a linear
+    //       address in the address space of the calling process.
+
+    // NOTE: This function *must* be able to handle any phsyical base
+    //       address, and hence you will have to handle rounding of
+    //       the physical base address to a page boundary (ie: 4Kb on
+    //       x86 CPU's) to be able to properly map in the memory
+    //       region.
+
+    // NOTE: If possible the isCached bit should be used to ensure that
+    //       the PCD (Page Cache Disable) and PWT (Page Write Through)
+    //       bits are set to disable caching for a memory mapping used
+    //       for MMIO register access. We also disable caching using
+    //       the MTRR registers for Pentium Pro and later chipsets so if
+    //       MTRR support is enabled for your OS then you can safely ignore
+    //       the isCached flag and always enable caching in the page
+    //       tables.
+    return NULL;
+}
+
+void PMAPI PM_freePhysicalAddr(void *ptr,ulong limit)
+{
+    // TODO: This function will free a physical memory mapping previously
+    //       allocated with PM_mapPhysicalAddr() if at all possible. If
+    //       you can't free physical memory mappings, simply do nothing.
+}
+
+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)
+{
+    // TODO: Put the process to sleep for 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;
+}
+
+void * PMAPI PM_mallocShared(long size)
+{
+    // TODO: This is used to allocate memory that is shared between process
+    //       that all access the common Nucleus drivers via a common display
+    //       driver DLL. If your OS does not support shared memory (or if
+    //       the display driver does not need to allocate shared memory
+    //       for each process address space), this should just call PM_malloc.
+    return PM_malloc(size);
+}
+
+void PMAPI PM_freeShared(void *ptr)
+{
+    // TODO: Free the shared memory block. This will be called in the context
+    //       of the original calling process that allocated the shared
+    //       memory with PM_mallocShared. Simply call free if you do not
+    //       need this.
+    PM_free(ptr);
+}
+
+void * PMAPI PM_mapToProcess(void *base,ulong limit)
+{
+    // TODO: This function is used to map a physical memory mapping
+    //       previously allocated with PM_mapPhysicalAddr into the
+    //       address space of the calling process. If the memory mapping
+    //       allocated by PM_mapPhysicalAddr is global to all processes,
+    //       simply return the pointer.
+    return base;
+}
+
+void * PMAPI PM_mapRealPointer(uint r_seg,uint r_off)
+{
+    // No BIOS access on the BeOS
+    return NULL;
+}
+
+void * PMAPI PM_allocRealSeg(uint size,uint *r_seg,uint *r_off)
+{
+    // No BIOS access on the BeOS
+    return NULL;
+}
+
+void PMAPI PM_freeRealSeg(void *mem)
+{
+    // No BIOS access on the BeOS
+}
+
+void PMAPI DPMI_int86(int intno, DPMI_regs *regs)
+{
+    // No BIOS access on the BeOS
+}
+
+int PMAPI PM_int86(int intno, RMREGS *in, RMREGS *out)
+{
+    // No BIOS access on the BeOS
+    return 0;
+}
+
+int PMAPI PM_int86x(int intno, RMREGS *in, RMREGS *out,
+    RMSREGS *sregs)
+{
+    // No BIOS access on the BeOS
+    return 0;
+}
+
+void PMAPI PM_callRealMode(uint seg,uint off, RMREGS *in,
+    RMSREGS *sregs)
+{
+    // No BIOS access on the BeOS
+}
+
+void PMAPI PM_availableMemory(ulong *physical,ulong *total)
+{
+    // TODO: Report the amount of available memory, both the amount of
+    //       physical memory left and the amount of virtual memory left.
+    //       If the OS does not provide these services, report 0's.
+    *physical = *total = 0;
+}
+
+void * PMAPI PM_allocLockedMem(uint size,ulong *physAddr,ibool contiguous,ibool below16Meg)
+{
+    // TODO: Allocate a block of locked, physical memory of the specified
+    //       size. This is used for bus master operations. If this is not
+    //       supported by the OS, return NULL and bus mastering will not
+    //       be used.
+    return NULL;
+}
+
+void PMAPI PM_freeLockedMem(void *p,uint size,ibool contiguous)
+{
+    // TODO: Free a memory block allocated with PM_allocLockedMem.
+}
+
+void PMAPI PM_setBankA(int bank)
+{
+    // No BIOS access on the BeOS
+}
+
+void PMAPI PM_setBankAB(int bank)
+{
+    // No BIOS access on the BeOS
+}
+
+void PMAPI PM_setCRTStart(int x,int y,int waitVRT)
+{
+    // No BIOS access on the BeOS
+}
+
+ibool PMAPI PM_enableWriteCombine(ulong base,ulong length,uint type)
+{
+    // TODO: This function should enable Pentium Pro and Pentium II MTRR
+    //       write combining for the passed in physical memory base address
+    //       and length. Normally this is done via calls to an OS specific
+    //       device driver as this can only be done at ring 0.
+    //
+    // NOTE: This is a *very* important function to implement! If you do
+    //       not implement, graphics performance on the latest Intel chips
+    //       will be severly impaired. For sample code that can be used
+    //       directly in a ring 0 device driver, see the MSDOS implementation
+    //       which includes assembler code to do this directly (if the
+    //       program is running at ring 0).
+    return false;
+}
+
+ibool PMAPI PM_doBIOSPOST(ushort axVal,ulong BIOSPhysAddr,void *mappedBIOS)
+{
+    // TODO: This function is used to run the BIOS POST code on a secondary
+    //       controller to initialise it for use. This is not necessary
+    //       for multi-controller operation, but it will make it a lot
+    //       more convenicent for end users (otherwise they have to boot
+    //       the system once with the secondary controller as primary, and
+    //       then boot with both controllers installed).
+    //
+    //       Even if you don't support full BIOS access, it would be
+    //       adviseable to be able to POST the secondary controllers in the
+    //       system using this function as a minimum requirement. Some
+    //       graphics hardware has registers that contain values that only
+    //       the BIOS knows about, which makes bring up a card from cold
+    //       reset difficult if the BIOS has not POST'ed it.
+    return false;
+}
+
+/****************************************************************************
+REMARKS:
+Function to find the first file matching a search criteria in a directory.
+****************************************************************************/
+ulong PMAPI PM_findFirstFile(
+    const char *filename,
+    PM_findData *findData)
+{
+    (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)
+{
+    (void)handle;
+    (void)findData;
+    return false;
+}
+
+/****************************************************************************
+REMARKS:
+Function to close the find process
+****************************************************************************/
+void PMAPI PM_findClose(
+    ulong handle)
+{
+    (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;
+}