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

#define __SOURCE__

#include "Core\Header\Include.h"
void CMuxPinSwitchInputSrc(void)
{
#if (_PCB_TYPE==_PCB_PT2662F1A ||_PCB_TYPE==_PCB_PT2662F1C)

#if _TYPEOF_INPUT==_TYPEOF_INPUT_8SRC
	//according to _INPUT_PORT_MAX!!!
	if (stSystemData.InputSource == 4)
	{
		//do other thing while DVD YCBCR is used.
		SET_DVD_POWER(_ON);
		SET_SRC_HW_YPBPR2(); 
	}
	else// if (stSystemData.InputSource == 3)
	{
		SET_DVD_POWER(_OFF);
		SET_SRC_HW_YPBPR1(); 
	}
#else	//#if _TYPEOF_INPUT==_TYPEOF_INPUT_8SRC

	if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_YPBPR_A0_PORT)
	{
		SET_DVD_POWER(_OFF);
		SET_SRC_HW_YPBPR1(); 
	}
#endif	//NOT #if _TYPEOF_INPUT==_TYPEOF_INPUT_8SRC

#endif	//#if _PCB_TYPE==_PCB_PT2662F1A
}
/**
 * CSourceHandler
 * Scan all input port and select active port
 * return TRUE if there is any active port available and selected
 * @param <none>
 * @return {TRUE/FALSE}
 *
*/
bit CSourceHandler(void)
{
	CMuxPinSwitchInputSrc();

	//stSystemData.InputSource = 0;						//provisional 暫定(VGA)
	//SET_INPUTSOURCE_TYPE(_SOURCE_VGA);
	//stSystemData.InputSource = 4;						//provisional 暫定(YPBPR)
	//stSystemData.InputSource = 1;						//provisional 暫定(HDMI)
	//SET_INPUTSOURCE_TYPE(_SOURCE_DVI);		//provisional 暫定(HDMI)
	//stSystemData.InputSource = 2;						//provisional 暫定(AV)

#if(_VGA_DVI_AUTO_SWITCH_SUPPORT == _ON)
	if (GET_SOURCE_AUTOCHANGE())
	{
		if (GET_INPUTSOURCE_TYPE() == _SOURCE_VGA)
		{
			stSystemData.InputSource = _SOURCE_DVI;
			SET_INPUTSOURCE_TYPE(_SOURCE_DVI);
		}
		else if (GET_INPUTSOURCE_TYPE() == _SOURCE_DVI)
		{
			stSystemData.InputSource = _SOURCE_VGA;
			SET_INPUTSOURCE_TYPE(_SOURCE_VGA);
		}
	}
#endif
	if(CSourceScanInputPort())
	{
		return _TRUE;
	}
	return _FALSE;
   /* if (GET_INPUTSIGNAL_AVAILABLE(stSystemData.InputSource))
    {
		return _TRUE;
    }
    return _FALSE;*/
}
/**
 * CSourceScanInputPort
 * Initial input port setting when firmware startup
 * @param <none>
 * @return {none}
 *
*/
void CSourceInitialInputPort(void)
{
#if _DVI_SUPPORT
	BYTE cnt;

	SET_INPUTSYNC_TYPE(_NO_SYNC_STATE);

	for(cnt=0;cnt<_INPUT_PORT_MAX;cnt++)
	{
		CLR_INPUTPORT_SELECT(cnt);
		//CLR_INPUTSIGNAL_AVAILABLE(cnt);
	}

		switch(GET_INPUTPORT_TYPE(stSystemData.InputSource))
		{
			case _DSUB_A0_PORT:
		       	SET_INPUTSOURCE_TYPE(_SOURCE_VGA);
				break;

#if (_HDMI_SUPPORT == _ON)
			case _HDMI_PORT:
			case _HDMI_PORT2:
#endif
#if(_TMDS_SUPPORT == _ON)			
			case _DVI_PORT:
#endif	
#if _DVI_SUPPORT
	#if(_TMDS_SUPPORT == _ON)			
			case _DVI_I_A0_PORT:
	#endif	
#endif
		       	SET_INPUTSOURCE_TYPE(_SOURCE_DVI);
		    		break;
				
			case _YPBPR_A0_PORT:
		       	SET_INPUTSOURCE_TYPE(_SOURCE_YPBPR);
		    		break;
				
			case _VIDEO_AV_PORT:
			case _VIDEO_SV_PORT:

			case _VIDEO_TV_PORT:
			case _VIDEO_YCBCR_PORT:
			case _VIDEO_SCART_PORT:
				SET_INPUTSOURCE_TYPE(_SOURCE_VIDEO8);
				break;
						
		}
#else
	BYTE cnt;

	SET_INPUTSYNC_TYPE(_NO_SYNC_STATE);

	for(cnt=0;cnt<_INPUT_PORT_MAX;cnt++)
	{
		CLR_INPUTPORT_SELECT(cnt);
		//CLR_INPUTSIGNAL_AVAILABLE(cnt);
		switch(GET_INPUTPORT_TYPE(stSystemData.InputSource))
		{
			case _DSUB_A0_PORT:
		       	SET_INPUTSOURCE_TYPE(_SOURCE_VGA);
				break;

#if (_HDMI_SUPPORT == _ON)
			case _HDMI_PORT:
			case _HDMI_PORT2:
#endif
#if(_TMDS_SUPPORT == _ON)			
			case _DVI_PORT:
#endif	
#if _DVI_SUPPORT
		#if(_TMDS_SUPPORT == _ON)			
			case _DVI_I_A0_PORT:
		#endif	
#endif
		       	SET_INPUTSOURCE_TYPE(_SOURCE_DVI);
		    		break;
				
			case _YPBPR_A0_PORT:
				//CTimerDelayXms(20);
		       	SET_INPUTSOURCE_TYPE(_SOURCE_YPBPR);
		    		break;
				
			case _VIDEO_AV_PORT:
			case _VIDEO_SV_PORT:

			//case _VIDEO_TV_PORT:
			case _VIDEO_YCBCR_PORT:
			case _VIDEO_SCART_PORT:
				//SET_AV_VIDEO();
				//CTimerDelayXms(20);
				SET_INPUTSOURCE_TYPE(_SOURCE_VIDEO8);
				break;
			case _VIDEO_TV_PORT:
				//SET_TV_VIDEO();
				//CTimerDelayXms(20);
				SET_INPUTSOURCE_TYPE(_SOURCE_VIDEO8);
				break;
			
		}
    }
#endif
}
/**
 * CSourceScanInputPort
 * Scan if there is an available port
 * Check connect pin and scan all input port to obtain if the signal is available
 * @param <none>
 * @return {none}
 *
*/
bit CSourceScanInputPort(void)
{
	BYTE cnt =stSystemData.InputSource;
	
   	switch (GET_INPUTPORT_TYPE(cnt))
	{
	#if(_YPBPR_SUPPORT == _ON)
        	case _YPBPR_A0_PORT:
		#endif
	#if 0//(_DTV_SUPPORT == _ON)
        	case _DTV_PORT:
	#endif
     		case _DSUB_A0_PORT:
			if (CSourceScanInputPortVGA(_ANALOG_SOURCE_0))
			{
                    		if ((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT4))
				{
                        		SET_INPUT_HS_SELECTION(cnt);
					//DebugPrintf("\n SET_INPUT_HS_SELECTION  %c",'!');
                    		}
                    		else
				{
                        		CLR_INPUT_HS_SELECTION(cnt);
					//DebugPrintf("\n CLR_INPUT_HS_SELECTION  %c",'!');
                    		}
                    		//SET_INPUTSIGNAL_AVAILABLE(cnt);
                    		return _TRUE;
			}
                	else
			{
                		//DebugPrintf("\n Scan fail  %c",'!');
                    		//CLR_INPUTSIGNAL_AVAILABLE(cnt);
                    		return _FALSE;
                	}
                	//break;

#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
		case _DVI_PORT:
			case _HDMI_PORT:
			case _HDMI_PORT2:
				//DebugPrintf("\n _DVI_PORT %c",'!');
				//DebugPrintf("\n CSourceScanInputPort(DVI)...%c",0x20);			
			if (CSourceScanInputPortDVI(_DE_ONLY_OFF))
			{
                		//DebugPrintf("\n AVAILABLE _DE_ONLY_OFF\n",'!');
                    		//SET_INPUTSIGNAL_AVAILABLE(cnt);
                    		return _TRUE;
			}
#if(_DVI_DE_ONLY_SUPPORT == _ON)
			else if (CSourceScanInputPortDVI(_DE_ONLY_ON))
			{
				//SET_INPUTSIGNAL_AVAILABLE(cnt);
				//DebugPrintf("\n AVAILABLE _DE_ONLY_ON\n",'!');
				return _TRUE;
			}
			#endif
                	else
			{
                     	//DebugPrintf("\n non-AVAILABLE %c",'!');
				//CLR_INPUTSIGNAL_AVAILABLE(cnt);
				return _FALSE;
                	}
                	//break;

            	case _DVI_I_A0_PORT:
		#if(_DVI_I_SOURCE_SWITCH_SUPPORT == _ON)
                	if (GET_DVI_I_SOURCE_SWITCH())
		#endif
                	{
				if (CSourceScanInputPortDVI(_DE_ONLY_OFF))
				{
                        		//SET_INPUTSIGNAL_AVAILABLE(cnt);
                        		return _TRUE;
                    		}
		#if(_DVI_DE_ONLY_SUPPORT == _ON)
                    		else if (CSourceScanInputPortDVI(_DE_ONLY_ON))
				{
                        		//SET_INPUTSIGNAL_AVAILABLE(cnt);
                        		return _TRUE;
                    		}
		#endif
                    		else if (CSourceScanInputPortVGA(_ANALOG_SOURCE_0))
				{
                        		if ((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT4))
					{
                           			SET_INPUT_HS_SELECTION(cnt);
                        		}
                        		else
					{
                           			CLR_INPUT_HS_SELECTION(cnt);
                        		}
                        		//SET_INPUTSIGNAL_AVAILABLE(cnt);
                        		return _TRUE;
                    		}
                    		else
				{
	                       	//CLR_INPUTSIGNAL_AVAILABLE(cnt);
	                       	return _FALSE;
                    		}
               	}
		#if(_DVI_I_SOURCE_SWITCH_SUPPORT == _ON)
               	else
			{
               		if (CSourceScanInputPortVGA(_ANALOG_SOURCE_0))
				{
                    			if ((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT4))
					{
                     			SET_INPUT_HS_SELECTION(cnt);
                     		}
                     		else
					{
                            		CLR_INPUT_HS_SELECTION(cnt);
                     		}
                     		//SET_INPUTSIGNAL_AVAILABLE(cnt);
                     		return _TRUE;
                		}
                    		else if (CSourceScanInputPortDVI(_DE_ONLY_OFF))
				{
                     		//SET_INPUTSIGNAL_AVAILABLE(cnt);
                     		return _TRUE;
                    		}
			#if(_DVI_DE_ONLY_SUPPORT == _ON)
                    		else if (CSourceScanInputPortDVI(_DE_ONLY_ON))
				{
                        		//SET_INPUTSIGNAL_AVAILABLE(cnt);
                        		return _TRUE;
                    		}
			#endif
                    		else
				{
                        		//CLR_INPUTSIGNAL_AVAILABLE(cnt);
                        		return _FALSE;
                    		}
                	}
		#endif
                //break;
	#endif//((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))

		default:
				break;
        }
} 


