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

#define __SCALER__

#include "Core\Header\Include.h"

//--------------------------------------------------
// Description  : Get bytes from selected register in data port
// Input Value  : ucAddr    --> Access Port Address of register
//                ucValue   --> Data Port Address we want to Get
//                ucLength  --> Numbers of data we want to read
//                pArray    --> Pointer of the reading data array
//                bAutoInc  --> Address auto increasing select
// Output Value : None
//--------------------------------------------------

void CScalerGetDataPortByte(BYTE ucAddr, BYTE ucValue, BYTE ucLength, BYTE *pArray, BIT bAutoInc)
{
    if(ucLength > 0)
    {
#if(_SCALER_TYPE==_RTD2662)
        if((ucAddr == _SU_ACCESS_PORT_33) || (ucAddr == _HW_ACCESS_PORT_60) 
        || (ucAddr == _CB_ACCESS_PORT_64) || (ucAddr == _PC_ACCESS_PORT_9A))
#else
        if((ucAddr == _SD_ACCESS_PORT_24) || (ucAddr == _SU_ACCESS_PORT_33) ||
           (ucAddr == _HW_ACCESS_PORT_60) || (ucAddr == _CB_ACCESS_PORT_64) ||
           (ucAddr == _PC_ACCESS_PORT_9A) || (ucAddr == _CMDI_ACCESS_PORT_F0))
#endif           
        {
            CScalerSetByte(ucAddr, 0x80);
            ucValue = ucValue | 0x80;
        }

        CScalerSetByte(ucAddr, ucValue);
        CScalerRead( ucAddr + 1, ucLength, pArray, bAutoInc);
    }
}

//--------------------------------------------------
// Description  : Initial settings for scaler
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerInitial(void)
{
    // Software reset for scaler
    CScalerSetBit(_HOST_CTRL_01, ~_BIT0, _BIT0);
    CTimerDelayXms(20);
    CScalerSetBit(_HOST_CTRL_01, ~_BIT0, 0x00);
    CModeResetCustomer(); //tommy add for prevent press power_key can't reponse when first powe up
//Alanli20070801***	
	//CScalerCodeW(tSCALER_POWERUP_INITIAL);
	CScalerCodeW_tSCALER_POWERUP_INITIAL();
#if(_YPBPR_HW_AUTO_SOY == _ENABLE)
#if 0
	CScalerPageSelect(_PAGE0);
	CScalerRead(_P0_ADC_DCR_CTRL_D3, 2, pData, _AUTOINC);
	DebugPrintf("\n _P0_ADC_DCR_CTRL_D3=%x  ",pData[0]);
	DebugPrintf("\n _P0_ADC_CLAMP_CTRL0_D4=%x  ",pData[1]);
	CScalerPageSelect(_PAGEB);
	CScalerSetByte(0xC2,0x86);
	CTimerDelayXms(10);
	CScalerSetByte(0xC5,0x06);
	CTimerDelayXms(10);
	CScalerSetByte(0xC8,0x10);
	CTimerDelayXms(10);
	CScalerSetByte(0xC9,0x00);
	CTimerDelayXms(10);	
	CScalerSetByte(0xC4,0x40);
	CTimerDelayXms(10);
	CScalerSetByte(0xC3,0xA0);
	CTimerDelayXms(10);
	CScalerSetByte(0xC4,0x48);
	CTimerDelayXms(10);	
#else
	CYPbPrHWAutoSOY();
#endif
#endif

#if (_HDMI_SUPPORT == _ON)
	//if(CHdmiFormatDetect())//Input source is the HDMI format.
	//CScalerCodeW(tSCALER_POWERUP_HDMI);
	CScalerCodeW_tSCALER_POWERUP_HDMI();
	//else//DVI
#else
	CScalerCodeW(tSCALER_POWERUP_DVI);
#endif	
//Alanli20070801###

    CScalerReset();


#if(_HDCP_SUPPORT == _ON)
	SET_HOTPLUG_HDMI(_OFF);
	SET_HOTPLUG_HDMI2(_OFF);

	CAdjustHDCP();//HDCP1.0 for DVI

	//CTimerDelayXms(100);//20070714 gary for HDMI compatibility problem

//20080215, Pioneer DVD HDMI cause YPBPR can't be shown.
#if (_HDCP_SUPPORT == _ON)
	if (GET_INPUTSOURCE_TYPE()==_SOURCE_DVI)
	{
		if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT)
		{
			SET_HOTPLUG_HDMI(_ON);
			SET_HOTPLUG_HDMI2(_OFF);
		}
		else if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT2)
		{
			SET_HOTPLUG_HDMI(_OFF);
			SET_HOTPLUG_HDMI2(_ON);
		}
	}
