tmdbg.c

wince host 和 target PCI驱动程序

	}

	/* COPYBACK ( Address, ???? ) */
	/* write back the buffer control block - ignoring the magic string */
	COPYBACK ( (((PBYTE)this->pPersistData) + TMHD_DBG_MAGICSIZE + 1), 1 );


	Length = wIdx;

	for ( wIdx = 0 ; wIdx < Length ; wIdx++ )
	{
		Invalidate = (DWORD)
			&this->pPersistData->pPBuffer[Current];

		if ( ++Current >= this->pPersistData->PBufLen )
		{
			Current = 0;
		}

		COPYBACK ( (PBYTE)Invalidate , 1); 
	}

	/* don't forget the last block 
	COPYBACK ( &this->pPersistData->pPBuffer[Current], 1); */

	End = cycles();
	intRESTORE_IEN ( PCSW );
	Cycles = ( End > Start ) ? (End - Start)  : (End + ((DWORD)(~0) - Start));
	/* if ( Cycles > 2000 ) tmDBGString("LATENCY ERROR"); */

}
	
VOID	dbgOutStdout ( PVOID pvDebug, PCHAR szString )
{
	PTMDBG_OBJECT this = (PVOID)pvDebug;

	fprintf ( stdout, szString  );
}

VOID	dbgOutStderr ( PVOID pvDebug, PCHAR szString )
{
	PTMDBG_OBJECT this = (PVOID)pvDebug;
	fprintf ( stderr, szString  );
}

VOID	dbgOutMono ( PVOID pvDebug, PCHAR szString )
{
	PTMDBG_OBJECT this = (PVOID)pvDebug;
	DWORD	dwIdx;
	DWORD	PCSW;

	DWORD	Start, End, Cycles;
	PCSW = intCLEAR_IEN ();
	Start = cycles();


	for ( dwIdx = 0 ; ; dwIdx++ )
	{
		switch ( szString[dwIdx] )	
		{
			
			case '\0' :
			return;

			case '\n' :
			dbgRowInc ( this );
			break;
			

			default :
			if ( ! iscntrl ( szString[dwIdx] ) )
			{


				*( this->pwScreenBuffer + 
					( ( this->dwStartRow + this->dwCurrentRow ) * SCREEN_COLS ) 
					+ ( this->dwStartCol + this->dwCurrentCol ) ) =
					(WORD)(szString[dwIdx] | 0x0700 ); 
				dbgColInc ( this );
			}
			
			break;

		}
	}
	End = cycles();
	intRESTORE_IEN ( PCSW );
	Cycles = ( End > Start ) ? (End - Start)  : (End + ((DWORD)(~0) - Start));
	/* if ( Cycles > 2000 ) tmDBGString("LATENCY ERROR"); */

}

/* callback debugging function entry point */
BOOL	dbgCallback ( DWORD FuncitonID )
{
	PTMDBG_OBJECT this = (PVOID)pDBG;
	return TRUE;
}

DWORD	tmDBGPrintf(char * pFormat, ...)
{
/*
	PTMDBG_OBJECT this = (PTMDBG_OBJECT)pDBG;


	DWORD	Idx, StrIdx = 0;
	BYTE	Char;
	DWORD	Items = 0;

	DWORD	PCSW;

	va_list	pArgument;

	DWORD	Start, End, Cycles;
	PCSW = intCLEAR_IEN ();
	Start = cycles();


	va_start ( pArgument, pFormat );

	for( Idx = 0 ; pFormat[Idx] ; Idx ++ )
	{
                if (StrIdx >= DBG_MAX_STRING_SIZE - 2) {
		     break;
		}

		if( pFormat[Idx] == '%')
		{
			Items++;
			Char = pFormat[++Idx];
			switch( Char )
			{
				case 'd':
				dbgProcessDec ( this->pTempStrG, &StrIdx, va_arg ( pArgument, DWORD ) );
				break;

				case 's':
				dbgProcessStr ( this->pTempStrG, &StrIdx, va_arg ( pArgument, PVOID ) );
				break;

				case 'c':
				dbgProcessChar ( this->pTempStrG, &StrIdx, va_arg ( pArgument, CHAR ) );
				break;

				case 'x':
				dbgProcessHex ( this->pTempStrG, &StrIdx, va_arg ( pArgument, DWORD ) );
				break;

				default :
				Items--;
				this->pTempStrG[StrIdx++] = ('%');
				this->pTempStrG[StrIdx++] = (Char);
				break;
			}
		}
		else
		{
			this->pTempStrG[StrIdx++] = pFormat[Idx];
			continue;
		}
	}
	this->pTempStrG[StrIdx] = 0;

	va_end ( pArgument );

	tmDBGString ( this->pTempStrG ); 

	End = cycles();
	intRESTORE_IEN ( PCSW );
	Cycles = ( End > Start ) ? (End - Start)  : (End + ((DWORD)(~0) - Start));
	 if ( Cycles > 2000 ) tmDBGString("LATENCY ERROR"); 

	return Items;
*/

	return 0;
}