//--------------------------------------------------
// Description  : Scan VGA input port to obtain if the signal is available
// Input Value  : Select analog source 0 or 1
// Output Value : Return _TRUE if the signal is available
//--------------------------------------------------
bit CSourceScanInputPortVGA(BYTE ucAnalogSource)
{
#if(_SCALER_TYPE==_RTD2662)
	BYTE	ucSearchIndex;	
    BYTE cnt, synctypetemp = _NO_SYNC_STATE;;

	//ucSearchIndex = 2;		//provisional 暫定 for VGA
	//ucSearchIndex = 3;		//provisional 暫定 for YPBPR	
	ucAnalogSource = 0;		//provisional 暫定

	if(GET_INPUTSOURCE_TYPE() == _SOURCE_VGA)				//provisional 暫定
		ucSearchIndex = 2;
	else if(GET_INPUTSOURCE_TYPE() == _SOURCE_YPBPR) 
		ucSearchIndex = 3;

	//DebugPrintf("\n CSourceScanInputPortVGA.0.%c",0x20);			
	if(GET_INPUTSOURCE_TYPE() == _SOURCE_VGA)	
		CScalerSetBit(_IPH_ACT_WID_H_16, ~(_BIT6 | _BIT5 | _BIT4), ((_ADC0_INPUT_SWAP_RG << 4) | (_ADC0_INPUT_SWAP_RB << 5)| (_ADC0_INPUT_SWAP_GB << 6)));
	else if(GET_INPUTSOURCE_TYPE() == _SOURCE_YPBPR)
		CScalerSetBit(_IPH_ACT_WID_H_16, ~(_BIT6 | _BIT5 | _BIT4), ((_ADC1_INPUT_SWAP_RG << 4) | (_ADC1_INPUT_SWAP_RB << 5)| (_ADC1_INPUT_SWAP_GB << 6)));

    CScalerPageSelect(_PAGE0);
    if((GET_INPUTPORT_SOURCE(ucSearchIndex) == _INPUTPORT_A0) || (GET_INPUTPORT_SOURCE(ucSearchIndex) == _INPUTPORT_D0)) 
    {
        CScalerSetBit(_SYNC_SELECT_47, ~(_BIT3 | _BIT2), (_HSYNC_SOURCE_SWAP == _OFF ? 0x00 : _BIT3 | _BIT2));
        CScalerSetDataPortBit(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_CLAMP_CTRL2_06, ~(_BIT5 | _BIT4), _BIT5); //off-line ADC clamp Enable
        CScalerSetBit(_P0_ADC_RBG_CTRL_CE, ~_BIT3, 0x00);// ADC input0
        CScalerSetBit(_P0_ADC_I_BAIS0_C7, ~_BIT0, _BIT0);  //SOG0 input MUX
        CScalerSetBit(_P0_ADC_I_BAIS1_C8, ~(_BIT7 | _BIT6), 0x00);
        CScalerSetBit(_P0_ADC_RED_CTL_CF, ~_BIT7, 0x00);//RGB clamp voltage sel
        CScalerSetBit(_P0_ADC_GREEN_CTL_D0, ~_BIT7, 0x00);
        CScalerSetBit(_P0_ADC_BLUE_CTL_D1, ~_BIT7, 0x00);
		//DebugPrintf("\n _INPUTPORT_A0/D0%c",0x20);
    }
    else if((GET_INPUTPORT_SOURCE(ucSearchIndex) == _INPUTPORT_A1) || (GET_INPUTPORT_SOURCE(ucSearchIndex) == _INPUTPORT_D1)) 
    {
        CScalerSetBit(_SYNC_SELECT_47, ~(_BIT3 | _BIT2), (_HSYNC_SOURCE_SWAP == _OFF ? _BIT3 | _BIT2 : 0x00));
        CScalerSetDataPortBit(_SYNC_PROC_ACCESS_PORT_5C, _SYNC_CLAMP_CTRL2_06, ~(_BIT5 | _BIT4), (_BIT5 | _BIT4));
        CScalerSetBit(_P0_ADC_RBG_CTRL_CE, ~_BIT3, _BIT3);
        CScalerSetBit(_P0_ADC_SOG_CTRL_D6, ~(_BIT6 | _BIT5 | _BIT4), 0x00);
        CScalerSetBit(_P0_ADC_RED_CTL_CF, ~_BIT7, _BIT7);
        CScalerSetBit(_P0_ADC_GREEN_CTL_D0, ~_BIT7, _BIT7);
        CScalerSetBit(_P0_ADC_BLUE_CTL_D1, ~_BIT7, _BIT7);
		//DebugPrintf("\n _INPUTPORT_A1/D1%c",0x20);
    }

    CScalerSetBit(_SYNC_CTRL_49, ~(_BIT1 | _BIT0), _BIT1);// ADC_HS/ADC_VS

#if(_YPBPR_SUPPORT == _ON)
    if((GET_INPUTPORT_TYPE(ucSearchIndex) == _A0_YPBPR_PORT) || (GET_INPUTPORT_TYPE(ucSearchIndex) == _A1_YPBPR_PORT))
        CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, _BIT4);//  SOG/SOY
    else
        CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, 0x00);// HS_RAW   
