adjust.c

很难得的最好的rtd3523系列原厂源码LCD驱动开发

    }
    else
    {
        CPowerADCAPLLOn();
        CScalerSetByte(_I_CODE_M_9A, 0x20);
        CTimerWaitForEvent(_EVENT_IVS);
        CTimerWaitForEvent(_EVENT_IVS);
        CScalerSetByte(_I_CODE_M_9A, 0x24);
        SET_FIRST_ADCCLOCK();
    }

#if(_APLL_FAST_LOCK)

    if(GET_FIRST_ADCCLOCK())
    {
        CScalerSetByte(_FAST_PLL_CTRL_9F, 0x68);
    }

#endif

    CTimerWaitForEvent(_EVENT_IEN_STOP);
    CTimerWaitForEvent(_EVENT_IEN_STOP);
    CScalerSetByte(_FAST_PLL_CTRL_9F, 0x00);

    CMiscClearStatusRegister();

    CAdjustEnableWatchDog(_WD_ALL);
    */
    //version 200D
    BYTE mcode, ncode, temp0, temp1;
    WORD delta;

    CAdjustEnableWatchDog(_WD_DV_TIMEOUT);

    if(!CAdjustCheckAdcClockRange(usClock, &delta))
        usClock = stModeInfo.IHTotal;

    pData[0]    = 0x0c;
    pData[1]    = 0x4f;
    pData[2]    = 0x24;
    pData[3]    = 0x00 | _DDS_P_CODE;
    CScalerWrite(_PLL_DIV_CTRL_98, 4, pData, _AUTOINC);

#if(_M2PLL_USE == _ON)
    pData[0]    = ((_APLL1_M_CODE * _RTD_M2PLL_RATIO) - 2);
#else
    pData[0]    = (_APLL1_M_CODE - 2);
#endif
    pData[1]    = (_APLL1_N_CODE - 2);
    pData[2]    = 0x37;
    CScalerWrite(_PLL1_M_A1, 3, pData, _AUTOINC);

    // usClock * 2 -------------------------------------
    usClock = usClock * 2;
    //--------------------------------------------------

    ((WORD *)pData)[2]  = 100;

    temp1   = 11;

    do
    {
        temp0   = ((LWORD)31 * _APLL1_N_CODE * temp1 * usClock)
                  / ((LWORD)32 * _APLL1_M_CODE * stModeInfo.IHCount);

        ((WORD *)pData)[0] = ((LWORD)3100 * _APLL1_N_CODE * temp1 * usClock)
                             / ((LWORD)_APLL1_M_CODE * temp0 * stModeInfo.IHCount);

        if(((WORD *)pData)[0] > 3240)
        {
            ((WORD *)pData)[0] = ((WORD *)pData)[0] - 3200;

            if(((WORD *)pData)[0] <= ((WORD *)pData)[2])
            {
                ((WORD *)pData)[2] = ((WORD *)pData)[0];
 
                mcode   = temp0;
                ncode   = temp1;
            }

            ((WORD *)pData)[1]  = ((LWORD)3100 * _APLL1_N_CODE * temp1 * usClock)
                                  / ((LWORD)_APLL1_M_CODE * (temp0 + 1) * stModeInfo.IHCount);
            ((WORD *)pData)[1]  = 3200 > ((WORD *)pData)[1] ? 3200 - ((WORD *)pData)[1] : ((WORD *)pData)[1] - 3200;
            
            if(((WORD *)pData)[1] < 40)
            {
                mcode   = temp0 + 1;
                ncode   = temp1;
                break;
            }

            if(((WORD *)pData)[1] <= ((WORD *)pData)[2])
            {
                ((WORD *)pData)[2] = ((WORD *)pData)[1];

                mcode   = temp0 + 1;
                ncode   = temp1;
            }
        }
        else
        {
            mcode   = temp0;
            ncode   = temp1;
            break;
        }
    }
    while(++temp1 < 48);

    usClock     = (usClock / 2);

#if(_APLL_FAST_LOCK)

    if(GET_FIRST_ADCCLOCK())
    {
        CScalerRead(_PLL2_M_A5, 2, &pData[14], _AUTOINC);
        pData[14] = pData[14] + 2;      // Old M code
        pData[15] = pData[15] + 2;      // Old N code

        CScalerRead(_PLLDIV_H_A9, 2, &pData[12], _AUTOINC);
        ((WORD *)pData)[6] = ((((WORD)(pData[12] & 0x0f)) << 8) | pData[13]) + 1;

        CScalerSetByte(_FAST_PLL_CTRL_9F, 0x00);
        CScalerSetByte(_FAST_PLL_CTRL_9F, 0x07);
        CScalerRead(_FAST_PLL_ISUM_A0, 4, pData, _NON_AUTOINC);

        ((LWORD *)pData)[1] = (LWORD)pData[15] * mcode * (LWORD)((WORD *)pData)[6]; // H Up
        ((LWORD *)pData)[2] = (LWORD)ncode * pData[14] * usClock;   // H Down
        ((LWORD *)pData)[0] = ((LWORD *)pData)[0] / ((LWORD *)pData)[2] * ((LWORD *)pData)[1];

        if(((LWORD *)pData)[2] > ((LWORD *)pData)[1])
            ((LWORD *)pData)[0] += (LWORD)4294967295 / ((LWORD *)pData)[2] * 16 * (((LWORD *)pData)[2] - ((LWORD *)pData)[1]);
        else
            ((LWORD *)pData)[0] -= (LWORD)4294967295 / ((LWORD *)pData)[2] * 16 * (((LWORD *)pData)[1] - ((LWORD *)pData)[2]);

        CScalerSetByte(_FAST_PLL_CTRL_9F, 0x20);
        CScalerSetByte(_FAST_PLL_CTRL_9F, 0x22);
        CScalerWrite(_FAST_PLL_ISUM_A0, 4, pData, _NON_AUTOINC);
    }