#endif

	//CTimerDelayXms(100);//CTimerDelayXms(1000);		
#endif

}

#if(_RESET_TYPE == _RESET_IN)
//--------------------------------------------------
// Description  : Initial settings for MCU reset Scaler
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerResetInForResetIn(void)
{

#if(_MCU_TYPE == _WINDBOND_W79E632)

	bSCALERRESET    = _HIGH;
	CTimerDelayXms(5);
 	bSCALERRESET    = _LOW;
	CTimerDelayXms(5);
	bSCALERRESET    = _HIGH;
	CTimerDelayXms(5);
#endif//#if(_MCU_TYPE == _WINDBOND_W78E65)

#if(_MCU_TYPE == _MYSON_MTV512)
	bMCURESET    = _HIGH;
	CTimerDelayXms(1);
 	bMCURESET    = _LOW;
	CTimerDelayXms(1);
	bMCURESET    = _HIGH;
	CTimerDelayXms(1);
#endif//#if(_MCU_TYPE == _WINDBOND_W78E65)

	while(_TRUE)
	{
    	if(CTimerPollingEventProc(100, CMiscScalerResetEvent));
    		break;
	}
}
#endif  // End of #if(_RESET_TYPE == _RESET_IN)

//--------------------------------------------------
// Description  : Reset scaler process
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerReset(void)
{
#if(_SCALER_TYPE==_RTD2662)
	//CScalerCodeW(tSCALER_RESET_TABLE);
	CScalerCodeW_tSCALER_RESET_TABLE();
#endif

	//20080103, JPE, S/W on/off cause 80ms pulse at mute pin, 
	//so, we only do pin share setting once at power up 
	//CMiscSetPinShare();

	CAdjustDisableWatchDog(_WD_ALL);

	CMiscClearStatusRegister();

	CScalerInitialDisplayInterface();

	CScalerInitialDisplayOutput();

	CModeSetFreeRun();

	if(GET_POWERSTATUS())
	{
       	CScalerEnableDisplayOutput();
       	// OSD power up initial
       	//CScalerCodeW(tOSD_POWERUP_INITIAL);
       	CScalerCodeW_tOSD_POWERUP_INITIAL();

       	CAdjustTMDSErrorCorrectionOn();
	 	COsdColorPalette(Palette_7_4bit);
       	//CAdjustSRGB();
#if(_GAMMA_TYPE == 	_COMPACT_GAMMA_NORMAL_TABLE)
       	CAdjustGamma(_COMPACT_GAMMA_NORMAL_TABLE, tGAMMA_COMPACT1, tGAMMA_COMPACT1, tGAMMA_COMPACT1);
#elif(_GAMMA_TYPE == _FULL_GAMMA_NORMAL_TABLE)||(_GAMMA_TYPE == _FULL_GAMMA_COMPRESS_TABLE2) 	
//20081126, x.hu, use S-Curve Gamma
#if _PQ_FINETUNE
//20081213, x.hu, update 
	//load gamma table data
       CAdjustGammaTable(GET_GAMMA());

	//ctrl gamma enable bit:
	
	//disable gamma for PC mode
	if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DSUB_A0_PORT)
	{
		CScalerSetBit(_GAMMA_CTRL_67, ~_BIT6, 0);
	}
	//gamma enable for others according to GET_GAMMA():
	else
	{
		if (GET_GAMMA())
			CScalerSetBit(_GAMMA_CTRL_67, ~_BIT6, _BIT6);
		else
			CScalerSetBit(_GAMMA_CTRL_67, ~_BIT6, 0);
	}
#else

    if(GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DSUB_A0_PORT 
		||GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT
		||GET_INPUTPORT_TYPE(stSystemData.InputSource)==_HDMI_PORT2
		||GET_INPUTPORT_TYPE(stSystemData.InputSource)==_YPBPR_A0_PORT
		||GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT
		||GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_AV_PORT
      )
        CAdjustGammaTable(0);
	else
		CAdjustGammaTable(1);
       	//CAdjustGammaTable(GET_GAMMA());
#endif
#endif
       	if((Panel[ucPanelSelect].PanelConfig & _BIT7) == _DISP_18_BIT)
       		CAdjustDither(tDITHER_SEQ_TABLE_0, tDITHER_TABLE_10_TO_6);
       	else if((Panel[ucPanelSelect].PanelConfig & _BIT7) == _DISP_24_BIT)
       		CAdjustDither(tDITHER_SEQ_TABLE_0, tDITHER_TABLE_10_TO_8);

		CScalerSetBit(_IPH_ACT_WID_H_16, ~(_BIT6 | _BIT5 | _BIT4), 0x00);
		//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)));		
		
       	CAdjustBrightness();
		CAdjustContrast();

    	// Load HDMI EDID to Chip

#if 0//(_HDMI_EDID == _ON)  improve edid 2007.7.12
         CScalerPageSelect(_PAGE2);
        CScalerSetBit(_P2_HDCP_PORT_CTRL_C2, ~_BIT1, 0x00);
		CScalerCodeW(tHDMI_EDID_DATA);
#endif
#if(_OD_SUPPORT == _ON)
		CMemoryLoadODLUT(_OD_TABLE_COMMON);
		CMemorySDRAMReset();
#endif

	}
	else
	{
		CPowerDPLLOff();
		//CScalerSetByte(_HOST_CTRL_01, 0x42);//731301
		CScalerSetBit(_HOST_CTRL_01, ~_BIT1,(_BIT4 | _BIT1)); //V307 modify//731301
		CScalerDisableDisplayOutput();
	}
}