#else
        CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, 0x00);
#endif  // End of #if(_YPBPR_SUPPORT == _ON)


    for(cnt=0;cnt<2;cnt++)
    {
        synctypetemp = CSyncGetSyncTypeAutoRun();

        if(synctypetemp != _NO_SYNC_STATE)
        {
        	  //eric 20070523 	mark dont change source
            //if(synctypetemp == _SOY_STATE)
            //    SET_INPUTSOURCE_TYPE(_SOURCE_YPBPR);
            //else
            //    SET_INPUTSOURCE_TYPE(_SOURCE_VGA);
			//DebugPrintf("\n CSourceScanInputPortVGA.1.%c",0x20);			
            return _TRUE;
        }
#if(_HSYNC_TYPE_SELECT != _HSYNC_ONLY)
        CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, _BIT4);
#endif  // End of #if(_HSYNC_TYPE_SELECT != _HSYNC_ONLY)
    }
	//DebugPrintf("\n CSourceScanInputPortVGA.2.%c",0x20);
		
    CScalerSetBit(_SYNC_SELECT_47, ~_BIT6, 0x00);// manual 
    CScalerSetBit(_STABLE_MEASURE_4F, ~_BIT0, 0x00);
    return _FALSE;

#else

	BYTE cnt, synctypetemp = _NO_SYNC_STATE;

	//set input path
