2244 lines
60 KiB
C
2244 lines
60 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: 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 <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <dos.h>
|
|
#include <conio.h>
|
|
#ifdef __GNUC__
|
|
#include <unistd.h>
|
|
#include <sys/nearptr.h>
|
|
#include <sys/stat.h>
|
|
#else
|
|
#include <direct.h>
|
|
#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 <pldos32.h>
|
|
#include <pharlap.h>
|
|
#include <hw386.h>
|
|
|
|
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 <x32.h>
|
|
|
|
#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;
|
|
}
|