void CScalerPanelDEControl(void)
{
// **20080510**
#if (_PANEL_TYPE == _LQ121S1LG55||_PANEL_TYPE == _HSD100IFW1)
    {
    	//DE only
        CScalerSetByte(_TCON_ADDR_PORT_8B, _TCON_LVDS_CTRL4_A4);
        //CScalerSetByte(_TCON_DATA_PORT_8C, 0x30);
        CScalerSetBit(_TCON_DATA_PORT_8C, 0xF0, 0x0A);	//Disable DHS/DVS
        CScalerSetByte(_TCON_ADDR_PORT_8B, _TCON_LVDS_CTRL5_A5);
        //CScalerSetByte(_TCON_DATA_PORT_8C, 0x30);
        CScalerSetBit(_TCON_DATA_PORT_8C, 0xF0, 0x0A);	//Disable DHS/DVS
    }
// **20080510**

#else
    {
        CScalerSetByte(_TCON_ADDR_PORT_8B, _TCON_LVDS_CTRL4_A4);
        //CScalerSetByte(_TCON_DATA_PORT_8C, 0x30);
        CScalerSetBit(_TCON_DATA_PORT_8C, 0xF0, 0x00);	//Enable DHS/DVS
        CScalerSetByte(_TCON_ADDR_PORT_8B, _TCON_LVDS_CTRL5_A5);
        //CScalerSetByte(_TCON_DATA_PORT_8C, 0x30);
        CScalerSetBit(_TCON_DATA_PORT_8C, 0xF0, 0x00);	//Enable DHS/DVS
    }
#endif
}
//--------------------------------------------------
// Description  : Initial display interface for TTL, LVDS and RSDS
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerInitialDisplayInterface(void)
{
	switch(Panel[ucPanelSelect].PanelStyle)
	{
       	case _PANEL_TTL:
       		//CScalerCodeW(tTTL_INITIAL);
			CScalerCodeW_tTTL_INITIAL();
           		break;

       	case _PANEL_LVDS:
       		//CScalerCodeW(tLVDS_INITIAL);
       		CScalerCodeW_tLVDS_INITIAL();
           		break;

#if 0
       	case _PANEL_RSDS:
       		CScalerCodeW(tLVDS_INITIAL);
			CScalerCodeW(tRSDS_INITIAL);
       		CScalerSetByte(_TCON_ADDR_PORT_8B, 0x02);
       		CScalerSetByte(_TCON_DATA_PORT_8C, 0x40 | Panel[ucPanelSelect].PanelConfig & (_BIT2 | _BIT1 | _BIT0));
       		//CScalerSetBit(_DISP_TIMING_46, ~_BIT0, _BIT0);
           		break;
#endif
	}
	CScalerPanelDEControl();
}

