modehandler.c

GM5621原代码

	// Start an auto adjust.


		//Fixed Abort Auto Adjust3 error in HDCP mode issue. 
#if LINE_BUFFER_OVERRUN_CHECK
	#ifdef UserPrefVFStartValue
		if((gmvw_InputFlagsMain & gmd_VIDEO_SRC) || (gmvw_InputWidthMain > PanelWidth))
		{
			if(!gm_CheckLineBufferOverRun())
			{  //Line buffer over run, force Vertical filter to 2 taps.
				gmvb_ExtCusFlags|=gmd_FORCE_VERTICAL_2TAPS;
				gm_ClearRegBitsByte(FILTER_CONTROL, FILTER_MODE_VER |FILTER_MODE_HOR);  //Set Vertical Filter to 2 taps.
				AdjustSharpness();
			}
		}
		else if (UserPrefVFStartValue & UN_SAVE_VFSTART)
		{	//This is un_save mode, it needs to Check Line Buffer over run or not
			UserPrefVFStartValue &= ~UN_SAVE_VFSTART;
			if(!gm_CheckLineBufferOverRun())
			{  //Line buffer over run, force Vertical filter to 2 taps.
				gmvb_ExtCusFlags|=gmd_FORCE_VERTICAL_2TAPS;
				gm_ClearRegBitsByte(FILTER_CONTROL, FILTER_MODE_VER |FILTER_MODE_HOR);  //Set Vertical Filter to 2 taps.
				UserPrefVFStartValue = NO_VALID_VFSTART;
				AdjustSharpness();
			}
			UserPrefVFStartValue |= gm_ReadRegWord(VF_START_OFFSET);
		}
		else if(UserPrefVFStartValue & NO_VALID_VFSTART)
		{		//This mode doesn't have Valid VFSTART value, So, it doesn't need to Check Buffer Over run. Just directly set it to force vertical 2 taps.
				gmvb_ExtCusFlags|=gmd_FORCE_VERTICAL_2TAPS;
				gm_ClearRegBitsByte(FILTER_CONTROL, FILTER_MODE_VER |FILTER_MODE_HOR);  //Set Vertical Filter to 2 taps.		
				AdjustSharpness();
		}
	#else //!UserPrefVFStartValue
		if(!gm_CheckLineBufferOverRun())
		{  //Line buffer over run, force Vertical filter to 2 taps.
			gmvb_ExtCusFlags|=gmd_FORCE_VERTICAL_2TAPS;
			gm_ClearRegBitsByte(FILTER_CONTROL, FILTER_MODE_VER |FILTER_MODE_HOR);  //Set Vertical Filter to 2 taps.
			AdjustSharpness();
		}
	#endif
#endif //LINE_BUFFER_OVERRUN_CHECK

		//DVI doesn't need to do auto.		
	if (B_InputSaveIndex == NonSavedModeLookUpIndex && InputPortArray[gmvb_CurrentPortMain].PowerDev!= gmd_PCD_DVI) 
