monitor.c

车载DVD osdIC TW8816原厂代码

/* Monitor.c */

#include "config.h"

#ifdef SERIAL

#include "typedefs.h"
#include "main.h"
#include "i2c.h"
#include "dispinfo.h"
#include "reg.h"
#include "printf.h"
//#include "dispinfo.h"
//#include "video.h"
//#include "eeprom.h"
//#include "measure.h"
#include "tw88.h"
#include "etc_eep.h"
#include "osdbasic.h"
#include "monitor.h"
#include "cpu.h"
#include "Measure.h"

#include "spi.h"

	IDATA BYTE MonAddress = 0x8a;		// initialize value should be placed to IDATA area
	BYTE MonIndex;
	BYTE MonRdata, MonWdata;

xdata BYTE monstr[30];		// buffer for input string
BYTE *argv[7];
BYTE argc=0;
bit	echo=1;

static bit indirect=0;

extern		  bit	AutoDetect;
extern IDATA  BYTE InputSelection;
extern	      BYTE	DebugLevel;
extern  CODE  struct struct_IdName struct_InputSelection[];

void Loader(BYTE);

//=============================================================================
//
//=============================================================================
void Prompt(void)
{
#ifdef INTERNAL_MCU
#ifdef BANKING
	if ( MonAddress == TW88I2CAddress )
		Printf("\r\n[B%1x]MCU_I2C[%02x]>", (WORD)BANKREG, (WORD)MonAddress);
	else
#else
	if ( MonAddress == TW88I2CAddress )
		Printf("\r\nMCU_I2C[%02x]>", (WORD)MonAddress);
	else
#endif
#endif
		Printf("\r\nI2C[%02x]>", (WORD)MonAddress);
}

void Mon_tx(BYTE ch)
{
	RS_tx(ch);
}



//=============================================================================
//		Convert ASCII to Binery                                             
//=============================================================================
DWORD a2i(BYTE *str)
{
	DWORD num=0;
	BYTE i;

	for(i=0; ; i++, str++) {
		if( *str=='\0' || *str==' ' ) break;
		num = num*10 + *str - '0';
	}
	return num;
}

BYTE Asc1Bin(BYTE asc)
{
	if(asc>='0' && asc <='9') return (asc - '0');
	if(asc>='a' && asc <='f') return (asc - 'a' + 0x0a);
	if(asc>='A' && asc <='F') return (asc - 'A' + 0x0a);
}

BYTE Asc2Bin(PDATA_P BYTE *s)
{
	BYTE bin;

	bin = 0;
	while(*s != '\0' && *s !=' ') {
		bin = bin<<4;
		bin = bin + Asc1Bin(*s);
		s++;
	}
	return (bin);
}

//=============================================================================
BYTE toupper(BYTE ch)
{
	if( ch>='a' && ch<='z' )
		return (ch - 'a' + 'A');
}

int stricmp(BYTE *ptr1, BYTE *ptr2)
{
	int		i;
	int		ret;
	
	for(i=0; *ptr1; i++) {
		ret = toupper(*ptr1++) - toupper(*ptr2++);
		if( ret ) return ret;
	}
	return 0;
}

//=============================================================================
//
//=============================================================================

void SetMonAddress(BYTE addr)
{
	MonAddress = addr;
}

void MonReadI2C(void)
{
	if( argc>=2 ) MonIndex = Asc2Bin( argv[1] );
	else	{
		Printf("   --> Missing parameter !!!");
		return;
	}

	if ( MonAddress == TW88I2CAddress )
		MonRdata = ReadTW88(MonIndex);
	else
		MonRdata = ReadI2C(MonAddress, MonIndex);

	if( echo )
		Printf("\r\nRead %2xh:%2xh", (WORD)MonIndex, (WORD)MonRdata);	
	
	MonWdata = MonRdata;
}


