tmman32.c

wince host 和 target PCI驱动程序

	if ( DeviceIoControl ( Global.hDevice, (DWORD)(TMIF_DIOC_DSPSETMISCINFO),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DSPMISCINFO),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DSPMISCINFO),
		&dwBytesReturned, NULL ) != TRUE )
	{
		return TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}


	return TMIF.Status;
}

STATUS	tmDSPExecutableRun ( DWORD DSPHandle, DWORD StartingAddress, 
	PTMMAN_TMCONS_PARAMS pTMConsParams )
{
	TMIF_STRUCT_DSPEXECUTABLERUN	TMIF;

	STATUS	Status = TMOK;
	TMMAN_DSP_CAPS DSPCaps;
	TMMAN_DSP_INFO DSPInfo;
	DWORD	BytesReturned;

	STARTUPINFO			StartupInformation;
	PROCESS_INFORMATION	ProcessInformation;

	HANDLE		hFile, StartObject;
	// maximum size of command string in DOS box.
	BYTE		szCommandString[128];
	PVOID		pBuffer;
	DWORD		ExitCode, dwWindowSize;
	CHAR		szTempString[80];
	BYTE		szDeviceName[0x10];

	DWORD		CreateProcessFlags = (CREATE_NEW_CONSOLE | NORMAL_PRIORITY_CLASS);


	tmDSPGetCaps ( DSPHandle , &DSPCaps );
	tmDSPGetMiscInfo ( DSPHandle , &DSPInfo );

	// if TMMan shared symbol is not patched then TMCons is not loaded
	// since the target is not linked with libtmman.a
	if ( ( DSPInfo.Flags & TMIF_DSPMISCINFO_SYMBOLNOTPATCHED ) || 
		// pTMCons is normally passed as NULL, to allow TMMan32 to take default action
		( (pTMConsParams ) && ( pTMConsParams->fIgnoreTMCons ) ) ); // don't load tmcons.
	else // load tmcons
	{

		StartupInformation.cb               = sizeof (STARTUPINFO);
		StartupInformation.lpReserved       = 0;
		StartupInformation.lpDesktop        = NULL;
		StartupInformation.lpTitle          = NULL;
		StartupInformation.dwX              = 0;
		StartupInformation.dwY              = 0;
		StartupInformation.dwXSize          = 0;
		StartupInformation.dwYSize          = 0;
		StartupInformation.dwXCountChars    = 0;
		StartupInformation.dwYCountChars    = 0;
		StartupInformation.dwFillAttribute  = 0;
		StartupInformation.dwFlags          = 0; //STARTF_USESTDHANDLES;
		StartupInformation.wShowWindow      = 0;
		StartupInformation.cbReserved2      = 0;
		StartupInformation.lpReserved2      = 0;
		
		
		
		wsprintf( szTempString, "TMConsStartEvent%x", DSPCaps.DSPNumber );
		if ( ( StartObject = 
			CreateEvent (NULL, TRUE, FALSE, szTempString) ) == NULL )
		{
			OutputDebugString(
				"tmman32:tmDSPExecutableRun:CreateEvent:TMConsStartEvent#:FAIL\n");
			Status = TM_STATUS ( TMMAN32_ERR_CREATEEVENTFAIL );
		}

		wsprintf ( szCommandString, "tmcons -d%x", DSPCaps.DSPNumber );

		if ( pTMConsParams )
		{
			if ( pTMConsParams->fUseWindowSize )
			{
				wsprintf ( szTempString, " -w%x",pTMConsParams->dwWindowSize ); 
				strcat ( szCommandString, szTempString);
			}
			else
			{
				// read the clock speed from the tmman.ini file
				wsprintf ( szDeviceName, "Device.%x", DSPCaps.DSPNumber );
				dwWindowSize = GetPrivateProfileInt (
					szDeviceName, "WindowSize", DEFAULT_WINDOW_SIZE, "tmman.ini" );

				// if there is a value specified in the tmman.ini file
				if ( dwWindowSize != DEFAULT_WINDOW_SIZE  )
				{
					wsprintf ( szTempString, " -w%x", dwWindowSize );
					strcat ( szCommandString, szTempString);
 				}
			}

			if ( pTMConsParams->fRedirectedStdin )
			{
				wsprintf ( szTempString, " -ri %s",pTMConsParams->szFilenameStdin ); 
				strcat ( szCommandString, szTempString);
			}
			
			if ( pTMConsParams->fRedirectedStdout )
			{
				wsprintf ( szTempString, " -ro %s",pTMConsParams->szFilenameStdout ); 
				strcat ( szCommandString, szTempString);
			}
						
			if ( pTMConsParams->fRedirectedStderr )
			{
				wsprintf ( szTempString, " -re %s",pTMConsParams->szFilenameStderr ); 
				strcat ( szCommandString, szTempString);
			}
			if ( pTMConsParams->fUseTMMonWindow )
			{
				StartupInformation.dwFlags          = STARTF_USESHOWWINDOW;//0; //STARTF_USESTDHANDLES;
				StartupInformation.wShowWindow      = SW_SHOWMINIMIZED; //0;
				//CreateProcessFlags = NORMAL_PRIORITY_CLASS;
			}

		}
		else
		{
			// read the clock speed from the tmman.ini file
			wsprintf ( szDeviceName, "Device.%x", DSPCaps.DSPNumber );
			dwWindowSize = GetPrivateProfileInt (
				szDeviceName, "WindowSize", DEFAULT_WINDOW_SIZE, "tmman.ini" );

			// if there is a value specified in the tmman.ini file
			if ( dwWindowSize != DEFAULT_WINDOW_SIZE  )
			{
				wsprintf ( szTempString, " -w%x", dwWindowSize );
				strcat ( szCommandString, szTempString);
 			}
		} 

		if ( CreateProcess (NULL, //"tmcons.exe",
			szCommandString, // command line formed 
			NULL,
			NULL,
			TRUE,
			CreateProcessFlags,
			NULL,NULL,
			&StartupInformation,
			&ProcessInformation ) != TRUE )
		{
			wsprintf ( szTemp, "tmman32:tmDSPExecutableRun:CreateProcess[tmcons]:FAIL[%x]\n", GetLastError() );
			OutputDebugString( szTemp );
			Status = TM_STATUS ( TMMAN32_ERR_CREATEPROCESSTMCONSFAIL );
			goto tmDSPExecutableRunExit;
		}


		WaitForSingleObject(StartObject, 30000 ); //INFINITE );
	}

	TMIF.DSPHandle = DSPHandle;
	TMIF.ClientHandle = Global.dwClientHandle;
	if ( StartingAddress == TMMAN_DEFAULT )
	{
		TMIF.PhysStartAddr = DSPCaps.SDRAM.dwPhysical;
	}
	else
	{
		TMIF.PhysStartAddr = StartingAddress;
	}

	if ( DeviceIoControl ( Global.hDevice,
		(DWORD)(TMIF_DIOC_DSPEXECUTABLERUN),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DSPEXECUTABLERUN),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DSPEXECUTABLERUN),
		&BytesReturned, NULL ) != TRUE )
	{
		OutputDebugString( "tmman32:tmDSPExecutableRun:DevIoCtl:FAIL\n" );	
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
	}

	
