[people/ms/u-boot.git] / board / MAI / bios_emulator / scitech / src / common / gawin32.c

/****************************************************************************
*
*                   SciTech Nucleus Graphics Architecture
*
*               Copyright (C) 1991-1998 SciTech Software, Inc.
*                            All rights reserved.
*
*  ======================================================================
*  |REMOVAL OR MODIFICATION OF THIS HEADER IS STRICTLY PROHIBITED BY LAW|
*  |                                                                    |
*  |This copyrighted computer code contains proprietary technology      |
*  |owned by SciTech Software, Inc., located at 505 Wall Street,        |
*  |Chico, CA 95928 USA (http://www.scitechsoft.com).                   |
*  |                                                                    |
*  |The contents of this file are subject to the SciTech Nucleus        |
*  |License; you may *not* use this file or related software except in  |
*  |compliance with the License. You may obtain a copy of the License   |
*  |at http://www.scitechsoft.com/nucleus-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.                           |
*  |                                                                    |
*  |REMOVAL OR MODIFICATION OF THIS HEADER IS STRICTLY PROHIBITED BY LAW|
*  ======================================================================
*
* Language:     ANSI C
* Environment:  Win32
*
* Description:  OS specific Nucleus Graphics Architecture services for
*               the Win32 operating system environments.
*
****************************************************************************/

#include "pm_help.h"
#include "pmapi.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define STRICT
#define WIN32_LEAN_AND_MEAN
#include <windows.h>

/*------------------------- Global Variables ------------------------------*/

#define DLL_NAME        "nga_w32.dll"

extern HANDLE           _PM_hDevice;
static HMODULE          hModDLL = NULL;
static ibool            useRing0Driver = false;
static ibool            haveRDTSC;
static GA_largeInteger  countFreq;

/*-------------------------- Implementation -------------------------------*/

/****************************************************************************
REMARKS:
Loads the shared "nga_w32.dll" library from disk and connects to it. This
library is *always* located in the same directory as the Nucleus
graphics.bpd file.
****************************************************************************/
static ibool LoadSharedDLL(void)
{
    char                filename[PM_MAX_PATH];
    char                bpdpath[PM_MAX_PATH];

    /* Check if we have already loaded the DLL */
    if (hModDLL)
	return true;
    PM_init();

    /* Open the DLL file */
    if (!PM_findBPD(DLL_NAME,bpdpath))
	return false;
    strcpy(filename,bpdpath);
    strcat(filename,DLL_NAME);
    if ((hModDLL = LoadLibrary(filename)) == NULL)
	return false;
    return true;
}

/****************************************************************************
PARAMETERS:
path    - Local path to the Nucleus driver files.

REMARKS:
This function is used by the application program to override the location
of the Nucleus driver files that are loaded. Normally the loader code
will look in the system Nucleus directories first, then in the 'drivers'
directory relative to the current working directory, and finally relative
to the MGL_ROOT environment variable.

Note that for Win32 we also call into the loaded PMHELP device driver
as necessary to change the local Nucleus path for system wide Nucleus
drivers.
****************************************************************************/
void NAPI GA_setLocalPath(
    const char *path)
{
    DWORD   inBuf[1];
    DWORD   outBuf[1],outCnt;

    PM_setLocalBPDPath(path);
    if (_PM_hDevice != INVALID_HANDLE_VALUE) {
	inBuf[0] = (DWORD)path;
	DeviceIoControl(_PM_hDevice, PMHELP_GASETLOCALPATH32,
	    inBuf, sizeof(inBuf), outBuf, sizeof(outBuf), &outCnt, NULL);
	}
}

