qemu/hw/ppc/pnv_i2c.c

/*
 * QEMU PowerPC PowerNV Processor I2C model
 *
 * Copyright (c) 2019-2023, IBM Corporation.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "qemu/osdep.h"
#include "qemu/module.h"
#include "qemu/log.h"
#include "sysemu/reset.h"

#include "hw/irq.h"
#include "hw/qdev-properties.h"

#include "hw/ppc/pnv.h"
#include "hw/ppc/pnv_chip.h"
#include "hw/ppc/pnv_i2c.h"
#include "hw/ppc/pnv_xscom.h"
#include "hw/ppc/fdt.h"

#include <libfdt.h>

#include "hw/i2c/pnv_i2c_regs.h"

static I2CBus *pnv_i2c_get_bus(PnvI2C *i2c)
{
    uint8_t port = GETFIELD(I2C_MODE_PORT_NUM, i2c->regs[I2C_MODE_REG]);

    if (port >= i2c->num_busses) {
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: invalid bus number %d/%d\n", port,
                      i2c->num_busses);
        return NULL;
    }
    return i2c->busses[port];
}

static void pnv_i2c_update_irq(PnvI2C *i2c)
{
    I2CBus *bus = pnv_i2c_get_bus(i2c);
    bool recv = !!(i2c->regs[I2C_CMD_REG] & I2C_CMD_READ_NOT_WRITE);
    uint16_t front_end = GETFIELD(I2C_RESIDUAL_FRONT_END,
                                  i2c->regs[I2C_RESIDUAL_LEN_REG]);
    uint16_t back_end = GETFIELD(I2C_RESIDUAL_BACK_END,
                                 i2c->regs[I2C_RESIDUAL_LEN_REG]);
    uint8_t fifo_count = GETFIELD(I2C_STAT_FIFO_ENTRY_COUNT,
                                   i2c->regs[I2C_STAT_REG]);
    uint8_t fifo_free = PNV_I2C_FIFO_SIZE - fifo_count;

    if (!bus) {
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: invalid port\n");
        return;
    }

    if (i2c_bus_busy(bus)) {
        i2c->regs[I2C_STAT_REG] &= ~I2C_STAT_DATA_REQ;

        if (recv) {
            if (fifo_count >=
                GETFIELD(I2C_WATERMARK_HIGH, i2c->regs[I2C_WATERMARK_REG])) {
                i2c->regs[I2C_EXTD_STAT_REG] |= I2C_EXTD_STAT_HIGH_WATER;
            } else {
                i2c->regs[I2C_EXTD_STAT_REG] &= ~I2C_EXTD_STAT_HIGH_WATER;
            }

            if (((i2c->regs[I2C_EXTD_STAT_REG] & I2C_EXTD_STAT_HIGH_WATER) &&
                 fifo_count != 0) || front_end == 0) {
                i2c->regs[I2C_STAT_REG] |= I2C_STAT_DATA_REQ;
            }
        } else {
            if (fifo_count <=
                GETFIELD(I2C_WATERMARK_LOW, i2c->regs[I2C_WATERMARK_REG])) {
                i2c->regs[I2C_EXTD_STAT_REG] |= I2C_EXTD_STAT_LOW_WATER;
            } else {
                i2c->regs[I2C_EXTD_STAT_REG] &= ~I2C_EXTD_STAT_LOW_WATER;
            }

            if (back_end > 0 &&
                (fifo_free >= back_end ||
                 (i2c->regs[I2C_EXTD_STAT_REG] & I2C_EXTD_STAT_LOW_WATER))) {
                i2c->regs[I2C_STAT_REG] |= I2C_STAT_DATA_REQ;
            }
        }

        if (back_end == 0 && front_end == 0) {
            i2c->regs[I2C_STAT_REG] &= ~I2C_STAT_DATA_REQ;
            i2c->regs[I2C_STAT_REG] |= I2C_STAT_CMD_COMP;

            if (i2c->regs[I2C_CMD_REG] & I2C_CMD_WITH_STOP) {
                i2c_end_transfer(bus);
                i2c->regs[I2C_EXTD_STAT_REG] &=
                    ~(I2C_EXTD_STAT_I2C_BUSY | I2C_EXTD_STAT_SELF_BUSY);
            }
        } else {
            i2c->regs[I2C_STAT_REG] &= ~I2C_STAT_CMD_COMP;
        }
    }

    /*
     * Status and interrupt registers have nearly the same layout.
     */
    i2c->regs[I2C_INTR_RAW_COND_REG] = i2c->regs[I2C_STAT_REG] >> 16;
    i2c->regs[I2C_INTR_COND_REG] =
        i2c->regs[I2C_INTR_RAW_COND_REG] & i2c->regs[I2C_INTR_MASK_REG];

    qemu_set_irq(i2c->psi_irq, i2c->regs[I2C_INTR_COND_REG] != 0);
}

