Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f01ee60f authored by Stephen Warren's avatar Stephen Warren Committed by Mark Brown
Browse files

regmap: implement register striding 



regmap_config.reg_stride is introduced. All extant register addresses
are a multiple of this value. Users of serial-oriented regmap busses will
typically set this to 1. Users of the MMIO regmap bus will typically set
this based on the value size of their registers, in bytes, so 4 for a
32-bit register.

Throughout the regmap code, actual register addresses are used. Wherever
the register address is used to index some array of values, the address
is divided by the stride to determine the index, or vice-versa. Error-
checking is added to all entry-points for register address data to ensure
that register addresses actually satisfy the specified stride. The MMIO
bus ensures that the specified stride is large enough for the register
size.

Signed-off-by: default avatarStephen Warren <swarren@nvidia.com>
Signed-off-by: default avatarMark Brown <broonie@opensource.wolfsonmicro.com>
parent c0cc6fe1

drivers/base/regmap/internal.h

+1 −0
Original line number Diff line number Diff line
@@ -62,6 +62,7 @@ struct regmap { 


	/* number of bits to (left) shift the reg value when formatting*/

	int reg_shift;

	int reg_stride;



	/* regcache specific members */

	const struct regcache_ops *cache_ops;

drivers/base/regmap/regcache-lzo.c

+6 −5
Original line number Diff line number Diff line
@@ -108,7 +108,7 @@ static int regcache_lzo_decompress_cache_block(struct regmap *map, 
static inline int regcache_lzo_get_blkindex(struct regmap *map,

					    unsigned int reg)

{

	return (reg * map->cache_word_size) /

	return ((reg / map->reg_stride) * map->cache_word_size) /

		DIV_ROUND_UP(map->cache_size_raw,

			     regcache_lzo_block_count(map));

}
@@ -116,7 +116,8 @@ static inline int regcache_lzo_get_blkindex(struct regmap *map, 
static inline int regcache_lzo_get_blkpos(struct regmap *map,

					  unsigned int reg)

{

	return reg % (DIV_ROUND_UP(map->cache_size_raw,

	return (reg / map->reg_stride) %

		    (DIV_ROUND_UP(map->cache_size_raw,

				  regcache_lzo_block_count(map)) /

		     map->cache_word_size);

}
@@ -322,7 +323,7 @@ static int regcache_lzo_write(struct regmap *map, 
	}



	/* set the bit so we know we have to sync this register */

	set_bit(reg, lzo_block->sync_bmp);

	set_bit(reg / map->reg_stride, lzo_block->sync_bmp);

	kfree(tmp_dst);

	kfree(lzo_block->src);

	return 0;

drivers/base/regmap/regcache-rbtree.c

+23 −17
Original line number Diff line number Diff line
@@ -39,11 +39,12 @@ struct regcache_rbtree_ctx { 
};



static inline void regcache_rbtree_get_base_top_reg(

	struct regmap *map,

	struct regcache_rbtree_node *rbnode,

	unsigned int *base, unsigned int *top)

{

	*base = rbnode->base_reg;

	*top = rbnode->base_reg + rbnode->blklen - 1;

	*top = rbnode->base_reg + ((rbnode->blklen - 1) * map->reg_stride);

}



static unsigned int regcache_rbtree_get_register(
@@ -70,7 +71,8 @@ static struct regcache_rbtree_node *regcache_rbtree_lookup(struct regmap *map, 


	rbnode = rbtree_ctx->cached_rbnode;

	if (rbnode) {

		regcache_rbtree_get_base_top_reg(rbnode, &base_reg, &top_reg);

		regcache_rbtree_get_base_top_reg(map, rbnode, &base_reg,

						 &top_reg);

		if (reg >= base_reg && reg <= top_reg)

			return rbnode;

	}
@@ -78,7 +80,8 @@ static struct regcache_rbtree_node *regcache_rbtree_lookup(struct regmap *map, 
	node = rbtree_ctx->root.rb_node;

	while (node) {

		rbnode = container_of(node, struct regcache_rbtree_node, node);

		regcache_rbtree_get_base_top_reg(rbnode, &base_reg, &top_reg);

		regcache_rbtree_get_base_top_reg(map, rbnode, &base_reg,

						 &top_reg);

		if (reg >= base_reg && reg <= top_reg) {

			rbtree_ctx->cached_rbnode = rbnode;

			return rbnode;
@@ -92,7 +95,7 @@ static struct regcache_rbtree_node *regcache_rbtree_lookup(struct regmap *map, 
	return NULL;

}



static int regcache_rbtree_insert(struct rb_root *root,

static int regcache_rbtree_insert(struct regmap *map, struct rb_root *root,

				  struct regcache_rbtree_node *rbnode)

{

	struct rb_node **new, *parent;
@@ -106,7 +109,7 @@ static int regcache_rbtree_insert(struct rb_root *root, 
		rbnode_tmp = container_of(*new, struct regcache_rbtree_node,

					  node);

		/* base and top registers of the current rbnode */

		regcache_rbtree_get_base_top_reg(rbnode_tmp, &base_reg_tmp,

		regcache_rbtree_get_base_top_reg(map, rbnode_tmp, &base_reg_tmp,

						 &top_reg_tmp);

		/* base register of the rbnode to be added */

		base_reg = rbnode->base_reg;
@@ -138,7 +141,7 @@ static int rbtree_show(struct seq_file *s, void *ignored) 
	unsigned int base, top;

	int nodes = 0;

	int registers = 0;

	int average;

	int this_registers, average;



	map->lock(map);
@@ -146,11 +149,12 @@ static int rbtree_show(struct seq_file *s, void *ignored) 
	     node = rb_next(node)) {

		n = container_of(node, struct regcache_rbtree_node, node);



		regcache_rbtree_get_base_top_reg(n, &base, &top);

		seq_printf(s, "%x-%x (%d)\n", base, top, top - base + 1);

		regcache_rbtree_get_base_top_reg(map, n, &base, &top);

		this_registers = ((top - base) / map->reg_stride) + 1;

		seq_printf(s, "%x-%x (%d)\n", base, top, this_registers);



		nodes++;

		registers += top - base + 1;

		registers += this_registers;

	}



	if (nodes)
@@ -255,7 +259,7 @@ static int regcache_rbtree_read(struct regmap *map, 


	rbnode = regcache_rbtree_lookup(map, reg);

	if (rbnode) {

		reg_tmp = reg - rbnode->base_reg;

		reg_tmp = (reg - rbnode->base_reg) / map->reg_stride;

		*value = regcache_rbtree_get_register(rbnode, reg_tmp,

						      map->cache_word_size);

	} else {
@@ -310,7 +314,7 @@ static int regcache_rbtree_write(struct regmap *map, unsigned int reg, 
	 */

	rbnode = regcache_rbtree_lookup(map, reg);

	if (rbnode) {

		reg_tmp = reg - rbnode->base_reg;

		reg_tmp = (reg - rbnode->base_reg) / map->reg_stride;

		val = regcache_rbtree_get_register(rbnode, reg_tmp,

						   map->cache_word_size);

		if (val == value)
@@ -321,13 +325,15 @@ static int regcache_rbtree_write(struct regmap *map, unsigned int reg, 
		/* look for an adjacent register to the one we are about to add */

		for (node = rb_first(&rbtree_ctx->root); node;

		     node = rb_next(node)) {

			rbnode_tmp = rb_entry(node, struct regcache_rbtree_node, node);

			rbnode_tmp = rb_entry(node, struct regcache_rbtree_node,

					      node);

			for (i = 0; i < rbnode_tmp->blklen; i++) {

				reg_tmp = rbnode_tmp->base_reg + i;

				if (abs(reg_tmp - reg) != 1)

				reg_tmp = rbnode_tmp->base_reg +

						(i * map->reg_stride);

				if (abs(reg_tmp - reg) != map->reg_stride)

					continue;

				/* decide where in the block to place our register */

				if (reg_tmp + 1 == reg)

				if (reg_tmp + map->reg_stride == reg)

					pos = i + 1;

				else

					pos = i;
@@ -357,7 +363,7 @@ static int regcache_rbtree_write(struct regmap *map, unsigned int reg, 
			return -ENOMEM;

		}

		regcache_rbtree_set_register(rbnode, 0, value, map->cache_word_size);

		regcache_rbtree_insert(&rbtree_ctx->root, rbnode);

		regcache_rbtree_insert(map, &rbtree_ctx->root, rbnode);

		rbtree_ctx->cached_rbnode = rbnode;

	}
@@ -397,7 +403,7 @@ static int regcache_rbtree_sync(struct regmap *map, unsigned int min, 
			end = rbnode->blklen;



		for (i = base; i < end; i++) {

			regtmp = rbnode->base_reg + i;

			regtmp = rbnode->base_reg + (i * map->reg_stride);

			val = regcache_rbtree_get_register(rbnode, i,

							   map->cache_word_size);

drivers/base/regmap/regcache.c

+11 −3
Original line number Diff line number Diff line
@@ -59,7 +59,7 @@ static int regcache_hw_init(struct regmap *map) 
	for (count = 0, i = 0; i < map->num_reg_defaults_raw; i++) {

		val = regcache_get_val(map->reg_defaults_raw,

				       i, map->cache_word_size);

		if (regmap_volatile(map, i))

		if (regmap_volatile(map, i * map->reg_stride))

			continue;

		count++;

	}
@@ -76,9 +76,9 @@ static int regcache_hw_init(struct regmap *map) 
	for (i = 0, j = 0; i < map->num_reg_defaults_raw; i++) {

		val = regcache_get_val(map->reg_defaults_raw,

				       i, map->cache_word_size);

		if (regmap_volatile(map, i))

		if (regmap_volatile(map, i * map->reg_stride))

			continue;

		map->reg_defaults[j].reg = i;

		map->reg_defaults[j].reg = i * map->reg_stride;

		map->reg_defaults[j].def = val;

		j++;

	}
@@ -98,6 +98,10 @@ int regcache_init(struct regmap *map, const struct regmap_config *config) 
	int i;

	void *tmp_buf;



	for (i = 0; i < config->num_reg_defaults; i++)

		if (config->reg_defaults[i].reg % map->reg_stride)

			return -EINVAL;



	if (map->cache_type == REGCACHE_NONE) {

		map->cache_bypass = true;

		return 0;
@@ -278,6 +282,10 @@ int regcache_sync(struct regmap *map) 
	/* Apply any patch first */

	map->cache_bypass = 1;

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

		if (map->patch[i].reg % map->reg_stride) {

			ret = -EINVAL;

			goto out;

		}

		ret = _regmap_write(map, map->patch[i].reg, map->patch[i].def);

		if (ret != 0) {

			dev_err(map->dev, "Failed to write %x = %x: %d\n",

drivers/base/regmap/regmap-debugfs.c

+2 −2
Original line number Diff line number Diff line
@@ -80,7 +80,7 @@ static ssize_t regmap_map_read_file(struct file *file, char __user *user_buf, 
	val_len = 2 * map->format.val_bytes;

	tot_len = reg_len + val_len + 3;      /* : \n */



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

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

		if (!regmap_readable(map, i))

			continue;
@@ -197,7 +197,7 @@ static ssize_t regmap_access_read_file(struct file *file, 
	reg_len = regmap_calc_reg_len(map->max_register, buf, count);

	tot_len = reg_len + 10; /* ': R W V P\n' */



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

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

		/* Ignore registers which are neither readable nor writable */

		if (!regmap_readable(map, i) && !regmap_writeable(map, i))

			continue;