stm32_i2c.c

Go to the documentation of this file.

/**
 * \file    heivs/stm32_i2c.c
 * \brief   i2c bus
 * \author  marc dot pignat at hevs dot ch
 */

/**
 * FIXME : if a device NACK, this will trigger the timeout error
 */
#include "heivs/stm32_i2c.h"
#include "heivs/time.h"
#include "heivs/bsp.h"
#include "stm32/stm32f4xx_i2c.h"
#include "stm32/stm32f4xx_rcc.h"
#include "heivs/delay.h"

#define I2C_STD_TIMEOUT_MS (5)

/**
 * \brief Workaround i2c devices without reset pins
 *
 * Force-reset any device which is stuck in an i2c transfer
 */
static void workaround_reset_i2c_devices(const struct gpio_t *pins)
{
    int i;
    struct gpio_t gpio_scl = pins[0];
    struct gpio_t gpio_sda = pins[1];
    gpio_scl.mode = GPIO_OUTPUT_1 | GPIO_OD | GPIO_SPEED_100;
    gpio_sda.mode = GPIO_OUTPUT_1 | GPIO_OD | GPIO_SPEED_100;
    gpio_setup(&gpio_scl);
    gpio_setup(&gpio_sda);

    for (i = 0 ; i < 9 ; i++)
    {
        gpio_set(&gpio_scl, 0);
        delay_wait_us(5);
        gpio_set(&gpio_scl, 1);
        delay_wait_us(5);
    }
}

static status_e init(const struct heivs_bus_t *bus)
{
    I2C_InitTypeDef I2C_InitStructure;
    const struct i2c_bus_private_t *i2c = bus->priv;

    workaround_reset_i2c_devices(i2c->gpios);
    gpio_setup_list(i2c->gpios, 2);

    switch ((uint32_t)i2c->ctrl)
    {
    case (uint32_t)I2C1:
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
    break;

    case (uint32_t)I2C2:
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);
    break;

    case (uint32_t)I2C3:
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C3, ENABLE);
    break;

    default:
    case 0:
        return ERROR_BAD_PARAM;
    }

    RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
    RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, DISABLE);

    /* Initialize the i2c controller */
    I2C_DeInit(i2c->ctrl);

    I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
    I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
    I2C_InitStructure.I2C_OwnAddress1 = 0x00;
    I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
    I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
    I2C_InitStructure.I2C_ClockSpeed = 100*1000;

    /* Enable the I2C peripheral */
    I2C_Init(i2c->ctrl, &I2C_InitStructure);
    I2C_Cmd(i2c->ctrl, ENABLE);

    return NO_ERROR;
}

static status_e suspend(const struct heivs_bus_t *bus)
{
    (void)bus;
    return ERROR_NOT_YET_IMPLEMENTED;
}