static void pnv_i2c_fifo_update_count(PnvI2C *i2c)
{
    uint64_t stat = i2c->regs[I2C_STAT_REG];

    i2c->regs[I2C_STAT_REG] = SETFIELD(I2C_STAT_FIFO_ENTRY_COUNT, stat,
                                       fifo8_num_used(&i2c->fifo));
}

static void pnv_i2c_frontend_update(PnvI2C *i2c)
{
    uint64_t residual_end = i2c->regs[I2C_RESIDUAL_LEN_REG];
    uint16_t front_end = GETFIELD(I2C_RESIDUAL_FRONT_END, residual_end);

    i2c->regs[I2C_RESIDUAL_LEN_REG] =
        SETFIELD(I2C_RESIDUAL_FRONT_END, residual_end, front_end - 1);
}

static void pnv_i2c_fifo_flush(PnvI2C *i2c)
{
    I2CBus *bus = pnv_i2c_get_bus(i2c);
    uint8_t data;
    int ret;

    if (!bus) {
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: invalid port\n");
        return;
    }
    if (!i2c_bus_busy(bus)) {
        return;
    }

    if (i2c->regs[I2C_CMD_REG] & I2C_CMD_READ_NOT_WRITE) {
        if (fifo8_is_full(&i2c->fifo)) {
            return;
        }

        data = i2c_recv(bus);
        fifo8_push(&i2c->fifo, data);
    } else {
        if (fifo8_is_empty(&i2c->fifo)) {
            return;
        }

        data = fifo8_pop(&i2c->fifo);
        ret = i2c_send(bus, data);
        if (ret) {
            i2c->regs[I2C_STAT_REG] |= I2C_STAT_NACK_RCVD_ERR;
            i2c_end_transfer(bus);
        }
    }

    pnv_i2c_fifo_update_count(i2c);
    pnv_i2c_frontend_update(i2c);
}

static void pnv_i2c_handle_cmd(PnvI2C *i2c, uint64_t val)
{
    I2CBus *bus = pnv_i2c_get_bus(i2c);
    uint8_t addr = GETFIELD(I2C_CMD_DEV_ADDR, val);
    int recv = !!(val & I2C_CMD_READ_NOT_WRITE);
    uint32_t len_bytes = GETFIELD(I2C_CMD_LEN_BYTES, val);

    if (!(val & I2C_CMD_WITH_START) && !(val & I2C_CMD_WITH_ADDR) &&
        !(val & I2C_CMD_WITH_STOP) && !len_bytes) {
        i2c->regs[I2C_STAT_REG] |= I2C_STAT_INVALID_CMD;
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: invalid command 0x%"PRIx64"\n",
                      val);
        return;
    }

    if (!(i2c->regs[I2C_STAT_REG] & I2C_STAT_CMD_COMP)) {
        i2c->regs[I2C_STAT_REG] |= I2C_STAT_INVALID_CMD;
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: command in progress\n");
        return;
    }

    if (!bus) {
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: invalid port\n");
        return;
    }

    i2c->regs[I2C_RESIDUAL_LEN_REG] =
        SETFIELD(I2C_RESIDUAL_FRONT_END, 0ull, len_bytes) |
        SETFIELD(I2C_RESIDUAL_BACK_END, 0ull, len_bytes);

    if (val & I2C_CMD_WITH_START) {
        if (i2c_start_transfer(bus, addr, recv)) {
            i2c->regs[I2C_STAT_REG] |= I2C_STAT_NACK_RCVD_ERR;
        } else {
            i2c->regs[I2C_EXTD_STAT_REG] |=
                (I2C_EXTD_STAT_I2C_BUSY | I2C_EXTD_STAT_SELF_BUSY);
            pnv_i2c_fifo_flush(i2c);
        }
    }
}

