gio_i2c.c

dm270 source code

#include <system/gio270.h>

#define	I2C_SCL			GIO31   // output_____I2C Bus SCL
#define I2C_SDA			GIO32   // out/input__I2C Bus SDA

enum {I2C_SUCCESS, I2C_ERROR};

void  i2cStart(void);
void  i2cStop(void);
static void  i2cWriteBit(BOOL bit);
void  i2cSendNack(void);
void  i2cWriteByte(Uchar byte);
void  i2cWait(void);
BOOL  i2cGetAck(void);
static BOOL  i2cReadBit(void);
Uchar i2cReadByte(void);

/* main initialization function */
void i2cInit()
{

   /* configure the 2 GIO lines as outputs (0) */
	{
	    GIO_ConfigData gioout;
	
	    gioout.dir              = GIO_OUTPUT;
	    gioout.altUse           = FALSE;
	    gioout.invert           = FALSE;
	    gioout.chatterInvalid   = FALSE;
	
	    GIO_setConfig(I2C_SCL, &gioout );
	    GIO_setBit(I2C_SCL);
	}
	{
	    GIO_ConfigData gioout;
	
	    gioout.dir              = GIO_OUTPUT;
	    gioout.altUse           = FALSE;
	    gioout.invert           = FALSE;
	    gioout.chatterInvalid   = FALSE;
	
	    GIO_setConfig(I2C_SDA, &gioout );
	    GIO_setBit(I2C_SDA);
	}


   /* put bus in stop state */
   i2cStop();
}

void makeSclLow(void)
{
   GIO_clearBit(I2C_SCL);
}

void makeSclHigh(void)
{
   GIO_setBit(I2C_SCL);
}

void makeSdaLow(void)
{
   GIO_clearBit(I2C_SDA);
}

void makeSdaHigh(void)
{
   GIO_setBit(I2C_SDA);
}

BOOL readSda(void)
{
   if(GIO_getBit(I2C_SDA))
      return (BOOL)1;
   else
      return (BOOL)0;
}

void makeSdaInput(void)
{
	    GIO_ConfigData gioin;
	
	    gioin.dir              = GIO_INPUT;
	    gioin.altUse           = FALSE;
	    gioin.invert           = FALSE;
	    gioin.chatterInvalid   = FALSE;
	
	    GIO_setConfig(I2C_SDA, &gioin );
}

/* set SDA as output */
void makeSdaOutput(void)
{
	    GIO_ConfigData gioout;
	
	    gioout.dir              = GIO_OUTPUT;
	    gioout.altUse           = FALSE;
	    gioout.invert           = FALSE;
	    gioout.chatterInvalid   = FALSE;
	
	    GIO_setConfig(I2C_SDA, &gioout );
}

void i2cWriteReg(Uchar slaveAddr, Uchar subAddr, Uchar val, Uchar *successFlag)
{
   Uchar nFlag=1;

   i2cStart();
   i2cWriteByte(slaveAddr & 0xfe);      
   nFlag &= i2cGetAck();
   i2cWriteByte(subAddr);
   nFlag &= i2cGetAck();
   i2cWriteByte(val);
   nFlag &= i2cGetAck();
   i2cStop();

   *successFlag = (nFlag) ? (Uchar)I2C_SUCCESS : (Uchar)I2C_ERROR;
}

void i2cWriteRegaic(Uchar slaveAddr, Uchar subAddr, Uchar val, Uchar *successFlag)
{
   Uchar nFlag=1;

   i2cStart();
   i2cWriteByte(slaveAddr);      
   nFlag &= i2cGetAck();
   i2cWriteByte(subAddr);
   nFlag &= i2cGetAck();
   i2cWriteByte(val);
   nFlag &= i2cGetAck();
   i2cStop();

   *successFlag = (nFlag) ? (Uchar)I2C_SUCCESS : (Uchar)I2C_ERROR;
}

void i2cWriteRegs(Uchar slaveAddr, Uchar subAddr, Uchar *val, Uint32 count, Uchar *successFlag)
{
   Uchar i, flag=1;

   i2cStart();
   i2cWriteByte(slaveAddr & 0xfe);      
   flag &= i2cGetAck();
   i2cWriteByte(subAddr);
   flag &= i2cGetAck();

   for (i = 0; i < count; i++)
   {
      i2cWriteByte(val[i]);
      flag &= i2cGetAck();
   }
   i2cStop();

   *successFlag = (flag) ? (Uchar)I2C_SUCCESS : (Uchar)I2C_ERROR;
}


Uchar i2cReadReg(Uchar slaveAddr, Uchar subAddr, Uchar *successFlag)
{
   Uchar val, flag=1;

   i2cStart();
   i2cWriteByte(slaveAddr & 0xfe);      
   flag &= i2cGetAck();
   i2cWriteByte(subAddr);
   flag &= i2cGetAck();

   i2cStart();
   i2cWriteByte(slaveAddr | 0x01);      
   flag &= i2cGetAck();
   makeSdaInput();
   i2cWait();
   val = i2cReadByte();
   makeSdaOutput();
   i2cWait();
   i2cSendNack();
   i2cStop();

   *successFlag = (flag) ? (Uchar)I2C_SUCCESS : (Uchar)I2C_ERROR;

   return val;
}

void i2cStart(void)
{
   makeSdaHigh();
   makeSclHigh();
   i2cWait();
   makeSdaLow();
   i2cWait();
   makeSclLow();
   i2cWait();
}

void i2cStop(void)
{
   makeSdaLow();
   makeSclHigh();
   i2cWait();
   makeSdaHigh();
   i2cWait();
}

static BOOL i2cReadBit(void)
{
   BOOL bit;

   makeSclHigh();
   i2cWait();
   i2cWait();
   i2cWait();
   i2cWait();
   i2cWait();
   i2cWait();
   bit = readSda();
   makeSclLow();
   i2cWait();

   return bit;
}

static void i2cWriteBit(BOOL bit)
{
   if (bit)
      makeSdaHigh();
   else
      makeSdaLow();

   makeSclHigh();
   i2cWait();
   makeSclLow();
   i2cWait();
}

BOOL i2cGetAck(void)
{
   BOOL ackVal;

   makeSdaInput();
   i2cWait();
   ackVal = (BOOL)(!i2cReadBit());      /* 0 - Ack, 1 - NACK */
   makeSdaOutput();
   i2cWait();

   return ackVal;
}

void i2cSendNack(void)
{
   i2cWriteBit((BOOL)1);
   i2cWait();
   i2cWait();   
}

void i2cSendAck(void)
{
   i2cWriteBit((BOOL)0);
   i2cWait();
   i2cWait();
}

Uchar i2cReadByte(void)
{
   Uchar i, mask=0x80, retVal=0;

   for (i = 0; i < 8; i++)
   {
      if (i2cReadBit())
         retVal |= mask;
      mask >>= 1;
   }

   return retVal;
}

void i2cWriteByte(Uchar byte)
{
   Uchar i, mask=0x80;

   for (i = 0; i < 8; i++)
   {
      if (byte & mask)
         i2cWriteBit((BOOL)1);
      else
         i2cWriteBit((BOOL)0);
      mask >>= 1;
   }
}

void i2cWait(void)
{
   volatile int i;

   for (i = 0; i < 300; i++);

}