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

#include "abi/guc_relay_actions_abi.h"

#include "xe_device_types.h"
#include "xe_sriov.h"
#include "xe_sriov_pf_helpers.h"
#include "xe_sriov_printk.h"

#include "xe_sriov_pf_service.h"
#include "xe_sriov_pf_service_types.h"

/**
 * xe_sriov_pf_service_init - Early initialization of the SR-IOV PF service.
 * @xe: the &xe_device to initialize
 *
 * Performs early initialization of the SR-IOV PF service.
 *
 * This function can only be called on PF.
 */
void xe_sriov_pf_service_init(struct xe_device *xe)
{
	BUILD_BUG_ON(!GUC_RELAY_VERSION_BASE_MAJOR && !GUC_RELAY_VERSION_BASE_MINOR);
	BUILD_BUG_ON(GUC_RELAY_VERSION_BASE_MAJOR > GUC_RELAY_VERSION_LATEST_MAJOR);

	xe_assert(xe, IS_SRIOV_PF(xe));

	/* base versions may differ between platforms */
	xe->sriov.pf.service.version.base.major = GUC_RELAY_VERSION_BASE_MAJOR;
	xe->sriov.pf.service.version.base.minor = GUC_RELAY_VERSION_BASE_MINOR;

	/* latest version is same for all platforms */
	xe->sriov.pf.service.version.latest.major = GUC_RELAY_VERSION_LATEST_MAJOR;
	xe->sriov.pf.service.version.latest.minor = GUC_RELAY_VERSION_LATEST_MINOR;
}

/* Return: 0 on success or a negative error code on failure. */
static int pf_negotiate_version(struct xe_device *xe,
				u32 wanted_major, u32 wanted_minor,
				u32 *major, u32 *minor)
{
	struct xe_sriov_pf_service_version base = xe->sriov.pf.service.version.base;
	struct xe_sriov_pf_service_version latest = xe->sriov.pf.service.version.latest;

	xe_assert(xe, IS_SRIOV_PF(xe));
	xe_assert(xe, base.major);
	xe_assert(xe, base.major <= latest.major);
	xe_assert(xe, (base.major < latest.major) || (base.minor <= latest.minor));

	/* VF doesn't care - return our latest  */
	if (wanted_major == VF2PF_HANDSHAKE_MAJOR_ANY &&
	    wanted_minor == VF2PF_HANDSHAKE_MINOR_ANY) {
		*major = latest.major;
		*minor = latest.minor;
		return 0;
	}

	/* VF wants newer than our - return our latest  */
	if (wanted_major > latest.major) {
		*major = latest.major;
		*minor = latest.minor;
		return 0;
	}

	/* VF wants older than min required - reject */
	if (wanted_major < base.major ||
	    (wanted_major == base.major && wanted_minor < base.minor)) {
		return -EPERM;
	}

	/* previous major - return wanted, as we should still support it */
	if (wanted_major < latest.major) {
		/* XXX: we are not prepared for multi-versions yet */
		xe_assert(xe, base.major == latest.major);
		return -ENOPKG;
	}

	/* same major - return common minor */
	*major = wanted_major;
	*minor = min_t(u32, latest.minor, wanted_minor);
	return 0;
}

static void pf_connect(struct xe_device *xe, u32 vfid, u32 major, u32 minor)
{
	xe_sriov_pf_assert_vfid(xe, vfid);
	xe_assert(xe, major || minor);

	xe->sriov.pf.vfs[vfid].version.major = major;
	xe->sriov.pf.vfs[vfid].version.minor = minor;
}

static void pf_disconnect(struct xe_device *xe, u32 vfid)
{
	xe_sriov_pf_assert_vfid(xe, vfid);

	xe->sriov.pf.vfs[vfid].version.major = 0;
	xe->sriov.pf.vfs[vfid].version.minor = 0;
}

