i2c_bit.c File Reference

I2C bit-bashing interface. More...

#include <stddef.h>
#include <stdint.h>
#include <errno.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <ipxe/bitbash.h>
#include <ipxe/i2c.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static void	i2c_delay (void)
	Delay between output state changes. More...
static void	setscl (struct bit_basher *basher, int state)
	Set state of I2C SCL line. More...
static void	setsda (struct bit_basher *basher, int state)
	Set state of I2C SDA line. More...
static int	getsda (struct bit_basher *basher)
	Get state of I2C SDA line. More...
static void	i2c_start (struct bit_basher *basher)
	Send an I2C start condition. More...
static void	i2c_send_bit (struct bit_basher *basher, int bit)
	Send an I2C data bit. More...
static int	i2c_recv_bit (struct bit_basher *basher)
	Receive an I2C data bit. More...
static void	i2c_stop (struct bit_basher *basher)
	Send an I2C stop condition. More...
static int	i2c_send_byte (struct bit_basher *basher, uint8_t byte)
	Send byte via I2C bus and check for acknowledgement. More...
static uint8_t	i2c_recv_byte (struct bit_basher *basher)
	Receive byte via I2C bus. More...
static int	i2c_select (struct bit_basher *basher, struct i2c_device *i2cdev, unsigned int offset, unsigned int direction)
	Select I2C device for reading or writing. More...
static int	i2c_reset (struct bit_basher *basher)
	Reset I2C bus. More...
static int	i2c_bit_read (struct i2c_interface *i2c, struct i2c_device *i2cdev, unsigned int offset, uint8_t *data, unsigned int len)
	Read data from I2C device via bit-bashing interface. More...
static int	i2c_bit_write (struct i2c_interface *i2c, struct i2c_device *i2cdev, unsigned int offset, const uint8_t *data, unsigned int len)
	Write data to I2C device via bit-bashing interface. More...
int	init_i2c_bit_basher (struct i2c_bit_basher *i2cbit, struct bit_basher_operations *bash_op)
	Initialise I2C bit-bashing interface. More...

Detailed Description

I2C bit-bashing interface.

This implements a simple I2C master via a bit-bashing interface that provides two lines: SCL (clock) and SDA (data).

Definition in file i2c_bit.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

i2c_delay()

static void i2c_delay ( void  )

static

Delay between output state changes.

Max rated i2c speed (for the basic i2c protocol) is 100kbps, i.e. 200k clock transitions per second.

Definition at line 49 of file i2c_bit.c.

                               {
        udelay ( I2C_UDELAY );
}

References I2C_UDELAY, and udelay().

Referenced by setscl(), and setsda().

setscl()

static void setscl ( struct bit_basher *  basher, int  state  )

static

Set state of I2C SCL line.

Parameters

basher	Bit-bashing interface
state	New state of SCL

Definition at line 59 of file i2c_bit.c.

                                                            {
        DBG2 ( "%c", ( state ? '/' : '\\' ) );
        write_bit ( basher, I2C_BIT_SCL, state );
        i2c_delay();
}

References DBG2, I2C_BIT_SCL, i2c_delay(), state, and write_bit().

Referenced by i2c_recv_bit(), i2c_reset(), i2c_send_bit(), i2c_start(), and i2c_stop().

setsda()

static void setsda ( struct bit_basher *  basher, int  state  )

static

Set state of I2C SDA line.

Parameters

basher	Bit-bashing interface
state	New state of SDA

Definition at line 71 of file i2c_bit.c.

                                                            {
        DBG2 ( "%c", ( state ? '1' : '0' ) );
        write_bit ( basher, I2C_BIT_SDA, state );
        i2c_delay();
}

References DBG2, I2C_BIT_SDA, i2c_delay(), state, and write_bit().

Referenced by i2c_reset(), i2c_send_bit(), i2c_start(), and i2c_stop().

getsda()

static int getsda ( struct bit_basher *  basher )

static

Get state of I2C SDA line.

Parameters

basher

Bit-bashing interface

Return values

state

State of SDA

Definition at line 83 of file i2c_bit.c.

                                                {
        int state;
        state = read_bit ( basher, I2C_BIT_SDA );
        DBG2 ( "%c", ( state ? '+' : '-' ) );
        return state;
}