//	if (B_InputSaveIndex == NonSavedModeLookUpIndex)	
	{																												
		// Not to AUTO-ADJUST even if the mode is not saved one
		#if AUTO_ADJUST_ON_MODE_CHANGE
	      #if THEFT_DETERRENCE_SUPPORT
	         if(TD_State == 2)     //Theft state
            {
   	  			EnableDisplay();
            }
				else
            {
					SystemFlags.AA_SaveModeWhenDone = gmd_TRUE;
					StartAutoAdjust();
            }
			#else
				SystemFlags.AA_SaveModeWhenDone = gmd_TRUE;
				StartAutoAdjust();
			#endif            
		#else
			EnableDisplay();
		#endif
		UpdateModeDependentSettings();

	}
	else
	{
		EnableDisplay();
		msg("Saved mode.",0);
	}

	if (gmvw_InputFlagsMain & gmd_SUB_SAMPLE)
		SendMsg(&OsdQ,MTO_SUBSAMPLE);
	else
		SendMsg(&OsdQ,MTO_VALID_MODE);

	#if !defined(TUCSON) && HDCP_ENABLE_4TH
		if (InputPortArray[gmvb_CurrentPortMain].Port == IP_DVI)
			Hdcp_TimingTransitionToStableEND();           //Reset Hdcp_TimingStable_Count
	#endif

	#if DEBUG_MH && DEBUG_MSG
		msg("Src Width  = %d", 	 gmvw_InputWidthMain);
		msg("Src Height = %d", 	 gmvw_InputHeightMain);
		msg("Src Vfreq  = %dHz", gmvw_InputVFreqMain/10);
		msg("Src HFreq  = %dKHz",  gmvw_InputHFreqMain/10);

		if (gmvw_InputFlagsMain & gmd_SUB_SAMPLE)
			msg("SubSample mode",0);
		if (gmvb_OutputFlags & gmd_V_SHRINK)
			msg("Vertical Shrink Mode",0);
		if (gmvb_OutputFlags & gmd_VSYNC_DIV2)
			msg("Display Vfreq is 1/2 of input Vfreq", 0);
	#endif

	if(gmvw_InputFlagsMain & gmd_INTERLACED)
	{// if source is interlaced, toggle IP_INTERLACE_EN / PHASE_ALT,
	 // this removes potential jitter problem.
			gm_ClearRegBitsByte(IP_CONTROL,		IP_INTERLACE_EN);
			gm_ClearRegBitsByte(FILTER_CONTROL, PHASE_ALT);
			gm_SetRegBitsByte(IP_CONTROL,     	IP_INTERLACE_EN);
			gm_SetRegBitsByte(FILTER_CONTROL, 	PHASE_ALT);
	}

   #ifdef USE_PIXCR_DATAINVIDEO
   gm_AutoColorBalanceMain(); 			// so we can see the pixel levels
//	gm_Print("Data In Video Running",0);
   PixCrDataInVideoLoad(128);
	DIVControl = 1;			// start data in video
   #endif

	return gmd_TRUE;
}


//******************************************************************
// DESCRIPTION 	:	It resets the input port configuration after the
//					mode switch. It setups the DDS Pll & clock divider
//					based on the input sclk frequency,
//					setups the ADC clamp width & start with sclk frequency
//					then reset the auto freerun state caused by the mode switch.
//					This function is called at the beginning of the new mode setup.
// SYNTEX		:	void SetupInputConfig(void)
// PARAMETERS	:	none
// RETURN		:	none
//******************************************************************
static void __near SetupInputConfig(void)
{
	WORD sclkFreq;

	sclkFreq = GetSClkFrequency();

	// setup ADC Clamp Width/Start
	if (InputPortArray[gmvb_CurrentPortMain].PowerDev == gmd_PCD_RGB)
		gm_SetADCClampingWidthMain(sclkFreq);

	// reset AFR if port enable bit says so, but
	// if input is a video source (PAL, NTCS etc.) then don't enable AFR.
	if((InputPortArray[gmvb_CurrentPortMain].AFR_Enable) && !(gmvw_InputFlagsMain & gmd_VIDEO_SRC))
		gm_ResetAutoFreeRun();

}


//******************************************************************
// DESCRIPTION 	:	Enables display after all mode setup has
//					been completed. Also it setups the IFM watch dog
//					register based on the input timing for the new
//					mode switch.
// SYNTEX		:	void EnableDisplay(void)
// PARAMETERS	:	none
// RETURN		:	none
//******************************************************************
static void __near EnableDisplay(void)
{
	gm_SetupIfmWatchdog();

	if(InputPortArray[gmvb_CurrentPortMain].PowerDev == gmd_PCD_RGB )
	{
    #ifdef PHOENIX_U
		StopADCCalibrationISR();
	#endif
		ADCQuickCalibrate();
		StartADCCalibrationISR();
	}
	else
		StopADCCalibrationISR();

	// reset AFR if port enable bit says so, but
	// if input is a video source (PAL, NTCS etc.) then don't enable AFR.
	if((InputPortArray[gmvb_CurrentPortMain].AFR_Enable) && !(gmvw_InputFlagsMain & gmd_VIDEO_SRC))
		gm_ResetAutoFreeRun();
	// turn on display
	gm_DisplayEnable();
#ifdef PHOENIX_U
	// 1114-1
//	gm_PowerUpPanel();	
	gm_ClearRegBitsByte(DISPLAY_CONTROL1, FORCE_BKGND);
	gm_ForceUpdate();
#else
	gm_ClearRegBitsByte(DISPLAY_CONTROL,  FORCE_BKGND);
	gm_ForceUpdate();
#endif
}


