ram.c

使用于克隆器

/******************************************************************************
 Copyright (c) 2003 MStar Semiconductor, Inc.
 All rights reserved.

 [Module Name]: Ram.c
 [Date]:        16-Dec-2003
 [Comment]:
   EEPROM access subroutines.
 [Reversion History]:
*******************************************************************************/

#define _RAM_C_

// System

// Common
#include "define.h"
#include "mcu.h"
#include "userdef.h"
// External
#include "board.h"
#include "i2c.h"
#include "common.h"
#include "global.h"

// Internal
#include "ram.h"

///////////////////////////////////////////////////////////////////////////////
// <Function>: rmReadByte
//
// <Description>: Read byte from EEPROM.
//
// <Returns> : Read byte.
//
// <Parameter>:  -  <Flow>  -  <Description>
//   wIndex      -    In    -   index
//-----------------------------------------------------------------------------
//
///////////////////////////////////////////////////////////////////////////////
BYTE rmReadByte(WORD wIndex)
{
    if (RM_EEPROM_TYPE == RM_TYPE_24C16)
    {
        return i2cReadByte(rmCalDeviceAdr(wIndex), LOBYTE(wIndex));
    }
    else if (RM_EEPROM_TYPE == RM_TYPE_24C32)
    {
        BYTE ucBuf; // byte buffer

        rmBurstReadBytes(wIndex, &ucBuf, sizeof(ucBuf));
        return ucBuf;
    }
}

///////////////////////////////////////////////////////////////////////////////
// <Function>: rmWriteByte
//
// <Description>: Write byte to EEPROM.
//
// <Returns> : None
//
// <Parameter>:  -  <Flow>  -  <Description>
//   wIndex      -    In    -   index
//   ucVal       -    In    -   data
//-----------------------------------------------------------------------------
//
///////////////////////////////////////////////////////////////////////////////
void rmWriteByte(WORD wIndex, BYTE ucVal)
{
    if (RM_EEPROM_TYPE == RM_TYPE_24C16)
        i2cWriteByte(rmCalDeviceAdr(wIndex), LOBYTE(wIndex), ucVal);
#if(RM_EEPROM_TYPE == RM_TYPE_24C32)
    else if(RM_EEPROM_TYPE == RM_TYPE_24C32)
        rmPageWrite(wIndex, &ucVal, sizeof(ucVal));
#endif
}

///////////////////////////////////////////////////////////////////////////////
// <Function>: rmBurstReadBytes
//
// <Description>: EEPROM burst read bytes
//
// <Parameter>:  -  <Flow>  -  <Description>
//   wIndex      -    In    -   index
//   pBuf        -    Out   -   buffer pointer
//   ucBufLen    -    In    -   buffer length
//-----------------------------------------------------------------------------
//
///////////////////////////////////////////////////////////////////////////////
void rmBurstReadBytes(WORD wIndex, BYTE* pBuf, BYTE ucBufLen)
{
    if (RM_EEPROM_TYPE == RM_TYPE_24C16)
    {
        i2cBurstReadBytes(rmCalDeviceAdr(wIndex), LOBYTE(wIndex), pBuf, ucBufLen);
    }
    else if (RM_EEPROM_TYPE == RM_TYPE_24C32)
    {
        BYTE ucDummy; // loop dummy

        ucDummy = I2C_ACCESS_DUMMY_TIME;
        while (ucDummy--)
        {
            if (i2c_AccessStart(RM_DEVICE_ADR, I2C_TRANS_WRITE) == FALSE)
                continue;

            if (i2c_SendByte(HIBYTE(wIndex)) == I2C_NON_ACKNOWLEDGE) // check non-acknowledge
                continue;

            if (i2c_SendByte(LOBYTE(wIndex)) == I2C_NON_ACKNOWLEDGE) // check non-acknowledge
                continue;

            if (i2c_AccessStart(RM_DEVICE_ADR, I2C_TRANS_READ) == FALSE)
                continue;

            while (ucBufLen--) // loop to burst read
            {
                *pBuf = i2c_ReceiveByte(ucBufLen); // receive byte

                pBuf++; // next byte pointer
            } // while

            break;
        } // while

        i2c_Stop();
        Delay1ms(8);
    }
}

///////////////////////////////////////////////////////////////////////////////
// <Function>: rmPageWrite
//
// <Description>: EEPROM page write for 24C32 only!!

// <Parameter>:  -  <Flow>  -  <Description>
//   wIndex      -    In    -   index
//   pBuf        -    Out   -   buffer pointer
//   ucBufLen    -    In    -   buffer length
//-----------------------------------------------------------------------------
//
///////////////////////////////////////////////////////////////////////////////

void rmPageWrite(WORD wIndex, BYTE* pBuf, BYTE ucBufLen)
{
    BYTE ucDummy; // loop dummy

    ucDummy = I2C_ACCESS_DUMMY_TIME;
    while (ucDummy--)
    {
        if (i2c_AccessStart(RM_DEVICE_ADR, I2C_TRANS_WRITE) == FALSE)
            continue;

        if (i2c_SendByte(HIBYTE(wIndex)) == I2C_NON_ACKNOWLEDGE) // check non-acknowledge
            continue;

        if (i2c_SendByte(LOBYTE(wIndex)) == I2C_NON_ACKNOWLEDGE) // check non-acknowledge
            continue;

        while (ucBufLen--) // loop of writting data
        {
            i2c_SendByte(*pBuf); // send byte

            pBuf++; // next byte pointer
        } // while

        break;
    } // while

    i2c_Stop();
}

///////////////////////////////////////////////////////////////////////////////
// <Function>: rmBurstWriteBytes
//
// <Description>: EEPROM burst write bytes
//
// <Parameter>:  -  <Flow>  -  <Description>
//   wIndex      -    In    -   index
//   pBuf        -    Out   -   buffer pointer
//   ucBufLen    -    In    -   buffer length
//-----------------------------------------------------------------------------
//
///////////////////////////////////////////////////////////////////////////////
void rmBurstWriteBytes(WORD wIndex, BYTE* pBuf, BYTE ucBufLen)
{
    BYTE ucWriteCount; // write counter
    BYTE ucRemainLen; // i2c word address

    while (1)
    {
        // check page write roll over
        if (ucBufLen > RM_PAGE_WRITE_LEN)
            ucWriteCount = RM_PAGE_WRITE_LEN;
        else
            ucWriteCount = ucBufLen;

        // check word address higher than page write bits
        ucRemainLen = LOBYTE(wIndex) % RM_PAGE_WRITE_LEN;
        if (ucRemainLen) // check ramain
        {
            ucRemainLen = RM_PAGE_WRITE_LEN - ucRemainLen;
            if (ucWriteCount > ucRemainLen) // check not roll over
                ucWriteCount = ucRemainLen;
        }

        // EEPROM page write
        if (RM_EEPROM_TYPE == RM_TYPE_24C16)
        {
            i2cBurstWriteBytes(rmCalDeviceAdr(wIndex), LOBYTE(wIndex), pBuf, ucWriteCount);
        }
        else if (RM_EEPROM_TYPE == RM_TYPE_24C32)
        {
            rmPageWrite(wIndex, pBuf, ucWriteCount);
        }

        // check end of buffer
        ucBufLen -= ucWriteCount;
        if (ucBufLen == 0)
            break;

        wIndex += ucWriteCount; // next word address
        pBuf += ucWriteCount; // next buffer pointer

        Delay1ms(8);
    } // while
}