auto.c

terawin的t103 LCD驱动程序

//---------------------------------------------------------------------------
// Terawins Inc. Company Confidential Strictly Private
//
// $Archive: Auto.c 702 $
// $Revision: 1.01 $
// $Author: JoannW $
// $Date: 2003/04/14 $
//
// --------------------------------------------------------------------------
// >>>>>>>>>>>>>>>>>>>>>>>>> COPYRIGHT NOTICE <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// --------------------------------------------------------------------------
// Copyright 2002 (c) Terawins Inc.
// This is an unpublished work.
// --------------------------------------------------------------------------
#include <reg51.h>
#include <math.h>
#include "common.h"

#include "Struct.h"
#include "system.h"

#include "TwoWire.h"

#include "TW803Reg.h"

#include "Display.h"
#include "Global.h"
#include "struct.h"
#ifdef NVRAM
#include "NVRam.h"
#endif
#include "ModeCtrl.h"
#include "ModeTbl.h"
#include "Auto.h"
static uCHAR  m_cGoodPhase;



BOOL srcOptimizing(uCHAR cTuneType)
{       
	AutoPositionAdj(cTuneType&0xF0);
	AutoPhaseAdj();
	/*
	if(cTuneType & CHANGMODE)
	{
		if(m_bDosMode)
			twdDelay(300); 
		else				
			twdDelay(200);
	}

	if(INT0!=0)
	{
		if(cTuneType & POS1)
		{
			if(!AutoPositionAdj((cTuneType&0xF0)))
	 			return FALSE;
	 	}
	}
	else
		return FALSE;
		
	if(INT0!=0)
	{
		if(cTuneType & PIXEL)
		{
			if(!AutoFrequencyAdj(cTuneType))
				return FALSE;
		}
	}
	else
		return FALSE;
				
	if(INT0!=0)
	{
		if(cTuneType & PHASE)
		{
			if(!AutoPhaseAdj())
				return FALSE;
   	}
	}
	else
		return FALSE;
	
	
	if(INT0!=0)
	{
		if(cTuneType & POS2)
		{
			if(!AutoPositionAdj(cTuneType&0xF0))
				return FALSE;
		}
	}
	else
		return FALSE;
	*/
	return TRUE;
}

BOOL AutoPositionAdj(uCHAR cTest)
{

	//Reset Hsync and Vsync offset.
	EepPrivate.wHOffset = 0;
	EepPrivate.wVOffset = 0;
	I2CWriteByte(TW803_P0, HSYCOFS_L, (uCHAR)EepPrivate.wHOffset);
	I2CWriteByte(TW803_P0, HSYCOFS_H, (uCHAR)(EepPrivate.wHOffset>>8));
	I2CWriteByte(TW803_P0, VSYCOFS_L, (uCHAR)EepPrivate.wVOffset);
	I2CWriteByte(TW803_P0, VSYCOFS_H, (uCHAR)(EepPrivate.wVOffset>>8));
	//~ Set threshold. ~//
	I2CWriteByte(TW803_P0, THRESHOLD, 0x30);
	
	//~ Enable boundary detection ~//		  	
	I2CWriteByte(TW803_P0, BOUNDCTR, (I2CReadByte(TW803_P0, BOUNDCTR)&0x7F));
	I2CWriteByte(TW803_P0, BOUNDCTR, (I2CReadByte(TW803_P0, BOUNDCTR)|0x80));
	m_wBuff[0]=10;
	while(m_wBuff[0])
	{
		twdDelay(100);
		if(I2CReadByte(TW803_P0, BOUNDCTR)&0x80)	break;
		m_wBuff[0]--;
	}
	//~ Disable boundary detection ~//
	I2CWriteByte(TW803_P0, BOUNDCTR, (I2CReadByte(TW803_P0, BOUNDCTR)&0x7F));	

	//data start
	m_wBuff[0] = I2CReadByte(TW803_P0, POS_LB_H);        
	m_wBuff[0] <<= 8;
	m_wBuff[0] |= I2CReadByte(TW803_P0, POS_LB_L); 

					
	//data end
	m_wBuff[1] = I2CReadByte(TW803_P0, POS_RB_H);       
	m_wBuff[1] <<= 8;
	m_wBuff[1] |= I2CReadByte(TW803_P0, POS_RB_L);
	
	m_wHRes = m_wBuff[1] - m_wBuff[0] + 1;
	Auto_H_Pos(cTest);
      
	//data start
	m_wBuff[0] = I2CReadByte(TW803_P0, POS_TB_H);        
	m_wBuff[0] <<= 8;
	m_wBuff[0] |= I2CReadByte(TW803_P0, POS_TB_L); 

	
	//data end
	m_wBuff[1] = I2CReadByte(TW803_P0, POS_BB_H);       
	m_wBuff[1] <<= 8;
	m_wBuff[1] |= I2CReadByte(TW803_P0, POS_BB_L);

	m_wVRes = m_wBuff[1] - m_wBuff[0] + 1;
	Auto_V_Pos(cTest);

	return TRUE;
}

