// SPDX-License-Identifier: MIT
/*
 * Copyright © 2025 Intel Corporation
 */

#include <drm/drm_managed.h>

#include "xe_device.h"
#include "xe_gt_sriov_pf_control.h"
#include "xe_gt_sriov_pf_migration.h"
#include "xe_pm.h"
#include "xe_sriov.h"
#include "xe_sriov_packet.h"
#include "xe_sriov_packet_types.h"
#include "xe_sriov_pf_helpers.h"
#include "xe_sriov_pf_migration.h"
#include "xe_sriov_printk.h"

static struct xe_sriov_migration_state *pf_pick_migration(struct xe_device *xe, unsigned int vfid)
{
        xe_assert(xe, IS_SRIOV_PF(xe));
        xe_assert(xe, vfid <= xe_sriov_pf_get_totalvfs(xe));

        return &xe->sriov.pf.vfs[vfid].migration;
}

/**
 * xe_sriov_pf_migration_waitqueue() - Get waitqueue for migration.
 * @xe: the &xe_device
 * @vfid: the VF identifier
 *
 * Return: pointer to the migration waitqueue.
 */
wait_queue_head_t *xe_sriov_pf_migration_waitqueue(struct xe_device *xe, unsigned int vfid)
{
        return &pf_pick_migration(xe, vfid)->wq;
}

/**
 * xe_sriov_pf_migration_supported() - Check if SR-IOV VF migration is supported by the device
 * @xe: the &xe_device
 *
 * Return: true if migration is supported, false otherwise
 */
bool xe_sriov_pf_migration_supported(struct xe_device *xe)
{
        xe_assert(xe, IS_SRIOV_PF(xe));

        return IS_ENABLED(CONFIG_DRM_XE_DEBUG) || !xe->sriov.pf.migration.disabled;
}

/**
 * xe_sriov_pf_migration_disable() - Turn off SR-IOV VF migration support on PF.
 * @xe: the &xe_device instance.
 * @fmt: format string for the log message, to be combined with following VAs.
 */
void xe_sriov_pf_migration_disable(struct xe_device *xe, const char *fmt, ...)
{
        struct va_format vaf;
        va_list va_args;

        xe_assert(xe, IS_SRIOV_PF(xe));

        va_start(va_args, fmt);
        vaf.fmt = fmt;
        vaf.va  = &va_args;
        xe_sriov_notice(xe, "migration %s: %pV\n",
                        IS_ENABLED(CONFIG_DRM_XE_DEBUG) ?
                        "missing prerequisite" : "disabled",
                        &vaf);
        va_end(va_args);

        xe->sriov.pf.migration.disabled = true;
}

static void pf_migration_check_support(struct xe_device *xe)
{
        if (!xe_device_has_memirq(xe))
                xe_sriov_pf_migration_disable(xe, "requires memory-based IRQ support");
}

static void pf_migration_cleanup(void *arg)
{
        struct xe_sriov_migration_state *migration = arg;

        xe_sriov_packet_free(migration->pending);
        xe_sriov_packet_free(migration->trailer);
        xe_sriov_packet_free(migration->descriptor);
}

/**
 * xe_sriov_pf_migration_init() - Initialize support for SR-IOV VF migration.
 * @xe: the &xe_device
 *
 * Return: 0 on success or a negative error code on failure.
 */
int xe_sriov_pf_migration_init(struct xe_device *xe)
{
        unsigned int n, totalvfs;
        int err;

        xe_assert(xe, IS_SRIOV_PF(xe));

        pf_migration_check_support(xe);

        if (!xe_sriov_pf_migration_supported(xe))
                return 0;

        totalvfs = xe_sriov_pf_get_totalvfs(xe);
        for (n = 1; n <= totalvfs; n++) {
                struct xe_sriov_migration_state *migration = pf_pick_migration(xe, n);

                err = drmm_mutex_init(&xe->drm, &migration->lock);
                if (err)
                        return err;

                init_waitqueue_head(&migration->wq);

                err = devm_add_action_or_reset(xe->drm.dev, pf_migration_cleanup, migration);
                if (err)
                        return err;
        }

        return 0;
}

