tw88.c

此程序为twell8806驱动程序

//=============================================================================
//	                        Panel Setting
//=============================================================================
#if defined( SUPPORT_PC ) || defined( SUPPORT_DTV )

BYTE IsBypassmode(void)
{
	BYTE dat;

	dat = ReadDecoder(TW88_XYSCALEHI) & 0x10;	// Zoom by-pass
	return dat;
}
/*
BYTE IsInteraced(void)
{
	if( ReadDecoder(0x42) & 0x80 ) return 1;
	return 0;
}
*/
WORD GetHstart(void)
{
	WORD hstart;

	WriteDecoder(0x5b, 0x80);
	hstart = (WORD)ReadDecoder(0x58) << 8;
	hstart += ReadDecoder(0x57);

	return hstart;
}

WORD GetVstart(void)
{
	WORD vstart;

	WriteDecoder(0x5b, 0xa0);
	vstart = (WORD)ReadDecoder(0x58) << 8;
	vstart += ReadDecoder(0x57);

	return vstart;
}



WORD GetVend(void)
{
	WORD vend;

	WriteDecoder(0x5b, 0xb0);
	vend = (WORD)ReadDecoder(0x5a) << 8;
	vend += ReadDecoder(0x59);

	return vend;
}

/**** Not used
void MaskOnSYNCInt()
{
	BYTE val;

	val = 0xfc;
	WriteDecoder(0xb2, val);	//IRQ mask
	dPrintf("\r\nDisableSYNCint:->%02x", val);
}
****/

void MaskOffSYNCInt()
{
	BYTE val;

	val = 0xfc;
	WriteDecoder(0xd2, val);	//IRQ mas
	WriteDecoder(0xd2, 0xcc);

}


void MakeStartInt(void)
{
	MaskOffSYNCInt();

	WriteDecoder(0xd3, 0x02);					// IRQ mask 2
	WriteDecoder(0x4e, ReadDecoder(0x4e) | 0x08);	// IRQ pin, active low
	WriteDecoder(0x5b, 0x01);					// Start measure
	WriteDecoder(0x5b, 0x00);					// clear measure
	WriteDecoder(0x5c, 0x07);					// change error tolerance and enable V/HSYNC change/loss detection

	SetEnDet();								// Set enable-detection
}

void Clear_bypass()
{
	BYTE dat;

	dat = ReadDecoder(TW88_XYSCALEHI);	//TW88_XYSCALEHI=0X63
	WriteDecoder(TW88_XYSCALEHI, dat & 0xef);	// xxx0 xxxx
}


WORD GetHactiveStart(void)
{
	WORD buf;
	BYTE val;

	val = ReadDecoder(0x49);	
	buf = (WORD)(val & 0x07) << 8;
	buf += ReadDecoder(0x47);

	return buf;
}

/**** Not used */
WORD GetHactiveEnd(void)
{
	WORD buf;
	BYTE val;

	val = ReadDecoder(0x49);
	buf = (WORD)(val & 0xf0) << 4;
	buf += ReadDecoder(0x48);

	return buf;
}
/****/

//#ifdef DEBUG_TW88
WORD GetVactiveStart(void)
{
	WORD buf;
	BYTE val;

	val = ReadDecoder(0x4d);			// high 2 bits
	buf = (WORD)(val & 0x03) << 8;
	buf |= ReadDecoder(0x4a);			// Vactive Odd field Line start position

	return buf;
}
//#endif

/**** Not used 
WORD GetVactiveLen(void)
{
	WORD buf;
	BYTE val;

	val = ReadDecoder(0x4d);			// high 3 bits
	buf = (val & 0x70) << 4;
	buf |= ReadDecoder(0x4c);

	return buf;
}
***/
//-------------------------------------------------------------------
//                  Set Active Region Functions
//-------------------------------------------------------------------
void SetHactiveStart(WORD hstart)
{
	BYTE val;

	// TW8804 write LSByte first
	val = ReadDecoder(0x49);
	val = val & 0xf8;
	val = val | (hstart>>8);

	WriteDecoder(0x49, val);
	WriteDecoder(0x47, (BYTE)hstart);
}

void SetHactiveEnd(WORD hend)
{
	BYTE	val, buf;

	// TW8804 write LSByte first
	buf = (BYTE)(hend>>8)<<4;
	val = ReadDecoder(0x49);
	val = val & 0x0f;
	val = val | buf;
	
	WriteDecoder(0x49, val);
	WriteDecoder(0x48, (BYTE)hend);
}