static void pnv_i2c_backend_update(PnvI2C *i2c)
{
    uint64_t residual_end = i2c->regs[I2C_RESIDUAL_LEN_REG];
    uint16_t back_end = GETFIELD(I2C_RESIDUAL_BACK_END, residual_end);

    if (!back_end) {
        i2c->regs[I2C_STAT_REG] |= I2C_STAT_BKEND_ACCESS_ERR;
        return;
    }

    i2c->regs[I2C_RESIDUAL_LEN_REG] =
        SETFIELD(I2C_RESIDUAL_BACK_END, residual_end, back_end - 1);
}

static void pnv_i2c_fifo_in(PnvI2C *i2c)
{
    uint8_t data = GETFIELD(I2C_FIFO, i2c->regs[I2C_FIFO_REG]);
    I2CBus *bus = pnv_i2c_get_bus(i2c);

    if (!bus) {
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: invalid port\n");
        return;
    }

    if (!i2c_bus_busy(bus)) {
        i2c->regs[I2C_STAT_REG] |= I2C_STAT_INVALID_CMD;
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: no command in progress\n");
        return;
    }

    if (i2c->regs[I2C_CMD_REG] & I2C_CMD_READ_NOT_WRITE) {
        i2c->regs[I2C_STAT_REG] |= I2C_STAT_INVALID_CMD;
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: read command in progress\n");
        return;
    }

    if (fifo8_is_full(&i2c->fifo)) {
        if (!(i2c->regs[I2C_MODE_REG] & I2C_MODE_PACING_ALLOW)) {
            i2c->regs[I2C_STAT_REG] |= I2C_STAT_BKEND_OVERRUN_ERR;
        }
        return;
    }

    fifo8_push(&i2c->fifo, data);
    pnv_i2c_fifo_update_count(i2c);
    pnv_i2c_backend_update(i2c);
    pnv_i2c_fifo_flush(i2c);
}

static void pnv_i2c_fifo_out(PnvI2C *i2c)
{
    uint8_t data;
    I2CBus *bus = pnv_i2c_get_bus(i2c);

    if (!bus) {
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: invalid port\n");
        return;
    }

    if (!i2c_bus_busy(bus)) {
        i2c->regs[I2C_STAT_REG] |= I2C_STAT_INVALID_CMD;
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: no command in progress\n");
        return;
    }

    if (!(i2c->regs[I2C_CMD_REG] & I2C_CMD_READ_NOT_WRITE)) {
        i2c->regs[I2C_STAT_REG] |= I2C_STAT_INVALID_CMD;
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: write command in progress\n");
        return;
    }

    if (fifo8_is_empty(&i2c->fifo)) {
        if (!(i2c->regs[I2C_MODE_REG] & I2C_MODE_PACING_ALLOW)) {
            i2c->regs[I2C_STAT_REG] |= I2C_STAT_BKEND_OVERRUN_ERR;
        }
        return;
    }

    data = fifo8_pop(&i2c->fifo);

    i2c->regs[I2C_FIFO_REG] = SETFIELD(I2C_FIFO, 0ull, data);
    pnv_i2c_fifo_update_count(i2c);
    pnv_i2c_backend_update(i2c);
}