static bool pf_migration_data_ready(struct xe_device *xe, unsigned int vfid)
{
        struct xe_gt *gt;
        u8 gt_id;

        for_each_gt(gt, xe, gt_id) {
                if (xe_gt_sriov_pf_control_check_save_failed(gt, vfid) ||
                    xe_gt_sriov_pf_control_check_save_data_done(gt, vfid) ||
                    !xe_gt_sriov_pf_migration_ring_empty(gt, vfid))
                        return true;
        }

        return false;
}

static struct xe_sriov_packet *
pf_migration_consume(struct xe_device *xe, unsigned int vfid)
{
        struct xe_sriov_packet *data;
        bool more_data = false;
        struct xe_gt *gt;
        u8 gt_id;

        for_each_gt(gt, xe, gt_id) {
                data = xe_gt_sriov_pf_migration_save_consume(gt, vfid);
                if (data && PTR_ERR(data) != EAGAIN)
                        return data;
                if (PTR_ERR(data) == -EAGAIN)
                        more_data = true;
        }

        if (!more_data)
                return NULL;

        return ERR_PTR(-EAGAIN);
}

/**
 * xe_sriov_pf_migration_save_consume() - Consume a VF migration data packet from the device.
 * @xe: the &xe_device
 * @vfid: the VF identifier
 *
 * Called by the save migration data consumer (userspace) when
 * processing migration data.
 * If there is no migration data to process, wait until more data is available.
 *
 * Return: Pointer to &xe_sriov_packet on success,
 *         NULL if ring is empty and no more migration data is expected,
 *         ERR_PTR value in case of error.
 */
struct xe_sriov_packet *
xe_sriov_pf_migration_save_consume(struct xe_device *xe, unsigned int vfid)
{
        struct xe_sriov_migration_state *migration = pf_pick_migration(xe, vfid);
        struct xe_sriov_packet *data;
        int ret;

        xe_assert(xe, IS_SRIOV_PF(xe));

        for (;;) {
                data = pf_migration_consume(xe, vfid);
                if (PTR_ERR(data) != -EAGAIN)
                        break;

                ret = wait_event_interruptible(migration->wq,
                                               pf_migration_data_ready(xe, vfid));
                if (ret)
                        return ERR_PTR(ret);
        }

        return data;
}

static int pf_handle_descriptor(struct xe_device *xe, unsigned int vfid,
                                struct xe_sriov_packet *data)
{
        int ret;

        if (data->hdr.tile_id != 0 || data->hdr.gt_id != 0)
                return -EINVAL;

        ret = xe_sriov_packet_process_descriptor(xe, vfid, data);
        if (ret)
                return ret;

        xe_sriov_packet_free(data);

        return 0;
}

static int pf_handle_trailer(struct xe_device *xe, unsigned int vfid,
                             struct xe_sriov_packet *data)
{
        struct xe_gt *gt;
        u8 gt_id;

        if (data->hdr.tile_id != 0 || data->hdr.gt_id != 0)
                return -EINVAL;
        if (data->hdr.offset != 0 || data->hdr.size != 0 || data->buff || data->bo)
                return -EINVAL;

        xe_sriov_packet_free(data);

        for_each_gt(gt, xe, gt_id)
                xe_gt_sriov_pf_control_restore_data_done(gt, vfid);

        return 0;
}

/**
 * xe_sriov_pf_migration_restore_produce() - Produce a VF migration data packet to the device.
 * @xe: the &xe_device
 * @vfid: the VF identifier
 * @data: Pointer to &xe_sriov_packet
 *
 * Called by the restore migration data producer (userspace) when processing
 * migration data.
 * If the underlying data structure is full, wait until there is space.
 *
 * Return: 0 on success or a negative error code on failure.
 */
