memory.c

realtek LCD monitor, TV开发源代码

#if(_DEBUG_MESSAGE_SUPPORT == _ON)
    CMiscDebugMessage("(DWORD)stModeInfo.IHFreq ", (DWORD)stModeInfo.IHFreq );
    CMiscDebugMessage("stDisplayInfo.DHTotal", stDisplayInfo.DHTotal);
    CMiscDebugMessage("((DWORD *)pData)[3]", ((DWORD *)pData)[3] );
#endif

    for(PixelChannel=PixelChannelAfterSize; PixelChannel>1; PixelChannel--)
    {
        for(Resolution=ResolutionAfterSize; Resolution>3; Resolution--)
        {

            if(!GET_FRCENABLE())
            {
                usFrequency = (DWORD)_PANEL_DH_WIDTH * ((DWORD *)pData)[3] / _PANEL_DH_TOTAL * Resolution * PixelChannel * 2 / _MEMORY_BUS_WIDTH * 100 / 90 / 1000;
#if(_DEBUG_MESSAGE_SUPPORT == _ON)
                CMiscDebugMessage("OD Speed(OD ON)", (DWORD)usFrequency * 1000000);
#endif
                if((usFrequency < _MEMORY_SPEED) && (Resolution > 3))
                {
                    break;
                }

            }
#if(_FRC_SUPPORT == _ON)
            else
            {
//Anderson 20080710 OD HW Start
#if(_OD_HW_MODE_SUPPORT == _ON)
                //Frequency = (DWORD)HWidth * ((DWORD *)pData)[3] / _PANEL_DH_TOTAL * Resolution * PixelChannel * 2 / _MEMORY_BUS_WIDTH * 100 / 90 / 1000;
                usFrequency = (DWORD)_PANEL_DH_WIDTH * ((DWORD *)pData)[3] / _PANEL_DH_TOTAL * Resolution * PixelChannel * 2 / _MEMORY_BUS_WIDTH * 100 / 90 / 1000;//Anderson V008_20080730 to Solve the Efficient Issue
#else
                usFrequency = (DWORD)_PANEL_DH_WIDTH * ((DWORD *)pData)[3] / _PANEL_DH_TOTAL * Resolution * PixelChannel * 2 / _MEMORY_BUS_WIDTH * 100 / 90 / 1000;

#endif // End of #if(_OD_HW_MODE_SUPPORT == _ON)
//Anderson 20080710 OD HW End

#if(_DEBUG_MESSAGE_SUPPORT == _ON)
                CMiscDebugMessage("OD Speed(FRC ON)", (DWORD)usFrequency * 1000000);

                CMiscDebugMessage("Remain Speed", ((DWORD)_MEMORY_SPEED * 1000000 - ((DWORD *)pData)[1]));
#endif

                if((((DWORD)usFrequency * 1000000) < ((DWORD)_MEMORY_SPEED * 1000000 - ((DWORD *)pData)[1])) && (Resolution > 3))
                {
                    break;
                }

            } // End of if(!GET_FRCENABLE())
#endif

        } // End of for(Resolution=ResolutionAfterSize; Resolution>3; Resolution--)

        if(!GET_FRCENABLE())
        {

            if((usFrequency < _MEMORY_SPEED) && (Resolution > 3))
            {
                break;
            }

        }
        else
        {

            if((((DWORD)usFrequency * 1000000) < ((DWORD)_MEMORY_SPEED * 1000000 - ((DWORD *)pData)[1])) && (Resolution > 3))
            {
                break;
            }

        }
    } // End of for(PixelChannel=PixelChannelAfterSize; PixelChannel>1; PixelChannel--)

#if(_DEBUG_MESSAGE_SUPPORT == _ON)
    CMiscDebugMessage("Resolution_after_speed", Resolution * PixelChannel);
#endif

    if((Resolution < 4) && (PixelChannel <= 2))
    {
        return _FALSE;
    }

    ulODStartAddress = _OD_START_ADDRESS;

#if(_FRC_SUPPORT == _ON)

