autofunc.c

MST720-DEMO程序

/******************************************************************************
 Copyright (c) 2005 MStar Semiconductor, Inc.
 All rights reserved.

 [Module Name]: AutoFunc.c
 [Date]:	12-Jan-2005
 [Comment]:
   Auto adjust functions for VGA input.
 [Reversion History]:
*******************************************************************************/
#define _AUTOFUNC_C_

/********************
* INCLUDE FILES     *
*********************/
#include "Project.h"
#include "Ms7X_reg.h"
#include "Mcu.h"
#include "TypeDef.h"
#include "Ms_RWreg.h"
#include "Debug.h"
#include "Misc.h"
#include "AutoFunc.h"
#include "Ms_Func.h"
#include "Global.h"
#include <math.h>

#if USE_VGA

void mstAutoColor(void)
{

	BYTE ucDbfc;

#if (RS232DBG&MSG_WHITEBLANCE)
sysWriteString(tChangeLine);
sysWriteString("-- AutoColor Start --");
#endif

	ucDbfc=mstReadByte(BK0_01_DBFC);

	mstWriteByte(GEN_00_REGBK,REGBANKSCALER);
	mstWriteByte(BK0_C8_ATGCTRL,0x11);
	mstWriteByte(BK0_C9_ATGST,0x00);
	mstWriteByte(BK0_01_DBFC,0x00);

	mstAutoOffset();
	mstAutoGain();

	mstWriteByte(GEN_00_REGBK,REGBANKSCALER);
	mstWriteByte(BK0_01_DBFC,ucDbfc);

#if (RS232DBG&MSG_WHITEBLANCE)
sysWriteString(tChangeLine);
sysWriteString("-- AutoColor End --");
#endif


}

void mstAutoOffset(void)
{

	BYTE ucRedOffset,ucGreenOffset,ucBlueOffset;
	BYTE ucMaxRedOffset,ucMaxGreenOffset,ucMaxBlueOffset;
	BYTE ucMinRedOffset,ucMinGreenOffset,ucMinBlueOffset;
	BYTE ucRedValue,ucGreenValue,ucBlueValue;
	BYTE ucRetry;
	BYTE ucVsyncTime;

	ucVsyncTime=mstGetVSyncTime();
	ucMaxRedOffset=ucMaxGreenOffset=ucMaxBlueOffset=0xff;
	ucMinRedOffset=ucMinGreenOffset=ucMinBlueOffset=0x00;

#if (RS232DBG&MSG_WHITEBLANCE)
sysWriteString(tChangeLine);
sysWriteString("-- Adjust offset --");
sysWriteString(tChangeLine);
sysWriteString("ADC_MAX_VALUE=0x");sysWriteHex(ADC_MAX_VALUE,0);
sysWriteString(", ADC_MIN_VALUE=0x");sysWriteHex(ADC_MIN_VALUE,0);
sysWriteString(tChangeLine);
sysWriteString("ucVsyncTime=");sysWriteDec(ucVsyncTime);
#endif

	ucRetry=8;

	while (ucRetry--)
	{
		
		ucRedOffset=((WORD)ucMaxRedOffset+ucMinRedOffset)/2;
		ucGreenOffset=((WORD)ucMaxGreenOffset+ucMinGreenOffset)/2;
		ucBlueOffset=((WORD)ucMaxBlueOffset+ucMinBlueOffset)/2;
	
		mstSetAdcRedOffset(ucRedOffset);
		mstSetAdcGreenOffset(ucGreenOffset);
		mstSetAdcBlueOffset(ucBlueOffset);

		miscDelay1ms(ucVsyncTime);
		mstWaitAutoStatusReady(BK0_C8_ATGCTRL,ATGR_B);

#if 0
		mstWriteByte(BK0_CA_ATFCHSEL,MIN_R);
		ucRedValue=mstReadByte(BK0_CD_ATGVALUE);
		mstWriteByte(BK0_CA_ATFCHSEL,MIN_G);
		ucGreenValue=mstReadByte(BK0_CD_ATGVALUE);
		mstWriteByte(BK0_CA_ATFCHSEL,MIN_B);
		ucBlueValue=mstReadByte(BK0_CD_ATGVALUE);
#endif

		mstWriteByte(BK0_CA_ATFCHSEL,MIN_R);
		miscDelay1ms(20); 	//20050908 mask	
		ucRedValue=mstReadByte(BK0_CD_ATGVALUE);
		if (ucRedValue<ADC_MIN_VALUE)
			ucMaxRedOffset=ucRedOffset;
		else
			ucMinRedOffset=ucRedOffset;

		mstWriteByte(BK0_CA_ATFCHSEL,MIN_G);
		miscDelay1ms(20); 	//20050908 mask	
		ucGreenValue=mstReadByte(BK0_CD_ATGVALUE);
		if (ucGreenValue<ADC_MIN_VALUE)
			ucMaxGreenOffset=ucGreenOffset;
		else
			ucMinGreenOffset=ucGreenOffset;

		mstWriteByte(BK0_CA_ATFCHSEL,MIN_B);
		miscDelay1ms(20); 	//20050908 mask	
		ucBlueValue=mstReadByte(BK0_CD_ATGVALUE);
		if (ucBlueValue<ADC_MIN_VALUE)
			ucMaxBlueOffset=ucBlueOffset;
		else
			ucMinBlueOffset=ucBlueOffset;
	miscDelay1ms(100); 	//20050908 mask	
#if (RS232DBG&MSG_WHITEBLANCE)
sysWriteString(tChangeLine);
sysWriteString("ROfst=0x");sysWriteHex(ucRedOffset,0);
sysWriteString(",GOfst=0x");sysWriteHex(ucGreenOffset,0);
sysWriteString(",BOfst=0x");sysWriteHex(ucBlueOffset,0);
sysWriteString(",RVal=0x");sysWriteHex(ucRedValue,0);
sysWriteString(",GVae=0x");sysWriteHex(ucGreenValue,0);
sysWriteString(",BVal=0x");sysWriteHex(ucBlueValue,0);
#endif

	}


	Display.ucVgaRedOffset=ucRedOffset;
	Display.ucVgaGreenOffset=ucGreenOffset;
	Display.ucVgaBlueOffset=ucBlueOffset;

	miscDelay1ms(300); 	//20050908 mask	
#if (RS232DBG&MSG_WHITEBLANCE)
sysWriteString(tChangeLine);
sysWriteString("-- Adjust offset End --");
#endif


}

