scaler.c

realtek LCD monitor, TV开发源代码

//**********************************************************************************************************
//  The  Software  is  proprietary,  confidential,  and  valuable to Realtek Semiconductor
//  Corporation  ("Realtek").  All  rights, including but not limited  to  copyrights,
//  patents,  trademarks, trade secrets, mask work rights, and other similar rights and interests,
//  are reserved to Realtek. Without  prior  written  consent  from  Realtek,  copying, reproduction,
//  modification,  distribution,  or  otherwise  is strictly prohibited. The Software  shall  be
//  kept  strictly  in  confidence,  and  shall  not be  disclosed to or otherwise accessed by
//  any third party. @ <2003> - <2008>   The Software is provided "AS IS" without any warranty of any kind,
//  express, implied, statutory or otherwise.
//**********************************************************************************************************
//----------------------------------------------------------------------------------------------------
// ID Code      : Scaler.c No.0000
// Update Note  :
//----------------------------------------------------------------------------------------------------

#define __SCALER__

#include "Common\Header\Include.h"

#if(_SCALER_SERIES_TYPE == _RTD2472D_SERIES)

//--------------------------------------------------
// Description  : Page select for scalar(Only for CR[A1]~CR[DF])
// Input Value  : Page Number
// Output Value : None
//--------------------------------------------------
void CScalerPageSelect(BYTE page)
{
//Anderson 080109 2545LR, 247xRD, 248xRD Have Page 10 Start
#if(_SCALER_TYPE == _RTD2472D)
    CScalerSetByte(_PAGE_SELECT_9F, (page & 0x0F));
#elif((_SCALER_TYPE == _RTD2545LR) || (_SCALER_TYPE == _RTD247xRD) || (_SCALER_TYPE == _RTD248xRD))
    CScalerSetByte(_PAGE_SELECT_9F, (page & 0x1F));

#else
    No Setting !!

#endif //End of #if(_SCALER_TYPE == _RTD2472D)
//Anderson 080109 2545LR, 247xRD, 248xRD Have Page 10 Start
}

//--------------------------------------------------
// Description  : Initial settings for scaler
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerInitial(void)
{
    // Software reset for scaler
    CScalerSetBit(_HOST_CTRL_01, ~(_BIT0 | _BIT1 | _BIT2), _BIT0);

#if(_MCU_TYPE == _REALTEK_EMBEDDED) //yc 20080415
    if(!GET_POWERSTATUS())       // Power Down Process
       CMcuSelectFlashClk(_XTAL_CLK);
    CTimerDelayXms(10);
#else
    CTimerDelayXms(100);
#endif

    CScalerSetBit(_HOST_CTRL_01, ~_BIT0, 0x00);
    CScalerReset();
    CTimerDelayXms(10);
#if(_MCU_TYPE == _REALTEK_EMBEDDED) //yc 20080415
    if(GET_POWERSTATUS())       // Power up Process
       CMcuSelectFlashClk(_FLASH_CLK);
#endif

#if(_RESET_CHECK_SUPPORT == _ON)
    CScalerSetBit(_HOST_CTRL_01, ~_BIT6, _BIT6);
#endif

}