#if(_FRC_YUV_MODE_SUPPORT == _ON)

    if(GET_FRC422STATUS())
    {
        ((DWORD *)pData)[0] = (DWORD)usHWidth * usVHeight * 2 * 8 * 2 / _MEMORY_BUS_WIDTH;
    }
    else
    {
        ((DWORD *)pData)[0] = (DWORD)usHWidth * usVHeight * 3 * 8 * 2 / _MEMORY_BUS_WIDTH;
    }

#else

//Anderson V008_20080730 for Frame Rate Conversion Start
    if(GET_FRCDOUBLEFRAME())
    {
        ((DWORD *)pData)[0] = (DWORD)usHWidth * usVHeight * 3 * 8 * 2 / _MEMORY_BUS_WIDTH;
    }
    else
    {
        ((DWORD *)pData)[0] = (DWORD)usHWidth * usVHeight * 3 * 8 * 1 / _MEMORY_BUS_WIDTH;
    }
//Anderson V008_20080730 for Frame Rate Conversion End

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

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

#if(_DEBUG_MESSAGE_SUPPORT == _ON)
    CMiscDebugMessage("FRC Size", ((DWORD *)pData)[0]);
#endif

#if((_OD_SUPPORT == _ON) && (_FRC_SUPPORT == _ON))

    if(GET_FRCENABLE())
    {
        ulODStartAddress += ((DWORD *)pData)[0];
    }

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

#if(_DEBUG_MESSAGE_SUPPORT == _ON)
    CMiscDebugMessage("OD Start Addr", ulODStartAddress);
#endif

//---------------------OD Highlight Window-----------------//
//Anderson 20080710 Start
#if(_OD_HW_MODE_SUPPORT == _ON)

    CScalerSetByte(_DISP_ACCESS_PORT_2A, (0x80 | _DISP_DH_BKGD_STA_H_03));
    CScalerRead(_DISP_DATA_PORT_2B, 4, pData, _NON_AUTOINC);//Read Display Horizontal Background Start
    ((WORD *)pData)[7] = ((WORD)pData[2] << 8 | pData[3]) - ((WORD)pData[0] << 8 | pData[1]);//Display Horizontal Background Start

    pData[0] = HIBYTE(((WORD *)pData)[7]);
    pData[1] = LOBYTE(((WORD *)pData)[7]);
    pData[2] = HIBYTE(((WORD *)pData)[7] + stDisplayInfo.DHWidth);//Anderson V008_20080730
    pData[3] = LOBYTE(((WORD *)pData)[7] + stDisplayInfo.DHWidth);//Anderson V008_20080730

    CScalerSetByte(_DISP_ACCESS_PORT_2A, (0x80 | _DISP_DV_BKGD_STA_H_0E));
    CScalerRead(_DISP_DATA_PORT_2B, 4, &pData[4], _NON_AUTOINC);//Read Display Vertical Background Start
    ((WORD *)pData)[7] = ((WORD)pData[6] << 8 | pData[7]) - ((WORD)pData[4] << 8 | pData[5]);//Display Vertical Background Start

    pData[4] = HIBYTE(((WORD *)pData)[7]);
    pData[5] = LOBYTE(((WORD *)pData)[7]);
    pData[6] = HIBYTE(((WORD *)pData)[7] + stDisplayInfo.DVHeight);//Anderson V008_20080730
    pData[7] = LOBYTE(((WORD *)pData)[7] + stDisplayInfo.DVHeight);//Anderson V008_20080730
    pData[8] = 0x00;//Border Width = 0

    CScalerSetBit(_HW_ACCESS_PORT_60, ~(_BIT7 | _BIT6 | _BIT3 | _BIT2 | _BIT1 | _BIT0), _BIT7);
    CTimerWaitForEvent(_EVENT_DEN_STOP);
    CScalerWrite(_HW_DATA_PORT_61, 9, pData, _NON_AUTOINC);
    CScalerSetBit(_HW_ACCESS_PORT_60, ~(_BIT7 | _BIT6), _BIT6);

