/**************************************************************************** * * 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: 16/32 bit DOS * * Description: Implementation for the OS Portability Manager Library, which * contains functions to implement OS specific services in a * generic, cross platform API. Porting the OS Portability * Manager library is the first step to porting any SciTech * products to a new platform. * ****************************************************************************/ #include "pmapi.h" #include "drvlib/os/os.h" #include "ztimerc.h" #include "mtrr.h" #include "pm_help.h" #include #include #include #include #include #ifdef __GNUC__ #include #include #include #else #include #endif #ifdef __BORLANDC__ #pragma warn -par #endif /*--------------------------- Global variables ----------------------------*/ typedef struct { int oldMode; int old50Lines; } DOS_stateBuf; #define MAX_RM_BLOCKS 10 static struct { void *p; uint tag; } rmBlocks[MAX_RM_BLOCKS]; static uint VESABuf_len = 1024; /* Length of the VESABuf buffer */ static void *VESABuf_ptr = NULL; /* Near pointer to VESABuf */ static uint VESABuf_rseg; /* Real mode segment of VESABuf */ static uint VESABuf_roff; /* Real mode offset of VESABuf */ static void (PMAPIP fatalErrorCleanup)(void) = NULL; ushort _VARAPI _PM_savedDS = 0; #ifdef DOS4GW static ulong PDB = 0,*pPDB = NULL; #endif #ifndef REALMODE static char VXD_name[] = PMHELP_NAME; static char VXD_module[] = PMHELP_MODULE; static char VXD_DDBName[] = PMHELP_DDBNAME; static uint VXD_version = -1; static uint VXD_loadOff = 0; static uint VXD_loadSel = 0; uint _VARAPI _PM_VXD_off = 0; uint _VARAPI _PM_VXD_sel = 0; int _VARAPI _PM_haveCauseWay = -1; /* Memory mapping cache */ #define MAX_MEMORY_MAPPINGS 100 typedef struct { ulong physical; ulong linear; ulong limit; } mmapping; static mmapping maps[MAX_MEMORY_MAPPINGS] = {0}; static int numMaps = 0; /* Page sized block cache */ #define PAGES_PER_BLOCK 100 #define FREELIST_NEXT(p) (*(void**)(p)) typedef struct pageblock { struct pageblock *next; struct pageblock *prev; void *freeListStart; void *freeList; void *freeListEnd; int freeCount; } pageblock; static pageblock *pageBlocks = NULL; #endif /* Start of all page tables in CauseWay */ #define CW_PAGE_TABLE_START (1024UL*4096UL*1023UL) /*----------------------------- Implementation ----------------------------*/ /* External assembler functions */ ulong _ASMAPI _PM_getPDB(void); int _ASMAPI _PM_pagingEnabled(void); void _ASMAPI _PM_VxDCall(VXD_regs *regs,uint off,uint sel); #ifndef REALMODE /**************************************************************************** REMARKS: Exit function to unload the dynamically loaded VxD ****************************************************************************/ static void UnloadVxD(void) { PMSREGS sregs; VXD_regs r; r.eax = 2; r.ebx = 0; r.edx = (uint)VXD_module; PM_segread(&sregs); #ifdef __16BIT__ r.ds = ((ulong)VXD_module) >> 16; #else r.ds = sregs.ds; #endif r.es = sregs.es; _PM_VxDCall(&r,VXD_loadOff,VXD_loadSel); } /**************************************************************************** REMARKS: External function to call the PMHELP helper VxD. ****************************************************************************/ void PMAPI PM_VxDCall( VXD_regs *regs) { if (_PM_VXD_sel != 0 || _PM_VXD_off != 0) _PM_VxDCall(regs,_PM_VXD_off,_PM_VXD_sel); } /**************************************************************************** RETURNS: BCD coded version number of the VxD, or 0 if not loaded (ie: 0x202 - 2.2) REMARKS: This function gets the version number for the VxD that we have connected to. ****************************************************************************/ uint PMAPI PMHELP_getVersion(void) { VXD_regs r; /* Call the helper VxD to determine the version number */ if (_PM_VXD_sel != 0 || _PM_VXD_off != 0) { memset(&r,0,sizeof(r)); r.eax = API_NUM(PMHELP_GETVER); _PM_VxDCall(&r,_PM_VXD_off,_PM_VXD_sel); return VXD_version = (uint)r.eax; } return VXD_version = 0; } /**************************************************************************** DESCRIPTION: Connects to the helper VxD and returns the version number RETURNS: True if the VxD was found and loaded, false otherwise. REMARKS: This function connects to the VxD (loading it if it is dynamically loadable) and returns the version number of the VxD. ****************************************************************************/ static ibool PMHELP_connect(void) { PMREGS regs; PMSREGS sregs; VXD_regs r; /* Bail early if we have alread connected */ if (VXD_version != -1) return VXD_version != 0; /* Get the static SDDHELP.VXD entry point if available */ PM_segread(&sregs); regs.x.ax = 0x1684; regs.x.bx = SDDHELP_DeviceID; regs.x.di = 0; sregs.es = 0; PM_int386x(0x2F,®s,®s,&sregs); _PM_VXD_sel = sregs.es; _PM_VXD_off = regs.x.di; if (_PM_VXD_sel != 0 || _PM_VXD_off != 0) { if (PMHELP_getVersion() >= PMHELP_VERSION) return true; } /* If we get here, then either SDDHELP.VXD is not loaded, or it is an * earlier version. In this case try to dynamically load the PMHELP.VXD * helper VxD instead. */ PM_segread(&sregs); regs.x.ax = 0x1684; regs.x.bx = VXDLDR_DeviceID; regs.x.di = 0; sregs.es = 0; PM_int386x(0x2F,®s,®s,&sregs); VXD_loadSel = sregs.es; VXD_loadOff = regs.x.di; if (VXD_loadSel == 0 && VXD_loadOff == 0) return VXD_version = 0; r.eax = 1; r.ebx = 0; r.edx = (uint)VXD_name; PM_segread(&sregs); r.ds = sregs.ds; r.es = sregs.es; _PM_VxDCall(&r,VXD_loadOff,VXD_loadSel); if (r.eax != 0) return VXD_version = 0; /* Get the dynamic VxD entry point so we can call it */ atexit(UnloadVxD); PM_segread(&sregs); regs.x.ax = 0x1684; regs.x.bx = 0; regs.e.edi = (uint)VXD_DDBName; PM_int386x(0x2F,®s,®s,&sregs); _PM_VXD_sel = sregs.es; _PM_VXD_off = regs.x.di; if (_PM_VXD_sel == 0 && _PM_VXD_off == 0) return VXD_version = 0; if (PMHELP_getVersion() >= PMHELP_VERSION) return true; return VXD_version = 0; } #endif /**************************************************************************** REMARKS: Initialise the PM library. First we try to connect to a static SDDHELP.VXD helper VxD, and check that it is a version we can use. If not we try to dynamically load the PMHELP.VXD helper VxD ****************************************************************************/ void PMAPI PM_init(void) { #ifndef REALMODE PMREGS regs; /* Check if we are running under CauseWay under real DOS */ if (_PM_haveCauseWay == -1) { /* Check if we are running under DPMI in which case we will not be * able to use our special ring 0 CauseWay functions. */ _PM_haveCauseWay = false; regs.x.ax = 0xFF00; PM_int386(0x31,®s,®s); if (regs.x.cflag || !(regs.e.edi & 8)) { /* We are not under DPMI, so now check if CauseWay is active */ regs.x.ax = 0xFFF9; PM_int386(0x31,®s,®s); if (!regs.x.cflag && regs.e.ecx == 0x43415553 && regs.e.edx == 0x45574159) _PM_haveCauseWay = true; } /* Now connect to PMHELP.VXD and initialise MTRR module */ if (!PMHELP_connect()) MTRR_init(); } #endif } /**************************************************************************** PARAMETERS: base - The starting physical base address of the region size - The size in bytes of the region type - Type to place into the MTRR register RETURNS: Error code describing the result. REMARKS: Function to enable write combining for the specified region of memory. ****************************************************************************/ int PMAPI PM_enableWriteCombine( ulong base, ulong size, uint type) { #ifndef REALMODE VXD_regs regs; if (PMHELP_connect()) { memset(®s,0,sizeof(regs)); regs.eax = API_NUM(PMHELP_ENABLELFBCOMB); regs.ebx = base; regs.ecx = size; regs.edx = type; _PM_VxDCall(®s,_PM_VXD_off,_PM_VXD_sel); return regs.eax; } return MTRR_enableWriteCombine(base,size,type); #else return PM_MTRR_NOT_SUPPORTED; #endif } ibool PMAPI PM_haveBIOSAccess(void) { return true; } long PMAPI PM_getOSType(void) { return _OS_DOS; } int PMAPI PM_getModeType(void) { #if defined(REALMODE) return PM_realMode; #elif defined(PM286) return PM_286; #elif defined(PM386) return PM_386; #endif } void PMAPI PM_backslash(char *s) { uint pos = strlen(s); if (s[pos-1] != '\\') { s[pos] = '\\'; s[pos+1] = '\0'; } } void PMAPI PM_setFatalErrorCleanup( void (PMAPIP cleanup)(void)) { fatalErrorCleanup = cleanup; } void PMAPI PM_fatalError(const char *msg) { if (fatalErrorCleanup) fatalErrorCleanup(); fprintf(stderr,"%s\n", msg); exit(1); } static void ExitVBEBuf(void) { if (VESABuf_ptr) PM_freeRealSeg(VESABuf_ptr); VESABuf_ptr = 0; } void * PMAPI PM_getVESABuf(uint *len,uint *rseg,uint *roff) { if (!VESABuf_ptr) { /* Allocate a global buffer for communicating with the VESA VBE */ if ((VESABuf_ptr = PM_allocRealSeg(VESABuf_len, &VESABuf_rseg, &VESABuf_roff)) == NULL) return NULL; atexit(ExitVBEBuf); } *len = VESABuf_len; *rseg = VESABuf_rseg; *roff = VESABuf_roff; return VESABuf_ptr; } int PMAPI PM_int386(int intno, PMREGS *in, PMREGS *out) { PMSREGS sregs; PM_segread(&sregs); return PM_int386x(intno,in,out,&sregs); } /* Routines to set and get the real mode interrupt vectors, by making * direct real mode calls to DOS and bypassing the DOS extenders API. * This is the safest way to handle this, as some servers try to be * smart about changing real mode vectors. */ void PMAPI _PM_getRMvect(int intno, long *realisr) { RMREGS regs; RMSREGS sregs; PM_saveDS(); regs.h.ah = 0x35; regs.h.al = intno; PM_int86x(0x21, ®s, ®s, &sregs); *realisr = ((long)sregs.es << 16) | regs.x.bx; } void PMAPI _PM_setRMvect(int intno, long realisr) { RMREGS regs; RMSREGS sregs; PM_saveDS(); regs.h.ah = 0x25; regs.h.al = intno; sregs.ds = (int)(realisr >> 16); regs.x.dx = (int)(realisr & 0xFFFF); PM_int86x(0x21, ®s, ®s, &sregs); } void PMAPI _PM_addRealModeBlock(void *mem,uint tag) { int i; for (i = 0; i < MAX_RM_BLOCKS; i++) { if (rmBlocks[i].p == NULL) { rmBlocks[i].p = mem; rmBlocks[i].tag = tag; return; } } PM_fatalError("To many real mode memory block allocations!"); } uint PMAPI _PM_findRealModeBlock(void *mem) { int i; for (i = 0; i < MAX_RM_BLOCKS; i++) { if (rmBlocks[i].p == mem) return rmBlocks[i].tag; } PM_fatalError("Could not find prior real mode memory block allocation!"); return 0; } char * PMAPI PM_getCurrentPath( char *path, int maxLen) { return getcwd(path,maxLen); } char PMAPI PM_getBootDrive(void) { return 'C'; } const char * PMAPI PM_getVBEAFPath(void) { return "c:\\"; } const char * PMAPI PM_getNucleusPath(void) { static char path[256]; char *env; if ((env = getenv("NUCLEUS_PATH")) != NULL) return env; if ((env = getenv("WINBOOTDIR")) != NULL) { /* Running in a Windows 9x DOS box or DOS mode */ strcpy(path,env); strcat(path,"\\system\\nucleus"); return path; } if ((env = getenv("SystemRoot")) != NULL) { /* Running in an NT/2K DOS box */ strcpy(path,env); strcat(path,"\\system32\\nucleus"); return path; } return "c:\\nucleus"; } const char * PMAPI PM_getNucleusConfigPath(void) { static char path[256]; strcpy(path,PM_getNucleusPath()); PM_backslash(path); strcat(path,"config"); return path; } const char * PMAPI PM_getUniqueID(void) { return "DOS"; } const char * PMAPI PM_getMachineName(void) { return "DOS"; } int PMAPI PM_kbhit(void) { return kbhit(); } int PMAPI PM_getch(void) { return getch(); } PM_HWND PMAPI PM_openConsole(PM_HWND hwndUser,int device,int xRes,int yRes,int bpp,ibool fullScreen) { /* Not used for DOS */ (void)hwndUser; (void)device; (void)xRes; (void)yRes; (void)bpp; (void)fullScreen; return 0; } int PMAPI PM_getConsoleStateSize(void) { return sizeof(DOS_stateBuf); } void PMAPI PM_saveConsoleState(void *stateBuf,PM_HWND hwndConsole) { RMREGS regs; DOS_stateBuf *sb = stateBuf; /* Save the old video mode state */ regs.h.ah = 0x0F; PM_int86(0x10,®s,®s); sb->oldMode = regs.h.al & 0x7F; sb->old50Lines = false; if (sb->oldMode == 0x3) { regs.x.ax = 0x1130; regs.x.bx = 0; regs.x.dx = 0; PM_int86(0x10,®s,®s); sb->old50Lines = (regs.h.dl == 42 || regs.h.dl == 49); } (void)hwndConsole; } void PMAPI PM_setSuspendAppCallback(int (_ASMAPIP saveState)(int flags)) { /* Not used for DOS */ (void)saveState; } void PMAPI PM_restoreConsoleState(const void *stateBuf,PM_HWND hwndConsole) { RMREGS regs; const DOS_stateBuf *sb = stateBuf; /* Retore 50 line mode if set */ if (sb->old50Lines) { regs.x.ax = 0x1112; regs.x.bx = 0; PM_int86(0x10,®s,®s); } (void)hwndConsole; } void PMAPI PM_closeConsole(PM_HWND hwndConsole) { /* Not used for DOS */ (void)hwndConsole; } void PMAPI PM_setOSCursorLocation(int x,int y) { uchar *_biosPtr = PM_getBIOSPointer(); PM_setByte(_biosPtr+0x50,x); PM_setByte(_biosPtr+0x51,y); } void PMAPI PM_setOSScreenWidth(int width,int height) { uchar *_biosPtr = PM_getBIOSPointer(); PM_setWord(_biosPtr+0x4A,width); PM_setWord(_biosPtr+0x4C,width*2); PM_setByte(_biosPtr+0x84,height-1); if (height > 25) { PM_setWord(_biosPtr+0x60,0x0607); PM_setByte(_biosPtr+0x85,0x08); } else { PM_setWord(_biosPtr+0x60,0x0D0E); PM_setByte(_biosPtr+0x85,0x016); } } void * PMAPI PM_mallocShared(long size) { return PM_malloc(size); } void PMAPI PM_freeShared(void *ptr) { PM_free(ptr); } #define GetRMVect(intno,isr) *(isr) = ((ulong*)rmZeroPtr)[intno] #define SetRMVect(intno,isr) ((ulong*)rmZeroPtr)[intno] = (isr) ibool PMAPI PM_doBIOSPOST( ushort axVal, ulong BIOSPhysAddr, void *mappedBIOS, ulong BIOSLen) { static int firstTime = true; static uchar *rmZeroPtr; long Current10,Current6D,Current42; RMREGS regs; RMSREGS sregs; /* Create a zero memory mapping for us to use */ if (firstTime) { rmZeroPtr = PM_mapPhysicalAddr(0,0x7FFF,true); firstTime = false; } /* Remap the secondary BIOS to 0xC0000 physical */ if (BIOSPhysAddr != 0xC0000L || BIOSLen > 32768) { /* DOS cannot virtually remap the BIOS, so we can only work if all * the secondary controllers are identical, and we then use the * BIOS on the first controller for all the remaining controllers. * * For OS'es that do virtual memory, and remapping of 0xC0000 * physical (perhaps a copy on write mapping) should be all that * is needed. */ return false; } /* Save current handlers of int 10h and 6Dh */ GetRMVect(0x10,&Current10); GetRMVect(0x6D,&Current6D); /* POST the secondary BIOS */ GetRMVect(0x42,&Current42); SetRMVect(0x10,Current42); /* Restore int 10h to STD-BIOS */ regs.x.ax = axVal; PM_callRealMode(0xC000,0x0003,®s,&sregs); /* Restore current handlers */ SetRMVect(0x10,Current10); SetRMVect(0x6D,Current6D); /* Second the primary BIOS mappin 1:1 for 0xC0000 physical */ if (BIOSPhysAddr != 0xC0000L) { /* DOS does not support this */ (void)mappedBIOS; } return true; } void PMAPI PM_sleep(ulong milliseconds) { ulong microseconds = milliseconds * 1000L; LZTimerObject tm; LZTimerOnExt(&tm); while (LZTimerLapExt(&tm) < microseconds) ; LZTimerOffExt(&tm); } int PMAPI PM_getCOMPort(int port) { switch (port) { case 0: return 0x3F8; case 1: return 0x2F8; } return 0; } int PMAPI PM_getLPTPort(int port) { switch (port) { case 0: return 0x3BC; case 1: return 0x378; case 2: return 0x278; } return 0; } PM_MODULE PMAPI PM_loadLibrary( const char *szDLLName) { (void)szDLLName; return NULL; } void * PMAPI PM_getProcAddress( PM_MODULE hModule, const char *szProcName) { (void)hModule; (void)szProcName; return NULL; } void PMAPI PM_freeLibrary( PM_MODULE hModule) { (void)hModule; } int PMAPI PM_setIOPL( int level) { return level; } /**************************************************************************** REMARKS: Internal function to convert the find data to the generic interface. ****************************************************************************/ static void convertFindData( PM_findData *findData, struct find_t *blk) { ulong dwSize = findData->dwSize; memset(findData,0,findData->dwSize); findData->dwSize = dwSize; if (blk->attrib & _A_RDONLY) findData->attrib |= PM_FILE_READONLY; if (blk->attrib & _A_SUBDIR) findData->attrib |= PM_FILE_DIRECTORY; if (blk->attrib & _A_ARCH) findData->attrib |= PM_FILE_ARCHIVE; if (blk->attrib & _A_HIDDEN) findData->attrib |= PM_FILE_HIDDEN; if (blk->attrib & _A_SYSTEM) findData->attrib |= PM_FILE_SYSTEM; findData->sizeLo = blk->size; strncpy(findData->name,blk->name,PM_MAX_PATH); findData->name[PM_MAX_PATH-1] = 0; } #define FIND_MASK (_A_RDONLY | _A_ARCH | _A_SUBDIR | _A_HIDDEN | _A_SYSTEM) /**************************************************************************** REMARKS: Function to find the first file matching a search criteria in a directory. ****************************************************************************/ void * PMAPI PM_findFirstFile( const char *filename, PM_findData *findData) { struct find_t *blk; if ((blk = PM_malloc(sizeof(*blk))) == NULL) return PM_FILE_INVALID; if (_dos_findfirst((char*)filename,FIND_MASK,blk) == 0) { convertFindData(findData,blk); return blk; } return PM_FILE_INVALID; } /**************************************************************************** REMARKS: Function to find the next file matching a search criteria in a directory. ****************************************************************************/ ibool PMAPI PM_findNextFile( void *handle, PM_findData *findData) { struct find_t *blk = handle; if (_dos_findnext(blk) == 0) { convertFindData(findData,blk); return true; } return false; } /**************************************************************************** REMARKS: Function to close the find process ****************************************************************************/ void PMAPI PM_findClose( void *handle) { PM_free(handle); } /**************************************************************************** REMARKS: Function to determine if a drive is a valid drive or not. Under Unix this function will return false for anything except a value of 3 (considered the root drive, and equivalent to C: for non-Unix systems). The drive numbering is: 1 - Drive A: 2 - Drive B: 3 - Drive C: etc ****************************************************************************/ ibool PMAPI PM_driveValid( char drive) { RMREGS regs; regs.h.dl = (uchar)(drive - 'A' + 1); regs.h.ah = 0x36; // Get disk information service PM_int86(0x21,®s,®s); return regs.x.ax != 0xFFFF; // AX = 0xFFFF if disk is invalid } /**************************************************************************** REMARKS: Function to get the current working directory for the specififed drive. Under Unix this will always return the current working directory regardless of what the value of 'drive' is. ****************************************************************************/ void PMAPI PM_getdcwd( int drive, char *dir, int len) { uint oldDrive,maxDrives; _dos_getdrive(&oldDrive); _dos_setdrive(drive,&maxDrives); getcwd(dir,len); _dos_setdrive(oldDrive,&maxDrives); } /**************************************************************************** REMARKS: Function to change the file attributes for a specific file. ****************************************************************************/ void PMAPI PM_setFileAttr( const char *filename, uint attrib) { #if defined(TNT) && defined(_MSC_VER) DWORD attr = 0; if (attrib & PM_FILE_READONLY) attr |= FILE_ATTRIBUTE_READONLY; if (attrib & PM_FILE_ARCHIVE) attr |= FILE_ATTRIBUTE_ARCHIVE; if (attrib & PM_FILE_HIDDEN) attr |= FILE_ATTRIBUTE_HIDDEN; if (attrib & PM_FILE_SYSTEM) attr |= FILE_ATTRIBUTE_SYSTEM; SetFileAttributes((LPSTR)filename, attr); #else uint attr = 0; if (attrib & PM_FILE_READONLY) attr |= _A_RDONLY; if (attrib & PM_FILE_ARCHIVE) attr |= _A_ARCH; if (attrib & PM_FILE_HIDDEN) attr |= _A_HIDDEN; if (attrib & PM_FILE_SYSTEM) attr |= _A_SYSTEM; _dos_setfileattr(filename,attr); #endif } /**************************************************************************** REMARKS: Function to create a directory. ****************************************************************************/ ibool PMAPI PM_mkdir( const char *filename) { #ifdef __GNUC__ return mkdir(filename,S_IRUSR) == 0; #else return mkdir(filename) == 0; #endif } /**************************************************************************** REMARKS: Function to remove a directory. ****************************************************************************/ ibool PMAPI PM_rmdir( const char *filename) { return rmdir(filename) == 0; } /*-------------------------------------------------------------------------*/ /* Generic DPMI routines common to 16/32 bit code */ /*-------------------------------------------------------------------------*/ #ifndef REALMODE ulong PMAPI DPMI_mapPhysicalToLinear(ulong physAddr,ulong limit) { PMREGS r; int i; ulong baseAddr,baseOfs,roundedLimit; /* We can't map memory below 1Mb, but the linear address are already * mapped 1:1 for this memory anyway so we just return the base address. */ if (physAddr < 0x100000L) return physAddr; /* Search table of existing mappings to see if we have already mapped * a region of memory that will serve this purpose. We do this because * DPMI 0.9 does not allow us to free physical memory mappings, and if * the mappings get re-used in the program we want to avoid allocating * more mappings than necessary. */ for (i = 0; i < numMaps; i++) { if (maps[i].physical == physAddr && maps[i].limit == limit) return maps[i].linear; } /* Find a free slot in our physical memory mapping table */ for (i = 0; i < numMaps; i++) { if (maps[i].limit == 0) break; } if (i == numMaps) { i = numMaps++; if (i == MAX_MEMORY_MAPPINGS) return NULL; } /* Round the physical address to a 4Kb boundary and the limit to a * 4Kb-1 boundary before passing the values to DPMI as some extenders * will fail the calls unless this is the case. If we round the * physical address, then we also add an extra offset into the address * that we return. */ baseOfs = physAddr & 4095; baseAddr = physAddr & ~4095; roundedLimit = ((limit+baseOfs+1+4095) & ~4095)-1; r.x.ax = 0x800; r.x.bx = baseAddr >> 16; r.x.cx = baseAddr & 0xFFFF; r.x.si = roundedLimit >> 16; r.x.di = roundedLimit & 0xFFFF; PM_int386(0x31, &r, &r); if (r.x.cflag) return 0xFFFFFFFFUL; maps[i].physical = physAddr; maps[i].limit = limit; maps[i].linear = ((ulong)r.x.bx << 16) + r.x.cx + baseOfs; return maps[i].linear; } int PMAPI DPMI_setSelectorBase(ushort sel,ulong linAddr) { PMREGS r; r.x.ax = 7; /* DPMI set selector base address */ r.x.bx = sel; r.x.cx = linAddr >> 16; r.x.dx = linAddr & 0xFFFF; PM_int386(0x31, &r, &r); if (r.x.cflag) return 0; return 1; } ulong PMAPI DPMI_getSelectorBase(ushort sel) { PMREGS r; r.x.ax = 6; /* DPMI get selector base address */ r.x.bx = sel; PM_int386(0x31, &r, &r); return ((ulong)r.x.cx << 16) + r.x.dx; } int PMAPI DPMI_setSelectorLimit(ushort sel,ulong limit) { PMREGS r; r.x.ax = 8; /* DPMI set selector limit */ r.x.bx = sel; r.x.cx = limit >> 16; r.x.dx = limit & 0xFFFF; PM_int386(0x31, &r, &r); if (r.x.cflag) return 0; return 1; } uint PMAPI DPMI_createSelector(ulong base,ulong limit) { uint sel; PMREGS r; /* Allocate 1 descriptor */ r.x.ax = 0; r.x.cx = 1; PM_int386(0x31, &r, &r); if (r.x.cflag) return 0; sel = r.x.ax; /* Set the descriptor access rights (for a 32 bit page granular * segment). */ if (limit >= 0x10000L) { r.x.ax = 9; r.x.bx = sel; r.x.cx = 0x40F3; PM_int386(0x31, &r, &r); } /* Map physical memory and create selector */ if ((base = DPMI_mapPhysicalToLinear(base,limit)) == 0xFFFFFFFFUL) return 0; if (!DPMI_setSelectorBase(sel,base)) return 0; if (!DPMI_setSelectorLimit(sel,limit)) return 0; return sel; } void PMAPI DPMI_freeSelector(uint sel) { PMREGS r; r.x.ax = 1; r.x.bx = sel; PM_int386(0x31, &r, &r); } int PMAPI DPMI_lockLinearPages(ulong linear,ulong len) { PMREGS r; r.x.ax = 0x600; /* DPMI Lock Linear Region */ r.x.bx = (linear >> 16); /* Linear address in BX:CX */ r.x.cx = (linear & 0xFFFF); r.x.si = (len >> 16); /* Length in SI:DI */ r.x.di = (len & 0xFFFF); PM_int386(0x31, &r, &r); return (!r.x.cflag); } int PMAPI DPMI_unlockLinearPages(ulong linear,ulong len) { PMREGS r; r.x.ax = 0x601; /* DPMI Unlock Linear Region */ r.x.bx = (linear >> 16); /* Linear address in BX:CX */ r.x.cx = (linear & 0xFFFF); r.x.si = (len >> 16); /* Length in SI:DI */ r.x.di = (len & 0xFFFF); PM_int386(0x31, &r, &r); return (!r.x.cflag); } /**************************************************************************** REMARKS: Adjust the page table caching bits directly. Requires ring 0 access and only works with DOS4GW and compatible extenders (CauseWay also works since it has direct support for the ring 0 instructions we need from ring 3). Will not work in a DOS box, but we call into the ring 0 helper VxD so we should never get here in a DOS box anyway (assuming the VxD is present). If we do get here and we are in windows, this code will be skipped. ****************************************************************************/ static void PM_adjustPageTables( ulong linear, ulong limit, ibool isCached) { #ifdef DOS4GW int startPDB,endPDB,iPDB,startPage,endPage,start,end,iPage; ulong andMask,orMask,pageTable,*pPageTable; andMask = ~0x18; orMask = (isCached) ? 0x00 : 0x18; if (_PM_pagingEnabled() == 1 && (PDB = _PM_getPDB()) != 0) { if (_PM_haveCauseWay) { /* CauseWay is a little different in the page table handling. * The code that we use for DOS4G/W does not appear to work * with CauseWay correctly as it does not appear to allow us * to map the page tables directly. Instead we can directly * access the page table entries in extended memory where * CauseWay always locates them (starting at 1024*4096*1023) */ startPage = (linear >> 12); endPage = ((linear+limit) >> 12); pPageTable = (ulong*)CW_PAGE_TABLE_START; for (iPage = startPage; iPage <= endPage; iPage++) pPageTable[iPage] = (pPageTable[iPage] & andMask) | orMask; } else { pPDB = (ulong*)DPMI_mapPhysicalToLinear(PDB,0xFFF); if (pPDB) { startPDB = (linear >> 22) & 0x3FF; startPage = (linear >> 12) & 0x3FF; endPDB = ((linear+limit) >> 22) & 0x3FF; endPage = ((linear+limit) >> 12) & 0x3FF; for (iPDB = startPDB; iPDB <= endPDB; iPDB++) { pageTable = pPDB[iPDB] & ~0xFFF; pPageTable = (ulong*)DPMI_mapPhysicalToLinear(pageTable,0xFFF); start = (iPDB == startPDB) ? startPage : 0; end = (iPDB == endPDB) ? endPage : 0x3FF; for (iPage = start; iPage <= end; iPage++) pPageTable[iPage] = (pPageTable[iPage] & andMask) | orMask; } } } PM_flushTLB(); } #endif } void * PMAPI DPMI_mapPhysicalAddr(ulong base,ulong limit,ibool isCached) { PMSREGS sregs; ulong linAddr; ulong DSBaseAddr; /* Get the base address for the default DS selector */ PM_segread(&sregs); DSBaseAddr = DPMI_getSelectorBase(sregs.ds); if ((base < 0x100000) && (DSBaseAddr == 0)) { /* DS is zero based, so we can directly access the first 1Mb of * system memory (like under DOS4GW). */ return (void*)base; } /* Map the memory to a linear address using DPMI function 0x800 */ if ((linAddr = DPMI_mapPhysicalToLinear(base,limit)) == 0xFFFFFFFF) { if (base >= 0x100000) return NULL; /* If the linear address mapping fails but we are trying to * map an area in the first 1Mb of system memory, then we must * be running under a Windows or OS/2 DOS box. Under these * environments we can use the segment wrap around as a fallback * measure, as this does work properly. */ linAddr = base; } /* Now expand the default DS selector to 4Gb so we can access it */ if (!DPMI_setSelectorLimit(sregs.ds,0xFFFFFFFFUL)) return NULL; /* Finally enable caching for the page tables that we just mapped in, * since DOS4GW and PMODE/W create the page table entries without * caching enabled which hurts the performance of the linear framebuffer * as it disables write combining on Pentium Pro and above processors. * * For those processors cache disabling is better handled through the * MTRR registers anyway (we can write combine a region but disable * caching) so that MMIO register regions do not screw up. */ if (DSBaseAddr == 0) PM_adjustPageTables(linAddr,limit,isCached); /* Now return the base address of the memory into the default DS */ return (void*)(linAddr - DSBaseAddr); } #if defined(PM386) /* Some DOS extender implementations do not directly support calling a * real mode procedure from protected mode. However we can simulate what * we need temporarily hooking the INT 6Ah vector with a small real mode * stub that will call our real mode code for us. */ static uchar int6AHandler[] = { 0x00,0x00,0x00,0x00, /* __PMODE_callReal variable */ 0xFB, /* sti */ 0x2E,0xFF,0x1E,0x00,0x00, /* call [cs:__PMODE_callReal] */ 0xCF, /* iretf */ }; static uchar *crPtr = NULL; /* Pointer to of int 6A handler */ static uint crRSeg,crROff; /* Real mode seg:offset of handler */ void PMAPI PM_callRealMode(uint seg,uint off, RMREGS *in, RMSREGS *sregs) { uchar *p; uint oldSeg,oldOff; if (!crPtr) { /* Allocate and copy the memory block only once */ crPtr = PM_allocRealSeg(sizeof(int6AHandler), &crRSeg, &crROff); memcpy(crPtr,int6AHandler,sizeof(int6AHandler)); } PM_setWord(crPtr,off); /* Plug in address to call */ PM_setWord(crPtr+2,seg); p = PM_mapRealPointer(0,0x6A * 4); oldOff = PM_getWord(p); /* Save old handler address */ oldSeg = PM_getWord(p+2); PM_setWord(p,crROff+4); /* Hook 6A handler */ PM_setWord(p+2,crRSeg); PM_int86x(0x6A, in, in, sregs); /* Call real mode code */ PM_setWord(p,oldOff); /* Restore old handler */ PM_setWord(p+2,oldSeg); } #endif /* PM386 */ #endif /* !REALMODE */ /**************************************************************************** REMARKS: Allocates a block of locked, physically contiguous memory. The memory may be required to be below the 16Meg boundary. ****************************************************************************/ void * PMAPI PM_allocLockedMem( uint size, ulong *physAddr, ibool contiguous, ibool below16Meg) { uchar *p,*roundedP; uint r_seg,r_off; uint roundedSize = (size + 4 + 0xFFF) & ~0xFFF; PM_lockHandle lh; /* Unused in DOS */ #ifndef REALMODE VXD_regs regs; /* If we have connected to our helper VxD in a Windows DOS box, use the * helper VxD services to allocate the memory that we need. */ if (VXD_version) { memset(®s,0,sizeof(regs)); regs.eax = API_NUM(PMHELP_ALLOCLOCKED); regs.ebx = size; regs.ecx = (ulong)physAddr; regs.edx = contiguous | (below16Meg << 8); _PM_VxDCall(®s,_PM_VXD_off,_PM_VXD_sel); return (void*)regs.eax; } /* If the memory is not contiguous, we simply need to allocate it * using regular memory allocation services, and lock it down * in memory. * * For contiguous memory blocks, the only way to guarantee contiguous physical * memory addresses under DOS is to allocate the memory below the * 1Meg boundary as real mode memory. * * Note that we must page align the memory block, and we also must * keep track of the non-aligned pointer so we can properly free * it later. Hence we actually allocate 4 bytes more than the * size rounded up to the next 4K boundary. */ if (!contiguous) p = PM_malloc(roundedSize); else #endif p = PM_allocRealSeg(roundedSize,&r_seg,&r_off); if (p == NULL) return NULL; roundedP = (void*)(((ulong)p + 0xFFF) & ~0xFFF); *((ulong*)(roundedP + size)) = (ulong)p; PM_lockDataPages(roundedP,size,&lh); if ((*physAddr = PM_getPhysicalAddr(roundedP)) == 0xFFFFFFFF) { PM_freeLockedMem(roundedP,size,contiguous); return NULL; } /* Disable caching for the memory since it is probably a DMA buffer */ #ifndef REALMODE PM_adjustPageTables((ulong)roundedP,size-1,false); #endif return roundedP; } /**************************************************************************** REMARKS: Free a block of locked memory. ****************************************************************************/ void PMAPI PM_freeLockedMem(void *p,uint size,ibool contiguous) { #ifndef REALMODE VXD_regs regs; PM_lockHandle lh; /* Unused in DOS */ if (!p) return; if (VXD_version) { memset(®s,0,sizeof(regs)); regs.eax = API_NUM(PMHELP_FREELOCKED); regs.ebx = (ulong)p; regs.ecx = size; regs.edx = contiguous; _PM_VxDCall(®s,_PM_VXD_off,_PM_VXD_sel); return; } PM_unlockDataPages(p,size,&lh); if (!contiguous) free(*((void**)((uchar*)p + size))); else #endif PM_freeRealSeg(*((void**)((char*)p + size))); } #ifndef REALMODE /**************************************************************************** REMARKS: Allocates a new block of pages for the page block manager. ****************************************************************************/ static pageblock *PM_addNewPageBlock(void) { int i,size; pageblock *newBlock; char *p,*next; /* Allocate memory for the new page block, and add to head of list */ size = PAGES_PER_BLOCK * PM_PAGE_SIZE + (PM_PAGE_SIZE-1) + sizeof(pageblock); if ((newBlock = PM_malloc(size)) == NULL) return NULL; newBlock->prev = NULL; newBlock->next = pageBlocks; if (pageBlocks) pageBlocks->prev = newBlock; pageBlocks = newBlock; /* Initialise the page aligned free list for the page block */ newBlock->freeCount = PAGES_PER_BLOCK; newBlock->freeList = p = (char*)(((ulong)(newBlock + 1) + (PM_PAGE_SIZE-1)) & ~(PM_PAGE_SIZE-1)); newBlock->freeListStart = newBlock->freeList; newBlock->freeListEnd = p + (PAGES_PER_BLOCK-1) * PM_PAGE_SIZE; for (i = 0; i < PAGES_PER_BLOCK; i++,p = next) FREELIST_NEXT(p) = next = p + PM_PAGE_SIZE; FREELIST_NEXT(p - PM_PAGE_SIZE) = NULL; return newBlock; } #endif /**************************************************************************** REMARKS: Allocates a page aligned and page sized block of memory ****************************************************************************/ void * PMAPI PM_allocPage( ibool locked) { #ifndef REALMODE VXD_regs regs; pageblock *block; void *p; PM_lockHandle lh; /* Unused in DOS */ /* Call the helper VxD for this service if we are running in a DOS box */ if (VXD_version) { memset(®s,0,sizeof(regs)); regs.eax = API_NUM(PMHELP_ALLOCPAGE); regs.ebx = locked; _PM_VxDCall(®s,_PM_VXD_off,_PM_VXD_sel); return (void*)regs.eax; } /* Scan the block list looking for any free blocks. Allocate a new * page block if no free blocks are found. */ for (block = pageBlocks; block != NULL; block = block->next) { if (block->freeCount) break; } if (block == NULL && (block = PM_addNewPageBlock()) == NULL) return NULL; block->freeCount--; p = block->freeList; block->freeList = FREELIST_NEXT(p); if (locked) PM_lockDataPages(p,PM_PAGE_SIZE,&lh); return p; #else return NULL; #endif } /**************************************************************************** REMARKS: Free a page aligned and page sized block of memory ****************************************************************************/ void PMAPI PM_freePage( void *p) { #ifndef REALMODE VXD_regs regs; pageblock *block; /* Call the helper VxD for this service if we are running in a DOS box */ if (VXD_version) { memset(®s,0,sizeof(regs)); regs.eax = API_NUM(PMHELP_FREEPAGE); regs.ebx = (ulong)p; _PM_VxDCall(®s,_PM_VXD_off,_PM_VXD_sel); return; } /* First find the page block that this page belongs to */ for (block = pageBlocks; block != NULL; block = block->next) { if (p >= block->freeListStart && p <= block->freeListEnd) break; } CHECK(block != NULL); /* Now free the block by adding it to the free list */ FREELIST_NEXT(p) = block->freeList; block->freeList = p; if (++block->freeCount == PAGES_PER_BLOCK) { /* If all pages in the page block are now free, free the entire * page block itself. */ if (block == pageBlocks) { /* Delete from head */ pageBlocks = block->next; if (block->next) block->next->prev = NULL; } else { /* Delete from middle of list */ CHECK(block->prev != NULL); block->prev->next = block->next; if (block->next) block->next->prev = block->prev; } PM_free(block); } #else (void)p; #endif } /*-------------------------------------------------------------------------*/ /* DOS Real Mode support. */ /*-------------------------------------------------------------------------*/ #ifdef REALMODE #ifndef MK_FP #define MK_FP(s,o) ( (void far *)( ((ulong)(s) << 16) + \ (ulong)(o) )) #endif void * PMAPI PM_mapRealPointer(uint r_seg,uint r_off) { return MK_FP(r_seg,r_off); } void * PMAPI PM_getBIOSPointer(void) { return MK_FP(0x40,0); } void * PMAPI PM_getA0000Pointer(void) { return MK_FP(0xA000,0); } void * PMAPI PM_mapPhysicalAddr(ulong base,ulong limit,ibool isCached) { uint sel = base >> 4; uint off = base & 0xF; limit = limit; return MK_FP(sel,off); } void PMAPI PM_freePhysicalAddr(void *ptr,ulong limit) { ptr = ptr; } ulong PMAPI PM_getPhysicalAddr(void *p) { return ((((ulong)p >> 16) << 4) + (ushort)p); } ibool PMAPI PM_getPhysicalAddrRange(void *p,ulong length,ulong *physAddress) { return false; } void * PMAPI PM_mapToProcess(void *base,ulong limit) { return (void*)base; } void * PMAPI PM_allocRealSeg(uint size,uint *r_seg,uint *r_off) { /* Call malloc() to allocate the memory for us */ void *p = PM_malloc(size); *r_seg = FP_SEG(p); *r_off = FP_OFF(p); return p; } void PMAPI PM_freeRealSeg(void *mem) { if (mem) PM_free(mem); } int PMAPI PM_int86(int intno, RMREGS *in, RMREGS *out) { return PM_int386(intno,in,out); } int PMAPI PM_int86x(int intno, RMREGS *in, RMREGS *out, RMSREGS *sregs) { return PM_int386x(intno,in,out,sregs); } void PMAPI PM_availableMemory(ulong *physical,ulong *total) { PMREGS regs; regs.h.ah = 0x48; regs.x.bx = 0xFFFF; PM_int86(0x21,®s,®s); *physical = *total = regs.x.bx * 16UL; } #endif /*-------------------------------------------------------------------------*/ /* Phar Lap TNT DOS Extender support. */ /*-------------------------------------------------------------------------*/ #ifdef TNT #include #include #include static uchar *zeroPtr = NULL; void * PMAPI PM_getBIOSPointer(void) { if (!zeroPtr) zeroPtr = PM_mapPhysicalAddr(0,0xFFFFF,true); return (void*)(zeroPtr + 0x400); } void * PMAPI PM_getA0000Pointer(void) { static void *bankPtr; if (!bankPtr) bankPtr = PM_mapPhysicalAddr(0xA0000,0xFFFF,true); return bankPtr; } void * PMAPI PM_mapPhysicalAddr(ulong base,ulong limit,ibool isCached) { CONFIG_INF config; ULONG offset; int err; ulong baseAddr,baseOfs,newLimit; VXD_regs regs; /* If we have connected to our helper VxD in a Windows DOS box, use * the helper VxD services to map memory instead of the DPMI services. * We do this because the helper VxD can properly disable caching * where necessary, which we can only do directly here if we are * running at ring 0 (ie: under real DOS). */ if (VXD_version == -1) PM_init(); if (VXD_version) { memset(®s,0,sizeof(regs)); regs.eax = API_NUM(PMHELP_MAPPHYS); regs.ebx = base; regs.ecx = limit; regs.edx = isCached; _PM_VxDCall(®s,_PM_VXD_off,_PM_VXD_sel); return (void*)regs.eax; } /* Round the physical address to a 4Kb boundary and the limit to a * 4Kb-1 boundary before passing the values to TNT. If we round the * physical address, then we also add an extra offset into the address * that we return. */ baseOfs = base & 4095; baseAddr = base & ~4095; newLimit = ((limit+baseOfs+1+4095) & ~4095)-1; _dx_config_inf(&config, (UCHAR*)&config); err = _dx_map_phys(config.c_ds_sel,baseAddr,(newLimit + 4095) / 4096,&offset); if (err == 130) { /* If the TNT function failed, we are running in a DPMI environment * and this function does not work. However we know how to handle * DPMI properly, so we use our generic DPMI functions to do * what the TNT runtime libraries can't. */ return DPMI_mapPhysicalAddr(base,limit,isCached); } if (err == 0) return (void*)(offset + baseOfs); return NULL; } void PMAPI PM_freePhysicalAddr(void *ptr,ulong limit) { } ulong PMAPI PM_getPhysicalAddr(void *p) { return 0xFFFFFFFFUL; } ibool PMAPI PM_getPhysicalAddrRange(void *p,ulong length,ulong *physAddress) { return false; } void * PMAPI PM_mapToProcess(void *base,ulong limit) { return (void*)base; } void * PMAPI PM_mapRealPointer(uint r_seg,uint r_off) { if (!zeroPtr) zeroPtr = PM_mapPhysicalAddr(0,0xFFFFF); return (void*)(zeroPtr + MK_PHYS(r_seg,r_off)); } void * PMAPI PM_allocRealSeg(uint size,uint *r_seg,uint *r_off) { USHORT addr,t; void *p; if (_dx_real_alloc((size + 0xF) >> 4,&addr,&t) != 0) return 0; *r_seg = addr; /* Real mode segment address */ *r_off = 0; /* Real mode segment offset */ p = PM_mapRealPointer(*r_seg,*r_off); _PM_addRealModeBlock(p,addr); return p; } void PMAPI PM_freeRealSeg(void *mem) { if (mem) _dx_real_free(_PM_findRealModeBlock(mem)); } #define INDPMI(reg) rmregs.reg = regs->reg #define OUTDPMI(reg) regs->reg = rmregs.reg void PMAPI DPMI_int86(int intno, DPMI_regs *regs) { SWI_REGS rmregs; memset(&rmregs, 0, sizeof(rmregs)); INDPMI(eax); INDPMI(ebx); INDPMI(ecx); INDPMI(edx); INDPMI(esi); INDPMI(edi); _dx_real_int(intno,&rmregs); OUTDPMI(eax); OUTDPMI(ebx); OUTDPMI(ecx); OUTDPMI(edx); OUTDPMI(esi); OUTDPMI(edi); regs->flags = rmregs.flags; } #define IN(reg) rmregs.reg = in->e.reg #define OUT(reg) out->e.reg = rmregs.reg int PMAPI PM_int86(int intno, RMREGS *in, RMREGS *out) { SWI_REGS rmregs; memset(&rmregs, 0, sizeof(rmregs)); IN(eax); IN(ebx); IN(ecx); IN(edx); IN(esi); IN(edi); _dx_real_int(intno,&rmregs); OUT(eax); OUT(ebx); OUT(ecx); OUT(edx); OUT(esi); OUT(edi); out->x.cflag = rmregs.flags & 0x1; return out->x.ax; } int PMAPI PM_int86x(int intno, RMREGS *in, RMREGS *out, RMSREGS *sregs) { SWI_REGS rmregs; memset(&rmregs, 0, sizeof(rmregs)); IN(eax); IN(ebx); IN(ecx); IN(edx); IN(esi); IN(edi); rmregs.es = sregs->es; rmregs.ds = sregs->ds; _dx_real_int(intno,&rmregs); OUT(eax); OUT(ebx); OUT(ecx); OUT(edx); OUT(esi); OUT(edi); sregs->es = rmregs.es; sregs->cs = rmregs.cs; sregs->ss = rmregs.ss; sregs->ds = rmregs.ds; out->x.cflag = rmregs.flags & 0x1; return out->x.ax; } void PMAPI PM_availableMemory(ulong *physical,ulong *total) { PMREGS r; uint data[25]; r.x.ax = 0x2520; /* Get free memory info */ r.x.bx = 0; r.e.edx = (uint)data; PM_int386(0x21, &r, &r); *physical = data[21] * 4096; *total = data[23] * 4096; } #endif /*-------------------------------------------------------------------------*/ /* Symantec C++ DOSX and FlashTek X-32/X-32VM support */ /*-------------------------------------------------------------------------*/ #if defined(DOSX) || defined(X32VM) #ifdef X32VM #include #define _x386_mk_protected_ptr(p) _x32_mk_protected_ptr((void*)p) #define _x386_free_protected_ptr(p) _x32_free_protected_ptr(p) #define _x386_zero_base_ptr _x32_zero_base_ptr #else extern void *_x386_zero_base_ptr; #endif void * PMAPI PM_mapRealPointer(uint r_seg,uint r_off) { return (void*)((ulong)_x386_zero_base_ptr + MK_PHYS(r_seg,r_off)); } void * PMAPI PM_allocRealSeg(uint size,uint *r_seg,uint *r_off) { PMREGS r; r.h.ah = 0x48; /* DOS function 48h - allocate mem */ r.x.bx = (size + 0xF) >> 4; /* Number of paragraphs to allocate */ PM_int386(0x21, &r, &r); /* Call DOS extender */ if (r.x.cflag) return 0; /* Could not allocate the memory */ *r_seg = r.e.eax; *r_off = 0; return PM_mapRealPointer(*r_seg,*r_off); } void PMAPI PM_freeRealSeg(void *mem) { /* Cannot de-allocate this memory */ mem = mem; } #pragma pack(1) typedef struct { ushort intno; ushort ds; ushort es; ushort fs; ushort gs; ulong eax; ulong edx; } _RMREGS; #pragma pack() #define IN(reg) regs.e.reg = in->e.reg #define OUT(reg) out->e.reg = regs.e.reg int PMAPI PM_int86(int intno, RMREGS *in, RMREGS *out) { _RMREGS rmregs; PMREGS regs; PMSREGS pmsregs; rmregs.intno = intno; rmregs.eax = in->e.eax; rmregs.edx = in->e.edx; IN(ebx); IN(ecx); IN(esi); IN(edi); regs.x.ax = 0x2511; regs.e.edx = (uint)(&rmregs); PM_segread(&pmsregs); PM_int386x(0x21,®s,®s,&pmsregs); OUT(eax); OUT(ebx); OUT(ecx); OUT(esi); OUT(edi); out->x.dx = rmregs.edx; out->x.cflag = regs.x.cflag; return out->x.ax; } int PMAPI PM_int86x(int intno, RMREGS *in, RMREGS *out, RMSREGS *sregs) { _RMREGS rmregs; PMREGS regs; PMSREGS pmsregs; rmregs.intno = intno; rmregs.eax = in->e.eax; rmregs.edx = in->e.edx; rmregs.es = sregs->es; rmregs.ds = sregs->ds; IN(ebx); IN(ecx); IN(esi); IN(edi); regs.x.ax = 0x2511; regs.e.edx = (uint)(&rmregs); PM_segread(&pmsregs); PM_int386x(0x21,®s,®s,&pmsregs); OUT(eax); OUT(ebx); OUT(ecx); OUT(esi); OUT(edi); sregs->es = rmregs.es; sregs->ds = rmregs.ds; out->x.dx = rmregs.edx; out->x.cflag = regs.x.cflag; return out->x.ax; } void * PMAPI PM_getBIOSPointer(void) { return (void*)((ulong)_x386_zero_base_ptr + 0x400); } void * PMAPI PM_getA0000Pointer(void) { return (void*)((ulong)_x386_zero_base_ptr + 0xA0000); } void * PMAPI PM_mapPhysicalAddr(ulong base,ulong limit,ibool isCached) { VXD_regs regs; /* If we have connected to our helper VxD in a Windows DOS box, use * the helper VxD services to map memory instead of the DPMI services. * We do this because the helper VxD can properly disable caching * where necessary, which we can only do directly here if we are * running at ring 0 (ie: under real DOS). */ if (VXD_version == -1) PM_init(); if (VXD_version) { memset(®s,0,sizeof(regs)); regs.eax = API_NUM(PMHELP_MAPPHYS); regs.ebx = base; regs.ecx = limit; regs.edx = isCached; _PM_VxDCall(®s,_PM_VXD_off,_PM_VXD_sel); return (void*)regs.eax; } if (base > 0x100000) return _x386_map_physical_address((void*)base,limit); return (void*)((ulong)_x386_zero_base_ptr + base); } void PMAPI PM_freePhysicalAddr(void *ptr,ulong limit) { /* Mapping cannot be freed */ } ulong PMAPI PM_getPhysicalAddr(void *p) { return 0xFFFFFFFFUL; } ibool PMAPI PM_getPhysicalAddrRange(void *p,ulong length,ulong *physAddress) { return false; } void * PMAPI PM_mapToProcess(void *base,ulong limit) { return (void*)base; } ulong _cdecl _X32_getPhysMem(void); void PMAPI PM_availableMemory(ulong *physical,ulong *total) { PMREGS regs; /* Get total memory available, including virtual memory */ regs.x.ax = 0x350B; PM_int386(0x21,®s,®s); *total = regs.e.eax; /* Get physical memory available */ *physical = _X32_getPhysMem(); if (*physical > *total) *physical = *total; } #endif /*-------------------------------------------------------------------------*/ /* Borland's DPMI32, Watcom DOS4GW and DJGPP DPMI support routines */ /*-------------------------------------------------------------------------*/ #if defined(DPMI32) || defined(DOS4GW) || defined(DJGPP) void * PMAPI PM_getBIOSPointer(void) { return PM_mapPhysicalAddr(0x400,0xFFFF,true); } void * PMAPI PM_getA0000Pointer(void) { return PM_mapPhysicalAddr(0xA0000,0xFFFF,true); } void * PMAPI PM_mapPhysicalAddr(ulong base,ulong limit,ibool isCached) { VXD_regs regs; #ifdef DJGPP /* Enable near pointers for DJGPP V2 */ __djgpp_nearptr_enable(); #endif /* If we have connected to our helper VxD in a Windows DOS box, use * the helper VxD services to map memory instead of the DPMI services. * We do this because the helper VxD can properly disable caching * where necessary, which we can only do directly here if we are * running at ring 0 (ie: under real DOS). */ if (VXD_version == -1) PM_init(); if (VXD_version) { memset(®s,0,sizeof(regs)); regs.eax = API_NUM(PMHELP_MAPPHYS); regs.ebx = base; regs.ecx = limit; regs.edx = isCached; _PM_VxDCall(®s,_PM_VXD_off,_PM_VXD_sel); return (void*)regs.eax; } return DPMI_mapPhysicalAddr(base,limit,isCached); } void PMAPI PM_freePhysicalAddr(void *ptr,ulong limit) { /* Mapping cannot be freed */ (void)ptr; (void)limit; } ulong PMAPI PM_getPhysicalAddr(void *p) { ulong physAddr; if (!PM_getPhysicalAddrRange(p,1,&physAddr)) return 0xFFFFFFFF; return physAddr | ((ulong)p & 0xFFF); } ibool PMAPI PM_getPhysicalAddrRange( void *p, ulong length, ulong *physAddress) { VXD_regs regs; ulong pte; PMSREGS sregs; ulong DSBaseAddr; /* If we have connected to our helper VxD in a Windows DOS box, use the * helper VxD services to find the physical address of an address. */ if (VXD_version) { memset(®s,0,sizeof(regs)); regs.eax = API_NUM(PMHELP_GETPHYSICALADDRRANGE); regs.ebx = (ulong)p; regs.ecx = (ulong)length; regs.edx = (ulong)physAddress; _PM_VxDCall(®s,_PM_VXD_off,_PM_VXD_sel); return regs.eax; } /* Find base address for default DS selector */ PM_segread(&sregs); DSBaseAddr = DPMI_getSelectorBase(sregs.ds); /* Otherwise directly access the page tables to determine the * physical memory address. Note that we touch the memory before * calling, otherwise the memory may not be paged in correctly. */ pte = *((ulong*)p); #ifdef DOS4GW if (_PM_pagingEnabled() == 0) { int count; ulong linAddr = (ulong)p; /* When paging is disabled physical=linear */ for (count = (length+0xFFF) >> 12; count > 0; count--) { *physAddress++ = linAddr; linAddr += 4096; } return true; } else if ((PDB = _PM_getPDB()) != 0 && DSBaseAddr == 0) { int startPDB,endPDB,iPDB,startPage,endPage,start,end,iPage; ulong pageTable,*pPageTable,linAddr = (ulong)p; ulong limit = length-1; pPDB = (ulong*)DPMI_mapPhysicalToLinear(PDB,0xFFF); if (pPDB) { startPDB = (linAddr >> 22) & 0x3FFL; startPage = (linAddr >> 12) & 0x3FFL; endPDB = ((linAddr+limit) >> 22) & 0x3FFL; endPage = ((linAddr+limit) >> 12) & 0x3FFL; for (iPDB = startPDB; iPDB <= endPDB; iPDB++) { pageTable = pPDB[iPDB] & ~0xFFFL; pPageTable = (ulong*)DPMI_mapPhysicalToLinear(pageTable,0xFFF); start = (iPDB == startPDB) ? startPage : 0; end = (iPDB == endPDB) ? endPage : 0x3FFL; for (iPage = start; iPage <= end; iPage++) *physAddress++ = (pPageTable[iPage] & ~0xFFF); } return true; } } #endif return false; } void * PMAPI PM_mapToProcess(void *base,ulong limit) { (void)limit; return (void*)base; } void * PMAPI PM_mapRealPointer(uint r_seg,uint r_off) { static uchar *zeroPtr = NULL; if (!zeroPtr) zeroPtr = PM_mapPhysicalAddr(0,0xFFFFF,true); return (void*)(zeroPtr + MK_PHYS(r_seg,r_off)); } void * PMAPI PM_allocRealSeg(uint size,uint *r_seg,uint *r_off) { PMREGS r; void *p; r.x.ax = 0x100; /* DPMI allocate DOS memory */ r.x.bx = (size + 0xF) >> 4; /* number of paragraphs */ PM_int386(0x31, &r, &r); if (r.x.cflag) return NULL; /* DPMI call failed */ *r_seg = r.x.ax; /* Real mode segment */ *r_off = 0; p = PM_mapRealPointer(*r_seg,*r_off); _PM_addRealModeBlock(p,r.x.dx); return p; } void PMAPI PM_freeRealSeg(void *mem) { PMREGS r; if (mem) { r.x.ax = 0x101; /* DPMI free DOS memory */ r.x.dx = _PM_findRealModeBlock(mem);/* DX := selector from 0x100 */ PM_int386(0x31, &r, &r); } } static DPMI_handler_t DPMI_int10 = NULL; void PMAPI DPMI_setInt10Handler(DPMI_handler_t handler) { DPMI_int10 = handler; } void PMAPI DPMI_int86(int intno, DPMI_regs *regs) { PMREGS r; PMSREGS sr; if (intno == 0x10 && DPMI_int10) { if (DPMI_int10(regs)) return; } PM_segread(&sr); r.x.ax = 0x300; /* DPMI issue real interrupt */ r.h.bl = intno; r.h.bh = 0; r.x.cx = 0; sr.es = sr.ds; r.e.edi = (uint)regs; PM_int386x(0x31, &r, &r, &sr); /* Issue the interrupt */ } #define IN(reg) rmregs.reg = in->e.reg #define OUT(reg) out->e.reg = rmregs.reg int PMAPI PM_int86(int intno, RMREGS *in, RMREGS *out) { DPMI_regs rmregs; memset(&rmregs, 0, sizeof(rmregs)); IN(eax); IN(ebx); IN(ecx); IN(edx); IN(esi); IN(edi); DPMI_int86(intno,&rmregs); /* DPMI issue real interrupt */ OUT(eax); OUT(ebx); OUT(ecx); OUT(edx); OUT(esi); OUT(edi); out->x.cflag = rmregs.flags & 0x1; return out->x.ax; } int PMAPI PM_int86x(int intno, RMREGS *in, RMREGS *out, RMSREGS *sregs) { DPMI_regs rmregs; memset(&rmregs, 0, sizeof(rmregs)); IN(eax); IN(ebx); IN(ecx); IN(edx); IN(esi); IN(edi); rmregs.es = sregs->es; rmregs.ds = sregs->ds; DPMI_int86(intno,&rmregs); /* DPMI issue real interrupt */ OUT(eax); OUT(ebx); OUT(ecx); OUT(edx); OUT(esi); OUT(edi); sregs->es = rmregs.es; sregs->cs = rmregs.cs; sregs->ss = rmregs.ss; sregs->ds = rmregs.ds; out->x.cflag = rmregs.flags & 0x1; return out->x.ax; } #pragma pack(1) typedef struct { uint LargestBlockAvail; uint MaxUnlockedPage; uint LargestLockablePage; uint LinAddrSpace; uint NumFreePagesAvail; uint NumPhysicalPagesFree; uint TotalPhysicalPages; uint FreeLinAddrSpace; uint SizeOfPageFile; uint res[3]; } MemInfo; #pragma pack() void PMAPI PM_availableMemory(ulong *physical,ulong *total) { PMREGS r; PMSREGS sr; MemInfo memInfo; PM_segread(&sr); r.x.ax = 0x500; /* DPMI get free memory info */ sr.es = sr.ds; r.e.edi = (uint)&memInfo; PM_int386x(0x31, &r, &r, &sr); /* Issue the interrupt */ *physical = memInfo.NumPhysicalPagesFree * 4096; *total = memInfo.LargestBlockAvail; if (*total < *physical) *physical = *total; } #endif #ifndef __16BIT__ /**************************************************************************** REMARKS: Call the VBE/Core software interrupt to change display banks. ****************************************************************************/ void PMAPI PM_setBankA( int bank) { DPMI_regs regs; memset(®s, 0, sizeof(regs)); regs.eax = 0x4F05; regs.ebx = 0x0000; regs.edx = bank; DPMI_int86(0x10,®s); } /**************************************************************************** REMARKS: Call the VBE/Core software interrupt to change display banks. ****************************************************************************/ void PMAPI PM_setBankAB( int bank) { DPMI_regs regs; memset(®s, 0, sizeof(regs)); regs.eax = 0x4F05; regs.ebx = 0x0000; regs.edx = bank; DPMI_int86(0x10,®s); regs.eax = 0x4F05; regs.ebx = 0x0001; regs.edx = bank; DPMI_int86(0x10,®s); } /**************************************************************************** REMARKS: Call the VBE/Core software interrupt to change display start address. ****************************************************************************/ void PMAPI PM_setCRTStart( int x, int y, int waitVRT) { DPMI_regs regs; memset(®s, 0, sizeof(regs)); regs.eax = 0x4F07; regs.ebx = waitVRT; regs.ecx = x; regs.edx = y; DPMI_int86(0x10,®s); } #endif /**************************************************************************** REMARKS: Function to get the file attributes for a specific file. ****************************************************************************/ uint PMAPI PM_getFileAttr( const char *filename) { // TODO: Implement this! return 0; } /**************************************************************************** REMARKS: Function to get the file time and date for a specific file. ****************************************************************************/ ibool PMAPI PM_getFileTime( const char *filename, ibool gmTime, PM_time *time) { // TODO: Implement this! return false; } /**************************************************************************** REMARKS: Function to set the file time and date for a specific file. ****************************************************************************/ ibool PMAPI PM_setFileTime( const char *filename, ibool gmTime, PM_time *time) { // TODO: Implement this! return false; }