/*
 * 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 2022 Oxide Computer Company
 */

#include "payload_common.h"
#include "payload_utils.h"

int
leaf_cmp(const uint32_t *a, const uint32_t *b)
{
	return (a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3]);
}

const uint32_t expected_base[] = { 5, 0x74737552, 0x65646978, 0x4f206465 };

struct test_case {
	uint32_t func;
	uint32_t idx;
	uint32_t val_eax;
	int fallback;
};

const struct test_case cases[] = {
	/* basic leaf match */
	{
		.func = 1,
		.val_eax = 0x100,
	},
	/* index matching */
	{
		.func = 3,
		.idx = 0,
		.val_eax = 0x300,
	},
	{
		.func = 3,
		.idx = 1,
		.val_eax = 0x301,
	},
	/* leaf match with hole */
	{
		.func = 4,
		.idx = 0,
		.val_eax = 0x400,
	},
	{
		.func = 4,
		.idx = 2,
		.val_eax = 0x402,
	},
	/* last std leaf */
	{
		.func = 5,
		.val_eax = 0x5,
	},

	/* invalid leaf */
	{
		.func = 2,
		.val_eax = 0,
	},
	/* invalid index */
	{
		.func = 3,
		.idx = 2,
		.val_eax = 0,
	},
	{
		.func = 4,
		.idx = 1,
		.val_eax = 0x0,
	},
	{
		.func = 4,
		.idx = 0xffff,
		.val_eax = 0x0,
	},

	/* basic extd leaf match */
	{
		.func = 0x80000000,
		.val_eax = 0x80000001,
	},
	/* basic extd index match */
	{
		.func = 0x80000001,
		.idx = 0,
		.val_eax = 0x8000,
	},
	{
		.func = 0x80000001,
		.idx = 1,
		.val_eax = 0x8001,
	},
	/* zeroed for invalid index */
	{
		.func = 0x80000001,
		.idx = 5,
		.val_eax = 0,
	},

	/* fallback beyond std leaf */
	{
		.func = 6,
		.fallback = 1,
	},
	/* fallback beyond extd leaf */
	{
		.func = 0x80000002,
		.fallback = 1,
	},
};
#define	NCASES	(sizeof (cases) / sizeof (cases[0]))

void
do_test(int intel_fallback)
{
	uint32_t regs[4];
	uint32_t expected_fallback[4] = { 0 };

	cpuid(0, 0, regs);
	if (!leaf_cmp(regs, expected_base)) {
		outb(IOP_TEST_RESULT, TEST_RESULT_FAIL);
	}

	if (intel_fallback) {
		cpuid(regs[0], 0, expected_fallback);
	}

	for (uint_t i = 0; i < NCASES; i++) {
		cpuid(cases[i].func, cases[i].idx, regs);
		if (cases[i].fallback != 0) {
			if (!leaf_cmp(regs, expected_fallback)) {
				outb(IOP_TEST_RESULT, TEST_RESULT_FAIL);
			}
		} else {
			if (regs[0] != cases[i].val_eax) {
				outb(IOP_TEST_RESULT, TEST_RESULT_FAIL);
			}
		}
	}
}

void
start(void)
{
	/* Check results expecting Intel-style fallback */
	do_test(1);

	/* Notify userspace component to change fallback style */
	outl(IOP_TEST_VALUE, 0);

	/* Check results expecting AMD-style fallback */
	do_test(0);

	/* If all is well by this point, indicate success */
	outb(IOP_TEST_RESULT, TEST_RESULT_PASS);
}