//----------------------------------------------------------------------------------------------------
// ID Code      : Sync.c No.0003
// Update Note  :
//
//----------------------------------------------------------------------------------------------------

#define __SYNC__

#include "Core\Header\Include.h"

/**
 * CSyncProcess
 * For VGA, DVI or YPbPr input source's state machine process.
 * first system initial, then main loop
 * @param <none>
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : For VGA, DVI or YPbPr input source's state machine process.
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CSyncProcess(void)
{
	switch (ucSyncProcessState) {
		case _SOURCE_CHANGE_STATE:
			CModeResetMode();
			
		case _SEARCH_STATE:		

			//DebugPrintf("\n _SEARCH_STATE!!!\n",'i');

			if (CSyncHandler())
			{			

				//DebugPrintf("\n sync OK!!!",'i');

				// Source and sync OK
				if (CModeDetect()) 
				{
					//CTimerCancelTimerEvent(COsdFxSetWinMovingEvent);

					//DebugPrintf("\n Source and sync OK!!!",'i');

					// Mode stable. Initial display settings  switch to active/nosignal/nosupport state					
					SET_READYFORDISPLAY();
					if (stModeInfo.ModeCurr == _MODE_NOSIGNAL) 
					{
						CLR_SHOW_NO_SIGNAL();
						ucSyncProcessState = _NOSIGNAL_STATE;
					}
					else if (stModeInfo.ModeCurr == _MODE_NOSUPPORT)
					{
						CLR_SHOW_NO_SUPPORT();
						CModeAutoMeasureOn();
						ucSyncProcessState = _NOSUPPORT_STATE;
					}
					else		//make sure input soure OK and display mode
					{

						//DebugPrintf("\n go to display...\n",'i');
						if(!CModeDisplayActiveMode())
						{
							CModeResetMode();
							//DebugPrintf("\n !CModeDisplayActiveMode\n",'i');
							break;
						}
						CModeAutoMeasureOn();
				#if(_HDMI_SUPPORT == _ON)
#if(_HDMI_SUPPORT == _ON)
						if((GET_INPUTSOURCE_TYPE()==_SOURCE_DVI) && CHdmiFormatDetect())		//Input source is the HDMI format.
						{
							CHdmiAudioFirstTracking();
							CTimerReactiveTimerEvent(SEC(1), CHdmiAudioWaitingFlagReadyEven);
							//DebugPrintf("\nHdmiDetect\n", 0);
						}
#endif
						else
						{							
							//COsdMessagePush(_SHOW_SIGNALSOURCE_MESSAGE);
							//SET_READYFORDISPLAY();
						}
				#else
						/*
						COsdMessagePush(_SHOW_SIGNALSOURCE_MESSAGE);
						SET_READYFORDISPLAY();
						*/
				#endif
						SET_SHOW_NO_SIGNAL();
						CTimerCancelTimerEvent(CModeNoSignalEvent);
						CTimerCancelTimerEvent(CModeNoSignalIconMoveEvent);
						CTimerCancelTimerEvent(CModeNoCableEvent);
						CTimerCancelTimerEvent(CModeNoSupportEvent);
						CTimerCancelTimerEvent(CModePowerSavingEvent);
						ucSyncProcessState = _ACTIVE_STATE;

						CLR_EARPHONE_LAST_STATUS();

						CLR_SHOWINFO();

					}
				}
				else
				{
					if((GET_INPUTSOURCE_TYPE()==_SOURCE_DVI) && CHdmiFormatDetect())//for Philips DVD
					{
						CTimerDelayXms(50);//for Philips DVD
					//DebugPrintf("\n CModeDetectfail!!!\n",'i');
//080319,test hdmi
#if 0//(_HDCP_SUPPORT == _ON)
						if (GET_INPUTSOURCE_TYPE()==_SOURCE_DVI)
						{
							ucHdmiSearchErrorTimes++;
			
							if (ucHdmiSearchErrorTimes<20)
							{
							}
							else
							{
								//DebugPrintf("\n!@#$resume HPD!@#$\n",'i');
								ucHdmiSearchErrorTimes = 0;
								ucHdmiMeasureErrorCnt = 0;
				
								//CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_SCR_00, ~(_BIT3 | _BIT2), _BIT3);//Set HDMI/DVI switch mode(manual,DVI)//Alanli20070801
								//CScalerSetDataPortByte(_P2_HDCP_ADDR_PORT_C3, 0x40, 0x81);// Change to HDCP1.0 for DVI
								//CTimerDelayXms(200);
								//CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_SCR_00, ~(_BIT3 | _BIT2), 0x00);//Set HDMI/DVI switch mode(auto)
				
								if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT)
								{
									//DebugPrintf("\n=====RESUME _HDMI_PORT=====",0);
									SET_HOTPLUG_HDMI(_OFF);
									CTimerDelayXms(100+20);
									SET_HOTPLUG_HDMI(_ON);
									CTimerDelayXms(500);
								}
								else if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT2)
								{
									//DebugPrintf("\n=====RESUME _HDMI_PORT2=====",0);
									SET_HOTPLUG_HDMI2(_OFF);
									CTimerDelayXms(100+20);
									SET_HOTPLUG_HDMI2(_ON);
									CTimerDelayXms(500);
								}
							}
						}