void SetVactiveStart(WORD vstart)
{
	BYTE val, v_h, v_l;

	// TW8804 write LSByte first
	v_l = (BYTE)vstart;
	v_h = (BYTE)(vstart>>8);

	val = ReadDecoder(0x4d);	// high 2 bits
	val = (val & 0xf0);
	val = val | (v_h<<2);
	val = val | v_h;
	WriteDecoder(0x4d, val);

	WriteDecoder(0x4a, v_l);	// Vactive Odd field Line start position
	WriteDecoder(0x4b, v_l);	// Vactive Even field Line start position
}

void SetVactiveLen(WORD van)
{
//	WORD vstop;
	BYTE val, buf;

	van += 10;							// HHY add 1, because of bottom line garbage

	// TW8804 write LSByte first
	buf = (BYTE)(van>>8) << 4;
	val = ReadDecoder(0x4d);
	val = val & 0x8f;
	val = val | buf;
	WriteDecoder(0x4d, val);
	WriteDecoder(0x4c, (BYTE)van);		
					
}

#include "osdmenu.h"
extern CODE struct RegisterInfo UserRange;
extern CODE struct RegisterInfo PanelContrastRange;
extern CODE struct RegisterInfo PanelBrightnessRange;
extern CODE struct RegisterInfo PanelSharpnessRange;
extern CODE struct RegisterInfo PanelHueRange;
extern CODE struct RegisterInfo PanelSaturationRange;

void GetInitPanelAttribute1(void)
{
	BYTE rdata;
	int	regv;

	rdata = GetPanelContrastEE();
	Mapping1( rdata, &UserRange ,&regv, &PanelContrastRange);
	SetRGBContrast( GetPCColorTempModeEE(), (BYTE)regv );

	rdata = GetPanelBrightnessEE() ;
	Mapping1( rdata, &UserRange , &regv,   &PanelBrightnessRange );
	SetPanelBrightnessReg(RED,   (BYTE)regv);
	SetPanelBrightnessReg(GREEN, (BYTE)regv);
	SetPanelBrightnessReg(BLUE,  (BYTE)regv);
}

#endif // SUPPORT_PC

void DefaultPanelAttributeForVideo(void)
{
	BYTE rdata;

	SelectPanelAttrRegGroup(GROUP_RGB);
	rdata = GetAttributesFromNTSCSettings(0x70);
	SetPanelHueReg( (ReadDecoder(0x70) & 0xc0) | (rdata & 0x3f) );

	rdata = GetAttributesFromNTSCSettings(0x71);
	SetPanelContrastReg(RED,  rdata);

	rdata = GetAttributesFromNTSCSettings(0x72);
	SetPanelContrastReg(GREEN,rdata);

	rdata = GetAttributesFromNTSCSettings(0x73);
	SetPanelContrastReg(BLUE, rdata);

	rdata = GetAttributesFromNTSCSettings(0x74);
	SetPanelBrightnessReg(RED,  rdata);

	rdata = GetAttributesFromNTSCSettings(0x75);
	SetPanelBrightnessReg(GREEN,rdata);

	rdata = GetAttributesFromNTSCSettings(0x76);
	SetPanelBrightnessReg(BLUE, rdata);

	//rdata = GetAttributesFromNTSCSettings(0x77);
	//SetPanelSharpnessReg( rdata );

	SelectPanelAttrRegGroup(GROUP_YCbCr);
	SetPanelSaturationReg(U_SAT, 0x80);
	SetPanelSaturationReg(V_SAT, 0x80);
	//SelectPanelAttrRegGroup(GROUP_RGB);

}

#ifdef SUPPORT_PC

//=============================================================================
//                          Invert Polarity Functions
//=============================================================================
void InvertHSYNCPolarity(void)
{
	BYTE val;

	val = ReadDecoder(0x40);
	if( val & 0x04 ) 
	{
		val &= 0xfb;
	}
	else 
	{
		val |= 0x04;

	}
	WriteDecoder(0x40, val);
}

void InvertVSYNCPolarity(void)
{
	BYTE val;

	val = ReadDecoder(0x40);
	if( val & 0x02 ) 
	{
		val &= 0xfd;
	}
	else {
		val |= 0x02;

	}
	WriteDecoder(0x40, val);
}
//=============================================================================
//
//=============================================================================
WORD GetVSYNCPulse(void)
{
	WORD buf;

	WriteDecoder(0x5b, 0x70);			// VSYNC 

	buf = (WORD)ReadDecoder(0x58) << 8;
	buf |= ReadDecoder(0x57);

	return buf;
}

