ctc.cpp

wince host 和 target PCI驱动程序

		switch ( pParser->wState )
		{
			/* Debugging Comamnds */
			case DEBUGON_CMD :
			pParser->DebugOn = TRUE;
			pParser->wState = DEBUGON_OPTIONS;
			break;

			case DEBUGOFF_CMD :
			pParser->DebugOn = FALSE;
			pParser->wState = DEBUGON_OPTIONS;
			break;

			case DEBUGON_OPTIONS :
			case DEBUGOFF_OPTIONS :
			if ( szToken[0] == '.' ) /* set the options */
			{
				TMMAN_DSP_INFO	Info;
				PTMHD_DBG_SHARED pDBG;

				tmDSPGetMiscInfo ( ((PTM_HW)pParser->pTMHW)->DSPHandle, 
					&Info );
				pDBG = (PTMHD_DBG_SHARED)Info.pDBGSharedData;

				if ( pParser->DebugOn )
				{
					pDBG->OptionBits |= pParser->DebugOptions;
				}
				else
				{
					pDBG->OptionBits &= pParser->DebugOptions;
				}
				pParser->wState = CMD_WAIT;
			}
			else /* process the next debug on option */
			{
				DWORD Options;
				if ( ( Options = GetDebugBit ( szToken ) ) != 0 )
				{
					if ( pParser->DebugOn )
					{
						pParser->DebugOptions |= Options;
					}
					else
					{
						 pParser->DebugOptions &= Options;
					}
				}
				else
				{
					goto ProcessLine_syntax;
				}
			}
			break;


			case TRACEV_CMD :
			{
				TMMAN_DSP_INFO	Info;
				PTMHD_DBG_SHARED pDBG;
				DWORD PrintableLength1;

				tmDSPGetMiscInfo ( ((PTM_HW)pParser->pTMHW)->DSPHandle, 
					&Info );
				pDBG = (PTMHD_DBG_SHARED)Info.pDBGSharedData;
				PrintableLength1 = pDBG->VBufPos;
			
				if ( pDBG->VWrapped ) /* wrap around has occured */
				{
					DWORD PrintableLength2 = pDBG->VBufLen - pDBG->VBufPos;

					// Write in trace edit box
					DisplayTrace(&pDBG->VBuffer[pDBG->VBufPos], PrintableLength2);
				}

				// Write in trace edit box
				DisplayTrace(&pDBG->VBuffer[0], PrintableLength1);
				traceBuffer[traceIndex]=0;
				pTraceView->SetWindowText(traceBuffer);			//May not display complete buffer
				if(traceIndex != 0 && pTraceView->GetWindowTextLength() == 0)
				{
					traceBuffer[20000]=0;
					pTraceView->SetWindowText(traceBuffer);
				}
			}
			pParser->wState = CMD_WAIT;
			break;

			case	TRACEP_CMD :
			pParser->wState = TRACEP_FILENAME;
			break;


			case	TRACEP_FILENAME :
			{
				PBYTE pSDRAM =	(PBYTE )halGetSDRAMLin ( pParser->pTMHW );
				DWORD SDRAMLength = halGetSDRAMLen ( pParser->pTMHW );
				PTMHD_DBG_PBUFFER pDBG;
				DWORD PrintableLength1, PrintableLength2;
				DWORD BytesWritten, Idx;
				CHAR	szMagic[TMHD_DBG_MAGICSIZE];
				PBYTE pBuffer;

				if ( szToken[0] == '.' )
				{	/* no filename print to stdout */
					pParser->wState = CMD_WAIT;

					strcpy ( szMagic, TMHD_DBG_BUFMAGIC );
					szMagic[0] = 'T';
					szMagic[1] = 'M';
					szMagic[2] = '-';
					szMagic[3] = 'S';
					szMagic[4] = 'o';
					szMagic[5] = 'f';
					szMagic[6] = 't';

					/* search the entire SDRAM for the magic string */
					for ( Idx = 0 ; Idx < SDRAMLength ;
						Idx += TMHD_DBG_MAGICSIZE, pSDRAM += TMHD_DBG_MAGICSIZE )
					{
						if ( strcmp ( (const char *)pSDRAM, szMagic ) == 0 )
						{
							break;
						}
					}

					if ( Idx >= SDRAMLength )
					{
						AfxMessageBox("ERROR : No Debug Information in SDRAM");
						break;
					}


					pDBG = (PTMHD_DBG_PBUFFER )pSDRAM;
					PrintableLength1 = pDBG->PBufPos;
					PrintableLength2 = pDBG->PBufLen - pDBG->PBufPos;
					pBuffer = tmPhysToLin( pDBG->pPBuffer, &TMHW.DSPCaps.SDRAM );

					if ( pParser->fTraceIntoFile == FALSE )
					{
						if ( pDBG->PWrapped ) /* wrap around has occured */
						{
							
							// Write in trace edit box
							DisplayTrace(pBuffer + pDBG->PBufPos, PrintableLength2);
						}

						// Write in trace edit box
						DisplayTrace(pBuffer, PrintableLength1);
						traceBuffer[traceIndex]=0;
						pTraceView->SetWindowText(traceBuffer);
						if(traceIndex != 0 && pTraceView->GetWindowTextLength() == 0)
						{
							traceBuffer[20000]=0;
							pTraceView->SetWindowText(traceBuffer);
						}
					}
					else /* open the trace file and write to it */
					{
						HANDLE hFile;
						
						PBYTE pBuffer = tmPhysToLin( pDBG->pPBuffer,
								&TMHW.DSPCaps.SDRAM ); 
						SYSTEMTIME	Time;
						DWORD	SizeOfMachineName;
						CHAR	szMachineName[MAX_COMPUTERNAME_LENGTH + 1];
						CHAR	szString[MAX_STRING];
						SizeOfMachineName = MAX_COMPUTERNAME_LENGTH + 1;
						pParser->fTraceIntoFile = FALSE;

						if ( ( hFile  = CreateFile ( pParser->szTraceFileName , 
							GENERIC_READ | GENERIC_WRITE, 0,
							NULL,
							CREATE_ALWAYS,
							FILE_ATTRIBUTE_NORMAL,
							NULL ) ) == (HANDLE)-1 )
						{
							CHAR	szTempString[MAX_STRING];
							sprintf ( szTempString,
								"ERROR [%x] : Creating Trace File [%s]",
								GetLastError(), pParser->szTraceFileName  );

							AfxMessageBox((LPCTSTR)szTempString);
							break;
						}

						GetComputerName ( szMachineName, &SizeOfMachineName );
						SizeOfMachineName = GetLastError();

						GetLocalTime(&Time);
						sprintf ( szString,
							"TMMon:TraceFile:Machine[%s]:D[%02d.%02d.%04d]:T[%02d:%02d:%02d]:Size[%u]\n",
							szMachineName, Time.wMonth,  Time.wDay, Time.wYear,
							Time.wHour, Time.wMinute, Time.wSecond,
							( (pDBG->PWrapped == TRUE )?  pDBG->PBufLen  : pDBG->PBufPos ) );

						if ( WriteFile (  hFile,
							szString, strlen( szString ),
							&BytesWritten, NULL ) != TRUE )
						{
							AfxMessageBox("ERROR : Writing Trace File Header");
							CloseHandle ( hFile );
							break;
						}
	
						if ( pDBG->PWrapped ) /* wrap around has occured */
						{
							if ( WriteFile (  hFile,
								pBuffer + pDBG->PBufPos,
								PrintableLength2,
								&BytesWritten, NULL ) != TRUE )
							{
								AfxMessageBox("ERROR : Writing Trace File");
								CloseHandle ( hFile );
								break;
							}
						}

						if ( WriteFile (  hFile,
							pBuffer, PrintableLength1,
							&BytesWritten, NULL ) != TRUE )
						{
							AfxMessageBox("ERROR : Writing Trace File");
							CloseHandle ( hFile );
							break;
						}

						CloseHandle ( hFile );
					}

				}
				else /* second parameter is a filename */
				{
					if ( pParser->fTraceIntoFile == TRUE ) 
					{
						pParser->fTraceIntoFile = FALSE;
						goto ProcessLine_syntax;
					}
					/* copy the filename in to the parser data structure */
					pParser->fTraceIntoFile = TRUE;
					strcpy ( pParser->szTraceFileName,szToken );
					break;
				}

			}
			break;


			/*
				load executeable file command 
			*/
			case LD_CMD :
			pParser->wState = LD_FILENAME;
			break;

			case LD_FILENAME :
			pParser->wState = LD_ARGS;

			p1 = szToken;
			while (*p1 != '\0')
			{
				if(*p1 == '#')
					*p1 = ' ';
				p1++;
			}
			strcpy ( pParser->CmdLDParam.szExecutableFile, szToken );
			pParser->CmdLDParam.dwIdxArgStr =  0;
			pParser->CmdLDParam.dwCountArg = 0;

			// name of the executeable is argv[0]
			strcpy ( 
				&pParser->CmdLDParam.ArgumentBuffer[pParser->CmdLDParam.dwIdxArgStr],
				szToken );
			pParser->CmdLDParam.ArgumentPtr[pParser->CmdLDParam.dwCountArg] = 
					&pParser->CmdLDParam.ArgumentBuffer[pParser->CmdLDParam.dwIdxArgStr];
			pParser->CmdLDParam.dwIdxArgStr += ( strlen ( szToken ) + 1) ;
			pParser->CmdLDParam.dwCountArg++;
			break;

			case LD_ARGS :
			{
				DWORD dwLength;
				if ( !szToken[0] )
				{
					break;
				}

				// check for termination of argument list
				if ( szToken[0] == '.' )
				{
					
					switch ( pParser->ProgramState )
					{
						case PROG_STATE_STARTED :
							ctcStopExecuteable(pParser);
						case PROG_STATE_LOADED :
						case PROG_STATE_NOTINIT :
						case PROG_STATE_STOPPED :
						if ( ctcLoadExecuteable ( 
							pParser, &pParser->CmdLDParam ) == TRUE )
						{
							pParser->ProgramState = PROG_STATE_LOADED;
						}
						break;

					}
					//  we have to set *dwArgv to point to our argument vector.
					pParser->wState = CMD_WAIT;
					break;

				}
				else
				{
					dwLength  = strlen ( szToken );
					if ( ( pParser->CmdLDParam.dwIdxArgStr + dwLength + 1 )>
						MAX_ARGUMENT_BUFFER )
					{
						AfxMessageBox("ERROR : Argument buffer overflow");
						pParser->wState = CMD_WAIT;
						break;
					}

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


			/*
				commands for in | out | err redirection
			*/
			case SI_CMD :
			pParser->wState = SI_FILENAME;
			break;

			case SI_FILENAME :
				strcpy ( pParser->TMCons.szFilenameStdin, szToken );
				pParser->TMCons.fRedirectedStdin = TRUE;
				pParser->wState = CMD_WAIT;
			break;

			case EI_CMD :
				pParser->TMCons.fRedirectedStdin = FALSE;
				pParser->wState = CMD_WAIT;
			break;


			case SO_CMD :
				pParser->wState = SO_FILENAME;
				break;

			case SO_FILENAME :
				strcpy ( pParser->TMCons.szFilenameStdout, szToken );
				pParser->TMCons.fRedirectedStdout = TRUE;
				pParser->wState = CMD_WAIT;
				break;
			
			case EO_CMD :
				pParser->TMCons.fRedirectedStdout = FALSE;
				pParser->wState = CMD_WAIT;
				break;

			case SE_CMD :
			pParser->wState = SE_FILENAME;
			break;

			case SE_FILENAME :
				strcpy ( pParser->TMCons.szFilenameStderr, szToken );
				pParser->TMCons.fRedirectedStderr = TRUE;
				pParser->wState = CMD_WAIT;
				break;
			
			case EE_CMD :
				pParser->TMCons.fRedirectedStderr  = FALSE;
				pParser->wState = CMD_WAIT;
				break;
		}
	}

	return TRUE;

ProcessLine_syntax :
//	(*pParser->WriteStr) ( pParser->pDevice, "\r\nTMMon : ERROR : Command Syntax\r\n"); 
	pParser->wState = CMD_WAIT;
	return TRUE;	
}