void MonWriteI2C(void)
{
	if( argc<3 ) {
		Printf("   --> Missing parameter !!!");
		return;
	}
	
	MonIndex = Asc2Bin( argv[1] );
	MonWdata = Asc2Bin( argv[2] );
	
	if( echo ) {
		Printf("\r\nWrite %2xh:%2xh ", (WORD)MonIndex, (WORD)MonWdata);
		if ( MonAddress == TW88I2CAddress ) {
			WriteTW88(MonIndex, MonWdata);
			MonRdata = ReadTW88(MonIndex);
		}
		else {
			WriteI2C(MonAddress, MonIndex, MonWdata);
			MonRdata = ReadI2C(MonAddress, MonIndex);
		}
   		Printf("==> Read %2xh:%2xh", (WORD)MonIndex, (WORD)MonRdata);
	}
	else {
		if ( MonAddress == TW88I2CAddress ) {
			WriteTW88(MonIndex, MonWdata);
		}
		else {
			WriteI2C(MonAddress, MonIndex, MonWdata);
		}
	}
}


void MonIncDecI2C(BYTE inc)
{

	switch(inc){
	case 0:  MonWdata--;	break;
	case 1:  MonWdata++;	break;
	case 10: MonWdata-=0x10;	break;
	case 11: MonWdata+=0x10;	break;
	}


	if ( MonAddress == TW88I2CAddress ) {
		WriteTW88(MonIndex, MonWdata);
		MonRdata = ReadTW88(MonIndex);
	}
	else {
		WriteI2C(MonAddress, MonIndex, MonWdata);
		MonRdata = ReadI2C(MonAddress, MonIndex);
	}

	if( echo ) {
		Printf("Write %2xh:%2xh ", (WORD)MonIndex, (WORD)MonWdata);
		Printf("==> Read %2xh:%2xh", (WORD)MonIndex, (WORD)MonRdata);
	}

	Prompt();

}

void MonDumpI2C(void)
{
	BYTE ToMonIndex;
	int  cnt=8;

	if( argc>=2 ) MonIndex = Asc2Bin(argv[1]);
	if( argc>=3 ) ToMonIndex = Asc2Bin(argv[2]);
	else ToMonIndex = MonIndex+cnt;
	if ( ToMonIndex < MonIndex ) ToMonIndex = 0xFF;
	cnt = ToMonIndex - MonIndex + 1;

	if( echo ) {
		if ( MonAddress == TW88I2CAddress ) {
			for ( ; cnt > 0; cnt-- ) {
				MonRdata = ReadTW88(MonIndex);
				Printf("\r\n==> Read %2xh:%2xh", (WORD)MonIndex, (WORD)MonRdata);
				MonIndex++;
			}
		}
		else {
			for ( ; cnt > 0; cnt-- ) {
				MonRdata = ReadI2C(MonAddress, MonIndex);
				Printf("\r\n==> Read %2xh:%2xh", (WORD)MonIndex, (WORD)MonRdata);
				MonIndex++;
			}
		}
	}
	else {
		if ( MonAddress == TW88I2CAddress ) {
			for ( ; cnt > 0; cnt-- ) {
				MonRdata = ReadTW88(MonIndex);
				MonIndex++;
			}
		}
		else {
			for ( ; cnt > 0; cnt-- ) {
				MonRdata = ReadI2C(MonAddress, MonIndex);
				MonIndex++;
			}
		}
	}
}

//-----------------------------------------------------------------------------

void MonNewReadI2C(void)
{
	BYTE Slave;

	if( argc>=3 ) MonIndex = Asc2Bin( argv[2] );
	else	{
		Printf("   --> Missing parameter !!!");
		return;
	}
	Slave = Asc2Bin(argv[1]);

	if ( Slave == TW88I2CAddress )
		MonRdata = ReadTW88(MonIndex);
	else
		MonRdata = ReadI2C(Slave, MonIndex);

	if( echo )
		Printf("\r\n<R>%2x[%2x]=%2x", (WORD)Slave, (WORD)MonIndex, (WORD)MonRdata);
	
	MonWdata = MonRdata;
}

