osdtune.02

采用台湾MRT晶捷公司的MRT4方案的液晶电视的程序

    goto pitchcal0;

pitchcal_down:
    // pitch down
    pitch -= 1;    
    if (up) {
#if DEBUGMSG
        printf("  pitch dn-----ERROR: back loop, abort pitchCal!\n");
#endif
        goto pitchcal_done;    
    }
    up = 0; dn = 1;
    
    if (tpitch0 != pitch)    // stop if back to old value    
    	goto pitchcal0;

pitchcal_done:
	eepModeData.setData.pitch = pitch;
#if USE_PITCH_PATCH	
	pitchPatch(); 
#endif	
    goto pitchcal_ret;

pitchcal_fail:
    CalibSuccess = 0;
    eepModeData.setData.pitch = PresetModeFlag ? autoModeData.pitch : DefaultPitch;

pitchcal_ret:
	eepModeData.setData.pitch_val = DEF_pitchval;
	eepModeData.setData.def_pitch = eepModeData.setData.pitch; 	
    RegByteOut(0xB0, 0x00);     // Disable calibration

	miscSetADCPitch(eepModeData.setData.pitch);
	
	if (tpitch0 == eepModeData.setData.pitch)
		return NOCHANGE;
		
	return CHANGE;

}



#undef hStart         
#undef hWidth         

#undef adjust_limit    







/************************************************
* Phase Calibration  use hWidth                 *
*************************************************/
#define hStart          ival
#define hWidth          ival1
#define minhWidth      	ival2


#define phaseStart		buff[12]
#define phaseEnd		buff[13]
#define phaseStart1		buff[14]
#define phaseEnd1		buff[15]
#define phaseStart2		buff[16]
#define phaseEnd2		buff[17]