void Auto_H_Pos(uCHAR cTest)
{
	if(cTest & (CHANGMODE|FORCEDTUNE))
	{
		if(m_bAlt)
		{
        	if (m_cModeStatus & ADCHIGHRANGE)
				HPosAutoAdj();
			else if (m_cModeStatus & ADCLOWRANGE)
				HPosAutoAdj();
			else
				HPosAutoAdj();
		}
		else
		{
       		if (m_cModeStatus & ADCHIGHRANGE)
				HPosAutoAdj();
			else if (m_cModeStatus & ADCLOWRANGE)
				HPosAutoAdj();
			else
				HPosAutoAdj();	
		}
	}
	else if(cTest&FINETUNE)
	{
       	if (m_cModeStatus & ADCHIGHRANGE)
				HPosAutoAdj();
			else if (m_cModeStatus & ADCLOWRANGE)
				HPosAutoAdj();
			else
				HPosAutoAdj();	
		
	}
}

void HPosAutoAdj()
{

	if(m_wHRes<(m_pResolutionPtr->wHRes*0.98))
	{
		//~ Difference is too large, so following the mode table. ~//
		m_wBuff[0] -=4;
	}
	else
	{
		//~ Reset ADC Capture HSize 0x48, 0x49 ~//
		I2CWriteByte(TW803_P0, HATVC_L, (uCHAR)m_wHRes);
		I2CWriteByte(TW803_P0, HATVC_H, (uCHAR)(m_wHRes>>8));
	}
	//~ Fill in the HSync Start Point by the register POS_LB. ~//
	if(m_wBuff[0]>(m_pModeDescriptorPtr->wHBlk*1.01))
	{
		I2CWriteByte(TW803_P0, HSST_L, (uCHAR)m_pModeDescriptorPtr->wHBlk);
		I2CWriteByte(TW803_P0, HSST_H, (uCHAR)(m_pModeDescriptorPtr->wHBlk>>8));
	}
	else
	{
		I2CWriteByte(TW803_P0, HSST_L, (uCHAR)m_wBuff[0]);
		I2CWriteByte(TW803_P0, HSST_H, (uCHAR)(m_wBuff[0]>>8));
	}

}

void Auto_V_Pos(uCHAR cTest)
{
	if(cTest & (CHANGMODE|FORCEDTUNE))
	{
		if(m_bAlt)
		{
     		if(!m_bInterlaced)
				VPosAutoAdj();
			else
				VPosAutoAdj();
		}       	
		else
		{
	       	if(!m_bInterlaced)
				VPosAutoAdj();
			else
				VPosAutoAdj();	
		}
	}
	else if(cTest&FINETUNE)
	{
       	if(!m_bInterlaced)
			VPosAutoAdj();
		else
			VPosAutoAdj();	
    }
	
}

void VPosAutoAdj()
{
	if(m_wVRes<(m_pResolutionPtr->wVRes*0.98))
	{
		//~ Difference is too large, so following the mode table. ~//
		m_wBuff[0] -= 4;
	}
	else
	{
		//~ Reset ADC Capture HSize 0x48, 0x49 ~//
		I2CWriteByte(TW803_P0, VATVR_L, (uCHAR)m_wVRes);
		I2CWriteByte(TW803_P0, VATVR_H, (uCHAR)(m_wVRes>>8));
	}
	//~ Fill in the HSync Start Point by the register POS_LB. ~//
	if(m_wBuff[0]>(m_pModeDescriptorPtr->cVBlk*1.01))
	{
		I2CWriteByte(TW803_P0, VSST_L, (uCHAR)m_pModeDescriptorPtr->cVBlk);
		I2CWriteByte(TW803_P0, VSST_H, (uCHAR)(m_pModeDescriptorPtr->cVBlk>>8));
	}
	else
	{
		I2CWriteByte(TW803_P0, VSST_L, (uCHAR)m_wBuff[0]);
		I2CWriteByte(TW803_P0, VSST_H, (uCHAR)(m_wBuff[0]>>8));
	}
}	