#endif
//080319,test hdmi

						
					}
				}
				ucTimerEvent = _INACTIVE_COUNTDOWN_EVENT;
			}
			else 
			{
				if(GET_INPUTSOURCE_TYPE() == _SOURCE_DVI)//eric 20070315
					CTimerCountDownEventProc(&ucTimerEvent, 10,CModeSyncTimeoutCountDownEvent);
				else	
				CTimerCountDownEventProc(&ucTimerEvent, 5,	CModeSyncTimeoutCountDownEvent);
			}
			
			break;

		case _ACTIVE_STATE:
			//DebugPrintf("\n _ACTIVE_STATE!!!\n",'i');
			// For VGA, DVI, input*/
		  	if (CFrameSyncDetect()) //&&(GET_INPUTPORT_TYPE(stSystemData.InputSource) != _YPBPR_A0_PORT)) 
			{
				//DebugPrintf("\n frame sync unstable!!!",'i');				
		  		CModeResetMode();
				break;
		  	}
			else
			{
		  		if (CModeIsChange() ) {
					//DebugPrintf("\n CModeIsChange !!!\n",'i');
		  			CModeResetMode();
					break;
		  		}
                		else
				{
#if 1//(_HDMI_SUPPORT == _ON)

					if(GET_INPUTSOURCE_TYPE() == _SOURCE_DVI)
					{
						//DebugPrintf("\n active: is hdmi, ucHdmiTimerEvent:%d\n",ucHdmiTimerEvent);
                				if(CHdmiFormatDetect())		//Input source is the HDMI format.
                				{
                					if(!GET_HDMIINPUT()) 
							{	

								//DebugPrintf("\n GET_HDMIINPUT!!!\n",'i');

                   						CModeResetMode();	
								break;
                   					}
                    					else
							{
                    						if(GET_AUDIOWAITINGTIMEOUT())
                    						{
                    							CHdmiEnableAudioOutput();
			//080319,test hdmi
									ucHdmiSearchErrorTimes = 0;
									ucHdmiMeasureErrorCnt = 0;
			//080319,test hdmi
                    						}
                    					}		
                   	 			}
                    				else
						{
                    					if(GET_HDMIINPUT())
							{

								//DebugPrintf("\n GET_HDMIINPUT_2!!!\n",'i');

                    						CModeResetMode();			
								break;
                        				}
                    				}
					}
#endif	//#if (_HDMI_SUPPORT == _ON)

             			}
		  	}
			
				if (!GET_SHOWINFO())
				{
					SET_SHOWINFO();
					SET_SHOW_NO_SIGNAL();
				//	CTimerCancelTimerEvent(COsdNoSignalEvent);
					if (GET_OSD_NOT_EXIST())
						COsdMessagePush(_SHOWINFO_MESSAGE);
					else
						CTimerReactiveTimerEvent(SEC(GET_OSDTIMEOUT()), COsdFxExitEvent);
				}

				if (GET_READYFORDISPLAY() == _TRUE) 
				{
					LED_Message(_LED_MSG_GREEN);
					CLR_READYFORDISPLAY();
					CLR_SOURCE_AUTOCHANGE();
//RTD2528R, add
#if(_OD_SUPPORT == _ON)
					CMemorySetODCompress();
					CMemorySetODFIFO();
					CMemorySetODOnOff(_ON);
#endif
					if (GET_LIGHTPOWERSTATUS() == _OFF)
					{
						if(!bForcePanelOff)
						CPowerPanelOn();
					}
//RTD2528R, add
#if (_HDMI_SUPPORT == _ON)
					CScalerPageSelect(_PAGE2);
					CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_VWDSR_41, ~_BIT0, _BIT0);//Enable packet variation Watch Dog
#endif

#if _YPBPR_NONE_CHECK_APLL
					if(GET_INPUTSOURCE_TYPE() == _SOURCE_YPBPR)
						CAdjustEnableWatchDog(_WD_ALL & ~_WD_APLL_NONLOCK);	// not to watch APLL mis-Lock,hill 20070417
#endif	//#if _YPBPR_NONE_CHECK_APLL
					else
						CAdjustEnableWatchDog(_WD_ALL);
					
					CAdjustBackgroundColor(0x00, 0x00, 0x00);

					//COsdDispFirstTimeLoadFont();
					//COsdDispFirstTimeLoadPalette();

#if _CGT_DELAY_PC_MUTE
					if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DSUB_A0_PORT && GET_PC_AUDIO_ACTIVE())
					{
					}
					else
					{
	
#if _VOLUME_PT2314_SUPPORT
						CPt2314WrBalance();
#endif
						SET_MUTE_PROCESS(_DISABLE);

						if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DSUB_A0_PORT)
							SET_PC_AUDIO_ACTIVE();

					}
	
#else	//#if _CGT_DELAY_PC_MUTE
				//earphone connect with PT2314 directly, 
				//the operation that writing balance cause MUTE of PT2314 fail when power up,
				//we do not write the balance, until now:
#if _VOLUME_PT2314_SUPPORT
				CPt2314WrBalance();
#endif
				CTimerDelayXms(2000);
				SET_MUTE_PROCESS(_DISABLE);