static status_e i2c_start_re(const struct i2c_bus_private_t *i2c, uint8_t address, uint8_t direction, uint32_t re)
{
    timeout_t timeout;

    if (!re)
    {
        timeout = time_set_timeout_ms(I2C_STD_TIMEOUT_MS);
        while (I2C_GetFlagStatus(i2c->ctrl, I2C_FLAG_BUSY))
        {
            if (time_elapsed(timeout))
            {
                return ERROR_TIMEOUT;
            }
        }
    }

    I2C_GenerateSTART(i2c->ctrl, ENABLE);
    timeout = time_set_timeout_ms(I2C_STD_TIMEOUT_MS);
    while (!I2C_CheckEvent(i2c->ctrl, I2C_EVENT_MASTER_MODE_SELECT))
    {
        if (time_elapsed(timeout))
        {
            return ERROR_TIMEOUT;
        }
    }

    I2C_Send7bitAddress(i2c->ctrl, address << 1, direction);
    timeout = time_set_timeout_ms(I2C_STD_TIMEOUT_MS);
    if (direction == I2C_Direction_Transmitter)
    {
        while(!I2C_CheckEvent(i2c->ctrl, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
        {
            if (time_elapsed(timeout))
            {
                return ERROR_TIMEOUT;
            }
        }
    }
    else
    {
        while(!I2C_CheckEvent(i2c->ctrl, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
        {
            if (time_elapsed(timeout))
            {
                return ERROR_TIMEOUT;
            }
        }
    }

    return NO_ERROR;
}

static status_e i2c_restart(const struct i2c_bus_private_t *i2c, uint8_t address, uint8_t direction)
{
    return i2c_start_re(i2c, address, direction, 1);
}

static status_e i2c_start(const struct i2c_bus_private_t *i2c, uint8_t address, uint8_t direction)
{
    return i2c_start_re(i2c, address, direction, 0);
}

static status_e i2c_write_one(const struct i2c_bus_private_t *i2c, uint8_t data)
{
    timeout_t timeout;

    I2C_SendData(i2c->ctrl, data);
    timeout = time_set_timeout_ms(I2C_STD_TIMEOUT_MS);
    while(!I2C_CheckEvent(i2c->ctrl, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
    {
        if (time_elapsed(timeout))
        {
            return ERROR_TIMEOUT;
        }
    }

    return NO_ERROR;
}

static status_e i2c_read_one_ack(const struct i2c_bus_private_t *i2c, uint8_t *data)
{
    timeout_t timeout;

    I2C_AcknowledgeConfig(i2c->ctrl, ENABLE);
    timeout = time_set_timeout_ms(I2C_STD_TIMEOUT_MS);
    while( !I2C_CheckEvent(i2c->ctrl, I2C_EVENT_MASTER_BYTE_RECEIVED) )
    {
        if (time_elapsed(timeout))
        {
            return ERROR_TIMEOUT;
        }
    }

    *data = I2C_ReceiveData(i2c->ctrl);

    return NO_ERROR;
}

static status_e i2c_read_one_nack(const struct i2c_bus_private_t *i2c, uint8_t *data)
{
    timeout_t timeout;

    I2C_AcknowledgeConfig(i2c->ctrl, DISABLE);
    timeout = time_set_timeout_ms(I2C_STD_TIMEOUT_MS);
    while( !I2C_CheckEvent(i2c->ctrl, I2C_EVENT_MASTER_BYTE_RECEIVED) )
    {
        if (time_elapsed(timeout))
        {
            return ERROR_TIMEOUT;
        }
    }

    *data = I2C_ReceiveData(i2c->ctrl);

    return NO_ERROR;
}

static void i2c_stop(const struct i2c_bus_private_t *i2c)
{
    I2C_GenerateSTOP(i2c->ctrl, ENABLE);
}

static status_e _read(const struct heivs_bus_t *bus, uint32_t address, uint8_t *data, size_t len, size_t *rlen)
{
    const struct i2c_bus_private_t *i2c = bus->priv;
    status_e status;
    size_t i;

    *rlen = 0;

    status = i2c_start(i2c, address, I2C_Direction_Receiver);
    if (status != NO_ERROR)
    {
        return status;
    }

    if (len > 1)
    {
        for (i = 0 ; i < len - 1 ; i++)
        {
            status = i2c_read_one_ack(i2c, &data[i]);
            if (status != NO_ERROR)
            {
                status = ERROR_TIMEOUT;
                goto error;
            }
            *rlen = *rlen+1;
        }
    }
    else
    {
        i = 0;
    }

    status = i2c_read_one_nack(i2c, &data[i]);
    if (status != NO_ERROR)
    {
        status = ERROR_TIMEOUT;
        goto error;
    }
    *rlen = *rlen+1;

error:
    i2c_stop(i2c);
    return status;
}

static status_e _write(const struct heivs_bus_t *bus, uint32_t address, const uint8_t *data, size_t len)
{
    const struct i2c_bus_private_t *i2c = bus->priv;
    status_e status;
    size_t i;

    status = i2c_start(i2c, address, I2C_Direction_Transmitter);
    if (status != NO_ERROR)
    {
        return status;
    }

    for (i = 0 ; i < len ; i++)
    {
        status = i2c_write_one(i2c, data[i]);
        if (status != NO_ERROR)
        {
            goto error;
        }
    }

error:
    i2c_stop(i2c);
    return status;
}

static status_e _writeread(const struct heivs_bus_t *bus, uint32_t address, const uint8_t *src, size_t src_len, uint8_t *dst, size_t dst_len, size_t *rlen)
{
    const struct i2c_bus_private_t *i2c = bus->priv;
    status_e status;
    size_t i;

    *rlen = 0;

    status = i2c_start(i2c, address, I2C_Direction_Transmitter);
    if (status != NO_ERROR)
    {
        return status;
    }

    for (i = 0 ; i < src_len ; i++)
    {
        status = i2c_write_one(i2c, src[i]);
        if (status != NO_ERROR)
        {
            goto error;
        }
    }

    status = i2c_restart(i2c, address, I2C_Direction_Receiver);
    if (status != NO_ERROR)
    {
        return status;
    }

    if (dst_len > 1)
    {
        for (i = 0 ; i < dst_len - 1 ; i++)
        {
            status = i2c_read_one_ack(i2c, &dst[i]);
            if (status != NO_ERROR)
            {
                goto error;
            }
            *rlen = *rlen+1;
        }
    }
    else
    {
        i = 0;
    }

    status = i2c_read_one_nack(i2c, &dst[i]);
    if (status != NO_ERROR)
    {
        status = ERROR_TIMEOUT;
        goto error;
    }
    *rlen = *rlen+1;

error:
    i2c_stop(i2c);
    return status;
}

static status_e read(const struct heivs_bus_t *bus, uint32_t address, uint8_t *data, size_t len, size_t *rlen)
{
    status_e status;

    status = _read(bus, address, data, len, rlen);
    if (status != NO_ERROR)
    {
        init(bus);
    }

    return status;
}

static status_e write(const struct heivs_bus_t *bus, uint32_t address, const uint8_t *data, size_t len)
{
    status_e status;

    status = _write(bus, address, data, len);
    if (status != NO_ERROR)
    {
        init(bus);
    }

    return status;
}

static status_e writeread(const struct heivs_bus_t *bus, uint32_t address, const uint8_t *src, size_t src_len, uint8_t *dst, size_t dst_len, size_t *rlen)
{
    status_e status;

    status = _writeread(bus, address, src, src_len, dst, dst_len, rlen);
    if (status != NO_ERROR)
    {
        init(bus);
    }

    return status;
}

static const struct i2c_bus_private_t bus_priv[BSP_I2C_BUS_COUNT] =
{
#if BSP_I2C_BUS_COUNT > 0

    {
        .ctrl       = BSP_I2C_BUS0_CTRL,
        .gpios      =
        {
            BSP_I2C_BUS0_GPIO_SCL,
            BSP_I2C_BUS0_GPIO_SDA,
        },
    },
#endif
#if BSP_I2C_BUS_COUNT > 1
    {
        .ctrl       = BSP_I2C_BUS1_CTRL,
        .gpios      =
        {
            BSP_I2C_BUS1_GPIO_SCL,
            BSP_I2C_BUS1_GPIO_SDA,
        },
    },
#endif
#if BSP_I2C_BUS_COUNT > 2
    {
        .ctrl       = BSP_I2C_BUS2_CTRL,
        .gpios      =
        {
            BSP_I2C_BUS2_GPIO_SCL,
            BSP_I2C_BUS2_GPIO_SDA,
        },
    },
#endif
};

static struct heivs_bus_var_t bus_var[BSP_I2C_BUS_COUNT];

const struct heivs_bus_t bus_i2c[BSP_I2C_BUS_COUNT] =
{
#if BSP_I2C_BUS_COUNT > 0
    #ifndef BSP_I2C_BUS0_NAME
        #define BSP_I2C_BUS0_NAME "bus_i2c[0]"
    #endif
        {
                .name = BSP_I2C_BUS0_NAME,
                .priv = &bus_priv[0],
                .var = &bus_var[0],

                ._init = init,
                ._read = read,
                ._write = write,
                ._suspend = suspend,
                ._writeread = writeread,
        },
#endif
#if BSP_I2C_BUS_COUNT > 1
    #ifndef BSP_I2C_BUS1_NAME
        #define BSP_I2C_BUS1_NAME "bus_i2c[1]"
    #endif
        {
                .name = BSP_I2C_BUS1_NAME,
                .priv = &bus_priv[1],
                .var = &bus_var[1],

                ._init = init,
                ._read = read,
                ._write = write,
                ._suspend = suspend,
                ._writeread = writeread,
        },
#endif
#if BSP_I2C_BUS_COUNT > 2
    #ifndef BSP_I2C_BUS2_NAME
        #define BSP_I2C_BUS2_NAME "bus_i2c[2]"
    #endif
        {
                .name = BSP_I2C_BUS2_NAME,
                .priv = &bus_priv[2],
                .var = &bus_var[2],

                ._init = init,
                ._read = read,
                ._write = write,
                ._suspend = suspend,
                ._writeread = writeread,
        },
#endif
#if BSP_I2C_BUS_COUNT > 3
    #error this CPU has no 4 I2c buses
#endif
};