/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2019 Joyent, Inc.
 * Copyright 2022 OmniOS Community Edition (OmniOSce) Association.
 * Copyright 2025 Oxide Computer Company
 */

/*
 * VIRTIO FRAMEWORK: Operations via the modern interface.
 *
 * For design and usage documentation, see the comments in "virtio.h".
 */

#include <sys/conf.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/types.h>
#include <sys/inttypes.h>
#include <sys/ddi_impldefs.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sysmacros.h>

#include "virtio.h"
#include "virtio_impl.h"
#include "virtio_endian.h"

static void virtio_modern_set_status_locked(virtio_t *, uint8_t);
static uint8_t virtio_modern_get_status(virtio_t *);

/*
 * Reads and writes to the modern common configuration area.
 */

static inline uint8_t
virtio_get_cmn8(virtio_t *vio, uintptr_t offset)
{
        return (ddi_get8(vio->vio_cap_common.vpc_barh,
            (uint8_t *)(vio->vio_cap_common.vpc_bar + offset)));
}

static inline uint16_t
virtio_get_cmn16(virtio_t *vio, uintptr_t offset)
{
        return virtio_le16toh((ddi_get16(vio->vio_cap_common.vpc_barh,
            (uint16_t *)(vio->vio_cap_common.vpc_bar + offset))));
}

static inline uint32_t
virtio_get_cmn32(virtio_t *vio, uintptr_t offset)
{
        return virtio_le32toh((ddi_get32(vio->vio_cap_common.vpc_barh,
            (uint32_t *)(vio->vio_cap_common.vpc_bar + offset))));
}

static inline void
virtio_put_cmn8(virtio_t *vio, uintptr_t offset, uint8_t value)
{
        ddi_put8(vio->vio_cap_common.vpc_barh,
            (uint8_t *)(vio->vio_cap_common.vpc_bar + offset), value);
}

static inline void
virtio_put_cmn16(virtio_t *vio, uintptr_t offset, uint16_t value)
{
        ddi_put16(vio->vio_cap_common.vpc_barh,
            (uint16_t *)(vio->vio_cap_common.vpc_bar + offset),
            virtio_htole16(value));
}

static inline void
virtio_put_cmn32(virtio_t *vio, uintptr_t offset, uint32_t value)
{
        ddi_put32(vio->vio_cap_common.vpc_barh,
            (uint32_t *)(vio->vio_cap_common.vpc_bar + offset),
            virtio_htole32(value));
}

/*
 * Reads and writes to the modern device configuration area.
 */

static uint8_t
virtio_modern_devcfg_getgen(virtio_t *vio)
{
        return (virtio_get_cmn8(vio, VIRTIO_MODERN_COMMON_CFGGENERATION));
}

static uint8_t
virtio_modern_devcfg_get8(virtio_t *vio, uintptr_t offset)
{
        return (ddi_get8(vio->vio_cap_device.vpc_barh,
            (uint8_t *)(vio->vio_cap_device.vpc_bar + offset)));
}

static uint16_t
virtio_modern_devcfg_get16(virtio_t *vio, uintptr_t offset)
{
        return (virtio_le16toh(ddi_get16(vio->vio_cap_device.vpc_barh,
            (uint16_t *)(vio->vio_cap_device.vpc_bar + offset))));
}

static uint32_t
virtio_modern_devcfg_get32(virtio_t *vio, uintptr_t offset)
{
        return (virtio_le32toh(ddi_get32(vio->vio_cap_device.vpc_barh,
            (uint32_t *)(vio->vio_cap_device.vpc_bar + offset))));
}

static uint64_t
virtio_modern_devcfg_get64(virtio_t *vio, uintptr_t offset)
{
        uint64_t val;
        uint8_t gen;

        /*
         * On at least some systems, a 64-bit read or write to this BAR is not
         * possible. Modern devices have a generation number that can be
         * inspected to determine if configuration may have changed half-way
         * through a read. We need to continue to read both halves of the
         * value until we read the same generation value either side.
         */
        do {
                gen = virtio_modern_devcfg_getgen(vio);
                val = (uint64_t)virtio_le32toh(virtio_modern_devcfg_get32(vio,
                    offset + sizeof (uint32_t))) << 32;
                val |= virtio_le32toh(virtio_modern_devcfg_get32(vio, offset));
        } while (virtio_modern_devcfg_getgen(vio) != gen);

        return (val);
}

static void
virtio_modern_devcfg_put8(virtio_t *vio, uintptr_t offset, uint8_t value)
{
        ddi_put8(vio->vio_cap_device.vpc_barh,
            (uint8_t *)(vio->vio_cap_device.vpc_bar + offset), value);
}

