mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-25 20:43:32 +00:00
c7de829c79
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.
1149 lines
45 KiB
C
1149 lines
45 KiB
C
/****************************************************************************
|
|
*
|
|
* 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 */
|
|
|