void phaseHWCalibration(void)
{

	bit phaseOkFlag=0;
	bit phaseOkFlag1=0;
	bit phaseOkFlag2=0;
	unsigned char phase;
	
    phaseStart=0;phaseEnd=0;
    phaseStart1=0;phaseEnd1=0;
    phaseStart2=0;phaseEnd2=0;
    
	minhWidth=2048;

#if (DEBUGMSG>=2)
    printf(" \n------------------ PhaseHWCalib \n");
#endif

    if ( !CalibSuccess ) return;

    RegByteOut(0xB2, COLORCMPMASK);     // Set color compare mask

    RegByteOut(0xB0, 0x04);     		// Enable vertical calibration

	

for(phase = 0;phase < 32;phase++)
{
	
	checkPowerOffButton();		//in phaseHWcalib
	if (!(eepData.MascotFlag & FLAG_POWERSTATUS))	goto phaseHWcal_fail;
	
	miscSetADCPhase(phase);
#if (DEBUGMSG>=3)
    printf("phase=%d",(unsigned int)phase);
#endif	
    RegByteOut(0xB0, 0x02);     // Enable vertical calibration
    RegByteOut(0x00, 0x00);     // Clear the calibration status reg
    if (!waitCalibReady(0x02)) goto phaseHWcal_fail;
    
    RegByteOut(0xB0, 0x04);
    RegByteOut(0x00, 0x00);     // Clear the calibration status reg
    if (!waitCalibReady(0x04)) goto phaseHWcal_fail;

    RegDataIn(0xD3, buff, 5);
    RegDataIn(0xF9, buff+5, 5);
    hStart = (((unsigned int)buff[2]&0x07)<<8) + buff[0];
    hWidth = ((unsigned int)(buff[7]&0x70)<<4) + buff[6] - hStart + 1;
#if (DEBUGMSG>=3)	
	printf("   hStart = %d , hWidth = %d \n",hStart,hWidth);
#endif	

	if (minhWidth > hWidth) 
	{
		minhWidth = hWidth;
	
		if(phaseEnd == 0)
		{
			phaseOkFlag = 1;
			phaseStart = phase;
#if (DEBUGMSG >= 3)
	  		printf("           phaseStart = %d\n",(unsigned int)phaseStart);
#endif			
		}
		else if (!phaseOkFlag1 && (phaseEnd != 0 ))
		{
			phaseOkFlag1 = 1;
			phaseStart1 = phase;
#if (DEBUGMSG >= 3)
	  		printf("           phaseStart1 = %d\n",(unsigned int)phaseStart1);
#endif					
		}
	
		else if (!phaseOkFlag2 && (phaseEnd1 != 0 ))
		{
			phaseOkFlag2 = 1;
			phaseStart2 = phase;
#if (DEBUGMSG >= 3)
	  		printf("           phaseStart2 = %d\n",(unsigned int)phaseStart2);
#endif					
		}

	}
	else if(minhWidth < hWidth)
	{
		minhWidth = hWidth;
		
		if(phaseOkFlag && (phaseEnd == 0))
		{
			phaseEnd = phase-1;
#if (DEBUGMSG >= 3)
	  		printf("           phaseEnd = %d\n",(unsigned int)phaseEnd);
#endif					
        	if(phaseEnd == phaseStart)
        	{
           		phaseOkFlag = 0;
            	phaseStart = phaseEnd = 0; 

#if (DEBUGMSG >= 3)
            	printf("           Reset phaseStart & phaseEnd  \n");
#endif
    		}	
		}	
	
		else if (phaseOkFlag1 && (phaseStart1 != 0 ) && (phaseEnd1 == 0))
		{
			phaseEnd1 = phase-1;
#if (DEBUGMSG >= 3)
	  		printf("           phaseEnd1 = %d\n",(unsigned int)phaseEnd1);
#endif		


        	if(phaseEnd1 == phaseStart1)
        	{
           		phaseOkFlag1 = 0;
            	phaseStart1 = phaseEnd1 = 0; 

#if (DEBUGMSG >= 3)
            	printf("           Reset phaseStart1 & phaseEnd1  \n");
#endif
    		}	
		}
	
		else if (phaseOkFlag2 && (phaseStart2 != 0 ) && (phaseEnd2 == 0))
		{
			phaseEnd2 = phase-1;
#if (DEBUGMSG >= 3)
	  		printf("           phaseEnd2 = %d\n",(unsigned int)phaseEnd2);
#endif	

        	if(phaseEnd2 == phaseStart2)
        	{
           		phaseOkFlag2 = 0;
            	phaseStart2 = phaseEnd2 = 0; 

#if (DEBUGMSG >= 3)
            	printf("           Reset phaseStart2 & phaseEnd2  \n");
#endif
    		}	
		}		


	}
}


       	if (phaseOkFlag && (phaseEnd == 0))  phaseEnd = 31;
        if (phaseOkFlag1 && (phaseEnd1 == 0))  phaseEnd1 = 31;
        if (phaseOkFlag2 && (phaseEnd2 == 0))  phaseEnd2 = 31;
        
		
		if (phaseOkFlag & phaseOkFlag1 & phaseOkFlag2)	
        {
           	if ((phaseStart == 0) && (phaseEnd2 == 31))
           	{
           		if((phaseEnd-phaseStart+phaseEnd2-phaseStart2) >= (phaseEnd1-phaseStart1))
            		phase = ((phaseStart2+phaseEnd)/2+16)& 0x1f;
            	else
            		phase = (phaseEnd1 + phaseStart1)/2;	
            }	
            else if((phaseEnd-phaseStart) >= (phaseEnd1-phaseStart1))
            {
            	if((phaseEnd-phaseStart) >= (phaseEnd2-phaseStart2))
                	phase = (phaseEnd + phaseStart)/2;
                else
                	phase = (phaseEnd2 + phaseStart2)/2;
            }    
            else
            {
            	if((phaseEnd1-phaseStart1) >= (phaseEnd2-phaseStart2))
                	phase = (phaseEnd1 + phaseStart1)/2;
                else
                	phase = (phaseEnd2 + phaseStart2)/2;                              
            }    

#if (DEBUGMSG >= 3)
            printf(" phaseOkFlag & phaseOkFlag1 & phaseOkFlag2  phaseVal   = %d\n",(unsigned int)phase);
#endif                                         
  
		}			                
		
        else if (phaseOkFlag & phaseOkFlag1)
        {
           	if ((phaseStart == 0) && (phaseEnd1 == 31))
           	{
            	phase = ((phaseStart1+phaseEnd)/2+16)& 0x1f;
            	phaseHwStart = phaseStart1;
            	phaseHwEnd = phaseEnd;
            }
            else if((phaseEnd-phaseStart) >= (phaseEnd1-phaseStart1))
            {
                phase = (phaseEnd + phaseStart)/2;
            	phaseHwStart = phaseStart;
            	phaseHwEnd = phaseEnd;               
            }
            else
            {
                phase = (phaseEnd1 + phaseStart1)/2;                                 
            	phaseHwStart = phaseStart1;
            	phaseHwEnd = phaseEnd1;         
			}
#if (DEBUGMSG >= 3)
            printf(" phaseOkFlag & phaseOkFlag1   phaseVal   = %d\n",(unsigned int)phase);
#endif                                         
     
		}
        else if(phaseOkFlag) 
        {

            phase = (phaseStart+phaseEnd)/2;
            phaseHwStart = phaseStart;
            phaseHwEnd = phaseEnd;            
#if (DEBUGMSG >= 3)
            printf(" phaseOkFlag          phaseVal   = %d\n",(unsigned int)phase);
#endif                
          
        }
        else
        {
            phase = 15; 
            phaseHwStart = 0;
            phaseHwEnd = 31;                      
#if (DEBUGMSG >= 3)
             printf(" Fail checkphase!!!  phaseVal = 15 \n");
#endif

        }
		
		eepModeData.setData.phase = phase;

    	goto phaseHWcal_ret;

phaseHWcal_fail:
    CalibSuccess = 0;
    eepModeData.setData.phase = PresetModeFlag ? autoModeData.phase : DefaultPhase;

phaseHWcal_ret:
    RegByteOut(0xB0, 0x00);     // Disable calibration
	miscSetADCPhase(eepModeData.setData.phase);

}



