int i2c_write(int address, const unsigned char* buf, int count )
{
int i,x=0;
i2c_start();
i2c_outb(address & 0xfe);
if (i2c_getack())
{
for (i=0; i<count; i++)
{
i2c_outb(buf[i]);
if (!i2c_getack())
{
x=-2;
break;
}
}
}
else
{
debugf("i2c_write() - no ack\n");
x=-1;
}
i2c_stop();
return x;
}
unsigned char
i2c_readreg(unsigned char theSlave, unsigned char theReg)
{
unsigned char b = 0;
int error, cntr = 3;
unsigned long flags;
spin_lock_irqsave(&i2c_lock, flags);
do {
error = 0;
i2c_start();
i2c_outbyte((theSlave & 0xfe));
if(!i2c_getack())
error = 1;
i2c_dir_out();
i2c_outbyte(theReg);
if(!i2c_getack())
error |= 2;
i2c_delay(CLOCK_LOW_TIME);
i2c_start();
i2c_outbyte(theSlave | 0x01);
if(!i2c_getack())
error |= 4;
b = i2c_inbyte();
i2c_sendnack();
i2c_stop();
} while(error && cntr--);
spin_unlock_irqrestore(&i2c_lock, flags);
return b;
}
int
i2c_writereg(unsigned char theSlave, unsigned char theReg,
unsigned char theValue)
{
int error, cntr = 3;
unsigned long flags;
spin_lock_irqsave(&i2c_lock, flags);
do {
error = 0;
i2c_start();
i2c_outbyte((theSlave & 0xfe));
if(!i2c_getack())
error = 1;
i2c_dir_out();
i2c_outbyte(theReg);
if(!i2c_getack())
error |= 2;
i2c_outbyte(theValue);
if(!i2c_getack())
error |= 4;
i2c_stop();
} while(error && cntr--);
i2c_delay(CLOCK_LOW_TIME);
spin_unlock_irqrestore(&i2c_lock, flags);
return -error;
}
int
i2c_write(unsigned char theSlave, void *data, size_t nbytes)
{
int error, cntr = 3;
unsigned char bytes_wrote = 0;
unsigned char value;
unsigned long flags;
spin_lock_irqsave(&i2c_lock, flags);
do {
error = 0;
i2c_start();
i2c_outbyte((theSlave & 0xfe));
if (!i2c_getack())
error = 1;
for (bytes_wrote = 0; bytes_wrote < nbytes; bytes_wrote++) {
memcpy(&value, data + bytes_wrote, sizeof value);
i2c_outbyte(value);
if (!i2c_getack())
error |= 4;
}
i2c_stop();
} while (error && cntr--);
i2c_delay(CLOCK_LOW_TIME);
spin_unlock_irqrestore(&i2c_lock, flags);
return -error;
}
/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: i2c_writereg
*#
*# DESCRIPTION : Writes a value to an I2C device
*#
*#--------------------------------------------------------------------------*/
int
i2c_writereg(unsigned char theSlave, unsigned char theReg,
unsigned char theValue)
{
int error, cntr = 3;
unsigned long flags;
do {
error = 0;
/*
* we don't like to be interrupted
*/
local_irq_save(flags);
local_irq_disable();
i2c_start();
/*
* send slave address
*/
i2c_outbyte((theSlave & 0xfe));
/*
* wait for ack
*/
if(!i2c_getack())
error = 1;
/*
* now select register
*/
i2c_dir_out();
i2c_outbyte(theReg);
/*
* now it's time to wait for ack
*/
if(!i2c_getack())
error |= 2;
/*
* send register register data
*/
i2c_outbyte(theValue);
/*
* now it's time to wait for ack
*/
if(!i2c_getack())
error |= 4;
/*
* end byte stream
*/
i2c_stop();
/*
* enable interrupt again
*/
local_irq_restore(flags);
} while(error && cntr--);
i2c_delay(CLOCK_LOW_TIME);
return -error;
}
/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: i2c_writereg
*#
*# DESCRIPTION : Writes a value to an I2C device
*#
*#--------------------------------------------------------------------------*/
int
i2c_writereg(unsigned char theSlave, unsigned char theReg,
unsigned char theValue)
{
int error, cntr = 3;
unsigned long flags;
spin_lock_irqsave(&i2c_lock, flags);
do {
error = 0;
i2c_start();
/*
* send slave address
*/
i2c_outbyte((theSlave & 0xfe));
/*
* wait for ack
*/
if(!i2c_getack())
error = 1;
/*
* now select register
*/
i2c_dir_out();
i2c_outbyte(theReg);
/*
* now it's time to wait for ack
*/
if(!i2c_getack())
error |= 2;
/*
* send register register data
*/
i2c_outbyte(theValue);
/*
* now it's time to wait for ack
*/
if(!i2c_getack())
error |= 4;
/*
* end byte stream
*/
i2c_stop();
} while(error && cntr--);
i2c_delay(CLOCK_LOW_TIME);
spin_unlock_irqrestore(&i2c_lock, flags);
return -error;
}
int rtc_read_multiple(unsigned char address, unsigned char *buf, int numbytes)
{
int ret = 0;
unsigned char obuf[1];
int i;
i2c_begin();
obuf[0] = address;
/* send read command */
if (i2c_write(RTC_DEV_READ, obuf, 1) >= 0)
{
i2c_start();
i2c_outb(RTC_DEV_READ);
if (i2c_getack())
{
for(i = 0; i < numbytes-1; i++)
buf[i] = i2c_inb(0);
buf[i] = i2c_inb(1);
}
else
{
ret = -1;
}
}
i2c_stop();
i2c_end();
return ret;
}
int rtc_read(unsigned char address)
{
int value = -1;
unsigned char buf[1];
i2c_begin();
buf[0] = address;
/* send read command */
if (i2c_write(RTC_DEV_READ,buf,1) >= 0)
{
i2c_start();
i2c_outb(RTC_DEV_READ);
if (i2c_getack())
{
value = i2c_inb(1);
}
}
i2c_stop();
i2c_end();
return value;
}
int
i2c_read(unsigned char theSlave, void *data, size_t nbytes)
{
unsigned char b = 0;
unsigned char bytes_read = 0;
int error, cntr = 3;
unsigned long flags;
spin_lock_irqsave(&i2c_lock, flags);
do {
error = 0;
memset(data, 0, nbytes);
i2c_start();
i2c_outbyte((theSlave | 0x01));
if (!i2c_getack())
error = 1;
for (bytes_read = 0; bytes_read < nbytes; bytes_read++) {
b = i2c_inbyte();
memcpy(data + bytes_read, &b, sizeof b);
if (bytes_read < (nbytes - 1))
i2c_sendack();
}
i2c_sendnack();
i2c_stop();
} while (error && cntr--);
spin_unlock_irqrestore(&i2c_lock, flags);
return -error;
}
/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: i2c_read
*#
*# DESCRIPTION : Reads a value from an I2C device
*#
*#--------------------------------------------------------------------------*/
int
i2c_read(unsigned char theSlave, void *data, size_t nbytes)
{
unsigned char b = 0;
unsigned char bytes_read = 0;
int error, cntr = 3;
unsigned long flags;
spin_lock_irqsave(&i2c_lock, flags);
do {
error = 0;
memset(data, 0, nbytes);
/*
* generate start condition
*/
i2c_start();
/*
* send slave address
*/
i2c_outbyte((theSlave | 0x01));
/*
* wait for ack
*/
if (!i2c_getack())
error = 1;
/*
* fetch data
*/
for (bytes_read = 0; bytes_read < nbytes; bytes_read++) {
b = i2c_inbyte();
memcpy(data + bytes_read, &b, sizeof b);
if (bytes_read < (nbytes - 1))
i2c_sendack();
}
/*
* last received byte needs to be nacked
* instead of acked
*/
i2c_sendnack();
/*
* end sequence
*/
i2c_stop();
} while (error && cntr--);
spin_unlock_irqrestore(&i2c_lock, flags);
return -error;
}
int i2c_read(int address, unsigned char* buf, int count )
{
int i,x=0;
i2c_start();
i2c_outb(address | 1);
if (i2c_getack()) {
for (i=0; i<count; i++) {
buf[i] = i2c_inb(0);
}
}
else
x=-1;
i2c_stop();
return x;
}
/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: i2c_outbyte
*#
*# DESCRIPTION : write a byte to the i2c interface
*#
*# PARAMETERS : x: byte to be sent on the I2C bus
*#
*# RETURN : none
*#
*#---------------------------------------------------------------------------
*/
int i2c_outbyte( unsigned char x )
{
int i;
i2c_sda_dir_out();
for ( i = 0; i < 8; i++ )
{
if ( x & 0x80 )
{
i2c_set_sda( SDA_HIGH );
}
else
{
i2c_set_sda( SDA_LOW );
}
i2c_delay( TSUDAT );
i2c_set_scl( SCL_HIGH );
i2c_delay( THIGH );
i2c_set_scl( SCL_LOW );
i2c_delay( TSUDAT );
i2c_set_sda( SDA_LOW );
/* There should be only 5 us between falling edge and new rising
* edge of clock pulse.
* Since we spend already 1 us since clock edge was low, there are
* only ( TLOW - TSUDAT ) us left.
* Next to this, since the data line will be set up 1 us before the
* clock line is set up, we can reduce the delay with another us.
*/
i2c_delay( TLOW - TSUDAT - WAITONEUS );
x <<= 1;
}
/* enable input */
i2c_sda_dir_in();
if ( !i2c_getack() )
{
return( EI2CNOACKNLD );
}
return ( EI2CNOERRORS );
} /* i2c_outbyte */
/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: i2c_readreg
*#
*# DESCRIPTION : Reads a value from the decoder registers.
*#
*#--------------------------------------------------------------------------*/
unsigned char
i2c_readreg(unsigned char theSlave, unsigned char theReg)
{
unsigned char b = 0;
int error, cntr = 3;
unsigned long flags;
spin_lock(&i2c_lock);
do {
error = 0;
/*
* we don't like to be interrupted
*/
local_irq_save(flags);
/*
* generate start condition
*/
i2c_start();
/*
* send slave address
*/
i2c_outbyte((theSlave & 0xfe));
/*
* wait for ack
*/
if(!i2c_getack())
error = 1;
/*
* now select register
*/
i2c_dir_out();
i2c_outbyte(theReg);
/*
* now it's time to wait for ack
*/
if(!i2c_getack())
error = 1;
/*
* repeat start condition
*/
i2c_delay(CLOCK_LOW_TIME);
i2c_start();
/*
* send slave address
*/
i2c_outbyte(theSlave | 0x01);
/*
* wait for ack
*/
if(!i2c_getack())
error = 1;
/*
* fetch register
*/
b = i2c_inbyte();
/*
* last received byte needs to be nacked
* instead of acked
*/
i2c_sendack();
/*
* end sequence
*/
i2c_stop();
/*
* enable interrupt again
*/
local_irq_restore(flags);
} while(error && cntr--);
spin_unlock(&i2c_lock);
return b;
}
/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: i2c_readreg
*#
*# DESCRIPTION : Reads a value from the decoder registers.
*#
*#--------------------------------------------------------------------------*/
unsigned char
i2c_readreg(unsigned char theSlave, unsigned char theReg)
{
unsigned char b = 0;
int error, cntr = 3;
unsigned long flags;
do {
error = 0;
/*
* we don't like to be interrupted
*/
save_flags(flags);
cli();
/*
* generate start condition
*/
i2c_start();
/*
* dummy preamble
*/
i2c_outbyte(0x01);
i2c_data(I2C_DATA_HIGH);
i2c_clk(I2C_CLOCK_HIGH);
i2c_delay(CLOCK_HIGH_TIME); /* Dummy Acknowledge */
i2c_clk(I2C_CLOCK_LOW);
i2c_delay(CLOCK_LOW_TIME);
i2c_clk(I2C_CLOCK_HIGH);
i2c_delay(CLOCK_LOW_TIME); /* Repeated Start Condition */
i2c_data(I2C_DATA_LOW);
i2c_delay(CLOCK_HIGH_TIME);
i2c_clk(I2C_CLOCK_LOW);
i2c_delay(CLOCK_LOW_TIME);
i2c_start();
/*
* send slave address
*/
i2c_outbyte(theSlave);
/*
* wait for ack
*/
if(!i2c_getack())
error = 1;
/*
* now select register
*/
i2c_dir_out();
i2c_outbyte(theReg);
/*
* now it's time to wait for ack
*/
if(!i2c_getack())
error = 1;
/*
* repeat start condition
*/
i2c_delay(CLOCK_LOW_TIME);
i2c_start();
/*
* send slave address
*/
i2c_outbyte(theSlave | 0x01);
/*
* wait for ack
*/
if(!i2c_getack())
error = 1;
/*
* fetch register
*/
b = i2c_inbyte();
/*
* send Ack
*/
i2c_sendack();
/*
* end sequence
*/
i2c_stop();
/*
* enable interrupt again
*/
restore_flags(flags);
} while(error && cntr--);
return b;
}
/*#---------------------------------------------------------------------------
*#
*# FUNCTION NAME: i2c_writereg
*#
*# DESCRIPTION : Writes a value to an I2C device
*#
*#--------------------------------------------------------------------------*/
int
i2c_writereg(unsigned char theSlave, unsigned char theReg,
unsigned char theValue)
{
int error, cntr = 3;
unsigned long flags;
do {
error = 0;
/*
* we don't like to be interrupted
*/
save_flags(flags);
cli();
/*
* generate start condition
*/
i2c_start();
/*
* dummy preamble
*/
i2c_outbyte(0x01);
i2c_data(I2C_DATA_HIGH);
i2c_clk(I2C_CLOCK_HIGH);
i2c_delay(CLOCK_HIGH_TIME); /* Dummy Acknowledge */
i2c_clk(I2C_CLOCK_LOW);
i2c_delay(CLOCK_LOW_TIME);
i2c_clk(I2C_CLOCK_HIGH);
i2c_delay(CLOCK_LOW_TIME); /* Repeated Start Condition */
i2c_data(I2C_DATA_LOW);
i2c_delay(CLOCK_HIGH_TIME);
i2c_clk(I2C_CLOCK_LOW);
i2c_delay(CLOCK_LOW_TIME);
i2c_start();
/*
* send slave address
*/
i2c_outbyte(theSlave);
/*
* wait for ack
*/
if(!i2c_getack())
error = 1;
/*
* now select register
*/
i2c_dir_out();
i2c_outbyte(theReg);
/*
* now it's time to wait for ack
*/
if(!i2c_getack())
error |= 2;
/*
* send register register data
*/
i2c_outbyte(theValue);
/*
* now it's time to wait for ack
*/
if(!i2c_getack())
error |= 4;
/*
* end byte stream
*/
i2c_stop();
/*
* enable interrupt again
*/
restore_flags(flags);
} while(error && cntr--);
i2c_delay(CLOCK_LOW_TIME);
return -error;
}
