tmmon.c

PNX系列设备驱动 PNX系列设备驱动

				default:
				break;

			}


			// BEGIN APPLOAD
			if ( tmmanGetImageInfo (
				pObject->szExecutableFile,
				&ImageType,
				&ImageEndian ) != True )
			{
				sprintf ( szErrorString,
					"\r\nTMMon: ERROR  : Loading Executable [%s]: FAIL (File Not Fuond)", 
					pObject->szExecutableFile );
				pContext->pIODevVTBL->WriteStr( pContext->pIODev, szErrorString );
				*pdwState = LD_CMD;
				Status = CMD_STATUS_COMPLETE;
				break;
			}

			if ( ImageType == TMObj_AppSegment ) 
			{
				UInt8	TCSPath[constTMManPathLength];

				strcpy ( pObject->szApplicationFile, pObject->szExecutableFile );

				pObject->fDynamicApplicaiton = True;

				if ( tmmanGetTCSPath ( 
					TCSPath,
					constTMManPathLength ) != True )
				{
					sprintf ( pObject->szExecutableFile, "%s", "appshell.out" ); 
				}
				else
				{
					// TCS\lib\el\appshell.out
					sprintf ( pObject->szExecutableFile, "%s\\lib\\%s\\WinNT\\appshell.out",
						TCSPath, 
						( ImageEndian == LittleEndian ) ? "el" : "eb"  ); 
				}

			} 
			else
			{
				pObject->fDynamicApplicaiton = False;
			}


			// END APPLOAD


			if ( ( TMMANStatus = tmmanDSPLoad ( 
				pContext->CurrentDSPHandle,
				constTMManDefault, 
				pObject->szExecutableFile ) ) != statusSuccess )
			{
				sprintf ( szErrorString,
					"\r\nTMMon: ERROR  : Loading Executable [%s] : FAIL [%x](%s)", 
					pObject->szExecutableFile, TMMANStatus, tmmanGetErrorString(TMMANStatus) );
				pContext->pIODevVTBL->WriteStr( pContext->pIODev, szErrorString );
			}
			*pdwState = LD_CMD;
			Status = CMD_STATUS_COMPLETE;
		}
		break;
	}

CmdEXELoadERROR : 
	return Status;
}

