i2c.c

使用于克隆器

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

 [Module Name]: I2c.c
 [Date]:        11-Nov-2003
 [Comment]:
   I2C subroutines.
 [Reversion History]:
*******************************************************************************/

#define _I2C_C_

// System

// Common
#include "define.h"
#include "mcu.h"

#include "board.h"

// External
#include "common.h"

// Internal
#include "userpref.h"
#include "i2c.h"
#include "uart.h"
#include "global.h"

void i2cSetSCL(BYTE is_hl)
{
    if (s_I2CSel)
    {
        i2cSCLRam_PIN = is_hl;//P7_5
    }
    else
    {
        i2cSCL_PIN = is_hl;//P7_7
    }
}

BIT i2cGetSCL(void)
{
    BIT bSCL;
    if (s_I2CSel)
    {
        i2cSCLRam_PIN_IN();
        bSCL = i2cSCLRam_PIN_STATUS;//P7_5
        i2cSCLRam_PIN_OUT();
    }
    else
    {
        i2cSCL_PIN_IN();
        bSCL = i2cSCL_PIN_STATUS;//P7_7
        i2cSCL_PIN_OUT();
    }
    return bSCL;
}

void i2cSetSDA(BOOL is_hl)
{
    if (s_I2CSel)
    {
        i2cSDARam_PIN = is_hl;//P7_6
    }
    else
    {
        i2cSDA_PIN = is_hl;//P3_4
    }
}

BIT i2cGetSDA(void)
{
    BIT bSDA;
    if (s_I2CSel)
    {
        i2cSDARam_PIN_IN();
        bSDA = i2cSDARam_PIN_STATUS;//P7_6
        i2cSDARam_PIN_OUT();
    }
    else
    {
        bSDA = i2cSDA_PIN_STATUS;//P3_4
    }
    return bSDA;
}

//////////////////////////////////////////////////////////////
// Delay 4us
//////////////////////////////////////////////////////////////
void i2c_Delay(void)
{
    // MCU_Delay1us();
    // MCU_Delay1us();
    MCU_Delay1us();
    MCU_Delay1us();
}


/////////////////////////////////////////
// Set I2C SCL pin high/low.
//
// Arguments: bSet - high/low bit
/////////////////////////////////////////
void i2cSetSCL_Chk(bit bSet)
{
    BYTE ucDummy; // loop dummy

    i2cSetSCL(bSet); // set SCL pin

    if (bSet == _HIGH) // if set pin high
    {
        ucDummy = I2C_CHECK_PIN_DUMMY; // initialize dummy
        while ((i2cGetSCL() == _LOW) && (ucDummy--)) ; // check SCL pull high
    } // if
}

/////////////////////////////////////////
// Set I2C SDA pin high/low
//
// Arguments: bSet - high/low bit
/////////////////////////////////////////
void i2cSetSDA_Chk(bit bSet)
{
    BYTE ucDummy; // loop dummy

    i2cSetSDA(bSet); // set SDA pin

    if (bSet == _HIGH) // if set pin high
    {
        ucDummy = I2C_CHECK_PIN_DUMMY; // initialize dummy
        while ((i2cGetSDA() == _LOW) && (ucDummy--)); // check SDA pull high
    } // if
}

//////////////////////////////////////////////////////
// I2C start signal.
// <comment>
//  SCL ________
//              \_________
//  SDA _____
//           \____________
//
// Return value: None
//////////////////////////////////////////////////////
BOOL i2c_Start(void)
{
    BOOL bStatus = TRUE; // success status

    EA = 1; // disable all interrupt

    i2cSetSDA_Chk(_HIGH);
    i2c_Delay();
    i2cSetSCL_Chk(_HIGH);
    i2c_Delay();

    // check pin error
    if ((i2cGetSCL() == _LOW) || (i2cGetSDA() == _LOW))
    {
        bStatus = FALSE;
    }
    else // success
    {
        i2cSetSDA(_LOW);
        i2c_Delay();
        i2cSetSCL(_LOW);
    }

    EA = 1; // release EA bit

    return bStatus;
}