BOOL AutoPhaseAdj(void)
{	
	uWORD MaxTrackValue, MinTarckValue, TrackValue;
	uCHAR MaxTrackAddre, MinTrackAddre;
	uCHAR i, PhSetTemp, ADCDetTemp, CountTemp;

	//~ Find Max and Min phase ~//
	MaxTrackValue=0x0000;
	MinTarckValue=0xFFFF;
	PhSetTemp = I2CReadByte(TW803_P0, 0x20)&0x07;
	ADCDetTemp = I2CReadByte(TW803_P0, 0x21)&0x7F;

	//~ Find Max. and Min. phase tracking. ~//
	for(i=0; i<32; i+=2)
	{
		//~ Set pahse ~//
		I2CWriteByte(TW803_P0, 0x20,(PhSetTemp|(i<<3)));
		CountTemp = 255;
		//~ Enable phase tracking. ~//
		I2CWriteByte(TW803_P0, 0x21, ADCDetTemp|0x80);
		/*if((I2CReadByte(TW803_P0, 0x21)&0x80)==0)
		{
			  CountTemp =20;
		} */
		while(CountTemp)
		{
			if(I2CReadByte(TW803_P0, 0x21)&0x80)	
				break;
			else 
		/*		TrackValue = TrackValue*1000;
				TrackValue = TrackValue/1000;  */
				CountTemp--;
		}
		TrackValue = I2CReadByte(TW803_P0, 0x23) | (I2CReadByte(TW803_P0, 0x24)<<8);
		//~ Disable phase tracking. ~//
		I2CWriteByte(TW803_P0, 0x21, ADCDetTemp&0x7F);

		if(TrackValue>MaxTrackValue)
		{
			MaxTrackValue = TrackValue;
			MaxTrackAddre = i;
		}
		if(TrackValue<MinTarckValue)
		{
			MinTarckValue = TrackValue;
			MinTrackAddre = i;
		}  
	}

	//~ Define evaluation range. ~//
	if(MaxTrackAddre>MinTrackAddre)
	{
		if((MaxTrackAddre + 6) > 31 )
		{
			m_cBuff[1] = 31;
		}
		else
		{
			m_cBuff[1] = MaxTrackAddre + 6;
		}
		if(MaxTrackAddre<6)
		{
			m_cBuff[0] = 0;
		}
		else
		{
			m_cBuff[0] = MaxTrackAddre - 6;
		}
  	}
	else
	{
		if((MaxTrackAddre + 6) > 32 )
		{
			m_cBuff[1] = 32;
		}
		else
		{
			m_cBuff[1] = MaxTrackAddre + 6;
		}
		if(MaxTrackAddre<6)
		{
			m_cBuff[0] = 0;
		}
		else
		{
			m_cBuff[0] = MaxTrackAddre - 6;
		}
 	}

	//~ Find Min. Delta ~//
	MaxTrackValue = 0xFFFF;
	MaxTrackAddre = 0;
	if(m_cBuff[0]==0) m_cBuff[0] += 1;
	if(m_cBuff[1]==31) m_cBuff[1] -= 1;
	for(i=m_cBuff[0]; i<m_cBuff[1]; i++)
	{
		//~ Set pahse 1 ~//
		
		I2CWriteByte(TW803_P0, 0x20,(PhSetTemp|((i-1)<<3)));
		CountTemp = 255;
		//~ Enable phase tracking. ~//
		I2CWriteByte(TW803_P0, 0x21, ADCDetTemp|0x80);
		while(CountTemp)
		{
			if(I2CReadByte(TW803_P0, 0x21)&0x80)	
				break;
			else
				CountTemp--;
		}
		m_wBuff[0] = I2CReadByte(TW803_P0, 0x23) | (I2CReadByte(TW803_P0, 0x24)<<8);
				
		//~ Set pahse 2 ~//
		I2CWriteByte(TW803_P0, 0x20, (PhSetTemp|((i)<<3)));
		CountTemp = 255;
		//~ Enable phase tracking. ~//
		I2CWriteByte(TW803_P0, 0x21, ADCDetTemp|0x80);
		while(CountTemp)
		{
			if(I2CReadByte(TW803_P0, 0x21)&0x80)	
				break;
			else 
				CountTemp--;
		}
		m_wBuff[1] = I2CReadByte(TW803_P0, 0x23) | (I2CReadByte(TW803_P0, 0x24)<<8);	
		
		//~ Set pahse 3 ~//
		I2CWriteByte(TW803_P0, 0x20,(PhSetTemp|((i+1)<<3)));
		CountTemp = 255;
		//~ Enable phase tracking. ~//
		I2CWriteByte(TW803_P0, 0x21, ADCDetTemp|0x80);
		while(CountTemp)
		{
			if(I2CReadByte(TW803_P0, 0x21)&0x80)	
				break;
			else 
				CountTemp--;
		}
		m_wBuff[2] = I2CReadByte(TW803_P0, 0x23) | (I2CReadByte(TW803_P0, 0x24)<<8);
		MinTarckValue = (abs(m_wBuff[1]-m_wBuff[0]) + abs(m_wBuff[2]-m_wBuff[1]))>>1;
		if(MinTarckValue<MaxTrackValue)
		{
			MaxTrackValue = MinTarckValue;
			MaxTrackAddre = i;
		}
	}

	//~ Set phase ~//
	I2CWriteByte(TW803_P0, 0x20,(PhSetTemp|((MaxTrackAddre)<<3)));		
}