#endif

    CScalerSetBit(_PLLDIV_H_A9, 0xf0, HIBYTE(usClock - 1) & 0x0f);
    CScalerSetByte(_PLLDIV_L_AA, LOBYTE(usClock - 1));
    CScalerSetByte(_PLL2_M_A5, mcode - 2);
    CScalerSetByte(_PLL2_N_A6, ncode - 2);

    // Original Formula : Icp/M2_Code = 0.4 must be constant
    // Icp   = M2_Code * 4 / 10
    // Icp   = 2.5u + A7[0]*2.5u + A7[1]*5u + A7[2]*10u + A7[3]*20u + A7[4]*30u (A)
    // 2*Icp = 5u + A7[0]*5u + A7[1]*10u + A7[2]*20u + A7[3]*40u + A7[4]*60u (A)

    // Calculate the 2*Icp,
    pData[5]    = (((WORD)mcode * 4 / 10) < 5) ? 0 : ((WORD)mcode * 4 / 10) - 5;
    pData[6]    = 0x00;
    
    if(pData[5] >= 60)
    {
        pData[5]    -= 60;
        pData[6]    |= 0x10;
    }

    if(pData[5] >= 40)
    {
        pData[5]    -= 40;
        pData[6]    |= 0x08;
    }

    if(pData[5] >= 20)
    {
        pData[5]    -= 20;
        pData[6]    |= 0x04;
    }

    if(pData[5] >= 10)
    {
        pData[5]    -= 10;
        pData[6]    |= 0x02;
    }

    if(pData[5] >= 5)
    {
        pData[5]    -= 5;
        pData[6]    |= 0x01;
    }

    // Larger charge pump current (+2)
    pData[6] += 2;
    CScalerSetBit(_PLL2_CRNT_A7, 0xe0, pData[6]);

    if(GET_FIRST_ADCCLOCK())
    {

    }
    else
    {
        CPowerADCAPLLOn();
        CScalerSetByte(_I_CODE_M_9A, 0x20);
        CTimerWaitForEvent(_EVENT_IVS);
        CTimerWaitForEvent(_EVENT_IVS);
        CScalerSetByte(_I_CODE_M_9A, 0x24);
        SET_FIRST_ADCCLOCK();
    }

#if(_APLL_FAST_LOCK)

    if(GET_FIRST_ADCCLOCK())
    {
        CScalerSetByte(_FAST_PLL_CTRL_9F, 0x68);
    }

#endif

    CTimerWaitForEvent(_EVENT_IEN_STOP);
    CTimerWaitForEvent(_EVENT_IEN_STOP);
    CScalerSetByte(_FAST_PLL_CTRL_9F, 0x00);

    CMiscClearStatusRegister();

    CAdjustEnableWatchDog(_WD_ALL);

}

//--------------------------------------------------
// Description  : Set phase
// Input Value  : ucPhase   --> Target phase, ucPhase = N, N = 0 ~ 63
// Output Value : None
//--------------------------------------------------
void CAdjustPhase(BYTE ucPhase)
{
    BYTE ctrl, select;

    CAdjustEnableWatchDog(_WD_DV_TIMEOUT_APLL_NONLOCK);

    ucPhase = ucPhase & 0x3f;

    // Code below is to select stable HSYNC latch edge.
    // There is about 6.0736ns delay for RTD2323 between input clock into ADC and output from ADC.
    // Calculating the corresponding phase delay for 6.0736ns 
    // Original Formula :
	// select = 64 * 6.0736 * ulRate / 1000000;

    select      = (LWORD)_RTD_XTAL * stModeInfo.IHTotal / stModeInfo.IHCount * 389 / 1000000;

    select      = (select <= 64) ? (64 - select) : (128 - select);

    // Calculate the absolute value from the selected phase to transition
    pData[0]    = (ucPhase >= select) ? ucPhase - select : select - ucPhase;
    ctrl        = (pData[0] > 12 && pData[0] < 52) ? 0x00 : 0x01;

    if((stModeInfo.IHStartPos < stModeUserData.HPosition) && ((stModeUserData.HPosition - stModeInfo.IHStartPos) > ucHStartBias))
        stModeUserData.HPosition = stModeInfo.IHStartPos + ucHStartBias;

    if((stModeInfo.IHStartPos > stModeUserData.HPosition) && ((stModeInfo.IHStartPos - stModeUserData.HPosition) > ucHStartBias))
        stModeUserData.HPosition = stModeInfo.IHStartPos - ucHStartBias;

    pData[0]    = ucHStartBias + stModeInfo.IHStartPos - stModeUserData.HPosition  + _PROGRAM_HDELAY;

    // Compensate the H position shift due to the phase select
    if (select > 12)
        select  = ((ucPhase + 12) < select) ? (pData[0] - 1) : pData[0];
    else
        select  = (ucPhase < (select + 52)) ? (pData[0] - 1) : pData[0];

    CScalerSetBit(_PLLDIV_H_A9, ~_BIT6, _BIT6);
    CScalerSetBit(_PLLPHASE_CTRL1_AC, 0xc0, ucPhase);               // Set phase
    CAdjustIHSDelay(select);                                        // Compensate IHS delay
    CScalerSetBit(_VGIP_DELAY_CTRL_07, ~_BIT3, (ctrl << 3));        // Select a correct edge to latch the stable data

    CMiscApplyDoubleBuffer();

    CMiscClearStatusRegister();

    CAdjustEnableWatchDog(_WD_ALL);
}

