autoadj.c

NT68521源代码

#include "Scaler.H"
#include "AutoAdj.H"
#include "MyDef.H"
#include "IIC.H"
#include "RAM.H"
#include "stdio.h"
#include "F63REG.H"
#include "MCU.H"
#include "UserAdj.H"
#include "ModeHandle.H"
#include "8051.H"
#include "sRGB.H"
#include "ROM_MAP.H"
#include "SAA7114.H"

void AutoTune(void)
{
xdata unsigned short HP_Temp,VP_Temp,addr;
//	HP_Temp = ReadIIC_HW(Scaler_Addr,0x01);
//	HP_Temp &= ~BIT_5;
//	WriteIIC_HW(Scaler_Addr,0x01,(unsigned char)HP_Temp);
	if(H_SYNC_Temp == 0xffff)
		goto Error1;
	HP_Temp = HP_Start;
	VP_Temp = VP_Start;
	NonFullScreen = 0;
	flag2 &= ~BIT_0;
	AutoPosition();
	if(H_SYNC_Temp == 0xffff)
		goto Error1;
	if((flag2 & BIT_0) != 0x00){
		if(NonFullScreen == 0){
			goto Error1;
		}
	}
	AutoClock();
	if(H_SYNC_Temp == 0xffff)
		goto Error1;
	if((flag2 & BIT_0) != 0x00){
		if(NonFullScreen == 0){
			goto Error;
		}
		else{
			flag2 &= ~BIT_0;
			AutoClockByPhase(1);
		}
	}
	else{
		AutoClockByPhase(0);
	}
	if(H_SYNC_Temp == 0xffff)
		goto Error1;
	AutoPhaseFineTune();
	if(H_SYNC_Temp == 0xffff)
		goto Error1;
	if((flag2 & BIT_0) != 0x00)
		goto Error;
	AutoPosition();
	if(H_SYNC_Temp == 0xffff)
		goto Error1;
	if(((flag2 & BIT_0) != 0x00)&&(NonFullScreen == 1)){	//fail
		if(ModePoint < UserModeSt){
			addr = 0x101 + (ModePoint * 8);
			VP_Temp = MCU_DataMap[addr];
			addr++;
			HP_Temp = MCU_DataMap[addr];
			HP_Temp <<= 8;
			addr++;
			HP_Temp += MCU_DataMap[addr];
		}
		HP_Start = HP_Temp;
		VP_Start = VP_Temp;
		SetHP();
		SetVP();
		flag2 &= ~BIT_0;
	}
Error:
	if((flag2 & BIT_0) != 0x00){	//fail
		if(H_SYNC_Temp != 0xffff){
			ForceToBackground(0);	//Set fource to background
			LoadModeDependentSettings();
			SetADC_PLL();
			SetADC_Phase();
			SetScaler();
			WriteIIC_HW(Scaler_Addr,0x95,0x00);
			SetDisplayNormal();
		}
	}
	else{		//ok
		SaveModeDependentSettings();
		SetMinMax();
	}
Error1:
	RepeatTimer = KeyHoldTime;
	Repeat = 0xff;

//	HP_Temp = ReadIIC_HW(Scaler_Addr,0x01);
//	HP_Temp |= BIT_5;
//	WriteIIC_HW(Scaler_Addr,0x01,(unsigned char)HP_Temp);
}

