ctc.cpp

wince host 和 target PCI驱动程序

		sprintf(szTemp,"0x%08x", pMMIO->dwLinear);
		pTmgmonDlg->SetDlgItemText(IDC_MMIO3,szTemp);

		sprintf(szTemp,"0x%08x",pUser->dwPhysical);
		pTmgmonDlg->SetDlgItemText(IDC_USER,szTemp);
		sprintf(szTemp,"0x%08x", pUser->dwSize);
		pTmgmonDlg->SetDlgItemText(IDC_USER2,szTemp);
		sprintf(szTemp,"0x%08x", pUser->dwLinear);
		pTmgmonDlg->SetDlgItemText(IDC_USER3,szTemp);

		// add to show Linear and physical address
		GetDisplayInfo();
//		sprintf(szTemp,"0x%08x",g_dwLinearAddress);
//		pTmgmonDlg->SetDlgItemText(IDC_LINEARADDRESS,szTemp);
		sprintf(szTemp,"0x%08x",g_dwPhysicalAddress);
		pTmgmonDlg->SetDlgItemText(IDC_PHYSICALADDRESS2,szTemp);
		sprintf(szTemp,"%08u",g_dwStride);
		pTmgmonDlg->SetDlgItemText(IDC_STRIDE,szTemp);
		sprintf(szTemp,"%08u",g_dwPixelDepth);
		pTmgmonDlg->SetDlgItemText(IDC_PIXEDDEPTH,szTemp);
	}

	return TRUE;
}