int xe_sriov_pf_migration_restore_produce(struct xe_device *xe, unsigned int vfid,
                                          struct xe_sriov_packet *data)
{
        struct xe_gt *gt;

        xe_assert(xe, IS_SRIOV_PF(xe));

        if (data->hdr.type == XE_SRIOV_PACKET_TYPE_DESCRIPTOR)
                return pf_handle_descriptor(xe, vfid, data);
        if (data->hdr.type == XE_SRIOV_PACKET_TYPE_TRAILER)
                return pf_handle_trailer(xe, vfid, data);

        gt = xe_device_get_gt(xe, data->hdr.gt_id);
        if (!gt || data->hdr.tile_id != gt->tile->id || data->hdr.type == 0) {
                xe_sriov_err_ratelimited(xe, "Received invalid restore packet for VF%u (type:%u, tile:%u, GT:%u)\n",
                                         vfid, data->hdr.type, data->hdr.tile_id, data->hdr.gt_id);
                return -EINVAL;
        }

        return xe_gt_sriov_pf_migration_restore_produce(gt, vfid, data);
}

/**
 * xe_sriov_pf_migration_read() - Read migration data from the device.
 * @xe: the &xe_device
 * @vfid: the VF identifier
 * @buf: start address of userspace buffer
 * @len: requested read size from userspace
 *
 * Return: number of bytes that has been successfully read,
 *         0 if no more migration data is available,
 *         -errno on failure.
 */
ssize_t xe_sriov_pf_migration_read(struct xe_device *xe, unsigned int vfid,
                                   char __user *buf, size_t len)
{
        struct xe_sriov_migration_state *migration = pf_pick_migration(xe, vfid);
        ssize_t ret, consumed = 0;

        xe_assert(xe, IS_SRIOV_PF(xe));

        scoped_cond_guard(mutex_intr, return -EINTR, &migration->lock) {
                while (consumed < len) {
                        ret = xe_sriov_packet_read_single(xe, vfid, buf, len - consumed);
                        if (ret == -ENODATA)
                                break;
                        if (ret < 0)
                                return ret;

                        consumed += ret;
                        buf += ret;
                }
        }

        return consumed;
}

/**
 * xe_sriov_pf_migration_write() - Write migration data to the device.
 * @xe: the &xe_device
 * @vfid: the VF identifier
 * @buf: start address of userspace buffer
 * @len: requested write size from userspace
 *
 * Return: number of bytes that has been successfully written,
 *         -errno on failure.
 */
ssize_t xe_sriov_pf_migration_write(struct xe_device *xe, unsigned int vfid,
                                    const char __user *buf, size_t len)
{
        struct xe_sriov_migration_state *migration = pf_pick_migration(xe, vfid);
        ssize_t ret, produced = 0;

        xe_assert(xe, IS_SRIOV_PF(xe));

        scoped_cond_guard(mutex_intr, return -EINTR, &migration->lock) {
                while (produced < len) {
                        ret = xe_sriov_packet_write_single(xe, vfid, buf, len - produced);
                        if (ret < 0)
                                return ret;

                        produced += ret;
                        buf += ret;
                }
        }

        return produced;
}

/**
 * xe_sriov_pf_migration_size() - Total size of migration data from all components within a device
 * @xe: the &xe_device
 * @vfid: the VF identifier (can't be 0)
 *
 * This function is for PF only.
 *
 * Return: total migration data size in bytes or a negative error code on failure.
 */
ssize_t xe_sriov_pf_migration_size(struct xe_device *xe, unsigned int vfid)
{
        size_t size = 0;
        struct xe_gt *gt;
        ssize_t ret;
        u8 gt_id;

        xe_assert(xe, IS_SRIOV_PF(xe));
        xe_assert(xe, vfid);

        for_each_gt(gt, xe, gt_id) {
                ret = xe_gt_sriov_pf_migration_size(gt, vfid);
                if (ret < 0)
                        return ret;

                size += ret;
        }

        return size;
}