sync.c

RTD2662板卡源代码

//----------------------------------------------------------------------------------------------------
// 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 (ucCurrState) 
	{	
	case _SEARCH_STATE:
		if (CSyncHandler())
		{
			// Source and sync OK
			if (CModeDetect()) 
			{
				if (stModeInfo.ModeCurr == _MODE_NOSIGNAL)
				{
					ucCurrState = _NOSIGNAL_STATE;
				#if (_HDMI_SUPPORT == _ON)
					if(CHdmiFormatDetect() && (_GET_INPUT_SOURCE() == _SOURCE_DVI || _GET_INPUT_SOURCE() == _SOURCE_HDMI)
                   && ( ucHdmiTimerEvent ==0 || ucHdmiTimerEvent == _INACTIVE_COUNTDOWN_EVENT))//741001
						ucHdmiTimerEvent = _HDMI_NO_SIGNAL_CHECK_CNT;//741001
				#endif
				//	SET_READYFORDISPLAY();
				}
				else if (stModeInfo.ModeCurr == _MODE_NOSUPPORT)
				{
					CModeAutoMeasureOn();
					ucCurrState = _NOSUPPORT_STATE;
				}
				else		//make sure input soure OK and display mode
				{
                    CPowerLightPowerOff();
					if(!CModeDisplayActiveMode())
					{
						CModeResetMode();
						break;
					}
					CModeAutoMeasureOn();
			#if(_HDMI_SUPPORT == _ON)
					if(CHdmiFormatDetect() && (_GET_INPUT_SOURCE() == _SOURCE_DVI || _GET_INPUT_SOURCE() == _SOURCE_HDMI))		//Input source is the HDMI format.
					{
						CHdmiAudioFirstTracking();
						CTimerReactiveTimerEvent(SEC(1), CHdmiAudioWaitingFlagReadyEven);
						ucHdmiTimerEvent = _HDMI_CHECK_CNT;
					}
					else
					{							
					//	SET_READYFORDISPLAY();
					}

			#else
				//	SET_READYFORDISPLAY();
			#endif
					SET_READYFORDISPLAY();
					CTimerCancelTimerEvent(CModeNoSignalEvent);
					CTimerCancelTimerEvent(CModeNoCableEvent);
					CTimerCancelTimerEvent(CModeNoSupportEvent);
					CTimerCancelTimerEvent(CModePowerSavingEvent);
					ucCurrState = _ACTIVE_STATE;				
				}
			}
			else
			{
				if (CHdmiFormatDetect() && (_GET_INPUT_SOURCE() == _SOURCE_DVI || _GET_INPUT_SOURCE() == _SOURCE_HDMI))//for Philips DVD
					CTimerDelayXms(50);//for Philips DVD
			}
			ucTimerEvent = _INACTIVE_COUNTDOWN_EVENT;
		}
		else 
		{
		#if(_HDMI_SUPPORT == _ON)
			if(_GET_INPUT_SOURCE() == _SOURCE_DVI || _GET_INPUT_SOURCE() == _SOURCE_HDMI)
				CTimerCountDownEventProc(&ucTimerEvent, 40,	CModeSyncTimeoutCountDownEvent);	
			else
				CTimerCountDownEventProc(&ucTimerEvent, 5,	CModeSyncTimeoutCountDownEvent);
		#else
				CTimerCountDownEventProc(&ucTimerEvent, 5,	CModeSyncTimeoutCountDownEvent);					
		#endif
		}
		break;

	case _ACTIVE_STATE:
		// For VGA, DVI, input*/
	  	if (CFrameSyncDetect())
		{
	  		//fram sync unstable
	  		CModeResetMode();
			break;
	  	}
		else
		{
			#if (_HDMI_HOT_PLUG_OPTION == _ENABLE)	
             	//eric 20070326 philips DVD player
		  		CModeHDMIStableConfirm();
		  	#endif	
         	if(CModeIsChange())
			{					
                if(_GET_INPUT_SOURCE() == _SOURCE_YPBPR)
                   CMuteOn();
			
			#if (_HDMI_HOT_PLUG_OPTION == _ENABLE)
					CModeHDMIChageDelay();
			#endif		
				CModeResetMode();
				break;
            }
            else
			{
#if(_HDMI_SUPPORT == _ON)
				if(_GET_INPUT_SOURCE() == _SOURCE_DVI || _GET_INPUT_SOURCE() == _SOURCE_HDMI)
				{
            		if(CHdmiFormatDetect())		//Input source is the HDMI format.
            		{
            			if(!GET_HDMIINPUT()) 
						{	
               				CModeResetMode();	
							break;
               			}
                		else
						{
                			//if(GET_AUDIOWAITINGTIMEOUT())  // Eric Lee mark for hdmi audio delay output
                				CHdmiEnableAudioOutput();
                		}
               	 	}
                	else
					{
                		if(GET_HDMIINPUT())
						{
                			CModeResetMode();			
							break;
                    	}
                	}
				}
#endif
                CSetModeReady();
         	}
	  	}

		break;
		
	case _NOSUPPORT_STATE:
		if (GET_READYFORDISPLAY() == _TRUE) 
		{
			CLR_READYFORDISPLAY();
            SET_OSD_READYFORDISPLAY(); 
			CModeSetFreeRun();
			CAdjustBackgroundColor(0xff, 0x00, 0x00);
		}
		if (CModeConnectIsChange() || CModeIsChange())
			CModeResetMode();
		break;
		
	case _NOSIGNAL_STATE: 
	#if (_HDMI_HOT_PLUG_OPTION == _ENABLE)	
		if(GET_READYFORDISPLAY())
			if (GET_INPUTSOURCE_TYPE() == _SOURCE_HDMI) 
			{
				CModeHdmiHP();
			}
	#endif
		if (!GET_SHOW_NO_SIGNAL()) 
		{
			SET_SHOW_NO_SIGNAL();
			CModeSetFreeRun();
            SET_OSD_READYFORDISPLAY();

        }   
                                           
		ucInputSyncType = _NO_SYNC_STATE;
		CLR_MODESTABLE();
	//	ucCurrState = _SEARCH_STATE;	
		if ((CModeConnectIsChange() || CSourceHandler()) && !bSourceVideo())
		{
			CPowerLenOn();
			CModeResetMode();
		}
		break;

	case _SLEEP_STATE:
		if ((CModeConnectIsChange() || CSourceHandler()) && !bSourceVideo())
		{
			CPowerLenOn();
			CModeResetMode();
		}
		break;

	default:
		break;
	}
}