/* Not used right now!!
WORD GetRelativePosition(void)
{
	WORD buf;

	WriteDecoder(0x5b, 0x70);			// VSYNC 

	buf = (WORD)ReadDecoder(0x5a) << 8;
	buf |= ReadDecoder(0x59);

	return buf;
}
//*/

WORD GetHSYNCPulse(void)
{
	WORD buf;

	WriteDecoder(0x5b, 0x60);			// HSYNC 
	buf = (WORD)ReadDecoder(0x58) << 8;		// from MSB
	buf |= ReadDecoder(0x57);

	return buf;
}

#endif	// SUPPORT_PC

//=============================================================================
//								Internal PLL
//=============================================================================
#if defined SUPPORT_PC || defined SUPPORT_DTV

BYTE GetPOST(void)
{
	BYTE post;

	post = ReadDecoder(TW88_PLL4);
	return post & 0x03;
}

DWORD GetFBDN(void)
{
	DWORD Freq;

	Freq = ReadDecoder(TW88_PLL0);
	Freq &= 0x1f;
	Freq <<= 8;
	Freq |= ReadDecoder(TW88_PLL1);
	Freq <<= 8;
	Freq |= ReadDecoder(TW88_PLL2);

	#ifdef DEBUG_TW88
	dPrintf("\r\n(GetFBDN) :%ld", Freq);
	#endif
	return Freq;
}

DWORD GetPPF(void)
{
	DWORD ppf;
	BYTE  i;

// 27000000 * FREQ / 2^21  / 2^POST
	ppf = 412L * ( GetFBDN() );

	i= GetPOST();
	for(; i>0; i-- )
		ppf /= 2;

	#ifdef DEBUG_TW88
	dPrintf("\r\n(GetPPF) :%ld", ppf);
	#endif
	return ppf;
}
#endif 

#if defined SUPPORT_PC || defined SUPPORT_DTV

void ChangeInternPLL(DWORD _PPF)
{
	BYTE	ppf, CURR, VCO, POST, i;
	DWORD	FREQ;

	#ifdef DEBUG_TW88
	dPrintf("\r\n++ ChangeInternPLL ++_PPF:%08lx(%ld) ", _PPF, _PPF);
	#endif

	ppf = _PPF/1000000;

	//----- Frequency Range --------------------
	if     ( ppf < 27 )  { VCO=0; CURR=0; POST=0; }		// step = 0.5MHz
	else if( ppf < 54 )  { VCO=1; CURR=0; POST=0; }		// step = 1.0MHz
	else if( ppf < 108 ) { VCO=2; CURR=0; POST=0; }		// step = 1.0MHz
	else                 { VCO=3; CURR=0; POST=0; }		// step = 1.0MHz

	//----- Get FBDN
	FREQ = (_PPF/100000L)*2427L;

	i = POST;
	for(; i>0; i-- )
		FREQ *= 2;

	FREQ = FREQ / 10L;

	//----- Setting Registers
	WriteDecoder( 0xf9, (CURR<<5) | (FREQ>>16));
	WriteDecoder( 0xfa, (BYTE)(FREQ>>8));
	WriteDecoder( 0xfb, (BYTE)FREQ );

	WriteDecoder( 0xfd, (VCO<<2) | POST );
}
//=============================================================================
//	                   Set Measurement Window Functions   
//=============================================================================
void SetMeasureWindowH(WORD start, WORD stop)
{
	BYTE val;

	#ifdef DEBUG_PC
	dPrintf("\r\nSetWindow H. Range(%04x, %04x)", start, stop);
	#endif

	// TW8804 write LSByte first
	val = (BYTE)((stop >> 4) & 0xf0);
	val |= (BYTE)((start>>8) & 0x07);
	WriteDecoder(0x53, val);				// H-start and H-stop

	WriteDecoder(0x51, (BYTE)start);		// H-start
	WriteDecoder(0x52, (BYTE)stop);			// H-stop
}

void SetMeasureWindowV(WORD start, WORD stop)
{
	BYTE val;

	#ifdef DEBUG_PC
	dPrintf("\r\nSetWindow V. Range(%04x, %04x)", start, stop);
	#endif

	// TW8804 write LSByte first
	val  = (BYTE)((stop>>4) & 0x70);
	val |= (BYTE)((start>>8) & 0x07);
	WriteDecoder(0x56, val);				// V-start & V-stop

	WriteDecoder(0x54, (BYTE)start);		// V-start
	WriteDecoder(0x55, (BYTE)stop);			// V-stop
}
#endif // SUPPORT_PC || defined SUPPORT_DTV

