Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 879082c9fe6e8fbddf787170eee605e4be138d0f

Authored by Mark Brown
1 parent 66baf40757
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

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>

Showing 4 changed files with 39 additions and 44 deletions Side-by-side Diff

drivers/base/regmap/internal.h
Diff comments   View file @ 879082c
... ... @@ -188,10 +188,10 @@
188 188 unsigned int reg, unsigned int value);
189 189 int regcache_sync(struct regmap *map);
190 190  
191   -unsigned int regcache_get_val(const void *base, unsigned int idx,
192   - unsigned int word_size);
193   -bool regcache_set_val(void *base, unsigned int idx,
194   - unsigned int val, unsigned int word_size);
  191 +unsigned int regcache_get_val(struct regmap *map, const void *base,
  192 + unsigned int idx);
  193 +bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,
  194 + unsigned int val);
195 195 int regcache_lookup_reg(struct regmap *map, unsigned int reg);
196 196  
197 197 void regmap_async_complete_cb(struct regmap_async *async, int ret);
drivers/base/regmap/regcache-lzo.c
Diff comments   View file @ 879082c
... ... @@ -260,8 +260,7 @@
260 260 ret = regcache_lzo_decompress_cache_block(map, lzo_block);
261 261 if (ret >= 0)
262 262 /* fetch the value from the cache */
263   - *value = regcache_get_val(lzo_block->dst, blkpos,
264   - map->cache_word_size);
  263 + *value = regcache_get_val(map, lzo_block->dst, blkpos);
265 264  
266 265 kfree(lzo_block->dst);
267 266 /* restore the pointer and length of the compressed block */
... ... @@ -304,8 +303,7 @@
304 303 }
305 304  
306 305 /* write the new value to the cache */
307   - if (regcache_set_val(lzo_block->dst, blkpos, value,
308   - map->cache_word_size)) {
  306 + if (regcache_set_val(map, lzo_block->dst, blkpos, value)) {
309 307 kfree(lzo_block->dst);
310 308 goto out;
311 309 }
drivers/base/regmap/regcache-rbtree.c
Diff comments   View file @ 879082c
... ... @@ -47,22 +47,21 @@
47 47 *top = rbnode->base_reg + ((rbnode->blklen - 1) * map->reg_stride);
48 48 }
49 49  
50   -static unsigned int regcache_rbtree_get_register(
51   - struct regcache_rbtree_node *rbnode, unsigned int idx,
52   - unsigned int word_size)
  50 +static unsigned int regcache_rbtree_get_register(struct regmap *map,
  51 + struct regcache_rbtree_node *rbnode, unsigned int idx)
53 52 {
54   - return regcache_get_val(rbnode->block, idx, word_size);
  53 + return regcache_get_val(map, rbnode->block, idx);
55 54 }
56 55  
57   -static void regcache_rbtree_set_register(struct regcache_rbtree_node *rbnode,
58   - unsigned int idx, unsigned int val,
59   - unsigned int word_size)
  56 +static void regcache_rbtree_set_register(struct regmap *map,
  57 + struct regcache_rbtree_node *rbnode,
  58 + unsigned int idx, unsigned int val)
60 59 {
61   - regcache_set_val(rbnode->block, idx, val, word_size);
  60 + regcache_set_val(map, rbnode->block, idx, val);
62 61 }
63 62  
64 63 static struct regcache_rbtree_node *regcache_rbtree_lookup(struct regmap *map,
65   - unsigned int reg)
  64 + unsigned int reg)
66 65 {
67 66 struct regcache_rbtree_ctx *rbtree_ctx = map->cache;
68 67 struct rb_node *node;
... ... @@ -260,8 +259,7 @@
260 259 rbnode = regcache_rbtree_lookup(map, reg);
261 260 if (rbnode) {
262 261 reg_tmp = (reg - rbnode->base_reg) / map->reg_stride;
263   - *value = regcache_rbtree_get_register(rbnode, reg_tmp,
264   - map->cache_word_size);
  262 + *value = regcache_rbtree_get_register(map, rbnode, reg_tmp);
265 263 } else {
266 264 return -ENOENT;
267 265 }
268 266  
269 267  
270 268  
... ... @@ -270,21 +268,23 @@
270 268 }
271 269  
272 270  
273   -static int regcache_rbtree_insert_to_block(struct regcache_rbtree_node *rbnode,
  271 +static int regcache_rbtree_insert_to_block(struct regmap *map,
  272 + struct regcache_rbtree_node *rbnode,
274 273 unsigned int pos, unsigned int reg,
275   - unsigned int value, unsigned int word_size)
  274 + unsigned int value)
276 275 {
277 276 u8 *blk;
278 277  
279 278 blk = krealloc(rbnode->block,
280   - (rbnode->blklen + 1) * word_size, GFP_KERNEL);
  279 + (rbnode->blklen + 1) * map->cache_word_size,
  280 + GFP_KERNEL);