//--------------------------------------------------
// Description  : Initial display output from Panel.h settings
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerInitialDisplayOutput(void)
{
	// Display signal control settings
	CScalerSetBit(_VDISP_CTRL_28, ~(_BIT4 | _BIT2), ((Panel[ucPanelSelect].PanelConfig & _BIT7) >> 3) | ((Panel[ucPanelSelect].PanelConfig & _BIT3) >> 1));
	CScalerSetByte(_VDISP_SIGINV_29, _DISPLAY_CTRL | (Panel[ucPanelSelect].PanelConfig & (_BIT6 | _BIT5 | _BIT4)));
}

//--------------------------------------------------
// Description  : Enable display output
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerEnableDisplayOutput(void)
{
	CScalerSetBit(_VDISP_CTRL_28, ~(_BIT6 | _BIT1), _BIT1);
	CScalerSetBit(_VDISP_CTRL_28, ~_BIT0, _BIT0);

	CScalerSetBit(_VDISP_CTRL_28, ~_BIT7, _BIT7);
	CScalerSetBit(_VDISP_CTRL_28, ~_BIT7, 0x00);
}

//--------------------------------------------------
// Description  : Disable display output
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerDisableDisplayOutput(void)
{
	if(Panel[ucPanelSelect].PanelStyle == _PANEL_TTL)
	{
		CScalerSetBit(_VDISP_SIGINV_29, ~(_BIT2 | _BIT1 | _BIT0), 0x00);
	}
	CScalerSetBit(_VDISP_CTRL_28, ~(_BIT6 | _BIT1), _BIT6);
	CScalerSetBit(_VDISP_CTRL_28, ~_BIT0, 0x00);
}

//731301***
#if((_TMDS_SUPPORT == _ON) || (_HDMI_SUPPORT == _ON))//V402 modify
//--------------------------------------------------
// Description  : Switch the Digital Input Port
// Input Value  : usSwitch  --> Parameter for Digital Input Port
// Output Value : None
//--------------------------------------------------
#if 0
void CScalerDigitalPortSwitch(void)
{
	CScalerPageSelect(_PAGE2);

	if(!CHdmiFormatDetect())
	{
            CScalerSetBit(_P2_POWER_ON_OFF_CTRL_A7, ~(_BIT6 | _BIT5), 0x00);
	}
	else
	{
            CScalerSetBit(_P2_POWER_ON_OFF_CTRL_A7, ~(_BIT6 | _BIT5), (_BIT6 | _BIT5));
	}

   /* switch(usSwitch)
    {
        case _DVI_D0_PORT:
        case _HDMI_H0_PORT:
            CScalerSetBit(_P2_TMDS_MEAS_RESULT0_A2, ~_BIT1, 0x00);
            CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT1 | _BIT0), _BIT1 | _BIT0);
            CScalerSetBit(_P2_HDCP_PORT_CTRL_C2, ~_BIT1, 0x00);
            break;

        case _DVI_D1_PORT:
        case _HDMI_H1_PORT:
            CScalerSetBit(_P2_TMDS_MEAS_RESULT0_A2, ~_BIT1, _BIT1);
            CScalerSetBit(_P2_ANALOG_COMMON_CTRL2_AB, ~(_BIT1 | _BIT0), _BIT1 | _BIT0);
            CScalerSetBit(_P2_HDCP_PORT_CTRL_C2, ~_BIT1, _BIT1);
            break;
    }*/
    CTimerDelayXms(200);
    CScalerSetBit(_P2_HDCP_CTRL_C0, ~_BIT0, _BIT0);
}
#endif
#endif