#endif	//#if _CGT_DELAY_PC_MUTE

				SET_SHOW_IS_NOSIGNAL_STATE();

				}
				else
				{
					if (GET_EARPHONE_STATUS_CHANGE())
					{
						SET_MUTE_PROCESS(_ENABLE);
						SET_MUTE_PROCESS(_DISABLE);
					}

					//illegal test: plug out/in the earphone quickly, sometimes cause detect error
					if (GET_EARPHONE_INSERT())
					{
						SET_AUDIO_CHIP_MUTE();
					}
				}

				if ((stModeUserData.FirstAuto == 0) && (GET_INPUTSOURCE_TYPE() == _SOURCE_VGA))  ///!do auto config when go to vga first time
				{
					//premier, undo auto while menu is on
					stModeUserData.FirstAuto = 1;
					if (!ucOsdState)
						COsdMessagePush(_DO_AUTO_CONFIG_MESSAGE);
					else
						CAutoDoAutoConfig();
				}

			break;
			
		case _NOSUPPORT_STATE:
			if (GET_READYFORDISPLAY() == _TRUE) {
				//20070324
				LED_Message(_LED_MSG_GREEN);
					
				CLR_READYFORDISPLAY();
				CModeSetFreeRun();
				if(0)//(GET_TV_BACKGROUND())						//add by lbh 20090927
					CAdjustBackgroundColor(0x00, 0x00, 0xff);	
				else
					CAdjustBackgroundColor(0x00, 0x00, 0x00);  // Background Black
				if (GET_LIGHTPOWERSTATUS() == _OFF)
				{
					if(!bForcePanelOff)
					CPowerPanelOn();					//enable by lbh 20090927
				}

				CTimerReactiveTimerEvent(SEC(3), CModeNoSupportEvent);
#if 0//(_OSD_MOVE_FOR_PDP)
					CTimerReactiveTimerEvent(SEC(_TIMER_ICONMOVE), COsdFxShowNoSupportMove);
#endif
			}

			//no support stay on screen, it may be closed by a key pressed.
			//we according to "GET_SHOW_NO_SIGNAL()" to show it again.
			//else
			{ // CLR_SHOW_NO_SIGNAL();
				if (!GET_SHOW_NO_SIGNAL())
				{
					SET_SHOW_NO_SIGNAL();
					//test
					//CModeSetFreeRun();
					//CAdjustBackgroundColor(0x00, 0x80, 0x00);  // Background Black
					CTimerReactiveTimerEvent(SEC(3), CModeNoSupportEvent);
#if 0//(_OSD_MOVE_FOR_PDP)
					CTimerReactiveTimerEvent(SEC(_TIMER_ICONMOVE), COsdFxShowNoSupportMove);
#endif
				}
			}

			//if (CModeConnectIsChange() || CModeIsChange())
			if (CModeIsChange())
			{
				CModeResetMode();
			}
			
#if 0//(_OSD_MOVE_FOR_PDP)
			SET_RAND_MOVE();
#endif

			break;
			
		case _NOSIGNAL_STATE:
			//DebugPrintf("\n_NOSIGNAL_STATE\n",0);
#ifdef DRAW_SLIDER
						COsdCoreDrawSlider();
#endif			

#if _CUSTOMER_SANSE
			if (bLedFlash)
			{
				bLedFlash = 0;
				LED_Message(_LED_MSG_FLASH_GREEN);
			}
#endif

			if (GET_READYFORDISPLAY() == _TRUE) 
			{

				//20070324
				LED_Message(_LED_MSG_GREEN);

				//if(GET_INPUTSOURCE_TYPE() == _SOURCE_DVI)
				//	CModeHdmiHP();

				CLR_READYFORDISPLAY();

				if (GET_LIGHTPOWERSTATUS() == _OFF)
				{
					if(!bForcePanelOff)
					;//CPowerPanelOn();					//enable by lbh 20090927
				}

				if (GET_OSD_NOT_EXIST())
				{
					if(GET_INPUTPORT_TYPE(stSystemData.InputSource)!=_YPBPR_A0_PORT)	//add 20091210
					if (GET_BURNSTATUS())
					{
						CTimerReactiveNosignal_Icon_Powersaving(0);
					}
					else
						CTimerReactiveNosignal_Icon_Powersaving(1);
				}
				
				if (!GET_SHOWINFO())
				{

					//DebugPrintf("\n GET_SHOWINFO()=0, ucOsdState=%d \n",ucOsdState);

					SET_SHOWINFO();
					//20070329
					if (GET_OSD_NOT_EXIST()){

						//DebugPrintf("\n SET_FIRST_ENTRY_SHOWSOURCE()\n",0);

						SET_FIRST_ENTRY_SHOWSOURCE();
						SET_SHOW_NO_SIGNAL();
						//COsdShowNoSignalOrSrc(1);
						COsdShowNoSignalOrSrc(0);
					}
					else{
						CLR_SHOW_NO_SIGNAL();
						//CTimerCancelTimerEvent(COsdFxExitEvent);
						CTimerCancelTimerEvent(COsdNoSignalEvent);
						CTimerActiveTimerEvent(SEC(GET_OSDTIMEOUT()), COsdFxExitEvent);
						CLR_SHOW_IS_NOSIGNAL_STATE();
						CModeSetFreeRun();
						if(0)//(GET_TV_BACKGROUND())					
							CAdjustBackgroundColor(0x00, 0x00, 0xff);	
						else
							CAdjustBackgroundColor(0x00, 0x00, 0x00);
					}
				}
			}
			
			//if (CModeConnectIsChange() || CSourceHandler())
			if (CSourceHandler())
				CModeResetMode();
			//20080919 ccy cancel
			//SET_RAND_MOVE();
			//review the add:
			SET_INPUTSYNC_TYPE(_NO_SYNC_STATE);
			CLR_MODESTABLE();

			break;

		default:
			break;
	}
}


