tmmon.c

wince host 和 target PCI驱动程序

	
			if ( ! szToken )
			{	// no filename print to stdout 
				*pdwState = TRACEP_CMD;
				Status = CMD_STATUS_COMPLETE;

				tmmanDSPMapSDRAM ( pContext->CurrentDSPHandle );

				tmmanDebugDPBuffers ( 
					pContext->CurrentDSPHandle,
					&pFirstHalfBuffer, 
					&FristHalfBufferSize, 
					&pSecondHalfBuffer, 
					&SecondHalfBufferSize );
				
	
				if ( pObject->fTraceIntoFile == False )
				{
					pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
						"\r\n");

					if ( pFirstHalfBuffer ) // wrap around has occured 
					{
						pContext->pIODevVTBL->WriteChar ( pContext->pIODev,   
							pFirstHalfBuffer, FristHalfBufferSize );
					}

					pContext->pIODevVTBL->WriteChar ( pContext->pIODev, 
						pSecondHalfBuffer, SecondHalfBufferSize );
				}
				else // open the trace file and write to it 
				{
					/*
					HANDLE hFile;
					
					SYSTEMTIME	Time;
					UInt32	SizeOfMachineName;
					UInt8	szMachineName[MAX_COMPUTERNAME_LENGTH + 1];
					UInt8	szString[80];
					UInt32	BytesWritten;
					
					SizeOfMachineName = MAX_COMPUTERNAME_LENGTH + 1;
					pObject->fTraceIntoFile = False;

					if ( ( hFile  = CreateFile ( pObject->szTraceFileName , 
						GENERIC_READ | GENERIC_WRITE, 0,
						Null,
						CREATE_ALWAYS,
						FILE_ATTRIBUTE_NORMAL,
						Null ) ) == (HANDLE)-1 )
					{
						sprintf ( szString,
							"\r\nTMMon : ERROR [%x] : Creating Trace File [%s]",
							GetLastError(), pObject->szTraceFileName  );

						pContext->pIODevVTBL->WriteStr ( pContext->pIODev,	
							szString);
						break;
					}

					GetComputerName ( szMachineName, &SizeOfMachineName );
					GetLocalTime(&Time);
					sprintf ( szString,
						"TMMon:TraceFile:Machine[%s]:D[%02d.%02d.%04d]:T[%02d:%02d:%02d]\n",
						szMachineName, Time.wMonth,  Time.wDay, Time.wYear,
						Time.wHour, Time.wMinute, Time.wSecond );

					if ( WriteFile (  hFile,
						szString, strlen( szString ),
						&BytesWritten, Null ) != True )
					{
						pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
							"\r\nTMMon : ERROR : Writing Trace File Header");
						CloseHandle ( hFile );
						break;
					}
			

					if ( pFirstHalfBuffer ) // wrap around has occured 
					{
						if ( WriteFile (  hFile,  
							pFirstHalfBuffer, FristHalfBufferSize, &BytesWritten, Null ) != True )
						{
							pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
								"\r\nTMMon : ERROR : Writing Trace File");
							CloseHandle ( hFile );
							break;
						}

					}

					if ( WriteFile (  hFile,
						pSecondHalfBuffer, SecondHalfBufferSize, &BytesWritten, Null ) != True )
					{
						pContext->pIODevVTBL->WriteStr ( pContext->pIODev,
							"\r\nTMMon : ERROR : Writing Trace File");
						CloseHandle ( hFile );
						break;
					}

					CloseHandle ( hFile );
					*/
				}

				tmmanDSPUnmapSDRAM ( pContext->CurrentDSPHandle );
			}
			else // second parameter is a filename 
			{
				if ( pObject->fTraceIntoFile == True ) 
				{
					pObject->fTraceIntoFile = False;
					*pdwState = TRACEP_CMD;
					Status = CMD_STATUS_PARAMERR;
					break;
				}
				// copy the filename in to the parser data structure 
				pObject->fTraceIntoFile = True;
				strcpy ( pObject->szTraceFileName, szToken );
				break;
			}

		}
		break;

		default :
		break;

	}

CmdTracePERROR :
	return Status;

}