static void
virtio_modern_devcfg_put16(virtio_t *vio, uintptr_t offset, uint16_t value)
{
        ddi_put16(vio->vio_cap_device.vpc_barh,
            (uint16_t *)(vio->vio_cap_device.vpc_bar + offset),
            virtio_htole16(value));
}

static void
virtio_modern_devcfg_put32(virtio_t *vio, uintptr_t offset, uint32_t value)
{
        ddi_put32(vio->vio_cap_device.vpc_barh,
            (uint32_t *)(vio->vio_cap_device.vpc_bar + offset),
            virtio_htole32(value));
}

/*
 * Reads and writes to the modern notification area.
 */

static inline void
virtio_put_nfy16(virtio_t *vio, uintptr_t offset, uint16_t value)
{
        ddi_put16(vio->vio_cap_notify.vpc_barh,
            (uint16_t *)(vio->vio_cap_notify.vpc_bar + offset),
            virtio_htole16(value));
}

/*
 * Reads from the modern ISR area.
 */

static inline uint8_t
virtio_get_isr8(virtio_t *vio, uintptr_t offset)
{
        return (ddi_get8(vio->vio_cap_isr.vpc_barh,
            (uint8_t *)(vio->vio_cap_isr.vpc_bar + offset)));
}

static uint64_t
virtio_modern_device_get_features(virtio_t *vio)
{
        uint64_t features = 0;

        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_DFSELECT, 1);
        features = virtio_get_cmn32(vio, VIRTIO_MODERN_COMMON_DF);
        features <<= 32;
        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_DFSELECT, 0);
        features |= virtio_get_cmn32(vio, VIRTIO_MODERN_COMMON_DF);

        return (features);
}

static bool
virtio_modern_device_set_features(virtio_t *vio, uint64_t features)
{
        uint8_t status;

        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_GFSELECT, 1);
        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_GF, features >> 32);
        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_GFSELECT, 0);
        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_GF, features & 0xffffffff);
        /* Signal that we are finished setting guest features */
        mutex_enter(&vio->vio_mutex);
        virtio_modern_set_status_locked(vio, VIRTIO_STATUS_FEAT_OK);
        /*
         * We now need to check that this bit is still set in the status. If
         * it is not, then feature negotiation has failed and the device is
         * unusable.
         */
        status = virtio_modern_get_status(vio);
        mutex_exit(&vio->vio_mutex);
        return ((status & VIRTIO_STATUS_FEAT_OK) != 0);
}

static void
virtio_modern_set_status_locked(virtio_t *vio, uint8_t status)
{
        VERIFY3U(status, !=, 0);
        VERIFY(MUTEX_HELD(&vio->vio_mutex));

        uint8_t old = virtio_get_cmn8(vio, VIRTIO_MODERN_COMMON_STATUS);
        virtio_put_cmn8(vio, VIRTIO_MODERN_COMMON_STATUS, status | old);
}

static uint8_t
virtio_modern_get_status(virtio_t *vio)
{
        return (virtio_get_cmn8(vio, VIRTIO_MODERN_COMMON_STATUS));
}

static void
virtio_modern_device_reset_locked(virtio_t *vio)
{
        VERIFY(MUTEX_HELD(&vio->vio_mutex));
        virtio_put_cmn8(vio, VIRTIO_MODERN_COMMON_STATUS, VIRTIO_STATUS_RESET);
}

static uint8_t
virtio_modern_isr_status(virtio_t *vio)
{
        return (virtio_get_isr8(vio, 0));
}

static uint16_t
virtio_modern_msix_config_get(virtio_t *vio)
{
        return (virtio_get_cmn16(vio, VIRTIO_MODERN_COMMON_MSIX));
}

static void
virtio_modern_msix_config_set(virtio_t *vio, uint16_t msi)
{
        virtio_put_cmn16(vio, VIRTIO_MODERN_COMMON_MSIX, msi);
}

static void
virtio_modern_queue_notify(virtio_queue_t *viq)
{
        virtio_put_nfy16(viq->viq_virtio, viq->viq_noff, viq->viq_index);
}

static void
virtio_modern_queue_select(virtio_t *vio, uint16_t qidx)
{
        virtio_put_cmn16(vio, VIRTIO_MODERN_COMMON_Q_SELECT, qidx);
}

static uint16_t
virtio_modern_queue_size_get(virtio_t *vio, uint16_t qidx)
{
        uint16_t val;

        virtio_acquireq(vio, qidx);
        val = virtio_get_cmn16(vio, VIRTIO_MODERN_COMMON_Q_SIZE);
        virtio_releaseq(vio);

        return (val);
}

