autoadj.c

车载DVD的主控MCU的源程序

/*==========================================
==========================================*/
#include "include.h"
/*==========================================
==========================================*/
/*
void TunePositionOnly()
{
	Abort = 0;
	//WriteIIC563(0x001,FuncBuf[pRADC]);
	//WriteIIC563(0x004,FuncBuf[pGADC]);
	//WriteIIC563(0x007,FuncBuf[pBADC]);
	AutoPosition();
	if(Abort)
	{	//fail
		LoadModeDependentSettings();
		SetHP();
		SetVP();
	}
	SetContrast();
}
*/
/*==========================================
==========================================*/
void AutoTune(void)
{
//	Word addr;
//	Byte PixelRate;
	Abort = 0;
	NonFullScreen = 0;
	//WriteIIC563(0x001,FuncBuf[pRADC]);
	//WriteIIC563(0x004,FuncBuf[pGADC]);
	//WriteIIC563(0x007,FuncBuf[pBADC]);
//	if(ModePoint < UserModeSt)
//		Recall();
	AutoPosition();
	if(!Abort)
		AutoClock();
//	PixelRate = ((unsigned long)FuncBuf[pCLOCK] * H_SYNC)/10000;
//	if(PixelRate >= PanelMaxPClk/1000)
//		Abort = 1;
	if(NonFullScreen && !Abort){	//non fullscreen recall
		//addr = ep_Sync_Data + (ModePoint * 8);
		//FuncBuf[pCLOCK] = Read24C16(addr+4) << 8;
		//FuncBuf[pCLOCK] |= Read24C16(addr+5);
		LoadPresetModeSettings(2);
		SetADC_PLL();
	}
#if 0
	if(Abort){
		if(NonFullScreen == 0){
			//goto Error;
		}
		else{
			Abort = 0;
			AutoClockByPhase(1);
		}
	}
	else{
		AutoClockByPhase(0);
	}
#else
	if(!Abort)
		AutoClockByPhase(0);
#endif
	if(!Abort)
		AutoPhaseFineTune(32);
	if(!Abort)
		AutoPosition();

	if(Abort)		//fail
	{
		LoadModeDependentSettings();
		SetADC_PLL();
		SetADC_Phase();
//-------------------------------------------------------
		if(SyncMode != 3){
			SetHP();
			SetVP();
		}
		if(Interlance){
			WriteWordIIC563(0x032,Vresolution);		// Capture V_Active
		}else{
			WriteWordIIC563(0x032,Vresolution); 	// Capture V_Active
		}
		WriteWordIIC563(0x036,Hresolution); 	// Capture H_Active
	}else{		//ok
		CheckModeChange();	// add by evan for mode change during auto will fail
	}
	LoadADC_Gain();	
}
void AutoPosition(void)
{
	Word OldVp,NewVp,Vact,Hact;
#if PRINT_MESSAGE
		printf("AutoPosition\n");
#endif
	WriteIIC563(0x02A,0);  // AutoPosition Pixel mask -> H
	WriteIIC563(0x02B,24);  // AutoPosition Pixel mask -> H
	WriteIIC563(0x02C,0x00);  // AutoPosition Pixel mask -> H
	WriteIIC563(0x02D,0x00);  // AutoPosition Pixel mask -> H
	WriteIIC563(0x107,0x40);  // Red Noise Margin 05/05/05 joe modify
	WriteIIC563(0x106,0x00);
	if(SyncMode == 3)
 	 	WriteIIC563(0x106,0x11);
	else
  	 	WriteIIC563(0x106,0x01);
#if DVImode == HVmode
	if(SyncMode == 3)
		WaitSetup(5);
#endif
	OldVp = FuncBuf[pVPOSITION];
   	LocalTimer = 100;
   	while((ReadIIC563(0x106) & BIT_0) && LocalTimer != 0){
		CheckModeChange();
		if(Abort)
			return;
	}
   	if(LocalTimer != 0){				// Auto-Position OK
		Hact = ReadWordIIC563(0x110) & 0x0fff;
    		//Hact = ReadIIC563(0x111) & 0x3f;
		//Hact <<= 8;
    		//Hact |= ReadIIC563(0x110);
		//if(Hact < 300)
//		if(Hact < Hresolution - 100){
//		if(Hact < Hresolution - 100 && Hresolution>720){	//if <720 may in dos mode AGN spec needs tune position
		if(Hact < Hresolution - 100 && Hresolution>720&&ReadWordIIC563(0x10c)!=576){	//joe modify 2005/4/29
			Abort = 1;
			return;
		}		
		if(abs(Hact - Hresolution) > 100 && Hresolution>720 && Vresolution > 480)	// add by evan date 051018
		{
			Abort = 1;
			return;
		}		
		FuncBuf[pVPOSITION] = ReadWordIIC563(0x108) & 0x07ff;
    		//FuncBuf[pVPOSITION] = ReadIIC563(0x109) & 0x07;
		//FuncBuf[pVPOSITION] <<= 8;
    		//FuncBuf[pVPOSITION] |= ReadIIC563(0x108);
		GetFuncRange(pVPOSITION);
		if(FuncBuf[pVPOSITION] > FuncMax)//over VPosition Max
		{
			FuncBuf[pVPOSITION] = FuncMax;
			#if PRINT_MESSAGE
				printf("VPositon over Max");
			#endif
		}
		FuncBuf[pHPOSITION] = ReadWordIIC563(0x10e) & 0x07ff;
    		//FuncBuf[pHPOSITION] = ReadIIC563(0x10F) & 0x07;
		//FuncBuf[pHPOSITION] <<= 8;
    		//FuncBuf[pHPOSITION] |= ReadIIC563(0x10E);
		GetFuncRange(pHPOSITION);
		if(FuncBuf[pHPOSITION] > FuncMax)//over VPosition Max
		{
			FuncBuf[pHPOSITION] = FuncMax;
			#if PRINT_MESSAGE
				printf("HPositon over Max");
			#endif
		}
		if(FuncBuf[pHPOSITION] < FuncMin)	// add by evan date 051018
		{
			Abort = 1;
			return;
		}
			

		Vact = ReadWordIIC563(0x10c) & 0x07ff;


			//Vact = ReadIIC563(0x10d) & 0x07;
		//Vact <<= 8;
    		//Vact |= ReadIIC563(0x10c);
		NewVp = FuncBuf[pVPOSITION];
		#if PRINT_MESSAGE
			printf("VP_Start = %d\n",FuncBuf[pVPOSITION]);
			printf("HP_Start = %d\n",FuncBuf[pHPOSITION]);
		#endif
			SetHP();
			if(OldVp > NewVp){
				for(;OldVp>=NewVp;OldVp--){
					//FuncBuf[pVPOSITION] = OldVp;
					//SetVP();
// 050604,Eason,Start	< for auto adjust don't stop issue>					
					if (OldVp<1){
						Abort = 1;			// abort
						#if PRINT_MESSAGE
							printf("AutoPosition fail\n");
						#endif
						break;
					}else{						
						FuncBuf[pVPOSITION] = OldVp;
						SetVP();
					}
// 050604,Eason,End					
				}
			}
			else if(OldVp < NewVp){
				for(;OldVp<=NewVp;OldVp++){
					FuncBuf[pVPOSITION] = OldVp;
					SetVP();
				}
			}else{
				FuncBuf[pVPOSITION] = OldVp;
				SetVP();
			}
	}else{
		Abort = 1;			// abort
		#if PRINT_MESSAGE
			printf("AutoPosition fail\n");
		#endif
	}
   	// wait for next V pulse coming to latch data
	WaitVblank();
}
/*==========================================
==========================================*/
void AutoClock()
{
	//preset mode total
	bit FirstDo;
	Byte H_Difference,i,Compare;
	Word H_Ref,H_Act,TempClock;
	TempClock = FuncBuf[pCLOCK];
	if(VTotal > (Vresolution + 190))	//not full screen
	{
		NonFullScreen = 1;
		return;
	}
	H_Ref = Hresolution;
	if(H_Ref >= FuncBuf[pCLOCK])
	{
		Abort = 1;
		FuncBuf[pCLOCK] = H_Ref + FuncBuf[pHPOSITION];
		SetADC_PLL();
//		return;
	}
	WriteWordIIC563(0x117, H_Ref);
	FirstDo = 0;
	for(i=0;i<20;i++)
	{
		WriteIIC563(0x106,0x01);
	   	LocalTimer = 10;
	   	while((ReadIIC563(0x106) & BIT_0) && LocalTimer != 0)
		{
			CheckModeChange();
			if(Abort)
				return;
		}
		H_Act = ReadWordIIC563(0x110) & 0x0fff;
		if(H_Act < (H_Ref - 124)){
			i = 0xff;
			break;
		}
		//------------------------
		H_Difference = ReadIIC563(0x119);
		Compare = (H_Difference & 0xC0) >> 6;
		H_Difference = (H_Difference & 0x3F) > AutoClock_Step ? AutoClock_Step : (H_Difference & 0x3f);
		if(Compare == 0){	//H_Act == H_Ref jacky20040326 for AutoPhasebyClock
			if(!FirstDo){
				FirstDo = 1;
				AutoPhaseByClock();
				if(Abort)
					return;
			}
			else
				break;				
		}
		if(Compare == 1)
		{
			FuncBuf[pCLOCK] += H_Difference;
			if(FuncBuf[pCLOCK] > 2048)
			{
				i = 0xff;
				break;
			}
		}
		if(Compare == 2 || Compare == 3)
		{
			FuncBuf[pCLOCK] -= H_Difference;
			if(FuncBuf[pCLOCK] < H_Ref)
			{
				i = 0xff;
				break;
			}
		}
		SetADC_PLL();
	}
	//printf("Clock divider 0 = %d\n",FuncBuf[pCLOCK]);
	if(i == 0xff)
	{
		Abort = 1;
		NonFullScreen = 1;
		return;
	}
	else
	{
		if(abs(FuncBuf[pCLOCK] - TempClock) > (TempClock / 11)){
			FuncBuf[pCLOCK] = TempClock;//joe reactive  5/12
			Abort = 1;}
		else
			FuncBuf[pCLOCK] = (FuncBuf[pCLOCK] + 2) & 0xfffc;
		FuncMax = ClockBase + 50;
		FuncMin = ClockBase - 50;
		if(FuncBuf[pCLOCK] > FuncMax)//over VPosition Max
		{
			FuncBuf[pCLOCK] = FuncMax;
		}
		
		SetADC_PLL();
	}
}
/*==========================================
==========================================*/
void AutoClockByPhase(bit h)
{
	bit R_L,U_D;
	Byte k,temp;
	Word GoodClk;
	xdata unsigned long MaxMin,Value;
	if(h == 1)
		LoadPresetModeSettings(2);

	GoodClk = FuncBuf[pCLOCK];
	SetADC_PLL();
	WaitSetup(4);
	if(Abort)
		return;
	MaxMin = CheckPhaseData();
	temp = TempPhase;
	if(Abort)
		return;
	U_D = 0;
	R_L = 0;
	for(k=0; k<16; k++)
	{
		if(R_L)
		{
			FuncBuf[pCLOCK] += 2;
			SetADC_PLL();
			//printf("Clock divider 1 = %d\n",FuncBuf[pCLOCK]);
			WaitSetup(4);
			if(Abort)
				return;
			//Sleep(25);
			Value = CheckPhaseData();
			//printf("Clock Value %d = %x %x\n",(unsigned short)k,(unsigned short)(Value >> 16),(unsigned short)Value);
			if(Abort)
				return;
			if(MaxMin < Value)
			{
				GoodClk = FuncBuf[pCLOCK];
				MaxMin = Value;
				temp = TempPhase;
				U_D = 1;
			}
			else
			{
				if(U_D == 0)
				{
					R_L = 0;
					FuncBuf[pCLOCK] -= 2;
					U_D = 1;
				}
				else
					break;
			}
		}
		else{
			FuncBuf[pCLOCK] -= 2;
			SetADC_PLL();
			WaitSetup(4);
			if(Abort)
				return;
			Value = CheckPhaseData();
			if(Abort)
				return;
			if(MaxMin < Value)
			{
				GoodClk = FuncBuf[pCLOCK];
				MaxMin = Value;
				temp = TempPhase;
				U_D = 1;
			}
			else
			{
				if(U_D == 0)
				{
					R_L = 1;
					FuncBuf[pCLOCK] += 2;
					U_D = 1;
				}
				else
					break;
			}
		}
	}
	FuncBuf[pCLOCK] = GoodClk;
	SetADC_PLL();
	FuncBuf[pPHASE] = (temp + 24) & 0x3f;
	SetADC_Phase();
}
/*==========================================
==========================================*/
unsigned long CheckPhaseData()
{
	Byte ch;
	Word zz;
	xdata unsigned long Value,MinValueTemp,MaxValueTemp;
	MaxValueTemp = 0;
	MinValueTemp = 0xffffffff;
	FuncBuf[pPHASE] = 0;
	SetADC_Phase();
	WriteIIC563(0x106,0x02); 
   	LocalTimer = 10;
	for(FuncBuf[pPHASE]=4; FuncBuf[pPHASE]<0x42; FuncBuf[pPHASE] += 4)
	{
		while((ReadIIC563(0x106) & BIT_1) && LocalTimer != 0)
		{
			CheckModeChange();
			if(Abort)
				return 0;
		}
		SetADC_Phase();
		WriteIIC563(0x106,0x02);
	   	LocalTimer = 10;
       	Value = 0x00000000;
        	for(zz=0x116; zz>0x112; zz--)
		{
       		ch = ReadIIC563(zz);
            		Value  = Value << 8;
            		Value  = Value + ch;
        	}
		if(Value < MinValueTemp)
		{
			MinValueTemp = Value;
			TempPhase = (FuncBuf[pPHASE] - 4) & 0x3f;
		}
		if(Value > MaxValueTemp)
			MaxValueTemp = Value;
	}
	Value = MaxValueTemp - MinValueTemp;
	return Value;
}
/*==========================================
==========================================*/
void AutoPhaseFineTune(Byte Val)
{
	unsigned short   zz;
	unsigned char   qq,uu,yy,i;
	unsigned long   Phase_0, Phase_1, Phase_2, Phase_Pre3, Phase_Now3, Phase_Delta;
	unsigned char   value;
	if(Abort)
		return;
//-------------------------at color xx , calculate phase-------------------------
    	Phase_1 = 0x00000000;   // (i-1)
    	Phase_2 = 0x00000000;   // (i-2)
    	Phase_Pre3 = 0x00000000;   // (pre sum)->(delta)->(now sum)
   	Phase_Delta = 0xffffffff;   // (min delta)
	qq = FuncBuf[pPHASE];
	WriteIIC563(0x106,0x02); // 0x01 --> 0x09
   	LocalTimer = 10;
	for(yy=1; yy<Val; yy++)
	{
	 	while((ReadIIC563(0x106) & BIT_1) && LocalTimer != 0)
		{
			CheckModeChange();
			if(Abort)
				return;
		}
		FuncBuf[pPHASE] = (qq + yy) & 0x3f;
		SetADC_Phase();
		WriteIIC563(0x106,0x02); // 0x01 --> 0x09
	   	LocalTimer = 100;
        	Phase_Now3  = 0x00000000;
        	for (zz=0x116; zz>0x112; zz--)
		{
       		value = ReadIIC563(zz);
            		Phase_Now3  = Phase_Now3 << 8;
            		Phase_Now3  = Phase_Now3 + value;
        	}
		i = (FuncBuf[pPHASE] - 1) & 0x3f;
        	Phase_2 = Phase_1;  // Shift	
        	Phase_1 = Phase_0;
        	Phase_0 = Phase_Now3;
		Phase_Now3 = (Phase_0>>1) + (Phase_1>>1) + (Phase_2>>2); // Phase_Now3
		if(yy < 4)
			Phase_Pre3  = Phase_Now3;   // Phase_Pre3 = Phase_Now3
		else
		{
			if(Phase_Now3 > Phase_Pre3)
				Phase_Pre3  = Phase_Now3 - Phase_Pre3;
			else
				Phase_Pre3  = Phase_Pre3 - Phase_Now3;  // Phase_Pre3=delta
			if(Phase_Pre3 < Phase_Delta)
			{
				uu = i;           
				Phase_Delta = Phase_Pre3;
			}
			Phase_Pre3  = Phase_Now3;   // Phase_Pre3 = Phase_Now3
		}     
	}
	FuncBuf[pPHASE] = (uu - 3) & 0x3f;
	SetADC_Phase();
}
/*==========================================
==========================================*/
void AutoPhaseByClock()
{
	//preset mode total
	Byte PhaseTemp;
	Word H_Act,MinHActiveTemp;
	MinHActiveTemp = 0xffff;
	FuncBuf[pPHASE] = 0;
	SetADC_Phase();
	
	for(FuncBuf[pPHASE]=4; FuncBuf[pPHASE]<0x42; FuncBuf[pPHASE] += 4)
	{
		WriteIIC563(0x106,0x01);
	   	LocalTimer = 10;
	   	while((ReadIIC563(0x106) & BIT_0) && LocalTimer != 0)
		{
			CheckModeChange();
			if(Abort)
				return;
		}
		SetADC_Phase();
		H_Act = ReadWordIIC563(0x110) & 0x0fff;
		if(H_Act < MinHActiveTemp)
		{
			MinHActiveTemp = H_Act;
			PhaseTemp = (FuncBuf[pPHASE] - 4) & 0x3f;
		}
	}
	FuncBuf[pPHASE] = PhaseTemp;
	SetADC_Phase();
}
/*==========================================
==========================================*/
void LoadPresetModeSettings(Byte type)
{
	switch(type)
	{
		case 0:
			FuncBuf[pPHASE] = EEP_ModeMap[T_Preset_ROM_Phase];//EEP_SyncMap[addr+7];	
			FuncBuf[pCLOCK] =EEP_ModeMap[T_Preset_ROM_HTotal];// EEP_SyncMap[addr+4];
			FuncBuf[pCLOCK] <<= 8;
			FuncBuf[pCLOCK] |= EEP_ModeMap[T_Preset_ROM_HTotal+1];//EEP_SyncMap[addr+5];
		case 1:
			FuncBuf[pVPOSITION] = EEP_ModeMap[T_Preset_ROM_VBP];//EEP_SyncMap[addr+1];
			FuncBuf[pHPOSITION] = EEP_ModeMap[T_Preset_ROM_HBP];//EEP_SyncMap[addr+2];
			FuncBuf[pHPOSITION] <<= 8;
			FuncBuf[pHPOSITION] |= EEP_ModeMap[T_Preset_ROM_HBP+1];//EEP_SyncMap[addr+3];
			break;
		case 2:
			FuncBuf[pCLOCK] =EEP_ModeMap[T_Preset_ROM_HTotal];// EEP_SyncMap[addr+4];
			FuncBuf[pCLOCK] <<= 8;
			FuncBuf[pCLOCK] |= EEP_ModeMap[T_Preset_ROM_HTotal+1];//EEP_SyncMap[addr+5];
			break;
		}
}
void WaitVblank()
{
/*
	LocalTimer = 3;	//30ms
	while(!V_SyncPresent)	//Vsync Lo
		{
		if(LocalTimer == 0)
			return;
		}
	LocalTimer = 5;	//50ms
	while(V_SyncPresent)	//Vsync Hi
		{
		if(LocalTimer == 0)
			return;
		}
*/
}