/**
 * CSyncHandler
 * sync type handler
 * and set input source according to the sync type
 * @param <none>
 * @return {TRUE if sync type is identified;FALSE if no sync}
 *
*/
//--------------------------------------------------
// Description  : Measure sync type
// Input Value  : None
// Output Value : Return _TRUE if succeed
//--------------------------------------------------
bit CSyncHandler(void)
{
		if (GET_INPUTSYNC_TYPE() == _NO_SYNC_STATE)
		{
      		if (!CSourceHandler())   //input Source not exist
      		{

     			//DebugPrintf("\n SyncHandler (NO_SYNC) !%c",0x20);

        		SET_INPUTSYNC_TYPE(_NO_SYNC_STATE);
        		return _FALSE;
        }
					
		CTimerDelayXms(3);
		
		SET_INPUTSYNC_TYPE(CSyncMeasureSyncType());
		switch (GET_INPUTSYNC_TYPE())
        {
        		case _NO_SYNC_STATE:
				//DebugPrintf("\n SyncHandler (NS) !%c",0x20);							
              			return _FALSE;

            	case _SS_STATE:
            	case _CS_STATE:
            	case _SOG_STATE:
				//DebugPrintf("\n SyncHandler (SS) !%c",0x20);				
				TV_Power_Down();//add by xyw 070903
                		return _TRUE;

		#if(_YPBPR_SUPPORT == _ON)
            	case _SOY_STATE:
 			 #if(_YPBPR_NEW_SYNC_DETECT == _ON)
			 	//DebugPrintf("\n SyncHandler (SOY) !%c",0x20);
				CScalerSetBit(_SYNC_INVERT_48, ~_BIT2,0x00);
  			#endif
				TV_Power_Down();//add by xyw 070903
                		return _TRUE;
		#endif

#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
            		case _DSS_STATE:
#if _DVI_SUPPORT
				if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DVI_I_A0_PORT)
				{
                			SET_INPUTSOURCE_TYPE(_SOURCE_DVI);
				}
				else
#endif
				{
					if(CHdmiFormatDetect())//Input source is the HDMI format.
#if (_TMDS_SUPPORT==_ON||_HDMI_SUPPORT == _ON)
						if(CHdmiFormatDetect())		//Input source is the HDMI format.
							SET_INPUTSOURCE_TYPE(_SOURCE_DVI);
#endif	//endof #if (_HDMI_SUPPORT == _ON)
				}
				TV_Power_Down();//add by xyw 070903
                		return _TRUE;
#endif

            		default:
                		SET_INPUTSYNC_TYPE(_NO_SYNC_STATE);
                		return _FALSE;
        	}
    	}
    	else
    	{
        	switch (GET_INPUTSOURCE_TYPE())
        	{
#if(_YPBPR_SUPPORT == _ON)
            		case _SOURCE_YPBPR:
#endif
            		case _SOURCE_VGA:
                		CScalerSetBit(_SYNC_CTRL_49, ~(_BIT1 | _BIT0), _BIT1);
                		break;

#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
            		case _SOURCE_DVI:
                		CScalerSetBit(_SYNC_CTRL_49, ~(_BIT1 | _BIT0), 0x00);
                		break;
#endif
     	}
 		return _TRUE;
    }
}

/**
 * CSyncMeasureSyncType
 * Measure sync type
 * called only by CSyncHandler
 * identify sync type according to the input source
 * @param <none>
 * @return {sync type we measured}
 *
*/
BYTE CSyncMeasureSyncType(void)
{
	BYTE synctypetemp;

    	switch (GET_INPUTPORT_TYPE(stSystemData.InputSource))
    	{
#if(_YPBPR_SUPPORT == _ON)
        	case _YPBPR_A0_PORT:
#endif
#if 0//(_DTV_SUPPORT == _ON)
        	case _DTV_PORT:
#endif
        	case _DSUB_A0_PORT:
#if(_SCALER_TYPE==_RTD2662)
					if(GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DSUB_A0_PORT)
						CScalerSetBit(_SYNC_SELECT_47, ~(_BIT3 | _BIT2), 0x00);//SOY0 , 1st HS/VS						
					else
						CScalerSetBit(_SYNC_SELECT_47, ~(_BIT3 | _BIT2), (_BIT3 | _BIT2));//SOY1 ,2nd HS/VS	
#else
            		CScalerSetBit(_SYNC_SELECT_47, ~(_BIT3 | _BIT2), 0x00);//reserve to 0
#endif            		

#if(_SCALER_TYPE!=_RTD2662)
		    		CScalerPageSelect(_PAGE0);
					CScalerSetBit(_P0_ADC_CTRL_A1,~_BIT3,_BIT3);//differential input mode
#endif
				//HS_RAW/SOY,source selection
            		CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, ((BYTE)GET_INPUT_HS_SELECTION(stSystemData.InputSource) << 4));
            		synctypetemp    = CSyncSearchSyncTypeVGA();
            		break;

#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
       	case _DVI_PORT:
		case _HDMI_PORT:
		case _HDMI_PORT2:
					//CScalerDigitalPortSwitch();//731301
					//DebugPrintf("\n SM_(HDMI_PORT)%c",0x20);
					synctypetemp = CSyncSearchSyncTypeDVI();
					//DebugPrintf("\n SM_(ssynctypetemp)=%x",synctypetemp);
            		break;

        	case _DVI_I_A0_PORT:
                	synctypetemp = CSyncSearchSyncTypeDVI();
                	if (synctypetemp == _NO_SYNC_STATE)
                	{
                    	CScalerSetBit(_SYNC_SELECT_47, ~(_BIT3 | _BIT2), 0x00);
#if(_SCALER_TYPE!=_RTD2662)
						CScalerPageSelect(_PAGE0);
						CScalerSetBit(_P0_ADC_CTRL_A1,~_BIT3,0x0);
#endif								
                    	CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, ((BYTE)GET_INPUT_HS_SELECTION(stSystemData.InputSource) << 4));
                    	synctypetemp = CSyncSearchSyncTypeVGA();
                	}
            		break;

