ctc.c

wince host 和 target PCI驱动程序

			dwBaud =  CBR_38400;
	}


	fprintf ( stderr, 
		"\r\nOPTIONS : SERIAL[%d] COM[%d] SPEED[%d] BATCH[%d] TIMEOUT[%d]\r\n",
		fSerial, dwPort, dwBaud, fBatch, dwWaitTimeOut );

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

	if ( ( tmNegotiateVersion (  TMMAN_DEFAULT,
		&Version ) ) != TMOK )
	{
		fprintf ( stderr,
			"\r\nTMMon : ERROR : Obsolete version of TMMon.exe : Terminating ... " );
		return;
	}

	if ( ( Version.dwMajor  < verGetFileMajorVersion() ) ||
		( Version.dwMinor  < verGetFileMinorVersion()) )
	{
		fprintf ( stderr,
			"\r\nTMMon : ERROR : Obsolete version of TMMan32.dll : Terminating ... " );
		return;
	}

	/* INITIALIZE THE HARDWARE HERE */
	if ( ( halInit ( pParser->pTMHW ) ) != TRUE )
	{	
		fprintf ( stderr, "\r\nTMMon : ERROR : Cannot initialize TMMAN : Terminating ... " );
		return;
	}

	if (fSerial)
	{
		pParser->fSerial = TRUE;
		QueryInterface ( IID_COMM, &pCommVtbl );
		if ( pCommVtbl->Create ( IID_COMM, &pComm ) ==  FALSE )
		{
			goto main_deviceerror;
		}

	
		pComm->dwCommPort = dwPort;
		if ( pComm->pVtbl->Open(pComm) == FALSE )
		{
			goto main_deviceerror;
		}
		pComm->dwBaudRate	= dwBaud ;//CBR_38400;
		pComm->bParity		= NOPARITY;
		pComm->bStopBits	= ONESTOPBIT;
		pComm->pVtbl->SetCommState(pComm);

		pParser->pDevice = pComm;
		pParser->WriteStr 			= pComm->pVtbl->WriteStr;
		pParser->WriteChar			= pComm->pVtbl->WriteChar;
		pParser->ReadChar			= pComm->pVtbl->ReadChar;
		pParser->Close				= pComm->pVtbl->Close;
		pParser->GetHandles			= pComm->pVtbl->GetHandles;

		// TR960629 - Yong's request - do this only if running on serial line
		sprintf ( szTemp, 
		"\r\nTriMedia Monitor - (c)Philips Semiconductors Version [%d.%d.%d]",
		verGetFileMajorVersion (),
		verGetFileMinorVersion (),
		verGetFileBuildVersion () );
		(*pParser->WriteStr)(pParser->pDevice, szTemp );
		

	}
	else
	{
		COORD   ConsoleSize;
		pParser->fSerial = FALSE;
		QueryInterface ( IID_CONS, &pConsVtbl );
		pConsVtbl->Create ( IID_CONS, &pCons );
		if ( pCons->pVtbl->Open(pCons) == FALSE )
		{
			goto main_deviceerror;
		}
		pParser->pDevice 			= pCons;
		pParser->WriteStr 			= pCons->pVtbl->WriteStr;
		pParser->WriteChar			= pCons->pVtbl->WriteChar;
		pParser->ReadChar			= pCons->pVtbl->ReadChar;
		pParser->Close				= pCons->pVtbl->Close;
		pParser->GetHandles			= pCons->pVtbl->GetHandles;

		/* use the default output mode for stdout and stderr */
		if ( dwWindowLines != 0 )
		{
			ConsoleSize.X = 80;
			ConsoleSize.Y = dwWindowLines;
			SetConsoleScreenBufferSize (
				GetStdHandle ( STD_OUTPUT_HANDLE ), ConsoleSize );
		}
		
	}

	// USE pParser->WriteStr for all ERROR reporting from now on 
	



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

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

		PTM_HW pHal = 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, "\r\nProcessor[%x] Type[%s1.%d %s] Name[%s]",
			0, 
			CPUType[TMSTD_GETTMTYPE(pHal->DSPCaps.dwCPUVersion)],
			TMSTD_GETTMREV(pHal->DSPCaps.dwCPUVersion),
			FabType[TMSTD_GETTMFAB(pHal->DSPCaps.dwCPUVersion)],
			pHal->DSPCaps.szPCIName); 

		(*pParser->WriteStr)(pParser->pDevice, szTemp );

		sprintf ( szTemp, "\r\nSDRAM	Phys[%08x] Size[%08x] Linr[%08x]",
			pSDRAM->dwPhysical, pSDRAM->dwSize,	pSDRAM->dwLinear);
		(*pParser->WriteStr)(pParser->pDevice, szTemp );

		sprintf ( szTemp, "\r\nMMIO	Phys[%08x] Size[%08x] Linr[%08x]",
			pMMIO->dwPhysical, pMMIO->dwSize, pMMIO->dwLinear);
		(*pParser->WriteStr)(pParser->pDevice, szTemp );
		 
		sprintf ( szTemp, "\r\nUser	Phys[%08x] Size[%08x] Linr[%08x]\r\n",
			pUser->dwPhysical, pUser->dwSize, pUser->dwLinear);
		(*pParser->WriteStr)(pParser->pDevice, szTemp );

	}

	pParser->GetHandles ( pParser->pDevice,  &Stdin, &Stdout, &Stderr );


	// get the class factory interface to FILE
	QueryInterface ( IID_FILE, &pParser->pFileVtbl );


	if ( fBatch ) // runs CTC in non-interactive mode.
	{
		if ( ctcLoadExecuteable ( pParser, &pParser->CmdLDParam ) != TRUE )
		{
			goto main_commonexit;
		}

		ctcStartExecuteable ( pParser );

		for  ( ; ( dwWaitTimeOut > 0 ) ; dwWaitTimeOut -- ) 
		{
			Sleep ( 1000 );
		}

		goto	main_exit;	
	}

	// main execution loop.
	for ( ;; )
	{
		if ( pParser->wState != CMD_WAIT )
		{
			// change prompt if previous line not complete.
			strcpy(pParser->szPrompt, "\r\n|> ");
		}
		else
		{
			strcpy(pParser->szPrompt, "\r\n>> ");				
		}

		(*pParser->WriteStr)(pParser->pDevice, pParser->szPrompt);

		ReadInputLine (pParser, pParser->szInputString);

		//collected one string's worth of characters
		if ( ProcessLine ( pParser ) == FALSE )
		{
			// quit command received.
			goto	main_exit;
		}
	}		

	goto 	main_exit;

