* 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.

1 files changed, 1149 insertions, 0 deletions

diff --git a/board/MAI/bios_emulator/scitech/include/pmapi.h b/board/MAI/bios_emulator/scitech/include/pmapi.h
new file mode 100644
index 0000000000..3affe67d63
--- /dev/null
+++ b/board/MAI/bios_emulator/scitech/include/pmapi.h
@@ -0,0 +1,1149 @@
+/****************************************************************************
+*
+*                   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:  Any
+*
+* Description:  Header file 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.
+*
+****************************************************************************/
+
+#ifndef __PMAPI_H
+#define __PMAPI_H
+
+#include "scitech.h"
+#include "pcilib.h"
+#include "ztimerc.h"
+#if !defined(__WIN32_VXD__) && !defined(__OS2_VDD__) && !defined(__NT_DRIVER__)
+#include <stdio.h>
+#include <stdlib.h>
+#endif
+
+/*--------------------------- Macros and Typedefs -------------------------*/
+
+/* You will need to define one of the following before you compile this
+ * library for it to work correctly with the DOS extender that you are
+ * using when compiling for extended DOS:
+ *
+ *      TNT         - Phar Lap TNT DOS Extender
+ *      DOS4GW      - Rational DOS/4GW, DOS/4GW Pro, Causeway and PMODE/W
+ *      DJGPP       - DJGPP port of GNU C++
+ *
+ * If none is specified, we will automatically determine which operating
+ * system is being targetted and the following will be defined (provided by
+ * scitech.h header file):
+ *
+ *      __MSDOS16__     - Default for 16 bit MSDOS mode
+ *      __MSDOS32__     - Default for 32 bit MSDOS
+ *      __WINDOWS16__   - Default for 16 bit Windows
+ *      __WINDOWS32__   - Default for 32 bit Windows
+ *
+ * One of the following will be defined automatically for you to select
+ * which memory model is in effect:
+ *
+ *      REALMODE    - 16 bit real mode (large memory model)
+ *      PM286       - 16 protected mode (large memory model)
+ *      PM386       - 32 protected mode (flat memory model)
+ */
+
+#if defined(__UNIX__) && !defined(_MAX_PATH)
+#define _MAX_PATH 256
+#endif
+
+#if defined(TNT) || defined(DOSX) || defined(X32VM) || defined(DPMI32)      \
+    || defined(DOS4GW) || defined(DJGPP) || defined(__WINDOWS32__)          \
+    || defined(__MSDOS32__) || defined(__UNIX__) || defined(__WIN32_VXD__) \
+    || defined(__32BIT__) || defined(__SMX32__) || defined(__RTTARGET__)
+#define PM386
+#elif defined(DPMI16) || defined(__WINDOWS16__)
+#define PM286
+#else
+#define REALMODE
+#endif
+
+#pragma pack(1)
+
+/* Provide the typedefs for the PM_int386 functions, which issue native
+ * interrupts in real or protected mode and can pass extended registers
+ * around.
+ */
+
+struct _PMDWORDREGS {
+    ulong   eax,ebx,ecx,edx,esi,edi,cflag;
+    };
+
+struct _PMWORDREGS {
+    ushort  ax,ax_hi;
+    ushort  bx,bx_hi;
+    ushort  cx,cx_hi;
+    ushort  dx,dx_hi;
+    ushort  si,si_hi;
+    ushort  di,di_hi;
+    ushort  cflag,cflag_hi;
+    };
+
+struct _PMBYTEREGS {
+    uchar   al, ah; ushort ax_hi;
+    uchar   bl, bh; ushort bx_hi;
+    uchar   cl, ch; ushort cx_hi;
+    uchar   dl, dh; ushort dx_hi;
+    };
+
+typedef union {
+    struct  _PMDWORDREGS e;
+    struct  _PMWORDREGS  x;
+    struct  _PMBYTEREGS  h;
+    } PMREGS;
+
+typedef struct {
+    ushort  es;
+    ushort  cs;
+    ushort  ss;
+    ushort  ds;
+    ushort  fs;
+    ushort  gs;
+    } PMSREGS;
+
+/* Provide definitions for the real mode register structures passed to
+ * the PM_int86() and PM_int86x() routines. Note that we provide our own
+ * functions to do this for 16-bit code that calls the PM_int386 functions.
+ */
+
+typedef PMREGS  RMREGS;
+typedef PMSREGS RMSREGS;
+
+typedef struct {
+    long    edi;
+    long    esi;
+    long    ebp;
+    long    reserved;
+    long    ebx;
+    long    edx;
+    long    ecx;
+    long    eax;
+    short   flags;
+    short   es,ds,fs,gs,ip,cs,sp,ss;
+    } DPMI_regs;
+
+#ifdef  __MSDOS__
+/* Register structure passed to PM_VxDCall function */
+typedef struct {
+    ulong   eax;
+    ulong   ebx;
+    ulong   ecx;
+    ulong   edx;
+    ulong   esi;
+    ulong   edi;
+    ushort  ds,es;
+    } VXD_regs;
+#endif
+
+#define PM_MAX_DRIVE                3
+#define PM_MAX_PATH                 256
+#define PM_FILE_INVALID             (void*)0xFFFFFFFF
+
+/* Structure for generic directory traversal and management. Also the same
+ * values are passed to PM_setFileAttr to change the file attributes.
+ */
+
+typedef struct {
+    ulong   dwSize;
+    ulong   attrib;
+    ulong   sizeLo;
+    ulong   sizeHi;
+    char    name[PM_MAX_PATH];
+    } PM_findData;
+
+/* Macro to compute the byte offset of a field in a structure of type type */
+
+#define PM_FIELD_OFFSET(type,field) ((long)&(((type*)0)->field))
+
+/* Marcto to compute the address of the base of the structure given its type,
+ * and an address of a field within the structure.
+ */
+
+#define PM_CONTAINING_RECORD(address, type, field)      \
+    ((type*)(                                           \
+    (char*)(address) -                                  \
+    (char*)(&((type*)0)->field)))
+
+/* Flags stored in the PM_findData structure, and also values passed to
+ * PM_setFileAttr to change the file attributes.
+ */
+
+#define PM_FILE_NORMAL              0x00000000
+#define PM_FILE_READONLY            0x00000001
+#define PM_FILE_DIRECTORY           0x00000002
+#define PM_FILE_ARCHIVE             0x00000004
+#define PM_FILE_HIDDEN              0x00000008
+#define PM_FILE_SYSTEM              0x00000010
+
+/* Flags returned by the PM_splitpath function */
+
+#define PM_HAS_WILDCARDS 0x01
+#define PM_HAS_EXTENSION 0x02
+#define PM_HAS_FILENAME  0x04
+#define PM_HAS_DIRECTORY 0x08
+#define PM_HAS_DRIVE     0x10
+
+/* Structure passed to the PM_setFileTime functions */
+typedef struct {
+    short   sec;        /* Seconds */
+    short   min;        /* Minutes */
+    short   hour;       /* Hour (0--23) */
+    short   day;        /* Day of month (1--31) */
+    short   mon;        /* Month (0--11) */
+    short   year;       /* Year (calendar year minus 1900) */
+    } PM_time;
+
+/* Define a macro for creating physical base addresses from segment:offset */
+
+#define MK_PHYS(s,o)  (((ulong)(s) << 4) + (ulong)(o))
+
+/* Define the different types of modes supported. This is a global variable
+ * that can be used to determine the type at runtime which will contain
+ * one of these values.
+ */
+
+typedef enum {
+    PM_realMode,
+    PM_286,
+    PM_386
+    } PM_mode_enum;
+
+/* Define types passed to PM_enableWriteCombine */
+
+#define PM_MTRR_UNCACHABLE  0
+#define PM_MTRR_WRCOMB      1
+#define PM_MTRR_WRTHROUGH   4
+#define PM_MTRR_WRPROT      5
+#define PM_MTRR_WRBACK      6
+#define PM_MTRR_MAX         6
+
+/* Error codes returned by PM_enableWriteCombine */
+
+#define PM_MTRR_ERR_OK                  0
+#define PM_MTRR_NOT_SUPPORTED           -1
+#define PM_MTRR_ERR_PARAMS              -2
+#define PM_MTRR_ERR_NOT_4KB_ALIGNED     -3
+#define PM_MTRR_ERR_BELOW_1MB           -4
+#define PM_MTRR_ERR_NOT_ALIGNED         -5
+#define PM_MTRR_ERR_OVERLAP             -6
+#define PM_MTRR_ERR_TYPE_MISMATCH       -7
+#define PM_MTRR_ERR_NONE_FREE           -8
+#define PM_MTRR_ERR_NOWRCOMB            -9
+#define PM_MTRR_ERR_NO_OS_SUPPORT       -10
+
+/* Values passed to the PM_DMACProgram function */
+
+#define PM_DMA_READ_ONESHOT     0x44    /* One-shot DMA read        */
+#define PM_DMA_WRITE_ONESHOT    0x48    /* One-shot DMA write       */
+#define PM_DMA_READ_AUTOINIT    0x54    /* Auto-init DMA read       */
+#define PM_DMA_WRITE_AUTOINIT   0x58    /* Auto-init DMA write      */
+
+/* Flags passed to suspend application callback */
+
+#define PM_DEACTIVATE       1
+#define PM_REACTIVATE       2
+
+/* Return codes that the application can return from the suspend application
+ * callback registered with the PM library. See the MGL documentation for
+ * more details.
+ */
+#define PM_SUSPEND_APP      0
+#define PM_NO_SUSPEND_APP   1
+
+/****************************************************************************
+REMARKS:
+This enumeration defines the type values passed to the PM_agpReservePhysical
+function, to define how the physical memory mapping should be handled.
+
+The PM_agpUncached type indicates that the memory should be allocated as
+uncached memory.
+
+The PM_agpWriteCombine type indicates that write combining should be enabled
+for physical memory mapping. This is used for framebuffer write combing and
+speeds up direct framebuffer writes to the memory.
+
+The PM_agpIntelDCACHE type indicates that memory should come from the Intel
+i81x Display Cache (or DCACHE) memory pool. This flag is specific to the
+Intel i810 and i815 controllers, and should not be passed for any other
+controller type.
+
+HEADER:
+pmapi.h
+
+MEMBERS:
+PM_agpUncached      - Indicates that the memory should be uncached
+PM_agpWriteCombine  - Indicates that the memory should be write combined
+PM_agpIntelDCACHE   - Indicates that the memory should come from DCACHE pool
+****************************************************************************/
+typedef enum {
+    PM_agpUncached,
+    PM_agpWriteCombine,
+    PM_agpIntelDCACHE
+    } PM_agpMemoryType;
+
+/* Defines the size of an system memory page */
+
+#define PM_PAGE_SIZE        4096
+
+/* Type definition for a physical memory address */
+
+typedef unsigned long PM_physAddr;
+
+/* Define a bad physical address returned by map physical functions */
+
+#define PM_BAD_PHYS_ADDRESS 0xFFFFFFFF
+
+/* Type definition for the 12-byte lock handle for locking linear memory */
+
+typedef struct {
+    ulong   h[3];
+    } PM_lockHandle;
+
+/* 'C' calling conventions always       */
+
+#define PMAPI   _ASMAPI
+#define PMAPIP  _ASMAPIP
+
+/* Internal typedef to override DPMI_int86 handler */
+
+typedef ibool (PMAPIP DPMI_handler_t)(DPMI_regs *regs);
+void PMAPI DPMI_setInt10Handler(DPMI_handler_t handler);
+
+/* Type definitions for a window handle for console modes */
+
+#if     defined(__DRIVER__) || defined(__WIN32_VXD__) || defined(__NT_DRIVER__)
+typedef void        *PM_HWND;   /* Pointer for portable drivers         */
+typedef void        *PM_MODULE; /* Module handle for portable drivers   */
+#elif   defined(__WINDOWS__)
+#ifdef  DECLARE_HANDLE
+typedef HWND        PM_HWND;    /* Real window handle                   */
+typedef HINSTANCE   PM_MODULE;  /* Win32 DLL handle                     */
+#else
+typedef void        *PM_HWND;   /* Place holder if windows.h not included */
+typedef void        *PM_MODULE; /* Place holder if windows.h not included */
+#endif
+#elif   defined(__USE_X11__)
+typedef struct {
+    Window      *window;
+    Display     *display;
+    } PM_HWND;                  /* X11 window handle */
+#elif   defined(__OS2__)
+typedef void    *PM_HWND;
+typedef void    *PM_MODULE;
+#elif   defined(__LINUX__)
+typedef int     PM_HWND;        /* Console id for fullscreen Linux */
+typedef void    *PM_MODULE;
+#elif   defined(__QNX__)
+typedef int     PM_HWND;        /* Console id for fullscreen QNX */
+typedef void    *PM_MODULE;
+#elif   defined(__RTTARGET__)
+typedef int     PM_HWND;        /* Placeholder for RTTarget-32 */
+typedef void    *PM_MODULE;
+#elif   defined(__REALDOS__)
+typedef int     PM_HWND;        /* Placeholder for fullscreen DOS */
+typedef void    *PM_MODULE;     /* Placeholder for fullscreen DOS */
+#elif   defined(__SMX32__)
+typedef int     PM_HWND;        /* Placeholder for fullscreen SMX */
+typedef void    *PM_MODULE;
+#elif   defined(__SNAP__)
+typedef void    *PM_HWND;
+typedef void    *PM_MODULE;
+#else
+#error  PM library not ported to this platform yet!
+#endif
+
+/* Type definition for code pointers */
+
+typedef void (*__codePtr)();
+
+/* Type definition for a C based interrupt handler */
+
+typedef void (PMAPIP PM_intHandler)(void);
+typedef ibool (PMAPIP PM_irqHandler)(void);
+
+/* Hardware IRQ handle used to save and restore the hardware IRQ */
+
+typedef void *PM_IRQHandle;
+
+/* Type definition for the fatal cleanup handler */
+
+typedef void (PMAPIP PM_fatalCleanupHandler)(void);
+
+/* Type defifinition for save state callback function */
+
+typedef int (PMAPIP PM_saveState_cb)(int flags);
+
+/* Type definintion for enum write combined callback function */
+
+typedef void (PMAPIP PM_enumWriteCombine_t)(ulong base,ulong length,uint type);
+
+/* Structure defining all the PM API functions as exported to
+ * the binary portable DLL's.
+ */
+
+typedef struct {
+    ulong   dwSize;
+    int     (PMAPIP PM_getModeType)(void);
+    void *  (PMAPIP PM_getBIOSPointer)(void);
+    void *  (PMAPIP PM_getA0000Pointer)(void);
+    void *  (PMAPIP PM_mapPhysicalAddr)(ulong base,ulong limit,ibool isCached);
+    void *  (PMAPIP PM_mallocShared)(long size);
+    void *  reserved1;
+    void    (PMAPIP PM_freeShared)(void *ptr);
+    void *  (PMAPIP PM_mapToProcess)(void *linear,ulong limit);
+    void *  (PMAPIP PM_mapRealPointer)(uint r_seg,uint r_off);
+    void *  (PMAPIP PM_allocRealSeg)(uint size,uint *r_seg,uint *r_off);
+    void    (PMAPIP PM_freeRealSeg)(void *mem);
+    void *  (PMAPIP PM_allocLockedMem)(uint size,ulong *physAddr,ibool contiguous,ibool below16Meg);
+    void    (PMAPIP PM_freeLockedMem)(void *p,uint size,ibool contiguous);
+    void    (PMAPIP PM_callRealMode)(uint seg,uint off, RMREGS *regs,RMSREGS *sregs);
+    int     (PMAPIP PM_int86)(int intno, RMREGS *in, RMREGS *out);
+    int     (PMAPIP PM_int86x)(int intno, RMREGS *in, RMREGS *out,RMSREGS *sregs);
+    void    (PMAPIP DPMI_int86)(int intno, DPMI_regs *regs);
+    void    (PMAPIP PM_availableMemory)(ulong *physical,ulong *total);
+    void *  (PMAPIP PM_getVESABuf)(uint *len,uint *rseg,uint *roff);
+    long    (PMAPIP PM_getOSType)(void);
+    void    (PMAPIP PM_fatalError)(const char *msg);
+    void    (PMAPIP PM_setBankA)(int bank);
+    void    (PMAPIP PM_setBankAB)(int bank);
+    void    (PMAPIP PM_setCRTStart)(int x,int y,int waitVRT);
+    char *  (PMAPIP PM_getCurrentPath)(char *path,int maxLen);
+    const char * (PMAPIP PM_getVBEAFPath)(void);
+    const char * (PMAPIP PM_getNucleusPath)(void);
+    const char * (PMAPIP PM_getNucleusConfigPath)(void);
+    const char * (PMAPIP PM_getUniqueID)(void);
+    const char * (PMAPIP PM_getMachineName)(void);
+    ibool   (PMAPIP VF_available)(void);
+    void *  (PMAPIP VF_init)(ulong baseAddr,int bankSize,int codeLen,void *bankFunc);
+    void    (PMAPIP VF_exit)(void);
+    PM_HWND (PMAPIP PM_openConsole)(PM_HWND hwndUser,int device,int xRes,int yRes,int bpp,ibool fullScreen);
+    int     (PMAPIP PM_getConsoleStateSize)(void);
+    void    (PMAPIP PM_saveConsoleState)(void *stateBuf,PM_HWND hwndConsole);
+    void    (PMAPIP PM_restoreConsoleState)(const void *stateBuf,PM_HWND hwndConsole);
+    void    (PMAPIP PM_closeConsole)(PM_HWND hwndConsole);
+    void    (PMAPIP PM_setOSCursorLocation)(int x,int y);
+    void    (PMAPIP PM_setOSScreenWidth)(int width,int height);
+    int     (PMAPIP PM_enableWriteCombine)(ulong base,ulong length,uint type);
+    void    (PMAPIP PM_backslash)(char *filename);
+    int     (PMAPIP PM_lockDataPages)(void *p,uint len,PM_lockHandle *lockHandle);
+    int     (PMAPIP PM_unlockDataPages)(void *p,uint len,PM_lockHandle *lockHandle);
+    int     (PMAPIP PM_lockCodePages)(__codePtr p,uint len,PM_lockHandle *lockHandle);
+    int     (PMAPIP PM_unlockCodePages)(__codePtr p,uint len,PM_lockHandle *lockHandle);
+    ibool   (PMAPIP PM_setRealTimeClockHandler)(PM_intHandler ih,int frequency);
+    void    (PMAPIP PM_setRealTimeClockFrequency)(int frequency);
+    void    (PMAPIP PM_restoreRealTimeClockHandler)(void);
+    ibool   (PMAPIP PM_doBIOSPOST)(ushort axVal,ulong BIOSPhysAddr,void *BIOSPtr,ulong BIOSLen);
+    char    (PMAPIP PM_getBootDrive)(void);
+    void    (PMAPIP PM_freePhysicalAddr)(void *ptr,ulong limit);
+    uchar   (PMAPIP PM_inpb)(int port);
+    ushort  (PMAPIP PM_inpw)(int port);
+    ulong   (PMAPIP PM_inpd)(int port);
+    void    (PMAPIP PM_outpb)(int port,uchar val);
+    void    (PMAPIP PM_outpw)(int port,ushort val);
+    void    (PMAPIP PM_outpd)(int port,ulong val);
+    void *  reserved2;
+    void    (PMAPIP PM_setSuspendAppCallback)(PM_saveState_cb saveState);
+    ibool   (PMAPIP PM_haveBIOSAccess)(void);
+    int     (PMAPIP PM_kbhit)(void);
+    int     (PMAPIP PM_getch)(void);
+    ibool   (PMAPIP PM_findBPD)(const char *dllname,char *bpdpath);
+    ulong   (PMAPIP PM_getPhysicalAddr)(void *p);
+    void    (PMAPIP PM_sleep)(ulong milliseconds);
+    int     (PMAPIP PM_getCOMPort)(int port);
+    int     (PMAPIP PM_getLPTPort)(int port);
+    PM_MODULE (PMAPIP PM_loadLibrary)(const char *szDLLName);
+    void *  (PMAPIP PM_getProcAddress)(PM_MODULE hModule,const char *szProcName);
+    void    (PMAPIP PM_freeLibrary)(PM_MODULE hModule);
+    int     (PMAPIP PCI_enumerate)(PCIDeviceInfo info[]);
+    ulong   (PMAPIP PCI_accessReg)(int index,ulong value,int func,PCIDeviceInfo *info);
+    ibool   (PMAPIP PCI_setHardwareIRQ)(PCIDeviceInfo *info,uint intPin,uint IRQ);
+    void    (PMAPIP PCI_generateSpecialCyle)(uint bus,ulong specialCycleData);
+    void *  reserved3;
+    ulong   (PMAPIP PCIBIOS_getEntry)(void);
+    uint    (PMAPIP CPU_getProcessorType)(void);
+    ibool   (PMAPIP CPU_haveMMX)(void);
+    ibool   (PMAPIP CPU_have3DNow)(void);
+    ibool   (PMAPIP CPU_haveSSE)(void);
+    ibool   (PMAPIP CPU_haveRDTSC)(void);
+    ulong   (PMAPIP CPU_getProcessorSpeed)(ibool accurate);
+    void    (PMAPIP ZTimerInit)(void);
+    void    (PMAPIP LZTimerOn)(void);
+    ulong   (PMAPIP LZTimerLap)(void);
+    void    (PMAPIP LZTimerOff)(void);
+    ulong   (PMAPIP LZTimerCount)(void);
+    void    (PMAPIP LZTimerOnExt)(LZTimerObject *tm);
+    ulong   (PMAPIP LZTimerLapExt)(LZTimerObject *tm);
+    void    (PMAPIP LZTimerOffExt)(LZTimerObject *tm);
+    ulong   (PMAPIP LZTimerCountExt)(LZTimerObject *tm);
+    void    (PMAPIP ULZTimerOn)(void);
+    ulong   (PMAPIP ULZTimerLap)(void);
+    void    (PMAPIP ULZTimerOff)(void);
+    ulong   (PMAPIP ULZTimerCount)(void);
+    ulong   (PMAPIP ULZReadTime)(void);
+    ulong   (PMAPIP ULZElapsedTime)(ulong start,ulong finish);
+    void    (PMAPIP ULZTimerResolution)(ulong *resolution);
+    void *  (PMAPIP PM_findFirstFile)(const char *filename,PM_findData *findData);
+    ibool   (PMAPIP PM_findNextFile)(void *handle,PM_findData *findData);
+    void    (PMAPIP PM_findClose)(void *handle);
+    void    (PMAPIP PM_makepath)(char *p,const char *drive,const char *dir,const char *name,const char *ext);
+    int     (PMAPIP PM_splitpath)(const char *fn,char *drive,char *dir,char *name,char *ext);
+    ibool   (PMAPIP PM_driveValid)(char drive);
+    void    (PMAPIP PM_getdcwd)(int drive,char *dir,int len);
+    void    (PMAPIP PM_setFileAttr)(const char *filename,uint attrib);
+    ibool   (PMAPIP PM_mkdir)(const char *filename);
+    ibool   (PMAPIP PM_rmdir)(const char *filename);
+    uint    (PMAPIP PM_getFileAttr)(const char *filename);
+    ibool   (PMAPIP PM_getFileTime)(const char *filename,ibool gmtTime,PM_time *time);
+    ibool   (PMAPIP PM_setFileTime)(const char *filename,ibool gmtTime,PM_time *time);
+    char *  (PMAPIP CPU_getProcessorName)(void);
+    int     (PMAPIP PM_getVGAStateSize)(void);
+    void    (PMAPIP PM_saveVGAState)(void *stateBuf);
+    void    (PMAPIP PM_restoreVGAState)(const void *stateBuf);
+    void    (PMAPIP PM_vgaBlankDisplay)(void);
+    void    (PMAPIP PM_vgaUnblankDisplay)(void);
+    void    (PMAPIP PM_blockUntilTimeout)(ulong milliseconds);
+    void    (PMAPIP _PM_add64)(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
+    void    (PMAPIP _PM_sub64)(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
+    void    (PMAPIP _PM_mul64)(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
+    void    (PMAPIP _PM_div64)(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
+    void    (PMAPIP _PM_shr64)(u32 a_low,s32 a_high,s32 shift,__i64 *result);
+    void    (PMAPIP _PM_sar64)(u32 a_low,s32 a_high,s32 shift,__i64 *result);
+    void    (PMAPIP _PM_shl64)(u32 a_low,s32 a_high,s32 shift,__i64 *result);
+    void    (PMAPIP _PM_neg64)(u32 a_low,s32 a_high,__i64 *result);
+    ulong   (PMAPIP PCI_findBARSize)(int bar,PCIDeviceInfo *pci);
+    void    (PMAPIP PCI_readRegBlock)(PCIDeviceInfo *info,int index,void *dst,int count);
+    void    (PMAPIP PCI_writeRegBlock)(PCIDeviceInfo *info,int index,void *src,int count);
+    void    (PMAPIP PM_flushTLB)(void);
+    void    (PMAPIP PM_useLocalMalloc)(void * (*malloc)(size_t size),void * (*calloc)(size_t nelem,size_t size),void * (*realloc)(void *ptr,size_t size),void (*free)(void *p));
+    void *  (PMAPIP PM_malloc)(size_t size);
+    void *  (PMAPIP PM_calloc)(size_t nelem,size_t size);
+    void *  (PMAPIP PM_realloc)(void *ptr,size_t size);
+    void    (PMAPIP PM_free)(void *p);
+    ibool   (PMAPIP PM_getPhysicalAddrRange)(void *p,ulong length,ulong *physAddress);
+    void *  (PMAPIP PM_allocPage)(ibool locked);
+    void    (PMAPIP PM_freePage)(void *p);
+    ulong   (PMAPIP PM_agpInit)(void);
+    void    (PMAPIP PM_agpExit)(void);
+    ibool   (PMAPIP PM_agpReservePhysical)(ulong numPages,int type,void **physContext,PM_physAddr *physAddr);
+    ibool   (PMAPIP PM_agpReleasePhysical)(void *physContext);
+    ibool   (PMAPIP PM_agpCommitPhysical)(void *physContext,ulong numPages,ulong startOffset,PM_physAddr *physAddr);
+    ibool   (PMAPIP PM_agpFreePhysical)(void *physContext,ulong numPages,ulong startOffset);
+    int     (PMAPIP PCI_getNumDevices)(void);
+    void    (PMAPIP PM_setLocalBPDPath)(const char *path);
+    void *  (PMAPIP PM_loadDirectDraw)(int device);
+    void    (PMAPIP PM_unloadDirectDraw)(int device);
+    PM_HWND (PMAPIP PM_getDirectDrawWindow)(void);
+    void    (PMAPIP PM_doSuspendApp)(void);
+    } PM_imports;
+
+#pragma pack()
+
+/*---------------------------- Global variables ---------------------------*/
+
+#ifdef  __cplusplus
+extern "C" {            /* Use "C" linkage when in C++ mode */
+#endif
+
+#ifdef  __WIN32_VXD__
+#define VESA_BUF_SIZE 1024
+extern uchar *_PM_rmBufAddr;
+#endif
+
+/* {secret} Pointer to global exports structure.
+ * Should not be used by application programs.
+ */
+extern PM_imports _VARAPI _PM_imports;
+
+/* {secret} */
+extern void * (*__PM_malloc)(size_t size);
+/* {secret} */
+extern void * (*__PM_calloc)(size_t nelem,size_t size);
+/* {secret} */
+extern void * (*__PM_realloc)(void *ptr,size_t size);
+/* {secret} */
+extern void (*__PM_free)(void *p);
+
+/*--------------------------- Function Prototypes -------------------------*/
+
+/* Routine to initialise the host side PM library. Note used from DLL's */
+
+void    PMAPI PM_init(void);
+
+/* Routine to return either PM_realMode, PM_286 or PM_386 */
+
+int     PMAPI PM_getModeType(void);
+
+/* Routine to return a selector to the BIOS data area at segment 0x40 */
+
+void *  PMAPI PM_getBIOSPointer(void);
+
+/* Routine to return a linear pointer to the VGA frame buffer memory */
+
+void *  PMAPI PM_getA0000Pointer(void);
+
+/* Routines to map/free physical memory into the current DS segment. In
+ * some environments (32-bit DOS is one), after the mapping has been
+ * allocated, it cannot be freed. Hence you should only allocate the
+ * mapping once and cache the value for use by other parts of your
+ * application. If the mapping cannot be createed, this function will
+ * return a NULL pointer.
+ *
+ * This routine will also work for memory addresses below 1Mb, but the
+ * mapped address cannot cross the 1Mb boundary.
+ */
+
+void *  PMAPI PM_mapPhysicalAddr(ulong base,ulong limit,ibool isCached);
+void    PMAPI PM_freePhysicalAddr(void *ptr,ulong limit);
+
+/* Routine to determine the physical address of a linear address. It is
+ * up to the caller to ensure the entire address range for a linear
+ * block of memory is page aligned if that is required.
+ */
+
+ulong   PMAPI PM_getPhysicalAddr(void *p);
+ibool   PMAPI PM_getPhysicalAddrRange(void *p,ulong length,ulong *physAddress);
+
+/* Routines for memory allocation. By default these functions use the regular
+ * C runtime library malloc/free functions, but you can use the
+ * PM_useLocalMalloc function to override the default memory allocator with
+ * your own memory allocator. This will ensure that all memory allocation
+ * used by SciTech products will use your overridden memory allocator
+ * functions.
+ *
+ * Note that BPD files automatically map the C runtime library
+ * malloc/calloc/realloc/free calls from inside the BPD to the PM library
+ * versions by default.
+ */
+
+void    PMAPI PM_useLocalMalloc(void * (*malloc)(size_t size),void * (*calloc)(size_t nelem,size_t size),void * (*realloc)(void *ptr,size_t size),void (*free)(void *p));
+void *  PMAPI PM_malloc(size_t size);
+void *  PMAPI PM_calloc(size_t nelem,size_t size);
+void *  PMAPI PM_realloc(void *ptr,size_t size);
+void    PMAPI PM_free(void *p);
+
+/* Routine to allocate a memory block in the global shared region that
+ * is common to all tasks and accessible from ring 0 code.
+ */
+
+void *  PMAPI PM_mallocShared(long size);
+
+/* Routine to free the allocated shared memory block */
+
+void    PMAPI PM_freeShared(void *ptr);
+
+/* Attach a previously allocated linear mapping to a new process */
+
+void *  PMAPI PM_mapToProcess(void *linear,ulong limit);
+
+/* Macros to extract byte, word and long values from a char pointer */
+
+#define PM_getByte(p)       *((volatile uchar*)(p))
+#define PM_getWord(p)       *((volatile ushort*)(p))
+#define PM_getLong(p)       *((volatile ulong*)(p))
+#define PM_setByte(p,v)     PM_getByte(p) = (v)
+#define PM_setWord(p,v)     PM_getWord(p) = (v)
+#define PM_setLong(p,v)     PM_getLong(p) = (v)
+
+/* Routine for accessing a low 1Mb memory block. You dont need to free this
+ * pointer, but in 16 bit protected mode the selector allocated will be
+ * re-used the next time this routine is called.
+ */
+
+void *  PMAPI PM_mapRealPointer(uint r_seg,uint r_off);
+
+/* Routine to allocate a block of conventional memory below the 1Mb
+ * limit so that it can be accessed from real mode. Ensure that you free
+ * the segment when you are done with it.
+ *
+ * This routine returns a selector and offset to the segment that has been
+ * allocated, and also returns the real mode segment and offset which can
+ * be passed to real mode routines. Will return 0 if memory could not be
+ * allocated.
+ *
+ * Please note that with some DOS extenders, memory allocated with the
+ * following function cannot be freed, hence it will be allocated for the
+ * life of your program. Thus if you need to call a bunch of different
+ * real-mode routines in your program, allocate a single large buffer at
+ * program startup that can be re-used throughout the program execution.
+ */
+
+void *  PMAPI PM_allocRealSeg(uint size,uint *r_seg,uint *r_off);
+void    PMAPI PM_freeRealSeg(void *mem);
+
+/* Routine to allocate a block of locked memory, and return both the
+ * linear and physical addresses of the memory. You should always
+ * allocate locked memory blocks in page sized chunks (ie: 4K on IA32).
+ * If the memory is not contiguous, you will need to use the
+ * PM_getPhysicalAddr function to get the physical address of linear
+ * pages within the memory block (the returned physical address will be
+ * for the first address in the memory block only).
+ */
+
+void *  PMAPI PM_allocLockedMem(uint size,ulong *physAddr,ibool contiguous,ibool below16Meg);
+void    PMAPI PM_freeLockedMem(void *p,uint size,ibool contiguous);
+
+/* Routine to allocate and free paged sized blocks of shared memory.
+ * Addressable from all processes, but not from a ring 0 context
+ * under OS/2. Note that under OS/2 PM_mapSharedPages must be called
+ * to map the memory blocks into the shared memory address space
+ * of each connecting process.
+ */
+
+void *  PMAPI PM_allocPage(ibool locked);
+void    PMAPI PM_freePage(void *p);
+#ifdef __OS2__
+void    PMAPI PM_mapSharedPages(void);
+#endif
+
+/* Routine to return true if we have access to the BIOS on the host OS */
+
+ibool   PMAPI PM_haveBIOSAccess(void);
+
+/* Routine to call a real mode assembly language procedure. Register
+ * values are passed in and out in the 'regs' and 'sregs' structures. We
+ * do not provide any method of copying data from the protected mode stack
+ * to the real mode stack, so if you need to pass data to real mode, you will
+ * need to write a real mode assembly language hook to recieve the values
+ * in registers, and to pass the data through a real mode block allocated
+ * with the PM_allocRealSeg() routine.
+ */
+
+void    PMAPI PM_callRealMode(uint seg,uint off, RMREGS *regs,RMSREGS *sregs);
+
+/* Routines to generate real mode interrupts using the same interface that
+ * is used by int86() and int86x() in realmode. This routine is need to
+ * call certain BIOS and DOS functions that are not supported by some
+ * DOS extenders. No translation is done on any of the register values,
+ * so they must be correctly set up and translated by the calling program.
+ *
+ * Normally the DOS extenders will allow you to use the normal int86()
+ * function directly and will pass on unhandled calls to real mode to be
+ * handled by the real mode handler. However calls to int86x() with real
+ * mode segment values to be loaded will cause a GPF if used with the
+ * standard int86x(), so you should use these routines if you know you
+ * want to call a real mode handler.
+ */
+
+int     PMAPI PM_int86(int intno, RMREGS *in, RMREGS *out);
+int     PMAPI PM_int86x(int intno, RMREGS *in, RMREGS *out,RMSREGS *sregs);
+
+/* Routine to generate a real mode interrupt. This is identical to the
+ * above function, but takes a DPMI_regs structure for the registers
+ * which has a lot more information. It is only available from 32-bit
+ * protected mode.
+ */
+
+void    PMAPI DPMI_int86(int intno, DPMI_regs *regs);
+
+/* Function to return the amount of available physical and total memory.
+ * The results of this function are *only* valid before you have made any
+ * calls to malloc() and free(). If you need to keep track of exactly how
+ * much memory is currently allocated, you need to call this function to
+ * get the total amount of memory available and then keep track of
+ * the available memory every time you call malloc() and free().
+ */
+
+void    PMAPI PM_availableMemory(ulong *physical,ulong *total);
+
+/* Return the address of a global VESA real mode transfer buffer for use
+ * by applications.
+ */
+
+void *  PMAPI PM_getVESABuf(uint *len,uint *rseg,uint *roff);
+
+/* Handle fatal error conditions */
+
+void    PMAPI PM_fatalError(const char *msg);
+
+/* Function to set a cleanup error handler called when PM_fatalError
+ * is called. This allows us to the console back into a normal state
+ * if we get a failure from deep inside a BPD file. This function is
+ * not exported to BPD files, and is only used by code compiled for the
+ * OS.
+ */
+
+void    PMAPI PM_setFatalErrorCleanup(PM_fatalCleanupHandler cleanup);
+
+/* Return the OS type flag as defined in <drvlib/os/os.h> */
+
+long    PMAPI PM_getOSType(void);
+
+/* Functions to set a VBE bank via an Int 10h */
+
+void    PMAPI PM_setBankA(int bank);
+void    PMAPI PM_setBankAB(int bank);
+void    PMAPI PM_setCRTStart(int x,int y,int waitVRT);
+
+/* Return the current working directory */
+
+char *  PMAPI PM_getCurrentPath(char *path,int maxLen);
+
+/* Return paths to the VBE/AF and Nucleus directories */
+
+const char * PMAPI PM_getVBEAFPath(void);
+const char * PMAPI PM_getNucleusPath(void);
+const char * PMAPI PM_getNucleusConfigPath(void);
+
+/* Find the path to a binary portable DLL */
+
+void    PMAPI PM_setLocalBPDPath(const char *path);
+ibool   PMAPI PM_findBPD(const char *dllname,char *bpdpath);
+
+/* Returns the drive letter of the boot drive for DOS, OS/2 and Windows */
+
+char    PMAPI PM_getBootDrive(void);
+
+/* Return a network unique machine identifier as a string */
+
+const char * PMAPI PM_getUniqueID(void);
+
+/* Return the network machine name as a string */
+
+const char * PMAPI PM_getMachineName(void);
+
+/* Functions to install and remove the virtual linear framebuffer
+ * emulation code. For unsupported DOS extenders and when running under
+ * a DPMI host like Windows or OS/2, this function will return a NULL.
+ */
+
+ibool   PMAPI VF_available(void);
+void *  PMAPI VF_init(ulong baseAddr,int bankSize,int codeLen,void *bankFunc);
+void    PMAPI VF_exit(void);
+
+/* Functions to wait for a keypress and read a key for command line
+ * environments such as DOS, Win32 console and Unix.
+ */
+
+int     PMAPI PM_kbhit(void);
+int     PMAPI PM_getch(void);
+
+/* Functions to create either a fullscreen or windowed console on the
+ * desktop, and to allow the resolution of fullscreen consoles to be
+ * changed on the fly without closing the console. For non-windowed
+ * environments (such as a Linux or OS/2 fullscreen console), these
+ * functions enable console graphics mode and restore console text mode.
+ *
+ * The suspend application callback is used to allow the application to
+ * save the state of the fullscreen console mode to allow temporary
+ * switching to another console or back to the regular GUI desktop. It
+ * is also called to restore the fullscreen graphics state after the
+ * fullscreen console regains the focus.
+ *
+ * The device parameter allows for the console to be opened on a different
+ * display controllers (0 is always the primary controller).
+ */
+
+PM_HWND PMAPI PM_openConsole(PM_HWND hwndUser,int device,int xRes,int yRes,int bpp,ibool fullScreen);
+int     PMAPI PM_getConsoleStateSize(void);
+void    PMAPI PM_saveConsoleState(void *stateBuf,PM_HWND hwndConsole);
+void    PMAPI PM_setSuspendAppCallback(PM_saveState_cb saveState);
+void    PMAPI PM_restoreConsoleState(const void *stateBuf,PM_HWND hwndConsole);
+void    PMAPI PM_closeConsole(PM_HWND hwndConsole);
+
+/* Functions to modify OS console information */
+
+void    PMAPI PM_setOSCursorLocation(int x,int y);
+void    PMAPI PM_setOSScreenWidth(int width,int height);
+
+/* Function to emable Intel PPro/PII write combining */
+
+int     PMAPI PM_enableWriteCombine(ulong base,ulong length,uint type);
+int     PMAPI PM_enumWriteCombine(PM_enumWriteCombine_t callback);
+
+/* Function to add a path separator to the end of a filename (if not present) */
+
+void    PMAPI PM_backslash(char *filename);
+
+/* Routines to lock and unlock regions of memory under a virtual memory
+ * environment. These routines _must_ be used to lock all hardware
+ * and mouse interrupt handlers installed, _AND_ any global data that
+ * these handler manipulate, so that they will always be present in memory
+ * to handle the incoming interrupts.
+ *
+ * Note that it is important to call the correct routine depending on
+ * whether the area being locked is code or data, so that under 32 bit
+ * PM we will get the selector value correct.
+ */
+
+int     PMAPI PM_lockDataPages(void *p,uint len,PM_lockHandle *lockHandle);
+int     PMAPI PM_unlockDataPages(void *p,uint len,PM_lockHandle *lockHandle);
+int     PMAPI PM_lockCodePages(__codePtr p,uint len,PM_lockHandle *lockHandle);
+int     PMAPI PM_unlockCodePages(__codePtr p,uint len,PM_lockHandle *lockHandle);
+
+/* Routines to install and remove Real Time Clock interrupt handlers. The
+ * frequency of the real time clock can be changed by calling
+ * PM_setRealTimeClockFrequeny, and the value can be any power of 2 value
+ * from 2Hz to 8192Hz.
+ *
+ * Note that you _must_ lock the memory containing the interrupt
+ * handlers with the PM_lockPages() function otherwise you may encounter
+ * problems in virtual memory environments.
+ *
+ * NOTE: User space versions of the PM library should fail these functions.
+ */
+
+ibool   PMAPI PM_setRealTimeClockHandler(PM_intHandler ih,int frequency);
+void    PMAPI PM_setRealTimeClockFrequency(int frequency);
+void    PMAPI PM_restoreRealTimeClockHandler(void);
+
+/* Routines to install and remove hardware interrupt handlers.
+ *
+ * Note that you _must_ lock the memory containing the interrupt
+ * handlers with the PM_lockPages() function otherwise you may encounter
+ * problems in virtual memory environments.
+ *
+ * NOTE: User space versions of the PM library should fail these functions.
+ */
+
+PM_IRQHandle PMAPI PM_setIRQHandler(int IRQ,PM_irqHandler ih);
+void    PMAPI PM_restoreIRQHandler(PM_IRQHandle irqHandle);
+
+/* Functions to program DMA using the legacy ISA DMA controller */
+
+void    PMAPI PM_DMACEnable(int channel);
+void    PMAPI PM_DMACDisable(int channel);
+void    PMAPI PM_DMACProgram(int channel,int mode,ulong bufferPhys,int count);
+ulong   PMAPI PM_DMACPosition(int channel);
+
+/* Function to post secondary graphics controllers using the BIOS */
+
+ibool   PMAPI PM_doBIOSPOST(ushort axVal,ulong BIOSPhysAddr,void *mappedBIOS,ulong BIOSLen);
+
+/* Function to init the AGP functions and return the AGP aperture size in MB */
+
+ulong   PMAPI PM_agpInit(void);
+void    PMAPI PM_agpExit(void);
+
+/* Functions to reserve and release physical AGP memory ranges */
+
+ibool   PMAPI PM_agpReservePhysical(ulong numPages,int type,void **physContext,PM_physAddr *physAddr);
+ibool   PMAPI PM_agpReleasePhysical(void *physContext);
+
+/* Functions to commit and free physical AGP memory ranges */
+
+ibool   PMAPI PM_agpCommitPhysical(void *physContext,ulong numPages,ulong startOffset,PM_physAddr *physAddr);
+ibool   PMAPI PM_agpFreePhysical(void *physContext,ulong numPages,ulong startOffset);
+
+/* Functions to do I/O port manipulation directly from C code. These
+ * functions are portable and will work on any processor architecture
+ * to access I/O space registers on PCI devices.
+ */
+
+uchar   PMAPI PM_inpb(int port);
+ushort  PMAPI PM_inpw(int port);
+ulong   PMAPI PM_inpd(int port);
+void    PMAPI PM_outpb(int port,uchar val);
+void    PMAPI PM_outpw(int port,ushort val);
+void    PMAPI PM_outpd(int port,ulong val);
+
+/* Functions to determine the I/O port locations for COM and LPT ports.
+ * The functions are zero based, so for COM1 or LPT1 pass in a value of 0,
+ * for COM2 or LPT2 pass in a value of 1 etc.
+ */
+
+int     PMAPI PM_getCOMPort(int port);
+int     PMAPI PM_getLPTPort(int port);
+
+/* Internal functions that need prototypes */
+
+void    PMAPI _PM_getRMvect(int intno, long *realisr);
+void    PMAPI _PM_setRMvect(int intno, long realisr);
+void    PMAPI _PM_freeMemoryMappings(void);
+
+/* Function to override the default debug log file location */
+
+void    PMAPI PM_setDebugLog(const char *logFilePath);
+
+/* Function to put the process to sleep for the specified milliseconds */
+
+void    PMAPI PM_sleep(ulong milliseconds);
+
+/* Function to block until 'milliseconds' have passed since last call */
+
+void    PMAPI PM_blockUntilTimeout(ulong milliseconds);
+
+/* Functions for directory traversal and management */
+
+void *  PMAPI PM_findFirstFile(const char *filename,PM_findData *findData);
+ibool   PMAPI PM_findNextFile(void *handle,PM_findData *findData);
+void    PMAPI PM_findClose(void *handle);
+void    PMAPI PM_makepath(char *p,const char *drive,const char *dir,const char *name,const char *ext);
+int     PMAPI PM_splitpath(const char *fn,char *drive,char *dir,char *name,char *ext);
+ibool   PMAPI PM_driveValid(char drive);
+void    PMAPI PM_getdcwd(int drive,char *dir,int len);
+uint    PMAPI PM_getFileAttr(const char *filename);
+void    PMAPI PM_setFileAttr(const char *filename,uint attrib);
+ibool   PMAPI PM_getFileTime(const char *filename,ibool gmTime,PM_time *time);
+ibool   PMAPI PM_setFileTime(const char *filename,ibool gmTime,PM_time *time);
+ibool   PMAPI PM_mkdir(const char *filename);
+ibool   PMAPI PM_rmdir(const char *filename);
+
+/* Functions to handle loading OS specific shared libraries */
+
+PM_MODULE PMAPI PM_loadLibrary(const char *szDLLName);
+void *  PMAPI PM_getProcAddress(PM_MODULE hModule,const char *szProcName);
+void    PMAPI PM_freeLibrary(PM_MODULE hModule);
+
+/* Functions and macros for 64-bit arithmetic */
+
+void    PMAPI _PM_add64(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
+void    PMAPI _PM_sub64(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
+void    PMAPI _PM_mul64(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
+void    PMAPI _PM_div64(u32 a_low,s32 a_high,u32 b_low,s32 b_high,__i64 *result);
+void    PMAPI _PM_shr64(u32 a_low,s32 a_high,s32 shift,__i64 *result);
+void    PMAPI _PM_sar64(u32 a_low,s32 a_high,s32 shift,__i64 *result);
+void    PMAPI _PM_shl64(u32 a_low,s32 a_high,s32 shift,__i64 *result);
+void    PMAPI _PM_neg64(u32 a_low,s32 a_high,__i64 *result);
+#ifdef __NATIVE_INT64__
+#define PM_add64(r,a,b)     (r) = (a) + (b)
+#define PM_add64_32(r,a,b)  (r) = (a) + (b)
+#define PM_sub64(r,a,b)     (r) = (a) - (b)
+#define PM_sub64_32(r,a,b)  (r) = (a) - (b)
+#define PM_mul64(r,a,b)     (r) = (a) * (b)
+#define PM_mul64_32(r,a,b)  (r) = (a) * (b)
+#define PM_div64(r,a,b)     (r) = (a) / (b)
+#define PM_div64_32(r,a,b)  (r) = (a) / (b)
+#define PM_shr64(r,a,s)     (r) = (a) >> (s)
+#define PM_sar64(r,a,s)     (r) = ((s64)(a)) >> (s)
+#define PM_shl64(r,a,s)     (r) = (u64)(a) << (s)
+#define PM_neg64(r,a,s)     (r) = -(a)
+#define PM_not64(r,a,s)     (r) = ~(a)
+#define PM_eq64(a,b)        (a) == (b)
+#define PM_gt64(a,b)        (a) > (b)
+#define PM_lt64(a,b)        (a) < (b)
+#define PM_geq64(a,b)       (a) >= (b)
+#define PM_leq64(a,b)       (a) <= (b)
+#define PM_64to32(a)        (u32)(a)
+#define PM_64tos32(a)       (s32)(a)
+#define PM_set64(a,b,c)     (a) = ((u64)(b) << 32) + (c)
+#define PM_set64_32(a,b)    (a) = (b)
+#else
+#define PM_add64(r,a,b)     _PM_add64((a).low,(a).high,(b).low,(b).high,&(r))
+#define PM_add64_32(r,a,b)  _PM_add64((a).low,(a).high,b,0,&(r))
+#define PM_sub64(r,a,b)     _PM_sub64((a).low,(a).high,(b).low,(b).high,&(r))
+#define PM_sub64_32(r,a,b)  _PM_sub64((a).low,(a).high,b,0,&(r))
+#define PM_mul64(r,a,b)     _PM_mul64((a).low,(a).high,(b).low,(b).high,&(r))
+#define PM_mul64_32(r,a,b)  _PM_mul64((a).low,(a).high,b,0,&(r))
+#define PM_div64(r,a,b)     _PM_div64((a).low,(a).high,(b).low,(b).high,&(r))
+#define PM_div64_32(r,a,b)  _PM_div64((a).low,(a).high,b,0,&(r))
+#define PM_shr64(r,a,s)     _PM_shr64((a).low,(a).high,s,&(r))
+#define PM_sar64(r,a,s)     _PM_sar64((a).low,(a).high,s,&(r))
+#define PM_shl64(r,a,s)     _PM_shl64((a).low,(a).high,s,&(r))
+#define PM_neg64(r,a,s)     _PM_neg64((a).low,(a).high,&(r))
+#define PM_not64(r,a,s)     (r).low = ~(a).low, (r).high = ~(a).high
+#define PM_eq64(a,b)        ((a).low == (b).low && (a).high == (b).high)
+#define PM_gt64(a,b)        (((a).high > (b).high) || ((a).high == (b).high && (a).low > (b).low))
+#define PM_lt64(a,b)        (((a).high < (b).high) || ((a).high == (b).high && (a).low < (b).low))
+#define PM_geq64(a,b)       (PM_eq64(a,b) || PM_gt64(a,b))
+#define PM_leq64(a,b)       (PM_eq64(a,b) || PM_lt64(a,b))
+#define PM_64to32(a)        (u32)(a.low)
+#define PM_64tos32(a)       ((a).high < 0) ? -(a).low : (a).low)
+#define PM_set64(a,b,c)     (a).high = (b), (a).low = (c)
+#define PM_set64_32(a,b)    (a).high = 0, (a).low = (b)
+#endif
+
+/* Function to enable IOPL access if required */
+
+int     PMAPI PM_setIOPL(int iopl);
+
+/* Function to flush the TLB and CPU caches */
+
+void    PMAPI PM_flushTLB(void);
+
+/* DOS specific fucntions */
+
+#ifdef  __MSDOS__
+uint    PMAPI PMHELP_getVersion(void);
+void    PMAPI PM_VxDCall(VXD_regs *regs);
+#endif
+
+/* Functions to save and restore the VGA hardware state */
+
+int     PMAPI PM_getVGAStateSize(void);
+void    PMAPI PM_saveVGAState(void *stateBuf);
+void    PMAPI PM_restoreVGAState(const void *stateBuf);
+void    PMAPI PM_vgaBlankDisplay(void);
+void    PMAPI PM_vgaUnblankDisplay(void);
+
+/* Functions to load and unload DirectDraw libraries. Only used on
+ * Windows platforms.
+ */
+
+void *  PMAPI PM_loadDirectDraw(int device);
+void    PMAPI PM_unloadDirectDraw(int device);
+PM_HWND PMAPI PM_getDirectDrawWindow(void);
+void    PMAPI PM_doSuspendApp(void);
+
+/* Functions to install, start, stop and remove NT services. Valid only
+ * for Win32 apps running on Windows NT.
+ */
+
+#ifdef __WINDOWS32__
+ulong   PMAPI PM_installService(const char *szDriverName,const char *szServiceName,const char *szLoadGroup,ulong dwServiceType);
+ulong   PMAPI PM_startService(const char *szServiceName);
+ulong   PMAPI PM_stopService(const char *szServiceName);
+ulong   PMAPI PM_removeService(const char *szServiceName);
+#endif
+
+/* Routines to generate native interrupts (ie: protected mode interrupts
+ * for protected mode apps) using an interface the same as that use by
+ * int86() and int86x() in realmode. These routines are required because
+ * many 32 bit compilers use different register structures and different
+ * functions causing major portability headaches. Thus we provide our
+ * own and solve it all in one fell swoop, and we also get a routine to
+ * put stuff into 32 bit registers from real mode ;-)
+ */
+
+void    PMAPI PM_segread(PMSREGS *sregs);
+int     PMAPI PM_int386(int intno, PMREGS *in, PMREGS *out);
+int     PMAPI PM_int386x(int intno, PMREGS *in, PMREGS *out,PMSREGS *sregs);
+
+/* Call the X86 emulator or the real BIOS in our test harness */
+
+#if defined(TEST_HARNESS) && !defined(PMLIB)
+#define PM_mapRealPointer(r_seg,r_off)      _PM_imports.PM_mapRealPointer(r_seg,r_off)
+#define PM_getVESABuf(len,rseg,roff)        _PM_imports.PM_getVESABuf(len,rseg,roff)
+#define PM_callRealMode(seg,off,regs,sregs) _PM_imports.PM_callRealMode(seg,off,regs,sregs)
+#define PM_int86(intno,in,out)              _PM_imports.PM_int86(intno,in,out)
+#define PM_int86x(intno,in,out,sregs)       _PM_imports.PM_int86x(intno,in,out,sregs)
+#endif
+
+#ifdef  __cplusplus
+}                       /* End of "C" linkage for C++   */
+#endif
+
+/* Include OS extensions for interrupt handling */
+
+#if defined(__REALDOS__) || defined(__SMX32__)
+#include "pmint.h"
+#endif
+
+#endif /* __PMAPI_H */
+