#if 0//(_DTV_SUPPORT== _ENABLE)
	if((GET_INPUTPORT_TYPE(stSystemData.InputSource) == _YPBPR_A0_PORT)||(GET_INPUTPORT_TYPE(stSystemData.InputSource) == _DTV_PORT))
#else
	if(GET_INPUTPORT_TYPE(stSystemData.InputSource) == _YPBPR_A0_PORT)
#endif		
	{
		CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, _BIT4);  // Set SOY/SOG
	}
	else
	{
		CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, 0x00);  // Set Seperate Sync
	}

	if (ucAnalogSource == _ANALOG_SOURCE_0)
	{
    	CScalerSetBit(_SYNC_SELECT_47, ~(_BIT3 | _BIT2), 0x00);		// SOG0/SOY0, 1st HS/VS
#if(_SCALER_TYPE!=_RTD2662)    	
		CScalerPageSelect(_PAGE0);
		CScalerSetBit(_P0_ADC_CTRL_A1,~_BIT3,_BIT3);// differental mode
#endif		
	}

	for (cnt=0;cnt<2;cnt++)//get sync type from reg
	{
#if(_HSYNC_TYPE_DETECTION == _NORMAL_RUN)
       	synctypetemp = CSyncGetSyncTypeStepVGA();
#elif(_HSYNC_TYPE_DETECTION == _AUTO_RUN)
       	synctypetemp = CSyncGetSyncTypeAutoRun();
#endif
		if (((synctypetemp == _CS_STATE) || (synctypetemp == _SOY_STATE)) && ((bit)CScalerGetBit(_SYNC_SELECT_47, _BIT4)))
		{
			CScalerSetBit(_SYNC_SELECT_47, ~_BIT0, 0x00);
			CAdjustSyncProcessorMeasureStart();
			if (CTimerPollingEventProc(60, CMiscModeMeasurePollingEvent))
			{
            	if (CModeMeasureData())
				{
					CScalerSetBit(_STABLE_MEASURE_4F, ~_BIT1, _BIT1);
					CScalerRead(_STABLE_PERIOD_H_50, 2, pData, _AUTOINC);
					((WORD *)pData)[1] = ((pData[0] & 0x07) << 8) | pData[1];
							//DebugPrintf("\n IHSyncPulseCount %x",(stModeInfo.IHSyncPulseCount &0xff00)>>8);
							//DebugPrintf("  %x",stModeInfo.IHSyncPulseCount & 0x00ff);
							//DebugPrintf("\n IHCount %x",(stModeInfo.IHCount & 0xff00)>>8);
							//DebugPrintf("  %x",stModeInfo.IHCount & 0x00ff);
							//DebugPrintf("\n pData)[1] %x",(pData[1] &0xff00)>>8);
							//DebugPrintf("  %x",pData[1]& 0x00ff);
                    if (((stModeInfo.IHSyncPulseCount * 7 / stModeInfo.IHCount) != 0)
						|| (stModeInfo.IHSyncPulseCount < 4) || (abs(stModeInfo.IHCount - ((WORD *)pData)[1]) > 4))
                    {
                    	return _FALSE;
                    }
                }
                else
				{
          			return _FALSE;
                }
            }
            else
			{
				return _FALSE;
            }
        }
        if (synctypetemp != _NO_SYNC_STATE)
		{
        	return _TRUE;
        }
   	}
  	return _FALSE;
