/****************************************************************************
*
* Copyright (c) 2006 Dave Hylands <dhylands@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* Alternatively, this software may be distributed under the terms of BSD
* license.
*
* See README and COPYING for more details.
*
****************************************************************************/
/**
*
* @file i2c-api.c
*
* @brief This file contains the implementation for performing I2C operations
* on the gumstix.
*
****************************************************************************/
// ---- Include Files -------------------------------------------------------
#include <string.h>
#include <errno.h>
#include "i2c.h"
#include "i2c-dev.h"
#include "i2c-api.h"
#include "Crc8.h"
#include "DumpMem.h"
#include "Log.h"
// ---- Public Variables ----------------------------------------------------
// ---- Private Constants and Types -----------------------------------------
// ---- Private Variables ---------------------------------------------------
static I2C_Addr_t gI2cAddr;
static int gUseCrc;
// ---- Private Function Prototypes -----------------------------------------
// ---- Functions -----------------------------------------------------------
//***************************************************************************
/**
*
* Sets the I2C address that we'll be communicating with, as well as whether
* the device uses smbus PEC (CRC).
*/
void I2cSetSlaveAddress( int i2cDev, I2C_Addr_t i2cAddr, int useCrc )
{
gI2cAddr = i2cAddr;
gUseCrc = useCrc;
LogDebug( "----- I2cSetSlaveAddress i2cAddr:0x%02x useCrc:%d -----\n",
i2cAddr, useCrc );
// Indicate which slave we wish to speak to
if ( ioctl( i2cDev, I2C_SLAVE, gI2cAddr ) < 0 )
{
LogError( "I2cSetSlaveAddress: Error trying to set slave address to 0x%02x (%d %s)\n",
gI2cAddr, errno, strerror( errno ));
}
// We do the CRC calculation ourself, so we don't need to tell the driver
// that we're using it.
#if 0
// Indicate that we use PEC (aka CRCs)
if ( ioctl( i2cDev, I2C_PEC, 1 ) < 0 )
{
LogError( "I2cSetSlaveAddress: Error trying to set PEC mode\n" );
}
#endif
} // I2cSetSlaveAddress
//***************************************************************************
/**
* Transfer data to/from an i2c device.
*
* This function implements the equivalent of the smbus functions using
* I2C_RDWR.
*
* The PXA driver doesn't support the smbus transfers.
*
* This function can perform the following SMBUS transactions:
*
* Write Byte: wrLen == 1, rdLen == 0
* Read Byte: wrLen == 0, rdLen == 1
* Write Word: wrLen == 2, rdLen == 0
* Read Word: wrLen == 0, rdLen == 2
* Process Call: wrLen == 2, rdLen == 2
* Write Block: wrLen == 0x80 + numBytes, rdLen == 0
* Read Block: wrLen == 0, rdLen == 0x80 + numBytes
* Process Block: wrLen == 0x80 + numBytes, rdLen == 0x80 + numBytes
*/
int I2cTransfer
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t cmd, ///< Command to send
const void *wrData, ///< Data to write
uint8_t wrLen, ///< Number of bytes to write (or in 0x80 for a block write)
void *rdData, ///< Place to store data read
uint8_t rdLen, ///< Number of bytes to read (or in 0x80 for a block read)
uint8_t *bytesReadp ///< Place to store number of bytes read
)
{
struct i2c_rdwr_ioctl_data rdwr;
struct i2c_msg msg[ 2 ];
uint8_t wrBuf[ I2C_MAX_DATA_LEN + 3 ]; // +1 for cmd, +1 for len, +1 for CRC
uint8_t rdBuf[ I2C_MAX_DATA_LEN + 2 ]; // +1 for len, +1 for CRC
uint8_t crc = 0;
uint8_t wrBlock = (( wrLen & 0x80 ) != 0 );
uint8_t rdBlock = (( rdLen & 0x80 ) != 0 );
int rc = 0;
LogDebug( "----- I2cTransfer: cmd:0x%02x wrLen:0x%02x rdLen:0x%02x wrBlock:%d rdBlock:%d -----\n",
cmd, wrLen, rdLen, wrBlock, rdBlock );
if ( wrData != NULL )
{
LogDebug( "----- wrData:0x%08x *wrData:0x%02x -----\n", wrData, *(const uint8_t *)wrData );
}
rdLen &= 0x7f;
wrLen &= 0x7f;
if ( bytesReadp != NULL )
{
*bytesReadp = 0;
}
if ( wrLen > I2C_MAX_DATA_LEN )
{
LogError( "I2cTransfer: wrLen too big: %d, max is %d\n",
wrLen, I2C_MAX_DATA_LEN );
errno = ENOBUFS;
return -1;
}
if ( rdLen > I2C_MAX_DATA_LEN )
{
LogError( "I2cTransfer: rdLen too big: %d, max is %d\n",
rdLen, I2C_MAX_DATA_LEN );
errno = ENOBUFS;
return -1;
}
// Whether we're doing a read or a write, we always send
// the command.
msg[ 0 ].addr = gI2cAddr;
msg[ 0 ].flags = 0;
msg[ 0 ].len = wrLen + 1 + wrBlock; // +1 for cmd
msg[ 0 ].buf = (char *)&wrBuf[ 0 ];
if ( gUseCrc )
{
crc = Crc8( 0, gI2cAddr << 1 );
crc = Crc8( crc, cmd );
}
wrBuf[ 0 ] = cmd;
if ( wrLen > 0 )
{
// We have some data to send down to the device
if ( wrBlock )
{
wrBuf[ 1 ] = wrLen;
memcpy( &wrBuf[ 2 ], wrData, wrLen );
wrLen++; // Add in cmd to the length
}
else
{
memcpy( &wrBuf[ 1 ], wrData, wrLen );
}
if ( gUseCrc )
{
crc = Crc8Block( crc, &wrBuf[ 1 ], wrLen );
if ( rdLen == 0 )
{
// This is a write-only, so we need to send the CRC
wrBuf[ wrLen + 1 ] = crc;
msg[ 0 ].len++;
}
}
}
if ( gDebug )
{
Log( "msg[ 0 ].addr = 0x%02x\n", msg[ 0 ].addr );
Log( "msg[ 0 ].flags = 0x%04x\n", msg[ 0 ].flags );
Log( "msg[ 0 ].len = %d\n", msg[ 0 ].len );
DumpMem( "I2cTransfer W", 0, &wrBuf[ 0 ], msg[ 0 ].len );
}
rdwr.msgs = msg;
rdwr.nmsgs = 1;
if ( rdLen > 0 )
{
// We're expecting some data to come back
msg[ 1 ].addr = gI2cAddr;
msg[ 1 ].flags = I2C_M_RD;
msg[ 1 ].len = rdLen + rdBlock + gUseCrc;
msg[ 1 ].buf = (char *)&rdBuf[ 0 ];
rdwr.nmsgs = 2;
if ( gUseCrc )
{
crc = Crc8( crc, ( gI2cAddr << 1 ) | 1 );
}
if ( gDebug )
{
Log( "msg[ 1 ].addr = 0x%02x\n", msg[ 1 ].addr );
Log( "msg[ 1 ].flags = 0x%04x\n", msg[ 1 ].flags );
Log( "msg[ 1 ].len = %d\n", msg[ 1 ].len );
}
}
if ( ioctl( i2cDev, I2C_RDWR, &rdwr ) < 0 )
{
LogError( "I2cTransfer: ioctl failed: %s (%d)\n", strerror( errno ), errno );
return -1;
}
if ( rdLen > 0 )
{
if ( rdBlock )
{
if ( rdBuf[ 0 ] > rdLen )
{
LogError( "I2cTransfer: length is too big: %d max: %d\n", rdBuf[ 0 ], rdLen );
rc = EMSGSIZE;
}
else
{
rdLen = rdBuf[ 0 ];
}
}
if ( gUseCrc )
{
crc = Crc8Block( crc, &rdBuf[ 0 ], rdLen + rdBlock );
if ( crc != rdBuf[ rdLen + rdBlock ] )
{
LogError( "I2cTransfer: CRC failed: Rcvd: 0x%02x, expecting: 0x%02x\n",
rdBuf[ rdLen + rdBlock ], crc );
rc = EBADMSG;
}
}
if ( gDebug )
{
DumpMem( "I2cTransfer R", 0, &rdBuf[ 0 ], msg[ 1 ].len );
}
memcpy( rdData, &rdBuf[ rdBlock ], rdLen );
if ( bytesReadp != NULL )
{
*bytesReadp = rdLen;
}
}
return rc;
} // I2cTransfer
//***************************************************************************
/**
* Uses the SMBUS Process-Block protocol to read data from a device.
*/
int I2cProcessBlock
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t cmd, ///< Command to send
const void *wrData, ///< Data to write
uint8_t wrLen, ///< Number of bytes to write
void *rdData, ///< Place to store data read
uint8_t rdLen, ///< Number of bytes to read
uint8_t *bytesReadp ///< Place to store number of bytes read
)
{
LogDebug( "----- I2cProcessBlock cmd: 0x%02x wrLen:0x%02x rdLen:0x%02x -----\n", cmd, wrLen, rdLen );
return I2cTransfer( i2cDev, cmd, wrData, 0x80 | wrLen, rdData, 0x80 | rdLen, bytesReadp );
} // I2cProcessBlock
//***************************************************************************
/**
* Uses the SMBUS Read-Block protocol to read data from a device.
*/
int I2cReadBlock
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t cmd, ///< Command to send
void *rdData, ///< Place to store data read
uint8_t rdLen, ///< Number of bytes to read
uint8_t *bytesReadp ///< Place to store number of bytes read
)
{
LogDebug( "----- I2cReadBlock cmd: 0x%02x rdLen:0x%02x -----\n", cmd, rdLen );
return I2cTransfer( i2cDev, cmd, NULL, 0, rdData, 0x80 | rdLen, bytesReadp );
} // I2cReadBlock
//***************************************************************************
/**
* Uses the SMBUS Read-Byte protocol to read a byte.
*/
int I2cReadByte
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t cmd, ///< Command to send
uint8_t *rdByte ///< Place to store byte read
)
{
LogDebug( "----- I2cReadByte cmd: 0x%02x -----\n", cmd );
return I2cTransfer( i2cDev, cmd, NULL, 0, rdByte, 1, NULL );
} // I2cReadByte
//***************************************************************************
/**
* Reads an array of bytes usinng i2c (not compatible with SMBUS)
*/
int I2cReadBytes
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t cmd, ///< Command to send
void *rdByte, ///< Place to store bytes read
uint8_t rdLen ///< Number of bytes to read
)
{
LogDebug( "----- I2cReadBytes cmd: 0x%02x rdLen: 0x%02x -----\n", cmd, rdLen );
return I2cTransfer( i2cDev, cmd, NULL, 0, rdByte, rdLen, NULL );
} // I2cReadBytes
//***************************************************************************
/**
* Uses the SMBUS Write-Block protocol to write data from a device.
*/
int I2cWriteBlock
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t cmd, ///< Command to send
const void *wrData, ///< Data to write
uint8_t wrLen ///< Number of bytes to write
)
{
LogDebug( "----- I2cWriteBlock cmd: 0x%02x wrLen:0x%02x -----\n", cmd, wrLen );
return I2cTransfer( i2cDev, cmd, wrData, 0x80 | wrLen, NULL, 0, NULL );
} // I2cWriteBlock
//***************************************************************************
/**
* Uses the SMBUS Write-Byte protocol to write a byte.
*/
int I2cWriteByte
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t cmd, ///< Command to send
uint8_t wrByte ///< Byte to write
)
{
LogDebug( "----- I2cWriteByte cmd: 0x%02x wrByte:0x%02x -----\n", cmd, wrByte );
LogDebug( "----- &wrByte = 0x%08x wrByte = 0x%02x -----\n", &wrByte, *&wrByte );
return I2cTransfer( i2cDev, cmd, &wrByte, 1, NULL, 0, NULL );
} // I2cWriteByte
//***************************************************************************
/**
* Writes an array of bytes using i2c (not compatible with SMBUS)
*/
int I2cWriteBytes
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t cmd, ///< Command to send
const void *wrByte, ///< Bytes to write
uint8_t wrLen ///< Number of bytes to write
)
{
LogDebug( "----- I2cWriteBytes cmd: 0x%02x wrLen: 0x%02x -----\n", cmd, wrLen );
return I2cTransfer( i2cDev, cmd, wrByte, wrLen, NULL, 0, NULL );
} // I2cWriteBytes
//***************************************************************************
/**
* Uses the SMBUS Receive-Byte protocol to read a byte.
*/
int I2cReceiveByte
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t *rdByte ///< Place to store byte read
)
{
return I2cReceiveBytes( i2cDev, rdByte, 1 );
} // I2cReceiveByte
//***************************************************************************
/**
* Uses the SMBUS Receive-Byte protocol to read multiple (or one or zero) bytes.
*/
int I2cReceiveBytes
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t *rdData, ///< Place to store data read
uint8_t rdLen ///< Number of bytes to read
)
{
struct i2c_rdwr_ioctl_data rdwr;
struct i2c_msg msg;
LogDebug( "----- I2cReceiveBytes -----\n" );
msg.addr = gI2cAddr;
msg.flags = I2C_M_RD;
msg.len = rdLen;
msg.buf = (char *)rdData;
rdwr.msgs = &msg;
rdwr.nmsgs = 1;
if ( ioctl( i2cDev, I2C_RDWR, &rdwr ) < 0 )
{
LogError( "I2cReceiveBytes: ioctl failed: %s (%d)\n", strerror( errno ), errno );
return -1;
}
return 0;
} // I2cReceiveBytes
//***************************************************************************
/**
* Uses the SMBUS Send-Byte protocol to write a byte.
*/
int I2cSendByte
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t wrByte ///< Byte to write
)
{
return I2cSendBytes( i2cDev, &wrByte, 1 );
} // I2cSendByte
//***************************************************************************
/**
* Uses the SMBUS Send-Byte protocol to write multiple (or zero or one) bytes.
*/
int I2cSendBytes
(
int i2cDev, ///< Handle to i2c-dev file
uint8_t *wrData, ///< Pointer to data to write
uint8_t wrLen ///< NUmber of bytes to write
)
{
struct i2c_rdwr_ioctl_data rdwr;
struct i2c_msg msg;
LogDebug( "----- I2cSendBytes wrLen = 0x%02x -----\n", wrLen );
msg.addr = gI2cAddr;
msg.flags = 0;
msg.len = wrLen;
msg.buf = (char *)wrData;
rdwr.msgs = &msg;
rdwr.nmsgs = 1;
if ( ioctl( i2cDev, I2C_RDWR, &rdwr ) < 0 )
{
LogError( "I2cSendBytes: ioctl failed: %s (%d)\n", strerror( errno ), errno );
return -1;
}
return 0;
} // I2cSendBytes