File content as of revision 1:914409dc83b1:

#include "smbus.h"
#include "device.h"
#include "smbus_defs.h"
#include "cmds.h"


SMBUS_HandleTypeDef SmbusHandle;

static volatile state_e state;

i2c_slave_t i2c;

static inline void put_cbuf(uint8_t o)
{
    i2c.cbuf[i2c.cbuf_in] = o;
    if (++i2c.cbuf_in == _RX_BUF_SIZE)
        i2c.cbuf_in = 0;
}

static volatile uint8_t i2c_buf_idx;

#ifdef TARGET_STM32L4
void SMBUSx_ER_IRQHandler()
{
    asm("nop"); // TODO
}
#endif /* TARGET_STM32L4 */

#ifdef TARGET_STM32L4
void SMBUSx_EV_IRQHandler(void)
#else
void SMBUSx_IRQHandler(void)
#endif
{
    uint32_t tmpisrvalue = SMBUS_GET_ISR_REG(&SmbusHandle);
    uint32_t icr = 0;
    static uint8_t xfer_length;
    static bool i2cTransferDirection; // true = read
    static uint8_t cmd;
    static uint8_t rx_buf_[32];

    if (tmpisrvalue & SMBUS_FLAG_RXNE) {
        uint8_t rxdr = SmbusHandle.Instance->RXDR;
        if (state == STATE_CMD) {
            cmd = rxdr;
            if (cmd_allowed(cmd)) {
                xfer_length = cmd_to_length[cmd];
                i2c_buf_idx = 0;
                state = STATE_XFERING;
            } else {
                state = STATE_NONE;
                __HAL_SMBUS_GENERATE_NACK(&SmbusHandle);
            }
        } else if (state == STATE_XFERING && i2cTransferDirection == 0) { // if xfering host write
            if (i2c_buf_idx < sizeof(rx_buf_))
                rx_buf_[i2c_buf_idx++] = rxdr;
        }

        icr |= SMBUS_FLAG_RXNE;
    }


    if (tmpisrvalue & SMBUS_FLAG_ADDR) {
        i2cTransferDirection = SMBUS_GET_DIR(&SmbusHandle);
        if (i2cTransferDirection) {
            // 1: Read transfer, slave enters transmitter mode..  cmd has already been provided
            fill_tx_buf(cmd);

            __HAL_SMBUS_ENABLE_IT(&SmbusHandle, SMBUS_IT_ERRI | SMBUS_IT_TCI | SMBUS_IT_STOPI | SMBUS_IT_NACKI | SMBUS_IT_TXI);
        } else {
            // 0: Write transfer, slave enters receiver mode.
            __HAL_SMBUS_ENABLE_IT(&SmbusHandle, SMBUS_IT_ERRI | SMBUS_IT_TCI | SMBUS_IT_STOPI | SMBUS_IT_NACKI | SMBUS_IT_RXI);
            if (state == STATE_NONE) {
                state = STATE_CMD;
            }
        }

        icr |= SMBUS_FLAG_ADDR;
    }

    if (tmpisrvalue & SMBUS_FLAG_AF) {
        /* last byte the host wants was sent */
        icr |= SMBUS_FLAG_AF;
    }

    if (tmpisrvalue & SMBUS_FLAG_STOPF) {
        icr |= SMBUS_FLAG_STOPF;
        if (i2cTransferDirection == 0) {   // host done writing to buf
            unsigned i;
            /* send to mainloop */
            put_cbuf(cmd);
            put_cbuf(i2c_buf_idx);
            for (i = 0; i < i2c_buf_idx; i++)
                put_cbuf(rx_buf_[i]);
        }

        if (!(tmpisrvalue & SMBUS_FLAG_TXE)) {
            /* slave wanted to send more than host wanted to receive */
            SmbusHandle.Instance->ISR = SMBUS_FLAG_TXE;
        }

        state = STATE_NONE;
    }

    if (tmpisrvalue & SMBUS_FLAG_TXIS ) {
        if (state == STATE_XFERING && i2cTransferDirection) {  // xfering in host-read direction
            SmbusHandle.Instance->TXDR = i2c.tx_buf[i2c_buf_idx++];
            if (i2c_buf_idx == xfer_length) {
                state = STATE_SEND_DONE;
                __HAL_SMBUS_DISABLE_IT(&SmbusHandle, SMBUS_IT_TXI);
            }
        }
    } else if (icr == 0) {
        /* unhandled interrupt flag: halt this irq */
#ifdef TARGET_STM32L4
        HAL_NVIC_DisableIRQ(SMBUSx_EV_IRQn);
#else
        HAL_NVIC_DisableIRQ(SMBUSx_IRQn);
#endif
    }

    __HAL_SMBUS_CLEAR_FLAG(&SmbusHandle, icr);
}

int smbus_init(uint8_t slaveAddress)
{
    uint32_t tmpisr;
    //HAL_StatusTypeDef status;

    SmbusHandle.Instance                  = I2Cx;

    SmbusHandle.Init.Timing               = I2C_TIMING;
    SmbusHandle.Init.AnalogFilter         = SMBUS_ANALOGFILTER_ENABLE;
    SmbusHandle.Init.OwnAddress1          = slaveAddress;
    SmbusHandle.Init.AddressingMode       = SMBUS_ADDRESSINGMODE_7BIT;
    SmbusHandle.Init.DualAddressMode      = SMBUS_DUALADDRESS_DISABLE;
    SmbusHandle.Init.OwnAddress2          = 0x00;
    SmbusHandle.Init.GeneralCallMode      = SMBUS_GENERALCALL_DISABLE;
    SmbusHandle.Init.NoStretchMode        = SMBUS_NOSTRETCH_DISABLE;
    SmbusHandle.Init.PacketErrorCheckMode = SMBUS_PEC_DISABLE;
    SmbusHandle.Init.PeripheralMode       = SMBUS_PERIPHERAL_MODE_SMBUS_SLAVE;
    SmbusHandle.Init.SMBusTimeout         = 0;

    if(HAL_SMBUS_Init(&SmbusHandle) != HAL_OK)
    { 
        return -1;
    }

    state = STATE_NONE;

    tmpisr = SMBUS_IT_ADDRI | SMBUS_IT_STOPI | SMBUS_IT_NACKI | SMBUS_IT_ERRI;
    __HAL_SMBUS_ENABLE_IT(&SmbusHandle, tmpisr);

    return 0;
}

static inline uint8_t get_cbuf()
{
    uint8_t ret = i2c.cbuf[i2c.cbuf_out];
    if (++i2c.cbuf_out == _RX_BUF_SIZE)
        i2c.cbuf_out = 0;

    return ret;
}

/* service_i2c(): call from main loop */
void service_i2c()
{
    if (i2c.cbuf_in != i2c.cbuf_out) {
        uint8_t n, cmd, len;
        cmd = get_cbuf();
        len = get_cbuf();
        uint8_t buf[32];
        /* host is writing: parse here */
        for (n = 0; n < len; n++)
            buf[n] = get_cbuf();

        /*if (len != cmd_to_length[cmd])
            pc.printf("[%02x != %02x] ", len, cmd_to_length[cmd]);*/

        service_i2c_write(cmd, len, buf);
    }
}