// mythis function should call into tmldr.dll or tmldr.exe 
BOOL	ctcLoadExecuteable ( PPARSER pParser, PCMD_LD_PARAM mythis )
{
	BYTE	bErrorString[MAX_STRING];
	BYTE	bFileName[MAX_STRING];
	STATUS	Status;

    DWORD              ImageType,ImageEndian;

	HANDLE				ImageFileHandle;
	DWORD				BytesReturned;
	DWORD				ArgIdx;
	DWORD				Argv0Length;


	// BEGIN APPLOAD

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


	if ( ImageType == TMObj_AppSegment ) 
	{

		CHAR	TCSPath[MAX_PATH]; 

		strcpy ( mythis->szApplicationFile, mythis->szExecutableFile );
		mythis->fDynamicApplicaiton = True;

        if ( tmGetTCSPath (
            TCSPath,
            MAX_PATH ) != True )
        {
            sprintf ( mythis->szExecutableFile, "%s", "appshell.out" );
        }
        else
        {
            // TCS\lib\el\appshell.out
            sprintf ( mythis->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 ( mythis->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++ )
		{
			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],
			mythis->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, mythis->szExecutableFile, mythis->dwCountArg, (PCHAR *)(mythis->ArgumentPtr) ) ) != TMOK )
	{
		sprintf ( (char *)bErrorString,
         "\r\nTMMon: ERROR  : Loading Executable [%s] : FAIL [%x]:[%s]", 
			mythis->szExecutableFile, Status, tmGetErrorString(Status) );
		 AfxMessageBox((LPCTSTR)bErrorString);
		 return FALSE;
	}

	return TRUE;
}

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

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


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

	if ( ( Status = tmDSPExecutableStop(
		((PTM_HW)pParser->pTMHW)->DSPHandle ) ) != TMOK )
	{
		sprintf ( (char *)bErrorString,
			"\r\nTMMon: ERROR  : Stopping Target Executable Image : FAIL [%x]:[%s]", 
			Status, tmGetErrorString(Status) );
		 AfxMessageBox((LPCTSTR)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	;


	return 0;
}

/***************************************************
Following functions are to called from GUI interface
***************************************************/

STATUS tmDSPGetStatus(DWORD dwHandle,PDWORD pdwFlags)
{
	PPARSER pParser=&Parser;
	switch(pParser->ProgramState)
	{
		case PROG_STATE_LOADED:
			*pdwFlags=TMMAN_DSPSTATUS_EXECUTABLE_LOADED;
			break;
		case PROG_STATE_NOTINIT:
		case PROG_STATE_STOPPED:
			*pdwFlags=TMMAN_DSPSTATUS_EXECUTABLE_STOPPED;
			break;
		case PROG_STATE_STARTED:
			*pdwFlags=TMMAN_DSPSTATUS_EXECUTABLE_RUNNING;
			break;
	}
	return TMOK;
}

int	halValidateAddress ( PTM_HW pTMHW, DWORD dwAddress, PDWORD pLinear,PDWORD pSize)
{
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->DSPCaps.SDRAM;
	PTMSTD_MEMORY_BLOCK	pMMIO = &pTMHW->DSPCaps.MMIO;
	PTMSTD_MEMORY_BLOCK	pUser = &pTMHW->DSPCaps.User;

	if( ( dwAddress >= pSDRAM->dwPhysical ) &&
		( dwAddress <= ( pSDRAM->dwPhysical + pSDRAM->dwSize - 1) ) )
	{
		*pLinear = (dwAddress - pSDRAM->dwPhysical ) + pSDRAM->dwLinear ;
		*pSize = pSDRAM->dwSize - (dwAddress - pSDRAM->dwPhysical);
		return 1;
	}
	if( ( dwAddress >= pUser->dwPhysical ) &&
		( dwAddress <= (pUser->dwPhysical + pUser->dwSize - 1)  ) )
	{
		*pLinear = (dwAddress - pUser->dwPhysical ) + pUser->dwLinear ;
		*pSize = (dwAddress - pUser->dwPhysical) + pUser->dwSize;

		return 3;
	}
	dwAddress &= 0xffffffffc;
	if( ( dwAddress >= pMMIO->dwPhysical ) &&
		( dwAddress <= (pMMIO->dwPhysical + pMMIO->dwSize - 1)  ) )
	{
		*pLinear = (dwAddress - pMMIO->dwPhysical ) + pMMIO->dwLinear ;
		*pSize = (dwAddress - pMMIO->dwPhysical) + pMMIO->dwSize;

		return 2;
	}
	return 0;		// Not in range
}

void ctc_exit(void)
{
	PPARSER pParser=&Parser;
	if	(pParser->ProgramState == PROG_STATE_STARTED )
		ctcStopExecuteable ( pParser );
	halExit((PTM_HW)(pParser->pTMHW));
}

void ctc_loadfile(char *filename,char *arguments)
{
    CWaitCursor wait;	// display wait cursor

	char *p1 = filename;
	while (*p1 != '\0')
	{
		if(*p1 == ' ')
			*p1 = '#';
		p1++;
	}

	PPARSER pParser=&Parser;
	strcpy(pParser->szInputString,"load ");
	strcat(pParser->szInputString,filename);
	strcat(pParser->szInputString," ");
	strcat(pParser->szInputString,arguments);
	strcat(pParser->szInputString," .");
	ProcessLine(pParser);
}

void ctc_stop(void)
{
	PPARSER pParser=&Parser;
	ctcStopExecuteable ( pParser );
	pParser->ProgramState = PROG_STATE_STOPPED;
	/*
	strcpy(pParser->szInputString,"stop");
	ProcessLine(pParser);
	*/
}

void ctc_go(char *filename,char *arguments)
{
	PPARSER pParser=&Parser;
	DWORD dwFlags;
	tmDSPGetStatus(((PTM_HW)pParser->pTMHW)->DSPHandle,&dwFlags);

	switch(dwFlags)
	{
		case TMMAN_DSPSTATUS_EXECUTABLE_LOADED:
			break;
		case TMMAN_DSPSTATUS_EXECUTABLE_STOPPED:
			if(*filename != 0)
				ctc_loadfile(filename,arguments);
			break;
		case TMMAN_DSPSTATUS_EXECUTABLE_RUNNING:
			ctc_stop();
			if(*filename != 0)
				ctc_loadfile(filename,arguments);
			break;
	}
	tmDSPGetStatus(((PTM_HW)pParser->pTMHW)->DSPHandle,&dwFlags);
	if(dwFlags == TMMAN_DSPSTATUS_EXECUTABLE_LOADED)
	{
		ctcStartExecuteable ( pParser );	
		pParser->ProgramState = PROG_STATE_STARTED;
	}
	else if (*filename == 0)
		AfxMessageBox("ERROR : No Program downloaded on TriMedia");
}

ctc_mem(HWND hwnd,DWORD PhyAddress,int dumptype,BOOL start)
{
	DWORD LinearAdr,Size;
	PPARSER pParser=&Parser;
	static int memtype=0;

	if(start)
	{
		memtype=halValidateAddress((PTM_HW)(pParser->pTMHW) ,PhyAddress,&LinearAdr,&Size);
		if(memtype == 0)
			return FALSE;
	}
	if(memtype == 2)		// MMIO
	{
		dumptype=2;
		PhyAddress &= 0xffffffffc;
	}
	ViewMem(hwnd,PhyAddress,(PVOID)LinearAdr,Size,dumptype,memtype,start);
	return TRUE;
}

void ctc_debug(char *str)
{
	PPARSER pParser=&Parser;
	strcpy(pParser->szInputString,str);
	ProcessLine(pParser);
}

void ctc_redirect(char *str)
{
	PPARSER pParser=&Parser;
	strcpy(pParser->szInputString,str);
	ProcessLine(pParser);
}

void ctc_trace(CEdit * pEdit,char *str)
{
    CWaitCursor wait;	// display wait cursor
	PPARSER pParser=&Parser;
	extern	CString		g_sFileName;

	traceEdit=TRUE;
	strcpy(pParser->szInputString,str);
	pTraceView=pEdit;
	pTraceView->SetWindowText("");

	if ( pParser->fTraceIntoFile == FALSE )			//If trace in window
	{
		traceBuffer=new char[65000];
		if(traceBuffer==0)
		{
			AfxMessageBox("Error: Cannot allocate memory");
			return;
		}
		traceIndex=0;
	}
	ProcessLine(pParser);
	if ( pParser->fTraceIntoFile == FALSE )			//If trace in window
		delete[] traceBuffer;
	traceEdit=FALSE;
}

DisplayTrace(PVOID pBuffer, DWORD dwLength)
{
	DWORD i;
	PBYTE pByte=(PBYTE)pBuffer;
	for(i=0;i<dwLength;i++)
	{
		if(traceIndex >= 64000)
			break;
		if(*pByte == '\n')
		{
			if(traceIndex > 0)
				if(traceBuffer[traceIndex-1] != '\r')
					traceBuffer[traceIndex++]='\r';
		}
		traceBuffer[traceIndex++]=*pByte++;
	}
	return 1;
}

void ctc_newcard(void)
{
	PPARSER pParser=&Parser;
	halExit((PTM_HW)(pParser->pTMHW));
}

typedef	DWORD ( FAR WINAPI *LPFNDDCREATE)( PVOID, LPDIRECTDRAW *, PVOID );

void GetDisplayInfo(void)
{
	HINSTANCE	hDDraw;
	LPDIRECTDRAW	pDD;
	LPDIRECTDRAWSURFACE	pDDSPrimary;
	LPFNDDCREATE	lpfnDirectDrawCreate;

	if ( !g_dwPhysicalAddress )
	{
		hDDraw = LoadLibrary( "DDRAW" );
		if ( !hDDraw )
		{
			return;
		}

		if ( !( lpfnDirectDrawCreate = (LPFNDDCREATE) GetProcAddress( hDDraw,"DirectDrawCreate" ) ) )
		{
			FreeLibrary( hDDraw );
			return;
		}

		if ( ( *lpfnDirectDrawCreate )( NULL, &pDD, NULL ) )
		{
			FreeLibrary( hDDraw );
			return;
		}

		if ( pDD->SetCooperativeLevel( NULL, DDSCL_NORMAL ) )
		{
			FreeLibrary( hDDraw );
			return;
		}

		DDSURFACEDESC	ddsd;

		ddsd.dwSize = sizeof( ddsd );
		ddsd.dwFlags = DDSD_CAPS;
		ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
		if ( pDD->CreateSurface( &ddsd, &pDDSPrimary, NULL ) )
		{
			FreeLibrary( hDDraw );
			return;
		}

		if ( pDDSPrimary->GetSurfaceDesc( &ddsd ) )
		{
			pDDSPrimary->Release();
			FreeLibrary( hDDraw );
			return;
		}

		if ( ( ddsd.ddpfPixelFormat.dwFlags & DDPF_RGB ) )
		{
			DWORD	dwIn[4];
			DWORD	dwOut[4];

			g_dwStride = ddsd.lPitch;
			g_dwPixelDepth = ddsd.ddpfPixelFormat.dwRGBBitCount;
			pDDSPrimary->Lock( NULL, &ddsd, 0, NULL );
			g_dwLinearAddress = (DWORD) ddsd.lpSurface;
			pDDSPrimary->Unlock( NULL );
			
			dwIn[0] = g_dwLinearAddress;
			dwIn[1] = 0x1000L;
			VXDCall( 0x202, dwIn, 8, dwOut, 8 );
			g_dwPhysicalAddress = dwOut[0];
			
		}

		pDDSPrimary->Release();
		FreeLibrary( hDDraw );
	}
}


DWORD
VXDCall(
	DWORD	Cmd,
	PVOID	InBuff,
	DWORD	cbIn,
	PVOID	OutBuff,
	DWORD	cbOut )
{
	OVERLAPPED	ovlp = { 0, 0, 0, 0, 0 };
	DWORD		cbRet;
	DWORD		dwErrorCode;
	HANDLE		hVxD;

	hVxD = CreateFile( "\\\\.\\VTMMAN.VXD", 
						0, 0, 0, 0,
						FILE_FLAG_DELETE_ON_CLOSE, 0 );
	if ( hVxD == INVALID_HANDLE_VALUE )
	{
		dwErrorCode = GetLastError();
		return ( dwErrorCode );
	}

	if ( !DeviceIoControl( hVxD, Cmd, InBuff, cbIn, 
							OutBuff, cbOut, &cbRet, &ovlp ) )
	{
		dwErrorCode = GetLastError();
		return ( dwErrorCode );
	}

	if ( hVxD )
		CloseHandle( hVxD );

	return 0;
}