//--------------------------------------------------
// Description  : Reset scaler process
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerReset(void)
{

    CScalerCodeW(tSCALER_RESET_TABLE);

    CScalerCodeW(tSCALER_POWERUP_INITIAL);

#if(_SCALER_TYPE == _RTD2545LR) //cyyeh V008_20080806 align L Series !!
    CMiscSetPinShare();
#endif

    CAdjustDisableWatchDog(_WD_ALL);

    CMiscClearStatusRegister();

    CScalerInitialDisplayInterface();

    CScalerInitialDisplayOutput();
    CModeSetFreeRun();

    CScalerEnableDisplayTiming();

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

        CAdjustTMDSErrorCorrectionOn();
        //CAdjustColorPalette(tPALETTE_0);
        CAdjustSRGB();

//Anderson 080104 for I/D Domain Dither Start
#if(_SCALER_TYPE == _RTD2472D)

        if(_DISP_BIT_MODE == _DISP_18_BIT)          //Hudson 20080725 add Temporal Dithering offset table !!
            CAdjustDither(tDITHER_SEQ_TABLE_0, tDITHER_TABLE_10_TO_6, tDITHER_TEMPOFFSET_TABLE);

        else if(_DISP_BIT_MODE == _DISP_24_BIT)     //Hudson 20080725 add Temporal Dithering offset table !!
            CAdjustDither(tDITHER_SEQ_TABLE_0, tDITHER_TABLE_10_TO_8_D_DOMAIN, tDITHER_TEMPOFFSET_TABLE);

#elif((_SCALER_TYPE == _RTD2545LR) || (_SCALER_TYPE == _RTD247xRD) || (_SCALER_TYPE == _RTD248xRD))

        if(_DISP_BIT_MODE == _DISP_18_BIT)          //Hudson 20080725 add Temporal Dithering offset table !!
            CAdjustDither(tDITHER_SEQ_TABLE_0, tDITHER_TABLE_10_TO_6, tDITHER_TEMPOFFSET_TABLE, _OUTPUT_DITHER);

        else if(_DISP_BIT_MODE == _DISP_24_BIT)     //Hudson 20080725 add Temporal Dithering offset table !!
            CAdjustDither(tDITHER_SEQ_TABLE_0, tDITHER_TABLE_10_TO_8_D_DOMAIN, tDITHER_TEMPOFFSET_TABLE,       _OUTPUT_DITHER);//Anderson 080104 for I/D Domain Dither Table

#else
    No Setting !!

#endif  //End of #if(_SCALER_TYPE == _RTD2472D)
//Anderson 080104 for 2545LR, 247xRD, 248xRD Dither End
        CScalerSetBit(_IPH_ACT_WID_H_16, ~(_BIT6 | _BIT5 | _BIT4), ((_ADC_INPUT_SWAP_RG << 6) | (_ADC_INPUT_SWAP_RB << 5)| (_ADC_INPUT_SWAP_GB << 4)));

        CAdjustBrightness();
        CAdjustContrast();

#if(_OD_SUPPORT == _ON)
        CMemoryLoadODLUT(_OD_TABLE_COMMON);
#endif

#if(_HDCP_SUPPORT == _ON) //cyyeh 20080710 for hdcp compatibility
        CAdjustHDCP();
#endif

#if(_GAMMA_FUCTION == _ON)

        CAdjustAccessGammaTable();

#endif// End of #if(_GAMMA_FUCTION == _ON)
    }
    else
    {
        CPowerPanelOff();
        CScalerDisableDisplayTiming();
        CPowerDPLLOff();
        CPowerTMDSOff();
        CPowerM2PLLOff();//cyyeh 20080326
#if((_SCALER_TYPE == _RTD2545LR) || (_SCALER_TYPE == _RTD247xRD) || (_SCALER_TYPE == _RTD248xRD))
        CPowerMPLLOff();//cyyeh 20080611
#endif
        CScalerSetByte(_HOST_CTRL_01, 0x46);
    }
}

//--------------------------------------------------
// Description  : Initial display interface for TTL and LVDS
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerInitialDisplayInterface(void)
{

#if(_PANEL_STYLE == _PANEL_TTL)

    CScalerCodeW(tTTL_INITIAL);

#endif // End of #if(_PANEL_STYLE == _PANEL_TTL)


#if(_PANEL_STYLE == _PANEL_LVDS)

    CScalerCodeW(tLVDS_INITIAL);

#if((_SCALER_TYPE == _RTD2545LR) ||(_SCALER_TYPE == _RTD247xRD) || (_SCALER_TYPE == _RTD248xRD))
    CScalerCodeW(tTCON7TCON5_SIM_TO_DEN);
#endif

#endif // End of #if(_PANEL_STYLE == _PANEL_LVDS)


#if(_PANEL_STYLE == _PANEL_RSDS)

    CScalerCodeW(tLVDS_INITIAL);
    CScalerCodeW(tRSDS_INITIAL);
//    CScalerSetDataPortByte(_TCON_ADDR_PORT_8B, _TCON_RSDS_OUTPUT_CTRL0_C0, 0x40 | ( (_RSDS_GC_SWAP << 2) | (_RSDS_HL_SWAP << 1) | (_RSDS_PN_SWAP) ));
    CScalerSetDataPortByte(_TCON_ADDR_PORT_8B, _TCON_RSDS_OUTPUT_CTRL0_C0, 0x92);
    CScalerSetDataPortBit(_DISP_ACCESS_PORT_2A, _DISP_TIMING_20, ~_BIT0, _BIT0);

#endif // End of #if(_PANEL_STYLE == _PANEL_RSDS)

}

//--------------------------------------------------
// 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), (_DISP_BIT_MODE << 4) | (_DISP_OUTPUT_PORT << 2));
    CScalerSetByte(_VDISP_SIGINV_29, ( (_DHS_MASK << 7) | (_DISP_EO_SWAP << 6) | (_DISP_RB_SWAP << 5) | (_DISP_ML_SWAP << 4) | (_DISP_SKEW << 3) | (_DISP_DVS_INVERT << 2) | (_DISP_DHS_INVERT << 1) | (_DISP_DEN_INVERT)));
}

