regmap: cache: Pass the map rather than the word size when updating values

It's more idiomatic to pass the map structure around and this means we
can use other bits of information from the map.

Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>

1 files changed, 25 insertions, 26 deletions

diff --git a/drivers/base/regmap/regcache-rbtree.c b/drivers/base/regmap/regcache-rbtree.c
index 3f21c6ab296f..461cff888bb1 100644
--- a/drivers/base/regmap/regcache-rbtree.c
+++ b/drivers/base/regmap/regcache-rbtree.c
@@ -47,22 +47,21 @@ static inline void regcache_rbtree_get_base_top_reg(
         *top = rbnode->base_reg + ((rbnode->blklen - 1) * map->reg_stride);
 }
 
-static unsigned int regcache_rbtree_get_register(
-        struct regcache_rbtree_node *rbnode, unsigned int idx,
-        unsigned int word_size)
+static unsigned int regcache_rbtree_get_register(struct regmap *map,
+        struct regcache_rbtree_node *rbnode, unsigned int idx)
 {
-        return regcache_get_val(rbnode->block, idx, word_size);
+        return regcache_get_val(map, rbnode->block, idx);
 }
 
-static void regcache_rbtree_set_register(struct regcache_rbtree_node *rbnode,
-                                         unsigned int idx, unsigned int val,
-                                         unsigned int word_size)
+static void regcache_rbtree_set_register(struct regmap *map,
+                                         struct regcache_rbtree_node *rbnode,
+                                         unsigned int idx, unsigned int val)
 {
-        regcache_set_val(rbnode->block, idx, val, word_size);
+        regcache_set_val(map, rbnode->block, idx, val);
 }
 
 static struct regcache_rbtree_node *regcache_rbtree_lookup(struct regmap *map,
-        unsigned int reg)
+                                                           unsigned int reg)
 {
         struct regcache_rbtree_ctx *rbtree_ctx = map->cache;
         struct rb_node *node;
@@ -260,8 +259,7 @@ static int regcache_rbtree_read(struct regmap *map,
         rbnode = regcache_rbtree_lookup(map, reg);
         if (rbnode) {
                 reg_tmp = (reg - rbnode->base_reg) / map->reg_stride;
-                *value = regcache_rbtree_get_register(rbnode, reg_tmp,
-                                                      map->cache_word_size);
+                *value = regcache_rbtree_get_register(map, rbnode, reg_tmp);
         } else {
                 return -ENOENT;
         }
@@ -270,21 +268,23 @@ static int regcache_rbtree_read(struct regmap *map,
 }
 
 
-static int regcache_rbtree_insert_to_block(struct regcache_rbtree_node *rbnode,
+static int regcache_rbtree_insert_to_block(struct regmap *map,
+                                           struct regcache_rbtree_node *rbnode,
                                            unsigned int pos, unsigned int reg,
-                                           unsigned int value, unsigned int word_size)
+                                           unsigned int value)
 {
         u8 *blk;
 
         blk = krealloc(rbnode->block,
-                       (rbnode->blklen + 1) * word_size, GFP_KERNEL);
+                       (rbnode->blklen + 1) * map->cache_word_size,
+                       GFP_KERNEL);
         if (!blk)
                 return -ENOMEM;
 
         /* insert the register value in the correct place in the rbnode block */
-        memmove(blk + (pos + 1) * word_size,
-                blk + pos * word_size,
-                (rbnode->blklen - pos) * word_size);
+        memmove(blk + (pos + 1) * map->cache_word_size,
+                blk + pos * map->cache_word_size,
+                (rbnode->blklen - pos) * map->cache_word_size);
 
         /* update the rbnode block, its size and the base register */
         rbnode->block = blk;
@@ -292,7 +292,7 @@ static int regcache_rbtree_insert_to_block(struct regcache_rbtree_node *rbnode,
         if (!pos)
                 rbnode->base_reg = reg;
 
-        regcache_rbtree_set_register(rbnode, pos, value, word_size);
+        regcache_rbtree_set_register(map, rbnode, pos, value);
         return 0;
 }
 
@@ -314,8 +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) / map->reg_stride;
-                regcache_rbtree_set_register(rbnode, reg_tmp, value,
-                                             map->cache_word_size);
+                regcache_rbtree_set_register(map, rbnode, reg_tmp, value);
         } else {
                 /* look for an adjacent register to the one we are about to add */
                 for (node = rb_first(&rbtree_ctx->root); node;
@@ -332,9 +331,10 @@ static int regcache_rbtree_write(struct regmap *map, unsigned int reg,
                                         pos = i + 1;
                                 else
                                         pos = i;
-                                ret = regcache_rbtree_insert_to_block(rbnode_tmp, pos,
-                                                                      reg, value,
-                                                                      map->cache_word_size);
+                                ret = regcache_rbtree_insert_to_block(map,
+                                                                      rbnode_tmp,
+                                                                      pos, reg,
+                                                                      value);
                                 if (ret)
                                         return ret;
                                 rbtree_ctx->cached_rbnode = rbnode_tmp;
@@ -357,7 +357,7 @@ static int regcache_rbtree_write(struct regmap *map, unsigned int reg,
                         kfree(rbnode);
                         return -ENOMEM;
                 }
-                regcache_rbtree_set_register(rbnode, 0, value, map->cache_word_size);
+                regcache_rbtree_set_register(map, rbnode, 0, value);
                 regcache_rbtree_insert(map, &rbtree_ctx->root, rbnode);
                 rbtree_ctx->cached_rbnode = rbnode;
         }
@@ -399,8 +399,7 @@ static int regcache_rbtree_sync(struct regmap *map, unsigned int min,
 
                 for (i = base; i < end; i++) {
                         regtmp = rbnode->base_reg + (i * map->reg_stride);
-                        val = regcache_rbtree_get_register(rbnode, i,
-                                                           map->cache_word_size);
+                        val = regcache_rbtree_get_register(map, rbnode, i);
 
                         /* Is this the hardware default?  If so skip. */
                         ret = regcache_lookup_reg(map, regtmp);