tmcrt.c

wince host 和 target PCI驱动程序

/* 
COPYRIGHT (c) 1997 by Philips Semiconductors

THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED AND COPIED IN 
ACCORDANCE WITH THE TERMS AND CONDITIONS OF SUCH A LICENSE AND WITH THE 
INCLUSION OF THE THIS COPY RIGHT NOTICE. THIS SOFTWARE OR ANY OTHER COPIES 
OF THIS SOFTWARE MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY OTHER
PERSON. THE OWNERSHIP AND TITLE OF THIS SOFTWARE IS NOT TRANSFERRED. 

THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT ANY PRIOR NOTICE
AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY Philips Semiconductor. 

PHILIPS ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF THIS SOFTWARE
ON PLATFORMS OTHER THAN THE ONE ON WHICH THIS SOFTWARE IS FURNISHED.
*/
/*
	Copyright (c) 1996 Philips Semiconductors - TriMedia. All rights reserved.

FILE	tmcrt.c

HISTORY	:
	960201 Tilakraj Roy		
		Created 
	961113 Tilakraj Roy		
		Pulled in from ctcmon sources
	970226	Tilakraj Roy	
		Pulled in from TMCons sources to incorporate functionality into TMMan32.dll
	970310	Tilakraj Roy	
		Added the file redirection + event signalling + context passing functionality.
	970627	Tilakraj Roy
		Added multiple DSP support and interfaces for the new TMMan interface
	970929	Tilakraj Roy
		Retrofitted for the new TMIF interface
		
COMMNETS
	Requires host_comm.lib & TMMan32.dll services
	Also requires that host_comm:INITFunc return immedately and create another worked thread.
*/

#include "windows.h"
#include "stdio.h"
#include "fcntl.h"
#include "io.h"
#include "time.h"
#include "sys\stat.h"


#include "tmtypes.h"
#include "tmmanapi.h"

#include "TM1IF.h"
#include "OpenDll.h"

#include "tmcrt.h"

#ifdef USE_DVD
#include "DVD_Ctl.h"
#endif

/* CONSTANTS */
#define	MAX_PATH_INDEX	0x20 // maximum of 32 entries may be picked from the ini file
BOOL	TraceFlag = 0;


// this is worst kludge i have ever made
// to save a parameter to a callback function.

#define TMCRT_MAGIC_PATTERN 0x005a5a5a

/* TYPEDEFS */
enum tStdHandles
{
	kLevel2StdinHandle = 0,
	kLevel2StdoutHandle = 1,
	kLevel2StderrHandle = 2
#ifdef USE_DVD
	,kDVDControHandle	= 0xfffffffe
#endif
};

typedef struct _TMCRT_STD_HANDLE
{
	DWORD	Magic:24;
	DWORD	StdType:3;
	DWORD	DSPNumber:5;
}	TMCRT_STD_HANDLE, *PTMCRT_STD_HANDLE;


/* GLOBALS */

typedef struct _TMCRT_CONTEXT 
{
	DWORD   OptionBitmap;
	DWORD   DSPHandle;
	DWORD   DSPNumber;
	HANDLE	StdInHandle;
	HANDLE	StdOutHandle;
	HANDLE	StdErrHandle;
	//event that is sianalled when the exit function is called.
	HANDLE	SynchObject;
	HANDLE	ExitObject;
	DWORD   ExitCode;
	BOOL    fServerLoaded;
	DWORD	VirtualNodeNumber;
	DWORD   ServerStatus;
	BOOL    fTargetExited;	
	DWORD   ArgumentCount;
	PVOID   ArgumentVector;
}	TMCRT_CONTEXT, *PTMCRT_CONTEXT;


///////////////////////////////////////////////////////////
VOID	StripCR ( PCHAR pBuffer, DWORD *BytesRead );
UInt32	crtPrintf ( HANDLE FileHandle, UInt8* Format, ...);
UInt32 ODS( UInt8* FormatString, ... );

DWORD	OpenFunc (  PCHAR PathName, DWORD Flags, DWORD Mode );




///////////////////////////////////////////////////////////
PTMCRT_CONTEXT	GlobalContext[constTMMANMaximumDeviceCount];
BOOL     fExitProcess = FALSE;
UInt32	g_Endian = TRUE;

///////////////////////////////////////////////////////////

