rtd2533b_eeprom.c

Realtek LCD monitor chip RTD25xx source code

//--------------------------------------------------
void CEepromLoadEDIDDataDefault(void)
{
#if((_MCU_TYPE == _MYSON_MTV512) || (_MCU_TYPE == _REALTEK_RTD2120))

    CEepromSaveFlashEDIDData(tEDID_TABLE_VGA, tEDID_TABLE_DVI);

#endif	//End of #if((_MCU_TYPE == _MYSON_MTV512) || (_MCU_TYPE == _REALTEK_RTD2120))
}

//--------------------------------------------------
// Description  : Save EDID Data of Flash.
// Input Value  : pArray1   --> EDID Table 0
//                pArray2   --> EDID Table 1
// Output Value : None
//--------------------------------------------------
void CEepromSaveFlashEDIDData(BYTE *pArray1, BYTE *pArray2)
{
    BYTE cnt;

    for(cnt=0;cnt<128;cnt++)
    {
        if((MCU_FLASH[(_END_PAGE - _START_PAGE + 1) * 1024 + ucFlashEDIDAddr * 8 - 256 + cnt] != tEDID_TABLE_VGA[cnt])
        || (MCU_FLASH[(_END_PAGE - _START_PAGE + 1) * 1024 + ucFlashEDIDAddr * 8 - 128 + cnt] != tEDID_TABLE_DVI[cnt]))
        {
            break;
        }
    }

    if(cnt<128)
    {
        if(ucFlashEDIDAddr == 96)
        {
            CEepromEraseFlash(_EDID);
            MCU_FLASH[(_END_PAGE - _START_PAGE + 2) * 1024 - 1] = _VERSION_CODE;
            ucFlashEDIDAddr = 0;
        } 

        for(cnt=0;cnt<128;cnt++)
	    {
		  MCU_DDCRAM_0[cnt] = pArray1[cnt];
		  MCU_DDCRAM_1[cnt] = pArray2[cnt];
		  MCU_FLASH[31 * 1024 + ucFlashEDIDAddr * 8 + cnt]        = pArray1[cnt];
		  MCU_FLASH[31 * 1024 + ucFlashEDIDAddr * 8 + 128 + cnt]  = pArray2[cnt];    
        }

        ucFlashEDIDAddr += 32;               
    }
}


//----------------------------------------------------------------------------------------------------


//--------------------------------------------------
// Description  : Initial Flash
// Input Value  : None
// Output Value : Return _TURE if succeed
//--------------------------------------------------
bit CEepromInitialFlash(void)
{
    BYTE cnt;

    if(!CEepromEraseFlash(_EDID))
        return _FALSE;

    for(cnt=_START_PAGE;cnt<(_START_PAGE + sizeof(pFlashCode));cnt++)
    {
        if(!CEepromEraseFlash(cnt))
            return _FALSE;
    }

    for(cnt=0;cnt<sizeof(pFlashCode);cnt++)     
    {
        MCU_FLASH[(cnt + 1) * 1024 - 1] = cnt;
        MCU_FLASH[(cnt + 1) * 1024 - 2] = 0;
        MCU_FLASH[(cnt + 1) * 1024 - 3] = 0;
        MCU_FLASH[(cnt + 1) * 1024 - 4] = 0;
        MCU_FLASH[(cnt + 1) * 1024 - 5] = 0 ^ 0 ^ 0 ^ cnt;

        pFlashCode[cnt] = cnt;
        pFlashPage[cnt] = cnt;
        pFlashAddr[cnt] = 0;
    }

    MCU_FLASH[(_END_PAGE - _START_PAGE + 2) * 1024 - 1] = _VERSION_CODE;
    ucFlashFreePage = sizeof(pFlashCode);
    ulFlashMovePage = 0;
    ucFlashEDIDAddr = 0;

    return _TRUE;
}


//--------------------------------------------------
// Description  : Erase Flash
// Input Value  : Number of Page (0 ~ 31)
// Output Value : Return _TURE if succeed
//--------------------------------------------------
bit CEepromEraseFlash(BYTE ucPage)
{
    MCU_FC_PAGE_ERASE_FF39 = (BYTE)((ucPage << 3) | _BIT0);
    if(!(CTimerPollingEventProc(40, CMiscFlashEraseEvent)))
        return _FALSE;

    return _TRUE;
}