//By xyw
void CScalerSetOsdPosition(DWORD usOsdActWidth, DWORD usOsdActHeight, BYTE ucHPos, BYTE ucVPos, BYTE ucPar)
{
    if(ucHPos > _OSD_HPOSITION_RANGE)
        ucHPos = _OSD_HPOSITION_RANGE;

    if(ucVPos > _OSD_VPOSITION_RANGE)
        ucVPos = _OSD_VPOSITION_RANGE;

	//usOsdActWidth  = _OSD_HPOSITION_OFFSET + (DWORD)((ucHPos)*((Panel[ucPanelSelect].DHEndPos - Panel[ucPanelSelect].DHStartPos)/4 - usOsdActWidth/4 - 4)) / _OSD_HPOSITION_RANGE;
	//usOsdActHeight = _OSD_VPOSITION_OFFSET + (DWORD)((_OSD_VPOSITION_RANGE - ucVPos)*((Panel[ucPanelSelect].DVEndPos - Panel[ucPanelSelect].DVStartPos)/4 - usOsdActHeight/4 - 6)) / _OSD_VPOSITION_RANGE;
	usOsdActWidth  = _OSD_HPOSITION_OFFSET + (DWORD)((ucHPos)*((Panel[ucPanelSelect].DHEndPos - Panel[ucPanelSelect].DHStartPos)/4 - usOsdActWidth/4 - 4)) / _OSD_HPOSITION_RANGE;
#if _PANEL_TYPE==_SAMSUNG_LTM190M2L31
	usOsdActHeight = _OSD_VPOSITION_OFFSET + (DWORD)((_OSD_VPOSITION_RANGE - ucVPos)*((Panel[ucPanelSelect].DVEndPos - Panel[ucPanelSelect].DVStartPos)/4 - usOsdActHeight/4 - 4)) / _OSD_VPOSITION_RANGE;
#elif _PANEL_TYPE==_SAMSUNG_LVDS_19_WXGA
	usOsdActHeight = _OSD_VPOSITION_OFFSET + (DWORD)((_OSD_VPOSITION_RANGE - ucVPos)*((Panel[ucPanelSelect].DVEndPos - Panel[ucPanelSelect].DVStartPos)/4 - usOsdActHeight/4 - 4)) / _OSD_VPOSITION_RANGE;
//#elif _PANEL_TYPE==_SVA156WX1_01TB
	//usOsdActHeight = _OSD_VPOSITION_OFFSET + (DWORD)((_OSD_VPOSITION_RANGE - ucVPos)*((Panel[ucPanelSelect].DVEndPos - Panel[ucPanelSelect].DVStartPos)/4 - usOsdActHeight/4 - 4)) / _OSD_VPOSITION_RANGE;

#else//20081008 ccy modify to  2times
	usOsdActHeight = _OSD_VPOSITION_OFFSET + (DWORD)((_OSD_VPOSITION_RANGE - ucVPos)*((Panel[ucPanelSelect].DVEndPos - Panel[ucPanelSelect].DVStartPos)/4 - usOsdActHeight/4 - 5)) / _OSD_VPOSITION_RANGE;//20080919 ccy modify
#endif

    CScalerSetBit(_OSD_SCRAMBLE_93, 0xf8, 0x02);

    pData[0] = CScalerGetBit(_OVERLAY_CTRL_6C, _BIT0);

    pData[0] = (pData[0] == 0x00) ? 0xc0 : 0xe0;
    pData[1] = 0x00;
    CScalerWrite(_OSD_ADDR_MSB_90, 2, pData, _AUTOINC);

    pData[0] = usOsdActHeight >> 1;
    pData[1] = (BYTE)(usOsdActWidth >> 2);
    pData[2] = ((BYTE)(usOsdActWidth & 0x0003) << 6) | ((usOsdActHeight & 0x01) << 5) | ucPar;
    CScalerWrite(_OSD_DATA_PORT_92, 3, pData, _NON_AUTOINC);
 
    CTimerWaitForEvent(_EVENT_DEN_STOP);
    CTimerWaitForEvent(_EVENT_DEN_STOP);
    CScalerSetBit(_OSD_SCRAMBLE_93, 0xf8, 0x05);
}


//731301###