void mstAutoGain(void)
{

	BYTE ucRedGain,ucGreenGain,ucBlueGain;
	BYTE ucMaxRedGain,ucMaxGreenGain,ucMaxBlueGain;
	BYTE ucMinRedGain,ucMinGreenGain,ucMinBlueGain;
	BYTE ucRedValue,ucGreenValue,ucBlueValue;
	BYTE ucRetry;
	BYTE ucVsyncTime;

	ucVsyncTime=mstGetVSyncTime();
	ucMaxRedGain=ucMaxGreenGain=ucMaxBlueGain=0xff;
	ucMinRedGain=ucMinGreenGain=ucMinBlueGain=0x00;

#if (RS232DBG&MSG_WHITEBLANCE)
sysWriteString(tChangeLine);
sysWriteString("-- Adjust gain --");
sysWriteString(tChangeLine);
sysWriteString("ucVsyncTime=");sysWriteDec(ucVsyncTime);
#endif


	ucRetry=8;

	while (ucRetry--)
	{
		
		ucRedGain=((WORD)ucMaxRedGain+ucMinRedGain)/2;
		ucGreenGain=((WORD)ucMaxGreenGain+ucMinGreenGain)/2;
		ucBlueGain=((WORD)ucMaxBlueGain+ucMinBlueGain)/2;
			
		mstSetAdcRedGain(ucRedGain);
		mstSetAdcGreenGain(ucGreenGain);
		mstSetAdcBlueGain(ucBlueGain);

		miscDelay1ms(ucVsyncTime);
		mstWaitAutoStatusReady(BK0_C8_ATGCTRL,ATGR_B);

#if 0
		mstWriteByte(BK0_CA_ATFCHSEL,MAX_R);
		ucRedValue=mstReadByte(BK0_CD_ATGVALUE);
		
		mstWriteByte(BK0_CA_ATFCHSEL,MAX_G);
		ucGreenValue=mstReadByte(BK0_CD_ATGVALUE);
		
		mstWriteByte(BK0_CA_ATFCHSEL,MAX_B);
		ucBlueValue=mstReadByte(BK0_CD_ATGVALUE);
#endif

		mstWriteByte(BK0_CA_ATFCHSEL,MAX_R);
		miscDelay1ms(20); 	//20050908 mask	
		ucRedValue=mstReadByte(BK0_CD_ATGVALUE);
		
		if (ucRedValue>ADC_MAX_VALUE)
			ucMinRedGain=ucRedGain;
		else
			ucMaxRedGain=ucRedGain;

		mstWriteByte(BK0_CA_ATFCHSEL,MAX_G);
		miscDelay1ms(20); 	//20050908 mask	
		ucGreenValue=mstReadByte(BK0_CD_ATGVALUE);
		
		if (ucGreenValue>ADC_MAX_VALUE)
			ucMinGreenGain=ucGreenGain;
		else
			ucMaxGreenGain=ucGreenGain;

		mstWriteByte(BK0_CA_ATFCHSEL,MAX_B);
		miscDelay1ms(20); 	//20050908 mask	
		ucBlueValue=mstReadByte(BK0_CD_ATGVALUE);
		
		if (ucBlueValue>ADC_MAX_VALUE)
			ucMinBlueGain=ucBlueGain;
		else
			ucMaxBlueGain=ucBlueGain;
	miscDelay1ms(300); 	//20050908 mask	
#if (RS232DBG&MSG_WHITEBLANCE)
sysWriteString(tChangeLine);
sysWriteString("RGain=0x");sysWriteHex(ucRedGain,0);
sysWriteString(",GGain=0x");sysWriteHex(ucGreenGain,0);
sysWriteString(",BGain=0x");sysWriteHex(ucBlueGain,0);
sysWriteString(",RVal=0x");sysWriteHex(ucRedValue,0);
sysWriteString(",GVal=0x");sysWriteHex(ucGreenValue,0);
sysWriteString(",BVal=0x");sysWriteHex(ucBlueValue,0);
#endif

	}


	Display.ucVgaRedGain=ucRedGain;
	Display.ucVgaGreenGain=ucGreenGain;
	Display.ucVgaBlueGain=ucBlueGain;

#if (RS232DBG&MSG_WHITEBLANCE)
	mstWriteByte(BK0_CA_ATFCHSEL,MAX_R);
	ucRedValue=mstReadByte(BK0_CD_ATGVALUE);

	mstWriteByte(BK0_CA_ATFCHSEL,MAX_G);
	ucGreenValue=mstReadByte(BK0_CD_ATGVALUE);

	mstWriteByte(BK0_CA_ATFCHSEL,MAX_B);
	ucBlueValue=mstReadByte(BK0_CD_ATGVALUE);

	mstWriteByte(BK0_CA_ATFCHSEL,MIN_R);
	ucRedValue=mstReadByte(BK0_CD_ATGVALUE);

	mstWriteByte(BK0_CA_ATFCHSEL,MIN_G);
	ucGreenValue=mstReadByte(BK0_CD_ATGVALUE);

	mstWriteByte(BK0_CA_ATFCHSEL,MIN_B);
	ucBlueValue=mstReadByte(BK0_CD_ATGVALUE);
		miscDelay1ms(300); 	//20050908 mask		
sysWriteString(tChangeLine);
sysWriteString("rOffsetValue=0x");sysWriteHex(ucRedValue,0);
sysWriteString(", gOffsetValue=0x");sysWriteHex(ucGreenValue,0);
sysWriteString(", bOffsetValue=0x");sysWriteHex(ucBlueValue,0);
sysWriteString(tChangeLine);
sysWriteString("-- Adjust gain End --");
#endif

}