/**
 * xe_sriov_pf_service_is_negotiated - Check if VF has negotiated given ABI version.
 * @xe: the &xe_device
 * @vfid: the VF identifier
 * @major: the major version to check
 * @minor: the minor version to check
 *
 * Performs early initialization of the SR-IOV PF service.
 *
 * This function can only be called on PF.
 *
 * Returns: true if VF can use given ABI version functionality.
 */
bool xe_sriov_pf_service_is_negotiated(struct xe_device *xe, u32 vfid, u32 major, u32 minor)
{
	xe_sriov_pf_assert_vfid(xe, vfid);

	return major == xe->sriov.pf.vfs[vfid].version.major &&
	       minor <= xe->sriov.pf.vfs[vfid].version.minor;
}

/**
 * xe_sriov_pf_service_handshake_vf - Confirm a connection with the VF.
 * @xe: the &xe_device
 * @vfid: the VF identifier
 * @wanted_major: the major service version expected by the VF
 * @wanted_minor: the minor service version expected by the VF
 * @major: the major service version to be used by the VF
 * @minor: the minor service version to be used by the VF
 *
 * Negotiate a VF/PF ABI version to allow VF use the PF services.
 *
 * This function can only be called on PF.
 *
 * Return: 0 on success or a negative error code on failure.
 */
int xe_sriov_pf_service_handshake_vf(struct xe_device *xe, u32 vfid,
				     u32 wanted_major, u32 wanted_minor,
				     u32 *major, u32 *minor)
{
	int err;

	xe_sriov_dbg_verbose(xe, "VF%u wants ABI version %u.%u\n",
			     vfid, wanted_major, wanted_minor);

	err = pf_negotiate_version(xe, wanted_major, wanted_minor, major, minor);

	if (err < 0) {
		xe_sriov_notice(xe, "VF%u failed to negotiate ABI %u.%u (%pe)\n",
				vfid, wanted_major, wanted_minor, ERR_PTR(err));
		pf_disconnect(xe, vfid);
	} else {
		xe_sriov_dbg(xe, "VF%u negotiated ABI version %u.%u\n",
			     vfid, *major, *minor);
		pf_connect(xe, vfid, *major, *minor);
	}

	return err;
}

/**
 * xe_sriov_pf_service_reset_vf - Reset a connection with the VF.
 * @xe: the &xe_device
 * @vfid: the VF identifier
 *
 * Reset a VF driver negotiated VF/PF ABI version.
 *
 * After that point, the VF driver will have to perform new version handshake
 * to continue use of the PF services again.
 *
 * This function can only be called on PF.
 */
void xe_sriov_pf_service_reset_vf(struct xe_device *xe, unsigned int vfid)
{
	pf_disconnect(xe, vfid);
}

static void print_pf_version(struct drm_printer *p, const char *name,
			     const struct xe_sriov_pf_service_version *version)
{
	drm_printf(p, "%s:\t%u.%u\n", name, version->major, version->minor);
}

/**
 * xe_sriov_pf_service_print_versions - Print ABI versions negotiated with VFs.
 * @xe: the &xe_device
 * @p: the &drm_printer
 *
 * This function is for PF use only.
 */
void xe_sriov_pf_service_print_versions(struct xe_device *xe, struct drm_printer *p)
{
	unsigned int n, total_vfs = xe_sriov_pf_get_totalvfs(xe);
	struct xe_sriov_pf_service_version *version;
	char name[8];

	xe_assert(xe, IS_SRIOV_PF(xe));

	print_pf_version(p, "base", &xe->sriov.pf.service.version.base);
	print_pf_version(p, "latest", &xe->sriov.pf.service.version.latest);

	for (n = 1; n <= total_vfs; n++) {
		version = &xe->sriov.pf.vfs[n].version;
		if (!version->major && !version->minor)
			continue;

		print_pf_version(p, xe_sriov_function_name(n, name, sizeof(name)), version);
	}
}

#if IS_BUILTIN(CONFIG_DRM_XE_KUNIT_TEST)
#include "tests/xe_sriov_pf_service_kunit.c"
#endif