vxdbg.c

wince host 和 target PCI驱动程序

/*---------------------------------------------------------------------------- 
COPYRIGHT (c) 1995 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.
----------------------------------------------------------------------------*/
/*
	HISTORY
	#define	TR	Tilakraj Roy
	960405	TR 	Created
	
*/

#define WANTVXDWRAPS
#include "basedef.h"
#include "vmm.h"
#include "vxdwraps.h"
#include "debug.h"

#include "vxstd.h"
#include "vxwin.h"
#include "vxdbg.h"

#include "tmwincom.h"
#include "tmshare.h"

#pragma	VxD_LOCKED_CODE_SEG
#pragma	VxD_LOCKED_DATA_SEG

typedef struct	_DEBUGCALLBACK
{
	PDBG_FUNCTION	pvFunction;
	PVOID	pvContext;
	PCHAR	pszString;
}	DEBUGCALLBACK, *PDEBUGCALLBACK;

typedef struct _DEBUGGING
{
	DWORD	dwLevelBitmap;
	PBYTE	pBuffer;
	WORD	wLength;
	WORD	wPosition;
	PDEBUGFUNC	pfnDBGOutput;

	// added to facilitate debugging
	DWORD	dwFunctionCount;
	DEBUGCALLBACK CBFunc[DBG_MAX_FUNCTION_COUNT];

	CHAR	pTempStr[0x80];
	CHAR	pTempStr2[0x80];
}	DEBUGGING, *PDEBUGGING;

DEBUGGING	DBG;

VOID	dbgTrace ( PBYTE pString );

//extern BOOL dbgSprintf(char * pString, char * pFormat, ...);

BOOL	dbgInit ( VOID )
{
	DWORD	Idx;
	DBG.wLength = 2000;
	if ( ( DBG.pBuffer =
		_HeapAllocate ( DBG.wLength,
		HEAPZEROINIT | HEAPSWAP ) ) == NULL )
	{
		return FALSE;
	}	
	
	DBG.dwLevelBitmap = 
		((PINIT_OBJECT)(pDriverObject->pInitObj))->dwDBGLevelBitmap;

	switch ( ((PINIT_OBJECT)(pDriverObject->pInitObj))->dwDBGType )
	{
		case 1 :
		DBG.pfnDBGOutput = dbgTrace;

		default :
		DBG.pfnDBGOutput = dbgOutput;
		break;
	}

	DBG.wPosition = 0;

	for (  Idx = 0 ; Idx < DBG_MAX_FUNCTION_COUNT ; Idx ++ )
	{
		DBG.CBFunc[Idx].pvFunction = NULL;
		DBG.CBFunc[Idx].pszString = NULL;
		DBG.CBFunc[Idx].pvContext = NULL;
	}

	DP( 0,"vtmman.vxd:DDBTraceBuffer:LinearAddress[%x]:Length[%x]\n",
		DBG.pBuffer, DBG.wLength );

	return	TRUE;
}

VOID	dbgGetTraceBuffer  ( PBYTE *pPing , PDWORD pPingSize,
	PBYTE *pPong, PDWORD pPongSize )
{

}

VOID	dbgTraceBufferDump ( VOID )
{

}


VOID	dbgTrace ( PBYTE pString )
{
	WORD	wIdx;
	WORD	TempPosition;

	for ( wIdx = 0; pString[wIdx]; wIdx++ )
	{
		if ( ! iscontrol(pString[wIdx]) ) 
		{
			if ( ++DBG.wPosition >= DBG.wLength )
				DBG.wPosition = 0;
		}
	}
	
	TempPosition = DBG.wPosition;
	if ( ++TempPosition >= DBG.wLength )
		TempPosition = 0;
	DBG.pBuffer[TempPosition] = '@';

	if ( ++TempPosition >= DBG.wLength )
		TempPosition = 0;
	DBG.pBuffer[TempPosition] = '@';

}
	
/*-----------------------------------------------------------------------------
dbgSprintf
-----------------------------------------------------------------------------*/
VOID dbgNULL(DWORD	dwLevel, char * pFormat, ...)
{
}