CMD_STATUS_CODE CmdTraceT( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	CMD_STATUS_CODE	Status = CMD_STATUS_OK;
	enum { TRACET_CMD, TRACET_PROCESS };

	UInt8*	pFirstHalfBuffer;
	UInt8*	pSecondHalfBuffer;
	UInt32	FristHalfBufferSize;
	UInt32	SecondHalfBufferSize;


	switch ( *pdwState )
	{

		case TRACET_CMD :
		*pdwState = TRACET_PROCESS;
		break;

		case TRACET_PROCESS :
		{
			tmmanDSPMapSDRAM ( pContext->CurrentDSPHandle );

			tmmanDebugTargetBuffers ( 
				pContext->CurrentDSPHandle,
				&pFirstHalfBuffer, 
				&FristHalfBufferSize, 
				&pSecondHalfBuffer, 
				&SecondHalfBufferSize );
				
			pContext->pIODevVTBL->WriteStr ( pContext->pIODev,"\r\n");

			if ( pFirstHalfBuffer ) // wrap around has occured 
			{
				pContext->pIODevVTBL->WriteChar ( pContext->pIODev, 
					pFirstHalfBuffer, FristHalfBufferSize );
			}

			pContext->pIODevVTBL->WriteChar ( pContext->pIODev,  
				pSecondHalfBuffer, SecondHalfBufferSize );

			tmmanDSPUnmapSDRAM ( pContext->CurrentDSPHandle );
		}
		*pdwState = TRACET_CMD;
		Status = CMD_STATUS_COMPLETE;
		break;

		default :
		break;

	}
	return Status;
}

CMD_STATUS_CODE CmdDSP ( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	PCMD_DSP		pObject		=  pContext->pCmdContext;	
	CMD_STATUS_CODE	Status		= CMD_STATUS_OK;
	TMStatus		TMMANStatus;
	UInt32			DSPHandle;
	tmmanDSPInfo	DSPInfo;

	enum { DSP_CMD, DSP_NUMBER, DSP_PROCESS };

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

	switch ( *pdwState )
	{
		case DSP_CMD :
		*pdwState = DSP_NUMBER;
		break;

		case DSP_NUMBER :
		*pdwState = DSP_PROCESS;
		sscanf ( szToken, "%x", &pObject->DSPNumber  );
		break;

		case DSP_PROCESS :
		if ( pObject->DSPNumber >= tmmanDSPGetNum() )
		{
			Status = CMD_STATUS_PARAMERR;
			goto CmdDSPERROR;
		}
		TMMANStatus = tmmanDSPOpen ( pObject->DSPNumber, &DSPHandle );
		TMMANStatus = tmmanDSPGetInfo ( DSPHandle, &DSPInfo );
		PrintProcessorInfo ( pContext, &DSPInfo );
		TMMANStatus = tmmanDSPClose ( pContext->CurrentDSPHandle );
		pContext->CurrentDSPHandle	= DSPHandle;
		pContext->CurrentDSPNumber	= pObject->DSPNumber;
		pContext->CurrentDSPInfo	= DSPInfo;
		*pdwState = DSP_CMD;
		Status = CMD_STATUS_COMPLETE;
		break;
	}

CmdDSPERROR : 
	return Status;
}

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

	enum { SET_CMD, SET_NAME, SET_VALUE, SET_PROCESS };

	enum { TYPE_BOOL, TYPE_NUMBER, TYPE_STRING };

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

	switch ( *pdwState )
	{
		case SET_CMD :
		*pdwState = SET_NAME;
		break;

		case SET_NAME :
		*pdwState = SET_VALUE;

		if ( stricmp ( szToken, "KeyPress" ) == 0 )
		{
			pObject->Type = TYPE_BOOL;
			pObject->Address = &pContext->WaitForKeyPress;
			break;
		}

		if ( stricmp ( szToken, "Debug" ) == 0 )
		{
			pObject->Type = TYPE_BOOL;
			pObject->Address = &pContext->Debug;
			break;
		}

		if ( stricmp ( szToken, "StdIO" ) == 0 )
		{
			pObject->Type = TYPE_BOOL;
			pObject->Address = &pContext->StdIO;
			break;
		}

		Status = CMD_STATUS_PARAMERR;
		goto CmdSetERROR;
		break;

		case SET_VALUE :
		*pdwState = SET_PROCESS;
		switch ( pObject->Type )
		{
			case  TYPE_BOOL :
			if ( stricmp ( szToken, "ON" ) == 0 )
			{
				*(UInt32*)pObject->Address = TRUE;
				break;
			}

			if ( stricmp ( szToken, "OFF" ) == 0 )
			{
				*(UInt32*)pObject->Address = FALSE;
				break;
			}
			Status = CMD_STATUS_PARAMERR;
			goto CmdSetERROR;
			break;

			case TYPE_NUMBER :
			{
				UInt32	Value;

				if ( sscanf ( szToken, "%d", &Value ) == 1 )
				{
					*(UInt32*)pObject->Address = Value;
				}
				else
				{
					Status = CMD_STATUS_PARAMERR;
					goto CmdSetERROR;
				}
			}
			break;

			case TYPE_STRING :
			strcpy ( (UInt8*)pObject->Address, szToken );
			break;

			default :
			// some thing is fucked up - real bad.
			break;

		}

		break;

		case SET_PROCESS :
		*pdwState = SET_CMD;
		Status = CMD_STATUS_COMPLETE;
		break;
	}

