Skip to content

Commit d5cbd9f

Browse files
torvaldstorvalds
committed
Merge tag 'regmap-v6.20' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap
Pull regmap updates from Mark Brown: "The main change here is the implementation of a mechanism for generating register defaults via a callback rather than with a table in the driver. This is useful for devices where there are large ranges of registers with the same or generated values, it allows us to have a small amount of code instead of a larger amount of default data" * tag 'regmap-v6.20' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap: regcache: Demote defaults readback from HW to debug print regmap: add KUnit coverage for reg_default_cb callback regmap: Add reg_default_cb callback for flat cache defaults regmap: Enable REGMAP when REGMAP_SLIMBUS is enabled
2 parents be653d2 + 4651c87 commit d5cbd9f

7 files changed

Lines changed: 133 additions & 3 deletions

File tree

‎drivers/base/regmap/Kconfig‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55

66
config REGMAP
77
bool
8-
default y if (REGMAP_I2C || REGMAP_SPI || REGMAP_SPMI || REGMAP_W1 || REGMAP_AC97 || REGMAP_MMIO || REGMAP_IRQ || REGMAP_SOUNDWIRE || REGMAP_SOUNDWIRE_MBQ || REGMAP_SCCB || REGMAP_I3C || REGMAP_SPI_AVMM || REGMAP_MDIO || REGMAP_FSI)
8+
default y if (REGMAP_I2C || REGMAP_SLIMBUS || REGMAP_SPI || REGMAP_SPMI || REGMAP_W1 || REGMAP_AC97 || REGMAP_MMIO || REGMAP_IRQ || REGMAP_SOUNDWIRE || REGMAP_SOUNDWIRE_MBQ || REGMAP_SCCB || REGMAP_I3C || REGMAP_SPI_AVMM || REGMAP_MDIO || REGMAP_FSI)
99
help
1010
Enable support for the Register Map (regmap) access API.
1111

‎drivers/base/regmap/internal.h‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -117,6 +117,9 @@ struct regmap {
117117
void *val_buf, size_t val_size);
118118
int (*write)(void *context, const void *data, size_t count);
119119

120+
int (*reg_default_cb)(struct device *dev, unsigned int reg,
121+
unsigned int *val);
122+
120123
unsigned long read_flag_mask;
121124
unsigned long write_flag_mask;
122125

‎drivers/base/regmap/regcache-flat.c‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -79,6 +79,25 @@ static int regcache_flat_populate(struct regmap *map)
7979
__set_bit(index, cache->valid);
8080
}
8181

82+
if (map->reg_default_cb) {
83+
dev_dbg(map->dev,
84+
"Populating regcache_flat using reg_default_cb callback\n");
85+
86+
for (i = 0; i <= map->max_register; i += map->reg_stride) {
87+
unsigned int index = regcache_flat_get_index(map, i);
88+
unsigned int value;
89+
90+
if (test_bit(index, cache->valid))
91+
continue;
92+
93+
if (map->reg_default_cb(map->dev, i, &value))
94+
continue;
95+
96+
cache->data[index] = value;
97+
__set_bit(index, cache->valid);
98+
}
99+
}
100+
82101
return 0;
83102
}
84103

‎drivers/base/regmap/regcache.c‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -73,7 +73,7 @@ static int regcache_hw_init(struct regmap *map)
7373

7474
if (!map->reg_defaults_raw) {
7575
bool cache_bypass = map->cache_bypass;
76-
dev_warn(map->dev, "No cache defaults, reading back from HW\n");
76+
dev_dbg(map->dev, "No cache defaults, reading back from HW\n");
7777

7878
/* Bypass the cache access till data read from HW */
7979
map->cache_bypass = true;
@@ -223,7 +223,8 @@ int regcache_init(struct regmap *map, const struct regmap_config *config)
223223
goto err_free;
224224
}
225225