BOOL ctc_main (CTmgmonDlg* pTmgmonDlg,char* verstr)
{
	CHAR			szTemp[MAX_STRING];

	PPARSER	pParser = &Parser;
	
	// required for processing arguments
	DWORD	dwWaitTimeOut = 0;
	DWORD	dwWindowLines = 0;
	WORD wCount = 0 ;

	TMSTD_VERSION_INFO Version;

	sprintf ( verstr, 
		"TriMedia Monitor - (c)Philips Semiconductors Version [%d.%d.%d]\n[%s %s]",
		verGetFileMajorVersion (),
		verGetFileMinorVersion (),
		verGetFileBuildVersion (),__DATE__, __TIME__);


	//initize the parser data structre
	pParser->wState 			= CMD_WAIT;
	pParser->pTMHW 				= &TMHW;	
	pParser->fTraceIntoFile		= FALSE;

	pParser->ProgramState = PROG_STATE_NOTINIT;

	pParser->TMCons.fRedirectedStdin = FALSE;
	pParser->TMCons.fRedirectedStdout = FALSE;
	pParser->TMCons.fRedirectedStderr = FALSE;
	pParser->TMCons.fUseWindowSize = FALSE;
	pParser->TMCons.fIgnoreTMCons = FALSE;
	pParser->TMCons.fUseTMMonWindow = FALSE;

	pParser->CmdLDParam.dwCountArg = 0;
	pParser->CmdLDParam.dwIdxArgStr = 0;
	

	if ( dwWaitTimeOut == 0 )
		dwWaitTimeOut = 100;

	Version.dwMajor = verGetFileMajorVersion();
	Version.dwMinor = verGetFileMinorVersion();

	if ( ( tmNegotiateVersion (  TMMAN_DEFAULT,
		&Version ) ) != TMOK )
	{
		AfxMessageBox("ERROR : Obsolete version of TMGMon.exe : Terminating ... " );
		return FALSE;
	}

	if ( ( Version.dwMajor  < verGetFileMajorVersion() ) ||
		( Version.dwMinor  < verGetFileMinorVersion()) )
	{
		AfxMessageBox("ERROR : Obsolete version of TMMan32.dll : Terminating ... " );
		return FALSE;
	}

	/* INITIALIZE THE HARDWARE HERE */
	if ( ( halInit ( (PTM_HW)(pParser->pTMHW) ) ) != TRUE )
	{	
		AfxMessageBox("ERROR : Cannot initialize TMMAN : Terminating ... " );
		return FALSE;
	}


	{
		PCHAR CPUType[] = {
			"TM1000 \0",
			"TM1000 S\0",
			"TM1100 \0",
			"Unknown\0"
		};

		PCHAR FabType[] = {
			"ST\0",
			"MOS4\0",
			"TSMC\0",
			"Unkown\0"
		};

		PTM_HW pHal = (TM_HW *)pParser->pTMHW;
		DWORD	CPU;


		PTMSTD_MEMORY_BLOCK		pSDRAM =  &pHal->DSPCaps.SDRAM;
		PTMSTD_MEMORY_BLOCK		pMMIO =  &pHal->DSPCaps.MMIO;
		PTMSTD_MEMORY_BLOCK		pUser =  &pHal->DSPCaps.User;

		sprintf(szTemp,"%x",dwDSPNumber);		// To be changed to variable
		pTmgmonDlg->SetDlgItemText(IDC_NUM,szTemp);
		
		sprintf( szTemp,"%s1.%d %s",
			CPUType[TMSTD_GETTMTYPE(pHal->DSPCaps.dwCPUVersion)],
			TMSTD_GETTMREV(pHal->DSPCaps.dwCPUVersion),
			FabType[TMSTD_GETTMFAB(pHal->DSPCaps.dwCPUVersion)] );

		pTmgmonDlg->SetDlgItemText(IDC_TYPE,szTemp);

		sprintf(szTemp,"%s",pHal->DSPCaps.szPCIName);
		pTmgmonDlg->SetDlgItemText(IDC_NAME,szTemp);

/*
		sprintf(szTemp,"%08x\t%08x\t%08x",pSDRAM->dwPhysical, pSDRAM->dwSize,	pSDRAM->dwLinear);
		pTmgmonDlg->SetDlgItemText(IDC_SDRAM,szTemp);

		sprintf(szTemp,"%08x\t%08x\t%08x",pMMIO->dwPhysical, pMMIO->dwSize, pMMIO->dwLinear);
		pTmgmonDlg->SetDlgItemText(IDC_MMIO,szTemp);

		sprintf(szTemp,"%08x\t%08x\t%08x",pUser->dwPhysical, pUser->dwSize, pUser->dwLinear);
		pTmgmonDlg->SetDlgItemText(IDC_USER,szTemp);
*/
		sprintf(szTemp,"0x%08x",pSDRAM->dwPhysical);
		pTmgmonDlg->SetDlgItemText(IDC_SDRAM,szTemp);
		sprintf(szTemp,"0x%08x",pSDRAM->dwSize);
		pTmgmonDlg->SetDlgItemText(IDC_SDRAM2,szTemp);
		sprintf(szTemp,"0x%08x", pSDRAM->dwLinear);
		pTmgmonDlg->SetDlgItemText(IDC_SDRAM3,szTemp);

		sprintf(szTemp,"0x%08x",pMMIO->dwPhysical);
		pTmgmonDlg->SetDlgItemText(IDC_MMIO,szTemp);
		sprintf(szTemp,"0x%08x", pMMIO->dwSize);
		pTmgmonDlg->SetDlgItemText(IDC_MMIO2,szTemp);