CmdSetERROR : 
	return Status;
}

/*----------------------------------------------------------------------------
FUNC	GetNextToken
ABOUT
	Given a CR terminated line this function returns the next available
	token, skipping all preceeding white spaces.
----------------------------------------------------------------------------*/
Bool GetNextToken( UInt8* pszString, UInt16* pwPosition,
	UInt8* pszToken  )
{
	// the different states of the Finite State Machine
	enum { GNT_WHITE_SPACE, GNT_ALPHA, GNT_NUM };

	UInt16 wState = GNT_WHITE_SPACE, fExit = 0;

	while ( ! fExit )
	{
		switch ( wState )
		{
			case GNT_WHITE_SPACE:
			// check if the string starts with a Null
			if ( pszString[*pwPosition] == '\0' ) 
			{
				return False ;
			}

			// check for white space
			//TR960223
			if ( ( iscntrl ( pszString[*pwPosition] ) )||				
				( isspace ( pszString[*pwPosition] ) ) )
				//( pszString[*pwPosition] == ' ') )
			{
				// go to the next character
				*pwPosition = *pwPosition + 1;
				break;
			}

			// all character that are not whitespace or control are 
			// valid token characters.
			// check for alphabetiacal characters.
			//if ( isalnum ( pszString[*pwPosition] ) )
			// TR960223
			{
				*pszToken++ = pszString[*pwPosition];
				*pwPosition = *pwPosition + 1;
				wState = GNT_ALPHA;
				break;
			}

			// non alpha, non WS, non numeric;
			//*pszToken++ = pszString[*pwPosition];
			//*pwPosition = *pwPosition + 1;
			//fExit=1;
			break;

			case GNT_ALPHA:
			//	if( ( isalnum ( pszString[*pwPosition] ) ) ||
			// ( pszString[*pwPosition] == '.') )
			// is a control or space appears within a string 
			// then the string ends. 
			//TR960223
			if ( ( iscntrl ( pszString[*pwPosition] ) )  ||
				( isspace (  pszString[*pwPosition] ) )	 )
			{
				fExit = 1;
			}	
			else
			{
				*pszToken++ = pszString[(*pwPosition)++];
				wState = GNT_ALPHA;
			}
			break;

			// wrong state : FSM screwed.
			default :
			break;
		}
	}
	*pszToken = '\0';
	return True;
}

/*----------------------------------------------------------------------------
FUNC	ReadInputLine
ABOUT
	Calls the device class read function and accumulates all the characters
	read until the buffers fills up or a CR is encountered.
	Echos the characters back to the output.
----------------------------------------------------------------------------*/
Bool	ReadInputLine (PTMMON_OBJECT pObject, UInt8* pszInputString)
{
	UInt16	wStringIdx;
	UInt8	bChar;

	for ( wStringIdx = 0 ; wStringIdx < (constTMManStringLength - 1 ) ; )
	{
		pObject->pIODevVTBL->ReadChar(pObject->pIODev, &bChar, 1);
		switch ( bChar )
		{
			case '\b' :
			if ( wStringIdx > 0 )
			{
				wStringIdx--;
				pObject->pIODevVTBL->WriteChar(pObject->pIODev, "\b", 1);
				pObject->pIODevVTBL->WriteChar(pObject->pIODev, " ", 1);
				pObject->pIODevVTBL->WriteChar(pObject->pIODev, "\b", 1);
			}
			break;

			case '\r' :
			case '\n' :
			pObject->pIODevVTBL->WriteChar(pObject->pIODev, &bChar, 1);

			pszInputString[wStringIdx] = 0;
			return True;

			case '\t' :
			bChar = ' ';

			//  fall 
			default :
			pszInputString[wStringIdx] = bChar;
			pObject->pIODevVTBL->WriteChar(pObject->pIODev, &bChar, 1);

			wStringIdx++;
			break;
		}
	
	}
	pszInputString[wStringIdx] = 0;
	// indicate that this string was not terminated by a CR.
	return False;
}



