regmap: cache: Factor out reg_present support from rbtree cache
Subsystems (2)
PATCH 1/4 regmap: cache: Factor out reg_present support from rbtree cache
The idea of maintaining a bitmap of present registers is something that can usefully be used by other cache types that maintain blocks of cached registers so move the code out of the rbtree cache and into the generic regcache code.
Refactor the interface slightly as we go to wrap the set bit and enlarge bitmap operations (since we never do one without the other) and make it more robust for reads of uncached registers by bounds checking before we look at the bitmap.
--- drivers/base/regmap/internal.h | 13 +++++++ drivers/base/regmap/regcache-rbtree.c | 60 ++------------------------------- drivers/base/regmap/regcache.c | 39 +++++++++++++++++++++ 3 files changed, 54 insertions(+), 58 deletions(-)
drivers/base/regmap/internal.h +13 -0
@@ -127,6 +127,9 @@ struct regmap {void *cache;u32 cache_dirty; +unsigned long *cache_present; +unsigned int cache_present_nbits; +struct reg_default *patch;int patch_regs;
@@ -202,6 +205,16 @@ unsigned int regcache_get_val(struct regmap *map, const void *base,bool regcache_set_val (struct regmap *map,void *base,unsigned int idx,unsigned int val);int regcache_lookup_reg (struct regmap *map,unsigned int reg); +int regcache_set_reg_present (struct regmap *map,unsigned int reg); + +static inline bool regcache_reg_present (struct regmap *map,unsigned int reg) +{ +if (!map->cache_present) +return true; +if (reg > map->cache_present_nbits) +return false; +return map->cache_present[BIT_WORD (reg)] &BIT_MASK (reg); +}int _regmap_raw_write (struct regmap *map,unsigned int reg,const void *val,size_t val_len,bool async);
drivers/base/regmap/regcache-rbtree.c +2 -58
104 lines not on this page · raw message
drivers/base/regmap/regcache.c +39 -0
@@ -121,6 +121,8 @@ int regcache_init(struct regmap *map, const struct regmap_config *config) map->reg_defaults_raw = config->reg_defaults_raw; map->cache_word_size =DIV_ROUND_UP (config->val_bits,8 ); map->cache_size_raw = map->cache_word_size * config->num_reg_defaults_raw; + map->cache_present =NULL ; + map->cache_present_nbits =0 ; map->cache =NULL ; map->cache_ops = cache_types[i];
@@ -179,6 +181,7 @@ void regcache_exit(struct regmap *map)BUG_ON (!map->cache_ops); +kfree (map->cache_present);kfree (map->reg_defaults);if (map->cache_free)kfree (map->reg_defaults_raw);
@@ -415,6 +418,42 @@ void regcache_cache_bypass(struct regmap *map, bool enable) }EXPORT_SYMBOL_GPL (regcache_cache_bypass); +int regcache_set_reg_present (struct regmap *map,unsigned int reg) +{ +unsigned long *cache_present; +unsigned int cache_present_size; +unsigned int nregs; +int i; + + nregs = reg +1 ; + cache_present_size =BITS_TO_LONGS (nregs); + cache_present_size *=sizeof (long ); + +if (!map->cache_present) { + cache_present =kmalloc (cache_present_size,GFP_KERNEL ); +if (!cache_present) +return -ENOMEM ; +bitmap_zero (cache_present, nregs); + map->cache_present = cache_present; + map->cache_present_nbits = nregs; + } + +if (nregs > map->cache_present_nbits) { + cache_present =krealloc (map->cache_present, + cache_present_size,GFP_KERNEL ); +if (!cache_present) +return -ENOMEM ; +for (i =0 ; i < nregs; i++) +if (i >= map->cache_present_nbits) +clear_bit (i, cache_present); + map->cache_present = cache_present; + map->cache_present_nbits = nregs; + } + +set_bit (reg, map->cache_present); +return 0 ; +} +bool regcache_set_val (struct regmap *map,void *base,unsigned int idx,unsigned int val) {
Signature · 1 line
1.7.10.4
PATCH 2/4 regmap: cache: Factor out block sync
The idea of holding blocks of registers in device format is shared between at least rbtree and lzo cache formats so split out the loop that does the sync from the rbtree code so optimisations on it can be reused.
--- drivers/base/regmap/internal.h | 3 +++ drivers/base/regmap/regcache-rbtree.c | 48 +++++---------------------------- drivers/base/regmap/regcache.c | 42 +++++++++++++++++++++++++++++ 3 files changed, 51 insertions(+), 42 deletions(-)
drivers/base/regmap/internal.h +3 -0
@@ -192,6 +192,9 @@ int regcache_read(struct regmap *map,int regcache_write (struct regmap *map,unsigned int reg,unsigned int value);int regcache_sync (struct regmap *map); +int regcache_sync_block (struct regmap *map,void *block, +unsigned int block_base,unsigned int start, +unsigned int end); static inline const void *regcache_get_val_addr(struct regmap *map, const void *base,
drivers/base/regmap/regcache-rbtree.c +6 -42
69 lines not on this page · raw message
drivers/base/regmap/regcache.c +42 -0
45 lines not on this page · raw message
Signature · 1 line
1.7.10.4
Re: [PATCH 2/4] regmap: cache: Factor out block sync
Quoted 5 lines · Mark Brown
The idea of holding blocks of registers in device format is shared between at least rbtree and lzo cache formats so split out the loop that does the sync from the rbtree code so optimisations on it can be reused.
Signed-off-by Mark Brown <[email protected]>
PATCH 3/4 regmap: cache: Split raw and non-raw syncs
In reply to Mark BrownFor code clarity after implementing block writes split out the raw and non-raw I/O sync implementations.
--- drivers/base/regmap/regcache.c | 64 +++++++++++++++++++++++++++++++++------- 1 file changed, 53 insertions(+), 11 deletions(-)
drivers/base/regmap/regcache.c +53 -11
@@ -545,9 +545,43 @@ int regcache_lookup_reg(struct regmap *map, unsigned int reg)return -ENOENT ; } -int regcache_sync_block (struct regmap *map,void *block, -unsigned int block_base,unsigned int start, -unsigned int end) +static int regcache_sync_block_single (struct regmap *map,void *block, +unsigned int block_base, +unsigned int start,unsigned int end) +{ +unsigned int i, regtmp, val; +int ret; + +for (i = start; i < end; i++) { + regtmp = block_base + (i * map->reg_stride); + +if (!regcache_reg_present (map, regtmp)) +continue ; + + val =regcache_get_val (map, block, i); + +/* Is this the hardware default? If so skip. */ + ret =regcache_lookup_reg (map, regtmp); +if (ret >=0 && val == map->reg_defaults[ret].def) +continue ; + + map->cache_bypass =1 ; + + ret =_regmap_write (map, regtmp, val); + + map->cache_bypass =0 ; +if (ret !=0 ) +return ret; +dev_dbg (map->dev,"Synced register %#x, value %#x\n" , + regtmp, val); + } + +return 0 ; +} + +int regcache_sync_block_raw (struct regmap *map,void *block, +unsigned int block_base,unsigned int start, +unsigned int end) {unsigned int i, regtmp, val;const void *addr;
@@ -568,14 +602,10 @@ int regcache_sync_block(struct regmap *map, void *block, map->cache_bypass =1 ; -if (regmap_can_raw_write (map)) { - addr =regcache_get_val_addr (map, block, i); - ret =_regmap_raw_write (map, regtmp, addr, - map->format.val_bytes, - false); - }else { - ret =_regmap_write (map, regtmp, val); - } + addr =regcache_get_val_addr (map, block, i); + ret =_regmap_raw_write (map, regtmp, addr, + map->format.val_bytes, + false); map->cache_bypass =0 ;if (ret !=0 )
@@ -586,3 +616,15 @@ int regcache_sync_block(struct regmap *map, void *block,return 0 ; } + +int regcache_sync_block (struct regmap *map,void *block, +unsigned int block_base,unsigned int start, +unsigned int end) +{ +if (regmap_can_raw_write (map)) +return regcache_sync_block_raw (map, block, block_base, + start, end); +else +return regcache_sync_block_single (map, block, block_base, + start, end); +}
Signature · 1 line
1.7.10.4
Re: [PATCH 3/4] regmap: cache: Split raw and non-raw syncs
Quoted 4 lines · Mark Brown
For code clarity after implementing block writes split out the raw and non-raw I/O sync implementations.
Signed-off-by Mark Brown <[email protected]>
PATCH 4/4 regmap: cache: Write consecutive registers in a single block write
In reply to Mark BrownWhen syncing blocks of data using raw writes combine the writes into a single block write, saving us bus overhead for setup, addressing and teardown.
Currently the block write is done unconditionally as it is expected that hardware which has a register format which can support raw writes will support auto incrementing writes, this decision may need to be revised in future.
--- drivers/base/regmap/regcache.c | 64 +++++++++++++++++++++++++++++----------- 1 file changed, 47 insertions(+), 17 deletions(-)
drivers/base/regmap/regcache.c +47 -17
@@ -579,42 +579,72 @@ static int regcache_sync_block_single(struct regmap *map, void *block,return 0 ; } +static int regcache_sync_block_raw_flush (struct regmap *map,const void **data, +unsigned int base,unsigned int cur) +{ +size_t val_bytes = map->format.val_bytes; +int ret, count; + +if (*data ==NULL ) +return 0 ; + + count = cur - base; + +dev_dbg (map->dev,"Writing %d bytes for %d registers from 0x%x-0x%x\n" , + count * val_bytes, count, base, cur -1 ); + + map->cache_bypass =1 ; + + ret =_regmap_raw_write (map, base, *data, count * val_bytes, + false); + + map->cache_bypass =0 ; + + *data =NULL ; + +return ret; +} +int regcache_sync_block_raw (struct regmap *map,void *block,unsigned int block_base,unsigned int start,unsigned int end) { -unsigned int i, regtmp, val; -const void *addr; +unsigned int i, val; +unsigned int regtmp =0 ; +unsigned int base =0 ; +const void *data =NULL ;int ret;for (i = start; i < end; i++) { regtmp = block_base + (i * map->reg_stride); -if (!regcache_reg_present (map, regtmp)) +if (!regcache_reg_present (map, regtmp)) { + ret =regcache_sync_block_raw_flush (map, &data, + base, regtmp); +if (ret !=0 ) +return ret;continue ; + } val =regcache_get_val (map, block, i);/* Is this the hardware default? If so skip. */ ret =regcache_lookup_reg (map, regtmp); -if (ret >=0 && val == map->reg_defaults[ret].def) +if (ret >=0 && val == map->reg_defaults[ret].def) { + ret =regcache_sync_block_raw_flush (map, &data, + base, regtmp); +if (ret !=0 ) +return ret;continue ; + } - map->cache_bypass =1 ; - - addr =regcache_get_val_addr (map, block, i); - ret =_regmap_raw_write (map, regtmp, addr, - map->format.val_bytes, - false); - - map->cache_bypass =0 ; -if (ret !=0 ) -return ret; -dev_dbg (map->dev,"Synced register %#x, value %#x\n" , - regtmp, val); +if (!data) { + data =regcache_get_val_addr (map, block, i); + base = regtmp; + } } -return 0 ; +return regcache_sync_block_raw_flush (map, &data, base, regtmp); } int regcache_sync_block(struct regmap *map, void *block,
Signature · 1 line
1.7.10.4
Re: [PATCH 4/4] regmap: cache: Write consecutive registers in a single block write
Quoted 10 lines · Mark Brown
When syncing blocks of data using raw writes combine the writes into a single block write, saving us bus overhead for setup, addressing and teardown.
Currently the block write is done unconditionally as it is expected that hardware which has a register format which can support raw writes will support auto incrementing writes, this decision may need to be revised in future.
Signed-off-by Mark Brown <[email protected]>
Quoted 11 lines · Mark Brown
The idea of maintaining a bitmap of present registers is something that can usefully be used by other cache types that maintain blocks of cached registers so move the code out of the rbtree cache and into the generic regcache code.
Refactor the interface slightly as we go to wrap the set bit and enlarge bitmap operations (since we never do one without the other) and make it more robust for reads of uncached registers by bounds checking before we look at the bitmap.
Signed-off-by Mark Brown <[email protected]>
Looks good.