CMD_STATUS_CODE CmdEXERun( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	PCMD_LOADRUN	pObject		=  pContext->pCmdContext;
	CMD_STATUS_CODE	Status = CMD_STATUS_OK;
	enum { GO_CMD, GO_ARGS };
	switch ( *pdwState )
	{
		case GO_CMD :
		*pdwState = GO_ARGS;
		// name of the executeable is argv[0]
		pObject->dwIdxArgStr = 0;
		pObject->dwCountArg = 0;

		strcpy ( 
			&pObject->ArgumentBuffer[pObject->dwIdxArgStr],
			pObject->szExecutableFile );
		pObject->ArgumentPtr[pObject->dwCountArg] = 
				&pObject->ArgumentBuffer[pObject->dwIdxArgStr];
		pObject->dwIdxArgStr += ( strlen ( pObject->szExecutableFile  ) + 1) ;
		pObject->dwCountArg += 1; // executable file name only 

		if ( pObject->fDynamicApplicaiton )
		{
			strcpy ( 
				&pObject->ArgumentBuffer[pObject->dwIdxArgStr],
				pObject->szApplicationFile );
			pObject->ArgumentPtr[pObject->dwCountArg] = 
					&pObject->ArgumentBuffer[pObject->dwIdxArgStr];
			pObject->dwIdxArgStr += ( strlen ( pObject->szApplicationFile  ) + 1) ;
			pObject->dwCountArg += 1; // executable file name only 
		}
		break;

		case GO_ARGS :
		{
			UInt8	szErrorString[constTMManStringLength];
			// check for termination of argument list
			if ( ! szToken )
			{
				UInt32	TMMANStatus;
				UInt32	DSPStatus;
				UInt32	CRTHandle;
				//tmmanDSPInternalInfo DSPInfo;

				TMMANStatus = tmmanDSPGetStatus ( pContext->CurrentDSPHandle, &DSPStatus );

				switch ( DSPStatus )
				{
					case constTMManDSPStatusReset :
					if ( pContext->CRT )
					{

						// start the C RUN Time server here.
						pContext->TMCRTParams.OptionBitmap		= 0;
						/*
						pContext->pIODevVTBL->GetHandles( pContext->pIODev,
							(HANDLE*)&pContext->TMCRTParams.StdInHandle,
							(HANDLE*)&pContext->TMCRTParams.StdOutHandle,
							(HANDLE*)&pContext->TMCRTParams.StdErrHandle );
						*/

						pContext->TMCRTParams.StdInHandle = (UInt32)GetStdHandle ( STD_INPUT_HANDLE );
						pContext->TMCRTParams.StdOutHandle = (UInt32)GetStdHandle ( STD_OUTPUT_HANDLE );
						pContext->TMCRTParams.StdErrHandle = (UInt32)GetStdHandle ( STD_ERROR_HANDLE );

						pContext->TMCRTParams.VirtualNodeNumber = pContext->CurrentDSPNumber;
						pContext->TMCRTParams.CRTThreadCount	= 1;


						if ( ( cruntimeCreate( 
							pContext->CurrentDSPNumber,
							pObject->dwCountArg ,
							(char**)pObject->ArgumentPtr,
							&pContext->TMCRTParams,
							&CRTHandle ) ) == NULL )
						{
							sprintf ( szErrorString,
								"\r\nTMMon: ERROR  : Starting C Run Time Server : FAIL " );
							pContext->pIODevVTBL->WriteStr( pContext->pIODev, szErrorString );
						}
						else
						{
							pContext->CRTHandleArray[pContext->CurrentDSPNumber] = CRTHandle;
						}
					}
					else
					{
						STARTUPINFO			StartupInformation;
						PROCESS_INFORMATION	ProcessInformation;
						CHAR				szCommandString[1024];
						CHAR				szTempString[80];
						UInt32				Idx;
						HANDLE				StartEventHandle = NULL;
						TCHAR				StartEventName[MAX_PATH];


						// spawn off tmrun here with the proper command line atguments.
						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;
						//StartupInformation.dwFlags          = STARTF_USESHOWWINDOW;//0; //STARTF_USESTDHANDLES;
						//StartupInformation.wShowWindow      = SW_SHOWMINIMIZED; //0;
						/*
						wsprintf ( szCommandString, 
							"tmrun -s -d%x -w%d", 
							pContext->CurrentDSPNumber,
							999 ); // BUGCHECK : Hardcoded Windows Size
						*/
						wsprintf ( szCommandString, 
							"tmrun -s -d%x ", 
							pContext->CurrentDSPNumber );

						if ( pContext->WaitForKeyPress != True )
						{
							strcat ( szCommandString, "-b " );
						}


						for ( Idx = 0 ; Idx < pObject->dwCountArg ; Idx ++ )
						{
							strcat ( szCommandString, " " );
							strcat ( szCommandString, pObject->ArgumentPtr[Idx]);
						}

						OutputDebugString ( szCommandString );

						wsprintf ( 
							StartEventName, 
							TEXT("TMCRTStartEvent%d"), 
							pContext->CurrentDSPNumber );

						if ( NULL == ( StartEventHandle = CreateEvent ( 
							NULL,	//security attributes
							FALSE,	//manual reset
							FALSE,	//initial state
							StartEventName ) ) )
						{
							sprintf ( szErrorString,
								"\r\nTMMon: ERROR  : Creating C Run Time Synchronization Event : FAIL" );
							pContext->pIODevVTBL->WriteStr( pContext->pIODev, szErrorString );
						}


						if ( CreateProcess (NULL, //"tmrun.exe",
							szCommandString, // command line formed 
							NULL,
							NULL,
							TRUE,
							CREATE_NEW_CONSOLE | NORMAL_PRIORITY_CLASS,
							NULL,NULL,
							&StartupInformation,
							&ProcessInformation ) != TRUE )
						{
							sprintf ( szErrorString,
								"\r\nTMMon: ERROR  : Spawning C Run Time Server : FAIL" );
							pContext->pIODevVTBL->WriteStr( pContext->pIODev, szErrorString );
						}
						else
						{
							if ( StartEventHandle )
							{
								switch ( WaitForSingleObject (StartEventHandle, 10000 ) )
								{
									case WAIT_OBJECT_0 :
									// everything OK
									break;

									case WAIT_ABANDONED :
									case WAIT_TIMEOUT :
									sprintf ( szErrorString,
                                                                                "\r\nTMMon: ERROR  : C Run Time Startup Synchronization : TIMEOUT" );
									pContext->pIODevVTBL->WriteStr( pContext->pIODev, szErrorString );
									break;
								}
								//Sleep( 3000 );	
							}
						}

						if ( StartEventHandle )
						{
							CloseHandle ( StartEventHandle );
						}
					}

					tmmanDSPStart ( pContext->CurrentDSPHandle );
					break;
				
					case constTMManDSPStatusRunning :
					pContext->pIODevVTBL->WriteStr ( pContext->pIODev,  
						"\r\nTMMon: ERROR  : Program Already Running On TriMedia" );
					break;

					default :
					pContext->pIODevVTBL->WriteStr ( pContext->pIODev,  
						"\r\nTMMon: ERROR  : TriMedia in Unknown State" );
					break;

				}

				*pdwState = GO_CMD;
				Status = CMD_STATUS_COMPLETE;
			}
			else
			{
				// input buffer overflow is already checked by ReadInputLine
				if ( pObject->dwCountArg >= constTMManMaximumArgumentCount )
				{
					pContext->pIODevVTBL->WriteStr ( pContext->pIODev,  
						"\r\nTMMon: WARNING  : To Many Arguments : Ignoring Arguments" );
				}
				else
				{

					strcpy ( 
						&pObject->ArgumentBuffer[pObject->dwIdxArgStr], szToken );
					pObject->ArgumentPtr[pObject->dwCountArg] = 
						&pObject->ArgumentBuffer[pObject->dwIdxArgStr];
					pObject->dwIdxArgStr += ( strlen ( szToken ) + 1) ;
					pObject->dwCountArg++;
				}

			}
		}
		break;
	}

	return Status;
}