//--------------------------------------------------
// Description  : Set H Position
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CAdjustHPosition(void)
{
    // Update IHS delay according to phase
    CAdjustPhase(stModeUserData.Phase);
}

//--------------------------------------------------
// Description  : Set V Position
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CAdjustVPosition(void)
{
/*
    BYTE temp;

    CAdjustEnableWatchDog(_WD_APLL_NONLOCK);

    temp = stModeInfo.IVTotal + ucVStartBias - stModeInfo.IVHeight - stModeInfo.IVStartPos;

    if((stModeInfo.IVStartPos < stModeUserData.VPosition) && ((stModeUserData.VPosition - stModeInfo.IVStartPos) > ucVStartBias))
        stModeUserData.VPosition = stModeInfo.IVStartPos + ucVStartBias;

    if((stModeInfo.IVStartPos > stModeUserData.VPosition) && ((stModeInfo.IVStartPos - stModeUserData.VPosition) > temp))
        stModeUserData.VPosition = stModeInfo.IVStartPos - temp;

    CAdjustIVSDelay(ucVStartBias + stModeInfo.IVStartPos - stModeUserData.VPosition + _PROGRAM_VDELAY - 1);

    CMiscApplyDoubleBuffer();

    CTimerWaitForEvent(_EVENT_DEN_STOP);
    CTimerWaitForEvent(_EVENT_DEN_START);

    CMiscClearStatusRegister();

    CAdjustEnableWatchDog(_WD_ALL);
    */
    //version 200D
        CAdjustEnableWatchDog(_WD_APLL_NONLOCK);

    if((stModeInfo.IVStartPos < stModeUserData.VPosition) && ((stModeUserData.VPosition - stModeInfo.IVStartPos) > ucVStartBias))
        stModeUserData.VPosition = stModeInfo.IVStartPos + ucVStartBias;

    if((stModeInfo.IVStartPos > stModeUserData.VPosition) && ((stModeInfo.IVStartPos - stModeUserData.VPosition) > ucVStartBias))
        stModeUserData.VPosition = stModeInfo.IVStartPos - ucVStartBias;

#if(_V_POSITION_DIRECTION == _LAST_LINE_METHOD_0)

    CAdjustIVSDelay(ucVStartBias + stModeInfo.IVStartPos - stModeUserData.VPosition + _PROGRAM_VDELAY);

#endif

#if(_V_POSITION_DIRECTION == _LAST_LINE_METHOD_1)

    CAdjustIVSDelay(ucVStartBias - (stModeInfo.IVStartPos - stModeUserData.VPosition) + _PROGRAM_VDELAY);

#endif

    CMiscApplyDoubleBuffer();

    CTimerWaitForEvent(_EVENT_DEN_STOP);
    CTimerWaitForEvent(_EVENT_DEN_START);

    CMiscClearStatusRegister();

    CAdjustEnableWatchDog(_WD_ALL);

}

//--------------------------------------------------
// Description  : Adjust Digital Filter
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CAdjustDigitalFilter(BYTE ucAccess, BYTE ucOffset, BYTE ucDiv, BYTE ucEnable)
{
    pData[0] = ((ucAccess & 0x07) << 5) | 0x00;

    if(ucAccess == _YPBPR_ACCESS_PORT)
    {
        pData[1] = ((ucOffset & 0x07) << 5) | 0x10;
    }
    else
    {
        pData[1] = ((ucEnable & 0x01) << 7) | ((ucOffset & 0x07) << 4) | ((ucDiv & 0x03) << 2);
    }

    CScalerWrite(_DIGITAL_FILTER_CTRL_17, 2, pData, _AUTOINC);

    CScalerSetByte(_DIGITAL_FILTER_CTRL_17, 0x00);
}