tmDSPExecutableRunExit :
	CloseHandle ( StartObject );
	return Status;
}

STATUS	tmDSPExecutableStop ( DWORD DSPHandle )
{
	TMIF_STRUCT_DSPEXECUTABLESTOP	TMIF;
	TMMAN_DSP_CAPS DSPCaps;
	DWORD	BytesReturned;
	STATUS	Status = TMOK;
	HANDLE	hServerEvent;
	CHAR	szEventName[80];

	tmDSPGetCaps ( DSPHandle , &DSPCaps );

	// use the dsp number to link to the server event 
	wsprintf( szEventName, "TMConsExitEvent%x", DSPCaps.DSPNumber );

	if ( ( hServerEvent = OpenEvent ( EVENT_MODIFY_STATE, TRUE,
		szEventName ) ) != NULL )
	{
		SetEvent ( hServerEvent );
		CloseHandle (  hServerEvent );
	}
	else
	{
		OutputDebugString(
			"tmman32:tmDSPExecutableStop:OpenEvent:TMConsExitEvent#:FAIL\n");
		Status = TM_STATUS ( TMMAN32_ERR_OPENEVENTFAIL );
	}

	TMIF.DSPHandle = DSPHandle;
	TMIF.ClientHandle = Global.dwClientHandle;

	if ( DeviceIoControl ( Global.hDevice,
		(DWORD)(TMIF_DIOC_DSPEXECUTABLESTOP),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DSPEXECUTABLESTOP),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DSPEXECUTABLESTOP),
		&BytesReturned, NULL ) != TRUE )
	{
		OutputDebugString( "tmman32:tmDSPExecutableStop:DevIoCtl:FAIL\n" );	
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
	}


	return Status;
}

