ctc.c

wince host 和 target PCI驱动程序

				switch ( pParser->wDataSize )
				{
					case 1:
					for ( dwScrIdx = 0 ;
						((dwMemIdx < pParser->dwLength ) &&
						(dwScrIdx < 0x10)) ;
						dwScrIdx++, dwMemIdx += 1, pParser->dwAddress += 1 )
					{

						(BYTE)dwValue =
							halMemoryReadB ( pParser->pTMHW,
							pParser->dwAddress);
						sprintf ( szTempString, " %02x",(BYTE)dwValue );
						strcat ( pParser->szOutputString, szTempString ); 
					}
					break;

					case 2:
					for ( dwScrIdx = 0 ;
						((dwMemIdx < pParser->dwLength ) &&
						(dwScrIdx < 0x8)) ;
						dwScrIdx++, dwMemIdx+=2, pParser->dwAddress += 2 )
					{

						(WORD)dwValue =
							halMemoryReadW ( pParser->pTMHW,
							pParser->dwAddress);
						sprintf ( szTempString, " %04x",(WORD)dwValue );
						strcat ( pParser->szOutputString, szTempString ); 
					}
					break;

					case 4:
					for ( dwScrIdx = 0 ;
						((dwMemIdx < pParser->dwLength ) &&
						(dwScrIdx < 0x4)) ;
						dwScrIdx++, dwMemIdx+= 4, pParser->dwAddress += 4 )
					{

						dwValue =
							halMemoryReadD ( pParser->pTMHW,
							pParser->dwAddress);
						sprintf ( szTempString, " %08x", dwValue );
						strcat ( pParser->szOutputString, szTempString ); 
					}
					break;

					default :
					break;
				} // switch
				pParser->WriteStr ( pParser->pDevice, pParser->szOutputString );
				ScreenScroll ( pParser );
			} // for
			break;


			case WX_DATA :
			if ( szToken[0] == '.' )
			{
				pParser->wState = CMD_WAIT;
				pParser->dwAddress = pParser->dwStartAddress;
				pParser->dwLength *= pParser->wDataSize;
				goto ProcessLine_readmem;
			}

			if ( IsValidHex ( szToken, pParser->wDataSize * 2 ) == FALSE )
			{
				goto	ProcessLine_syntax;
			}
			if ( sscanf( szToken,"%x", &pParser->dwData ) != 1)
			{
				goto ProcessLine_syntax;
			}		
			if ( ! ValidateData (  pParser->wDataSize, pParser->dwData) )
			{
				goto ProcessLine_range;
			}

			/* increment the number of items we are writing*/
			pParser->dwLength ++;

			switch ( pParser->wDataSize )
			{
				case 1 :
				halMemoryWriteB ( pParser->pTMHW, pParser->dwAddress, 
					(BYTE) pParser->dwData );
				break;

				case 2 :
				halMemoryWriteW ( pParser->pTMHW, pParser->dwAddress, 
					(WORD) pParser->dwData );
				break;

				case 4 :
				halMemoryWriteD ( pParser->pTMHW, pParser->dwAddress, 
					(DWORD) pParser->dwData );
				break;
			}

			pParser->dwAddress += pParser->wDataSize;
			break;

			/*
				Put File Command
			*/
			case PF_CMD :
			pParser->wState = PF_ADDRESS;
			break;

			case PF_ADDRESS :
			pParser->wState = PF_LENGTH;
			goto ProcessLine_address;

			break;
			case PF_LENGTH :
			pParser->wState = PF_FILENAME;
			goto ProcessLine_length;

			case PF_FILENAME :
			{
				FILE_OBJECT		FileMem;
				PFILE_OBJECT 	pFileMem = &FileMem;
				QueryInterface ( IID_FILE, &pParser->pFileVtbl );
				pParser->pFileVtbl->Create ( IID_FILE, &pFileMem );
				if ( pFileMem->pVtbl->Open (pFileMem, szToken, 
					FILE_ATTRIBUTE_NORMAL, CREATE_ALWAYS) == FALSE )
				{
					goto ProcessLine_iofail;
				}
				// MMIO registers can only be accessed as DWORD.
				// so to take a snapshot of MMIO registers DWORD has to be 
				// used instead of WORD | BYTE.
				for ( dwMemIdx = 0 ; dwMemIdx < pParser->dwLength ;
					dwMemIdx += 4)
				{
					dwValue = halMemoryReadD(pParser->pTMHW,
						pParser->dwAddress + dwMemIdx );
					pFileMem->pVtbl->Write ( pFileMem, &dwValue,
						sizeof (DWORD), &dwBytesXfered );
				}
				// file size will be multiples of 4 only.
				pFileMem->pVtbl->Close(pFileMem);
				pFileMem->pVtbl->Destroy(pFileMem );
			}	
			pParser->wState = CMD_WAIT;
			break;

			/*
				Get File Command
			*/
			case GF_CMD :
			pParser->wState = GF_ADDRESS;
			break;

			case GF_ADDRESS :
			pParser->wState = GF_FILENAME;
			goto ProcessLine_address;

			case GF_FILENAME :
			{
				FILE_OBJECT		FileMem;
				PFILE_OBJECT 	pFileMem = &FileMem;

				QueryInterface ( IID_FILE, &pParser->pFileVtbl );
				pParser->pFileVtbl->Create ( IID_FILE, &pFileMem );
				if ( pFileMem->pVtbl->Open (pFileMem, szToken, 
					FILE_ATTRIBUTE_NORMAL, OPEN_EXISTING) == FALSE )
				{
					goto ProcessLine_iofail;
				}

				for ( dwMemIdx = 0 ; dwMemIdx < pParser->dwLength ;
					dwMemIdx += 4)
				{

					if ( pFileMem->pVtbl->Read ( 
						pFileMem, &dwValue, sizeof (DWORD),
						&dwBytesXfered) == FALSE )
					{
						break; // we are the end of the file.
					}
					halMemoryWriteD ( pParser->pTMHW, 
						pParser->dwAddress + dwMemIdx, dwValue );
				}

				pFileMem->pVtbl->Close(pFileMem);
				pFileMem->pVtbl->Destroy(pFileMem );
				pParser->wState = CMD_WAIT;
			}
			break;

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

			case LD_FILENAME :
			pParser->wState = LD_ARGS;
			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 )
					{
						pParser->WriteStr(pParser->pDevice,
							"\r\nTMMon: 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;

			/*
				command to start program execution 
			*/
			case GO_CMD :
			switch ( pParser->ProgramState )
			{
				case PROG_STATE_STARTED :
				pParser->WriteStr(pParser->pDevice,
					"\r\nTMMon : ERROR : Program already executing on TriMedia");
				break;

				case PROG_STATE_LOADED :
				ctcStartExecuteable ( pParser );	
				pParser->ProgramState = PROG_STATE_STARTED;
				break;

				case PROG_STATE_STOPPED :
				case PROG_STATE_NOTINIT :
				pParser->WriteStr(pParser->pDevice,
					"\r\nTMMon : ERROR : No Program downloaded on TriMedia");
				break;
			}
			pParser->wState = CMD_WAIT;
			break;

			case ST_CMD :
			{
				HANDLE hServerEvent;
				ctcStopExecuteable ( pParser );	
				pParser->ProgramState = PROG_STATE_STOPPED;
				/*
				switch ( pParser->ProgramState )
				{
					case PROG_STATE_STARTED :
					ctcStopExecuteable ( pParser );	
					pParser->ProgramState = PROG_STATE_STOPPED;
					break;

					case PROG_STATE_LOADED :
					case PROG_STATE_STOPPED :
					case PROG_STATE_NOTINIT :
					pParser->WriteStr(pParser->pDevice,
						"\r\nTMMon : ERROR : No Program Executing on TriMedia");
					break;

				}
				*/
			}
			pParser->wState = CMD_WAIT;
			break;

			/* 
				command to generate interrupt 
			*/
			case GI_CMD :
			__asm {
			   push    eax
			   push    edx
			   mov     dx, 0378h
			   mov     al, 01h
			   out     dx, al
			   mov     al, 00h
			   out     dx, al
			   pop     edx
			   pop     eax

			}
			pParser->wState = CMD_WAIT;
			break;

			/*
				Quit Debugger Command
			*/
			case QU_CMD :
			// quit the debugger.
			if	( pParser->ProgramState == PROG_STATE_STARTED )
			{
				ctcStopExecuteable ( pParser );	
				pParser->ProgramState = PROG_STATE_STOPPED;
			}
			pParser->wState = CMD_WAIT;
			return FALSE;


			case HL_CMD :
			case HE_CMD :
			pParser->WriteStr(pParser->pDevice, 
				"\r\n TMMon command set : " );

			pParser->WriteStr(pParser->pDevice, 
				"\r\n HELP : Prints this Help Screen");
			pParser->WriteStr(pParser->pDevice, 
				"\r\n QUIT : Quit the Debugger");

			pParser->WriteStr(pParser->pDevice, 
				"\r\n RB <Address> <Length> : Read Byte <- Memory");
			pParser->WriteStr(pParser->pDevice,
				"\r\n RW <Address> <Length> : Read Word <- Memory");
			pParser->WriteStr(pParser->pDevice,
				"\r\n RD <Address> <Length> : Read Dword <- Memory");
			pParser->WriteStr(pParser->pDevice,
				"\r\n WB <Address> <Byte1> <Byte2> <Byte3> ... <.> : Write Byte -> Memory");
			pParser->WriteStr(pParser->pDevice,
				"\r\n WW <Address> <Word1> <Word2> <Word3>... <.> : Write Word -> Memory");
			pParser->WriteStr(pParser->pDevice,
				"\r\n WD <Address> <Dword1> <Dword2> <Dword3>...<.> : Write Dword -> Memory");
			pParser->WriteStr(pParser->pDevice,
				"\r\n PF <Address> <Length> <Filename> : Memory -> File Dump");
			pParser->WriteStr(pParser->pDevice,
				"\r\n GF <Address> <Filename> : File -> Memory Dump");
			pParser->WriteStr(pParser->pDevice, "\r\n GI : Generate Interrupt");

			pParser->WriteStr(pParser->pDevice,
				"\r\n LOAD <filename> <arg1> <arg2>... <.> : Load Executeable Image -> Memory");
			pParser->WriteStr(pParser->pDevice,
				"\r\n RUN : Execute TM code");
			pParser->WriteStr(pParser->pDevice,
				"\r\n STOP : Stops program execution on TriMedia");

			pParser->WriteStr(pParser->pDevice,
				"\r\n TE < arg1> <arg2>... <.> : Execute a test function");

			pParser->WriteStr(pParser->pDevice,
				"\r\n SO <Filename> : Start STDOUT Redirection");
			pParser->WriteStr(pParser->pDevice,
				"\r\n EO : End STDOUT Redirection");

			pParser->WriteStr(pParser->pDevice,
				"\r\n SI <Filename> : Start STDIN Redirection");
			pParser->WriteStr(pParser->pDevice,
				"\r\n EI : End STDIN Redirection");

			pParser->WriteStr(pParser->pDevice,
				"\r\n SE <Filename> : Start STDERR Redirection");
			pParser->WriteStr(pParser->pDevice,
				"\r\n EE : End STDERR Redirection");

			pParser->WriteStr(pParser->pDevice,
				"\r\n SS <Size> : Set Scroll Windows Size for TMCons");

			pParser->WriteStr(pParser->pDevice,
				"\r\n DEBUGON <pcmem|sdram|mono>... <.> : Set tmDBGString() Output");
			pParser->WriteStr(pParser->pDevice,
				"\r\n DEBUGOFF <pcmem|sdram|mono>... <.> : Remove tmDBGString() Output");

			pParser->WriteStr(pParser->pDevice,
				"\r\n TRACEP <filename> <.> : Dump Persistent Trace Buffer");
			pParser->WriteStr(pParser->pDevice,
				"\r\n TRACEV : Dump Volatile Trace Buffer");

			pParser->wState = CMD_WAIT;
			break;


			/* TR960222 - added for calling test routines in test.c */
			case TE_CMD :
			pParser->dwTaskTestArgCount = 0;
			pParser->dwIdxArgStr = 0;
			pParser->wState = TE_ARGS;
			break;

			case TE_ARGS :
			// if we have reached end of line then continue on the next line.
			if ( ! szToken[0] )
				break;

			if ( szToken[0] == '.' )	
			{
				PCHAR *ArgPtrArray;
				DWORD 	dwArgIdx, dwStrIdx ;

				if ( ( ArgPtrArray =
					malloc ( sizeof ( PCHAR ) * ( pParser->dwTaskTestArgCount + 1 ) ) ) 
					== NULL )
				{
					fprintf ( stderr, 
						"\r\nTMMon : ERROR : CMD TE : out of memory");	
					pParser->wState = CMD_WAIT;
					break;
				}
		
				for ( dwStrIdx = dwArgIdx = 0 ;
						dwArgIdx < pParser->dwTaskTestArgCount ;
						dwArgIdx++, dwStrIdx++ ) // dwStrIdx++ to skip over NULL
				{
				 	
					// put the pointer to the vectors in the pointer array
					ArgPtrArray[dwArgIdx] = &pParser->szTestName[dwStrIdx];
					
					// search for the end of the string
					for ( ; pParser->szTestName[dwStrIdx] ; dwStrIdx ++ );

				}
				 
				ArgPtrArray[dwArgIdx] = NULL;

									
				TaskTest ( pParser->dwTaskTestArgCount,
					ArgPtrArray,
					halGetSDRAMLin ( pParser->pTMHW ),
					halGetMMIOLin ( pParser->pTMHW ), 
					halGetSDRAMLen ( pParser->pTMHW ) );
				
				free ( ArgPtrArray );
				pParser->wState = CMD_WAIT;
			}
			else
			{
				strcpy ( &pParser->szTestName[pParser->dwIdxArgStr],
					szToken );
				pParser->dwIdxArgStr += ( strlen ( szToken ) + 1) ;
				pParser->dwTaskTestArgCount++;

				if ( pParser->dwIdxArgStr > MAX_STRING )
				{
					pParser->WriteStr(pParser->pDevice,
						"\r\nTMMon : ERROR : Input buffer overflow");
					pParser->wState = CMD_WAIT;
				}

			}
			break;
			

			/* command for setting the windows size */
			case SS_CMD :
			pParser->wState = SS_SIZE;
			break;

			case SS_SIZE :
			if ( sscanf( szToken,"%d", &pParser->TMCons.dwWindowSize ) != 1)
			{