void AutoPosition(void)
{
unsigned short temph,tempv;
	WriteIIC_HW(Scaler_Addr,0x2E,HP_Min);  // AutoPosition Pixel mask -> H
	WriteIIC_HW(Scaler_Addr,0x3C,0x00);  // AutoPosition Pixel mask -> V
	WriteIIC_HW(Scaler_Addr,0x2F,0x30);  // Red Noise Margin
	WriteIIC_HW(Scaler_Addr,0x30,0x30);  // Green Noise Margin
	WriteIIC_HW(Scaler_Addr,0x31,0x30);  // Blue Noise Margin

	CheckModeChange();
	if((flag2 & BIT_0) != 0)
		return;
	
	WriteIIC_HW(Scaler_Addr,0x1F,0x00);
	if(SyncMode == 3){	//DVI
 	 	WriteIIC_HW(Scaler_Addr,0x1E,0x19);
	}
	else{
  	 	WriteIIC_HW(Scaler_Addr,0x1E,0x09);
	}
   	Timer3 = 10;
   	while(!(ReadIIC_HW(Scaler_Addr,0x1F) & BIT_0) && Timer3 != 0){
		CheckModeChange();
		if((flag2 & BIT_0) != 0)
			return;
	}
   	if(Timer3 != 0){				// Auto-Position OK
		tempv = ReadWordIIC_HW(Scaler_Addr,0x32) & 0x07ff;
		temph = ReadWordIIC_HW(Scaler_Addr,0x36) & 0x07ff;
		if((tempv > 0xff) || (temph > (HTotal-H_Act))){
			flag2 |= BIT_0;			// abort
			NonFullScreen = 1;
		}
		else{
			HP_Start = temph;
			VP_Start = tempv;
			SetHP();
			SetVP();
		}
	}
	else{
		flag2 |= BIT_0;			// abort
	}
}

void AutoClock(void)
{
unsigned char H_Difference,i,Compare,k;
unsigned short PLL_Divider,V_Act;
unsigned short H_Ref;
	if((flag2 & BIT_0) != 0x00)
		return;
	V_Act = ReadWordIIC_HW(Scaler_Addr,0x34) & 0x07ff;
//	if(VTotal > (V_Act + 190)){
//		flag2 |= BIT_0;
//		NonFullScreen = 1;
//		return;
//	}
	if((flag3 & BIT_6) != 0){
		V_Act <<= 1;
	}
	PLL_Divider = ReadWordIIC_HW(Scaler_Addr,0x38) & 0x07ff;

	for(i=0; i<16; i++){		//check Vtotal
		if(V_Act > V_ActiveTab[i])
			H_Ref = V_Act - V_ActiveTab[i];
		else
			H_Ref = V_ActiveTab[i] - V_Act;
		if(H_Ref < 5){			//check Htotal
			H_Ref = H_ActiveTab[i];
			if((i == 1)&&(Read24C16(0xd3) != 0))
				H_Ref = 640;
			if(PLL_Divider > H_Ref){
				PLL_Divider = PLL_Divider - H_Ref;
				Compare = 0;
			}
			else{
				PLL_Divider =  H_Ref - PLL_Divider;
				Compare = 1;
			}
			if(PLL_Divider > (H_Ref >> 3)){			//check Htotal range
				if((i == 2) && (Compare == 0)){
					i = 13;
					H_Ref = 848;
				}
//				else{
//					flag2 |= BIT_0;
//					NonFullScreen = 1;
//					return;
//				}
			}
			PLL_Divider = 0x106 + (ModePoint * 8);
			if(i != Read24C16(PLL_Divider)){		//change resolution
				Write24C16(PLL_Divider,i);
				SetScaler();
			}
			break;
		}
	}
	if((i == 16)||(V_Act < 340)){
		flag2 |= BIT_0;
		NonFullScreen = 1;
		return;
	}
	k = i;
// Set refance H_Active
	WriteWordIIC_HW(Scaler_Addr,0x3A,H_Ref);
// read pll divider
	if(HTotal <= H_Ref){
		HTotal = H_Ref + HP_Start;
		SetADC_PLL();
		if((flag3 & BIT_1) != 0){
			flag2 |= BIT_0;
			return;
		}
	}
	for(i=0; i<0x20; i++){
		WriteIIC_HW(Scaler_Addr,0x1F,0x00);
		WriteIIC_HW(Scaler_Addr,0x1E,0x09);
	   	Timer3 = 10;
	   	while(!(ReadIIC_HW(Scaler_Addr,0x1F) & BIT_0) && Timer3 != 0){
			CheckModeChange();
			if((flag2 & BIT_0) != 0)
				return;
		}
		if(Timer3 == 0){
			flag2 |= BIT_0;
			return;
		}
		H_Act = ReadWordIIC_HW(Scaler_Addr,0x38) & 0x07ff;
		H_Difference = ReadIIC_HW(Scaler_Addr,0x1F);
		Compare = (H_Difference & 0x0C) >> 2;
		H_Difference = (H_Difference & 0xF0) >> 4;
		if(Compare==0x01){
			break; //H_Ref=H_Act
		}
		if(Compare==0x00){
//			if(H_Difference == 0x01)
//				break;
			HTotal = HTotal + H_Difference;
			if(HTotal > 2048){
				i = 0xff;
				break;
			}
		}
		if(Compare == 0x02){
//			if(H_Difference == 0x01)
//				break;
			HTotal = HTotal - H_Difference;
			if(HTotal < H_Ref){
				i = 0xff;
				break;
			}
		}
		SetADC_PLL();
		if((flag3 & BIT_1) != 0){
			flag2 |= BIT_0;
			return;
		}
	}
	if(i == 0xff){
		NonFullScreen = 1;
		flag2 |= BIT_0;
	}
	else{
#if 1
		HTotal = (HTotal + 2) & 0xfffc;
#else
		HTotal = (HTotal + 1) & 0xfffe;
#endif
		SetADC_PLL();
		if((flag3 & BIT_1) != 0){
			flag2 |= BIT_0;
			return;
		}
	}
}