main_exit :
	( *pParser->WriteStr )( pParser->pDevice, "\r\nTMMon : Monitor Terminating\r\n");
	( *pParser->Close )( pParser->pDevice );
	goto main_commonexit;


main_argerr :
	fprintf ( stderr, "\r\nTMMon : ERROR : Cannot Parse Parameter : Terminating ... ");
	goto main_commonexit;
		
main_deviceerror :
	fprintf ( stderr, "\r\nTMMon : ERROR : Cannot Open Serial Device : Terminating ... ");
	goto main_commonexit;

main_iofail :
	fprintf ( stderr, "\r\nTMMon : ERROR : Cannot Open Redirection File : Terminating ... ");
	goto	main_prehalexit;

main_commonexit :
//	pParser->fExitDebugger = TRUE;

	if ( pParser->fServerLoaded )
	{
		// then kill it 
		(*pRPCServExitFunc)( );
		pParser->fServerLoaded = FALSE;
	}

	//Sleep ( 1000 );
	halExit( pParser->pTMHW );

main_prehalexit:
	return;

}


/*----------------------------------------------------------------------------
FUNC	ValidateData
ABOUT
		Determines if he data is within given bounds or not.
----------------------------------------------------------------------------*/

BOOL	ValidateData ( WORD wDataSize, DWORD dwData )
{
	switch (wDataSize )
	{
		case 1 :
		if  ( dwData  > 0xff )
			return FALSE;
		break;

		case 2 :
		if  ( dwData  > 0xffff )
			return FALSE;
		break;

		// a dword cannot hold more than a a dword.
		default :
		break;
	}
	return TRUE;
}




/*----------------------------------------------------------------------------
FUNC	IsValidHex
ABOUT
	Takes a character string and determines if it a valid hex number of a 
	given size. This funciton is needed since Xscanf does not translate
	hex number correctly if the number of characters > given size of the 
	number.
----------------------------------------------------------------------------*/
BOOL IsValidHex ( PSTR pszString, DWORD dwSize  )
{
	DWORD	dwIdx;
	for ( dwIdx = 0 ; *pszString ; dwIdx ++, pszString++ )
	{
		if (  dwIdx >= dwSize )
			return FALSE;
		if ( ( isdigit (*pszString ) ) ||
		( ( toupper ( *pszString ) >= 'A' ) && ( toupper ( *pszString ) <='F' ) )  )
			continue;
		return FALSE;
	}
	return TRUE;

}

/*
 * output string to serial or console with newline to cr/lf conversion
 */
void
ctc_outstring(char *bfr)
{
	char	str[1024] ;
	char	*src ;
	char	*dst ;
	
	/*
	 * Convert newline to CR/LF
	 */

	src = bfr ;
	dst = str ;
	while (*src != 0)
		{
		if (*src == '\n')
			{
			*dst++ = '\r' ;
			*dst++ = '\n' ;
			src++ ;
			}
		else
			{
			*dst++ = *src++ ;
			}
		}
	*dst = 0 ;
	Parser.WriteStr ( Parser.pDevice, str);
}