//--------------------------------------------------
// Description  : Initial Address of Flash
// Input Value  : None
// Output Value : Return _TURE if succeed
//--------------------------------------------------
bit CEepromInitialFlashAddr(void)
{
    BYTE cnt,i;
    DWORD ulMovePage = 0;
    BYTE result=0; 

    ulFlashMovePage = 0;

    for(cnt=0;cnt<sizeof(pFlashCode);cnt++)     
        pFlashCode[cnt] = cnt;

    for(i=0;i<sizeof(pFlashCode);i++)
    {    
        for(cnt=0;cnt<(_END_PAGE - _START_PAGE + 1);cnt++)
        {
            if((MCU_FLASH[(cnt + 1) * 1024 - 1] == pFlashCode[i]) && (MCU_FLASH[(cnt + 1) * 1024 - 5] == (MCU_FLASH[(cnt + 1) * 1024 - 4] ^ MCU_FLASH[(cnt + 1) * 1024 - 3] ^ MCU_FLASH[(cnt + 1) * 1024 - 2] ^ MCU_FLASH[(cnt + 1) * 1024 - 1])))
            {
                pFlashPage[i] = cnt;
                pFlashAddr[i] = CEepromSearchFlashAddr(cnt);
                ulMovePage = (MCU_FLASH[(cnt + 1) * 1024 - 4] << 16) | (MCU_FLASH[(cnt + 1) * 1024 - 3] << 8) | MCU_FLASH[(cnt + 1) * 1024 - 2];

                if(ulMovePage > ulFlashMovePage)
                {
                    ulFlashMovePage = ulMovePage;
                    ucFlashFreePage = cnt;
                }
                break;
            }
            if(cnt == _END_PAGE - _START_PAGE) return _FALSE;
        }
    }
    
    ucFlashEDIDAddr = CEepromSearchFlashAddr(_END_PAGE - _START_PAGE + 1);

    if(ulFlashMovePage == 0)
        ucFlashFreePage = sizeof(pFlashCode);
    else
        ucFlashFreePage = CEepromSearchFlashPage(ucFlashFreePage);

    return _TRUE;
}


//--------------------------------------------------
// Description  : Search Flash Address
// Input Value  : Number of Page (0 ~ 31)
// Output Value : Return address
//--------------------------------------------------
BYTE CEepromSearchFlashAddr(BYTE ucPage)
{
    BYTE cnt, i;

    for(cnt=127;cnt>0;cnt--)
    {
        for(i=0;i<8;i++)
            if(MCU_FLASH[ucPage * 1024 + (cnt - 1) * 8 + i] != 0xff)
                return cnt;
    }

    return 0;
}


//--------------------------------------------------
// Description  : Search Free Page of Flash
// Input Value  : Number of Page of Flash
// Output Value : Free Page
//--------------------------------------------------
BYTE CEepromSearchFlashPage(BYTE FreePage)
{
    SBYTE k=0;
    
    if(FreePage == _END_PAGE - _START_PAGE)
        FreePage = 0;
    else
        FreePage += 1;
    
    do
    {
        if(FreePage == pFlashPage[k])
        {
            if(FreePage == _END_PAGE - _START_PAGE)
                FreePage = 0;
            else
                FreePage += 1;

            k = -1;
        }

        k++;

    }while(k < sizeof(pFlashCode));

    return FreePage;
}

//--------------------------------------------------
// Description  : Start for Load Eeprom default
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromStartLoadDefault(void)
{
    BYTE i;

    pFlashTemp[0] = 0;

    for(i=1;i<8;i++)
        pFlashTemp[i] = 0xff;

    CEepromSaveFlashData(_GLOBAL, pFlashTemp); 
}

//--------------------------------------------------
// Description  : Start for Load Eeprom default
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromFinishLoadDefault(void)
{
    BYTE i;

    pFlashTemp[0] = 0;

    for(i=1;i<8;i++)
        pFlashTemp[i] = 0x00;

    CEepromSaveFlashData(_GLOBAL, pFlashTemp); 
}

//--------------------------------------------------
// Description  : Check for Load Eeprom default
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromCheckLoadDefault(void)
{
    BYTE i;

    if(CEepromLoadFlashData(_GLOBAL, 0, pFlashTemp))
    {
        for(i=1;i<8;i++)
        {
            if(pFlashTemp[i] != 0x00)
            {
                CEepromLoadDefault();
                break;
            }
        }
    }
    else
    {
        CEepromLoadDefault();
    }
}

//--------------------------------------------------
// Description  : Save Data of Flash.
// Input Value  : Number of Page of Flash
// Output Value : None
//--------------------------------------------------
void CEepromSaveFlashData(BYTE ucPage, BYTE *pArray)
{
    BYTE cnt,i;
    bit equal=1;

    for(cnt=pFlashAddr[ucPage] + 1;cnt>0;cnt--)
    {
        if((MCU_FLASH[pFlashPage[ucPage] * 1024 + (cnt - 1) * 8] & 0x7f) == (pArray[0] & 0x7f))
        {
            for(i=0;i<8;i++)
            {
                if(MCU_FLASH[pFlashPage[ucPage] * 1024 + (cnt - 1) * 8 + i] != pArray[i])
                {
                    equal = 0;
                    break;
                }
            }

            break;
        }

        if(cnt==1)
            equal = 0;
    }

    if(!equal)
    {
        if(pFlashAddr[ucPage] == 127)
        {
            CEepromMoveFlashData(ucPage);
        }
        else
        {
            for(cnt=1;cnt<8;cnt++)
                MCU_FLASH[pFlashPage[ucPage] * 1024 + pFlashAddr[ucPage] * 8 + cnt] = pArray[cnt];

            MCU_FLASH[pFlashPage[ucPage] * 1024 + pFlashAddr[ucPage] * 8] = pArray[0];      
            pFlashAddr[ucPage] += 1;
        } 
    }      
}


