path: root/drivers/resctrl/test_mpam_resctrl.c

// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2025 Arm Ltd.
/* This file is intended to be included into mpam_resctrl.c */

#include <kunit/test.h>
#include <linux/array_size.h>
#include <linux/bits.h>
#include <linux/math.h>
#include <linux/sprintf.h>

struct percent_value_case {
	u8	pc;
	u8	width;
	u16	value;
};

/*
 * Mysterious inscriptions taken from the union of ARM DDI 0598D.b,
 * "Arm Architecture Reference Manual Supplement - Memory System
 * Resource Partitioning and Monitoring (MPAM), for A-profile
 * architecture", Section 9.8, "About the fixed-point fractional
 * format" (exact percentage entries only) and ARM IHI0099B.a
 * "MPAM system component specification", Section 9.3,
 * "The fixed-point fractional format":
 */
static const struct percent_value_case percent_value_cases[] = {
	/* Architectural cases: */
	{   1,  8,    1 },	{   1, 12,  0x27 },	{   1, 16,  0x28e },
	{  25,  8, 0x3f },	{  25, 12, 0x3ff },	{  25, 16, 0x3fff },
	{  33,  8, 0x53 },	{  33, 12, 0x546 },	{  33, 16, 0x5479 },
	{  35,  8, 0x58 },	{  35, 12, 0x598 },	{  35, 16, 0x5998 },
	{  45,  8, 0x72 },	{  45, 12, 0x732 },	{  45, 16, 0x7332 },
	{  50,  8, 0x7f },	{  50, 12, 0x7ff },	{  50, 16, 0x7fff },
	{  52,  8, 0x84 },	{  52, 12, 0x850 },	{  52, 16, 0x851d },
	{  55,  8, 0x8b },	{  55, 12, 0x8cb },	{  55, 16, 0x8ccb },
	{  58,  8, 0x93 },	{  58, 12, 0x946 },	{  58, 16, 0x9479 },
	{  75,  8, 0xbf },	{  75, 12, 0xbff },	{  75, 16, 0xbfff },
	{  80,  8, 0xcb },	{  80, 12, 0xccb },	{  80, 16, 0xcccb },
	{  88,  8, 0xe0 },	{  88, 12, 0xe13 },	{  88, 16, 0xe146 },
	{  95,  8, 0xf2 },	{  95, 12, 0xf32 },	{  95, 16, 0xf332 },
	{ 100,  8, 0xff },	{ 100, 12, 0xfff },	{ 100, 16, 0xffff },
};

static void test_percent_value_desc(const struct percent_value_case *param,
				    char *desc)
{
	snprintf(desc, KUNIT_PARAM_DESC_SIZE,
		 "pc=%d, width=%d, value=0x%.*x\n",
		 param->pc, param->width,
		 DIV_ROUND_UP(param->width, 4), param->value);
}

KUNIT_ARRAY_PARAM(test_percent_value, percent_value_cases,
		  test_percent_value_desc);

struct percent_value_test_info {
	u32 pc;			/* result of value-to-percent conversion */
	u32 value;		/* result of percent-to-value conversion */
	u32 max_value;		/* maximum raw value allowed by test params */
	unsigned int shift;	/* promotes raw testcase value to 16 bits */
};

/*
 * Convert a reference percentage to a fixed-point MAX value and
 * vice-versa, based on param (not test->param_value!)
 */
static void __prepare_percent_value_test(struct kunit *test,
					 struct percent_value_test_info *res,
					 const struct percent_value_case *param)
{
	struct mpam_props fake_props = { };

	/* Reject bogus test parameters that would break the tests: */
	KUNIT_ASSERT_GE(test, param->width, 1);
	KUNIT_ASSERT_LE(test, param->width, 16);
	KUNIT_ASSERT_LT(test, param->value, 1 << param->width);

	mpam_set_feature(mpam_feat_mbw_max, &fake_props);
	fake_props.bwa_wd = param->width;

	res->shift = 16 - param->width;
	res->max_value = GENMASK_U32(param->width - 1, 0);
	res->value = percent_to_mbw_max(param->pc, &fake_props);
	res->pc = mbw_max_to_percent(param->value << res->shift, &fake_props);
}