//******************************************************************
// DESCRIPTION 	:	Set H/V Start variables if not saved mode. If the
//					mode is in the standard mode table, use the H/V Start
//					in the standard mode table. If it is estimated mode,
//					then calculate H/V start.
//					The H/V start variable is setup from the rising edge of sync,
//					so that it it is positive sync, start = sync width + back porch.
//					Also adjust input HStart if the input is subsample mode.
//					Also minor adjust H/V start	due to zan3 chip delay.
//
//					Note: Made separate function to share with Factory Reset
//					that reset H/V start from the mode table.
// SYNTEX		:	void SetupHVStartVariables(void)
// PARAMETERS	:	none
// RETURN		:	none
//******************************************************************
void SetupHVStartVariables(void)
{
	// if saved mode, ignore this adjustment
	if (B_InputSaveIndex == NonSavedModeLookUpIndex)
	{
		// update H/V start in estimated mode from H/V Total
		if (gmvw_InputFlagsMain & gmd_ESTIMATED)
		{
			// Estimated mode
			// it can be simplified if not checking the sync polarity
			// because it is estimated mode.
			if(gmvw_InputFlagsMain & gmd_NEG_HSYNC)
				gmvw_InputHStartMain = (gmvw_StdHTotal / 8);
			else
				gmvw_InputHStartMain = (gmvw_StdHTotal / 6);

			if(gmvw_InputFlagsMain & gmd_NEG_HSYNC)
				gmvw_InputVStartMain = (gmvw_InputVTotalMain / 32);
			else
				gmvw_InputVStartMain = (gmvw_InputVTotalMain / 32 + 3);

			if (gmvw_InputFlagsMain & gmd_INTERLACED)
				gmvw_InputVStartMain /= 2;
		}
		else
		{
			// Standard mode. Get the H/V start from the standard mode table.
			//gmvw_InputHTotalMain = gmvw_StdHTotal;
			if(gmvw_InputFlagsMain & gmd_NEG_HSYNC)
				gmvw_InputHStartMain = StandardModeTable[ModeTableIndex].StdHBackPorch;
			else
				gmvw_InputHStartMain = StandardModeTable[ModeTableIndex].StdHBackPorch + StandardModeTable[ModeTableIndex].StdHSyncWidth;
	 		if(gmvw_InputFlagsMain & gmd_NEG_VSYNC)
				gmvw_InputVStartMain = StandardModeTable[ModeTableIndex].StdVBackPorch;
			else
				gmvw_InputVStartMain = StandardModeTable[ModeTableIndex].StdVBackPorch + StandardModeTable[ModeTableIndex].StdVSyncWidth;
		}

		// adjust HStart if subsample mode to fit in the right position
		if (gmvw_InputFlagsMain & gmd_SUB_SAMPLE)
		{
			gmvw_InputHStartMain = (WORD)(((DWORD)PanelWidth * gmvw_InputHStartMain) / StandardModeTable[ModeTableIndex].StdWidth);
		}
	}

	// The individual "if" statements below are to make minor changes to
	// image position based on the InputPortArray[].Port
	if (InputPortArray[gmvb_CurrentPortMain].Port == IP_RGB)
	{
		if (gmvw_InputFlagsMain & gmd_VIDEO_SRC)
		{
			gm_WriteRegWord(IPHS_DELAY, 			0x00);
			gm_WriteRegWord(IPH_ACT_START, 		IPHS_ActiveStart);
			gm_WriteRegWord(IPV_ACT_START_ODD, 	0x06);
			gm_WriteRegWord(IPV_ACT_START_EVEN, 0x06);
			msg("IP_RGB * Video Source * ",0);
		}
		else
		{
			gm_WriteRegWord(IPH_ACT_START, 		IPHS_ActiveStart);
			gm_WriteRegWord(IPV_ACT_START_ODD, 	IPVS_ActiveStart);
			gm_WriteRegWord(IPV_ACT_START_EVEN, IPVS_ActiveStart);
			msg("IP_RGB *** ",0);
			#if (SUPPORT_VESA_CVT_MODES)
				if(gmvw_InputFlagsMain & gmd_CVT_MODE_RB)
				{
					WORD verticalBP,VsyncWidth,adjust = 0;
					verticalBP = cvt_getVBP();
					msg("  CVT RB",0);
					if( verticalBP <= 7)
					{
						VsyncWidth = cvt_getVsyncWidth();
						if(VsyncWidth >= 6)
							adjust = 1;
						gm_WriteRegWord(IPV_ACT_START_ODD, 	verticalBP + adjust);
						gm_WriteRegWord(IPV_ACT_START_EVEN, verticalBP + adjust);
					}
				}
			#endif //(SUPPORT_VESA_CVT_MODES)
		}

	}
//	else if (InputPortArray[gmvb_CurrentPortMain].Port == IP_VIDEO_ON_RGB)
	else if (InputPortArray[gmvb_CurrentPortMain].Port == IP_COMPONENT)		
	{
		if (gmvw_InputFlagsMain & gmd_VIDEO_SRC)
		{
#if USE_COMPONENT_INPUT_ON_RGB
//For Component video source, setup H/V position here based on predefine value mode by mode.
			BYTE i=0;
			while(PREDEF_COMPONENT_TBL[i].ModeIndex!=0xff)
				{
					if(PREDEF_COMPONENT_TBL[i].ModeIndex==ModeTableIndex)
					{
						gmvw_InputHStartMain=PREDEF_COMPONENT_TBL[i].HPosition;
						gmvw_InputVStartMain=PREDEF_COMPONENT_TBL[i].VPosition;
						break;
					}
					i++;
				}
#endif			
			gm_WriteRegWord(IPHS_DELAY, 			0x80);
			gm_WriteRegWord(IPH_ACT_START, 		IPHS_ActiveStart);
			gm_WriteRegWord(IPV_ACT_START_ODD, 	0x06);
			gm_WriteRegWord(IPV_ACT_START_EVEN, 0x06);
			msg("IP_VIDEO_ON_RGB * Video Source * ",0);
		}
		else
		{
			gm_WriteRegWord(IPH_ACT_START, 		IPHS_ActiveStart);
			gm_WriteRegWord(IPV_ACT_START_ODD, 	IPVS_ActiveStart);
			gm_WriteRegWord(IPV_ACT_START_EVEN, IPVS_ActiveStart);
			msg("IP_VIDEO_ON_RGB *** ",0);
		}

	}
	else if (InputPortArray[gmvb_CurrentPortMain].Port == IP_VIDEO)
	{
		gmvw_InputHStartMain = 0x00;
		gmvw_InputVStartMain = 0x00;
		gm_WriteRegWord(IPHS_DELAY, 			0x00);
		gm_WriteRegWord(IPH_ACT_START, 		0x18);
		gm_WriteRegWord(IPV_ACT_START_ODD, 	0x06);
		gm_WriteRegWord(IPV_ACT_START_EVEN, 0x06);
		msg("IP_VIDEO *** ",0);
	}
	else
	{// For DVI , IPH_ACTIVE_START and IPHS_DELAY should be zero.
		gmvw_InputHStartMain = 0x00;
		gmvw_InputVStartMain = gm_ReadRegByte(IBD_VSTART);
		gm_WriteRegWord(IPH_ACT_START, 		0x00);
		gm_WriteRegWord(IPV_ACT_START_ODD, 	IPVS_ActiveStart);
		gm_WriteRegWord(IPV_ACT_START_EVEN, IPVS_ActiveStart);
		if (InputPortArray[gmvb_CurrentPortMain].Port == IP_VIDEO_ON_DVI)
			msg("IP_VIDEO_ON_DVI *** ",0);
		else
			msg("IP_DVI *** ",0);
	}
}

//******************************************************************
// DESCRIPTION  : Get the calculated source Pixel clock rate.
//						If input ADC clock is too fast for Genesis device,
//                then use the subsampling methods.
//
// SYNTEX     	 :	void CheckAdcClock(void)
// INPUT        : None
// OUTPUT       : Returns SClk value in 1/10 MHz unit.
//******************************************************************
void CheckAdcClock(void)
{
	WORD pixelRate;

	if (InputPortArray[gmvb_CurrentPortMain].PowerDev != gmd_PCD_RGB)
		return;

	pixelRate = GetSClkFrequency();

	if (pixelRate > MAX_ADC_CLOCK * 10)
	{   
		msg("AdcClockLimit exceeded. Reduce SrcHTotal and Width.  sub-samping. Pixel clock = %d MHz",pixelRate/10);
		gmvw_InputHTotalMain = (WORD)((DWORD) gmvw_InputHTotalM