/////////////////////////////////////////
// I2C stop signal.
// <comment>
//              ____________
//  SCL _______/
//                 _________
//  SDA __________/
/////////////////////////////////////////
void i2c_Stop(void)
{
    EA = 1; // disable all interrupt

    i2cSetSCL(_LOW);
    i2c_Delay();
    i2cSetSDA(_LOW);
    i2c_Delay();
    i2cSetSCL_Chk(_HIGH);
    i2c_Delay();
    i2cSetSDA_Chk(_HIGH);
    i2c_Delay();

    EA = 1; // release EA bit
}

//////////////////////////////////////////////////////////////////////////
// I2C receive byte from device.
//
// Return value: receive byte
//////////////////////////////////////////////////////////////////////////
BYTE i2c_ReceiveByte(BOOL bAck)
{
    BYTE ucReceive = 0;
    BYTE ucMask = 0x80;

    EA = 1;

    while (ucMask)
    {
        i2cSetSDA(_HIGH);
        i2cSetSCL_Chk(_HIGH);
        i2c_Delay();
        if (i2cGetSDA() == _HIGH)
            ucReceive |= ucMask;
        i2cSetSCL(_LOW);
        i2c_Delay();

        ucMask >>= 1; // next
    } // while

    if (bAck) // acknowledge
        i2cSetSDA_Chk(I2C_ACKNOWLEDGE);
    else // non-acknowledge
        i2cSetSDA_Chk(I2C_NON_ACKNOWLEDGE);

    i2c_Delay();
    i2cSetSCL_Chk(_HIGH);
    i2c_Delay();
    i2cSetSCL(_LOW);
    i2c_Delay();

    EA = 1;

    return ucReceive;
}

//////////////////////////////////////////////////////////////////////////
// I2C send byte to device.
//
// Arguments: ucVal - send byte
// Return value: I2C acknowledge bit
//               I2C_ACKNOWLEDGE/I2C_NON_ACKNOWLEDGE
//////////////////////////////////////////////////////////////////////////
bit i2c_SendByte(BYTE ucVal)
{
    BYTE ucMask = 0x80;
    bit bAck; // acknowledge bit

    EA = 1;

    while (ucMask)
    {
        if (ucVal & ucMask)
            i2cSetSDA_Chk(_HIGH);
        else
            i2cSetSDA_Chk(_LOW);
        i2c_Delay();
        i2cSetSCL_Chk(_HIGH); // clock
        i2c_Delay();
        i2cSetSCL(_LOW);
        i2c_Delay();

        ucMask >>= 1; // next
    } // while

    // recieve acknowledge
    i2cSetSDA(_HIGH);
    i2c_Delay();
    i2cSetSCL_Chk(_HIGH);
    i2c_Delay();
    bAck = i2cGetSDA(); // recieve acknowlege
    i2cSetSCL(_LOW);
    i2c_Delay();

    EA = 1;

    return (bAck);
}

//////////////////////////////////////////////////////////////////////////
// I2C access start.
//
// Arguments: ucSlaveAdr - slave address
//            trans_t - I2C_TRANS_WRITE/I2C_TRANS_READ
//////////////////////////////////////////////////////////////////////////
BOOL i2c_AccessStart(BYTE ucSlaveAdr, I2cIoTransType trans_t)
{
    BYTE ucDummy; // loop dummy

    //if ((ucSlaveAdr & 0xf0) == 0xA0)//RM_DEVICE_ADR
    //    s_I2CSel = TV_RAM;
    //else
    //    s_I2CSel = MCU_RAM;//default

    if (trans_t == I2C_TRANS_READ) // check i2c read or write
        ucSlaveAdr = I2C_DEVICE_ADR_READ(ucSlaveAdr); // read
    else
        ucSlaveAdr = I2C_DEVICE_ADR_WRITE(ucSlaveAdr); // write

    ucDummy = I2C_ACCESS_DUMMY_TIME;
    while (ucDummy--)
    {
        if (i2c_Start() == FALSE)
            continue;

        if (i2c_SendByte(ucSlaveAdr) == I2C_ACKNOWLEDGE) // check acknowledge
        {
            //if(g_FacSetting.bFactoryMode)
            //FacIICtestHandler(ucSlaveAdr,TRUE);
            return TRUE;
        }

        //FacIICtestHandler(ucSlaveAdr,FALSE);
        i2c_Stop();

        Delay1ms(1);
    } // while

    return FALSE;
}

/////////////////////////////////////////////////////////////////
// I2C read bytes from device.
//
// Arguments: ucSlaveAdr - slave address
//            ucSubAdr - sub address
//            pBuf - pointer of buffer