#endif
		
}

/**
 * CSourceScanInputPortDVI
 * Scan DVI input port to obtain if the signal is available
 * @param <BYTE ucPar> {_DE_ONLY_OFF or _DE_ONLY_ON}
 * @return {_TRUE if the signal is valid and in freq range,_FALSE if not}
 *
*/
#if(_TMDS_SUPPORT == _ON || _HDMI_SUPPORT == _ON)
bit CSourceScanInputPortDVI(BYTE ucPar)
{
	BYTE cnt0, cnt1;

	CScalerPageSelect(_PAGE2);
	CScalerRead(_P2_HDMI_SR_CB, 1, &pData[0], _NON_AUTOINC);
	CScalerRead(_P2_TMDS_CTRL_A4, 1, &pData[1], _NON_AUTOINC);

	/*
	if((pData[0]&0x40)&& (pData[1]&0xF8))
	{
		ucHdmiAVMuteCnt++;
		if(ucHdmiAVMuteCnt == 20)
		{
			CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_SCR_00, ~(_BIT3 | _BIT2), _BIT3);//Set HDMI/DVI switch mode(manual,DVI)//Alanli20070801
			CTimerDelayXms(200);
			CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_SCR_00, ~(_BIT3 | _BIT2), 0x00);//Set HDMI/DVI switch mode(auto)
			ucHdmiAVMuteCnt = 0;
		}
		return _FALSE;	
	}
	*/
	if (0)//((pData[0]&0x40)&& (pData[1]&0xF8))
	{
		ucHdmiAVMuteCnt++;
		if(ucHdmiAVMuteCnt == 20)
		{
			CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_SCR_00, ~(_BIT3 | _BIT2), _BIT3);//Set HDMI/DVI switch mode(manual,DVI)//Alanli20070801
			CTimerDelayXms(200);
			CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_SCR_00, ~(_BIT3 | _BIT2), 0x00);//Set HDMI/DVI switch mode(auto)
			ucHdmiAVMuteCnt = 0;
			//DebugPrintf("\n*******set HDMI/DVI sw auto********\n",1);			
		}
		return _FALSE;	
	}


	//DebugPrintf("\n not return %d",1);			

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

	CScalerPageSelect(_PAGE2);
	CScalerSetBit(_SYNC_CTRL_49, ~(_BIT1 | _BIT0), 0x00);		//sync : 0=TMDS, 1=v8/v16,2=AHS/ADCVS,3=CS_RAW/VS_RAW

	//CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT1 | _BIT0), _BIT1 | _BIT0);	//ch0/ch1 Z0 ON/OFF: 1=ON
	//20080421, HDMI update RT080321. start...
	if(GET_INPUTPORT_TYPE(stSystemData.InputSource) == _HDMI_PORT) 
    		CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT1 | _BIT0),  _BIT0);	//ch0 Z0 ON/OFF: 1=ON
	else if(GET_INPUTPORT_TYPE(stSystemData.InputSource) == _HDMI_PORT2) 
		CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT1 | _BIT0), _BIT1 );	//ch1 Z0 ON/OFF: 1=ON
	else
		CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT1 | _BIT0), _BIT1 | _BIT0);	//ch0/ch1 Z0 ON/OFF: 1=ON
	CTimerDelayXms(100);	
	//20080421, HDMI update RT080321. end...

	CScalerSetBit(_P2_UP_DOWN_CTRL0_B5, ~(_BIT7), _BIT7);


