api_eeprom.c

其乐达(Cheertek)LCD驱动芯片(CT675)的C51源代码

#include "..\INC\SYS_DECLARE.H"
#include "..\INC\SYS_GLOBAL.H"
#include "..\INC\SYS_EEPROM.H"

#include "INC\API_IIC.H"
#include "INC\API_EEPROM.H"

void _LoadDefault(WORD wAddr, BYTE code *pData, BYTE bCnt)
{
    BYTE it;

    for(it = 0; it < bCnt; it++)
        gbTrmBuf[it] = *(pData + it);

    it = API_EEPROM_CalCheckSum(gbTrmBuf, bCnt);
    gbTrmBuf[bCnt] = it;

    API_EE_WriteBurst(wAddr, bCnt + 1);
}

void _StoreParameter(WORD wAddr, BYTE bCnt)
{
    BYTE it;

    it = API_EEPROM_CalCheckSum(gbTrmBuf, bCnt);
    gbTrmBuf[bCnt] = it;

    API_EE_WriteBurst(wAddr, bCnt + 1);
}

void _WithdrawParameter(WORD wAddr, BYTE code *pData, BYTE bCnt)
{
    BYTE it, csum;

    API_EE_ReadBurst(wAddr, bCnt + 1);
    csum = gbTrmBuf[bCnt];

    it = API_EEPROM_CalCheckSum(gbTrmBuf, bCnt);

    if(csum != it)
    {
        _LoadDefault(wAddr, pData, bCnt);
    }
}

void API_EEPROM_CheckVersionNo(void)
{
    WORD MainVersionNo;
    BYTE SubVersionNo;


    SubVersionNo = API_EE_ReadByte(EE_SUB_VERSION_NO);;

    API_EE_ReadBurst(EE_MAIN_VERSION_NO, 2);
    MainVersionNo = (((WORD)gbTrmBuf[0]) << 8) + gbTrmBuf[1];

    if((SubVersionNo != (BYTE)(SUB_VERSION_NO)) || (MainVersionNo != (WORD)(MAIN_VERSION_NO)))
    {
        SubVersionNo = (BYTE)(SUB_VERSION_NO);
        MainVersionNo = (WORD)(MAIN_VERSION_NO);

        gbTrmBuf[0] = (BYTE)(MainVersionNo >> 8);
        gbTrmBuf[1] = (BYTE)(MainVersionNo & 0x00FF);

        API_EE_WriteByte(EE_SUB_VERSION_NO, SubVersionNo);
        API_EE_WriteBurst(EE_MAIN_VERSION_NO, 2);
        API_EEPROM_LoadAllDefault();
    }
    else
    {
        API_EEPROM_WithdrawParameters(EE_SYS_INFO);
    }
}

BYTE API_EEPROM_CalCheckSum(BYTE *pData, BYTE bCnt)
{
    BYTE it, csum = 0;

    for(it = 0; it < bCnt; it++)
        csum += *(pData + it);

    return csum;
}