static void
virtio_modern_queue_size_set(virtio_t *vio, uint16_t qidx, uint16_t qsz)
{
        virtio_acquireq(vio, qidx);
        virtio_put_cmn16(vio, VIRTIO_MODERN_COMMON_Q_SIZE, qsz);
        virtio_releaseq(vio);
}

static uint64_t
virtio_modern_queue_noff_get(virtio_t *vio, uint16_t qidx)
{
        uint64_t noff;

        virtio_acquireq(vio, qidx);
        noff = (uint64_t)virtio_get_cmn16(vio, VIRTIO_MODERN_COMMON_Q_NOFF);
        virtio_releaseq(vio);

        noff *= vio->vio_multiplier;

        return (noff);
}

static bool
virtio_modern_queue_enable_get(virtio_t *vio, uint16_t qidx)
{
        bool val;

        virtio_acquireq(vio, qidx);
        val = (virtio_get_cmn16(vio, VIRTIO_MODERN_COMMON_Q_ENABLE) != 0);
        virtio_releaseq(vio);

        return (val);
}

static void
virtio_modern_queue_enable_set(virtio_t *vio, uint16_t qidx, bool enable)
{
        virtio_acquireq(vio, qidx);
        virtio_put_cmn16(vio, VIRTIO_MODERN_COMMON_Q_ENABLE, enable);
        virtio_releaseq(vio);
}

static void
virtio_modern_queue_addr_set(virtio_t *vio, uint16_t qidx, uint64_t descaddr,
    uint64_t availaddr, uint64_t usedaddr)
{
        virtio_acquireq(vio, qidx);
        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_Q_DESCLO,
            descaddr & 0xffffffff);
        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_Q_DESCHI,
            descaddr >> 32);
        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_Q_AVAILLO,
            availaddr & 0xffffffff);
        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_Q_AVAILHI,
            availaddr >> 32);
        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_Q_USEDLO,
            usedaddr & 0xffffffff);
        virtio_put_cmn32(vio, VIRTIO_MODERN_COMMON_Q_USEDHI,
            usedaddr >> 32);
        virtio_releaseq(vio);
}

static uint16_t
virtio_modern_msix_queue_get(virtio_t *vio, uint16_t qidx)
{
        uint16_t val;

        virtio_acquireq(vio, qidx);
        val = virtio_get_cmn16(vio, VIRTIO_MODERN_COMMON_Q_MSIX);
        virtio_releaseq(vio);

        return (val);
}

static void
virtio_modern_msix_queue_set(virtio_t *vio, uint16_t qidx, uint16_t msi)
{
        virtio_acquireq(vio, qidx);
        virtio_put_cmn16(vio, VIRTIO_MODERN_COMMON_Q_MSIX, msi);
        virtio_releaseq(vio);
}

virtio_ops_t virtio_modern_ops = {
        .vop_device_get_features = virtio_modern_device_get_features,
        .vop_device_set_features = virtio_modern_device_set_features,
        .vop_set_status_locked = virtio_modern_set_status_locked,
        .vop_get_status = virtio_modern_get_status,
        .vop_device_reset_locked = virtio_modern_device_reset_locked,
        .vop_isr_status = virtio_modern_isr_status,
        .vop_msix_config_get = virtio_modern_msix_config_get,
        .vop_msix_config_set = virtio_modern_msix_config_set,
        .vop_queue_notify = virtio_modern_queue_notify,

        .vop_queue_select = virtio_modern_queue_select,
        .vop_queue_size_get = virtio_modern_queue_size_get,
        .vop_queue_size_set = virtio_modern_queue_size_set,
        .vop_queue_noff_get = virtio_modern_queue_noff_get,
        .vop_queue_enable_get = virtio_modern_queue_enable_get,
        .vop_queue_enable_set = virtio_modern_queue_enable_set,
        .vop_queue_addr_set = virtio_modern_queue_addr_set,
        .vop_msix_queue_get = virtio_modern_msix_queue_get,
        .vop_msix_queue_set = virtio_modern_msix_queue_set,

        .vop_device_cfg_gen = virtio_modern_devcfg_getgen,
        .vop_device_cfg_get8 = virtio_modern_devcfg_get8,
        .vop_device_cfg_get16 = virtio_modern_devcfg_get16,
        .vop_device_cfg_get32 = virtio_modern_devcfg_get32,
        .vop_device_cfg_get64 = virtio_modern_devcfg_get64,
        .vop_device_cfg_put8 = virtio_modern_devcfg_put8,
        .vop_device_cfg_put16 = virtio_modern_devcfg_put16,
        .vop_device_cfg_put32 = virtio_modern_devcfg_put32,
};