#endif//(_TMDS_SUPPORT == _ON)

			default:
			break;

	}

#if(_HSYNC_TYPE_DETECTION == _AUTO_RUN)
	if (1)
#endif

#if(_HSYNC_TYPE_DETECTION == _NORMAL_RUN)
        if (synctypetemp != _SS_STATE)
#endif
    	{
        	CAdjustSyncProcessorMeasureStart();

        	if (CTimerPollingEventProc(60, CMiscModeMeasurePollingEvent))
        	{
            		if (CModeMeasureData())
                		CSyncModifyPolarityVGA();
            		else
                		synctypetemp = _NO_SYNC_STATE;
        	}
        	else
            		synctypetemp = _NO_SYNC_STATE;
    	}
	
    	return synctypetemp;
}

/**
 * CSyncSearchSyncTypeVGA
 * Search VGA sync type
 * if the same type is searched for 3 times return sync type
 * @param <none>
 * @return {sync type}
 *
*/
//--------------------------------------------------
// Description  : Search VGA sync type
// Input Value  : None
// Output Value : Return sync type
//--------------------------------------------------
BYTE CSyncSearchSyncTypeVGA(void)
{
	#define _SYNCTYPE_CONFIRM_TIMES   3

    	BYTE synctypeprev, synctypecurr, cnt;

    	cnt = _SYNCTYPE_CONFIRM_TIMES;

    	do
    	{
#if(_HSYNC_TYPE_DETECTION == _NORMAL_RUN)
        	synctypecurr = CSyncGetSyncTypeStepVGA();
#elif(_HSYNC_TYPE_DETECTION == _AUTO_RUN)
       	synctypecurr = CSyncGetSyncTypeAutoRun();
#endif

        	if (cnt == _SYNCTYPE_CONFIRM_TIMES)
        	{
            		synctypeprev = synctypecurr;
            		continue;
        	}

        	if (synctypecurr != synctypeprev)
        	{
            		return _NO_SYNC_STATE;
        	}

    	}
    	while (--cnt);

    	return synctypecurr;

	#undef _SYNCTYPE_CONFIRM_TIMES
}

#if(_HSYNC_TYPE_DETECTION == _NORMAL_RUN)
/**
 * CSyncGetSyncTypeStepVGA
 * Get VGA sync type according to sync detection by detecting registers
 * @param <none>
 * @return {sync type}
 *
*/
BYTE CSyncGetSyncTypeStepVGA(void)
{
    BYTE flag, cnt = 0;

    CScalerPageSelect(_PAGE0);
    CScalerSetByte(_P0_ADC_POWER_AD, 0x18);//DCR  enable,1M

    CScalerSetByte(_VGIP_ODD_CTRL_13, 0x00);
    CScalerSetByte(_YUV2RGB_CTRL_9C, 0x00);//disable YUV->RGB
    CScalerSetBit(_IPH_ACT_WID_H_16, ~(_BIT7 | _BIT3), 0x00);
    CScalerSetBit(_SCALE_CTRL_32, ~_BIT7, 0x00); //disable video compensation
    CScalerSetBit(_SYNC_CTRL_49, ~(_BIT2 | _BIT1 | _BIT0), _BIT2 | _BIT1); // SeHS/DeHS ,ADC_HS/ADC/VS
    CScalerSetBit(_SYNC_INVERT_48, ~(_BIT4 | _BIT2), (_BIT4 | _BIT2));// HS_OUT ,clamp output enable

    if((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT4)) //V304 modify
    {
        CScalerPageSelect(_PAGE0);
        CScalerSetByte(_P0_ADC_TEST_CTRL_AF, 0x04);
    }

    CScalerSetBit(_SYNC_SELECT_47, ~_BIT5, _BIT5);  //Enable De-composite circuit

	// Vsync counter level 384 crystal clocks
    CScalerSetBit(_VSYNC_COUNTER_LEVEL_MSB_4C, ~(_BIT2 | _BIT1 | _BIT0), 0x03);//768Hsync
    CScalerSetByte(_VSYNC_COUNTER_LEVEL_LSB_4D, 0x00);

    do
    {
        CScalerSetBit(_STABLE_MEASURE_4F, ~_BIT0, 0x00);
        CScalerSetBit(_STABLE_MEASURE_4F, ~_BIT0, _BIT0);//Measure start


        if(!CTimerPollingEventProc(20, CMiscStableFlagPollingEvent))
        {
            	if((bit)CScalerGetBit(_HSYNC_TYPE_DETECTION_FLAG_4E, _BIT7))//HS_Overflow
                	return _NO_SYNC_STATE;	//No signal
            	else
                	return _NO_SYNC_STATE;	//Not support
        }

        CScalerSetBit(_STABLE_MEASURE_4F, ~_BIT1, _BIT1);//Pop up stable value

        if(!(bit)CScalerGetBit(_STABLE_MEASURE_4F, _BIT6))//Stable polarity
        {
            	CScalerSetBit(_SYNC_INVERT_48, ~_BIT3, CScalerGetBit(_SYNC_INVERT_48, _BIT3) ^ _BIT3);
            	cnt++;
        }
        else
            	break;

        	if(cnt >= 2)
            		return _NO_SYNC_STATE;
    	}
    	while(_TRUE);

    	CScalerSetByte(_HSYNC_TYPE_DETECTION_FLAG_4E, 0xff);
    	CTimerDelayXms(40);
	flag = CScalerGetBit(_HSYNC_TYPE_DETECTION_FLAG_4E, 0xff);

    	if((bit)(flag & _BIT6) || (bit)(flag & _BIT5) || (bit)(flag & _BIT3))// 1.Stable period chang 2.Stable polarity chang 3.window unlock
        	return _NO_SYNC_STATE;
   	else if((bit)(flag & _BIT1))  // Composite-Sync
   	{
		CScalerSetBit(_SYNC_CTRL_49, ~(_BIT6 | _BIT5 | _BIT2), (_BIT6 | _BIT5 | _BIT2));// 1.DeHS 2.DeVS3..
		if((bit)(flag & _BIT0))	  // Not SOY signal
		{
			CScalerSetBit(_SYNC_INVERT_48, ~(_BIT6 | _BIT1), (_BIT6 | _BIT1));
			if((bit)(flag & _BIT2))
				return _CS_STATE;  //CS with Equalizer
			else
				return _CS_STATE;  //OR-Type & XOR-Type CS
		}
		else
		{
		   	CScalerSetBit(_SYNC_INVERT_48, ~(_BIT6 | _BIT1), 0x00);
			if((bit)(flag & _BIT2))
				return _SOY_STATE;  //YPbPr
			else
#if(_YPBPR_SUPPORT == _ON)
                if((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT4))
                    return _SOY_STATE;
                else
            	    return _CS_STATE;
#else
                return _CS_STATE;
#endif
			}
  	}
  	else    		// Check if Hsync only
 	{
	   	CScalerSetBit(_SYNC_CTRL_49, ~(_BIT6 | _BIT5 | _BIT2), _BIT2);
		CScalerSetBit(_SYNC_SELECT_47, ~_BIT5, 0x00);  //Disable De-composite circuit
    		CAdjustSyncProcessorMeasureStart();
    		if(CTimerPollingEventProc(60, CMiscModeMeasurePollingEvent))
    		{
        		if(CModeMeasureData())
				{
            			CSyncModifyPolarityVGA();
            			return _SS_STATE;
				}
				else
            			return _NO_SYNC_STATE;
		}
		else
        		return _NO_SYNC_STATE;
	}
}
#endif	// End of #if(_HSYNC_TYPE_DETECTION == _NORMAL_RUN)