VOID dbgPrintf(DWORD	dwLevel, char * pFormat, ...)
{
	PVOID	pArgument = &pFormat;
	WORD	Idx, StrIdx = 0, BufIdx = 0;
	BYTE	Char;

	if( (((DWORD)( 0x01 << (dwLevel))) & DBG.dwLevelBitmap) && 
			(DBG.pfnDBGOutput) ) ;
	else
	{
		return;
	}

	// this function is ment for a 32 bit environment.
	// modify pointer increment values for 32 bit stack.
	((PVOID *)pArgument)++;

	for( Idx = 0 ; pFormat[Idx] ; Idx ++ )
	{
		if( pFormat[Idx] == '%')
		{
			Char = pFormat[++Idx];
			switch( Char )
			{

				case 'd':
				{
					DWORD	Value = *((PDWORD)pArgument);
					DWORD	Divisor;
					for( Divisor = 1 ; (Value / Divisor) >= 10 ;
						Divisor *= 10);
					do
					//for( ; Value ; Divisor /= 10)
					{
						DBG.pTempStr[StrIdx++] = (BYTE)
							( (Value / Divisor) + '0');

						Value = (DWORD)(Value % Divisor);
						Divisor /= 10;
					} while ( Divisor > 0);

					((PDWORD)pArgument)++;
				}
				break;

				case 's':
				for ( BufIdx = 0 ;
					((PBYTE)(*((PBYTE*)pArgument)))[BufIdx];
					BufIdx++ )
					DBG.pTempStr[StrIdx++] = 
					(((PBYTE)(*((PBYTE*)pArgument)))[BufIdx]);

				((PVOID *)pArgument)++;
				break;

				case 'c':
				DBG.pTempStr[StrIdx++] = (*((PBYTE)pArgument));
				((PDWORD)pArgument)++;
				break;

				case 'x':
				{
					DWORD	Value = *((PDWORD)pArgument);
					BYTE Hex[] = "0123456789ABCDEF";
					DWORD	Divisor;
					for( Divisor = 1 ; (Value / Divisor) >= 16 ;
						Divisor *= 16);

					do
					//for(  ; Value ; Divisor /= 16)
					{
						DBG.pTempStr[StrIdx++] = 
							(Hex[(Value / Divisor)]);

						Value = (DWORD)(Value % Divisor);

						Divisor /= 16;

					} while ( Divisor > 0);

					((PDWORD)pArgument)++;
				}
				break;

				default :
				DBG.pTempStr[StrIdx++] = ('%');
				DBG.pTempStr[StrIdx++] = (Char);
				break;
			}
		}
		else
		{
			DBG.pTempStr[StrIdx++] = pFormat[Idx];
			continue;
		}
	}
	DBG.pTempStr[StrIdx] = 0;
	(DBG.pfnDBGOutput)(DBG.pTempStr);
}

/*---------------------------------------------------------------------------- 
	Soft/ICE & WDEB386 specific functionality 
	When calling this function ensure that the string is not on local 
	stack since it will fuck things up mighty bad.
----------------------------------------------------------------------------*/
BOOL	dbgRegister ( PDBG_FUNCTION pFunc, PCHAR szString )
{
	if ( DBG.dwFunctionCount >= DBG_MAX_FUNCTION_COUNT )
		return FALSE;
	DBG.CBFunc[DBG.dwFunctionCount].pvFunction = pFunc;
	DBG.CBFunc[DBG.dwFunctionCount].pszString = szString;
	DBG.dwFunctionCount++;
	return TRUE;
}

VOID	vxdDebugDumpC ( VOID )
{
	BYTE	bInput;
	BYTE	bFunctionIndex,bBoardIndex = 0;
	DWORD	dwIdx;

	dbgPrintf ( 0, "TM : vtmman : Debug Subsystem \n");

	for ( dwIdx = 0; dwIdx < DBG.dwFunctionCount ; dwIdx ++ )
	{
		dbgPrintf (0, "[%x] - [%s]\n", dwIdx, DBG.CBFunc[dwIdx].pszString );
		
	}

	if ( pDriverObject->wDeviceCount > 1)
	{
		dbgPrintf ( 0, 
		"Enter Board Number [0 - %x] >>",
			pDriverObject->wDeviceCount - 1 );

		winIn_Debug_Chr ( &bInput );
		dbgPrintf ( 0, "%c\n", bInput );

		bBoardIndex = ( bInput - '0' );

	}

	while ( 1 )
	{
		if ( DBG.dwFunctionCount == 0 )
		{
			dbgPrintf(0, "vxd:DEBUG:No Debugging Info Available\n" );
			break;
		}

		dbgPrintf ( 0, 
			"Enter Debug Option [0 - %x] or [Q to Quit] >>",
				DBG.dwFunctionCount - 1 );

		winIn_Debug_Chr ( &bInput );
		dbgPrintf ( 0, "%c\n", bInput );

		bFunctionIndex = ( bInput - '0' );
		
		if ( ( bInput == 'Q' ) || ( bInput == 'q' ) ) 
			break;

		if( ( bFunctionIndex < 0 ) || 
			( ( bFunctionIndex >= DBG.dwFunctionCount ) ) )
		{
			dbgPrintf(0, "vxd:DEBUG:Invalid Option [%c]\n", bInput );
			continue;
		}

		if ( DBG.CBFunc[bFunctionIndex].pvFunction == NULL )
		{
			dbgPrintf(0, "vxd:DEBUG:No DebugInfo for Option [%c]\n", bInput );
			continue;
		}

		DBG.CBFunc[bFunctionIndex].pvFunction ( 
			pDriverObject->pDeviceList[bBoardIndex] );
	}

}