STATUS	tmDSPReset ( DWORD DSPHandle )
{
	TMIF_STRUCT_DSPRESET	TMIF;
	DWORD	BytesReturned;
	STATUS	Status = TMOK;

	TMIF.DSPHandle = DSPHandle;
	TMIF.ClientHandle = Global.dwClientHandle;

	if ( DeviceIoControl ( Global.hDevice,
		(DWORD)(TMIF_DIOC_DSPRESET),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DSPRESET),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DSPRESET),
		&BytesReturned, NULL ) != TRUE )
	{
		OutputDebugString( "tmman32:tmDSPReset:DevIoCtl:FAIL\n" );	
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
	}


	return Status;

}


// BUFFER FUNCTIONS 
STATUS	tmBufferPrepare ( DWORD DSPHandle, PVOID pvBufferAddr,
	DWORD dwBufferSize, PDWORD	pdwPhysicalAddress, PDWORD pdwHandle )
{
	TMIF_STRUCT_BUFFERPREPARE	TMIF;
	DWORD	BytesReturned;
	STATUS	Status = TMOK;

	TMIF.DSPHandle = DSPHandle;
	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.dwAddress = (DWORD)pvBufferAddr;
	TMIF.dwSize = dwBufferSize;

	if ( DeviceIoControl ( Global.hDevice,
		(DWORD)(TMIF_DIOC_BUFFERPREPARE),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_BUFFERPREPARE),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_BUFFERPREPARE),
		&BytesReturned, NULL ) != TRUE )
	{
		OutputDebugString( "tmman32:tmDSPExecutableStop:DevIoCtl:FAIL\n" );	
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
		*pdwPhysicalAddress = TMIF.dwPhysicalAddress;
		*pdwHandle = TMIF.dwBufferHandle;
	}
	return Status;
}

STATUS	tmBufferUnprepare ( DWORD dwHandle )
{
	TMIF_STRUCT_BUFFERUNPREPARE	TMIF;
	DWORD	BytesReturned;
	STATUS	Status = TMOK;
	
	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.dwBufferHandle = dwHandle;
	
	if ( DeviceIoControl ( Global.hDevice,
		(DWORD)(TMIF_DIOC_BUFFERUNPREPARE),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_BUFFERUNPREPARE),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_BUFFERUNPREPARE),
		&BytesReturned, NULL ) != TRUE )
	{
		OutputDebugString( "tmman32:tmDSPExecutableStop:DevIoCtl:FAIL\n" );	
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
	}
	return Status;
}

// PARAMETER SET & GET FUNCTIONS 
STATUS	tmParameterDWORDSet ( DWORD	DSPHandle, DWORD ID, DWORD Value )
{
	TMIF_STRUCT_DWORDPARAMGETSET	TMIF;
	DWORD	BytesReturned;
	STATUS	Status = TMOK;

	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.DSPHandle = DSPHandle;
	TMIF.ParamID = ID;
	TMIF.Value = Value;
	
	if ( DeviceIoControl ( Global.hDevice,
		(DWORD)(TMIF_DIOC_DWORDPARAMSET),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DWORDPARAMGETSET),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DWORDPARAMGETSET),
		&BytesReturned, NULL ) != TRUE )
	{
		OutputDebugString( "tmman32:tmDSPExecutableStop:DevIoCtl:FAIL\n" );	
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
	}
	return Status;
}

/* 
	tmParameterDWORDGet
	get parameters for counterparts running on DSP 
*/
STATUS	tmParameterDWORDGet ( DWORD	DSPHandle, DWORD ID, PDWORD pValue )
{
	TMIF_STRUCT_DWORDPARAMGETSET	TMIF;
	DWORD	BytesReturned;
	STATUS	Status = TMOK;

	TMIF.ClientHandle = Global.dwClientHandle;
	TMIF.DSPHandle = DSPHandle;
	TMIF.ParamID = ID;
	
	if ( DeviceIoControl ( Global.hDevice,
		(DWORD)(TMIF_DIOC_DWORDPARAMGET),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DWORDPARAMGETSET),
		(PVOID)&TMIF, sizeof (TMIF_STRUCT_DWORDPARAMGETSET),
		&BytesReturned, NULL ) != TRUE )
	{
		OutputDebugString( "tmman32:tmDSPExecutableStop:DevIoCtl:FAIL\n" );	
		Status = TM_STATUS ( TMMAN32_ERR_DEVIOCTLFAIL );
	}
	else
	{
		Status = TMIF.Status;
		*pValue = TMIF.Value;
	}
	return Status;
}


BOOL    halValidateAddress ( PTMSTD_MEMORY_BLOCK pMem, DWORD dwAddress )
{

    if( ( dwAddress >= pMem->dwPhysical ) &&
        ( dwAddress <= (pMem->dwPhysical + pMem->dwSize - 1)))
    {
        return TRUE;
    }

    return FALSE;
}

