Unverified Commit 468d277e authored by Richard Fitzgerald's avatar Richard Fitzgerald Committed by Mark Brown
Browse files

regmap: kunit: Add cache-drop test with multiple cache blocks 



Add a test case for dropping only some cache blocks and leaving others
unchanged.

The regmap is divided into 8 register ranges, and only 4 of these are
written with values. This creates 4 non-contiguous ranges of registers
with cached values.

One whole range is then dropped, and part of another range. A cache
sync is then performed to check that the correct registers were written,
and the correct values were written to these registers.

Signed-off-by: default avatarRichard Fitzgerald <rf@opensource.cirrus.com>
Link: https://msgid.link/r/20240408144600.230848-11-rf@opensource.cirrus.com


Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent d6f2fd7a

drivers/base/regmap/regmap-kunit.c

+103 −0
Original line number Diff line number Diff line
@@ -1007,6 +1007,108 @@ static void cache_drop(struct kunit *test) 
	KUNIT_EXPECT_MEMEQ(test, &data->vals[param->from_reg], rval, sizeof(rval));

}



static void cache_drop_with_non_contiguous_ranges(struct kunit *test)

{

	const struct regmap_test_param *param = test->param_value;

	struct regmap *map;

	struct regmap_config config;

	struct regmap_ram_data *data;

	unsigned int val[4][BLOCK_TEST_SIZE];

	unsigned int reg;

	const int num_ranges = ARRAY_SIZE(val) * 2;

	int rangeidx, i;



	static_assert(ARRAY_SIZE(val) == 4);



	config = test_regmap_config;

	config.max_register = param->from_reg + (num_ranges * BLOCK_TEST_SIZE);



	map = gen_regmap(test, &config, &data);

	KUNIT_ASSERT_FALSE(test, IS_ERR(map));

	if (IS_ERR(map))

		return;



	for (i = 0; i < config.max_register + 1; i++)

		data->written[i] = false;



	/* Create non-contiguous cache blocks by writing every other range */

	get_random_bytes(&val, sizeof(val));

	for (rangeidx = 0; rangeidx < num_ranges; rangeidx += 2) {

		reg = param->from_reg + (rangeidx * BLOCK_TEST_SIZE);

		KUNIT_EXPECT_EQ(test, 0, regmap_bulk_write(map, reg,

							   &val[rangeidx / 2],

							   BLOCK_TEST_SIZE));

		KUNIT_EXPECT_MEMEQ(test, &data->vals[reg],

				   &val[rangeidx / 2], sizeof(val[rangeidx / 2]));

	}



	/* Check that odd ranges weren't written */

	for (rangeidx = 1; rangeidx < num_ranges; rangeidx += 2) {

		reg = param->from_reg + (rangeidx * BLOCK_TEST_SIZE);

		for (i = 0; i < BLOCK_TEST_SIZE; i++)

			KUNIT_EXPECT_FALSE(test, data->written[reg + i]);

	}



	/* Drop range 2 */

	reg = param->from_reg + (2 * BLOCK_TEST_SIZE);

	KUNIT_EXPECT_EQ(test, 0, regcache_drop_region(map, reg, reg + BLOCK_TEST_SIZE - 1));



	/* Drop part of range 4 */

	reg = param->from_reg + (4 * BLOCK_TEST_SIZE);

	KUNIT_EXPECT_EQ(test, 0, regcache_drop_region(map, reg + 3, reg + 5));



	/* Mark dirty and reset mock registers to 0 */

	regcache_mark_dirty(map);

	for (i = 0; i < config.max_register + 1; i++) {

		data->vals[i] = 0;

		data->written[i] = false;

	}



	/* The registers that were dropped from range 4 should now remain at 0 */

	val[4 / 2][3] = 0;

	val[4 / 2][4] = 0;

	val[4 / 2][5] = 0;



	/* Sync and check that the expected register ranges were written */

	KUNIT_EXPECT_EQ(test, 0, regcache_sync(map));



	/* Check that odd ranges weren't written */

	for (rangeidx = 1; rangeidx < num_ranges; rangeidx += 2) {

		reg = param->from_reg + (rangeidx * BLOCK_TEST_SIZE);

		for (i = 0; i < BLOCK_TEST_SIZE; i++)

			KUNIT_EXPECT_FALSE(test, data->written[reg + i]);

	}



	/* Check that even ranges (except 2 and 4) were written */

	for (rangeidx = 0; rangeidx < num_ranges; rangeidx += 2) {

		if ((rangeidx == 2) || (rangeidx == 4))

			continue;



		reg = param->from_reg + (rangeidx * BLOCK_TEST_SIZE);

		for (i = 0; i < BLOCK_TEST_SIZE; i++)

			KUNIT_EXPECT_TRUE(test, data->written[reg + i]);



		KUNIT_EXPECT_MEMEQ(test, &data->vals[reg],

				   &val[rangeidx / 2], sizeof(val[rangeidx / 2]));

	}



	/* Check that range 2 wasn't written */

	reg = param->from_reg + (2 * BLOCK_TEST_SIZE);

	for (i = 0; i < BLOCK_TEST_SIZE; i++)

		KUNIT_EXPECT_FALSE(test, data->written[reg + i]);



	/* Check that range 4 was partially written */

	reg = param->from_reg + (4 * BLOCK_TEST_SIZE);

	for (i = 0; i < BLOCK_TEST_SIZE; i++)

		KUNIT_EXPECT_EQ(test, data->written[reg + i], i < 3 || i > 5);



	KUNIT_EXPECT_MEMEQ(test, &data->vals[reg], &val[4 / 2], sizeof(val[4 / 2]));



	/* Nothing before param->from_reg should have been written */

	for (i = 0; i < param->from_reg; i++)

		KUNIT_EXPECT_FALSE(test, data->written[i]);

}



static void cache_drop_all_and_sync_marked_dirty(struct kunit *test)

{

	const struct regmap_test_param *param = test->param_value;
@@ -1663,6 +1765,7 @@ static struct kunit_case regmap_test_cases[] = { 
	KUNIT_CASE_PARAM(cache_sync_readonly, real_cache_types_gen_params),

	KUNIT_CASE_PARAM(cache_sync_patch, real_cache_types_gen_params),

	KUNIT_CASE_PARAM(cache_drop, sparse_cache_types_gen_params),

	KUNIT_CASE_PARAM(cache_drop_with_non_contiguous_ranges, sparse_cache_types_gen_params),

	KUNIT_CASE_PARAM(cache_drop_all_and_sync_marked_dirty, sparse_cache_types_gen_params),

	KUNIT_CASE_PARAM(cache_drop_all_and_sync_no_defaults, sparse_cache_types_gen_params),

	KUNIT_CASE_PARAM(cache_drop_all_and_sync_has_defaults, sparse_cache_types_gen_params),