References DBG2, I2C_BIT_SDA, read_bit(), and state.

Referenced by i2c_recv_bit(), and i2c_reset().

i2c_start()

static void i2c_start ( struct bit_basher *  basher )

static

Send an I2C start condition.

Parameters

basher

Bit-bashing interface

Definition at line 95 of file i2c_bit.c.

                                                    {
        setscl ( basher, 1 );
        setsda ( basher, 0 );
        setscl ( basher, 0 );
        setsda ( basher, 1 );
}

References setscl(), and setsda().

Referenced by i2c_reset(), and i2c_select().

i2c_send_bit()

static void i2c_send_bit ( struct bit_basher *  basher, int  bit  )

static

Send an I2C data bit.

Parameters

basher	Bit-bashing interface
bit	Bit to send

Definition at line 108 of file i2c_bit.c.

                                                                {
        setsda ( basher, bit );
        setscl ( basher, 1 );
        setscl ( basher, 0 );
        setsda ( basher, 1 );
}

References bit, setscl(), and setsda().

Referenced by i2c_recv_byte(), and i2c_send_byte().

i2c_recv_bit()

static int i2c_recv_bit ( struct bit_basher *  basher )

static

Receive an I2C data bit.

Parameters

basher

Bit-bashing interface

Return values

bit	Received bit

Definition at line 121 of file i2c_bit.c.

                                                      {
        int bit;

        setscl ( basher, 1 );
        bit = getsda ( basher );
        setscl ( basher, 0 );
        return bit;
}

References bit, getsda(), and setscl().

Referenced by i2c_recv_byte(), and i2c_send_byte().

i2c_stop()

static void i2c_stop ( struct bit_basher *  basher )

static

Send an I2C stop condition.

Parameters

basher

Bit-bashing interface

Definition at line 135 of file i2c_bit.c.

                                                   {
        setsda ( basher, 0 );
        setscl ( basher, 1 );
        setsda ( basher, 1 );
}

References setscl(), and setsda().

Referenced by i2c_bit_read(), i2c_bit_write(), and i2c_reset().

i2c_send_byte()

static int i2c_send_byte ( struct bit_basher *  basher, uint8_t  byte  )

static

Send byte via I2C bus and check for acknowledgement.

Parameters

basher	Bit-bashing interface
byte	Byte to send

Return values

rc	Return status code

Sends a byte via the I2C bus and checks for an acknowledgement from the slave device.

Definition at line 151 of file i2c_bit.c.

                                                                     {
        int i;
        int ack;

        /* Send byte */
        DBG2 ( "[send %02x]", byte );
        for ( i = 8 ; i ; i-- ) {
                i2c_send_bit ( basher, byte & 0x80 );
                byte <<= 1;
        }

        /* Check for acknowledgement from slave */
        ack = ( i2c_recv_bit ( basher ) == 0 );
        DBG2 ( "%s", ( ack ? "[acked]" : "[not acked]" ) );

        return ( ack ? 0 : -EIO );
}

References DBG2, EIO, i2c_recv_bit(), and i2c_send_bit().

Referenced by i2c_bit_read(), i2c_bit_write(), and i2c_select().

i2c_recv_byte()

static uint8_t i2c_recv_byte ( struct bit_basher *  basher )

static

Receive byte via I2C bus.

Parameters

basher

Bit-bashing interface

Return values

byte	Received byte

Receives a byte via the I2C bus and sends NACK to the slave device.

Definition at line 177 of file i2c_bit.c.

                                                           {
        uint8_t byte = 0;
        int i;

        /* Receive byte */
        for ( i = 8 ; i ; i-- ) {
                byte <<= 1;
                byte |= ( i2c_recv_bit ( basher ) & 0x1 );
        }

        /* Send NACK */
        i2c_send_bit ( basher, 1 );

        DBG2 ( "[rcvd %02x]", byte );
        return byte;
}

References DBG2, i2c_recv_bit(), and i2c_send_bit().

Referenced by i2c_bit_read().

i2c_select()

static int i2c_select ( struct bit_basher *  basher, struct i2c_device *  i2cdev, unsigned int  offset, unsigned int  direction  )

static