#if _DVI_SUPPORT
	if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DVI_I_A0_PORT)
	{
//DebugPrintf("\n DVI setting...\n", 0);
		CScalerSetBit(_IPH_ACT_WID_H_16, ~_BIT3, _BIT3);	//TMDS/Video8 switch: 1 for TMDS											//TMDS/Video8:TMDS
		CScalerSetBit(_P2_TMDS_MEAS_RESULT0_A2, ~_BIT1, _BIT1);	// 2D ch: 0 for D1								// 2D:D0
		CScalerSetBit(_P2_HDCP_PORT_CTRL_C2, ~_BIT1, _DDC_CHANNEL_FOR_D1<<1);   	//_DDC3 
		CScalerSetBit(_P2_POWER_ON_OFF_CTRL_A7, ~(_BIT6 | _BIT5), 0x00);   
		
		#if(_FIX_HDMI_ERROR)
		CScalerSetBit(_P2_HDCP_CTRL_C0, ~_BIT0, _BIT0);	//HDCP enable:
		#else
              CScalerSetBit(_P2_HDCP_CTRL_C0, ~_BIT0, 0x00);	//HDCP enable:
		#endif
	}
	else
#endif	//#if _DVI_SUPPORT
	{
		if (GET_INPUTPORT_TYPE(stSystemData.InputSource) == _HDMI_PORT)
		{
			CScalerSetBit(_IPH_ACT_WID_H_16, ~_BIT3, _BIT3);			//TMDS/Video8 switch: TMDS
			CScalerSetBit(_P2_TMDS_MEAS_RESULT0_A2, ~_BIT1, 0x00);	// 2D:D0
			CScalerSetBit(_P2_HDCP_PORT_CTRL_C2, ~_BIT1, _DDC_CHANNEL_FOR_D0<<1);   	//_DDC2    
			CScalerSetBit(_P2_POWER_ON_OFF_CTRL_A7, ~(_BIT6 | _BIT5), _BIT6| _BIT5);   //R/B swap & P/N Swap    
			CScalerSetBit(_P2_HDCP_CTRL_C0, ~_BIT0, _BIT0);			//auto enable HDCP function
		}
		else if (GET_INPUTPORT_TYPE(stSystemData.InputSource) == _HDMI_PORT2)
		{
			CScalerSetBit(_IPH_ACT_WID_H_16, ~_BIT3, _BIT3);			//TMDS/Video8 switch: TMDS
			CScalerSetBit(_P2_TMDS_MEAS_RESULT0_A2, ~_BIT1, _BIT1);	// 2D:D1
			CScalerSetBit(_P2_HDCP_PORT_CTRL_C2, ~_BIT1, _DDC_CHANNEL_FOR_D1<<1);   	//_DDC3    
			CScalerSetBit(_P2_POWER_ON_OFF_CTRL_A7, ~(_BIT6 | _BIT5), _BIT6| _BIT5);   //R/B swap & P/N Swap    
			CScalerSetBit(_P2_HDCP_CTRL_C0, ~_BIT0, _BIT0);			//auto enable HDCP function
		}
	}

