board/MAI/bios_emulator/scitech/include/pmapi.h

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