//--------------------------------------------------
void CSetModeReady(void)
{
#if (_HDMI_SUPPORT == _ON)
	if(CHdmiFormatDetect() && (_GET_INPUT_SOURCE()==_SOURCE_DVI || _GET_INPUT_SOURCE() == _SOURCE_HDMI))
	{			
        CPowerPanelOn();
		if (GET_LIGHTPOWERSTATUS() == _OFF) 
		{
            CPowerLightPowerOn();
            SET_OSD_READYFORDISPLAY(); 
		}
		if(ucHdmiTimerEvent == _HDMI_CHECK_CNT)
		{
            CScalerSetBit(_VDISP_CTRL_28, ~(_BIT5), (0x00));
			CLR_READYFORDISPLAY();
			CLR_SOURCE_AUTOCHANGE();
		#if(_OD_SUPPORT == _ON)
			CMemorySetODCompress();
			CMemorySetODFIFO();
			CMemorySetODOnOff(_ON);
		#endif
			CScalerPageSelect(_PAGE2);
			CScalerSetDataPortBit(_P2_HDMI_ADDR_PORT_C9, _P2_HDMI_VWDSR_41, ~_BIT0, _BIT0);//Enable packet variation Watch Dog
			CAdjustEnableWatchDog(_WD_DV_TIMEOUT|_WD_FRAMESYNC);			
			ucHdmiTimerEvent--;
		}
		else if(ucHdmiTimerEvent == 0)
		{
			CModeHDMITimeoutCountDownEvent();
			ucHdmiTimerEvent =_INACTIVE_COUNTDOWN_EVENT;
		}
		else if(ucHdmiTimerEvent ==_INACTIVE_COUNTDOWN_EVENT)
		{
			return;
		}					
		else
		{
			ucHdmiTimerEvent--;
			CTimerDelayXms(50);
		}	
	}			
	else
	{
		if (GET_READYFORDISPLAY() == _TRUE) 
		{
            CScalerSetBit(_VDISP_CTRL_28, ~(_BIT5), (0x00));
			CLR_READYFORDISPLAY();
			CLR_SOURCE_AUTOCHANGE();
		#if(_OD_SUPPORT == _ON)
			CMemorySetODCompress();
			CMemorySetODFIFO();
			CMemorySetODOnOff(_ON);
		#endif
            CPowerPanelOn();
			if (GET_LIGHTPOWERSTATUS() == _OFF) 
			{
                CPowerLightPowerOn();
			}
		#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_INPUT_SOURCE() == _SOURCE_YPBPR)
				CAdjustEnableWatchDog(_WD_DV_TIMEOUT | _WD_FRAMESYNC);	// not to watch APLL mis-Lock,hill 20070417
			else
		#endif		
				CAdjustEnableWatchDog(_WD_ALL);
			
            SET_OSD_READYFORDISPLAY(); 
            if (GET_FIRST_SHOW_NOTE())
               ucOsdEventMsg = _DO_SHOW_NOTE;

		}
		if ((stModeUserData.FirstAuto == 0) &&   ///!do auto config when go to vga first time
			(_GET_INPUT_SOURCE() == _SOURCE_VGA)) 
		{
			stModeUserData.FirstAuto = 1;
		}
	}
#else
	if (GET_READYFORDISPLAY() == _TRUE) 
	{
        CScalerSetBit(_VDISP_CTRL_28, ~(_BIT5), (0x00));
		CLR_READYFORDISPLAY();
		CLR_SOURCE_AUTOCHANGE();
	#if(_OD_SUPPORT == _ON)
		CMemorySetODCompress();
		CMemorySetODFIFO();
		CMemorySetODOnOff(_ON);
	#endif
        CPowerPanelOn();
		if (GET_LIGHTPOWERSTATUS() == _OFF) 
		{
            CPowerLightPowerOn();
		}

		CAdjustEnableWatchDog(_WD_ALL);
        SET_OSD_READYFORDISPLAY(); 
        if (GET_FIRST_SHOW_NOTE())
           ucOsdEventMsg = _DO_SHOW_NOTE;   
          
	}
	if ((stModeUserData.FirstAuto == 0) &&   ///!do auto config when go to vga first time
		(_GET_INPUT_SOURCE() == _SOURCE_VGA)) 
	{
		stModeUserData.FirstAuto = 1;
	}
#endif
}

