📄 adjust.c

📁 车载液晶显示器的主控程序（主要使用芯片为 MYSON MTV512 单片机、RealTek 2323 Scare 芯片、TVP5147（视频解码）。配Sharp 8寸液晶显示器）。
💻 C
📖 第 1 页 / 共 4 页
字号:
12 3 4 下一页
//----------------------------------------------------------------------------------------------------
// ID Code      : Adjust.c No.0001
// Update Note  : 
//
//----------------------------------------------------------------------------------------------------

#define __ADJUST__

#include "..\Header\Include.h"


//--------------------------------------------------
// Description  : Adjust IHS delay
// Input Value  : IHS delay
// Output Value : None
//--------------------------------------------------
void CAdjustIHSDelay(WORD usIHSDelay)
{
    CScalerSetBit(_VGIP_HV_DELAY_13, ~_BIT0, HIBYTE(usIHSDelay) & _BIT0);
    CScalerSetByte(_IHS_DELAY_12, LOBYTE(usIHSDelay));
}

//--------------------------------------------------
// Description  : Adjust IVS delay
// Input Value  : IVS delay
// Output Value : None
//--------------------------------------------------
void CAdjustIVSDelay(WORD usIVSDelay)
{
    CScalerSetBit(_VGIP_HV_DELAY_13, ~_BIT1, (usIVSDelay >> 7) & _BIT1);
    CScalerSetByte(_IVS_DELAY_11, LOBYTE(usIVSDelay));
}

//--------------------------------------------------
// Description  : Adjust Dclk offset
// Input Value  : Dclk offset
// Output Value : None
//--------------------------------------------------
void CAdjustDclkOffset(WORD usDclkOffset)
{
    CScalerSetBit(_DCLK_FINE_TUNE_OFFSET_MSB_B5, 0xf0, HIBYTE(usDclkOffset) & 0x0f);
    CScalerSetByte(_DCLK_FINE_TUNE_OFFSET_LSB_B6, LOBYTE(usDclkOffset));
    CScalerSetBit(_SPREAD_SPECTRUM_B7, ~_BIT2, _BIT2);
}

//--------------------------------------------------
// Description  : Adjust spread spectrum range
// Input Value  : Spread spectrum range
// Output Value : None
//--------------------------------------------------
void CAdjustSpreadSpectrumRange(BYTE ucSpreadRange)
{
    CScalerSetBit(_SPREAD_SPECTRUM_B7, 0x0f, (ucSpreadRange << 4) & 0xf0);
    CScalerSetBit(_SPREAD_SPECTRUM_B7, ~_BIT2, _BIT2);
}

//--------------------------------------------------
// Description  : Sync processor measure start
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CAdjustSyncProcessorMeasureStart(void)
{
    	CScalerSetBit(_MEAS_HS_PERIOD_H_52, ~_BIT5, _BIT5);	//Enable to start a measurement, auto cleared after finished. note by zhang_dc
}

//--------------------------------------------------
// Description  : Turn on the error correction function
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CAdjustTMDSErrorCorrectionOn(void)
{
    CScalerSetBit(_UP_DOWN_CTRL3_D4, 0x3f, 0xc0);
}
/*
//--------------------------------------------------
// Description  : Turn off the error correction function
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CAdjustTMDSErrorCorrectionOff(void)
{
    CScalerSetBit(_UP_DOWN_CTRL3_D4, 0x3f, 0x00);
}
*/

#if(_TMDS_SUPPORT == _ON)
//--------------------------------------------------
// Description  : Measure TMDS transition result
// Input Value  : ucType    --> _TMDS_MEASURE_AVE, _TMDS_MEASURE_MAX, _TMDS_MEASURE_MIN
//                ucSelect  --> _TMDS_MEASURE_HSYNC_BE, _TMDS_MEASURE_HSYNC_AF, _TMDS_MEASURE_DE_BE, _TMDS_MEASURE_DE_AF
// Output Value : Transition result
//--------------------------------------------------
BYTE CAdjustTMDSMeasure(BYTE ucType, BYTE ucSelect)
{
    BYTE result;

    CScalerSetBit(_TMDS_MEAS_RESULT0_BD, ~(_BIT6 | _BIT5), (ucType << 5));
    CScalerSetBit(_TMDS_MEAS_RESULT0_BD, ~(_BIT7 | _BIT4 | _BIT3), (_BIT7 | (ucSelect << 3)));

    if(CTimerPollingEventProc(60, CMiscTMDSMeasureEvent) == _FALSE)
    {
        CScalerSetBit(_TMDS_MEAS_RESULT0_BD, ~_BIT7, 0x00);
        return 0xff;
    }

    CScalerRead(_TMDS_MEAS_RESULT1_BE, 1, &result, _NON_AUTOINC);

    return (result & 0x7f);
}