#endif	//#if(_SCALER_TYPE==_RTD2662)

	CScalerPageSelect(_PAGE2);

   	if(ucPar == _DE_ONLY_ON)
		CScalerSetBit(_P2_POWER_ON_OFF_CTRL_A7, ~_BIT7, _BIT7);	//Generate VS/HS from DE signal: 1=enable
	else
		CScalerSetBit(_P2_POWER_ON_OFF_CTRL_A7, ~_BIT7, 0x00);
	
    CTimerDelayXms(25+50);//HDMI debug 080322
	
	CScalerRead(_P2_UP_DOWN_CTRL1_B6, 1, pData, _NON_AUTOINC);

	//DebugPrintf("\n_P2_UP_DOWN_CTRL1_B6 = 0x%x\n", pData[0]);//080322 delay for HDMI must review
	
	pData[0] &= 0xf0;
	
	if(pData[0] == 0xe0)
		CScalerSetByte(_P2_RGB_PLL_SETTING_AE, 0x24);
	else if((pData[0] == 0x80) | (pData[0] == 0x60) | (pData[0] == 0x10))
		CScalerSetByte(_P2_RGB_PLL_SETTING_AE, 0x2c);
	else if((pData[0] == 0x40) | (pData[0] == 0x30))
		CScalerSetByte(_P2_RGB_PLL_SETTING_AE, 0x30);
	else
		return _FALSE;	

	if(pData[0] == 0xe0)
		CScalerSetByte(_P2_ADAPTIVE_EQUALIZER2_B8, 0x01);
	else
		CScalerSetByte(_P2_ADAPTIVE_EQUALIZER2_B8, 0x00);

	CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT3 | _BIT2), 0x00);
	CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT6 | _BIT5 | _BIT4), _BIT6 | _BIT5 | _BIT4);	

	for(cnt0=0;cnt0<2;cnt0++)
	{
		for(cnt1=0;cnt1<2;cnt1++)
		{
			CScalerSetByte(_P2_TMDS_CTRL_A4, 0xf8);

			#if _DVI_SUPPORT

			if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DVI_PORT)//reduce detect time to avoided KEY response slowly.  add by xyw 070810
			{
                             //CTimerDelayXms(25+100); 
				 CTimerDelayXms(25);                           //
			}
			else
			       CTimerDelayXms(25);  
			#else
			//CTimerDelayXms(25+25); 
			CTimerDelayXms(25+50);//CTimerDelayXms(25); //HDMI debug 080322
			#endif

			CScalerRead(_P2_TMDS_CTRL_A4, 1, pData, _NON_AUTOINC);

			if(ucPar == _DE_ONLY_ON)
				pData[0] = ((pData[0] & 0xe0) == 0xe0) ? _TRUE : _FALSE;
			else
				pData[0] = ((pData[0] & 0xf8) == 0xf8) ? _TRUE : _FALSE;

			//DebugPrintf("\_P2_TMDS_CTRL_A4 = 0x%x\n", pData[0]);//080322 delay for HDMI must review
			CTimerDelayXms(10);
			if (pData[0])
			{
				CScalerRead(_P2_UP_DOWN_CTRL1_B6, 1, pData, _NON_AUTOINC);
				pData[0] &= 0xf0;

				//DebugPrintf("\n_P2_UP_DOWN_CTRL1_B6 = 0x%x\n", pData[0]);
				CTimerDelayXms(10);
				if((pData[0] == 0xe0) || (pData[0] == 0x80) || (pData[0] == 0x60) || (pData[0] == 0x40) || (pData[0] == 0x30))
				{
#if _DVI_SUPPORT
					if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DVI_I_A0_PORT)
					{
						if(CHdmiFormatDetect())
							return _FALSE;

						//DebugPrintf("\n! CHdmiFormatDetect()\n", 0);
						return _TRUE;
					}
					else
#endif
					{
			#if(_HDMI_SUPPORT == _ON)
	 					if(CHdmiFormatDetect())
						{
							if(!CHdmiVideoSetting())
								return _FALSE;
						}
						else
							CHdmiVideoSetting();
			#else
						if(CHdmiFormatDetect())
							return _FALSE;
			#endif
						return _TRUE;
					}
				}
			}
#if(_HDMI_SUPPORT == _ON)
			if(!CHdmiFormatDetect())
#endif
				CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT3 | _BIT2), _BIT2);
		}

		CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT6 | _BIT5 | _BIT4), _BIT4);
		CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT3 | _BIT2), 0x00);
	}

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