static uint64_t pnv_i2c_xscom_read(void *opaque, hwaddr addr,
                                   unsigned size)
{
    PnvI2C *i2c = PNV_I2C(opaque);
    uint32_t offset = addr >> 3;
    uint64_t val = -1;
    int i;

    switch (offset) {
    case I2C_STAT_REG:
        val = i2c->regs[offset];
        break;

    case I2C_FIFO_REG:
        pnv_i2c_fifo_out(i2c);
        val = i2c->regs[offset];
        break;

    case I2C_PORT_BUSY_REG: /* compute busy bit for each port  */
        val = 0;
        for (i = 0; i < i2c->num_busses; i++) {
            val |= (uint64_t)i2c_bus_busy(i2c->busses[i]) << i;
        }
        break;

    case I2C_CMD_REG:
    case I2C_MODE_REG:
    case I2C_WATERMARK_REG:
    case I2C_INTR_MASK_REG:
    case I2C_INTR_RAW_COND_REG:
    case I2C_INTR_COND_REG:
    case I2C_EXTD_STAT_REG:
    case I2C_RESIDUAL_LEN_REG:
        val = i2c->regs[offset];
        break;
    default:
        i2c->regs[I2C_STAT_REG] |= I2C_STAT_INVALID_CMD;
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: read at register: 0x%"
                      HWADDR_PRIx "\n", addr >> 3);
    }

    pnv_i2c_update_irq(i2c);

    return val;
}

static void pnv_i2c_reset(void *dev)
{
    PnvI2C *i2c = PNV_I2C(dev);

    memset(i2c->regs, 0, sizeof(i2c->regs));

    i2c->regs[I2C_STAT_REG] =
        SETFIELD(I2C_STAT_UPPER_THRS, 0ull, i2c->num_busses - 1) |
        I2C_STAT_CMD_COMP | I2C_STAT_SCL_INPUT_LEVEL |
        I2C_STAT_SDA_INPUT_LEVEL;
    i2c->regs[I2C_EXTD_STAT_REG] =
        SETFIELD(I2C_EXTD_STAT_FIFO_SIZE, 0ull, PNV_I2C_FIFO_SIZE) |
        SETFIELD(I2C_EXTD_STAT_I2C_VERSION, 0ull, 23); /* last version */

    fifo8_reset(&i2c->fifo);
}

static void pnv_i2c_xscom_write(void *opaque, hwaddr addr,
                                uint64_t val, unsigned size)
{
    PnvI2C *i2c = PNV_I2C(opaque);
    uint32_t offset = addr >> 3;

    switch (offset) {
    case I2C_MODE_REG:
        {
            i2c->regs[offset] = val;
            I2CBus *bus = pnv_i2c_get_bus(i2c);
            if (!bus) {
                qemu_log_mask(LOG_GUEST_ERROR, "I2C: invalid port\n");
                return;
            }
            if (i2c_bus_busy(bus)) {
                i2c->regs[I2C_STAT_REG] |= I2C_STAT_INVALID_CMD;
                qemu_log_mask(LOG_GUEST_ERROR, "I2C: command in progress\n");
            }
        }
        break;

    case I2C_CMD_REG:
        i2c->regs[offset] = val;
        pnv_i2c_handle_cmd(i2c, val);
        break;

    case I2C_FIFO_REG:
        i2c->regs[offset] = val;
        pnv_i2c_fifo_in(i2c);
        break;

    case I2C_WATERMARK_REG:
        i2c->regs[offset] = val;
        break;

    case I2C_RESET_I2C_REG:
        pnv_i2c_reset(i2c);
        break;

    case I2C_RESET_ERRORS:
        i2c->regs[I2C_STAT_REG] &= ~I2C_STAT_ANY_ERR;
        i2c->regs[I2C_RESIDUAL_LEN_REG] = 0;
        i2c->regs[I2C_EXTD_STAT_REG] &=
            (I2C_EXTD_STAT_FIFO_SIZE | I2C_EXTD_STAT_I2C_VERSION);
        fifo8_reset(&i2c->fifo);
        break;

    case I2C_INTR_MASK_REG:
        i2c->regs[offset] = val;
        break;

    case I2C_INTR_MASK_OR_REG:
        i2c->regs[I2C_INTR_MASK_REG] |= val;
        break;

    case I2C_INTR_MASK_AND_REG:
        i2c->regs[I2C_INTR_MASK_REG] &= val;
        break;

    case I2C_PORT_BUSY_REG:
    case I2C_SET_S_SCL_REG:
    case I2C_RESET_S_SCL_REG:
    case I2C_SET_S_SDA_REG:
    case I2C_RESET_S_SDA_REG:
        i2c->regs[offset] = val;
        break;
    default:
        i2c->regs[I2C_STAT_REG] |= I2C_STAT_INVALID_CMD;
        qemu_log_mask(LOG_GUEST_ERROR, "I2C: write at register: 0x%"
                      HWADDR_PRIx " val=0x%"PRIx64"\n", addr >> 3, val);
    }

    pnv_i2c_update_irq(i2c);
}