void API_EEPROM_LoadDefault(BYTE bSection)
{
    BYTE bOffset;
    BYTE code *dptr;

    switch(bSection)
    {
        case EE_SYS_INFO:
            _LoadDefault(EE_SYS_INFO_ADDR, EE_SysInfoDefaultTable, EE_SYS_INFO_ITEMS);

            gSysInfo.bPowerStatus   = gbTrmBuf[0] & 0x03;
            gSysInfo.fBurnMode      = gbTrmBuf[1] & 0x01;
            gSysInfo.fFactoryMode   = gbTrmBuf[2] & 0x01;
            gSysInfo.bInputSource   = gbTrmBuf[3] & 0x07;
            break;

        case EE_SCALER:
            _LoadDefault(EE_SCALER_ADDR, EE_ScalerDefaultTable, EE_SCALER_ITEMS);

            gScalerPara.fAspectType    = gbTrmBuf[0]  & 0x01;
            gScalerPara.bFlipMode      = gbTrmBuf[1]  & 0x03;
            // CTRL BYTE HERE
            gScalerPara.bBkliteBright  = gbTrmBuf[3];
            gScalerPara.bOsdAlphaBlind = gbTrmBuf[4]  & 0x0F;
            break;

        case EE_SC_COLOR:
            bOffset = 16 * (gSysInfo.bInputSource * 3 + gSysInfo.bVideoSystem);
            dptr    = EE_ScColorParaDefault[gSysInfo.bInputSource];
            dptr    = dptr + gSysInfo.bVideoSystem * EE_SC_COLOR_ITEMS;

            _LoadDefault(EE_SC_CVBS_N_ADDR + bOffset, dptr, EE_SC_COLOR_ITEMS);

            gScalerPara.bBrightness    = gbTrmBuf[0];
            gScalerPara.bContrast      = gbTrmBuf[1];
            gScalerPara.bHue           = gbTrmBuf[2];
            gScalerPara.bSaturation    = gbTrmBuf[3];
            gScalerPara.bSharpness     = gbTrmBuf[4] & 0x0F;
            gScalerPara.bCTI           = gbTrmBuf[5] & 0x0F;
            gScalerPara.bNR            = gbTrmBuf[6] & 0x0F;
            break;

        case EE_VIDEO:
            _LoadDefault(EE_VIDEO_ADDR, EE_VideoDefaultTable, EE_VIDEO_ITEMS);

            gVideoPara.bBrightness = gbTrmBuf[0];
            gVideoPara.bContrast   = gbTrmBuf[1];
            gVideoPara.bHue        = gbTrmBuf[2];
            gVideoPara.bSaturation = gbTrmBuf[3];
            break;

        default:
            break;
    };
}

void API_EEPROM_StoreParameters(BYTE bSection)
{
    BYTE bOffset;

    switch(bSection)
    {
        case EE_SYS_INFO:
            gbTrmBuf[0] = gSysInfo.bPowerStatus;
            gbTrmBuf[1] = gSysInfo.fBurnMode;
            gbTrmBuf[2] = gSysInfo.fFactoryMode;
            gbTrmBuf[3] = gSysInfo.bInputSource;

            _StoreParameter(EE_SYS_INFO_ADDR, EE_SYS_INFO_ITEMS);
            break;

        case EE_SCALER:
            gbTrmBuf[0] = gScalerPara.fAspectType;
            gbTrmBuf[1] = gScalerPara.bFlipMode;
            gbTrmBuf[2] = 0; // CTRL BYTE HERE
            gbTrmBuf[3] = gScalerPara.bBkliteBright;
            gbTrmBuf[4] = gScalerPara.bOsdAlphaBlind;

            _StoreParameter(EE_SCALER_ADDR, EE_SCALER_ITEMS);
            break;

        case EE_SC_COLOR:
            gbTrmBuf[0] = gScalerPara.bBrightness;
            gbTrmBuf[1] = gScalerPara.bContrast;
            gbTrmBuf[2] = gScalerPara.bHue;
            gbTrmBuf[3] = gScalerPara.bSaturation;
            gbTrmBuf[4] = gScalerPara.bSharpness;
            gbTrmBuf[5] = gScalerPara.bCTI;
            gbTrmBuf[6] = gScalerPara.bNR;

            bOffset = 16 * (gSysInfo.bInputSource * 3 + gSysInfo.bVideoSystem);

            _StoreParameter(EE_SC_CVBS_N_ADDR + bOffset, EE_SC_COLOR_ITEMS);
            break;

        case EE_VIDEO:
            gbTrmBuf[0] = gVideoPara.bBrightness;
            gbTrmBuf[1] = gVideoPara.bContrast;
            gbTrmBuf[2] = gVideoPara.bHue;
            gbTrmBuf[3] = gVideoPara.bSaturation;

            _StoreParameter(EE_VIDEO_ADDR, EE_VIDEO_ITEMS);
            break;

        default:
            break;
    };
}