CMD_STATUS_CODE CmdEXEStop( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	CMD_STATUS_CODE	Status = CMD_STATUS_OK;

	enum { ST_CMD, ST_PROCESS };
	UInt32	DSPStatus;

	switch ( *pdwState )
	{
		case ST_CMD :
		*pdwState = ST_PROCESS;
		break;

		case ST_PROCESS :
		{
			tmmanDSPGetStatus ( pContext->CurrentDSPHandle, &DSPStatus );

			switch ( DSPStatus )
			{
				case constTMManDSPStatusReset :
				pContext->pIODevVTBL->WriteStr ( pContext->pIODev,  
					"\r\nTMMon: WARNING  : No Program Running On TriMedia" );

				// fall through
				case constTMManDSPStatusRunning :
				tmmanDSPStop( pContext->CurrentDSPHandle );

				// stop the CRunTime Server if it is running
				if ( pContext->CRT )
				{
					if ( pContext->CRTHandleArray[pContext->CurrentDSPNumber] )
					{
						UInt32 ExitCode;
						
						cruntimeDestroy ( 
							pContext->CRTHandleArray[pContext->CurrentDSPNumber], &ExitCode );
						pContext->CRTHandleArray[pContext->CurrentDSPNumber] = 0;
					}
				}
				else
				{
					// signal  the event that whacks tmrun
					HANDLE	hServerEvent;
					CHAR	szEventName[80];
					wsprintf( szEventName, "TMRunExitEvent%x", pContext->CurrentDSPNumber );

					if ( ( hServerEvent = OpenEvent ( EVENT_MODIFY_STATE, TRUE,
						szEventName ) ) != NULL )
					{
						SetEvent ( hServerEvent );
						CloseHandle (  hServerEvent );
					}

				}
				break;

			}
		}

		*pdwState = ST_CMD;
		Status = CMD_STATUS_COMPLETE;
		break;
	}

	return Status;
}

CMD_STATUS_CODE CmdHelp( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	CMD_STATUS_CODE	Status = CMD_STATUS_OK;
	enum { HL_CMD, HL_PROCESS };

	switch ( *pdwState )
	{
		case HL_CMD :
		*pdwState = HL_PROCESS;
		break;

		case HL_PROCESS :

		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,  
			"\r\n TMMon command set : " );

		pContext->pIODevVTBL->WriteStr ( pContext->pIODev, 
			"\r\n HELP : Prints this Help Screen");
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev, 
			"\r\n QUIT : Quit the Monitor");

		pContext->pIODevVTBL->WriteStr ( pContext->pIODev, 
			"\r\n DSP DSPNumber : Switch Current DSP");

		pContext->pIODevVTBL->WriteStr ( pContext->pIODev, 
			"\r\n RB <Address> <Length> : Read Byte <- Memory");
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n RW <Address> <Length> : Read Word <- Memory");
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n RD <Address> <Length> : Read Dword <- Memory");
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n WB <Address> <Byte1> <Byte2> <Byte3> ...  : Write Byte -> Memory");
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n WW <Address> <Word1> <Word2> <Word3>...  : Write Word -> Memory");
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n WD <Address> <Dword1> <Dword2> <Dword3>... : Write Dword -> Memory");

		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n LOAD <filename> : Load Executeable Image -> Memory");
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n RUN <arg1> <arg2>... : Execute TM code");
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n STOP : Stops program execution on TriMedia");
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n RESET : Reinitializes the TM processor after hardware reset");

		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n DP : Dump Persistent Trace Buffer");
		/*
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n DT : Dump TMMan Internal Debug Buffers");
		*/
		pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
			"\r\n SET <variable> <value> : Set TMMon Variable");

		*pdwState = HL_CMD;
		Status = CMD_STATUS_COMPLETE;
		break;
	}
	return Status;
}