void mstAutoTune(void)
{
#if (RS232DBG&MSG_AUTOTUNE)
sysWriteString(tChangeLine);
sysWriteString("-- AutoTune Start --");
#endif

	mstWriteByte(REGBANKSCALER,REGBANKSCALER);
	mstWriteByte(BK0_CB_ATOCTRL,0x01);
	mstWriteByte(BK0_DB_ATPCTRL,0x19);
	mstWriteByte(BK0_DA_ATPTTH,0x1C);
	mstWriteByte(BK0_CC_AOVDV,0xC0);

	mstAutoHtotal();
	mstAutoPhase();
	mstAutoPosition();


#if (RS232DBG&MSG_AUTOTUNE)
sysWriteString(tChangeLine);
sysWriteString("-- AutoTune End --");
#endif

}

void mstAutoPosition(void)
{
	WORD uwHStart,uwVStart;

#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOPOSITION
sysWriteString(tChangeLine);
sysWriteString(tChangeLine);
sysWriteString("-- autoCAutoPosition Start --");
#endif

	mstWaitAutoStatusReady(BK0_CB_ATOCTRL,ATOR_B);
	uwHStart=mstReadWord(BK0_D1_AOHST_H);
	
	mstWaitAutoStatusReady(BK0_CB_ATOCTRL,ATOR_B);
	uwVStart=mstReadWord(BK0_CF_AOVST_H);

	mstWriteWord(BK0_08_SPRHST_H,uwHStart-HOFFSET);	//BK0_07_SPRHST_L,BK0_08_SPRHST_H
	mstWriteWord(BK0_06_SPRVST_H,uwVStart-VOFFSET);	//BK0_05_SPRVST_L, BK0_06_SPRVST_H

#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOPOSITION
sysWriteString(tChangeLine);
sysWriteString("HStart=");sysWriteDec(uwHStart);
sysWriteString(", VStart=");sysWriteDec(uwVStart);
sysWriteString(", HOFFSET=");sysWriteDec(HOFFSET);
sysWriteString(", VOFFSET=");sysWriteDec(VOFFSET);
sysWriteString(tChangeLine);
sysWriteString("-- autoCAutoPosition End --");
#endif
	
}