BOOL    halValidateLength ( PTMSTD_MEMORY_BLOCK pMem, DWORD dwAddress,
    DWORD dwLength )
{

    // assumes that MMIO and SDRAM are not contigious.
    if ( ( dwAddress >= pMem->dwPhysical ) &&
        ( dwAddress < (pMem->dwPhysical + pMem->dwSize - 1)))
    {
        if ( ( dwAddress + dwLength ) <=
            (pMem->dwPhysical + pMem->dwSize - 1))
            return TRUE;
        else
            return FALSE;
    }

    
    return FALSE;
}



VOID	ErrorBox ( PCHAR pszErrorString )
{
	MessageBox ( NULL,
	pszErrorString,
	"TriMedia Manager : tmman32.dll : FATAL ERROR",
	MB_OK | MB_ICONSTOP | MB_DEFBUTTON1 | MB_APPLMODAL );

}

PCHAR tmGetErrorString ( DWORD Code )
{
   switch ( Code )
   {
		case	TMMAN32_ERR_CREATEPROCESSTMCONSFAIL : return "TMCons.exe could not be started/found";
		case	TMMAN32_ERR_MEMALLOCFAIL : return "Image Buffer Memory Allocation failure";
		case	TMMAN32_ERR_MINVERSIONERROR : return "TMMan32 Minor Version Mismatch";
		case	TMMAN32_ERR_MAJVERSIONERROR : return "TMMan32 Major Version Mismatch";
		case	TMMAN32_ERR_UNKNOWNCOMPONENT : return "Error Component code is not recognized by tmman32";
		case	TMMAN32_ERR_DEVIOCTLFAIL : return "TMMan Internal Error DeviceIoControl FAIL";
		case	TMMAN32_ERR_CREATEEVENTFAIL : return "TMConsStartEvent cannot be created : TMCons may be runnning";
		case	TMMAN32_ERR_OPENEVENTFAIL : return "TMConsExitEvent cannot be Opened : TMCons is not runnning";
		case	TMMAN32_ERR_IMAGENOTLITTLEENDIAN : return "Target is not Little Endian, link with -target Win95 option";

		default : /* not a tmman error code */
		if ( ( ( Code & 0xffff0000  ) >> 16 ) == TM_STATUS_HCOMP_TMLD ) 
		{
			return TMDwnLdr_get_last_error( Code & 0x0000ffff );
		}
		else
		{
			return "Unknown Error Code";
		}
	}
}


BOOL	tmGetImageInfo (
	CHAR*	ImagePath,
	DWORD*	TypePtr,
	DWORD*	EndianPtr )
{
	HANDLE				ImageFileHandle;
	TMObj_Module_Rec	ExecutableHeader;
	DWORD				BytesReturned;

	// BEGIN APPLOAD

	if ( ( ImageFileHandle = CreateFile ( 
		ImagePath,
		GENERIC_READ,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL ) ) == INVALID_HANDLE_VALUE )
	{
		OutputDebugString ( "tmman32:tmmanGetModuleInfo:CreateFile:FAIL\n" );
		return FALSE;
	}


	if ( ReadFile( ImageFileHandle,
		&ExecutableHeader,
		sizeof(TMObj_Module_Rec),
		&BytesReturned, 
		NULL ) == FALSE )
	{
		OutputDebugString ( "tmman32:tmmanGetModuleInfo:ReadFile:FAIL\n" );
		CloseHandle ( ImageFileHandle );
		return FALSE;
	}

	if ( BytesReturned != sizeof(TMObj_Module_Rec) )
	{
		OutputDebugString ( "tmman32:tmmanGetModuleInfo:ReadFile:sizeof(TMObj_Module_Rec):FAIL\n" );
		CloseHandle ( ImageFileHandle );
		return FALSE;
	}

	CloseHandle ( ImageFileHandle );

	*TypePtr = (UInt32)ExecutableHeader.type ;
	*EndianPtr = (UInt32)ExecutableHeader.code_endian;
	return TRUE;
}

BOOL	tmGetTCSPath ( 
	CHAR*	TCSPathBuffer,
	DWORD	TCSPathBufferLength )
{
	GetPrivateProfileString (
		"DLLPath", 
		"TCS", 
		"DEFAULT", 
		TCSPathBuffer, 
		TCSPathBufferLength, 
		"tmman.ini" );

	if ( _stricmp ( TCSPathBuffer, "DEFAULT" ) == 0 )
	{
		return FALSE;
	}
	else
	{
		return TRUE;
	}
}