//--------------------------------------------------
// Description  : Load Data of Flash.
// Input Value  : usPage      --> Number of Page of Flash
//                ucIndex     --> Number of Index
// Output Value : Return _TRUE if succeed
//--------------------------------------------------
bit CEepromLoadFlashData(BYTE ucPage, BYTE ucIndex, BYTE *pArray)
{

    BYTE cnt, i;
     
    for(cnt=pFlashAddr[ucPage] + 1;cnt>0;cnt--)
    {
        if((MCU_FLASH[pFlashPage[ucPage] * 1024 + (cnt - 1) * 8] & 0x7f) == ucIndex)
        {
            for(i=0;i<8;i++)
                pArray[i] = MCU_FLASH[pFlashPage[ucPage] * 1024 + (cnt - 1) * 8 + i];

            break;
        }

        if(cnt==1)
            return _FALSE;  //Can't find the Index Number
    }
    
    return _TRUE;
    
}


//--------------------------------------------------
// Description  : Move data to another page of Flash
// Input Value  : Number of Page of Flash
// Output Value : Return _TRUE if succeed
//--------------------------------------------------
bit CEepromMoveFlashData(BYTE ucPage)
{
    BYTE cnt,modecnt,i;
    BYTE j=1, page=pFlashPage[ucPage];

    if(!CEepromEraseFlash(ucFlashFreePage + _START_PAGE))
        return _FALSE; 

    for(cnt=0;cnt<8;cnt++)
        MCU_FLASH[ucFlashFreePage * 1024 + cnt] = pFlashTemp[cnt];

    modecnt = pFlashTemp[0] & 0x7f;

    for(i=0;i<8;i++)
        pFlashTemp[i] = 0;
    
    pFlashTemp[modecnt / 8] =  pFlashTemp[modecnt / 8] | (0x01 << (modecnt & 7));

    pFlashPage[ucPage] = ucFlashFreePage;
    ucFlashFreePage = CEepromSearchFlashPage(ucFlashFreePage);
    ulFlashMovePage += 1;    
   
    for(cnt=127;cnt>0;cnt--)
    {
      	modecnt = MCU_FLASH[page * 1024 + (cnt - 1) * 8] & 0x7f;
	
       	if((modecnt != 0x7f) && (!(pFlashTemp[modecnt / 8] & (0x01 << (modecnt & 7)))))
       	{
            for(i=0;i<8;i++)
                MCU_FLASH[pFlashPage[ucPage] * 1024 + j * 8 + i] = MCU_FLASH[page * 1024 + (cnt - 1) * 8 + i];

            pFlashTemp[modecnt / 8] =  pFlashTemp[modecnt / 8] | (0x01 << (modecnt & 7));
            j++;
       	}
    }

    pFlashAddr[ucPage] = j;

    MCU_FLASH[(pFlashPage[ucPage] + 1) * 1024 - 4] = (BYTE)(ulFlashMovePage >> 16);
    MCU_FLASH[(pFlashPage[ucPage] + 1) * 1024 - 3] = (BYTE)(ulFlashMovePage >> 8);
    MCU_FLASH[(pFlashPage[ucPage] + 1) * 1024 - 2] = (BYTE)ulFlashMovePage;
    MCU_FLASH[(pFlashPage[ucPage] + 1) * 1024 - 1] = pFlashCode[ucPage];
    MCU_FLASH[(pFlashPage[ucPage] + 1) * 1024 - 5] = ((BYTE)(ulFlashMovePage >> 16)) ^ ((BYTE)(ulFlashMovePage >> 8)) ^ ((BYTE)ulFlashMovePage) ^ pFlashCode[ucPage];

    if(!CEepromEraseFlash(page + _START_PAGE))
        return _FALSE;
    else
        return _TRUE;  
}

#endif  //End of #if((_MCU_TYPE == _REALTEK_RTD2120) && (_MEMORY_LOCATION == _FLASH))

//--------------------------------------------------------------------------------------------------------------------


#endif  // End of #if((_SCALER_TYPE == _RTD2533B) || (_SCALER_TYPE == _RTD2023L) || (_SCALER_TYPE == _RTD2023S) || (_SCALER_TYPE == _RTD2023L_VB) || (_SCALER_TYPE == _RTD2023S_VB))