//--------------------------------------------------
// Description  : Enable display output
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerEnableDisplayOutput(void)
{
    CScalerGetDataPortByte(_TCON_ADDR_PORT_8B, _TCON_CTRL0_00, 1, pData, _NON_AUTOINC);
    CScalerSetDataPortByte(_TCON_ADDR_PORT_8B, _TCON_CTRL0_00, ((pData[0] & ~(_BIT1 | _BIT0)) | (_PANEL_STYLE & (_BIT1 | _BIT0))));
}
/*
//--------------------------------------------------
// Description  : Disable display output
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerDisableDisplayOutput(void)
{
    CScalerGetDataPortByte(_TCON_ADDR_PORT_8B, _TCON_CTRL0_00, 1, pData, _NON_AUTOINC);
    CScalerSetDataPortByte(_TCON_ADDR_PORT_8B, _TCON_CTRL0_00, (pData[0] & ~_BIT3));
}
*/
//--------------------------------------------------
// Description  : Enable display
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerEnableDisplayTiming(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
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerDisableDisplayTiming(void)
{

#if(_PANEL_STYLE == _PANEL_TTL)

    CScalerSetBit(_VDISP_SIGINV_29, ~(_BIT2 | _BIT1 | _BIT0), 0x00);

#endif

    CScalerSetBit(_VDISP_CTRL_28, ~(_BIT6 | _BIT1), _BIT6);
    CScalerSetBit(_VDISP_CTRL_28, ~_BIT0, 0x00);
}

//----------------------------------------------------------------------------------------------------
// Scaler communication basic function
//----------------------------------------------------------------------------------------------------
#if(_MCU_TYPE != _REALTEK_EMBEDDED)
//Anderson 071219 for 2545LR Start
#if(_SCALER_TYPE == _RTD2545LR)
void CScalerSendReadStop(void)
{
    SETSCALERSDIO3(_HIGH);
    SETSCALERSDIO3(_LOW);
    SETSCALERSDIO3(_HIGH);

    SETSCALERSCLK();
}

void CScalerSendWriteStop(void)
{
    CLRSCALERSCLK();
    SETSCALERSCLK();

    SETSCALERSCLK();
    SETSCALERSDIO3(_HIGH);
    SETSCALERSDIO3(_LOW);
    SETSCALERSDIO3(_HIGH);
}
void CScalerSendAddr(BYTE ucAddr, bit bReadWrite, bit bAutoInc)
{
    SETSCALERSCLK();
    SETSCALERSDIO3(_HIGH);
    SETSCALERSDIO3(_LOW);
    SETSCALERSDIO3(_HIGH);

    CScalerSendByte(ucAddr);

    SETSCALERSDIO3(bReadWrite);
    CLRSCALERSCLK();
    SETSCALERSDIO3(bAutoInc);
    SETSCALERSCLK();

    SETSCALERSDIO3(_HIGH);
}

#else
void CScalerSendReadStop(void)
{
    SETSCALERSCLK();
    SETSCALERSCSB();
}

void CScalerSendWriteStop(void)
{
    CLRSCALERSCLK();
    SETSCALERSCLK();

    SETSCALERSCLK();
    SETSCALERSCSB();
}
void CScalerSendAddr(BYTE ucAddr, bit bReadWrite, bit bAutoInc)
{
    CLRSCALERSCSB();

    CScalerSendByte(ucAddr);

    SETSCALERSDIO3(bReadWrite);
    CLRSCALERSCLK();
    SETSCALERSDIO3(bAutoInc);
    SETSCALERSCLK();

    SETSCALERSDIO3(_HIGH);
}
#endif  // End of #if(_SCALER_TYPE == _RTD2545LR)
//Anderson 071219 for 2545LR End

void CScalerSendByte(BYTE ucValue)
{
    SETSCALERSDIO3((bit)(ucValue & 0x01));
    CLRSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x02));
    SETSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x04));
    CLRSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x08));
    SETSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x10));
    CLRSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x20));
    SETSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x40));
    CLRSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x80));
    SETSCALERSCLK();
}

void CScalerSETSCLK(void)
{
    SETSCALERSCLK();
    SETSCALERSCLK();
    SETSCALERSCLK();
    SETSCALERSCLK();
    SETSCALERSCLK();
}

void CScalerCLRSCLK(void)
{
    CLRSCALERSCLK();
    CLRSCALERSCLK();
    CLRSCALERSCLK();
    CLRSCALERSCLK();
    CLRSCALERSCLK();
}
//cyyeh 20080225
#if(_SCALER_TYPE == _RTD2545LR)
BYTE CScalerGetByte1(void)
{
    BYTE value = 0;

    CScalerCLRSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x01;
    CScalerSETSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x02;
    CScalerCLRSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x04;
    CScalerSETSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x08;
    CScalerCLRSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x10;
    CScalerSETSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x20;
    CScalerCLRSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x40;
    CScalerSETSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x80;

    CScalerCLRSCLK();

    return value;
}

BYTE CScalerGetByte2(void)
{
    BYTE value = 0;

    CScalerSETSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x01;
    CScalerCLRSCLK();