/**
 * CSyncModifyPolarityVGA
 * Modify VGA sync polarity
 * @param <none>
 * @return {none}
 *
*/
//--------------------------------------------------
// Description  : Modify VGA sync polarity
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CSyncModifyPolarityVGA(void)
{
	BYTE polarity;

	polarity = CScalerGetBit(_VGIP_SIGINV_11, 0xff);
	polarity &= ~(_BIT3 | _BIT2);

	if(!(bit)(stModeInfo.Polarity & _BIT0))
		polarity |= _BIT2;

	if(!(bit)(stModeInfo.Polarity & _BIT1))
		polarity |= _BIT3;

	CScalerSetByte(_VGIP_SIGINV_11, polarity);
}

/**
 * CSyncSearchSyncTypeDVI
 * Search DVI sync type
 * called only by CSyncMeasureSyncType
 * if the same type is searched for 3 times return sync type
 * @param <none>
 * @return {sync type}
 *
*/
//--------------------------------------------------
// Description  : Search DVI sync type
// Input Value  : None
// Output Value : Return sync type
//--------------------------------------------------
#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
BYTE CSyncSearchSyncTypeDVI(void)
{
    	BYTE synctypetemp = _DSS_STATE;
if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT || GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT2)	//hdmi input from dvi port
{
    	//initial DVI register setting add by frank
    	CScalerSetByte(_VGIP_ODD_CTRL_13, 0x00);

       if(!CHdmiFormatDetect())
    		CScalerSetByte(_YUV2RGB_CTRL_9C, 0x00);

    	CScalerSetBit(_IPH_ACT_WID_H_16, ~(_BIT7 | _BIT3), 0x00);
    	CScalerSetBit(_SCALE_CTRL_32, ~_BIT7, 0x00);
    	CScalerSetBit(_VSYNC_COUNTER_LEVEL_MSB_4C, ~_BIT3, 0x00);
}
    	CPowerADCAPLLOff();

	CScalerPageSelect(_PAGE2);
	if(!CSourceScanInputPortDVI((bit)CScalerGetBit(_P2_POWER_ON_OFF_CTRL_A7, _BIT7)))
        	return _NO_SYNC_STATE;

#if(((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON)) && (_DVI_LONG_CABLE_SUPPORT == _ON))
    if(CAdjustTMDSEqualizer() == _FALSE)
        return _NO_SYNC_STATE;
#endif

    	CPowerTMDSOn();	// Measure HS/VS source select as TMDS

    	return synctypetemp;
}
#endif  // End of #if(_TMDS_SUPPORT == _ON)