/* internal use of TMMAN */
DWORD	tmDGBTMMANGetLevel(DWORD dwLevel )
{
    return ( ( ( dwLevel) & DBG.pSharedData->Level ) == dwLevel );
}

/* internal use of TMMAN */
DWORD	tmDBGTMMANPrintf( char * pFormat, ...)
{
	PTMDBG_OBJECT this = (PTMDBG_OBJECT)pDBG;

	DWORD	Idx, StrIdx = 0;
	BYTE	Char;
	DWORD	Items = 0;

	DWORD	PCSW;

	va_list	pArgument;

	DWORD	Start, End, Cycles;

	PCSW = intCLEAR_IEN ();
/*	Start = cycles();  */


	va_start ( pArgument, pFormat );

	for( Idx = 0 ; pFormat[Idx] ; Idx ++ )
	{

		if ( ! ( StrIdx < DBG_MAX_STRING_SIZE ) )
		{
			StrIdx--;
			break;
		} 

		if( pFormat[Idx] == '%')
		{
			Items++;
			Char = pFormat[++Idx];
			switch( Char )
			{
				case 'd':
				dbgProcessDec ( this->pTempStrT, &StrIdx, va_arg ( pArgument, DWORD ) );
				break;

				case 's':
				dbgProcessStr ( this->pTempStrT, &StrIdx, va_arg ( pArgument, PVOID ) );
				break;

				case 'c':
				dbgProcessChar ( this->pTempStrT, &StrIdx, va_arg ( pArgument, CHAR ) );
				break;

				case 'x':
				dbgProcessHex ( this->pTempStrT, &StrIdx, va_arg ( pArgument, DWORD ) );
				break;

				default :
				Items--;
				this->pTempStrT[StrIdx++] = ('%');
				this->pTempStrT[StrIdx++] = (Char);
				break;
			}
		}
		else
		{
			this->pTempStrT[StrIdx++] = pFormat[Idx];
			continue;
		}
	}
	this->pTempStrT[StrIdx] = 0;

	va_end ( pArgument );

	dbgOutTraceP ( this,  this->pTempStrT  ); 

/*	End = cycles(); */
	intRESTORE_IEN ( PCSW );
/*	Cycles = ( End > Start ) ? (End - Start)  : (End + ((DWORD)(~0) - Start)); */

	return Items;
}

DWORD	tmDBGNULL(PVOID pDummy, ...)
{
	return 0;
}