//--------------------------------------------------
// Description  : Measure TMDS CRC value
// Input Value  : None
// Output Value : CRC value, LWORD data type
//--------------------------------------------------
LWORD CAdjustTMDSCRCMeasure(void)
{
    BYTE result[4];

    result[0] = 0;
    CScalerSetBit(_POWER_ON_OFF_CTRL_C2, ~_BIT0, 0x00);
    CScalerSetBit(_POWER_ON_OFF_CTRL_C2, ~_BIT0, _BIT0);

    if(CTimerPollingEventProc(60, CMiscTMDSCRCEvent) == _FALSE)
    {
        CScalerSetBit(_POWER_ON_OFF_CTRL_C2, ~_BIT0, 0x00);
        return 0xffffffffl;
    }

    CScalerRead(_CRC_OUTPUT_BYTE_2_C0, 3, &result[1], _NON_AUTOINC);

    return ((LWORD *)result)[0];
}

//--------------------------------------------------
// Description  : Do two times CRC check and get phase SOD value
// Input Value  : pArray    --> SOD value buffer
// Output Value : Return 0 if CRCs are not the same or CRCs == 0
//--------------------------------------------------
BYTE CAdjustTMDSCRC(BYTE *pArray)
{
    BYTE temp;

    CScalerSetByte(_AUTO_ADJ_CTRL1_7D, 0x3b);
    CScalerSetByte(_STATUS0_02, 0x00);

    ((LWORD *)pData)[0] = CAdjustTMDSCRCMeasure();
    ((LWORD *)pData)[1] = CAdjustTMDSCRCMeasure();

    CScalerRead(_STATUS0_02, 1, &temp, _NON_AUTOINC);
    CScalerRead(_AUTO_PHASE_3_84, 4, pArray, _AUTOINC);

    if((((LWORD *)pData)[0] != ((LWORD *)pData)[1]) || ((temp & 0x03) != 0) || (((LWORD *)pData)[0] == 0) || (((LWORD *)pData)[1] == 0))
        return 0;
    else
        return 1;
}

//--------------------------------------------------
// Description  : TMDS CRC check process before displaying
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CAdjustTMDSCRCCheck(void)
{
    BYTE temp0, temp1;
    LWORD dsod0, dsod1;

    if(GET_FRAMESYNCSTATUS())
    {
        CTimerDelayXms(20);

        temp0 = 0;
        temp0 += CAdjustTMDSCRC(&pData[8]);
        temp0 += CAdjustTMDSCRC(&pData[12]);
        dsod0 = abs(((LWORD *)pData)[2] - ((LWORD *)pData)[3]);

        if(temp0 < 2)
        {
            CScalerSetBit(_ANALOG_COMMON_CTRL2_C6, ~(_BIT5 | _BIT6), CScalerGetBit(_ANALOG_COMMON_CTRL2_C6, (_BIT6 | _BIT5)) ^ (_BIT5 | _BIT6));

            temp1 = 0;
            temp1 += CAdjustTMDSCRC(&pData[8]);
            temp1 += CAdjustTMDSCRC(&pData[12]);
            dsod1 = abs(((LWORD *)pData)[2] - ((LWORD *)pData)[3]);

            if(temp1 < 2)
            {
                if(GET_USE_TRANSITION_RESULT())
                {
                    CScalerSetBit(_ANALOG_COMMON_CTRL2_C6, ~(_BIT5 | _BIT6), CScalerGetBit(_ANALOG_COMMON_CTRL2_C6, (_BIT6 | _BIT5)) ^ (_BIT5 | _BIT6));
                }
                else
                {
                    if(dsod0 <= dsod1)
                        CScalerSetBit(_ANALOG_COMMON_CTRL2_C6, ~(_BIT5 | _BIT6), CScalerGetBit(_ANALOG_COMMON_CTRL2_C6, (_BIT6 | _BIT5)) ^ (_BIT5 | _BIT6));
                }
            }
            else
            {
                //CModeSetDigitalCapture();
            }
        }
        else
        {
            //CModeSetDigitalCapture();
        }
    }
}

//--------------------------------------------------
// Description  : Get TMDS transition difference 
// Input Value  : ucPar     --> _MEASURE_HSYNC or _MEASURE_DE
// Output Value : Transition difference result
//--------------------------------------------------
BYTE CAdjustTMDSEqualizerCheck(BYTE ucPar)
{
    BYTE result0, result1;

    if(ucPar == _MEASURE_HSYNC)
    {
        result0 = CAdjustTMDSMeasure(_TMDS_MEASURE_MAX, _TMDS_MEASURE_HSYNC_BE);
        if(result0 == 0xff)     return 0xff;
        else if(result0 < 6)    return 0xfe;

        result1 = CAdjustTMDSMeasure(_TMDS_MEASURE_MIN, _TMDS_MEASURE_HSYNC_AF);
        if(result1 == 0xff)     return 0xff;
        else if(result1 < 6)    return 0xfe;
    }
    else if(ucPar == _MEASURE_DE)
    {
        result0 = CAdjustTMDSMeasure(_TMDS_MEASURE_MAX, _TMDS_MEASURE_DE_BE);
        if(result0 == 0xff)     return 0xff;
        else if(result0 < 6)    return 0xfe;

        result1 = CAdjustTMDSMeasure(_TMDS_MEASURE_MAX, _TMDS_MEASURE_DE_AF);
        if(result1 == 0xff)     return 0xff;
        else if(result1 < 6)    return 0xfe;
    }

    result0 = abs(result0 - result1);

    if(result0 <= 2)
        result0 = 0;

    return result0;
}