#if(_HSYNC_TYPE_DETECTION == _AUTO_RUN)
/**
 * CSyncGetSyncTypeAutoRun
 * Get VGA sync type by Hsync Type Detection Auto Run
 * @param <none>
 * @return {sync type}
 *
*/
BYTE CSyncGetSyncTypeAutoRun(void)
{
	BYTE synctemp;

    CScalerPageSelect(_PAGE0);
    CScalerSetBit(_P0_ADC_POWER_C6, ~(_BIT5 | _BIT4 | _BIT3), (_BIT5 | _BIT4 | _BIT3));//ADC RGB power
    CScalerSetBit(_IPH_ACT_WID_H_16, ~_BIT7, 0x00);
    CScalerSetBit(_SCALE_CTRL_32, ~_BIT7, 0x00); //video mode compensation disable
    CScalerSetBit(_SYNC_CTRL_49, ~(_BIT2 | _BIT1 | _BIT0), _BIT2 | _BIT1);// ADC_HS/ADC_VS ,SeHS/DeHS
	CScalerSetByte(_P0_ADC_CLAMP_CTRL1_D5, 0x00);//clamp to black_Low

    if((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT4)) // HS_RAW/SOY source selection
    {    	
    /*20080517**
        if((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT3)) // SOG1/SOY1
            CScalerSetBit(_P0_ADC_SOG_CTRL_D6, ~(_BIT1 | _BIT0), _SOY_RESISTER);// R=500K,10n
        else // SOG0/SOY0
            CScalerSetBit(_P0_ADC_SOG_CTRL_D6, ~(_BIT3 | _BIT2), _SOY_RESISTER);// R=500K,10n
    20080517**/
        if((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT3)) // SOG1/SOY1
           CScalerSetBit(_P0_ADC_SOG_CTRL_D6, ~(_BIT1 | _BIT0), _BIT0);// R=500K,10n
        else // SOG0/SOY0
            CScalerSetBit(_P0_ADC_SOG_CTRL_D6, ~(_BIT3 | _BIT2), _BIT2);// R=500K,10n
    }

	CScalerSetBit(_STABLE_MEASURE_4F, ~_BIT0, 0x00);//Measure- Clear
	CScalerSetBit(_STABLE_MEASURE_4F, ~_BIT0, _BIT0);//Measure- Start

	CTimerDelayXms(5);

	if((bit)CScalerGetBit(_HSYNC_TYPE_DETECTION_FLAG_4E, _BIT7)){// Hsync overflow
		return _NO_SYNC_STATE;
    }
	//eric 20070523 VGA long time wake up 
	CTimerDelayXms(60);
    if(!((bit)CScalerGetBit(_STABLE_MEASURE_4F, _BIT7)))//both polarity and period are stable
        return _NO_SYNC_STATE;
    //if(!CTimerPollingEventProc(60, CMiscStableFlagPollingEvent)){
    //    return _NO_SYNC_STATE;
    //}				

	CScalerSetBit(_STABLE_MEASURE_4F, ~_BIT1, _BIT1);//Pop up result

    // Get stable period
	CScalerRead(_STABLE_PERIOD_H_50, 2, pData, _AUTOINC);
	((WORD *)pData)[1] = ((pData[0] & 0x07) << 8) | pData[1];
	
	if(GET_INPUTSOURCE_TYPE() == _SOURCE_VGA){
    	CScalerSetBit(_VSYNC_COUNTER_LEVEL_MSB_4C, ~(_BIT2 | _BIT1 | _BIT0), (BYTE)(((WORD *)pData)[1] >> 10) & 0x07);
    	CScalerSetByte(_VSYNC_COUNTER_LEVEL_LSB_4D, (BYTE)(((WORD *)pData)[1] >> 2));
	}
	else{
		if(((WORD *)pData)[1]<=0x500)	{
			if((((WORD *)pData)[1]<=0x2D4)&&(((WORD *)pData)[1]>=0x2C9))
			{
				//720P50
				CScalerSetBit(_VSYNC_COUNTER_LEVEL_MSB_4C, ~(_BIT2 | _BIT1 | _BIT0), (BYTE)(((WORD *)pData)[1] >> 8) & 0x07);
    				CScalerSetByte(_VSYNC_COUNTER_LEVEL_LSB_4D, (BYTE)(((WORD *)pData)[1] ));
			}
			else
			{
				//480p (_STABLE_PERIOD=0x6B3)
	    			CScalerSetBit(_VSYNC_COUNTER_LEVEL_MSB_4C, ~(_BIT2 | _BIT1 | _BIT0), (BYTE)(((WORD *)pData)[1] >> 10) & 0x07);
	    			CScalerSetByte(_VSYNC_COUNTER_LEVEL_LSB_4D, (BYTE)(((WORD *)pData)[1] >> 2));				
			}
				
		
		}
		else{
			//480i (_STABLE_PERIOD=0x359)
			CScalerSetBit(_VSYNC_COUNTER_LEVEL_MSB_4C, ~(_BIT2 | _BIT1 | _BIT0), (BYTE)(((WORD *)pData)[1] >> 9) & 0x07);
			CScalerSetByte(_VSYNC_COUNTER_LEVEL_LSB_4D, (BYTE)(((WORD *)pData)[1] >> 1));
		}		
	}	
	
	CScalerSetBit(_STABLE_MEASURE_4F, ~_BIT0, 0x00);//stable measure stop

	CScalerSetBit(_SYNC_SELECT_47, ~_BIT6, 0x00);
	CScalerSetBit(_SYNC_SELECT_47, ~_BIT6, _BIT6);	//Enable hsync type detection auto run

	//DebugPrintf("\n Hs detect auto run%c",0x20);
	//CScalerRead(_VSYNC_COUNTER_LEVEL_MSB_4C, 1, pData, _AUTOINC);
	//DebugPrintf("=%x",pData[0]);
	
	if(CTimerPollingEventProc(90, CMiscHsyncTypeAutoRunFlagPollingEvent)) //auto run ready
	{
		synctemp = (CScalerGetBit(_VSYNC_COUNTER_LEVEL_MSB_4C, 0xff) & 0x70) >> 4;//Measur result
		ucStablePol = ~(CScalerGetBit(_STABLE_PERIOD_H_50, _BIT6) >> 6); //Get Hsync Polarity
#if(_YPBPR_AUTO_SOY == _ENABLE)
		if(GET_INPUTSOURCE_TYPE() == _SOURCE_YPBPR){
			if((synctemp == 0)||(synctemp == 1)){	// No-signal or Not-support			
				SyncLevelOffset++;
				CYPbPrAutoSOY();		// Adjust SOG sync level
			}
		}
#endif
		switch(synctemp)
        	{//eric 20070530
            		case _NO_SIGNAL:		// No Signal
            		case _NOT_SUPPORT:		// Not Support
            		case _HSYNC_WITHOUT_VS: // Hsync only
            			synctemp =_NO_SYNC_STATE;	
				break;						

            		case _YPBPR_SYNC:		// YPbPr-Type CS
            			synctemp =_SOY_STATE;
				break;	

            		case _SERRATION_CS:		// Serration-Type CS
#if(_YPBPR_SUPPORT == _ON)
	#if(_HSYNC_TYPE_SELECT == _HSYNC_WITH_SOG_SOY)
            		if((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT4))
            		{
                		if(CModeMeasureReady())
                		{
                    			if(CModeMeasureData())
                    			{
                        			if((stModeInfo.IHFreq < _H_FREQ_MIN) || (stModeInfo.IHFreq > _H_FREQ_MAX) || (stModeInfo.IVFreq < _V_FREQ_MIN) || (stModeInfo.IVFreq > _V_FREQ_MAX)){
                        				synctemp=_NO_SYNC_STATE;		
							break;			                            			
                        			}
                        			else{                        			
                            			if(CYPbPrSearchMode() != _MODE_NOSUPPORT)
								synctemp=_SOY_STATE;                                				
                            			else
								synctemp =_CS_STATE;				                                				
							break;			
                        			}
                    			}
                		}
                		else{
                			synctemp =_NO_SYNC_STATE;
					break;		        	        		
                		}
            		}
            		else{
            			synctemp =_CS_STATE;
				break;		                		
            		}            
	#else
            		if((GET_INPUTPORT_TYPE(ucSearchIndex) == _A0_YPBPR_PORT) || (GET_INPUTPORT_TYPE(ucSearchIndex) == _A1_YPBPR_PORT))
				synctemp =_SOY_STATE;	                		         					
            		else
				synctemp =_CS_STATE;
			break;                		
            					
	#endif  //End of #if(_HSYNC_TYPE_SELECT == _HSYNC_WITH_SOG_SOY)				
#else
			synctemp =_CS_STATE;
			break;			
#endif

			case _XOR_OR_TYPE_CS_WITH_EQR:		// CS with Equalizer
			case _XOR_OR_TYPE_CS_WITHOUT_EQR:		// OR-Type & XOR-Type CS
				synctemp =_CS_STATE;
				break;				

			case _SEPARATE_HSYNC:		// Separate Sync
				synctemp =_SS_STATE;
				break;				

			default:		// Hsync only
				synctemp =_NO_SYNC_STATE;				
		}

	}
	else
		synctemp =_NO_SYNC_STATE;	
#if(_HSYNC_TYPE_SELECT != _HSYNC_ONLY)
    	if((synctemp != _NO_SYNC_STATE) && ((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT4)))
    	{
        	CScalerRead(_STABLE_HIGH_PERIOD_H_4A, 2, pData, _AUTOINC);
        	stModeInfo.IHSyncPulseCount = ((pData[0] & 0x07) << 8) | pData[1];

        	CScalerRead(_STABLE_PERIOD_H_50, 2, pData, _AUTOINC);
        	stModeInfo.IHCount = ((pData[0] & 0x07) << 8) | pData[1];

        	if(((stModeInfo.IHSyncPulseCount * 7 / stModeInfo.IHCount) != 0) || (stModeInfo.IHSyncPulseCount < 4))
            		synctemp = _NO_SYNC_STATE;

    }
#endif  // End of #if(_HSYNC_TYPE_SELECT != _HSYNC_ONLY)
	return synctemp;	
	
}
#endif	// End of #if(_HSYNC_TYPE_DETECTION == _AUTO_RUN)

#if(_YPBPR_AUTO_SOY == _ENABLE)
void CYPbPrAutoSOY(void)
{
	if((SOGSyncLevel - SyncLevelOffset) < MinSOGSyncLevel)
		SyncLevelOffset = 0;
	CScalerPageSelect(_PAGE0); //_P0_SOG0_CTRL_AB

	//eric 20070530
	#if(_YPBPR_SYNC_SOURCE == _SOG0)	
		CScalerSetByte(_P0_ADC_SOG0_CTRL_D2,SOGSyncLevel - SyncLevelOffset);
	#else
		CScalerPageSelect(_PAGEB);
		CScalerSetByte(_PB_SOYCH0_CFG3_C3,SOGSyncLevel - SyncLevelOffset);
	#endif		
}
#endif