/****************************************************************************
RETURNS:
Pointer to the system wide PM library imports, or the internal version if none

REMARKS:
In order to support deploying new Nucleus drivers that may require updated
PM library functions, we check here to see if there is a system wide version
of the PM functions available. If so we return those functions for use with
the system wide Nucleus drivers, otherwise the compiled in version of the PM
library is used with the application local version of Nucleus.
****************************************************************************/
PM_imports * NAPI GA_getSystemPMImports(void)
{
    PM_imports * pmImp;
    PM_imports * (NAPIP _GA_getSystemPMImports)(void);

    if (LoadSharedDLL()) {
	/* Note that Visual C++ build DLL's with only a single underscore in front
	 * of the exported name while Watcom C provides two of them. We check for
	 * both to allow working with either compiled DLL.
	 */
	if ((_GA_getSystemPMImports = (void*)GetProcAddress(hModDLL,"_GA_getSystemPMImports")) != NULL) {
	    if ((_GA_getSystemPMImports = (void*)GetProcAddress(hModDLL,"__GA_getSystemPMImports")) != NULL) {
		pmImp = _GA_getSystemPMImports();
		memcpy(&_PM_imports,pmImp,MIN(_PM_imports.dwSize,pmImp->dwSize));
		return pmImp;
		}
	    }
	}
    return &_PM_imports;
}

/****************************************************************************
PARAMETERS:
gaExp   - Place to store the exported functions
shared  - True if connecting to the shared, global Nucleus driver

REMARKS:
For Win32 if we are connecting to the shared, global Nucleus driver (loaded
at ring 0) then we need to load a special nga_w32.dll library which contains
thunks to call down into the Ring 0 device driver as necessary. If we are
connecting to the application local Nucleus drivers (ie: Nucleus on DirectDraw
emulation layer) then we do nothing here.
****************************************************************************/
ibool NAPI GA_getSharedExports(
    GA_exports *gaExp,
    ibool shared)
{
    GA_exports * exp;
    GA_exports * (NAPIP _GA_getSystemGAExports)(void);

    useRing0Driver = false;
    if (shared) {
	if (!LoadSharedDLL())
	    PM_fatalError("Unable to load " DLL_NAME "!");
	if ((_GA_getSystemGAExports = (void*)GetProcAddress(hModDLL,"_GA_getSystemGAExports")) == NULL)
	    if ((_GA_getSystemGAExports = (void*)GetProcAddress(hModDLL,"__GA_getSystemGAExports")) == NULL)
		PM_fatalError("Unable to load " DLL_NAME "!");
	exp = _GA_getSystemGAExports();
	memcpy(gaExp,exp,MIN(gaExp->dwSize,exp->dwSize));
	useRing0Driver = true;
	return true;
	}
    return false;
}

#ifndef TEST_HARNESS
/****************************************************************************
REMARKS:
Nothing special for this OS
****************************************************************************/
ibool NAPI GA_queryFunctions(
    GA_devCtx *dc,
    N_uint32 id,
    void _FAR_ *funcs)
{
    static ibool (NAPIP _GA_queryFunctions)(GA_devCtx *dc,N_uint32 id,void _FAR_ *funcs) = NULL;

    if (useRing0Driver) {
	/* Call the version in nga_w32.dll if it is loaded */
	if (!_GA_queryFunctions) {
	    if ((_GA_queryFunctions = (void*)GetProcAddress(hModDLL,"_GA_queryFunctions")) == NULL)
		if ((_GA_queryFunctions = (void*)GetProcAddress(hModDLL,"__GA_queryFunctions")) == NULL)
		    PM_fatalError("Unable to get exports from " DLL_NAME "!");
	    }
	return _GA_queryFunctions(dc,id,funcs);
	}
    return __GA_exports.GA_queryFunctions(dc,id,funcs);
}

/****************************************************************************
REMARKS:
Nothing special for this OS
****************************************************************************/
ibool NAPI REF2D_queryFunctions(
    REF2D_driver *ref2d,
    N_uint32 id,
    void _FAR_ *funcs)
{
    static ibool (NAPIP _REF2D_queryFunctions)(REF2D_driver *ref2d,N_uint32 id,void _FAR_ *funcs) = NULL;

    if (useRing0Driver) {
	/* Call the version in nga_w32.dll if it is loaded */
	if (!_REF2D_queryFunctions) {
	    if ((_REF2D_queryFunctions = (void*)GetProcAddress(hModDLL,"_REF2D_queryFunctions")) == NULL)
		if ((_REF2D_queryFunctions = (void*)GetProcAddress(hModDLL,"__REF2D_queryFunctions")) == NULL)
		    PM_fatalError("Unable to get exports from " DLL_NAME "!");
	    }
	return _REF2D_queryFunctions(ref2d,id,funcs);
	}
    return __GA_exports.REF2D_queryFunctions(ref2d,id,funcs);
}
#endif