CMD_STATUS_CODE CmdEXEReset( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	CMD_STATUS_CODE	Status = CMD_STATUS_OK;
	enum { RS_CMD, RS_PROCESS };

	switch ( *pdwState )
	{
		case RS_CMD :
		*pdwState = RS_PROCESS;
		break;

		case RS_PROCESS :
		tmmanDSPReset ( pContext->CurrentDSPHandle );
		*pdwState = RS_CMD;
		Status = CMD_STATUS_COMPLETE;
		break;
	}
	return Status;
}

/*
CMD_STATUS_CODE CmdDebug( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	CMD_STATUS_CODE	Status = CMD_STATUS_OK;
	PCMD_DEBUG	pObject = pContext->pCmdContext;
	

	enum { DB_CMD, DB_ONOFF, DB_PARAM  };

	if ( ( szToken == Null )  && ( *pdwState != DB_PARAM ) )
	{
		Status = CMD_STATUS_INADEQUATE;
		goto CmdDebugERROR;
	}

	switch ( *pdwState )
	{
		case	DB_CMD :
		*pdwState = DB_ONOFF;
		pObject->fDebugOn = False;
		pObject->DebugOptions;
		break;

		case DB_ONOFF :
		*pdwState = DB_PARAM;
		if ( stricmp ( szToken , "ON" ) == 0 )
		{
			pObject->fDebugOn = True;
			break;
		}

		if ( stricmp ( szToken , "OFF" ) == 0 )
		{
			pObject->fDebugOn = False;
			break;
		}
		// syntax error 
		*pdwState = DB_CMD;
		Status = CMD_STATUS_PARAMERR;
		break;

		case DB_PARAM :
		if ( ! szToken ) // set the options 
		{
			UInt32	OptionBits;
			tmDBGGetOptions( pContext->CurrentDSPHandle, &OptionBits );

			if ( pObject->fDebugOn )
			{
				tmDBGSetOptions ( pContext->CurrentDSPHandle, OptionBits | pObject->DebugOptions );
			}
			else
			{
				tmDBGSetOptions ( pContext->CurrentDSPHandle, OptionBits & (~pObject->DebugOptions) );
			}
			*pdwState = DB_CMD;
			Status = CMD_STATUS_COMPLETE;
		}
		else // process the next debug on option 
		{
			UInt32 Options;
			if ( ( Options = GetDebugBit ( szToken ) ) != 0 )
			{
				if ( pObject->fDebugOn )
				{
					pObject->DebugOptions |= Options;
				}
				else
				{
					 pObject->DebugOptions &= Options;
				}
			}
			else
			{
				*pdwState = DB_CMD;
				Status = CMD_STATUS_PARAMERR;
				goto CmdDebugERROR;
			}
		}
		break;
	
		default :
		break;
	}

CmdDebugERROR :
	return Status;
}

*/
CMD_STATUS_CODE CmdTraceP( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	enum { TRACEP_CMD, TRACEP_FILENAME } ;
	PCMD_TRACEP	pObject = pContext->pCmdContext;
	CMD_STATUS_CODE	Status = CMD_STATUS_OK;
	UInt8*	pFirstHalfBuffer;
	UInt8*	pSecondHalfBuffer;
	UInt32	FristHalfBufferSize;
	UInt32	SecondHalfBufferSize;

	if ( ( szToken == Null )  && ( *pdwState != TRACEP_FILENAME ) )
	{
		Status = CMD_STATUS_INADEQUATE;
		goto CmdTracePERROR;
	}

	switch ( *pdwState )
	{

		case	TRACEP_CMD :
		*pdwState = TRACEP_FILENAME;
		pObject->fTraceIntoFile = False;
		break;

		case	TRACEP_FILENAME :
		{