#endif // End of #if(_OD_HW_MODE_SUPPORT == _ON)
//Anderson 20080710 End

#if(_DEBUG_MESSAGE_SUPPORT == _ON)
    CMiscDebugMessage("stDisplayInfo.DHWidth",stDisplayInfo.DHWidth);
    CMiscDebugMessage("stDisplayInfo.DVHeight",stDisplayInfo.DVHeight);
#endif

    if(bControl == _OD_CONFIRM)
    {
        CScalerPageSelect(_PAGE3);
        pData[0] = (((DWORD)ulODStartAddress >> 16) & 0x3f);
        pData[1] = (((DWORD)ulODStartAddress >> 8) & 0xff);
        pData[2] = ((DWORD)ulODStartAddress & 0xff);
        CScalerWrite(_P3_LS_MEM_START_ADDR_H_C6, 3, pData, _AUTOINC);

#if(_DEBUG_MESSAGE_SUPPORT == _ON)
        CMiscDebugMessage("OD ok", 0x00);
#endif // End of #if(_DEBUG_MESSAGE_SUPPORT == _ON)

        return (Resolution * PixelChannel);
    }

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

    return _TRUE; //To Prevent No Return Value

}
//Anderson 080812 for OD & FRC ON End

//--------------------------------------------------
// Description  : Reset SDRAM
// Input Value  : NONE
// Output Value : NONE
//--------------------------------------------------
void CMemorySDRAMReset(void)
{

    CScalerPageSelect(_PAGE4);
    CScalerSetBit(_P4_SDR_PRCG_A4, ~_BIT4, _BIT4);
    CTimerDelayXms(5);
    CScalerSetBit(_P4_SDR_PRCG_A4, ~_BIT4, 0x00);

}

//--------------------------------------------------
// Description  : Calculate the number and remain
// Input Value  : ulTotalSize --> Image total size
//                ucLength --> Length of SDRAM access
// Output Value : Number and Remain
//--------------------------------------------------
DWORD CMemoryCalculateNumberAndRemain(DWORD ulTotalSize, BYTE ucLength, bit bDummy)
{

    BYTE Remain = 0;
    WORD usNumber = 0;

    if(bDummy)
    {

        if (ulTotalSize & 0x03)
        {
            (ulTotalSize += 4 - (ulTotalSize & 0x03));
        }

    }

    if((ulTotalSize % ucLength) != 0)
    {
        usNumber = ulTotalSize / ucLength;
        Remain = ulTotalSize % ucLength;
    }
    else
    {
        ulTotalSize = ulTotalSize - ucLength;
        usNumber = ulTotalSize / ucLength;
        Remain = ucLength;
    }

    return (((DWORD)Remain << 16) | usNumber);

}
#endif //End of #if((_OD_SUPPORT == _ON) || (_FRC_SUPPORT == _ON))

#if(_OD_SUPPORT == _ON)
//--------------------------------------------------
// Description  : Load OD Table to LUT
// Input Value  : ucColor --> LUT Channel Select
// Output Value : NONE
//--------------------------------------------------
void CMemoryLoadODLUT(BYTE ucColor)
{

    BYTE Repeat = 0; //Repeat LUT or Not

    CScalerPageSelect(_PAGE3);
    CScalerSetBit(_P3_LS_LUT_ROW_ADDR_AE, ~_BIT7, _BIT7);

    if((ucColor == _OD_TABLE_COMMON))
    {
        CScalerSetBit(_P3_LS_LUT_COL_ADDR_AF, ~(_BIT7 | _BIT6), _OD_TABLE_COMMON << 6);
        CMemoryLoadODTable(tOD_TABLE[_OD_TABLE_MIDDLE]);
    }
    else
    {
        for(Repeat=0; Repeat<3; Repeat++)
        {
            CScalerSetBit(_P3_LS_LUT_COL_ADDR_AF, ~(_BIT7 | _BIT6), Repeat << 6);
            CMemoryLoadODTable(tOD_TABLE[Repeat]);
        }
    }

    CScalerSetBit(_P3_LS_LUT_ROW_ADDR_AE, ~_BIT7, 0x00);

}