void AutoPhaseFineTune(void)
{
unsigned char   qq,yy,zz,uu,i;
unsigned long   Phase_0, Phase_1, Phase_2, Phase_Pre3, Phase_Now3, Phase_Delta;
unsigned char   value;
	if((flag2 & BIT_0) != 0x00)
		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)
//	ADC_Phase =( ADC_Phase - 6) & 0x3F; // 3 is search range....
	qq = ADC_Phase;
//	SetADC_Phase();
	WriteIIC_HW(Scaler_Addr,0x20,0x01); // 0x01 --> 0x09
   	Timer3 = 100;
//	for(yy=1; yy<16; yy++){
	for(yy=1; yy<Repeat; yy++){
		while((ReadIIC_HW(Scaler_Addr,0x20) & BIT_0) && Timer3 != 0){
			CheckModeChange();
			if((flag2 & BIT_0) != 0)
				return;
		}
		ADC_Phase = (qq + yy) & 0x3f;
		SetADC_Phase();
		WriteIIC_HW(Scaler_Addr,0x20,0x01); // 0x01 --> 0x09
	   	Timer3 = 100;
        Phase_Now3  = 0x00000000;
        for (zz=0x24; zz>0x20; zz--){
       		value = ReadIIC_HW(Scaler_Addr,zz);
            Phase_Now3  = Phase_Now3 << 8;
            Phase_Now3  = Phase_Now3 + value;
        }
		i = (ADC_Phase - 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
		}     
	}
	ADC_Phase = (uu - 2) & 0x3f;
	SetADC_Phase();
}