static void test_get_mba_granularity(struct kunit *test)
{
	int ret;
	struct mpam_props fake_props = { };

	/* Use MBW_MAX */
	mpam_set_feature(mpam_feat_mbw_max, &fake_props);

	fake_props.bwa_wd = 0;
	KUNIT_EXPECT_FALSE(test, mba_class_use_mbw_max(&fake_props));

	fake_props.bwa_wd = 1;
	KUNIT_EXPECT_TRUE(test, mba_class_use_mbw_max(&fake_props));

	/* Architectural maximum: */
	fake_props.bwa_wd = 16;
	KUNIT_EXPECT_TRUE(test, mba_class_use_mbw_max(&fake_props));

	/* No usable control... */
	fake_props.bwa_wd = 0;
	ret = get_mba_granularity(&fake_props);
	KUNIT_EXPECT_EQ(test, ret, 0);

	fake_props.bwa_wd = 1;
	ret = get_mba_granularity(&fake_props);
	KUNIT_EXPECT_EQ(test, ret, 50);	/* DIV_ROUND_UP(100, 1 << 1)% = 50% */

	fake_props.bwa_wd = 2;
	ret = get_mba_granularity(&fake_props);
	KUNIT_EXPECT_EQ(test, ret, 25);	/* DIV_ROUND_UP(100, 1 << 2)% = 25% */

	fake_props.bwa_wd = 3;
	ret = get_mba_granularity(&fake_props);
	KUNIT_EXPECT_EQ(test, ret, 13);	/* DIV_ROUND_UP(100, 1 << 3)% = 13% */

	fake_props.bwa_wd = 6;
	ret = get_mba_granularity(&fake_props);
	KUNIT_EXPECT_EQ(test, ret, 2);	/* DIV_ROUND_UP(100, 1 << 6)% = 2% */

	fake_props.bwa_wd = 7;
	ret = get_mba_granularity(&fake_props);
	KUNIT_EXPECT_EQ(test, ret, 1);	/* DIV_ROUND_UP(100, 1 << 7)% = 1% */

	/* Granularity saturates at 1% */
	fake_props.bwa_wd = 16; /* architectural maximum */
	ret = get_mba_granularity(&fake_props);
	KUNIT_EXPECT_EQ(test, ret, 1);	/* DIV_ROUND_UP(100, 1 << 16)% = 1% */
}

static void test_mbw_max_to_percent(struct kunit *test)
{
	const struct percent_value_case *param = test->param_value;
	struct percent_value_test_info res;

	/*
	 * Since the reference values in percent_value_cases[] all
	 * correspond to exact percentages, round-to-nearest will
	 * always give the exact percentage back when the MPAM max
	 * value has precision of 0.5% or finer.  (Always true for the
	 * reference data, since they all specify 8 bits or more of
	 * precision.
	 *
	 * So, keep it simple and demand an exact match:
	 */
	__prepare_percent_value_test(test, &res, param);
	KUNIT_EXPECT_EQ(test, res.pc, param->pc);
}

static void test_percent_to_mbw_max(struct kunit *test)
{
	const struct percent_value_case *param = test->param_value;
	struct percent_value_test_info res;

	__prepare_percent_value_test(test, &res, param);

	KUNIT_EXPECT_GE(test, res.value, param->value << res.shift);
	KUNIT_EXPECT_LE(test, res.value, (param->value + 1) << res.shift);
	KUNIT_EXPECT_LE(test, res.value, res.max_value << res.shift);

	/* No flexibility allowed for 0% and 100%! */

	if (param->pc == 0)
		KUNIT_EXPECT_EQ(test, res.value, 0);

	if (param->pc == 100)
		KUNIT_EXPECT_EQ(test, res.value, res.max_value << res.shift);
}

static const void *test_all_bwa_wd_gen_params(struct kunit *test, const void *prev,
					      char *desc)
{
	uintptr_t param = (uintptr_t)prev;

	if (param > 15)
		return NULL;

	param++;

	snprintf(desc, KUNIT_PARAM_DESC_SIZE, "wd=%u\n", (unsigned int)param);

	return (void *)param;
}

static unsigned int test_get_bwa_wd(struct kunit *test)
{
	uintptr_t param = (uintptr_t)test->param_value;

	KUNIT_ASSERT_GE(test, param, 1);
	KUNIT_ASSERT_LE(test, param, 16);

	return param;
}

static void test_mbw_max_to_percent_limits(struct kunit *test)
{
	struct mpam_props fake_props = {0};
	u32 max_value;

	mpam_set_feature(mpam_feat_mbw_max, &fake_props);
	fake_props.bwa_wd = test_get_bwa_wd(test);
	max_value = GENMASK(15,