/*
COPYRIGHT (c) 1996 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) 1997 Philips Semiconductors - TriMedia. All rights reserved.

FILE	tmmon.c

HISTROY
	970211	Tilakraj Roy	Completely rearchitected to resolve existing problems 
	970812	Tilakraj Roy	Ported to generic TMMan Interface. 
*/
#include "windows.h"
#include "stdio.h"
#include "string.h"
#include "ctype.h"





#include "tmmanapi.h"
#include "tmcrt.h"
#include "verinfo.h"
#include "tmmanlib.h"
#include "iodev.h"

#include "TMObj.h"

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

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

typedef enum  
{
	CMD_STATUS_OK,				// 0	OK
	CMD_STATUS_PARSEERR,		// 1	Parser Error
	CMD_STATUS_QUIT,			// 2	End of Session
	CMD_STATUS_INADEQUATE,		// 3	Inadequate Input
	CMD_STATUS_PARAMERR,		// 4	Parameter Validation Error
	CMD_STATUS_PARAMEXTRA,		// 5	Extra Input
	CMD_STATUS_COMPLETE			// 6	Command Completed Successfully
}	CMD_STATUS_CODE;

typedef struct	_TMMON_OBJECT
{
	// current DSP specific Parameters
	UInt32			DSPCount;
	UInt32			CurrentDSPNumber;
	UInt32			CurrentDSPHandle;
	tmmanDSPInfo	CurrentDSPInfo;

	// flags that can be altered via the set command
	Bool			CRT;
	Bool			WaitForKeyPress;
	Bool			Debug;
	Bool			StdIO; // causes stdin, stdout, stserr to be null in tmcrt


	// global context
	Pointer			pIODev;
	PIODEVICE_VTBL	pIODevVTBL;
	Pointer			StdIn;
	Pointer			StdOut;
	Pointer			StdErr;
	Pointer			pCmdContext;
	Bool			UseCOMPort;
	UInt32			dwPort; 
	UInt32			dwBaud;
	UInt32			dwWindowLines;
	CRunTimeParameterBlock	TMCRTParams;
	UInt32			CRTHandleArray[constTMMANMaximumDeviceCount];
}	TMMON_OBJECT, *PTMMON_OBJECT;

typedef CMD_STATUS_CODE ( *COMMAND_FUNCTION )( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );

typedef struct _TMMON_COMMAND
{
	UInt8				szCommand[constTMManStringLength];
	COMMAND_FUNCTION	CommandFunction;
	Pointer				pContext;
	UInt32				dwState;
}	TMMON_COMMAND, *PTMMON_COMMAND;


typedef struct _CMD_READMEMORY
{
	Bool	fSDRAM;		/* is this address in SDRAM range */
	UInt16	wDataSize;	/* word size for current command */
	UInt32	dwAddress;
	UInt32	dwLength;

}	CMD_READMEMORY, *PCMD_READMEMORY;

typedef struct _CMD_WRITEMEMORY
{
	Bool	fSDRAM;		/* is this address in SDRAM range */
	UInt16	wDataSize;	/* word size for current command */
	UInt32	dwAddress;
	UInt32	dwData;
	UInt32	dwLength;
	UInt32	dwStartAddress; /* address where the writing started */	
}	CMD_WRITEMEMORY, *PCMD_WRITEMEMORY;

typedef struct _CMD_LOADRUN
{
	Bool	fSDRAM;		/* is this address in SDRAM range */
	Bool	fDynamicApplicaiton;		/* szApplicaitonFile field is valid */
	UInt8	szExecutableFile[constTMManStringLength];
	UInt8	szApplicationFile[constTMManStringLength];
	UInt32	dwCountArg;
	UInt32	dwIdxArgStr;
	Pointer	ArgumentPtr[constTMManMaximumArgumentCount];
	UInt8	ArgumentBuffer[constTMManMaximumArgumentBuffer];
}	CMD_LOADRUN, *PCMD_LOADRUN;

typedef struct _CMD_DEBUG
{
	Bool	fDebugOn;
	UInt32	DebugOptions;
}	CMD_DEBUG, *PCMD_DEBUG;

typedef struct _CMD_TRACEP
{
	Bool	fTraceIntoFile;
	UInt8	szTraceFileName[constTMManStringLength];
}	CMD_TRACEP, *PCMD_TRACEP;