//--------------------------------------------------
// Description  : Adjust TMDS equalizer setting
// Input Value  : None
// Output Value : return _TRUE if success
//--------------------------------------------------
bit CAdjustTMDSEqualizer(void)
{
    BYTE cnt, result0, result1;

    CLR_USE_TRANSITION_RESULT();

    CScalerSetByte(_TMDS_MEAS_SELECT_BC, 0x21);
    CScalerSetBit(_TMDS_MEAS_RESULT0_BD, 0x9f, 0x20);

    cnt = 1;
    do
    {
        CScalerSetBit(_TMDS_MEAS_SELECT_BC, 0xf0, (cnt%16));

        result0 = CAdjustTMDSMeasure(_TMDS_MEASURE_MAX, _TMDS_MEASURE_DE_BE);
        if(result0 == 0xff)
            return _FALSE;

        if(result0 > 80)
            break;

        cnt++;
    }
    while(cnt <= 16);

    cnt = 0;

    CScalerSetBit(_ANALOG_COMMON_CTRL2_C6, 0x8f, 0x00);
    result0 = CAdjustTMDSEqualizerCheck(_MEASURE_HSYNC);
    if(result0 == 0xff)     return _FALSE;
    if(result0 == 0xfe)     cnt += 1;

    CScalerSetBit(_ANALOG_COMMON_CTRL2_C6, 0x8f, 0x10);
    result1 = CAdjustTMDSEqualizerCheck(_MEASURE_HSYNC);
    if(result1 == 0xff)     return _FALSE;
    if(result1 == 0xfe)     cnt += 2;

    if((abs(result0 - result1) <= 2) || (cnt != 0))
    {
        cnt = 0;

        CScalerSetBit(_ANALOG_COMMON_CTRL2_C6, 0x8f, 0x00);
        result0 = CAdjustTMDSEqualizerCheck(_MEASURE_DE);
        if(result0 == 0xff)     return _FALSE;
        if(result0 == 0xfe)     cnt += 1;

        CScalerSetBit(_ANALOG_COMMON_CTRL2_C6, 0x8f, 0x10);
        result1 = CAdjustTMDSEqualizerCheck(_MEASURE_DE);
        if(result1 == 0xff)     return _FALSE;
        if(result1 == 0xfe)     cnt += 2;
    }

    if((result0 <= result1) || (cnt >= 2))
        CScalerSetBit(_ANALOG_COMMON_CTRL2_C6, 0x8f, 0x70);

    if(abs(result0 - result1) > 2)
        SET_USE_TRANSITION_RESULT();

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

#if(_HDCP_SUPPORT == _ON)
//--------------------------------------------------
// Description  : Adjust HDCP key
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CAdjustHDCP(void)
{
    CScalerSetByte(_HDCP_CTRL_D5, 0x06);
    CScalerCodeW(tHDCP_CTRL);
    CScalerWrite(_DEVICE_KEY_ACCESS_PORT_D6, 320, tHDCP_KEY_TABLE_0, _NON_AUTOINC);
    CScalerSetByte(_HDCP_CTRL_D5, 0x01);
}
#endif

//--------------------------------------------------
// Description  : Enable watch dog
// Input Value  : ucPar --> Parameter for watch dog
// Output Value : None
//--------------------------------------------------
void CAdjustEnableWatchDog(BYTE ucPar)
{
    if(GET_FRAMESYNCSTATUS())
    {
        CScalerSetByte(_WATCHDOG_CTRL1_DA, 0x00);
        CMiscClearStatusRegister();
        CScalerSetBit(_WATCHDOG_CTRL1_DA, ~ucPar, 0x06 | ucPar);
    }
}

//--------------------------------------------------
// Description  : Disable watch dog
// Input Value  : ucPar --> Parameter for watch dog
// Output Value : None
//--------------------------------------------------
void CAdjustDisableWatchDog(BYTE ucPar)
{
    BYTE temp;

    CScalerSetBit(_WATCHDOG_CTRL1_DA, ~ucPar, 0x00);

    temp = CScalerGetBit(_WATCHDOG_CTRL1_DA, (_BIT5 | _BIT4 | _BIT3));

    if(temp == 0x00)
        CScalerSetByte(_WATCHDOG_CTRL1_DA, 0x00);
}

//--------------------------------------------------
// Description  : Adjust sRGB function ( Not ready )
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CAdjustSRGB(void)
{

}

//--------------------------------------------------
12 3 4 下一页
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -