702 lines
20 KiB
C
702 lines
20 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: RTTarget-32
|
|
*
|
|
* 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 <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#define STRICT
|
|
#include <windows.h>
|
|
#include <mmsystem.h>
|
|
#ifdef __BORLANDC__
|
|
#pragma warn -par
|
|
#endif
|
|
|
|
/*--------------------------- Global variables ----------------------------*/
|
|
|
|
static void (PMAPIP fatalErrorCleanup)(void) = NULL;
|
|
|
|
/*----------------------------- Implementation ----------------------------*/
|
|
|
|
void MTRR_init(void);
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Initialise the PM library.
|
|
****************************************************************************/
|
|
void PMAPI PM_init(void)
|
|
{
|
|
/* TODO: dO any special init code in here. */
|
|
MTRR_init();
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return the operating system type identifier.
|
|
****************************************************************************/
|
|
long PMAPI PM_getOSType(void)
|
|
{
|
|
return _OS_RTTARGET;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return the runtime type identifier.
|
|
****************************************************************************/
|
|
int PMAPI PM_getModeType(void)
|
|
{
|
|
return PM_386;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Add a file directory separator to the end of the filename.
|
|
****************************************************************************/
|
|
void PMAPI PM_backslash(
|
|
char *s)
|
|
{
|
|
uint pos = strlen(s);
|
|
if (s[pos-1] != '\\') {
|
|
s[pos] = '\\';
|
|
s[pos+1] = '\0';
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Add a user defined PM_fatalError cleanup function.
|
|
****************************************************************************/
|
|
void PMAPI PM_setFatalErrorCleanup(
|
|
void (PMAPIP cleanup)(void))
|
|
{
|
|
fatalErrorCleanup = cleanup;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Report a fatal error condition and halt the program.
|
|
****************************************************************************/
|
|
void PMAPI PM_fatalError(
|
|
const char *msg)
|
|
{
|
|
if (fatalErrorCleanup)
|
|
fatalErrorCleanup();
|
|
/* TODO: Display a fatal error message and exit! */
|
|
/* MessageBox(NULL,msg,"Fatal Error!", MB_ICONEXCLAMATION); */
|
|
exit(1);
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Allocate the real mode VESA transfer buffer for communicating with the BIOS.
|
|
****************************************************************************/
|
|
void * PMAPI PM_getVESABuf(
|
|
uint *len,
|
|
uint *rseg,
|
|
uint *roff)
|
|
{
|
|
/* No BIOS access for the RTTarget */
|
|
return NULL;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Check if a key has been pressed.
|
|
****************************************************************************/
|
|
int PMAPI PM_kbhit(void)
|
|
{
|
|
/* TODO: Need to check if a key is waiting on the keyboard queue */
|
|
return true;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Wait for and return the next keypress.
|
|
****************************************************************************/
|
|
int PMAPI PM_getch(void)
|
|
{
|
|
/* TODO: Need to obtain the next keypress, and block until one is hit */
|
|
return 0xD;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Set the location of the OS console cursor.
|
|
****************************************************************************/
|
|
void PM_setOSCursorLocation(
|
|
int x,
|
|
int y)
|
|
{
|
|
/* Nothing to do for RTTarget-32 */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Set the width of the OS console.
|
|
****************************************************************************/
|
|
void PM_setOSScreenWidth(
|
|
int width,
|
|
int height)
|
|
{
|
|
/* Nothing to do for RTTarget-32 */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Set the real time clock handler (used for software stereo modes).
|
|
****************************************************************************/
|
|
ibool PMAPI PM_setRealTimeClockHandler(
|
|
PM_intHandler ih,
|
|
int frequency)
|
|
{
|
|
/* Not supported for RTTarget-32 */
|
|
return false;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Set the real time clock frequency (for stereo modes).
|
|
****************************************************************************/
|
|
void PMAPI PM_setRealTimeClockFrequency(
|
|
int frequency)
|
|
{
|
|
/* Not supported under RTTarget-32 */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Restore the original real time clock handler.
|
|
****************************************************************************/
|
|
void PMAPI PM_restoreRealTimeClockHandler(void)
|
|
{
|
|
/* Not supported under RTTarget-32 */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return the current operating system path or working directory.
|
|
****************************************************************************/
|
|
char * PMAPI PM_getCurrentPath(
|
|
char *path,
|
|
int maxLen)
|
|
{
|
|
return getcwd(path,maxLen);
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return the drive letter for the boot drive.
|
|
****************************************************************************/
|
|
char PMAPI PM_getBootDrive(void)
|
|
{
|
|
return 'c';
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return the path to the VBE/AF driver files.
|
|
****************************************************************************/
|
|
const char * PMAPI PM_getVBEAFPath(void)
|
|
{
|
|
return "c:\\";
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return the path to the Nucleus driver files.
|
|
****************************************************************************/
|
|
const char * PMAPI PM_getNucleusPath(void)
|
|
{
|
|
/* TODO: Point this at the path when the Nucleus drivers will be found */
|
|
return "c:\\nucleus";
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return the path to the Nucleus configuration files.
|
|
****************************************************************************/
|
|
const char * PMAPI PM_getNucleusConfigPath(void)
|
|
{
|
|
static char path[256];
|
|
strcpy(path,PM_getNucleusPath());
|
|
PM_backslash(path);
|
|
strcat(path,"config");
|
|
return path;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return a unique identifier for the machine if possible.
|
|
****************************************************************************/
|
|
const char * PMAPI PM_getUniqueID(void)
|
|
{
|
|
return PM_getMachineName();
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Get the name of the machine on the network.
|
|
****************************************************************************/
|
|
const char * PMAPI PM_getMachineName(void)
|
|
{
|
|
/* Not necessary for RTTarget-32 */
|
|
return "Unknown";
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return a pointer to the real mode BIOS data area.
|
|
****************************************************************************/
|
|
void * PMAPI PM_getBIOSPointer(void)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
return NULL;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return a pointer to 0xA0000 physical VGA graphics framebuffer.
|
|
****************************************************************************/
|
|
void * PMAPI PM_getA0000Pointer(void)
|
|
{
|
|
static void *bankPtr;
|
|
if (!bankPtr)
|
|
bankPtr = PM_mapPhysicalAddr(0xA0000,0xFFFF,true);
|
|
return bankPtr;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Map a physical address to a linear address in the callers process.
|
|
****************************************************************************/
|
|
void * PMAPI PM_mapPhysicalAddr(
|
|
ulong base,
|
|
ulong limit,
|
|
ibool isCached)
|
|
{
|
|
/* TODO: Map a physical memory address to a linear address */
|
|
return NULL;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Free a physical address mapping allocated by PM_mapPhysicalAddr.
|
|
****************************************************************************/
|
|
void PMAPI PM_freePhysicalAddr(
|
|
void *ptr,
|
|
ulong limit)
|
|
{
|
|
/* TODO: Free the physical address mapping */
|
|
}
|
|
|
|
ulong PMAPI PM_getPhysicalAddr(void *p)
|
|
{
|
|
/* TODO: This function should find the physical address of a linear */
|
|
/* address. */
|
|
return 0xFFFFFFFFUL;
|
|
}
|
|
|
|
void PMAPI PM_sleep(ulong milliseconds)
|
|
{
|
|
Sleep(milliseconds);
|
|
}
|
|
|
|
int PMAPI PM_getCOMPort(int port)
|
|
{
|
|
/* TODO: Re-code this to determine real values using the Plug and Play */
|
|
/* manager for the OS. */
|
|
switch (port) {
|
|
case 0: return 0x3F8;
|
|
case 1: return 0x2F8;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int PMAPI PM_getLPTPort(int port)
|
|
{
|
|
/* TODO: Re-code this to determine real values using the Plug and Play */
|
|
/* manager for the OS. */
|
|
switch (port) {
|
|
case 0: return 0x3BC;
|
|
case 1: return 0x378;
|
|
case 2: return 0x278;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Allocate a block of (unnamed) shared memory.
|
|
****************************************************************************/
|
|
void * PMAPI PM_mallocShared(
|
|
long size)
|
|
{
|
|
return PM_malloc(size);
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Free a block of shared memory.
|
|
****************************************************************************/
|
|
void PMAPI PM_freeShared(
|
|
void *ptr)
|
|
{
|
|
PM_free(ptr);
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Map a linear memory address to the calling process address space. The
|
|
address will have been allocated in another process using the
|
|
PM_mapPhysicalAddr function.
|
|
****************************************************************************/
|
|
void * PMAPI PM_mapToProcess(
|
|
void *base,
|
|
ulong limit)
|
|
{
|
|
return base;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Map a real mode pointer to a protected mode pointer.
|
|
****************************************************************************/
|
|
void * PMAPI PM_mapRealPointer(
|
|
uint r_seg,
|
|
uint r_off)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
return NULL;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Allocate a block of real mode memory
|
|
****************************************************************************/
|
|
void * PMAPI PM_allocRealSeg(
|
|
uint size,
|
|
uint *r_seg,
|
|
uint *r_off)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
return NULL;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Free a block of real mode memory.
|
|
****************************************************************************/
|
|
void PMAPI PM_freeRealSeg(
|
|
void *mem)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Issue a real mode interrupt (parameters in DPMI compatible structure)
|
|
****************************************************************************/
|
|
void PMAPI DPMI_int86(
|
|
int intno,
|
|
DPMI_regs *regs)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Issue a real mode interrupt.
|
|
****************************************************************************/
|
|
int PMAPI PM_int86(
|
|
int intno,
|
|
RMREGS *in,
|
|
RMREGS *out)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Issue a real mode interrupt.
|
|
****************************************************************************/
|
|
int PMAPI PM_int86x(
|
|
int intno,
|
|
RMREGS *in,
|
|
RMREGS *out,
|
|
RMSREGS *sregs)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Call a real mode far function.
|
|
****************************************************************************/
|
|
void PMAPI PM_callRealMode(
|
|
uint seg,
|
|
uint off,
|
|
RMREGS *in,
|
|
RMSREGS *sregs)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Return the amount of available memory.
|
|
****************************************************************************/
|
|
void PMAPI PM_availableMemory(
|
|
ulong *physical,
|
|
ulong *total)
|
|
{
|
|
/* TODO: Figure out how to determine the available memory. Not entirely */
|
|
/* critical so returning 0 is OK. */
|
|
*physical = *total = 0;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Allocate a block of locked, physical memory for DMA operations.
|
|
****************************************************************************/
|
|
void * PMAPI PM_allocLockedMem(
|
|
uint size,
|
|
ulong *physAddr,
|
|
ibool contiguous,
|
|
ibool below16M)
|
|
{
|
|
/* TODO: Allocate a block of locked, phsyically contigous memory for DMA */
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Free a block of locked physical memory.
|
|
****************************************************************************/
|
|
void PMAPI PM_freeLockedMem(
|
|
void *p,
|
|
uint size,
|
|
|
|
ibool contiguous)
|
|
{
|
|
/* TODO: Free a locked memory buffer */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Call the VBE/Core software interrupt to change display banks.
|
|
****************************************************************************/
|
|
void PMAPI PM_setBankA(
|
|
int bank)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Call the VBE/Core software interrupt to change display banks.
|
|
****************************************************************************/
|
|
void PMAPI PM_setBankAB(
|
|
int bank)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Call the VBE/Core software interrupt to change display start address.
|
|
****************************************************************************/
|
|
void PMAPI PM_setCRTStart(
|
|
int x,
|
|
int y,
|
|
int waitVRT)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Execute the POST on the secondary BIOS for a controller.
|
|
****************************************************************************/
|
|
ibool PMAPI PM_doBIOSPOST(
|
|
ushort axVal,
|
|
ulong BIOSPhysAddr,
|
|
void *mappedBIOS)
|
|
{
|
|
/* Not used for RTTarget-32 */
|
|
return false;
|
|
}
|
|
|
|
PM_MODULE PMAPI PM_loadLibrary(
|
|
const char *szDLLName)
|
|
{
|
|
/* TODO: Implement this to load shared libraries! */
|
|
(void)szDLLName;
|
|
return NULL;
|
|
}
|
|
|
|
void * PMAPI PM_getProcAddress(
|
|
PM_MODULE hModule,
|
|
const char *szProcName)
|
|
{
|
|
/* TODO: Implement this! */
|
|
(void)hModule;
|
|
(void)szProcName;
|
|
return NULL;
|
|
}
|
|
|
|
void PMAPI PM_freeLibrary(
|
|
PM_MODULE hModule)
|
|
{
|
|
/* TODO: Implement this! */
|
|
(void)hModule;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Function to find the first file matching a search criteria in a directory.
|
|
****************************************************************************/
|
|
ulong PMAPI PM_findFirstFile(
|
|
const char *filename,
|
|
PM_findData *findData)
|
|
{
|
|
/* TODO: This function should start a directory enumeration search */
|
|
/* given the filename (with wildcards). The data should be */
|
|
/* converted and returned in the findData standard form. */
|
|
(void)filename;
|
|
(void)findData;
|
|
return PM_FILE_INVALID;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Function to find the next file matching a search criteria in a directory.
|
|
****************************************************************************/
|
|
ibool PMAPI PM_findNextFile(
|
|
ulong handle,
|
|
PM_findData *findData)
|
|
{
|
|
/* TODO: This function should find the next file in directory enumeration */
|
|
/* search given the search criteria defined in the call to */
|
|
/* PM_findFirstFile. The data should be converted and returned */
|
|
/* in the findData standard form. */
|
|
(void)handle;
|
|
(void)findData;
|
|
return false;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Function to close the find process
|
|
****************************************************************************/
|
|
void PMAPI PM_findClose(
|
|
ulong handle)
|
|
{
|
|
/* TODO: This function should close the find process. This may do */
|
|
/* nothing for some OS'es. */
|
|
(void)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)
|
|
{
|
|
if (drive == 3)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/****************************************************************************
|
|
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)
|
|
{
|
|
(void)drive;
|
|
getcwd(dir,len);
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Function to change the file attributes for a specific file.
|
|
****************************************************************************/
|
|
void PMAPI PM_setFileAttr(
|
|
const char *filename,
|
|
uint attrib)
|
|
{
|
|
/* TODO: Set the file attributes for a file */
|
|
(void)filename;
|
|
(void)attrib;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Function to create a directory.
|
|
****************************************************************************/
|
|
ibool PMAPI PM_mkdir(
|
|
const char *filename)
|
|
{
|
|
return mkdir(filename) == 0;
|
|
}
|
|
|
|
/****************************************************************************
|
|
REMARKS:
|
|
Function to remove a directory.
|
|
****************************************************************************/
|
|
ibool PMAPI PM_rmdir(
|
|
const char *filename)
|
|
{
|
|
return rmdir(filename) == 0;
|
|
}
|