static const MemoryRegionOps pnv_i2c_xscom_ops = {
    .read = pnv_i2c_xscom_read,
    .write = pnv_i2c_xscom_write,
    .valid.min_access_size = 8,
    .valid.max_access_size = 8,
    .impl.min_access_size = 8,
    .impl.max_access_size = 8,
    .endianness = DEVICE_BIG_ENDIAN,
};

static int pnv_i2c_bus_dt_xscom(PnvI2C *i2c, void *fdt,
                                int offset, int index)
{
    int i2c_bus_offset;
    const char i2c_compat[] =
        "ibm,opal-i2c\0ibm,power8-i2c-port\0ibm,power9-i2c-port";
    g_autofree char *i2c_port_name = NULL;
    g_autofree char *name = g_strdup_printf("i2c-bus@%x", index);

    i2c_bus_offset = fdt_add_subnode(fdt, offset, name);
    _FDT(i2c_bus_offset);

    _FDT((fdt_setprop_cell(fdt, i2c_bus_offset, "reg", index)));
    _FDT((fdt_setprop_cell(fdt, i2c_bus_offset, "#address-cells", 1)));
    _FDT((fdt_setprop_cell(fdt, i2c_bus_offset, "#size-cells", 0)));
    _FDT(fdt_setprop(fdt, i2c_bus_offset, "compatible", i2c_compat,
                     sizeof(i2c_compat)));
    _FDT((fdt_setprop_cell(fdt, i2c_bus_offset, "bus-frequency", 400000)));

    i2c_port_name = g_strdup_printf("p8_%08x_e%dp%d", i2c->chip->chip_id,
                                    i2c->engine, index);
    _FDT(fdt_setprop_string(fdt, i2c_bus_offset, "ibm,port-name",
                            i2c_port_name));
    return 0;
}

#define XSCOM_BUS_FREQUENCY 466500000
#define I2C_CLOCK_FREQUENCY (XSCOM_BUS_FREQUENCY / 4)