typedef struct _CMD_DSP
{
	UInt32	DSPNumber;
}	CMD_DSP, *PCMD_DSP;


typedef struct _CMD_SET
{
	UInt32	Type;
	Pointer	Address;
}	CMD_SET, *PCMD_SET;


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

Bool	IsValidHex ( UInt8* pszString, UInt32 dwSize  );
Bool	GetNextToken( UInt8* pszString, UInt16* pwPosition,
		UInt8* pszToken  );
Bool	ReadInputLine (PTMMON_OBJECT pObject, UInt8* pszInputString);
Bool	ValidateData ( UInt16 wDataSize, UInt32 dwData);
UInt32	GetDebugBit ( UInt8* szToken );
void	DumpMemory ( PTMMON_OBJECT pContext, UInt32 dwAddress, UInt32 dwLength, UInt16 wDataSize, Bool fSDRAM  );
void	PrintProcessorInfo ( PTMMON_OBJECT pObject, tmmanDSPInfo* pDSPCaps );

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

CMD_STATUS_CODE CmdReadMemory( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdReadUInt32( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdReadUInt16( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdReadUInt8( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );

CMD_STATUS_CODE CmdWriteMemory( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdWriteUInt32( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdWriteUInt16( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdWriteUInt8( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );

CMD_STATUS_CODE CmdEXELoad( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdEXERun( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdEXEStop( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdEXEReset( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );

CMD_STATUS_CODE CmdHelp( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );

CMD_STATUS_CODE CmdQuit( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );

CMD_STATUS_CODE CmdExit( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );

CMD_STATUS_CODE CmdDSP( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );

CMD_STATUS_CODE CmdSet( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );

CMD_STATUS_CODE CmdDebug( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdTraceP( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );
CMD_STATUS_CODE CmdTraceT( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext );

///////////////////////////////////////////////////////////////////////////////////////////
CMD_READMEMORY	CmdReadMemoryContext;
CMD_WRITEMEMORY	CmdWriteMemoryContext;
CMD_LOADRUN		CmdLoadRunContext;
CMD_DEBUG		CmdDebugContext;
CMD_TRACEP		CmdTracePContext;
CMD_DSP			CmdDSPContext;
CMD_SET			CmdSetContext;

TMMON_COMMAND	CommandTable[] =
{
	{ "RD", CmdReadUInt32, &CmdReadMemoryContext, 0 },
	{ "RW", CmdReadUInt16, &CmdReadMemoryContext, 0 },
	{ "RB", CmdReadUInt8, &CmdReadMemoryContext, 0 },

	{ "WD", CmdWriteUInt32, &CmdWriteMemoryContext, 0 },
	{ "WW", CmdWriteUInt16, &CmdWriteMemoryContext, 0 },
	{ "WB", CmdWriteUInt8, &CmdWriteMemoryContext, 0 },

	{ "LOAD", CmdEXELoad, &CmdLoadRunContext, 0 },
	{ "RUN", CmdEXERun, &CmdLoadRunContext, 0 },
	{ "STOP", CmdEXEStop, Null, 0 },
	{ "RESET", CmdEXEReset, Null, 0 },

	{ "HELP", CmdHelp, Null, 0 },

	{ "QUIT", CmdQuit, Null, 0 },

	{ "EXIT", CmdQuit, Null, 0 },

	{ "DSP", CmdDSP, &CmdDSPContext, 0 },

//	{ "DEBUG", CmdDebug, &CmdDebugContext, 0 },
	{ "DP", CmdTraceP, &CmdTracePContext, 0 },
	{ "DT", CmdTraceT, Null, 0 },

	{ "SET", CmdSet, &CmdSetContext, 0 },
};

UInt32	MaxCommands = sizeof (CommandTable) / sizeof ( TMMON_COMMAND );


///////////////////////////////////////////////////////////////////////////////////////////
CMD_STATUS_CODE CmdQuit( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	CMD_STATUS_CODE	Status = CMD_STATUS_OK;
	enum { QU_CMD, QU_PROCESS };

	switch ( *pdwState )
	{
		case QU_CMD :
		*pdwState = QU_PROCESS;
		break;

		case QU_PROCESS :
		*pdwState = QU_CMD;
		Status = CMD_STATUS_QUIT;
		break;
	}
	return Status;
}

CMD_STATUS_CODE CmdReadMemory( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	
	CMD_STATUS_CODE	Status = CMD_STATUS_OK;
	PCMD_READMEMORY	pObject = 	pContext->pCmdContext;
	enum { RX_CMD, RX_ADDRESS, RX_LENGTH, RX_PROCESS };

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

	switch ( *pdwState )
	{
		case RX_CMD :
		*pdwState = RX_ADDRESS;
		// syntax error
		break;

		case RX_ADDRESS :
		// default incase of error
		*pdwState = RX_CMD;
		if ( IsValidHex ( szToken, 8 ) == False )
		{
			Status = CMD_STATUS_PARSEERR;
			goto CmdReadMemoryERROR;
		}
		if ( sscanf( szToken,"%x", &pObject->dwAddress ) != 1)
		{
			Status = CMD_STATUS_PARSEERR;
			goto CmdReadMemoryERROR;
		}
		// no need to validate the address, the address and
		// length will be validated together one both are available

		*pdwState = RX_LENGTH;
		break;

		case RX_LENGTH :
		*pdwState = RX_CMD;
		if ( sscanf( szToken,"%x", &pObject->dwLength ) != 1)
		{
			Status = CMD_STATUS_PARSEERR;
			goto CmdReadMemoryERROR;
		}

		if ( tmmanValidateAddressAndLength (
			&pContext->CurrentDSPInfo.MMIO,
			pObject->dwAddress,
			pObject->dwLength ) == True )
		
		{
			pObject->fSDRAM = False;
			pObject->wDataSize = 4;				
			*pdwState = RX_PROCESS;
			break;
		}

		if ( tmmanValidateAddressAndLength (
			&pContext->CurrentDSPInfo.SDRAM,
			pObject->dwAddress,
			pObject->dwLength ) == True )
		
		{
			pObject->fSDRAM = True;
			//pObject->wDataSize = 4;				
			*pdwState = RX_PROCESS;
			break;
		}

		Status = CMD_STATUS_PARAMERR;
		goto CmdReadMemoryERROR;
		break;

		case	RX_PROCESS:
		DumpMemory ( pContext, pObject->dwAddress, pObject->dwLength, pObject->wDataSize, pObject->fSDRAM );
		*pdwState = RX_CMD;
		Status = CMD_STATUS_COMPLETE;
		break;

	}	// switch ( *pdwState )
	return Status;

CmdReadMemoryERROR :
	*pdwState = RX_CMD;
	return Status;
}

CMD_STATUS_CODE CmdReadUInt32( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	PCMD_READMEMORY	pCmdState =  pContext->pCmdContext;	
	pCmdState->wDataSize = 4;
	return CmdReadMemory ( szToken, pdwState, pContext );
}


CMD_STATUS_CODE CmdReadUInt16( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	PCMD_READMEMORY	pCmdState =  pContext->pCmdContext;	
	pCmdState->wDataSize = 2;
	return CmdReadMemory ( szToken, pdwState, pContext );
}

CMD_STATUS_CODE CmdReadUInt8( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	PCMD_READMEMORY	pCmdState =  pContext->pCmdContext;	
	pCmdState->wDataSize = 1;
	return CmdReadMemory ( szToken, pdwState, pContext );
}


CMD_STATUS_CODE CmdWriteMemory( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	
	CMD_STATUS_CODE	Status = CMD_STATUS_OK;
	PCMD_WRITEMEMORY	pObject = 	pContext->pCmdContext;
	UInt32			dwLinAddr, dwData;

	enum { WX_CMD, WX_ADDRESS, WX_DATA };	

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

	switch ( *pdwState )
	{
		case WX_CMD :
		pObject->dwLength= 0;
		*pdwState = WX_ADDRESS;
		// syntax error
		break;

		case WX_ADDRESS :
		// default incase of error
		*pdwState = WX_CMD;
		if ( IsValidHex ( szToken, 8 ) == False )
		{
			Status = CMD_STATUS_PARSEERR;
			goto CmdWriteMemoryERROR;
		}
		if ( sscanf( szToken,"%x", &pObject->dwAddress ) != 1)
		{
			Status = CMD_STATUS_PARSEERR;
			goto CmdWriteMemoryERROR;
		}
		*pdwState = WX_DATA;
		break;

		case WX_DATA :
		if ( ! szToken )
		{
			DumpMemory ( pContext, pObject->dwAddress, pObject->dwLength, pObject->wDataSize, pObject->fSDRAM );
			*pdwState = WX_CMD;
			Status = CMD_STATUS_COMPLETE;
			break;
		}

		if ( IsValidHex ( szToken, pObject->wDataSize * 2 ) == False )
		{
			Status = CMD_STATUS_PARAMERR;
			goto CmdWriteMemoryERROR;
		}
		if ( sscanf( szToken,"%x", &dwData ) != 1)
		{
			Status = CMD_STATUS_PARAMERR;
			goto CmdWriteMemoryERROR;
		}		
		if ( ! ValidateData (  pObject->wDataSize, dwData) )
		{
			Status = CMD_STATUS_PARAMERR;
			goto CmdWriteMemoryERROR;
		}

		if ( tmmanValidateAddressAndLength (
			&pContext->CurrentDSPInfo.SDRAM,
			pObject->dwAddress,
			pObject->dwLength + pObject->wDataSize ) == True )
		{
			pObject->fSDRAM = True;
			dwLinAddr =  tmmanPhysicalToMapped ( 
				&pContext->CurrentDSPInfo.SDRAM,
				pObject->dwAddress);
			goto	CmdWriteMemoryWRITE;
		}

		// mmio accesses have to be of DWORD length
		if ( tmmanValidateAddressAndLength (
			&pContext->CurrentDSPInfo.MMIO,
			pObject->dwAddress,
			pObject->dwLength + 4) == True )
		{
			pObject->fSDRAM = False;
			dwLinAddr =  tmmanPhysicalToMapped ( 
				&pContext->CurrentDSPInfo.MMIO,
				pObject->dwAddress);
			pObject->wDataSize = 4;
			goto	CmdWriteMemoryWRITE;	
		}

		Status = CMD_STATUS_PARAMERR;
		goto CmdWriteMemoryERROR;
		

CmdWriteMemoryWRITE:

		// increment the number of locations items we are writing
		pObject->dwLength += pObject->wDataSize;

		switch ( pObject->wDataSize )
		{
			case 1 :
			*((UInt8*)dwLinAddr) = (UInt8)dwData;
			break;

			case 2 :
			*((UInt16*)dwLinAddr) = (UInt16)dwData;
			break;

			case 4 :
			*((UInt32*)dwLinAddr) = (UInt32)dwData;
			break;
		}
		break;

	} // switch

CmdWriteMemoryERROR :
	return Status;
}

CMD_STATUS_CODE CmdWriteUInt32( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	PCMD_WRITEMEMORY	pObject =  pContext->pCmdContext;	
	pObject->wDataSize = 4;
	return CmdWriteMemory ( szToken, pdwState, pContext );
}

CMD_STATUS_CODE CmdWriteUInt16( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	PCMD_WRITEMEMORY	pObject =  pContext->pCmdContext;	
	pObject->wDataSize = 2;
	return CmdWriteMemory ( szToken, pdwState, pContext );

}

CMD_STATUS_CODE CmdWriteUInt8( UInt8* szToken, UInt32* pdwState, PTMMON_OBJECT pContext )
{
	PCMD_WRITEMEMORY	pObject =  pContext->pCmdContext;	
	pObject->wDataSize = 1;
	return CmdWriteMemory ( szToken, pdwState, pContext );
}

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

	UInt32				ImageType,ImageEndian;

	enum { LD_CMD, LD_FILENAME, LD_PROCESS };

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

	switch ( *pdwState )
	{
		case LD_CMD :
		*pdwState = LD_FILENAME;
		break;

		case LD_FILENAME :
		*pdwState = LD_PROCESS;
		strcpy ( pObject->szExecutableFile, szToken );
		break;


		case LD_PROCESS :
		{

			UInt32	DSPStatus;
			TMStatus TMMANStatus;
			UInt8	szErrorString[constTMManStringLength];

			tmmanDSPGetStatus ( pContext->CurrentDSPHandle, &DSPStatus );

			switch ( DSPStatus )
			{
				case constTMManDSPStatusRunning :
				tmmanDSPStop( pContext->CurrentDSPHandle );
				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;