memory.c

realtek LCD monitor, TV开发源代码

        Compress = 0;
    }
    else if(Resolution == 15)
    {
        CScalerSetBit(_P3_LS_CTRL0_A1, ~(_BIT2 | _BIT1 | _BIT0),(((_DISP_BIT_MODE << 7) >> 5) | 0x01));
        CScalerSetBit(_P3_LS_CPRS_CTRL_A4, ~(_BIT6 | _BIT5 | _BIT4), _BIT5);
        Compress = 0;
    }
//Anderson 20080710 for YUV 6 bit first Start
    else if(Resolution == 12) // Use YUV 6bit OD
    {
        //CScalerSetBit(_P3_LS_CTRL0_A1, ~(_BIT2 | _BIT1 | _BIT0),(((_DISP_BIT_MODE << 7) >> 5) | 0x02));
        //CScalerSetBit(_P3_LS_CPRS_CTRL_A4, ~(_BIT6 | _BIT5), 0x00);
        CScalerSetBit(_P3_LS_CTRL0_A1, ~(_BIT2 | _BIT1 | _BIT0),(((_DISP_BIT_MODE << 7) >> 5) | 0x00));
        CScalerSetBit(_P3_LS_CPRS_CTRL_A4, ~(_BIT6 | _BIT5 | _BIT4), (_BIT6 | _BIT4));
//Anderson 20080710 for YUV 6 bit first End
        Compress = 0;
    }
    else if(Resolution == 10)
    {
        CScalerSetBit(_P3_LS_CTRL0_A1, ~(_BIT2 | _BIT1 | _BIT0),(((_DISP_BIT_MODE << 7) >> 5) | 0x01)); //Anderson 080512
        CScalerSetBit(_P3_LS_CPRS_CTRL_A4, ~(_BIT6 | _BIT5 | _BIT4), (_BIT5 | _BIT4));
        Compress = 0;
    }
    else if(Resolution == 8)
    {
        CScalerSetBit(_P3_LS_CTRL0_A1, ~(_BIT2 | _BIT1 | _BIT0),(((_DISP_BIT_MODE << 7) >> 5) | 0x02)); //Anderson 080512
        CScalerSetBit(_P3_LS_CPRS_CTRL_A4, ~(_BIT6 | _BIT5| _BIT4), _BIT4);
        Compress = 0;
    }
    else
    {
        return _FALSE;
    }

    if((Resolution == 10) || (Resolution == 8))
    {
        Compress = _FALSE;
    }
    else
    {
        Compress = (Compress | _OD_COMPRESSION);
    }

    CScalerSetBit(_P3_LS_CTRL0_A1, ~_BIT4, (Compress << 4));

    if(Compress == _TRUE)
    {
        //Rounding to 5bit/4bit
        if(Resolution == 18)
        {
            CScalerSetBit(_P3_LS_CPRS_CTRL_A4, ~(_BIT6 | _BIT5), _BIT5);
            Resolution = 15;
        }
        else
        {
            CScalerSetBit(_P3_LS_CPRS_CTRL_A4, ~(_BIT6 | _BIT5), 0x00);
            Resolution = 12;
        }

        pData[0] = (HIBYTE(_COMPRESS_GROUP_NUMBER) & 0x07); //Anderson 080205 Support to 1280
        pData[1] = (LOBYTE(_COMPRESS_GROUP_NUMBER));
        CScalerWrite(_P3_LS_GRP_NUM_H_A7, 2, pData, _AUTOINC);

        usTarget = (WORD)Resolution * _COMPRESS_GROUP_NUMBER / 64;

        pData[0] = (HIBYTE(usTarget) & 0x01);
        pData[1] = (LOBYTE(usTarget));
        CScalerWrite(_P3_LS_TG_SIZE_H_A5, 2, pData, _AUTOINC);
    }

    return _TRUE;

}