static int pnv_i2c_dt_xscom(PnvXScomInterface *dev, void *fdt,
                            int offset)
{
    PnvI2C *i2c = PNV_I2C(dev);
    int i2c_offset;
    const char i2c_compat[] = "ibm,power8-i2cm\0ibm,power9-i2cm";
    uint32_t i2c_pcba = PNV9_XSCOM_I2CM_BASE +
        (i2c->engine - 1) * PNV9_XSCOM_I2CM_SIZE;
    uint32_t reg[2] = {
        cpu_to_be32(i2c_pcba),
        cpu_to_be32(PNV9_XSCOM_I2CM_SIZE)
    };
    int i;
    g_autofree char *name = g_strdup_printf("i2cm@%x", i2c_pcba);

    i2c_offset = fdt_add_subnode(fdt, offset, name);
    _FDT(i2c_offset);

    _FDT(fdt_setprop(fdt, i2c_offset, "reg", reg, sizeof(reg)));

    _FDT((fdt_setprop_cell(fdt, i2c_offset, "#address-cells", 1)));
    _FDT((fdt_setprop_cell(fdt, i2c_offset, "#size-cells", 0)));
    _FDT(fdt_setprop(fdt, i2c_offset, "compatible", i2c_compat,
                     sizeof(i2c_compat)));
    _FDT((fdt_setprop_cell(fdt, i2c_offset, "chip-engine#", i2c->engine)));
    _FDT((fdt_setprop_cell(fdt, i2c_offset, "clock-frequency",
                           I2C_CLOCK_FREQUENCY)));

    for (i = 0; i < i2c->num_busses; i++) {
        pnv_i2c_bus_dt_xscom(i2c, fdt, i2c_offset, i);
    }
    return 0;
}

static void pnv_i2c_sys_reset(void *dev)
{
    int port;
    PnvI2C *i2c = PNV_I2C(dev);

    pnv_i2c_reset(dev);

    /* reset all buses connected to this i2c controller */
    for (port = 0; port < i2c->num_busses; port++) {
        bus_cold_reset(BUS(i2c->busses[port]));
    }
}

static void pnv_i2c_realize(DeviceState *dev, Error **errp)
{
    PnvI2C *i2c = PNV_I2C(dev);
    int i;

    assert(i2c->chip);

    if (i2c->num_busses > PNV_I2C_MAX_BUSSES) {
        error_setg(errp, "Invalid number of busses: %u", i2c->num_busses);
        return;
    }

    pnv_xscom_region_init(&i2c->xscom_regs, OBJECT(i2c), &pnv_i2c_xscom_ops,
                          i2c, "xscom-i2c", PNV9_XSCOM_I2CM_SIZE);

    i2c->busses = g_new(I2CBus *, i2c->num_busses);
    for (i = 0; i < i2c->num_busses; i++) {
        char name[32];

        snprintf(name, sizeof(name), TYPE_PNV_I2C ".%d", i);
        i2c->busses[i] = i2c_init_bus(dev, name);
    }

    fifo8_create(&i2c->fifo, PNV_I2C_FIFO_SIZE);

    qemu_register_reset(pnv_i2c_sys_reset, dev);

    qdev_init_gpio_out(DEVICE(dev), &i2c->psi_irq, 1);
}

static Property pnv_i2c_properties[] = {
    DEFINE_PROP_LINK("chip", PnvI2C, chip, TYPE_PNV_CHIP, PnvChip *),
    DEFINE_PROP_UINT32("engine", PnvI2C, engine, 1),
    DEFINE_PROP_UINT32("num-busses", PnvI2C, num_busses, 1),
    DEFINE_PROP_END_OF_LIST(),
};

static void pnv_i2c_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);
    PnvXScomInterfaceClass *xscomc = PNV_XSCOM_INTERFACE_CLASS(klass);

    xscomc->dt_xscom = pnv_i2c_dt_xscom;

    /* Reason: This device is part of the CPU and cannot be used separately */
    dc->user_creatable = false;

    dc->desc = "PowerNV I2C";
    dc->realize = pnv_i2c_realize;
    device_class_set_props(dc, pnv_i2c_properties);
}

static const TypeInfo pnv_i2c_info = {
    .name          = TYPE_PNV_I2C,
    .parent        = TYPE_DEVICE,
    .instance_size = sizeof(PnvI2C),
    .class_init    = pnv_i2c_class_init,
    .interfaces    = (InterfaceInfo[]) {
        { TYPE_PNV_XSCOM_INTERFACE },
        { }
    }
};

static void pnv_i2c_register_types(void)
{
    type_register_static(&pnv_i2c_info);
}

type_init(pnv_i2c_register_types);