Commit d5cbd9f3 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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
parents be653d2d 4651c87b

drivers/base/regmap/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -5,7 +5,7 @@ 


config REGMAP

	bool

	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)

	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)

	help

	  Enable support for the Register Map (regmap) access API.

drivers/base/regmap/internal.h

+3 −0
Original line number Diff line number Diff line
@@ -117,6 +117,9 @@ struct regmap { 
		    void *val_buf, size_t val_size);

	int (*write)(void *context, const void *data, size_t count);



	int (*reg_default_cb)(struct device *dev, unsigned int reg,

			      unsigned int *val);



	unsigned long read_flag_mask;

	unsigned long write_flag_mask;

drivers/base/regmap/regcache-flat.c

+19 −0
Original line number Diff line number Diff line
@@ -79,6 +79,25 @@ static int regcache_flat_populate(struct regmap *map) 
		__set_bit(index, cache->valid);

	}



	if (map->reg_default_cb) {

		dev_dbg(map->dev,

			"Populating regcache_flat using reg_default_cb callback\n");



		for (i = 0; i <= map->max_register; i += map->reg_stride) {

			unsigned int index = regcache_flat_get_index(map, i);

			unsigned int value;



			if (test_bit(index, cache->valid))

				continue;



			if (map->reg_default_cb(map->dev, i, &value))

				continue;



			cache->data[index] = value;

			__set_bit(index, cache->valid);

		}

	}



	return 0;

}

drivers/base/regmap/regcache.c