DWORD	ExitCodeFunc ( DWORD DSPNumber, DWORD ExitCode )
{
	PTMCRT_CONTEXT	pCRT = (PTMCRT_CONTEXT)GlobalContext[DSPNumber];
	DWORD	BytesWritten;
	CHAR	szTemp[0x80];

	//fprintf ( stderr, "[ExitCodeFunc1|ExitCode:%x|NodeID:%x:pCRT:%x]", 
	//	ExitCode, DSPNumber, pCRT );


	if ( TraceFlag )
	{
		ODS("[ExitCodeFunc|ExitCode:%x|NodeID:%x]", ExitCode, DSPNumber );
	}

	if ( pCRT->OptionBitmap & constCRunTimeFlagsNonInteractive );
	else
	{
		crtPrintf ( pCRT->StdOutHandle, 	
			"\r\nCRunTime : TriMedia # %d Program Exit Code [%x]\n", 
			DSPNumber, ExitCode );
	}


	/* get out of this program */
	pCRT->fTargetExited = TRUE;
	pCRT->ExitCode = ExitCode;

	//fprintf ( stderr, "[ExitCodeFunc2|ExitCode:%x|NodeID:%x:pCRT:%x]", 
	//	ExitCode, DSPNumber, pCRT );

	if ( pCRT->OptionBitmap & constCRunTimeFlagsUseSynchObject)
	{
		SetEvent ( pCRT->SynchObject );
	}

	SetEvent ( pCRT->ExitObject );
	return 0;
}

DWORD	OpenDLLFunc( PCHAR pszFilename )
{
	if ( TraceFlag )
	{
		ODS("[OpenDLLFunc|FileName:%s]", pszFilename );
	}

	return OpenDll_open_dll ( pszFilename, (PVOID)OpenFunc, g_Endian );
}


DWORD	ReadFunc (  DWORD Handle, PVOID pBuffer, DWORD Count )
{
	

	PTMCRT_STD_HANDLE	EncodedHandle = (PTMCRT_STD_HANDLE)&Handle;

	static   DWORD FuncCount = 0;
	DWORD	BytesRead;

#ifdef USE_DVD
	if ( ( Handle == kDVDControHandle ) )
	{
		BytesRead = dvdRead ( pBuffer, Count );
		goto ReadFuncExit ;
	}
	
#endif

	if ( TraceFlag )
	{
		ODS("[ReadFunc#%x|Handle:%08x|Count:%x]", FuncCount, Handle, Count );
	}

	if ( fExitProcess == TRUE )
	{
		BytesRead = 0;
		goto ReadFuncExit;
	}

	if ( EncodedHandle->Magic == TMCRT_MAGIC_PATTERN )
	{
		PTMCRT_CONTEXT	pCRT = (PTMCRT_CONTEXT)GlobalContext[EncodedHandle->DSPNumber];

		// runtime destroy has already been called 
		if ( !pCRT )
		{
			BytesRead = 0;
			goto ReadFuncExit;

		}
		
		if ( EncodedHandle->StdType == kLevel2StdinHandle )
		{
			BOOL Status;
			//HANDLE		Objects[2];
			//DWORD		ObjectSignalled;

			if ( pCRT->OptionBitmap & constCRunTimeFlagsNoConsole )
			{
				BytesRead = 0;
			 goto ReadFuncExit;

			}
/*	
			Objects[0] =  pCRT->StdInHandle; 
			Objects[1] =  pCRT->ExitObject;

			if ( TraceFlag )
			{
				ODS("[ReadFunc%x|WaitingForMultipleObjects]",  FuncCount );
			}

			ObjectSignalled = WaitForMultipleObjects  ( 2, Objects, FALSE, INFINITE );

			if ( (ObjectSignalled - WAIT_OBJECT_0 ) == 1 )
			{
				BytesRead = 0;
				goto ReadFuncExit;

			}

*/
			Status = ReadFile (  pCRT->StdInHandle, 
				pBuffer, 
				Count, 
				&BytesRead,
				NULL );

			// TRC Fix to Bug# 503703
			//if ( GetFileType (pCRT->StdInHandle) == FILE_TYPE_CHAR )
				StripCR ( pBuffer, &BytesRead );

			if ( Status == TRUE  )
			{
			goto ReadFuncExit;

			}
			else
			{
				BytesRead = 0;
			 goto ReadFuncExit;
			}
		}

	}

	BytesRead = _read ( Handle, pBuffer, Count );

	// fall through
ReadFuncExit :
	if ( TraceFlag )
	{
		ODS("[ReadFunc#%x|Handle:%08x|Buffer:%08x|Returned:%x]", 
			FuncCount++, Handle, *((UInt32 *)pBuffer), BytesRead );
	}

	return BytesRead;

}


