Skip to content

Commit ac4394b

Browse files
rfvirgilbroonie
rfvirgil
authored and
broonie
committed
regmap: kunit: Run non-sparse cache tests at non-zero register addresses
Change the tests parameterized by real_cache_types_list[] to test at some register addresses that are not 0. The cache_range_window_reg() test has hardcoded address assumptions that are not present in any other tests using real_cache_types_list[] table. So it has been given a separate parameter table, real_cache_types_only_list[], that preserves the original parameterization. Signed-off-by: Richard Fitzgerald <rf@opensource.cirrus.com> Link: https://msgid.link/r/20240408144600.230848-6-rf@opensource.cirrus.com Signed-off-by: Mark Brown <broonie@kernel.org>
1 parent 7109157 commit ac4394b

1 file changed

Lines changed: 57 additions & 29 deletions

File tree

‎drivers/base/regmap/regmap-kunit.c‎

Lines changed: 57 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -92,12 +92,32 @@ static const struct regmap_test_param regcache_types_list[] = {
9292

9393
KUNIT_ARRAY_PARAM(regcache_types, regcache_types_list, param_to_desc);
9494

95-
static const struct regmap_test_param real_cache_types_list[] = {
95+
static const struct regmap_test_param real_cache_types_only_list[] = {
9696
{ .cache = REGCACHE_FLAT },
9797
{ .cache = REGCACHE_RBTREE },
9898
{ .cache = REGCACHE_MAPLE },
9999
};
100100

101+
KUNIT_ARRAY_PARAM(real_cache_types_only, real_cache_types_only_list, param_to_desc);
102+
103+
static const struct regmap_test_param real_cache_types_list[] = {
104+
{ .cache = REGCACHE_FLAT, .from_reg = 0 },
105+
{ .cache = REGCACHE_FLAT, .from_reg = 0x2001 },
106+
{ .cache = REGCACHE_FLAT, .from_reg = 0x2002 },
107+
{ .cache = REGCACHE_FLAT, .from_reg = 0x2003 },
108+
{ .cache = REGCACHE_FLAT, .from_reg = 0x2004 },
109+
{ .cache = REGCACHE_RBTREE, .from_reg = 0 },
110+
{ .cache = REGCACHE_RBTREE, .from_reg = 0x2001 },
111+
{ .cache = REGCACHE_RBTREE, .from_reg = 0x2002 },
112+
{ .cache = REGCACHE_RBTREE, .from_reg = 0x2003 },
113+
{ .cache = REGCACHE_RBTREE, .from_reg = 0x2004 },
114+
{ .cache = REGCACHE_MAPLE, .from_reg = 0 },
115+
{ .cache = REGCACHE_MAPLE, .from_reg = 0x2001 },
116+
{ .cache = REGCACHE_MAPLE, .from_reg = 0x2002 },
117+
{ .cache = REGCACHE_MAPLE, .from_reg = 0x2003 },
118+
{ .cache = REGCACHE_MAPLE, .from_reg = 0x2004 },
119+
};
120+
101121
KUNIT_ARRAY_PARAM(real_cache_types, real_cache_types_list, param_to_desc);
102122

103123
static const struct regmap_test_param sparse_cache_types_list[] = {
@@ -175,9 +195,12 @@ static struct regmap *gen_regmap(struct kunit *test,
175195
return ret;
176196
}
177197

178-
static bool reg_5_false(struct device *context, unsigned int reg)
198+
static bool reg_5_false(struct device *dev, unsigned int reg)
179199
{
180-
return reg != 5;
200+
struct kunit *test = dev_get_drvdata(dev);
201+
const struct regmap_test_param *param = test->param_value;
202+
203+
return reg != (param->from_reg + 5);
181204
}
182205

183206
static void basic_read_write(struct kunit *test)
@@ -648,6 +671,7 @@ static void stress_insert(struct kunit *test)
648671

649672
static void cache_bypass(struct kunit *test)
650673
{
674+
const struct regmap_test_param *param = test->param_value;
651675
struct regmap *map;
652676
struct regmap_config config;
653677
struct regmap_ram_data *data;
@@ -663,27 +687,28 @@ static void cache_bypass(struct kunit *test)
663687
get_random_bytes(&val, sizeof(val));
664688

665689
/* Ensure the cache has a value in it */
666-
KUNIT_EXPECT_EQ(test, 0, regmap_write(map, 0, val));
690+
KUNIT_EXPECT_EQ(test, 0, regmap_write(map, param->from_reg, val));
667691

668692
/* Bypass then write a different value */
669693
regcache_cache_bypass(map, true);
670-
KUNIT_EXPECT_EQ(test, 0, regmap_write(map, 0, val + 1));
694+
KUNIT_EXPECT_EQ(test, 0, regmap_write(map, param->from_reg, val + 1));
671695

672696
/* Read the bypassed value */
673-
KUNIT_EXPECT_EQ(test, 0, regmap_read(map, 0, &rval));
697+
KUNIT_EXPECT_EQ(test, 0, regmap_read(map, param->from_reg, &rval));
674698
KUNIT_EXPECT_EQ(test, val + 1, rval);
675-
KUNIT_EXPECT_EQ(test, data->vals[0], rval);
699+
KUNIT_EXPECT_EQ(test, data->vals[param->from_reg], rval);
676700

677701
/* Disable bypass, the cache should still return the original value */
678702
regcache_cache_bypass(map, false);
679-
KUNIT_EXPECT_EQ(test, 0, regmap_read(map, 0, &rval));
703+
KUNIT_EXPECT_EQ(test, 0, regmap_read(map, param->from_reg, &rval));
680704
KUNIT_EXPECT_EQ(test, val, rval);
681705

682706
regmap_exit(map);
683707
}
684708

685709
static void cache_sync(struct kunit *test)
686710
{
711+
const struct regmap_test_param *param = test->param_value;
687712
struct regmap *map;
688713
struct regmap_config config;
689714
struct regmap_ram_data *data;
@@ -700,26 +725,27 @@ static void cache_sync(struct kunit *test)
700725
get_random_bytes(&val, sizeof(val));
701726

702727
/* Put some data into the cache */
703-
KUNIT_EXPECT_EQ(test, 0, regmap_bulk_write(map, 0, val,
728+
KUNIT_EXPECT_EQ(test, 0, regmap_bulk_write(map, param->from_reg, val,
704729
BLOCK_TEST_SIZE));
705730
for (i = 0; i < BLOCK_TEST_SIZE; i++)
706-
data->written[i] = false;
731+
data->written[param->from_reg + i] = false;
707732

708733
/* Trash the data on the device itself then resync */
709734
regcache_mark_dirty(map);
710735
memset(data->vals, 0, sizeof(val));
711736
KUNIT_EXPECT_EQ(test, 0, regcache_sync(map));
712737

713738
/* Did we just write the correct data out? */
714-
KUNIT_EXPECT_MEMEQ(test, data->vals, val, sizeof(val));
739+
KUNIT_EXPECT_MEMEQ(test, &data->vals[param->from_reg], val, sizeof(val));
715740
for (i = 0; i < BLOCK_TEST_SIZE; i++)
716-
KUNIT_EXPECT_EQ(test, true, data->written[i]);
741+
KUNIT_EXPECT_EQ(test, true, data->written[param->from_reg + i]);
717742

718743
regmap_exit(map);
719744
}
720745

721746
static void cache_sync_defaults(struct kunit *test)
722747
{
748+
const struct regmap_test_param *param = test->param_value;
723749
struct regmap *map;
724750
struct regmap_config config;
725751
struct regmap_ram_data *data;
@@ -737,23 +763,24 @@ static void cache_sync_defaults(struct kunit *test)
737763
get_random_bytes(&val, sizeof(val));
738764

739765
/* Change the value of one register */
740-
KUNIT_EXPECT_EQ(test, 0, regmap_write(map, 2, val));
766+
KUNIT_EXPECT_EQ(test, 0, regmap_write(map, param->from_reg + 2, val));
741767

742768
/* Resync */
743769
regcache_mark_dirty(map);
744770
for (i = 0; i < BLOCK_TEST_SIZE; i++)
745-
data->written[i] = false;
771+
data->written[param->from_reg + i] = false;
746772
KUNIT_EXPECT_EQ(test, 0, regcache_sync(map));
747773

748774
/* Did we just sync the one register we touched? */
749775
for (i = 0; i < BLOCK_TEST_SIZE; i++)
750-
KUNIT_EXPECT_EQ(test, i == 2, data->written[i]);
776+
KUNIT_EXPECT_EQ(test, i == 2, data->written[param->from_reg + i]);
751777

752778
regmap_exit(map);
753779
}
754780

755781
static void cache_sync_readonly(struct kunit *test)
756782
{
783+
const struct regmap_test_param *param = test->param_value;
757784
struct regmap *map;
758785
struct regmap_config config;
759786
struct regmap_ram_data *data;
@@ -770,29 +797,30 @@ static void cache_sync_readonly(struct kunit *test)
770797

771798
/* Read all registers to fill the cache */
772799
for (i = 0; i < BLOCK_TEST_SIZE; i++)
773-
KUNIT_EXPECT_EQ(test, 0, regmap_read(map, i, &val));
800+
KUNIT_EXPECT_EQ(test, 0, regmap_read(map, param->from_reg + i, &val));
774801

775802
/* Change the value of all registers, readonly should fail */
776803
get_random_bytes(&val, sizeof(val));
777804
regcache_cache_only(map, true);
778805
for (i = 0; i < BLOCK_TEST_SIZE; i++)
779-
KUNIT_EXPECT_EQ(test, i != 5, regmap_write(map, i, val) == 0);
806+
KUNIT_EXPECT_EQ(test, i != 5, regmap_write(map, param->from_reg + i, val) == 0);
780807
regcache_cache_only(map, false);
781808

782809
/* Resync */
783810
for (i = 0; i < BLOCK_TEST_SIZE; i++)
784-
data->written[i] = false;
811+
data->written[param->from_reg + i] = false;
785812
KUNIT_EXPECT_EQ(test, 0, regcache_sync(map));
786813

787814
/* Did that match what we see on the device? */
788815
for (i = 0; i < BLOCK_TEST_SIZE; i++)
789-
KUNIT_EXPECT_EQ(test, i != 5, data->written[i]);
816+
KUNIT_EXPECT_EQ(test, i != 5, data->written[param->from_reg + i]);
790817

791818
regmap_exit(map);
792819
}
793820

794821
static void cache_sync_patch(struct kunit *test)
795822
{
823+
const struct regmap_test_param *param = test->param_value;
796824
struct regmap *map;
797825
struct regmap_config config;
798826
struct regmap_ram_data *data;
@@ -810,14 +838,14 @@ static void cache_sync_patch(struct kunit *test)
810838
return;
811839

812840
/* Stash the original values */
813-
KUNIT_EXPECT_EQ(test, 0, regmap_bulk_read(map, 0, rval,
841+
KUNIT_EXPECT_EQ(test, 0, regmap_bulk_read(map, param->from_reg, rval,
814842
BLOCK_TEST_SIZE));
815843

816844
/* Patch a couple of values */
817-
patch[0].reg = 2;
845+
patch[0].reg = param->from_reg + 2;
818846
patch[0].def = rval[2] + 1;
819847
patch[0].delay_us = 0;
820-
patch[1].reg = 5;
848+
patch[1].reg = param->from_reg + 5;
821849
patch[1].def = rval[5] + 1;
822850
patch[1].delay_us = 0;
823851
KUNIT_EXPECT_EQ(test, 0, regmap_register_patch(map, patch,
@@ -826,23 +854,23 @@ static void cache_sync_patch(struct kunit *test)
826854
/* Sync the cache */
827855
regcache_mark_dirty(map);
828856
for (i = 0; i < BLOCK_TEST_SIZE; i++)
829-
data->written[i] = false;
857+
data->written[param->from_reg + i] = false;
830858
KUNIT_EXPECT_EQ(test, 0, regcache_sync(map));
831859

832860
/* The patch should be on the device but not in the cache */
833861
for (i = 0; i < BLOCK_TEST_SIZE; i++) {
834-
KUNIT_EXPECT_EQ(test, 0, regmap_read(map, i, &val));
862+
KUNIT_EXPECT_EQ(test, 0, regmap_read(map, param->from_reg + i, &val));
835863
KUNIT_EXPECT_EQ(test, val, rval[i]);
836864

837865
switch (i) {
838866
case 2:
839867
case 5:
840-
KUNIT_EXPECT_EQ(test, true, data->written[i]);
841-
KUNIT_EXPECT_EQ(test, data->vals[i], rval[i] + 1);
868+
KUNIT_EXPECT_EQ(test, true, data->written[param->from_reg + i]);
869+
KUNIT_EXPECT_EQ(test, data->vals[param->from_reg + i], rval[i] + 1);
842870
break;
843871
default:
844-
KUNIT_EXPECT_EQ(test, false, data->written[i]);
845-
KUNIT_EXPECT_EQ(test, data->vals[i], rval[i]);
872+
KUNIT_EXPECT_EQ(test, false, data->written[param->from_reg + i]);
873+
KUNIT_EXPECT_EQ(test, data->vals[param->from_reg + i], rval[i]);
846874
break;
847875
}
848876
}
@@ -1436,7 +1464,7 @@ static struct kunit_case regmap_test_cases[] = {
14361464
KUNIT_CASE_PARAM(cache_sync_patch, real_cache_types_gen_params),
14371465
KUNIT_CASE_PARAM(cache_drop, sparse_cache_types_gen_params),
14381466
KUNIT_CASE_PARAM(cache_present, sparse_cache_types_gen_params),
1439-
KUNIT_CASE_PARAM(cache_range_window_reg, real_cache_types_gen_params),
1467+
KUNIT_CASE_PARAM(cache_range_window_reg, real_cache_types_only_gen_params),
14401468

14411469
KUNIT_CASE_PARAM(raw_read_defaults_single, raw_test_types_gen_params),
14421470
KUNIT_CASE_PARAM(raw_read_defaults, raw_test_types_gen_params),

0 commit comments

Comments
 (0)