Select I2C device for reading or writing.

Parameters

basher	Bit-bashing interface
i2cdev	I2C device
offset	Starting offset within the device
direction	I2C_READ or I2C_WRITE

Return values

rc	Return status code

Definition at line 203 of file i2c_bit.c.

                                                                      {
        unsigned int address;
        int shift;
        unsigned int byte;
        int rc;

        i2c_start ( basher );

        /* Calculate address to appear on bus */
        address = ( ( ( i2cdev->dev_addr |
                        ( offset >> ( 8 * i2cdev->word_addr_len ) ) ) << 1 )
                    | direction );

        /* Send address a byte at a time */
        for ( shift = ( 8 * ( i2cdev->dev_addr_len - 1 ) ) ;
              shift >= 0 ; shift -= 8 ) {
                byte = ( ( address >> shift ) & 0xff );
                if ( ( rc = i2c_send_byte ( basher, byte ) ) != 0 )
                        return rc;
        }

        return 0;
}

References address, i2c_device::dev_addr, i2c_device::dev_addr_len, direction, i2c_send_byte(), i2c_start(), offset, rc, and i2c_device::word_addr_len.

Referenced by i2c_bit_read(), and i2c_bit_write().

i2c_reset()

static int i2c_reset ( struct bit_basher *  basher )

static

Reset I2C bus.

Parameters

basher

Bit-bashing interface

Return values

rc	Return status code

i2c devices often don't have a reset line, so even a reboot or system power cycle is sometimes not enough to bring them back to a known state.

Definition at line 238 of file i2c_bit.c.

                                                   {
        unsigned int i;
        int sda;

        /* Clock through several cycles, waiting for an opportunity to
         * pull SDA low while SCL is high (which creates a start
         * condition).
         */
        open_bit ( basher );
        setscl ( basher, 0 );
        setsda ( basher, 1 );
        for ( i = 0 ; i < I2C_RESET_MAX_CYCLES ; i++ ) {
                setscl ( basher, 1 );
                sda = getsda ( basher );
                if ( sda ) {
                        /* Now that the device will see a start, issue it */
                        i2c_start ( basher );
                        /* Stop the bus to leave it in a known good state */
                        i2c_stop ( basher );
                        DBGC ( basher, "I2CBIT %p reset after %d attempts\n",
                               basher, ( i + 1 ) );
                        close_bit ( basher );
                        return 0;
                }
                setscl ( basher, 0 );
        }

        DBGC ( basher, "I2CBIT %p could not reset after %d attempts\n",
               basher, i );
        close_bit ( basher );
        return -ETIMEDOUT;
}

References close_bit(), DBGC, ETIMEDOUT, getsda(), I2C_RESET_MAX_CYCLES, i2c_start(), i2c_stop(), open_bit(), setscl(), and setsda().

Referenced by init_i2c_bit_basher().

i2c_bit_read()

static int i2c_bit_read ( struct i2c_interface *  i2c, struct i2c_device *  i2cdev, unsigned int  offset, uint8_t *  data, unsigned int  len  )

static

Read data from I2C device via bit-bashing interface.

Parameters

i2c	I2C interface
i2cdev	I2C device
offset	Starting offset within the device
data	Data buffer
len	Length of data buffer

Return values

rc	Return status code

Note that attempting to read zero bytes of data is a valid way to check for I2C device presence.

Definition at line 284 of file i2c_bit.c.

                                                            {
        struct i2c_bit_basher *i2cbit
                = container_of ( i2c, struct i2c_bit_basher, i2c );
        struct bit_basher *basher = &i2cbit->basher;
        int rc = 0;

        DBGC ( basher, "I2CBIT %p reading from device %x: ",
               basher, i2cdev->dev_addr );

        open_bit ( basher );

        for ( ; ; data++, offset++ ) {

                /* Select device for writing */
                if ( ( rc = i2c_select ( basher, i2cdev, offset,
                                         I2C_WRITE ) ) != 0 )
                        break;

                /* Abort at end of data */
                if ( ! ( len-- ) )
                        break;

                /* Select offset */
                if ( ( rc = i2c_send_byte ( basher, offset ) ) != 0 )
                        break;
                
                /* Select device for reading */
                if ( ( rc = i2c_select ( basher, i2cdev, offset,
                                         I2C_READ ) ) != 0 )
                        break;

                /* Read byte */
                *data = i2c_recv_byte ( basher );
                DBGC ( basher, "%02x ", *data );
        }
        
        DBGC ( basher, "%s\n", ( rc ? "failed" : "" ) );
        i2c_stop ( basher );
        close_bit ( basher );
        return rc;
}