DWORD	WriteFunc ( DWORD Handle, PVOID pBuffer, DWORD Count )
{
	PTMCRT_STD_HANDLE	EncodedHandle = (PTMCRT_STD_HANDLE)&Handle;

	

	DWORD	BytesWritten;
	static DWORD FuncCount = 0;

#ifdef USE_DVD
	if ( ( Handle == kDVDControHandle ) )
	{
		BytesWritten = dvdWrite ( pBuffer, Count );
		return BytesWritten;
	}
#endif

	if ( TraceFlag )
	{
	ODS("[WriteFunc#%x|Handle:%08x|Count:%x]", 
		  FuncCount, Handle, Count );
	}

	if ( EncodedHandle->Magic == TMCRT_MAGIC_PATTERN )
	{
		PTMCRT_CONTEXT	pCRT = (PTMCRT_CONTEXT)GlobalContext[EncodedHandle->DSPNumber];
		// runtime destroy has already been called 
		if ( !pCRT )
		{
			BytesWritten = 0;
			goto WriteFuncExit;

		}
			
		if ( EncodedHandle->StdType == kLevel2StdoutHandle )
		{
			if ( pCRT->OptionBitmap & constCRunTimeFlagsNoConsole )
			{
				BytesWritten = 0;
			 goto WriteFuncExit;

			}

			if ( WriteFile (  pCRT->StdOutHandle, 
				pBuffer, 
				Count, 
				&BytesWritten,
				NULL ) != TRUE )
			{
				BytesWritten = 0;
			 goto WriteFuncExit;

			}
			else
			{
				goto WriteFuncExit;
			}
		}


		// fall through
		if ( EncodedHandle->StdType == kLevel2StderrHandle )
		{
			if ( pCRT->OptionBitmap & constCRunTimeFlagsNoConsole )
			{
				BytesWritten = 0;
			 goto WriteFuncExit;

			}

			if ( WriteFile ( pCRT->StdErrHandle, 
				pBuffer, 
				Count, 
				&BytesWritten,
				NULL ) != TRUE )
			{
				BytesWritten = 0;
			 goto WriteFuncExit;

			}
			else
			{
				goto WriteFuncExit;
			}
		}

	}

	BytesWritten  = _write ( Handle, pBuffer, Count );

	// fall through
WriteFuncExit :
	if ( TraceFlag )
	{
		ODS("[WriteFunc#%x|Handle:%08x|Buffer:%08x|Returned:%x]", 
			FuncCount++, Handle, *((UInt32 *)pBuffer), BytesWritten );
	}

	return BytesWritten;
}

DWORD	FstatFunc (DWORD Handle,  struct stat *pStat )
{
	PTMCRT_STD_HANDLE	EncodedHandle = (PTMCRT_STD_HANDLE)&Handle;

#ifdef USE_DVD
	if ( ( Handle == kDVDControHandle ) )
	{
		return -1;
	}
#endif

	if ( TraceFlag )
	{
		ODS("[FstatFunc|Handle:%x|pStat:%x]", Handle, pStat );
	}

	if ( EncodedHandle->Magic == TMCRT_MAGIC_PATTERN )
	{
		PTMCRT_CONTEXT	pCRT = (PTMCRT_CONTEXT)GlobalContext[EncodedHandle->DSPNumber];

		if ( !pCRT )
		{
			return 0;

		}
		
		if ( ( EncodedHandle->StdType == kLevel2StdinHandle ) || 
			( EncodedHandle->StdType == kLevel2StdoutHandle ) ||
			( EncodedHandle->StdType == kLevel2StderrHandle ) )
		{
			pStat->st_mode	= S_IFCHR;
			pStat->st_size	= 512;
			return 0;
		}
	}

	return _fstat ( Handle, (struct _stat *)pStat );

}
DWORD	StatFunc (PCHAR pFilename,  struct stat *pStat )
{

	if ( TraceFlag )
	{
		ODS("[StatFunc|FileName:%s|pStat:%x]", 
			pFilename, pStat );
	}

	return _stat ( pFilename, (struct _stat *)pStat );
}

DWORD	FcntlFunc ( DWORD Handle, DWORD Command, DWORD Flags )
{

	if ( TraceFlag )
	{
		ODS("[FcntlFunc|Handle:%x|Command:%x|Flags:%x]", 
			Handle, Command, Flags );
	}

	if ( Command == _O_BINARY)
	{
		return _setmode( Handle, Command );
	}
	else
	{
		return ((DWORD)~0);
	}
}

DWORD	IsattyFunc ( DWORD Handle )
{
	PTMCRT_STD_HANDLE	EncodedHandle = (PTMCRT_STD_HANDLE)&Handle;

#ifdef USE_DVD
	if ( ( Handle == kDVDControHandle ) )
	{
		return -1;
	}
#endif

	if ( TraceFlag )
	{
		ODS("[IsattyFunc|Handle:%x]", Handle );
	}

	if ( EncodedHandle->Magic == TMCRT_MAGIC_PATTERN )
	{
		PTMCRT_CONTEXT	pCRT = (PTMCRT_CONTEXT)GlobalContext[EncodedHandle->DSPNumber];

		if ( !pCRT )
		{
			return 0;
		}
		
		if ( ( EncodedHandle->StdType == kLevel2StdinHandle ) || 
			( EncodedHandle->StdType == kLevel2StdoutHandle ) ||
			( EncodedHandle->StdType == kLevel2StderrHandle ) )
		{
			return 1;
		}
	}

	return _isatty ( Handle );
}

DWORD	LseekFunc (  DWORD Handle, DWORD Offset, DWORD Origin )
{
	PTMCRT_STD_HANDLE	EncodedHandle = (PTMCRT_STD_HANDLE)&Handle;

#ifdef USE_DVD
	if ( ( Handle == kDVDControHandle ) )
	{
		return -1;
	}
#endif

	if ( TraceFlag )
	{
		ODS("[LseekFunc|Handle:%x|Offset:%x|Origin:%x]", Handle, Offset, Origin );
	}