// this function should call into tmldr.dll or tmldr.exe 
BOOL	ctcLoadExecuteable ( PPARSER pParser, PCMD_LD_PARAM this )
{
	FILE_OBJECT			FileMem;
	PFILE_OBJECT 		pFileMem = &FileMem;
	HANDLE				ImageFileHandle;
	TMObj_Module_Rec	ExecutableHeader;
	DWORD				BytesReturned;
	BYTE				bErrorString[0x80];
	STATUS				Status;
	DWORD				ArgIdx;
	DWORD				Argv0Length;
    DWORD              ImageType,ImageEndian;

	
	// BEGIN APPLOAD

    if ( tmGetImageInfo (
        this->szExecutableFile,
        &ImageType,
        &ImageEndian ) != True )
    {
		sprintf ( bErrorString,
            "\r\nTMMon: ERROR  : Loading Executable [%s]: FAIL (File Not Found)",
            this->szExecutableFile );
		(*pParser->WriteStr)  ( pParser->pDevice, bErrorString );
		return FALSE;
    }

    if ( ImageType == TMObj_AppSegment )
	{
		CHAR	TCSPath[MAX_PATH]; 

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

		this->fDynamicApplicaiton = True;

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


		// begin arguments
		
		// insert the name of the shell at the head of the argument list.

		Argv0Length = strlen ( this->szExecutableFile );

		//make space for argv0 string
		memmove ( 
			((PCHAR)&pParser->CmdLDParam.ArgumentBuffer[0]) + Argv0Length + 1,
			&pParser->CmdLDParam.ArgumentBuffer[0],
			pParser->CmdLDParam.dwIdxArgStr );

		// change all the pointers
		for ( ArgIdx = 0; ArgIdx < pParser->CmdLDParam.dwCountArg ; ArgIdx++ )
		{
			((PCHAR)pParser->CmdLDParam.ArgumentPtr[ArgIdx]) = 
				((PCHAR)pParser->CmdLDParam.ArgumentPtr[ArgIdx]) + ( Argv0Length + 1 );
		}



		// make space for storing argv[0] pointer
		for ( ArgIdx = pParser->CmdLDParam.dwCountArg ; ArgIdx > 0 ; ArgIdx-- )
		{
			pParser->CmdLDParam.ArgumentPtr[ArgIdx] = 
				pParser->CmdLDParam.ArgumentPtr[ArgIdx - 1];
		}

		// copy argv0 in the begining of the argument buffer.
		strcpy ( 
			&pParser->CmdLDParam.ArgumentBuffer[0],
			this->szExecutableFile );

		// update the pointer
		pParser->CmdLDParam.ArgumentPtr[0] = &pParser->CmdLDParam.ArgumentBuffer[0];

		// we have added another argument, reflect it.
		pParser->CmdLDParam.dwIdxArgStr += ( Argv0Length + 1) ;
		pParser->CmdLDParam.dwCountArg++;


		// arguemnts ends


	} 


	// did we load a server successfully.
	if ( ( Status = tmDSPExecutableLoad ( 
		((PTM_HW)pParser->pTMHW)->DSPHandle,
		TMMAN_DEFAULT, 
		this->szExecutableFile, 
		this->dwCountArg, 
		this->ArgumentPtr ) ) != TMOK )
	{
		sprintf ( bErrorString,
			"\r\nTMMon: ERROR  : Loading Executable [%s] : Error [%s] : FAIL [%x]", 
			this->szExecutableFile, tmGetErrorString(Status), Status );
		(*pParser->WriteStr)  ( pParser->pDevice, bErrorString );
	}
	return TRUE;
}

BOOL	ctcStartExecuteable ( PPARSER pParser )
{
	STATUS Status;
	BYTE	bErrorString[0x80];

	if ( ( Status = tmDSPExecutableRun( ((PTM_HW)pParser->pTMHW)->DSPHandle, TMMAN_DEFAULT,
		&pParser->TMCons ) ) != TMOK )
	{
		sprintf ( bErrorString,
			"\r\nTMMon: ERROR  : Running Target Executable Image : Error [%s] : FAIL [%x]", 
			tmGetErrorString(Status), Status );

		(*pParser->WriteStr)  ( pParser->pDevice, bErrorString );
		return FALSE;
	}
	return TRUE;
}

BOOL	ctcStopExecuteable ( PPARSER pParser )
{
	STATUS Status;
	BYTE	bErrorString[0x80];

	if ( ( Status = tmDSPExecutableStop(
		((PTM_HW)pParser->pTMHW)->DSPHandle ) ) != TMOK )
	{
		sprintf ( bErrorString,
			"\r\nTMMon: ERROR  : Stopping Target Executable Image : Error [%s] : FAIL [%x]", 
			tmGetErrorString(Status), Status );
		(*pParser->WriteStr)  ( pParser->pDevice, bErrorString );
		return FALSE;

	}
	return TRUE;
}


DWORD	GetDebugBit ( PCHAR szToken )
{
	if ( stricmp ( szToken, "pcmem" ) == 0 )
		return TMSTD_DBG_OPTIONVOLATILE;
	if ( stricmp ( szToken, "sdram" ) == 0 )
		return TMSTD_DBG_OPTIONPERSIST;
	if ( stricmp ( szToken, "mono" ) == 0 )
		return TMSTD_DBG_OPTIONMONO	;

		/*
	if ( stricmp ( szToken, "stdout" ) == 0 )
		return TMSTD_DBG_OPTIONSTDOUT;
	if ( stricmp ( szToken, "stderr" ) == 0 )
		return TMSTD_DBG_OPTIONSTDERR;
		*/

	return 0;
}