References i2c_bit_basher::basher, close_bit(), container_of, data, DBGC, i2c_device::dev_addr, i2c_bit_basher::i2c, I2C_READ, i2c_recv_byte(), i2c_select(), i2c_send_byte(), i2c_stop(), I2C_WRITE, len, offset, open_bit(), and rc.

Referenced by init_i2c_bit_basher().

i2c_bit_write()

static int i2c_bit_write ( struct i2c_interface *  i2c, struct i2c_device *  i2cdev, unsigned int  offset, const uint8_t *  data, unsigned int  len  )

static

Write data to I2C device via bit-bashing interface.

Parameters

i2c	I2C interface
i2cdev	I2C device
offset	Starting offset within the device
data	Data buffer
len	Length of data buffer

Return values

rc	Return status code

Note that attempting to write zero bytes of data is a valid way to check for I2C device presence.

Definition at line 341 of file i2c_bit.c.

                                                                   {
        struct i2c_bit_basher *i2cbit
                = container_of ( i2c, struct i2c_bit_basher, i2c );
        struct bit_basher *basher = &i2cbit->basher;
        int rc = 0;

        DBGC ( basher, "I2CBIT %p writing to device %x: ",
               basher, i2cdev->dev_addr );

        open_bit ( basher );

        for ( ; ; data++, offset++ ) {

                /* Select device for writing */
                if ( ( rc = i2c_select ( basher, i2cdev, offset,
                                         I2C_WRITE ) ) != 0 )
                        break;
                
                /* Abort at end of data */
                if ( ! ( len-- ) )
                        break;

                /* Select offset */
                if ( ( rc = i2c_send_byte ( basher, offset ) ) != 0 )
                        break;
                
                /* Write data to device */
                DBGC ( basher, "%02x ", *data );
                if ( ( rc = i2c_send_byte ( basher, *data ) ) != 0 )
                        break;
        }

        DBGC ( basher, "%s\n", ( rc ? "failed" : "" ) );
        i2c_stop ( basher );
        close_bit ( basher );
        return rc;
}

References i2c_bit_basher::basher, close_bit(), container_of, data, DBGC, i2c_device::dev_addr, i2c_bit_basher::i2c, i2c_select(), i2c_send_byte(), i2c_stop(), I2C_WRITE, len, offset, open_bit(), and rc.

Referenced by init_i2c_bit_basher().

init_i2c_bit_basher()

int init_i2c_bit_basher	(	struct i2c_bit_basher *	i2cbit,
		struct bit_basher_operations *	bash_op
	)

Initialise I2C bit-bashing interface.

Parameters

i2cbit	I2C bit-bashing interface
bash_op	Bit-basher operations

Definition at line 387 of file i2c_bit.c.

                                                                  {
        struct bit_basher *basher = &i2cbit->basher;
        int rc;

        /* Initialise data structures */
        basher->op = bash_op;
        assert ( basher->op->read != NULL );
        assert ( basher->op->write != NULL );
        i2cbit->i2c.read = i2c_bit_read;
        i2cbit->i2c.write = i2c_bit_write;

        /* Reset I2C bus */
        if ( ( rc = i2c_reset ( basher ) ) != 0 ) {
                DBGC ( basher, "I2CBIT %p could not reset I2C bus: %s\n",
                       basher, strerror ( rc ) );
                return rc;
        }

        return 0;
}

References assert(), i2c_bit_basher::basher, DBGC, i2c_bit_basher::i2c, i2c_bit_read(), i2c_bit_write(), i2c_reset(), NULL, bit_basher::op, rc, bit_basher_operations::read, i2c_interface::read, strerror(), bit_basher_operations::write, and i2c_interface::write.

Referenced by exanic_try_init_eeprom(), falcon_probe_spi(), linda_init_i2c(), and qib7322_init_i2c().