//--------------------------------------------------
// Description  : Measure sync type
// Input Value  : None
// Output Value : Return _TRUE if succeed
//--------------------------------------------------
bit CSyncHandler(void)
{
	if (ucInputSyncType == _NO_SYNC_STATE)
	{
  		if (!CSourceHandler())   //input Source not exist
		{
			ucInputSyncType = _NO_SYNC_STATE;
			return _FALSE;
		}
		
		CTimerDelayXms(3);
		
		ucInputSyncType = CSyncMeasureSyncType();
		switch (ucInputSyncType)
		{
		case _NO_SYNC_STATE:
			return _FALSE;
			
		case _SS_STATE:
		case _CS_STATE:
		case _SOG_STATE:
			return _TRUE;
			
#if(_YPBPR_SUPPORT == _ON)
		case _SOY_STATE:
#if(_YPBPR_NEW_SYNC_DETECT == _ON)
			CScalerSetBit(_SYNC_INVERT_48, ~_BIT2,0x00);
#endif
			return _TRUE;
#endif
			
#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
		case _DSS_STATE:
			if(CHdmiFormatDetect())//Input source is the HDMI format.
#if (_HDMI_SUPPORT == _ON)
				if(CHdmiFormatDetect())		//Input source is the HDMI format.
                {
                    if (0)//_GET_INPUT_SOURCE() != _SOURCE_HDMI)
                    {
                        _SET_INPUT_SOURCE(_SOURCE_HDMI);
                        CModeResetMode();
                    }
                }
				//	_SET_INPUT_SOURCE(_SOURCE_DVI);
#endif
				return _TRUE;
#endif
				
		default:
			ucInputSyncType = _NO_SYNC_STATE;
			return _FALSE;
		}
	}
	else
	{
		switch (_GET_INPUT_SOURCE())
		{
#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:
        case _SOURCE_HDMI:
			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 (CGetSourcePortType(_GET_INPUT_SOURCE()))
	{
#if(_YPBPR_SUPPORT == _ON)
	case _YPBPR_A0_PORT:
#endif
	case _DSUB_A0_PORT:
	//	if(CGetSourcePortType(_GET_INPUT_SOURCE()) == _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	
		
		//HS_RAW/SOY,source selection
		CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, ((BYTE)bHsyncSelection << 4));
		synctypetemp    = CSyncSearchSyncTypeVGA();
		break;
		
#if(_YPBPR_SUPPORT == _ON)
	case _YPBPR_A1_PORT:
#endif
	case _DSUB_A1_PORT:
	//	if(CGetSourcePortType(_GET_INPUT_SOURCE()) == _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	
		
		//HS_RAW/SOY,source selection
		CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, ((BYTE)bHsyncSelection << 4));
		synctypetemp    = CSyncSearchSyncTypeVGA();
		break;
		
#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))
	case _DVI_PORT:
	case _HDMI_PORT:
    case _DVI_D0_PORT:
    case _DVI_D1_PORT:
    case _HDMI_D0_PORT:
    case _HDMI_D1_PORT:
		synctypetemp = CSyncSearchSyncTypeDVI();
		break;
		       /*
	case _DVI_I_A0_PORT:
		synctypetemp = CSyncSearchSyncTypeDVI();
		if (synctypetemp == _NO_SYNC_STATE)
		{
			CScalerSetBit(_SYNC_SELECT_47, ~(_BIT3 | _BIT2), 0x00);
			CScalerSetBit(_SYNC_SELECT_47, ~_BIT4, ((BYTE)bHsyncSelection << 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;