//--------------------------------------------------
// Description  : Set OD FIFO
// Input Value  : NONE
// Output Value : NONE
//--------------------------------------------------
void CMemorySetODFIFO(void)//V402 modify
{

    BYTE Resolution = 18; //OD Resolution
    BYTE Length = 128; //SDRAM Length
    DWORD ulValue = 0; //Number and Remain
    //Anderson 080528 for OD Highlight Window Start
    WORD usHWidth = 0; //Horizontal Width
    WORD usVHeight = 0; //Vertical Height

    if(stModeInfo.IHWidth < stDisplayInfo.DHWidth)
    {
        usHWidth = stModeInfo.IHWidth;
    }
    else
    {
        usHWidth = stDisplayInfo.DHWidth;
    }

    if(stModeInfo.IVHeight < stDisplayInfo.DVHeight)
    {
        usVHeight = stModeInfo.IVHeight;
    }
    else
    {
        usVHeight = stDisplayInfo.DVHeight;
    }

    CScalerPageSelect(_PAGE3);
    CScalerRead(_P3_LS_CPRS_CTRL_A4, 1, pData, _NON_AUTOINC);

    if((pData[0] & 0x10) == 0x10)
    {

        if((pData[0] & 0x40) == 0x40)
        {
            Resolution = 12;
        }
        else if((pData[0] & 0x20) == 0x20)
        {
            Resolution = 10;
        }
        else
        {
            Resolution = 8;
        }

    }
    else
    {
        if((pData[0] & 0x40) == 0x40)
        {
            Resolution = 18;
        }
        else if((pData[0] & 0x20) == 0x20)
        {
            Resolution = 15;
        }
        else
        {
            Resolution = 12;
        }

    }
//Anderson 20080710 OD HW Start
#if(_OD_HW_MODE_SUPPORT == _ON)

    if(GET_FRCENABLE())
    {
        ((DWORD *)pData)[0] = (((DWORD)usHWidth * usVHeight) * Resolution % 64) ?
                              ((((DWORD)usHWidth * usVHeight) * Resolution / 64) + 1) :
                              (((DWORD)usHWidth * usVHeight) * Resolution / 64); //One frame total pixel for SDRAM (unit : 64 bits)
    }
    else
#endif // End of #if(_OD_HW_MODE_SUPPORT == _ON)
//Anderson 20080710 OD HW End
    {
        ((DWORD *)pData)[0] = (((DWORD)_PANEL_DH_WIDTH * _PANEL_DV_HEIGHT) * Resolution % 64) ?
                              ((((DWORD)_PANEL_DH_WIDTH * _PANEL_DV_HEIGHT) * Resolution / 64) + 1) :
                              (((DWORD)_PANEL_DH_WIDTH * _PANEL_DV_HEIGHT) * Resolution / 64);// One frame total pixel for SDRAM (unit : 64 bits)
    }
//Anderson 080528 for OD Highlight Window End
//Anderson 080422 for OD End

    ulValue = CMemoryCalculateNumberAndRemain(((DWORD *)pData)[0], Length, 1);

    CScalerPageSelect(_PAGE3);
    CScalerSetByte(_P3_LS_WTLVL_W_C0, (Length / 2));
    CScalerSetByte(_P3_LS_WTLVL_R_C1, (Length / 2));

    pData[0] = (HIBYTE(ulValue));
    pData[1] = (LOBYTE(ulValue));
    CScalerWrite(_P3_LS_MEM_FIFO_RW_NUM_H_C2, 2, pData, _AUTOINC);

    CScalerSetByte(_P3_LS_MEM_FIFO_RW_LEN_C4, Length);
    CScalerSetByte(_P3_LS_MEM_FIFO_RW_REMAIN_C5, ((ulValue >> 16) & 0xff));

}

#endif //End of #if(_OD_SUPPORT == _ON)

#if(_FRC_SUPPORT == _ON)
//--------------------------------------------------
// Description  : IN1&MAIN FIFO Setting for FRC Mode
// Input Value  : usHorSize --> Horizontal size
///               usVerSize --> Vertical Size
// Output Value : None
//--------------------------------------------------
void CMemoryControlForFRC(WORD usHorSize, WORD usVerSize)
{

    CScalerSetByte(_FIFO_FREQUENCY_22,0x00);//Anderson 080422
    CMemoryCtrlForFRCInput(usHorSize, usVerSize);
    CMemoryCtrlForFRCDisplay(usHorSize, usVerSize);

}

