i2c.c

使用于克隆器

//            ucBufLen - length of buffer
/////////////////////////////////////////////////////////////////
void i2cBurstReadBytes(BYTE ucSlaveAdr, BYTE ucSubAdr, BYTE* pBuf, BYTE ucBufLen)
{
    BYTE ucDummy; // loop dummy

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

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

        if (i2c_AccessStart(ucSlaveAdr, 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);
}

/////////////////////////////////////////////////////////////////
// I2C write bytes to device.
//
// Arguments: ucSlaveAdr - slave address
//            ucSubAdr - sub address
//            pBuf - pointer of buffer
//            ucBufLen - length of buffer
/////////////////////////////////////////////////////////////////
void i2cBurstWriteBytes(BYTE ucSlaveAdr, BYTE ucSubAdr, BYTE* pBuf, BYTE ucBufLen)
{
    BYTE ucDummy; // loop dummy

    ucDummy = I2C_ACCESS_DUMMY_TIME;
    while (ucDummy--)
    {
        if (i2c_AccessStart(ucSlaveAdr, I2C_TRANS_WRITE) == FALSE)
        {
            //printf("\r\nIIC[%x] NG", ucSlaveAdr);
            continue;
        }

        if (i2c_SendByte(ucSubAdr) == 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();
}

/////////////////////////////////////////////////////////////////
// I2C read a byte from device.
//
// Arguments: ucSlaveAdr - slave address
//            ucSubAdr - sub address
// Return value: read byte
/////////////////////////////////////////////////////////////////
BYTE i2cReadByte(BYTE ucSlaveAdr, BYTE ucSubAdr)
{
    BYTE ucBuf; // byte buffer

    i2cBurstReadBytes(ucSlaveAdr, ucSubAdr, &ucBuf, 1);
    return ucBuf;
}

/////////////////////////////////////////////////////////////////
// I2C write a byte from device.
//
// Arguments: ucSlaveAdr - slave address
//            ucSubAdr - sub address
//            ucVal - write byte
/////////////////////////////////////////////////////////////////
void i2cWriteByte(BYTE ucSlaveAdr, BYTE ucSubAdr, BYTE ucVal)
{
    i2cBurstWriteBytes(ucSlaveAdr, ucSubAdr, &ucVal, 1);
}
# if 1
/////////////////////////////////////////////////////////////////
// I2C read a current byte from device.
//
// Arguments: ucSlaveAdr - slave address
// Return value: read byte
/////////////////////////////////////////////////////////////////
BYTE i2cReadCurrent(BYTE ucSlaveAdr)
{
    BYTE ucDummy; // loop dummy
    BYTE ucByte; // byte buffer

    ucDummy = I2C_ACCESS_DUMMY_TIME;
    while (ucDummy--)
    {
        if (i2c_AccessStart(ucSlaveAdr, I2C_TRANS_READ) == FALSE)
            continue;

        ucByte = i2c_ReceiveByte(FALSE); // receive byte

        break;
    } // while

    i2c_Stop();

    return ucByte;
}

/////////////////////////////////////////////////////////////////
// I2C write a current byte to device.
//
// Arguments: ucSlaveAdr - slave address
//            ucVal - write byte
/////////////////////////////////////////////////////////////////
#if (_DEBUG_TESTCOMMAND_EN_)
void i2cWriteCurrent(BYTE ucSlaveAdr, BYTE ucVal)
{
    i2cBurstWriteBytes(ucSlaveAdr, ucVal, NULL, 0);
}
#endif

#endif
//////////////////////////////////////////////////////////////////////////////
// <Name>: msWrite2Bytes
//
// <Description>: Program i2c register bytes.
//
// <Parameter>:  -  <Flow>  -  <Description>
// ---------------------------------------------------------------------------
//   ucSlaveAdr  -      In  -    slave address
//   pTable      -      In  -    table pointer
//////////////////////////////////////////////////////////////////////////////
#if 1
void i2cWriteRegsTbl(BYTE ucSlaveAdr, RegUnitType code* pTable)
{
    BYTE ucIndex; // register index

    while (1)
    {
        ucIndex = pTable->ucIndex; // get register index
        if (ucIndex == _END_OF_TBL_) // check end of table
            break;

        i2cBurstWriteBytes(ucSlaveAdr, ucIndex, &pTable->ucValue, 1); // write register

        pTable++; // next
    } // while
}
#endif

static bit wait_IIC()
{
    bit err = 0;
    BYTE counter = 0;

    while ((INTFLG & 0x01) == 0)                 // Wait for MBUFl
    {
        if (++counter > 80)
        {
            err = 1;
            break;
        }
    }

    if ((IICSTUSL & 0x01) != 0)             // No Ack receieved from IIC slave device
        err = 1;

    INTFLG = 0;

    return(err);
}

static NOP()
{
}
#if 1///520
BYTE i2cReadByte2(BYTE ucSlaveAdr, BYTE ucSubAdr)
{
    bit error;BYTE temp;
    PADMOD2 = 0x47;
    OPTION = 0x62;

    INTFLG = INTFLG & 0xfe;//Clear Master IIC bus interrupt flag
    //start
    IICCTR = 0x00;   // S=0,P=0
    MBUF = ucSlaveAdr;   // slave address (dummy write)
    NOP();
    IICCTR = 0x01;   // S=1,P=0
    error = wait_IIC();
    MBUF = ucSubAdr;   //address
    error = wait_IIC();
    //restart
    IICCTR = IICCTR & 0xfe;   // S set 0
    MBUF = ucSlaveAdr | 0x01;   //restart + slave address (read)
    NOP();
    IICCTR = IICCTR | 0x01;   // S set 1
    error = wait_IIC();
    IICCTR = 0x05;   //Ack=1
    //dummy read
    temp = MBUF;
    error = wait_IIC();

    temp = MBUF;
    IICCTR = 0x00;
    NOP();
    IICCTR = IICCTR | 0x02;   //P rise

    PADMOD2 = 0x07;

    i2cSCL_PIN = 1;//P7_7
    i2cSDA_PIN = 1;//P3_4

    return(temp);
}
#endif

#if( ENABLE_CC_VCHIP )
void i2cBurstReadBytes2(BYTE ucSlaveAdr, BYTE ucSubAdr, BYTE* pBuf, BYTE ucBufLen)
{
    BYTE ucDummy; // loop dummy
    bit error;
    PADMOD2 = 0x47;
    OPTION = 0x62;

    ucDummy = I2C_ACCESS_DUMMY_TIME;
    while (ucDummy--)
    {
        INTFLG = INTFLG & 0xfe;//Clear Master IIC bus interrupt flag
        //start
        IICCTR = 0x00;   // S=0,P=0
        MBUF = ucSlaveAdr;   // slave address (dummy write)
        NOP();
        IICCTR = 0x01;   // S=1,P=0
        error = wait_IIC();
        if (error)
            continue;
        MBUF = ucSubAdr;   //address
        error = wait_IIC();
        if (error)
            continue;
        //restart
        IICCTR = IICCTR & 0xfe;   // S set 0
        MBUF = ucSlaveAdr | 0x01;   //restart + slave address (read)
        NOP();
        IICCTR = IICCTR | 0x01;   // S set 1
        error = wait_IIC();
        if (error)
            continue;

        //dummy read
        *pBuf = MBUF;
        error = wait_IIC();
        if (error)
            continue;
        ucBufLen--;
        while (ucBufLen--) // loop to burst read
        {
            if (ucBufLen == 0)
                IICCTR = 0x05;   //Ack=1
            *pBuf++ = MBUF; // receive byte
            error = wait_IIC();
            if (error)
                break;
        } // while
        if (error)
            continue;
        //stop
        IICCTR = 0x00;
        NOP();
        IICCTR = IICCTR | 0x02;   //P rise
        break;
    } // while


    PADMOD2 = 0x07;

    i2cSCL_PIN = 1;//P7_7
    i2cSDA_PIN = 1;//P3_4
}
#endif

#if 0//_EEPROM_TYPE == RM_TYPE_24C32)
#if ((ENABLE_HDMI_SOURCE))
BOOL PingIC(BYTE ucSlaveAdr)
{
    BOOL bStatus = TRUE;

    //printf("\r\n Slave=%x", ucSlaveAdr);
    if ((ucSlaveAdr & 0xF0) == 0xA0)//RM_DEVICE_ADR
        s_I2CSel = 1;
    else
        s_I2CSel = 0;//default

    //ucSlaveAdr &= (~_BIT0); // read
    if (i2c_Start() == FALSE)
    {
        bStatus = FALSE;
        //putstr("\r\n start error");
    }
    if (i2c_SendByte(ucSlaveAdr) == _HIGH)
    {
        bStatus = FALSE;
        //putstr("\r\n ping error");
    }
    i2c_Stop();

    return bStatus;
}
#endif
#endif