void mstAutoPhase(void)
{
	DWORD ulValue,ulMaxValue;
	BYTE ucPhase,ucGoodPhase;
	BYTE ucVsyncTime;

#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOPHASE
sysWriteString(tChangeLine);
sysWriteString(tChangeLine);
sysWriteString("-- autoCAutoPhase Start --");
#endif

	ucVsyncTime=mstGetVSyncTime();

#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOPHASE
sysWriteString(tChangeLine);
sysWriteString("VsyncTime=");sysWriteDec(ucVsyncTime);
#endif

	ulMaxValue=0;

	for (ucPhase=0;ucPhase<0x40;ucPhase++)
	{
		mstSetPhase(ucPhase);
		miscDelay1ms(ucVsyncTime);
		mstWaitAutoStatusReady(BK0_DB_ATPCTRL,ATPR_B);

		ulValue=mstReadWord(BK0_DF_ATPV4);
		ulValue=(ulValue<<16)|mstReadWord(BK0_DD_ATPV2);
		
		if (ulValue>ulMaxValue)
		{
			ucGoodPhase=ucPhase;
			ulMaxValue=ulValue;
#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOPHASE
sysWriteString(tChangeLine);
sysWriteString("phase=");sysWriteDec(ucPhase);
sysWriteString(" ,Value=");sysWriteUartDec6(ulValue);
sysWriteString(" ,MaxValue=");sysWriteUartDec6(ulMaxValue);
#endif
		}
	}

	mstSetPhase(ucGoodPhase);

#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOPHASE
sysWriteString(tChangeLine);
sysWriteString("GoodPhase=");sysWriteDec(ucGoodPhase);
sysWriteString(" ,MaxValue=");sysWriteUartDec6(ulMaxValue);
sysWriteString(tChangeLine);
sysWriteString("-- autoCAutoPhase End --");
#endif

}