void SetADC_Offset(unsigned char OffSet)
{
unsigned char i,j,k,m,n,value;
unsigned long PhaseResult,Temp;
//	WriteIIC_HW(Scaler_Addr,0x02,0x36);
//	WriteIIC_HW(Scaler_Addr,0x04,0x35);
//	WriteIIC_HW(Scaler_Addr,0x06,0x37);
	WriteIIC_HW(Scaler_Addr,0x26,0x00);
	WriteIIC_HW(Scaler_Addr,0x27,0x00);
	for(m=0; m<3; m++){
		for(k=OffSet; k<128; k=k+8){
			i = 0x0f + m;
			WriteIIC_HW(Scaler_Addr,i,k);
			WaitSetup(5);
			Timer3 = 10;
			i = 0x19 + m * 0x10;
			WriteIIC_HW(Scaler_Addr,0x20,i);
		   	while((ReadIIC_HW(Scaler_Addr,0x20) & BIT_0) && Timer3 != 0){
				CheckModeChange();
				if((flag2 & BIT_0) != 0)
					return;
			}
			if(Timer3 == 0){
				flag2 |= BIT_0;
				return;
			}
			j = 0;
			Temp = 0;
			for(i=0; i<8; i++){
				WriteIIC_HW(Scaler_Addr,0x24,i);
				value = ReadIIC_HW(Scaler_Addr,0x23);
				PhaseResult = value;
				PhaseResult <<= 8;
				value = ReadIIC_HW(Scaler_Addr,0x22);
				PhaseResult += value;
				PhaseResult <<= 8;
				value = ReadIIC_HW(Scaler_Addr,0x21);
				PhaseResult += value;
				if(PhaseResult > Temp){
					Temp = PhaseResult;
					j = i;
				}
			}
			if(Temp > 0x300){
				i = 0x0f + m;
				j = k+j;
				WriteIIC_HW(Scaler_Addr,i,j);
				break;
			}
		}
		if(k == 128){
			flag2 |= BIT_0;
			return;
		}
		for(n=0; n<8; n++){
			i = 0x0f + m;
			WriteIIC_HW(Scaler_Addr,i,k+n);
			WaitSetup(5);
			Timer3 = 10;
			i = 0x19 + m * 0x10;
			WriteIIC_HW(Scaler_Addr,0x20,i);
		   	while((ReadIIC_HW(Scaler_Addr,0x20) & BIT_0) && Timer3 != 0){
				CheckModeChange();
				if((flag2 & BIT_0) != 0)
					return;
			}
			if(Timer3 == 0){
				flag2 |= BIT_0;
				return;
			}
			j = 0;
			Temp = 0;
			for(i=0; i<8; i++){
				WriteIIC_HW(Scaler_Addr,0x24,i);
				value = ReadIIC_HW(Scaler_Addr,0x23);
				PhaseResult = value;
				PhaseResult <<= 8;
				value = ReadIIC_HW(Scaler_Addr,0x22);
				PhaseResult += value;
				PhaseResult <<= 8;
				value = ReadIIC_HW(Scaler_Addr,0x21);
				PhaseResult += value;
				if(PhaseResult > Temp){
					Temp = PhaseResult;
					j = i;
				}
			}
			if(j == 0){
				break;
			}
		}
		i = 0x0f + m;
		j = k+n;
		WriteIIC_HW(Scaler_Addr,i,j);
	}
	Write24C16(0xfa,ReadIIC_HW(Scaler_Addr,0x0f));
	Write24C16(0xfb,ReadIIC_HW(Scaler_Addr,0x10));
	Write24C16(0xfc,ReadIIC_HW(Scaler_Addr,0x11));
}

void SetADC_Gain(unsigned char OffSet)
{
unsigned char i,j,k,m,n,value;
unsigned long PhaseResult,Temp;
	WriteIIC_HW(Scaler_Addr,0x26,0x00);
	WriteIIC_HW(Scaler_Addr,0x27,0xf8);
	for(m=0; m<3; m++){
		for(k=OffSet; k>7; k=k-8){
			i = 0x02 + m * 2;
			WriteIIC_HW(Scaler_Addr,i,k);
			WaitSetup(5);
			Timer3 = 10;
			i = 0x19 + m * 0x10;
			WriteIIC_HW(Scaler_Addr,0x20,i);
		   	while((ReadIIC_HW(Scaler_Addr,0x20) & BIT_0) && Timer3 != 0){
				CheckModeChange();
				if((flag2 & BIT_0) != 0)
					return;
			}
			if(Timer3 == 0){
				flag2 |= BIT_0;
				return;
			}
			j = 0;
			Temp = 0;
			for(i=0; i<8; i++){
				WriteIIC_HW(Scaler_Addr,0x24,i);
				value = ReadIIC_HW(Scaler_Addr,0x23);
				PhaseResult = value;
				PhaseResult <<= 8;
				value = ReadIIC_HW(Scaler_Addr,0x22);
				PhaseResult += value;