VOID	dbgProcessChar ( PCHAR pszBuffer, PDWORD pdwPosition, CHAR Value  )
{
	pszBuffer[(*pdwPosition)++] = Value;
}
VOID	dbgProcessDec ( PCHAR pszBuffer, PDWORD pdwPosition, DWORD Value  )
{
	DWORD	Divisor;
	for( Divisor = 1 ; (Value / Divisor) >= 10 ;
		Divisor *= 10);
	do
	{
		pszBuffer[(*pdwPosition)++] = (BYTE)
			( (Value / Divisor) + '0');

		/* check if we are overflowing the temp buffer. */
                if ((*pdwPosition) >= DBG_MAX_STRING_SIZE - 1) {
		     break;
		}

		Value = (DWORD)(Value % Divisor);
		Divisor /= 10;
	} while ( Divisor > 0);
}
VOID	dbgProcessHex ( PCHAR pszBuffer, PDWORD pdwPosition, DWORD Value  )
{
	BYTE Hex[] = "0123456789ABCDEF";
	DWORD	Divisor;

	for( Divisor = 1 ; (Value / Divisor) >= 16 ;
		Divisor *= 16);

	do
	{
		pszBuffer[(*pdwPosition)++] = (Hex[(Value / Divisor)]);

		/* check if we are overflowing the temp buffer. */
                if ((*pdwPosition) >= DBG_MAX_STRING_SIZE - 1) {
		     break;
		}

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

VOID	dbgProcessStr ( PCHAR pszBuffer, PDWORD pdwPosition, PCHAR Value  )
{
	DWORD BufIdx;
	for ( BufIdx = 0 ; Value[BufIdx];	BufIdx++ ) {
		pszBuffer[(*pdwPosition)++]  = Value[BufIdx];
		/* check if we are overflowing the temp buffer. */
                if ((*pdwPosition) >= DBG_MAX_STRING_SIZE - 1) {
		     break;
		}
	}
}


VOID	tmDBGString ( PCHAR szString )
{

/*
	PTMDBG_OBJECT this = pDBG;
	DWORD	BitMask = 0x01;
	DWORD	IdxFunc;

	for ( IdxFunc = 0 ; IdxFunc <  TMSTD_DBG_MAXOUTFUNC ; 
		IdxFunc++, BitMask <<= 1 )
	{
		if ( ( this->pSharedData->OptionBits & BitMask ) )
		{
			if ( this->OutFunc[IdxFunc] )
			{
				this->OutFunc[IdxFunc](pDBG, szString);
			}
		}
	}
*/

}

STATUS	tmDBGBufferSize ( DWORD Size )
{
	PTMDBG_OBJECT this = pDBG; /* GLOBAL */
	PVOID	pPBuf;

	DWORD	dwPCSW;
	DISABLEALL(dwPCSW);

	/* try to allcoate the memory */
	if ( ( pPBuf = malloc ( Size + sizeof ( TMHD_DBG_PBUFFER ) +
		TMDBG_CACHE_ALIGNED_SIZE ) ) == NULL ) /* HARDCODED 64 byte alignment */
	{
		tmDBGTMMANPrintf(0, "tmman:tmDBGBufferSize:malloc:Persistent[%x]:FAIL\n", Size);
		ENABLEALL(dwPCSW);
		return TMDBG_ERR_OUTOFMEMORY;
	}

	/* destroy the magic so that TMMon doesn't get confused */
	memset ( this->pPersistData->szMagic, 0, TMHD_DBG_MAGICSIZE  );

	/* make sure that the cache contensts are dumped back to SDRAM */
	COPYBACK ( this->pPersistData->szMagic, 2 );

	/* assume there is an existing buffer and destroy it */
	free ( this->pPersistData->pPBufStart );


	this->pPersistData = 
		(PTMHD_DBG_PBUFFER)((((DWORD)pPBuf) & 0xffffffc0 ) + TMDBG_CACHE_BLOCK_SIZE);
	this->pPersistData->pPBufStart = pPBuf;
	this->pPersistData->PWrapped = FALSE;
	strcpy ( this->pPersistData->szMagic, TMHD_DBG_BUFMAGIC );

	this->pPersistData->szMagic[0] = 'T';
	this->pPersistData->szMagic[1] = 'M';
	this->pPersistData->szMagic[2] = '-';
	this->pPersistData->szMagic[3] = 'S';
	this->pPersistData->szMagic[4] = 'o';
	this->pPersistData->szMagic[5] = 'f';
	this->pPersistData->szMagic[6] = 't';

	this->pPersistData->PBufLen = Size;
	this->pPersistData->PBufPos = 0;
	this->pPersistData->pPBuffer = 
		((PBYTE)this->pPersistData) + sizeof ( TMHD_DBG_PBUFFER );

	COPYBACK (this->pPersistData->szMagic, 2 );

	ENABLEALL(dwPCSW);

	return TMOK;
}

DWORD	tmDBGOptions ( DWORD OptionBits )
{
	PTMDBG_OBJECT this = pDBG; /* GLOBAL */
	DWORD	TempOptionBits = this->pSharedData->OptionBits;
	this->pSharedData->OptionBits = OptionBits;
	return TempOptionBits;
}