void MonNewWriteI2C(void)
{
	BYTE Slave;

	if( argc<4 ) {
		Printf("   --> Missing parameter !!!");
		return;
	}
	
	MonIndex = Asc2Bin( argv[2] );
	MonWdata = Asc2Bin( argv[3] );
	Slave = Asc2Bin(argv[1]);
	
	if ( Slave == TW88I2CAddress ) {
		WriteTW88(MonIndex, MonWdata);
		MonRdata = ReadTW88(MonIndex);
	}
	else {
		WriteI2C(Slave, MonIndex, MonWdata);
		MonRdata = ReadI2C(Slave, MonIndex);
   	}

	if( echo )
		Printf("\r\n<R>%2x[%2x]=%2x", (WORD)Slave, (WORD)MonIndex, (WORD)MonRdata);

}

void MonNewDumpI2C(void)
{
	BYTE 	ToMonIndex, Slave;
	WORD	i;
	
	if( argc>=2 ) MonIndex = Asc2Bin(argv[2]);
	if( argc>=3 ) ToMonIndex = Asc2Bin(argv[3]);
	Slave = Asc2Bin(argv[1]);

	if( echo ) {
		if ( Slave == TW88I2CAddress ) {
			for(i=MonIndex; i<=ToMonIndex; i++) {
				MonRdata = ReadTW88(i);
        		Printf("\r\n<R>%2x[%2x]=%2x", (WORD)Slave, (WORD)i, (WORD)MonRdata);
			}
		}
		else {
			for(i=MonIndex; i<=ToMonIndex; i++) {
				MonRdata = ReadI2C(Slave, i);
        		Printf("\r\n<R>%2x[%2x]=%2x", (WORD)Slave, (WORD)i, (WORD)MonRdata);
			}
		}
	}
	else {
		if ( Slave == TW88I2CAddress ) {
			for(i=MonIndex; i<=ToMonIndex; i++) {
				MonRdata = ReadTW88(i);
			}
		}
		else {
			for(i=MonIndex; i<=ToMonIndex; i++) {
				MonRdata = ReadI2C(Slave, i);
			}
		}
	}
}


void MonWriteBit(void)
{
	BYTE mask, i, FromBit, ToBit,  MonMask, val;
	BYTE Slave;
	// b 88 index startbit|endbit data

	if( argc<5 ) {
		Printf("   --> Missing parameter !!!");
		return;
	}
	Slave = Asc2Bin(argv[1]);

	MonIndex = Asc2Bin( argv[2] );
	FromBit  = (Asc2Bin( argv[3] ) >> 4) & 0x0f;
	ToBit  = Asc2Bin( argv[3] )  & 0x0f;
	MonMask  = Asc2Bin( argv[4] );

	if( FromBit<ToBit || FromBit>7 || ToBit>7) {
		Printf("\r\n   --> Wrong range of bit operation !!!");
		return;
	}
	
	mask = 0xff; 
	val=0x7f;
	for(i=7; i>FromBit; i--) {
		mask &= val;
		val = val>>1;
	}

	val=0xfe;
	for(i=0; i<ToBit; i++) {
		mask &= val;
		val = val<<1;
	}

	if ( Slave == TW88I2CAddress ) {
		MonRdata = ReadTW88(MonIndex);
		MonWdata = (MonRdata & (~mask)) | (MonMask & mask);
				
		WriteTW88(MonIndex, MonWdata);
		MonRdata = ReadTW88(MonIndex);
	}
	else {
		MonRdata = ReadI2C(Slave, MonIndex);
		MonWdata = (MonRdata & (~mask)) | (MonMask & mask);
				
		WriteI2C(Slave, MonIndex, MonWdata);
		MonRdata = ReadI2C(Slave, MonIndex);
	}

	if( echo )
		Printf("\r\n<R>%2x[%2x]=%2x", (WORD)Slave, (WORD)MonIndex, (WORD)MonRdata);

}