//--------------------------------------------------
// Description  : Load OD Table to LUT
// Input Value  : pChannelArray --> OD Table Start Address
// Output Value : NONE
//--------------------------------------------------
void CMemoryLoadODTable(BYTE *pChannelArray)
{

    CScalerPageSelect(_PAGE3);//Anderson 080422
    CScalerWrite(_P3_LS_LUT_DATA_B0, 1088, pChannelArray, _NON_AUTOINC);

}

//--------------------------------------------------
// Description  : OD On/Off Select
// Input Value  : ucSelect --> On or Off
// Output Value : NONE
//--------------------------------------------------
void CMemorySetODOnOff(BYTE ucSelect)
{

    CScalerPageSelect(_PAGE3);
    CScalerSetBit(_P3_LS_CTRL0_A1, ~(_BIT6 | _BIT5 | _BIT3), (_BIT6 | _BIT5 | _BIT3));

//Anderson 20080710 for OD Highlight Window Start
#if(_OD_HW_MODE_SUPPORT == _ON)
    CScalerSetBit(_P3_LS_CTRL1_A2, ~_BIT6, 0x00);//Disable Inside Highlight Window
    CScalerSetByte(_P3_LS_CTRL1_A2, ((BYTE)_OD_LBNRT_ENABLE<<4 | _OD_LBNRT_MODE<<3 | _OD_LBNRT_LEVEL) | _BIT7);
#else
    CScalerSetByte(_P3_LS_CTRL1_A2, ((BYTE)_OD_LBNRT_ENABLE<<4 | _OD_LBNRT_MODE<<3 | _OD_LBNRT_LEVEL) | _BIT7 | _BIT6);
#endif
//Anderson 20080710 for OD Highlight Window End


    if((bit)CScalerGetBit(_P3_LS_CPRS_CTRL_A4, _BIT4))
    {
        CScalerSetByte(_P3_LS_FRAME0_CC, 0x19);
        CScalerSetByte(_P3_LS_FRAME1_CD, 0x99);
        CScalerSetBit(_P3_LS_FRAME2_CE, 0x00, (_YC_OD_PIXDIFFVAL & 0x3f));
    }
    else
    {
        CScalerSetByte(_P3_LS_FRAME0_CC, 0x00);
        CScalerSetByte(_P3_LS_FRAME1_CD, 0x00);
        CScalerSetBit(_P3_LS_FRAME2_CE, 0x00, (0 & 0x3f));
    }

    CScalerSetByte(_P3_LS_STATUS0_B6, 0x01);

    CAdjustODeltaGain(_DEFAULT_OD_GAIN);

    if(ucSelect == _ON)
    {
        CScalerSetBit(_P3_LS_CTRL0_A1, ~(_BIT7 | _BIT6), (_BIT7 | _BIT6));
    }
    else
    {
        CScalerSetBit(_P3_LS_CTRL0_A1, ~(_BIT7 | _BIT6), 0x00);
    }

}
//Anderson 080512 Delete CMemoryCalculateODBitResolution

//--------------------------------------------------
// Description  : OD Compress
// Input Value  : NONE
// Output Value : NONE
//--------------------------------------------------
//Anderson 080422 for FRC Start
bit CMemorySetODCompress(void)//V403 modify
{

    BYTE Compress = 0; //Compression Enable or Disable
    BYTE Resolution = 0; //OD Resolution
    WORD usTarget = 0; //Target Size

    CScalerPageSelect(_PAGE3);

    Resolution = CMemorySDRAMConfirm(_OD_CONFIRM);
    Resolution = 12;//1125 sephinroth

    if(Resolution == 18)
    {
        CScalerSetBit(_P3_LS_CTRL0_A1, ~(_BIT2 | _BIT1 | _BIT0),(((_DISP_BIT_MODE << 7) >> 5) | 0x00));
        CScalerSetBit(_P3_LS_CPRS_CTRL_A4, ~(_BIT6 | _BIT5 | _BIT4), _BIT6);