226-
if (map->num_reg_defaults && map->cache_ops->populate) {
226+
if (map->cache_ops->populate &&
227+
(map->num_reg_defaults || map->reg_default_cb)) {
227228
dev_dbg(map->dev, "Populating %s cache\n", map->cache_ops->name);
228229
map->lock(map->lock_arg);
229230
ret = map->cache_ops->populate(map);

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

Lines changed: 91 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,8 @@ KUNIT_DEFINE_ACTION_WRAPPER(regmap_exit_action, regmap_exit, struct regmap *);
1515

1616
struct regmap_test_priv {
1717
struct device *dev;
18+
bool *reg_default_called;
19+
unsigned int reg_default_max;
1820
};
1921

2022
struct regmap_test_param {
@@ -118,6 +120,14 @@ static const struct regmap_test_param real_cache_types_only_list[] = {
118120

119121
KUNIT_ARRAY_PARAM(real_cache_types_only, real_cache_types_only_list, param_to_desc);
120122

123+
static const struct regmap_test_param flat_cache_types_list[] = {
124+
{ .cache = REGCACHE_FLAT, .from_reg = 0 },
125+
{ .cache = REGCACHE_FLAT, .from_reg = 0, .fast_io = true },
126+
{ .cache = REGCACHE_FLAT, .from_reg = 0x2001 },
127+
};
128+
129+
KUNIT_ARRAY_PARAM(flat_cache_types, flat_cache_types_list, param_to_desc);
130+
121131
static const struct regmap_test_param real_cache_types_list[] = {
122132
{ .cache = REGCACHE_FLAT, .from_reg = 0 },
123133
{ .cache = REGCACHE_FLAT, .from_reg = 0, .fast_io = true },
@@ -248,6 +258,37 @@ static bool reg_5_false(struct device *dev, unsigned int reg)
248258
return reg != (param->from_reg + 5);
249259
}
250260

261+
static unsigned int reg_default_expected(unsigned int reg)
262+
{
263+
return 0x5a5a0000 | (reg & 0xffff);
264+
}
265+
266+
static int reg_default_test_cb(struct device *dev, unsigned int reg,
267+
unsigned int *def)
268+
{
269+
struct kunit *test = dev_get_drvdata(dev);
270+
struct regmap_test_priv *priv = test->priv;
271+
272+
if (priv && priv->reg_default_called && reg <= priv->reg_default_max)
273+
priv->reg_default_called[reg] = true;
274+
275+
*def = reg_default_expected(reg);
276+
return 0;
277+
}
278+
279+
static void expect_reg_default_value(struct kunit *test, struct regmap *map,
280+
struct regmap_ram_data *data,
281+
struct regmap_test_priv *priv,
282+
unsigned int reg)
283+
{
284+
unsigned int val;
285+
286+
KUNIT_EXPECT_TRUE(test, priv->reg_default_called[reg]);
287+
KUNIT_EXPECT_EQ(test, 0, regmap_read(map, reg, &val));
288+
KUNIT_EXPECT_EQ(test, reg_default_expected(reg), val);
289+
KUNIT_EXPECT_FALSE(test, data->read[reg]);
290+
}
291+
251292
static void basic_read_write(struct kunit *test)
252293
{
253294
struct regmap *map;
@@ -628,6 +669,54 @@ static void reg_defaults(struct kunit *test)
628669
KUNIT_EXPECT_EQ(test, config.cache_type == REGCACHE_NONE, data->read[i]);
629670
}
630671

672+
static void reg_default_callback_populates_flat_cache(struct kunit *test)
673+
{
674+
const struct regmap_test_param *param = test->param_value;
675+
struct regmap_test_priv *priv = test->priv;
676+
struct regmap *map;
677+
struct regmap_config config;
678+
struct regmap_ram_data *data;
679+
unsigned int reg, val;
680+
unsigned int defaults_end;
681+
682+
config = test_regmap_config;
683+
config.num_reg_defaults = 3;
684+
config.max_register = param->from_reg + BLOCK_TEST_SIZE - 1;
685+
config.reg_default_cb = reg_default_test_cb;
686+
687+
priv->reg_default_max = config.max_register;
688+
priv->reg_default_called = kunit_kcalloc(test, config.max_register + 1,
689+
sizeof(*priv->reg_default_called),
690+
GFP_KERNEL);
691+
KUNIT_ASSERT_NOT_NULL(test, priv->reg_default_called);
692+
693+
map = gen_regmap(test, &config, &data);
694+
KUNIT_ASSERT_FALSE(test, IS_ERR(map));
695+
if (IS_ERR(map))
696+
return;
697+
698+
for (reg = 0; reg <= config.max_register; reg++)
699+
data->read[reg] = false;
700+
701+
defaults_end = param->from_reg + config.num_reg_defaults - 1;
702+
703+
for (reg = param->from_reg; reg <= defaults_end; reg++) {
704+
KUNIT_EXPECT_FALSE(test, priv->reg_default_called[reg]);
705+
KUNIT_EXPECT_EQ(test, 0, regmap_read(map, reg, &val));
706+
KUNIT_EXPECT_EQ(test, data->vals[reg], val);
707+
KUNIT_EXPECT_FALSE(test, data->read[reg]);
708+
}
709+
710+
if (param->from_reg > 0)
711+
expect_reg_default_value(test, map, data, priv, 0);
712+
713+
if (defaults_end + 1 <= config.max_register)
714+
expect_reg_default_value(test, map, data, priv, defaults_end + 1);
715+
716+
if (config.max_register > defaults_end + 1)
717+
expect_reg_default_value(test, map, data, priv, config.max_register);
718+
}
719+
631720
static void reg_defaults_read_dev(struct kunit *test)
632721
{
633722
struct regmap *map;
@@ -2058,6 +2147,8 @@ static struct kunit_case regmap_test_cases[] = {
20582147
KUNIT_CASE_PARAM(write_readonly, regcache_types_gen_params),
20592148
KUNIT_CASE_PARAM(read_writeonly, regcache_types_gen_params),
20602149
KUNIT_CASE_PARAM(reg_defaults, regcache_types_gen_params),
2150+
KUNIT_CASE_PARAM(reg_default_callback_populates_flat_cache,
2151+
flat_cache_types_gen_params),
20612152
KUNIT_CASE_PARAM(reg_defaults_read_dev, regcache_types_gen_params),
20622153
KUNIT_CASE_PARAM(register_patch, regcache_types_gen_params),
20632154
KUNIT_CASE_PARAM(stride, regcache_types_gen_params),

‎drivers/base/regmap/regmap.c‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -813,6 +813,7 @@ struct regmap *__regmap_init(struct device *dev,
813813
map->precious_reg = config->precious_reg;
814814
map->writeable_noinc_reg = config->writeable_noinc_reg;
815815
map->readable_noinc_reg = config->readable_noinc_reg;
816+
map->reg_default_cb = config->reg_default_cb;
816817
map->cache_type = config->cache_type;
817818

818819
spin_lock_init(&map->async_lock);
@@ -1435,6 +1436,7 @@ int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
14351436
map->precious_reg = config->precious_reg;
14361437
map->writeable_noinc_reg = config->writeable_noinc_reg;
14371438
map->readable_noinc_reg = config->readable_noinc_reg;
1439+
map->reg_default_cb = config->reg_default_cb;
14381440
map->cache_type = config->cache_type;
14391441

14401442
ret = regmap_set_name(map, config);

‎include/linux/regmap.h‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -359,6 +359,10 @@ typedef void (*regmap_unlock)(void *);
359359
* @reg_defaults: Power on reset values for registers (for use with
360360
* register cache support).
361361
* @num_reg_defaults: Number of elements in reg_defaults.
362+
* @reg_default_cb: Optional callback to return default values for registers
363+
* not listed in reg_defaults. This is only used for
364+
* REGCACHE_FLAT population; drivers must ensure the readable_reg/
365+
* writeable_reg callbacks are defined to handle holes.
362366
*
363367
* @read_flag_mask: Mask to be set in the top bytes of the register when doing
364368
* a read.
@@ -449,6 +453,8 @@ struct regmap_config {
449453
const struct regmap_access_table *rd_noinc_table;
450454
const struct reg_default *reg_defaults;
451455
unsigned int num_reg_defaults;
456+
int (*reg_default_cb)(struct device *dev, unsigned int reg,
457+
unsigned int *def);
452458
enum regcache_type cache_type;
453459
const void *reg_defaults_raw;
454460
unsigned int num_reg_defaults_raw;
@@ -1349,6 +1355,14 @@ static inline int regmap_write_bits(struct regmap *map, unsigned int reg,
13491355
return regmap_update_bits_base(map, reg, mask, val, NULL, false, true);
13501356
}
13511357

1358+
static inline int regmap_default_zero_cb(struct device *dev,
1359+
unsigned int reg,
1360+
unsigned int *def)
1361+
{
1362+
*def = 0;
1363+
return 0;
1364+
}
1365+
13521366
int regmap_get_val_bytes(struct regmap *map);
13531367
int regmap_get_max_register(struct regmap *map);
13541368
int regmap_get_reg_stride(struct regmap *map);

0 commit comments

Comments
 (0)