#if defined( SUPPORT_PC ) || defined( SUPPORT_DTV )
void PclkAccess(void)
{
	DWORD pclk;

	if( argc > 2 ) {
		Printf("   --> Too many parameter !!!");
		return;
	}

	if( argc==2 ) {
		pclk = (DWORD)a2i(argv[1]) * 1000000;
		Printf("\r\n --> Set Pclk:  %ld Hz ", pclk);
//		Printf("\r\n Not Suuport ");
		ChangeInternPLL(pclk);
	}
	
	if( argc==1)   GetPPF();
	
}
#endif

void MonTxDump(void)
{
	WORD	count;

	if ( argc < 2 ) {
		Puts("\r\nInsufficient parameters...");
		return;
	}
	count = (WORD)a2i(argv[1]);
	do {
		RS_tx((count&0x1F)+0x20);
		count--;
	} while ( count != 0 );
}

//=============================================================================
//			Help Message
//=============================================================================
void MonHelp(void)
{
	Printf("\r\n=======================================================");
	Printf("\r\n>>>     Welcome to Techwell Monitor  Rev 1.00     <<<");
	Printf("\r\n=======================================================");
	Printf("\r\n   R ii             ; Read data");
	Printf("\r\n   W ii dd          ; Write data");
	Printf("\r\n   D [ii] [cc]      ; Dump");
	Printf("\r\n   C aa             ; Change I2C address");
	Printf("\r\n   M ?              ; Current Input");
	Printf("\r\n   M dd             ; Change Input");
	Printf("\r\n   AutoDetect [0,1] ; PC Automode On/OFF");
	Printf("\r\n   PCAuto		    ; RUN PC Auto Adjust");
	Printf("\r\n   Debug [0..255]   ; Debuging display level");
	Printf("\r\n   Echo On/Off      ; Terminal Echoing On/Off");
	Printf("\r\n   Delta            ; Init DeltaRGB Panel");
	Printf("\r\n   Delta w ii dh dl; SPI Write to DeltaRGB Panel");
	Printf("\r\n");
	Printf("\r\n=======================================================");
	Printf("\r\n");
}

//=============================================================================
//
//=============================================================================
BYTE MonGetCommand(void)
{
	static BYTE comment=0;
	static BYTE incnt=0, last_argc=0;
	BYTE i, ch;
	BYTE ret=0;

	if( !RS_ready() ) return 0;
	ch = RS_rx();

	//----- if comment, echo back and ignore -----
	if( comment ) {
		if( ch=='\r' || ch==0x1b ) comment = 0;
		else { 
			Mon_tx(ch);
			return 0;
		}
	}
	else if( ch==';' ) {
		comment = 1;
		Mon_tx(ch);
		return 0;
	}

	//=====================================
	switch( ch ) {

	case 0x1b:
		argc = 0;
		incnt = 0;
		comment = 0;
		Prompt();
		return 0;

	//--- end of string
	case '\r':

		if( incnt==0 ) {
			Prompt();
			break;
		}

		monstr[incnt++] = '\0';
		argc=0;

		for(i=0; i<incnt; i++) if( monstr[i]!=' ' ) break;

		if( !monstr[i] ) {
			incnt = 0;
			comment = 0;
			Prompt();
			return 0;
		}
		argv[0] = &monstr[i];
		for(; i<incnt; i++) {
			if( monstr[i]==' ' || monstr[i]=='\0' ) {
				monstr[i]='\0';
     			 //Printf("(%s) ",  argv[argc]);
				i++;
				while( monstr[i]==' ' ) i++;
				argc++;
				if( monstr[i] ){
     			 argv[argc] = &monstr[i];
				}
			}
		}

		ret = 1;
		last_argc = argc;
		incnt = 0;
		
		break;

	//--- repeat command
	case '/':
		argc = last_argc;
		ret = 1;
		break;

	//--- back space
	case 0x08:
		if( incnt ) {
			incnt--;
			Mon_tx(ch);
			Mon_tx(' ');
			Mon_tx(ch);
		}
		break;

	//--- decreamental write
	case ',':
		if( incnt ) {
			Mon_tx(ch);
			monstr[incnt++] = ch;