uDWORD	GetPhaseQuality(void)
{
	uDWORD	wdPhase;
	//uCHAR   cTemp;
	uCHAR   cCount;

#if 0
	cTemp = I2CReadByte(TW803_P0, 0x50);
	cTemp |= 0x01;	//Enable auto tracking interrupt
	I2CWriteByte(TW803_P0, 0x50, cTemp);
#endif
				
	cCount = 255;
	while(cCount--)
	{
		if(INT0==0)	break;
		twdDelay(1);        //Time dealy, need adjust
		if (I2CReadByte(TW803_P0, 0x50)&0x02)
			break;
	}
		
	wdPhase = I2CReadByte(TW803_P0, 0x57);     
	wdPhase <<= 8;
	wdPhase |= I2CReadByte(TW803_P0, 0x56);
	wdPhase <<= 8;
	wdPhase |= I2CReadByte(TW803_P0, 0x55);
	//11.11 wdPhase <<= 8;
	//wdPhase |= I2CReadByte(TW803_P0, 0x54);

	//cTemp &= 0xFC;	//Disable auto tracking and clear done bit
	I2CWriteByte(TW803_P0, 0x50, I2CReadByte(TW803_P0, 0x50)&0xFC);
	I2CWriteByte(TW803_P0, 0x50, I2CReadByte(TW803_P0, 0x50)|0x01);
	
	return wdPhase;
}


uDWORD	GetPhaseDelta(uWORD wTotal)
{
	uDWORD  IDATA wdMinPhase, wdMaxPhase;
	uDWORD  IDATA dwPhase1; 
	
	wdMaxPhase = 0;
	wdMinPhase = 0xFFFFFFFFL;

	I2CWriteByte(TW803_P0, 0x50, I2CReadByte(TW803_P0, 0x50)|0x01);	//Enable auto tracking interrupt
	//Purpose: phase+2, improve speed
	for (m_cBuff[3]=0; m_cBuff[3]<16; m_cBuff[3] +=1)
	{
		if(INT0==0)	return FALSE;
		I2CWriteByte(TW803_P0, ADC_PHASE, m_cBuff[3]<<4);
		dwPhase1 = GetPhaseQuality();
        	
		if (dwPhase1 > wdMaxPhase)
		{
			wdMaxPhase = dwPhase1;
			m_cGoodPhase = m_cBuff[3];
		}
		if (dwPhase1 < wdMinPhase)
		{
			wdMinPhase = dwPhase1;
     }
	}
	//Disable auto tracking and clear done bit
	I2CWriteByte(TW803_P0, 0x50, I2CReadByte(TW803_P0, 0x50)&0xFC);
	     
	return (wdMaxPhase - wdMinPhase) / wTotal;
		
}