//--------------------------------------------------
// Description  : IN1 FIFO Setting for FRC Mode
// Input Value  : ucHorSize --> Horizontal size
//                ucVerSize --> Vertical Size
// Output Value : None
//--------------------------------------------------
void CMemoryCtrlForFRCInput(WORD usHorSize, WORD usVerSize)
{

    BYTE Length = 160; //SDRAM Length
    DWORD ulValue = 0; //Number and Remain
    DWORD ulStep = 0; //Line Step

//Anderson 080422 for FRC Start
#if(_FRC_YUV_MODE_SUPPORT == _ON)

    if(GET_FRC422STATUS())
    {
        ((DWORD *)pData)[0] = ((DWORD)usHorSize * 2 * 8 % 64) ?
                              (((DWORD)usHorSize * 2 * 8 / 64) + 1) :
                              ((DWORD)usHorSize * 2 * 8 / 64);// One line total pixel for SDRAM (unit : 64 bits)
    }
    else
#endif
    {

#if(_FRC_MODE == _LINE_MODE)
        ((DWORD *)pData)[0] = ((DWORD)usHorSize * 3 * 8 % 64) ?
                              (((DWORD)usHorSize * 3 * 8 / 64) + 1) :
                              ((DWORD)usHorSize * 3 * 8 / 64);// One line total pixel for SDRAM (unit : 64 bits)
#else
        ((DWORD *)pData)[0] = ((DWORD)usHorSize * usVerSize * 3 * 8 % 64) ?
                              (((DWORD)usHorSize * usVerSize * 3 * 8 / 64) + 1) :
                              ((DWORD)usHorSize * usVerSize * 3 * 8 / 64);// One Frame total pixel for SDRAM (unit : 64 bits)
#endif // End of #if(_FRC_MODE == _LINE_MODE)

    }
//Anderson 080422 for FRC End

    ulValue = CMemoryCalculateNumberAndRemain(((DWORD *)pData)[0], Length, 1);
    ulStep = CMemoryCalculateLineStepAndBlockStep(usHorSize, usVerSize);

    pData[0] = Length;
    pData[1] = HIBYTE(ulValue);
    pData[2] = LOBYTE(ulValue);
    pData[3] = Length;
    pData[4] = (ulValue >> 16) & 0xff;
    pData[5] = (BYTE)(_FRC_1ST_BLOCK_STA_ADDR >> 16);
    pData[6] = (BYTE)(_FRC_1ST_BLOCK_STA_ADDR >> 8);
    pData[7] = (BYTE)(_FRC_1ST_BLOCK_STA_ADDR >> 0);
    pData[8] = (BYTE)(ulStep >> 24); //LINE_STEP
    pData[9] = (BYTE)(ulStep >> 16); //LINE_STEP

#if(_FIELD_MERGE_SUPPORT == _ON)

    if(GET_FIELDMERGE_MODE())
    {
        pData[10] = (BYTE)(_FRC_2ND_BLOCK_STA_ADDR >> 20); //BLOCK_STEP
        pData[11] = (BYTE)(_FRC_2ND_BLOCK_STA_ADDR >> 12); //BLOCK_STEP
    }
    else
    {
        pData[10] = 0x00; //BLOCK_STEP
        pData[11] = 0x00; //BLOCK_STEP
    }

#else
    pData[10] = 0x00; //BLOCK_STEP
    pData[11] = 0x00; //BLOCK_STEP
#endif

    pData[12] = (BYTE)(_FRC_2ND_BLOCK_STA_ADDR >> 16);
    pData[13] = (BYTE)(_FRC_2ND_BLOCK_STA_ADDR >> 8);
    pData[14] = (BYTE)(_FRC_2ND_BLOCK_STA_ADDR >> 0);

    CScalerPageSelect(_PAGE5);
    CScalerWrite(_P5_SDRF_IN1_WATER_LEVEL_A8, 15, pData, _AUTOINC);

#if(_FRC_MODE == _LINE_MODE)
    pData[0] = (((usVerSize >> 8) & 0x0f) | 0x00);
#else
    pData[0] = (((usVerSize >> 8) & 0x0f) | 0x10);
#endif // End of #if(_FRC_MODE == _LINE_MODE

    pData[1] = LOBYTE(usVerSize);

//Anderson 080528 for FRC YUV Mode Start
#if(_FIELD_MERGE_SUPPORT == _ON)

    if(GET_FIELDMERGE_MODE())
    {
        pData[2] = 0xe2; //0xc2;
    }
    else
#if(_FRC_YUV_MODE_SUPPORT == _ON)
    {
        pData[2] = 0xa2; //Double Buffer
    }
#else
//Anderson V008_20080730 for Frame Rate Conversion Start
    {
        if(GET_FRCDOUBLEFRAME())
        {
            pData[2] = 0xa2; //Double Buffer
        }
        else
        {
            pData[2] = 0x82; //Single Buffer
        }
    }
//Anderson V008_20080730 for Frame Rate Conversion End
#endif // End of #if(_FRC_YUV_MODE_SUPPORT == _ON)

#else // #if(_FIELD_MERGE_SUPPORT != _ON)

#if(_FRC_YUV_MODE_SUPPORT == _ON)
    pData[2] = 0xa2;//Double Buffer
#else
//Anderson V008_20080730 for Frame Rate Conversion Start
    if(GET_FRCDOUBLEFRAME())
    {
        pData[2] = 0xa2;//Double Buffer
    }
    else
    {
        pData[2] = 0x82;//Single Buffer
    }
//Anderson V008_20080730 for Frame Rate Conversion End
#endif // End of #if(_FRC_YUV_MODE_SUPPORT == _ON)

#endif // End of #if(_FIELD_MERGE_SUPPORT == _ON)

//Anderson 080528 for FRC YUV Mode End
    CScalerWrite(_P5_SDRF_IN1_LINE_NUM_H_B7, 3, pData, _AUTOINC);

}

//--------------------------------------------------
// Description  : MAIN FIFO Setting for FRC Mode
// Input Value  : usHorSize --> Horizontal size
//                usVerSize --> Vertical Size
// Output Value : None
//--------------------------------------------------
void CMemoryCtrlForFRCDisplay(WORD usHorSize, WORD usVerSize)
{

    BYTE Length = 160;
    DWORD ulValue = 0; //Number and Remain
    DWORD ulStep = 0; //Line Step

//Anderson 080422 for FRC Start
#if(_FRC_YUV_MODE_SUPPORT == _ON)
    if(GET_FRC422STATUS())
    {
        ((DWORD *)pData)[0] = ((DWORD)usHorSize * 2 * 8 % 64) ?
                              (((DWORD)usHorSize * 2 * 8 / 64) + 1) :
                              ((DWORD)usHorSize * 2 * 8 / 64);// One line total pixel for SDRAM (unit : 64 bits)
    }
    else
#endif
    {
#if(_FRC_MODE == _LINE_MODE)
        ((DWORD *)pData)[0] = ((DWORD)usHorSize * 3 * 8 % 64) ?