Bool	OpenIoDevice ( PTMMON_OBJECT pObject, UInt8* pszFilename, IODEV_TYPE iodevType  )
{
	if ( ! pszFilename[0] )
	{
		return pObject->pIODevVTBL->OpenStdIO ( pObject->pIODev, pObject->dwWindowLines, iodevType );
	}
	

	if ( strncmp ( pszFilename, "COM:", 4 ) == 0 )
	{
		return pObject->pIODevVTBL->OpenComm ( pObject->pIODev, pObject->dwPort, pObject->dwBaud, iodevType );
	}

	return pObject->pIODevVTBL->OpenFile ( pObject->pIODev, pszFilename, iodevType );
}

void main ( int argc, char *argv[] )
{
	TMMON_OBJECT		Object;
	PTMMON_OBJECT		pObject = &Object;
	TMStatus			TMMANStatus;
	tmmanVersion		Version;
	UInt8				szFilenameIn[constTMManStringLength] ;
	UInt8				szFilenameOut[constTMManStringLength];
	UInt8				szFilenameErr[constTMManStringLength];
	UInt8				szPrompt[constTMManStringLength];
	UInt8				TempString[constTMManStringLength];
	UInt16				wIdxArg;
	Bool				fExitFlag = False, fNewLine = False;
	UInt32				DSPIdx, Idx;
	UInt16				wCount = 0 ;

	// initialize default values
	pObject->CRT				= False;
	pObject->WaitForKeyPress	= True;
	pObject->Debug				= True;
	pObject->StdIO				= True; // causes stdin, stdout, stserr to be null in tmcrt

	pObject->dwPort = 2;
	pObject->dwBaud =  38400; 
	pObject->dwWindowLines = 0;
	pObject->CurrentDSPNumber = 0;
	pObject->pIODev = Null;
	pObject->pIODevVTBL = Null;
	pObject->StdIn = Null;
	pObject->StdOut = Null;
	pObject->StdErr = Null;
	pObject->UseCOMPort = False;

	for ( Idx = 0 ; Idx < constTMMANMaximumDeviceCount ; Idx ++ )
	{
		pObject->CRTHandleArray[Idx] = 0;
	}


	fprintf ( stderr, 
		"\r\nTriMedia Monitor -  Version [%d.%d.%d] (c) Philips Semiconductors",
		verGetFileMajorVersion (),
		verGetFileMinorVersion (),
		verGetFileBuildVersion () );

	fprintf ( stderr, 
		"\r\n[%s %s] : \"help\" for cmds | \"TMMon -?\" for cmd line args",
		 __DATE__, __TIME__  );


	// assume STDIO
	szFilenameIn[0] = szFilenameOut[0] = szFilenameErr[0] = 0;

	//initize the parser data structre
	
	// process the command line arguments here
	for ( wIdxArg = 1; wIdxArg < argc ; wIdxArg++ )
	{
		if( argv[wIdxArg][0] != '-' )
		{
			goto main_argerr;
		}

		switch ( toupper ( argv[wIdxArg][1]) )
		{
			case 'P' :
			sscanf(&argv[wIdxArg][2], "%d", &pObject->dwPort );
			if ( ( pObject->dwPort < 1 ) || ( pObject->dwPort > 3 ) )
			{
				goto main_argerr;
			}
			pObject->UseCOMPort = True;
			break;

			case 'B' :
			sscanf(&argv[wIdxArg][2], "%d", &pObject->dwBaud );
			if ( ( pObject->dwBaud < 110 ) || ( pObject->dwBaud > 115200 ) )
			{
				goto main_argerr;
			}
			break;

			case 'A' :
			fprintf ( stderr,
				"\nAuthor Tilakraj Roy : [e-mail]\n");