+3 −2
Original line number Diff line number Diff line
@@ -73,7 +73,7 @@ static int regcache_hw_init(struct regmap *map) 


	if (!map->reg_defaults_raw) {

		bool cache_bypass = map->cache_bypass;

		dev_warn(map->dev, "No cache defaults, reading back from HW\n");

		dev_dbg(map->dev, "No cache defaults, reading back from HW\n");



		/* Bypass the cache access till data read from HW */

		map->cache_bypass = true;
@@ -223,7 +223,8 @@ int regcache_init(struct regmap *map, const struct regmap_config *config) 
			goto err_free;

	}



	if (map->num_reg_defaults && map->cache_ops->populate) {

	if (map->cache_ops->populate &&

	    (map->num_reg_defaults || map->reg_default_cb)) {

		dev_dbg(map->dev, "Populating %s cache\n", map->cache_ops->name);

		map->lock(map->lock_arg);

		ret = map->cache_ops->populate(map);

drivers/base/regmap/regmap-kunit.c

+91 −0
Original line number Diff line number Diff line
@@ -15,6 +15,8 @@ KUNIT_DEFINE_ACTION_WRAPPER(regmap_exit_action, regmap_exit, struct regmap *); 


struct regmap_test_priv {

	struct device *dev;

	bool *reg_default_called;

	unsigned int reg_default_max;

};



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


KUNIT_ARRAY_PARAM(real_cache_types_only, real_cache_types_only_list, param_to_desc);



static const struct regmap_test_param flat_cache_types_list[] = {

	{ .cache = REGCACHE_FLAT, .from_reg = 0 },

	{ .cache = REGCACHE_FLAT, .from_reg = 0, .fast_io = true },

	{ .cache = REGCACHE_FLAT, .from_reg = 0x2001 },

};



KUNIT_ARRAY_PARAM(flat_cache_types, flat_cache_types_list, param_to_desc);



static const struct regmap_test_param real_cache_types_list[] = {

	{ .cache = REGCACHE_FLAT,   .from_reg = 0 },

	{ .cache = REGCACHE_FLAT,   .from_reg = 0, .fast_io = true },
@@ -248,6 +258,37 @@ static bool reg_5_false(struct device *dev, unsigned int reg) 
	return reg != (param->from_reg + 5);

}



static unsigned int reg_default_expected(unsigned int reg)

{

	return 0x5a5a0000 | (reg & 0xffff);

}



static int reg_default_test_cb(struct device *dev, unsigned int reg,

			       unsigned int *def)

{

	struct kunit *test = dev_get_drvdata(dev);

	struct regmap_test_priv *priv = test->priv;



	if (priv && priv->reg_default_called && reg <= priv->reg_default_max)

		priv->reg_default_called[reg] = true;



	*def = reg_default_expected(reg);

	return 0;

}



static void expect_reg_default_value(struct kunit *test, struct regmap *map,

				     struct regmap_ram_data *data,

				     struct regmap_test_priv *priv,

				     unsigned int reg)

{

	unsigned int val;



	KUNIT_EXPECT_TRUE(test, priv->reg_default_called[reg]);

	KUNIT_EXPECT_EQ(test, 0, regmap_read(map, reg, &val));

	KUNIT_EXPECT_EQ(test, reg_default_expected(reg), val);

	KUNIT_EXPECT_FALSE(test, data->read[reg]);

}



static void basic_read_write(struct kunit *test)

{

	struct regmap *map;
@@ -628,6 +669,54 @@ static void reg_defaults(struct kunit *test) 
		KUNIT_EXPECT_EQ(test, config.cache_type == REGCACHE_NONE, data->read[i]);

}



static void reg_default_callback_populates_flat_cache(struct kunit *test)

{

	const struct regmap_test_param *param = test->param_value;

	struct regmap_test_priv *priv = test->priv;

	struct regmap *map;

	struct regmap_config config;

	struct regmap_ram_data *data;

	unsigned int reg, val;

	unsigned int defaults_end;



	config = test_regmap_config;

	config.num_reg_defaults = 3;

	config.max_register = param->from_reg + BLOCK_TEST_SIZE - 1;

	config.reg_default_cb = reg_default_test_cb;



	priv->reg_default_max = config.max_register;

	priv->reg_default_called = kunit_kcalloc(test, config.max_register + 1,

						 sizeof(*priv->reg_default_called),

						 GFP_KERNEL);

	KUNIT_ASSERT_NOT_NULL(test, priv->reg_default_called);



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

	KUNIT_ASSERT_FALSE(test, IS_ERR(map));

	if (IS_ERR(map))

		return;



	for (reg = 0; reg <= config.max_register; reg++)

		data->read[reg] = false;



	defaults_end = param->from_reg + config.num_reg_defaults - 1;



	for (reg = param->from_reg; reg <= defaults_end; reg++) {

		KUNIT_EXPECT_FALSE(test, priv->reg_default_called[reg]);

		KUNIT_EXPECT_EQ(test, 0, regmap_read(map, reg, &val));

		KUNIT_EXPECT_EQ(test, data->vals[reg], val);

		KUNIT_EXPECT_FALSE(test, data->read[reg]);

	}



	if (param->from_reg > 0)

		expect_reg_default_value(test, map, data, priv, 0);



	if (defaults_end + 1 <= config.max_register)

		expect_reg_default_value(test, map, data, priv, defaults_end + 1);



	if (config.max_register > defaults_end + 1)

		expect_reg_default_value(test, map, data, priv, config.max_register);

}



static void reg_defaults_read_dev(struct kunit *test)

{

	struct regmap *map;
@@ -2058,6 +2147,8 @@ static struct kunit_case regmap_test_cases[] = { 
	KUNIT_CASE_PARAM(write_readonly, regcache_types_gen_params),

	KUNIT_CASE_PARAM(read_writeonly, regcache_types_gen_params),

	KUNIT_CASE_PARAM(reg_defaults, regcache_types_gen_params),

	KUNIT_CASE_PARAM(reg_default_callback_populates_flat_cache,

			 flat_cache_types_gen_params),

	KUNIT_CASE_PARAM(reg_defaults_read_dev, regcache_types_gen_params),

	KUNIT_CASE_PARAM(register_patch, regcache_types_gen_params),

	KUNIT_CASE_PARAM(stride, regcache_types_gen_params),