void API_EEPROM_WithdrawParameters(BYTE bSection)
{
    BYTE bOffset;
    BYTE code *dptr;

    switch(bSection)
    {
        case EE_SYS_INFO:
            _WithdrawParameter(EE_SYS_INFO_ADDR, EE_SysInfoDefaultTable, EE_SYS_INFO_ITEMS);

            gSysInfo.bPowerStatus   = gbTrmBuf[0] & 0x03;
            gSysInfo.fBurnMode      = gbTrmBuf[1] & 0x01;
            gSysInfo.fFactoryMode   = gbTrmBuf[2] & 0x01;
            gSysInfo.bInputSource   = gbTrmBuf[3] & 0x07;
            break;

        case EE_SCALER:
            _WithdrawParameter(EE_SCALER_ADDR, EE_ScalerDefaultTable, EE_SCALER_ITEMS);

            gScalerPara.fAspectType    = gbTrmBuf[0]  & 0x01;
            gScalerPara.bFlipMode      = gbTrmBuf[1]  & 0x03;
            // CTRL BYTE HERE
            gScalerPara.bBkliteBright  = gbTrmBuf[3];
            gScalerPara.bOsdAlphaBlind = gbTrmBuf[4]  & 0x0F;
            break;

        case EE_SC_COLOR:
            bOffset = 16 * (gSysInfo.bInputSource * 3 + gSysInfo.bVideoSystem);
            dptr    = EE_ScColorParaDefault[gSysInfo.bInputSource];
            dptr    = dptr + gSysInfo.bVideoSystem * EE_SC_COLOR_ITEMS;

            _WithdrawParameter(EE_SC_CVBS_N_ADDR + bOffset, dptr, EE_SC_COLOR_ITEMS);

            gScalerPara.bBrightness    = gbTrmBuf[0];
            gScalerPara.bContrast      = gbTrmBuf[1];
            gScalerPara.bHue           = gbTrmBuf[2];
            gScalerPara.bSaturation    = gbTrmBuf[3];
            gScalerPara.bSharpness     = gbTrmBuf[4] & 0x0F;
            gScalerPara.bCTI           = gbTrmBuf[5] & 0x0F;
            gScalerPara.bNR            = gbTrmBuf[6] & 0x0F;
            break;

        case EE_VIDEO:
            _WithdrawParameter(EE_VIDEO_ADDR, EE_VideoDefaultTable, EE_VIDEO_ITEMS);

            gVideoPara.bBrightness = gbTrmBuf[0];
            gVideoPara.bContrast   = gbTrmBuf[1];
            gVideoPara.bHue        = gbTrmBuf[2];
            gVideoPara.bSaturation = gbTrmBuf[3];
            break;

        default:
            break;
    };
}

void API_EEPROM_LoadAllDefault(void)
{
    BYTE it, ix, iy;
    BYTE bSource;
    BYTE bSystem;

    for(it = EE_SYS_INFO; it <= EE_VIDEO; it++)
    {
        if(it != EE_SC_COLOR)
        {
            API_EEPROM_LoadDefault(it);

            if(it == EE_SYS_INFO)
            {
                bSource = gSysInfo.bInputSource;
                bSystem = gSysInfo.bVideoSystem;
            }
        }
        else
        {
            for(iy = 0; iy < 3; iy++)
            {
                gSysInfo.bVideoSystem = iy;

                for(ix = EN_INPUT_CVBS; ix <= EN_INPUT_CCIR656; ix++)
                {
                    gSysInfo.bInputSource = ix;
                    API_EEPROM_LoadDefault(it);
                }
            }

            gSysInfo.bVideoSystem = bSystem;
            gSysInfo.bInputSource = bSource;
        }
    }
}

void API_EEPROM_WithdrawAllPara(void)
{
    BYTE it;

    for(it = EE_SYS_INFO; it <= EE_VIDEO; it++)
    {
        API_EEPROM_WithdrawParameters(it);
    }
}

void API_EEPROM_StoreAllPara(void)
{
    BYTE it;

    for(it = EE_SYS_INFO; it <= EE_VIDEO; it++)
    {
        API_EEPROM_StoreParameters(it);
    }
}