/****************************************************************************
REMARKS:
This function initialises the high precision timing functions for the
Nucleus loader library.
****************************************************************************/
ibool NAPI GA_TimerInit(void)
{
    if (_GA_haveCPUID() && (_GA_getCPUIDFeatures() & CPU_HaveRDTSC) != 0) {
	haveRDTSC = true;
	return true;
	}
    else if (QueryPerformanceFrequency((LARGE_INTEGER*)&countFreq)) {
	haveRDTSC = false;
	return true;
	}
    return false;
}

/****************************************************************************
REMARKS:
This function reads the high resolution timer.
****************************************************************************/
void NAPI GA_TimerRead(
    GA_largeInteger *value)
{
    if (haveRDTSC)
	_GA_readTimeStamp(value);
    else
	QueryPerformanceCounter((LARGE_INTEGER*)value);
}
Commit	Line	Data
c7de829c WD	1	/****************************************************************************
	2	*
	3	* SciTech Nucleus Graphics Architecture
	4	*
	5	* Copyright (C) 1991-1998 SciTech Software, Inc.
	6	* All rights reserved.
	7	*
	8	* ======================================================================
	9	* \|REMOVAL OR MODIFICATION OF THIS HEADER IS STRICTLY PROHIBITED BY LAW\|
	10	* \| \|
	11	* \|This copyrighted computer code contains proprietary technology \|
	12	* \|owned by SciTech Software, Inc., located at 505 Wall Street, \|
	13	* \|Chico, CA 95928 USA (http://www.scitechsoft.com). \|
	14	* \| \|
	15	* \|The contents of this file are subject to the SciTech Nucleus \|
	16	* \|License; you may not use this file or related software except in \|
	17	* \|compliance with the License. You may obtain a copy of the License \|
	18	* \|at http://www.scitechsoft.com/nucleus-license.txt \|
	19	* \| \|
	20	* \|Software distributed under the License is distributed on an \|
	21	* \|"AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or \|
	22	* \|implied. See the License for the specific language governing \|
	23	* \|rights and limitations under the License. \|
	24	* \| \|
	25	* \|REMOVAL OR MODIFICATION OF THIS HEADER IS STRICTLY PROHIBITED BY LAW\|
	26	* ======================================================================
	27	*
	28	* Language: ANSI C
	29	* Environment: Win32
	30	*
	31	* Description: OS specific Nucleus Graphics Architecture services for
	32	* the Win32 operating system environments.
	33	*
	34	****************************************************************************/
	35
	36	#include "pm_help.h"
	37	#include "pmapi.h"
	38	#include <stdio.h>
	39	#include <stdlib.h>
	40	#include <string.h>
	41	#define STRICT
	42	#define WIN32_LEAN_AND_MEAN
	43	#include <windows.h>
	44
	45	/------------------------- Global Variables ------------------------------/
	46
	47	#define DLL_NAME "nga_w32.dll"
	48
	49	extern HANDLE _PM_hDevice;
	50	static HMODULE hModDLL = NULL;
	51	static ibool useRing0Driver = false;
	52	static ibool haveRDTSC;
	53	static GA_largeInteger countFreq;
	54
	55	/-------------------------- Implementation -------------------------------/
	56
	57	/****************************************************************************
	58	REMARKS:
	59	Loads the shared "nga_w32.dll" library from disk and connects to it. This
	60	library is always located in the same directory as the Nucleus
	61	graphics.bpd file.
	62	****************************************************************************/
	63	static ibool LoadSharedDLL(void)
	64	{
65	char filename[PM_MAX_PATH];
66	char bpdpath[PM_MAX_PATH];
67
68	/* Check if we have already loaded the DLL */
69	if (hModDLL)
8bde7f77	70	return true;
c7de829c WD	71	PM_init();
	72
	73	/* Open the DLL file */
	74	if (!PM_findBPD(DLL_NAME,bpdpath))
8bde7f77	75	return false;
c7de829c WD	76	strcpy(filename,bpdpath);
	77	strcat(filename,DLL_NAME);
	78	if ((hModDLL = LoadLibrary(filename)) == NULL)
8bde7f77	79	return false;
c7de829c WD	80	return true;
	81	}
	82
	83	/****************************************************************************
	84	PARAMETERS:
	85	path - Local path to the Nucleus driver files.
	86
	87	REMARKS:
	88	This function is used by the application program to override the location
	89	of the Nucleus driver files that are loaded. Normally the loader code
	90	will look in the system Nucleus directories first, then in the 'drivers'
	91	directory relative to the current working directory, and finally relative
	92	to the MGL_ROOT environment variable.
	93
	94	Note that for Win32 we also call into the loaded PMHELP device driver
	95	as necessary to change the local Nucleus path for system wide Nucleus
	96	drivers.
	97	****************************************************************************/
	98	void NAPI GA_setLocalPath(
	99	const char *path)
	100	{
	101	DWORD inBuf[1];
	102	DWORD outBuf[1],outCnt;
	103
	104	PM_setLocalBPDPath(path);
	105	if (_PM_hDevice != INVALID_HANDLE_VALUE) {
8bde7f77 WD	106	inBuf[0] = (DWORD)path;
	107	DeviceIoControl(_PM_hDevice, PMHELP_GASETLOCALPATH32,
	108	inBuf, sizeof(inBuf), outBuf, sizeof(outBuf), &outCnt, NULL);
	109	}
c7de829c WD	110	}
	111
	112	/****************************************************************************
	113	RETURNS:
	114	Pointer to the system wide PM library imports, or the internal version if none
	115
	116	REMARKS:
	117	In order to support deploying new Nucleus drivers that may require updated
	118	PM library functions, we check here to see if there is a system wide version
	119	of the PM functions available. If so we return those functions for use with
	120	the system wide Nucleus drivers, otherwise the compiled in version of the PM
	121	library is used with the application local version of Nucleus.
	122	****************************************************************************/
	123	PM_imports * NAPI GA_getSystemPMImports(void)
	124	{
	125	PM_imports * pmImp;
	126	PM_imports * (NAPIP _GA_getSystemPMImports)(void);
	127
	128	if (LoadSharedDLL()) {
8bde7f77 WD	129	/* Note that Visual C++ build DLL's with only a single underscore in front
	130	* of the exported name while Watcom C provides two of them. We check for
	131	* both to allow working with either compiled DLL.
	132	*/
	133	if ((_GA_getSystemPMImports = (void*)GetProcAddress(hModDLL,"_GA_getSystemPMImports")) != NULL) {
	134	if ((_GA_getSystemPMImports = (void*)GetProcAddress(hModDLL,"__GA_getSystemPMImports")) != NULL) {
	135	pmImp = _GA_getSystemPMImports();
	136	memcpy(&_PM_imports,pmImp,MIN(_PM_imports.dwSize,pmImp->dwSize));
	137	return pmImp;
	138	}
	139	}
	140	}
c7de829c WD	141	return &_PM_imports;
	142	}
	143
	144	/****************************************************************************
	145	PARAMETERS:
	146	gaExp - Place to store the exported functions
	147	shared - True if connecting to the shared, global Nucleus driver
	148
	149	REMARKS:
	150	For Win32 if we are connecting to the shared, global Nucleus driver (loaded
	151	at ring 0) then we need to load a special nga_w32.dll library which contains
	152	thunks to call down into the Ring 0 device driver as necessary. If we are
	153	connecting to the application local Nucleus drivers (ie: Nucleus on DirectDraw
	154	emulation layer) then we do nothing here.
	155	****************************************************************************/
	156	ibool NAPI GA_getSharedExports(
	157	GA_exports *gaExp,
	158	ibool shared)
	159	{
	160	GA_exports * exp;
	161	GA_exports * (NAPIP _GA_getSystemGAExports)(void);
	162
	163	useRing0Driver = false;
	164	if (shared) {
8bde7f77 WD	165	if (!LoadSharedDLL())
	166	PM_fatalError("Unable to load " DLL_NAME "!");
	167	if ((_GA_getSystemGAExports = (void*)GetProcAddress(hModDLL,"_GA_getSystemGAExports")) == NULL)
	168	if ((_GA_getSystemGAExports = (void*)GetProcAddress(hModDLL,"__GA_getSystemGAExports")) == NULL)
	169	PM_fatalError("Unable to load " DLL_NAME "!");
	170	exp = _GA_getSystemGAExports();
	171	memcpy(gaExp,exp,MIN(gaExp->dwSize,exp->dwSize));
	172	useRing0Driver = true;
	173	return true;
	174	}
c7de829c WD	175	return false;
	176	}
	177
	178	#ifndef TEST_HARNESS
	179	/****************************************************************************
	180	REMARKS:
	181	Nothing special for this OS
	182	****************************************************************************/
	183	ibool NAPI GA_queryFunctions(
	184	GA_devCtx *dc,
	185	N_uint32 id,
	186	void _FAR_ *funcs)
	187	{
	188	static ibool (NAPIP _GA_queryFunctions)(GA_devCtx dc,N_uint32 id,void _FAR_ funcs) = NULL;
	189
	190	if (useRing0Driver) {
8bde7f77 WD	191	/* Call the version in nga_w32.dll if it is loaded */
	192	if (!_GA_queryFunctions) {
	193	if ((_GA_queryFunctions = (void*)GetProcAddress(hModDLL,"_GA_queryFunctions")) == NULL)
	194	if ((_GA_queryFunctions = (void*)GetProcAddress(hModDLL,"__GA_queryFunctions")) == NULL)
	195	PM_fatalError("Unable to get exports from " DLL_NAME "!");
	196	}
	197	return _GA_queryFunctions(dc,id,funcs);
	198	}
c7de829c WD	199	return __GA_exports.GA_queryFunctions(dc,id,funcs);
	200	}
	201
	202	/****************************************************************************
	203	REMARKS:
	204	Nothing special for this OS
	205	****************************************************************************/
	206	ibool NAPI REF2D_queryFunctions(
	207	REF2D_driver *ref2d,
	208	N_uint32 id,
	209	void _FAR_ *funcs)
	210	{
	211	static ibool (NAPIP _REF2D_queryFunctions)(REF2D_driver ref2d,N_uint32 id,void _FAR_ funcs) = NULL;
	212
	213	if (useRing0Driver) {
8bde7f77 WD	214	/* Call the version in nga_w32.dll if it is loaded */
	215	if (!_REF2D_queryFunctions) {
	216	if ((_REF2D_queryFunctions = (void*)GetProcAddress(hModDLL,"_REF2D_queryFunctions")) == NULL)
	217	if ((_REF2D_queryFunctions = (void*)GetProcAddress(hModDLL,"__REF2D_queryFunctions")) == NULL)
	218	PM_fatalError("Unable to get exports from " DLL_NAME "!");
	219	}
	220	return _REF2D_queryFunctions(ref2d,id,funcs);
	221	}
c7de829c WD	222	return __GA_exports.REF2D_queryFunctions(ref2d,id,funcs);
	223	}
	224	#endif
	225
	226	/****************************************************************************
	227	REMARKS:
	228	This function initialises the high precision timing functions for the
	229	Nucleus loader library.
	230	****************************************************************************/
	231	ibool NAPI GA_TimerInit(void)
	232	{
	233	if (_GA_haveCPUID() && (_GA_getCPUIDFeatures() & CPU_HaveRDTSC) != 0) {
8bde7f77 WD	234	haveRDTSC = true;
	235	return true;
	236	}
c7de829c	237	else if (QueryPerformanceFrequency((LARGE_INTEGER*)&countFreq)) {
8bde7f77 WD	238	haveRDTSC = false;
	239	return true;
	240	}
c7de829c WD	241	return false;
	242	}
	243
	244	/****************************************************************************
	245	REMARKS:
	246	This function reads the high resolution timer.
	247	****************************************************************************/
	248	void NAPI GA_TimerRead(
	249	GA_largeInteger *value)
	250	{
	251	if (haveRDTSC)
8bde7f77	252	_GA_readTimeStamp(value);
c7de829c	253	else
8bde7f77	254	QueryPerformanceCounter((LARGE_INTEGER*)value);
c7de829c	255	}