void mstAutoHtotal(void)
{

	// tune HTotal
	WORD uwWidth,uwWidthCom;
	WORD uwHStart,uwHEnd;
	WORD uwHTotal,uwEepHtotal;

#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOHTOTAL
sysWriteString(tChangeLine);
sysWriteString(tChangeLine);
sysWriteString("-- autoCAutoHtotal Start --");
#endif

	uwEepHtotal=mstGetHtotal();

	if(abs(uwEepHtotal-INPUT_HTOTAL)>HTOTAL_RANGE)
	{
#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOHTOTAL
sysWriteString(tChangeLine);
sysWriteString("Current HTotal Over Range");
sysWriteString(tChangeLine);
sysWriteString("CurrentHtotal=");sysWriteDec(uwEepHtotal);
sysWriteString(" ,InputHtotal=");sysWriteDec(INPUT_HTOTAL);
sysWriteString(" ,HtotalRange=");sysWriteDec(HTOTAL_RANGE);
sysWriteString(tChangeLine);
sysWriteString("-- autoCAutoHtotal End --");
#endif
		return;
	}

	mstWaitAutoStatusReady(BK0_CB_ATOCTRL,ATOR_B);
	uwHStart=mstReadWord(BK0_D1_AOHST_H);
	mstWaitAutoStatusReady(BK0_CB_ATOCTRL,ATOR_B);
	uwHEnd=mstReadWord(BK0_D5_AOHEND_H);
	uwWidth=uwHEnd-uwHStart+1;
	uwHTotal=(DWORD)uwEepHtotal*IUPUT_WIDTH/uwWidth;
#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOHTOTAL
sysWriteString(tChangeLine);
sysWriteString("HTotal=");sysWriteDec(uwHTotal);
#endif

	if(abs(uwHTotal-INPUT_HTOTAL)>HTOTAL_RANGE)
	{
#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOHTOTAL
sysWriteString(tChangeLine);
sysWriteString("Adjust HTotal Over Range");
sysWriteString(tChangeLine);
sysWriteString("Width=");sysWriteDec(uwWidth);
sysWriteString(" ,InputHtotal=");sysWriteDec(INPUT_HTOTAL);
sysWriteString(" ,HtotalRange=");sysWriteDec(HTOTAL_RANGE);
sysWriteString(tChangeLine);
sysWriteString("-- autoCAutoHtotal End --");
#endif
		return;
	}

	if(uwHTotal&0x01)
	{

		mstSetHtotal(uwHTotal+1);
		mstWaitAutoStatusReady(BK0_CB_ATOCTRL,ATOR_B);
		uwHStart=mstReadByte(BK0_D1_AOHST_H);
		mstWaitAutoStatusReady(BK0_CB_ATOCTRL,ATOR_B);
		uwHEnd=mstReadByte(BK0_D5_AOHEND_H);
		uwWidth=uwHEnd-uwHStart+1;

#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOHTOTAL
sysWriteString(tChangeLine);
sysWriteString("HTotal+1");
sysWriteString(tChangeLine);
sysWriteString("Width=");sysWriteDec(uwWidth);
sysWriteString("HStart=");sysWriteDec(uwHStart);
sysWriteString("HEnd=");sysWriteDec(uwHEnd);
#endif

		mstSetHtotal(uwHTotal-1);
		mstWaitAutoStatusReady(BK0_CB_ATOCTRL,ATOR_B);
		uwHStart=mstReadByte(BK0_D1_AOHST_H);
		mstWaitAutoStatusReady(BK0_CB_ATOCTRL,ATOR_B);
		uwHEnd=mstReadByte(BK0_D5_AOHEND_H);
		uwWidthCom=uwHEnd-uwHStart+1;

#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOHTOTAL
sysWriteString(tChangeLine);
sysWriteString("HTotal-1");
sysWriteString(tChangeLine);
sysWriteString("Width=");sysWriteDec(uwWidth);
sysWriteString("HStart=");sysWriteDec(uwHStart);
sysWriteString("HEnd=");sysWriteDec(uwHEnd);
#endif

		if(uwWidth==IUPUT_WIDTH)
			uwHTotal++;
		else if(uwWidthCom==IUPUT_WIDTH)
			uwHTotal--;
	}

	mstSetHtotal(uwHTotal);

#if (RS232DBG&MSG_AUTOTUNE)&&MSG_AUTOHTOTAL
sysWriteString(tChangeLine);
sysWriteString("HTotal=");sysWriteDec(uwHTotal);
sysWriteString(tChangeLine);
sysWriteString("-- autoCAutoHtotal End --");
#endif

}

BYTE mstGetVSyncTime(void)
{

	WORD uwHsync,uwVtime;
	WORD uwHsPriod;
	WORD uwVTotal;

	uwHsPriod=0x1fff&mstReadWord(BK0_EB_HSPRD_H);
	uwVTotal=0x7ff&mstReadWord(BK0_ED_VTOTAL_H);
	uwHsync=((DWORD)MCU_XTAL_CLK_KHZ*10+uwHsPriod/2)/uwHsPriod;
	uwVtime=((WORD)uwVTotal*10+uwHsync/2)/uwHsync;
	return (BYTE)uwVtime;
}

void mstWaitAutoStatusReady(BYTE regAddr, BYTE regFlag)
{
	BYTE ucWaits=200;
	while (ucWaits-- && !(mstReadByte(regAddr)&regFlag));
}

void mstSetPhase(BYTE phase)
{
	mstWriteByte(GEN_00_REGBK,REGBANKADC);
	mstWriteByte(BK1_10_CLKCTRL1,phase+8);
	mstWriteByte(BK1_11_CLKCTRL2,phase);
	mstWriteByte(GEN_00_REGBK,REGBANKSCALER);
}

void mstSetHtotal(WORD hTotal)
{
	hTotal -= 3;
	mstWriteByte(GEN_00_REGBK,REGBANKADC);
	mstWriteByte(BK1_02_PLLDIVM,hTotal>>4);
	mstWriteByte(BK1_03_PLLDIVL,hTotal<<4);
	mstWriteByte(GEN_00_REGBK,REGBANKSCALER);
}

WORD mstGetHtotal(void)
{
	WORD uwHTotal;
	mstWriteByte(GEN_00_REGBK,REGBANKADC);
	uwHTotal = mstReadByte(BK1_02_PLLDIVM)<<4;
	uwHTotal |= mstReadByte(BK1_03_PLLDIVL)>>4;
	mstWriteByte(GEN_00_REGBK,REGBANKSCALER);
	uwHTotal += 3;
	return uwHTotal;
}

#endif	//USE_VGA