281 281 if (!blk)
282 282 return -ENOMEM;
283 283  
284 284 /* insert the register value in the correct place in the rbnode block */
285   - memmove(blk + (pos + 1) * word_size,
286   - blk + pos * word_size,
287   - (rbnode->blklen - pos) * word_size);
  285 + memmove(blk + (pos + 1) * map->cache_word_size,
  286 + blk + pos * map->cache_word_size,
  287 + (rbnode->blklen - pos) * map->cache_word_size);
288 288  
289 289 /* update the rbnode block, its size and the base register */
290 290 rbnode->block = blk;
... ... @@ -292,7 +292,7 @@
292 292 if (!pos)
293 293 rbnode->base_reg = reg;
294 294  
295   - regcache_rbtree_set_register(rbnode, pos, value, word_size);
  295 + regcache_rbtree_set_register(map, rbnode, pos, value);
296 296 return 0;
297 297 }
298 298  
... ... @@ -314,8 +314,7 @@
314 314 rbnode = regcache_rbtree_lookup(map, reg);
315 315 if (rbnode) {
316 316 reg_tmp = (reg - rbnode->base_reg) / map->reg_stride;
317   - regcache_rbtree_set_register(rbnode, reg_tmp, value,
318   - map->cache_word_size);
  317 + regcache_rbtree_set_register(map, rbnode, reg_tmp, value);
319 318 } else {
320 319 /* look for an adjacent register to the one we are about to add */
321 320 for (node = rb_first(&rbtree_ctx->root); node;
... ... @@ -332,9 +331,10 @@
332 331 pos = i + 1;
333 332 else
334 333 pos = i;
335   - ret = regcache_rbtree_insert_to_block(rbnode_tmp, pos,
336   - reg, value,
337   - map->cache_word_size);
  334 + ret = regcache_rbtree_insert_to_block(map,
  335 + rbnode_tmp,
  336 + pos, reg,
  337 + value);
338 338 if (ret)
339 339 return ret;
340 340 rbtree_ctx->cached_rbnode = rbnode_tmp;
... ... @@ -357,7 +357,7 @@
357 357 kfree(rbnode);
358 358 return -ENOMEM;
359 359 }
360   - regcache_rbtree_set_register(rbnode, 0, value, map->cache_word_size);
  360 + regcache_rbtree_set_register(map, rbnode, 0, value);
361 361 regcache_rbtree_insert(map, &rbtree_ctx->root, rbnode);
362 362 rbtree_ctx->cached_rbnode = rbnode;
363 363 }
... ... @@ -399,8 +399,7 @@
399 399  
400 400 for (i = base; i < end; i++) {
401 401 regtmp = rbnode->base_reg + (i * map->reg_stride);
402   - val = regcache_rbtree_get_register(rbnode, i,
403   - map->cache_word_size);
  402 + val = regcache_rbtree_get_register(map, rbnode, i);
404 403  
405 404 /* Is this the hardware default? If so skip. */
406 405 ret = regcache_lookup_reg(map, regtmp);
drivers/base/regmap/regcache.c
Diff comments   View file @ 879082c
... ... @@ -58,8 +58,7 @@
58 58  
59 59 /* calculate the size of reg_defaults */
60 60 for (count = 0, i = 0; i < map->num_reg_defaults_raw; i++) {
61   - val = regcache_get_val(map->reg_defaults_raw,
62   - i, map->cache_word_size);
  61 + val = regcache_get_val(map, map->reg_defaults_raw, i);
63 62 if (regmap_volatile(map, i * map->reg_stride))
64 63 continue;
65 64 count++;
... ... @@ -75,8 +74,7 @@
75 74 /* fill the reg_defaults */
76 75 map->num_reg_defaults = count;
77 76 for (i = 0, j = 0; i < map->num_reg_defaults_raw; i++) {
78   - val = regcache_get_val(map->reg_defaults_raw,
79   - i, map->cache_word_size);
  77 + val = regcache_get_val(map, map->reg_defaults_raw, i);
80 78 if (regmap_volatile(map, i * map->reg_stride))
81 79 continue;
82 80 map->reg_defaults[j].reg = i * map->reg_stride;
83 81  
... ... @@ -417,10 +415,10 @@
417 415 }
418 416 EXPORT_SYMBOL_GPL(regcache_cache_bypass);
419 417  
420   -bool regcache_set_val(void *base, unsigned int idx,
421   - unsigned int val, unsigned int word_size)
  418 +bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,
  419 + unsigned int val)
422 420 {
423   - switch (word_size) {
  421 + switch (map->cache_word_size) {
424 422 case 1: {
425 423 u8 *cache = base;
426 424 if (cache[idx] == val)
427 425  
... ... @@ -448,13 +446,13 @@
448 446 return false;
449 447 }
450 448  
451   -unsigned int regcache_get_val(const void *base, unsigned int idx,
452   - unsigned int word_size)
  449 +unsigned int regcache_get_val(struct regmap *map, const void *base,
  450 + unsigned int idx)
453 451 {
454 452 if (!base)
455 453 return -EINVAL;
456 454  
457   - switch (word_size) {
  455 + switch (map->cache_word_size) {
458 456 case 1: {
459 457 const u8 *cache = base;
460 458 return cache[idx];