//=============================================================================
//	                              ZoomControl
//=============================================================================
#if defined(SUPPORT_PC) || defined(SUPPORT_DTV)
void BypassZoom()
{
	#ifdef WXGA
	WriteDecoder(TW88_XUSCALELO, 0xcd);
	WriteDecoder(TW88_YUSCALELO, 0x80);
	WriteDecoder(TW88_XDSCALELO, 0x00);
	WriteDecoder(TW88_XYSCALEHI, 0x06);	
	#else
	//SetBypassmode=1;
	WriteDecoder(TW88_XUSCALELO, 0x00);
	WriteDecoder(TW88_XDSCALELO, 0x80);
	WriteDecoder(TW88_YUSCALELO, 0x00);
	WriteDecoder(TW88_XYSCALEHI, 0x15);	//Set bit 4 to 1
	#endif
}
#endif

#if defined(SUPPORT_PC) || defined(SUPPORT_DTV) //  || defined(WIDE_SCREEN)
void XscaleU(DWORD scale)
{
	BYTE val;

	WriteDecoder( TW88_XUSCALEFINE, (BYTE)scale);

	scale >>= 8;
	WriteDecoder( TW88_XUSCALELO, (BYTE)scale);

	scale >>= 8;
	val = ReadDecoder(TW88_XYSCALEHI);
	val &= 0xfe;
	val |= (BYTE)scale;
	WriteDecoder( TW88_XYSCALEHI, val );
}

void XscaleD(DWORD scale)
{
	BYTE val;

	WriteDecoder( TW88_XDSCALELO, (BYTE)scale);

	scale >>= 8;
	scale <<= 1;
	val = ReadDecoder(TW88_XYSCALEHI);
	val &= 0xfd;
	val |= (BYTE)scale;
	WriteDecoder( TW88_XYSCALEHI, val );
}

void XScale2(DWORD scale)
{
	if( scale==0x10000 ) {		// No Scale
		XscaleU(0x10000);
		XscaleD(0x80);
	}
	else if( scale<0x10000 ) {	// Up Scale
		XscaleU(scale);
		XscaleD(0x80);
	}
	else {						// Down Scale
		XscaleU(0x10000);
		XscaleD(scale/2/256);
	}
}

void YScale2(DWORD scale)
{
	BYTE val;

	WriteDecoder( TW88_YUSCALEFINE, (BYTE)(scale));

	scale >>= 8;
	WriteDecoder( TW88_YUSCALELO, (BYTE)(scale));

	scale >>= 8;
	scale <<= 2;
	val = ReadDecoder(TW88_XYSCALEHI) & 0xf3;
	val |= (BYTE)scale;
	WriteDecoder( TW88_XYSCALEHI, val );
}
#endif // SUPPORT_PC || SUPPORT_DTV || WIDE_SCREEN

/**
#if defined(SUPPORT_PC) || defined(SUPPORT_DTV)
WORD GetYScale(void)
{
	WORD scale;
	BYTE val;

	scale = ReadDecoder(TW88_YUSCALELO);
	val = ReadDecoder(TW88_XYSCALEHI);
	val = (val >> 2) & 0x03;
	scale = scale + val*0x100;

	return scale;
}
#endif // SUPPORT_PC || SUPPORT_DTV
**/

//=============================================================================
//	                             Panel related..
//=============================================================================
/***
#if (defined SERIAL) || (defined WIDE_SCREEN)
void SetPVR(WORD pvr)
{
	BYTE buf;

	// TW8804 write LSByte first
	buf = ReadDecoder(0xbb) & 0x0f;
	buf = buf | ( (pvr>>4) & 0xf0 );
	WriteDecoder( 0xbb, buf );

	WriteDecoder( 0xba, (BYTE)pvr );
}

void SetPHR(WORD phr)
{
	BYTE buf;

	// TW8804 write LSByte first
	buf = ReadDecoder(0xb6) & 0x0f;
	buf = buf | ( (phr>>4) & 0xf0 );
	WriteDecoder( 0xb6, buf );

	WriteDecoder( 0xb5, (BYTE)phr );
}
#endif // SERIAL || WIDE_SCREEN
***/

#if defined( SUPPORT_PC ) || defined( SUPPORT_DTV ) || defined( DEBUG_SETPANEL)
//----- Panel V Resolution
WORD GetPVR(void)