#undef hStart         
#undef hWidth         
#undef minhWidth


//#undef phase
#undef phaseStart		
#undef phaseEnd		
#undef phaseStart1		
#undef phaseEnd1		
#undef phaseStart2		
#undef phaseEnd2		
















#if DETAIL_AUTOTUNE
/************************************************
* Phase Calibration                             *
*************************************************/
#define phaseStart		buff[11]
#define phaseEnd		buff[12]
#define phaseStart1		buff[13]
#define phaseEnd1		buff[14]
#define phaseStart2		buff[15]
#define phaseEnd2		buff[16]
#define minValue 		buff[17]
#define minError		buff[18]
#define phaseVal    	buff[19]


#define USE_MAX_DIFF	0	// use Max difference point to setting calibration area


char phaseCalibration(unsigned char control)
{

	unsigned char phaseRet;
    bit phaseOkFlag=0,phaseOkFlag1=0,phaseOkFlag2=0; 
    phaseStart=0,phaseEnd=0;
    phaseStart1=0,phaseEnd1=0;
    phaseStart2=0,phaseEnd2=0;
    minValue=0,minError=255;

#if (DEBUGMSG >= 3)
    printf(" \n---------------- phaseCalibration %02X\n", (unsigned int)control);
#endif

	phaseRet = phaseVal = phaseHwStart;;

#if (DEBUGMSG >= 2)
    	printf("  phaseVal = %d\n",(unsigned int)phaseVal);
#endif

    miscSetADCPhase(phaseRet);

    // Get phase cal points
    RegByteOut(0xB0, 0x04);     // Enable hort calibration
    RegByteOut(0xB1, 0x00);
    RegByteOut(0xB2, COLORCMPMASK);
    RegByteOut(0x00, 0x00);     // Clear the calibration status reg
    if ( waitCalibReady(0x04) == 0) {
        goto phasecal_fail;
    }
    
//-------------------------    
#if USE_MAX_DIFF	
	RegDataIn(0xD4, buff, 2);

    // Get Max difference point
    RegByteOut(0xB0, 0x10);     // Enable Max diffenence calibration
    RegByteOut(0x00, 0x00);     // Clear the calibration status reg
    if ( waitCalibReady(0x10) == 0) {
        goto phasecal_fail;
    }
	RegDataIn(0xD8, buff+5, 3);

	//point1 H position = H_start
	ival = ((unsigned int)(buff[7]&0x70)<<4) + buff[6];	//0xd8
	//point2 H position = H_end
	ival1 = ((unsigned int)(buff[1]&0x70)<<4) + buff[0];	//0xd3

	buff[3] = (unsigned char)ival;
	buff[4] = (unsigned char)ival1 ;
	buff[5] = (unsigned char)((ival1&0x0f00)>>4) + (unsigned char)((ival&0x0f00)>>8);

	//point1 V position = V_start
	ival = ((unsigned int)(buff[7]&0x07)<<8)+ buff[5];	//0xd8
	//point2 V position 
	ival1 = ival + 20; 

	buff[6] = (unsigned char)ival;
	buff[7] = (unsigned char)ival1 ;
	buff[8] = (unsigned char)((ival1&0x0f00)>>4) + (unsigned char)((ival&0x0f00)>>8);

#else

    RegDataIn(0xD0, buff, 8);

	//point1 H position = H_start
	ival = buff[3]+((buff[5]&0x07)<<8);
	//point2 H position = H_end
//	ival1 = buff[4]+((buff[5]&0x70)<<4);
	ival1 = ival + CurrentWidth / 2;
	
	buff[3] = (unsigned char)ival;
	buff[4] = (unsigned char)ival1 ;
	buff[5] = (unsigned char)((ival1&0x0f00)>>4) + (unsigned char)((ival&0x0f00)>>8);
	
	//point1 V position = V_start
	ival = buff[6]+((buff[7]&0x07)<<8);
	//point2 V position 
	ival1 = ival + 20; 

	buff[6] = (unsigned char)ival;
	buff[7] = (unsigned char)ival1 ;
	buff[8] = (unsigned char)((ival1&0x0f00)>>4) + (unsigned char)((ival&0x0f00)>>8);

#endif
//-------------------------


    RegDataOut(0xB9, buff+3, 6);
    
#if (DEBUGMSG >= 2)
    printf(" (%d,%d) (%d,%d)\n",
        (unsigned int)buff[3]+((buff[5]&0x0F)<<8),
        (unsigned int)buff[6]+((buff[8]&0x0F)<<8),
        (unsigned int)buff[4]+((buff[5]&0xF0)<<4),
        (unsigned int)buff[7]+((buff[8]&0xF0)<<4) );
#endif


    // start phase cal
    RegByteOut(0xB2, phaseError);
    RegByteOut(0xB0, 0x08); // Enable phase calibration

cp_chkphase:
	checkPowerOffButton(); 		//in phaseCalib
	if (!(eepData.MascotFlag & FLAG_POWERSTATUS))	goto phasecal_fail;

#if (DEBUGMSG >= 2)
    printf("PHASE=%d: ",(unsigned int)phaseRet);
#endif

    if (control & 0x01) {
        RegByteOut(0xB1, (control&0xF0)+0x01);
        RegByteOut(0x00, 0x00);     // Clear the calibration status reg
        if ( waitCalibReady1(0x08) == 0) {
        	goto phasecal_fail;
        }
        RegDataIn(0xE7, buff, 2);
        ival = (unsigned int)buff[0] + buff[1];
    }
    if (control & 0x02) {
        RegByteOut(0xB1, (control&0xF0)+0x02);
        RegByteOut(0x00, 0x00);     // Clear the calibration status reg
        if ( waitCalibReady1(0x08) == 0) {
        	goto phasecal_fail;
        }
        RegDataIn(0xE7, buff, 2);
        ival += (unsigned int)buff[0] + buff[1];
    }
    if (control & 0x04) {
        RegByteOut(0xB1, (control&0xF0)+0x04);
        RegByteOut(0x00, 0x00);     // Clear the calibration status reg
        if ( waitCalibReady1(0x08) == 0) {
        	goto phasecal_fail;
        }
        RegDataIn(0xE7, buff, 2);
        ival += (unsigned int)buff[0] + buff[1];
    }

#if (DEBUGMSG >= 3)
        printf("%d=%d+%d\n", ival,(unsigned int)buff[0],(unsigned int)buff[1]);
#endif



//-----------------------------------------------------------------------------
	if (minError > ival)
	{
		minError = ival;
		minValue = phaseRet;		
	}
	//set phaseStart
    if (ival == 0 && !phaseOkFlag && phaseStart == 0 )