regmap: Mark reg_defaults in regmap_multi_reg_write as const
Subsystems (4)
PATCH 1/4 regmap: Mark reg_defaults in regmap_multi_reg_write as const
There should be no need for the writes supplied to this function to be edited by it so mark them as const.
--- drivers/base/regmap/regmap.c | 4 ++-- include/linux/regmap.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-)
drivers/base/regmap/regmap.c +2 -2
@@ -1607,8 +1607,8 @@ EXPORT_SYMBOL_GPL(regmap_bulk_write);* A value of zero will be returned on success, a negative errno will * be returned in error cases. */ -int regmap_multi_reg_write (struct regmap *map,struct reg_default *regs, -int num_regs) +int regmap_multi_reg_write (struct regmap *map,const struct reg_default *regs, +int num_regs) {int ret =0 , i;
include/linux/regmap.h +1 -1
@@ -388,7 +388,7 @@ int regmap_raw_write(struct regmap *map, unsigned int reg, const void *val, size_t val_len);int regmap_bulk_write (struct regmap *map,unsigned int reg,const void *val,size_t val_count); -int regmap_multi_reg_write (struct regmap *map,struct reg_default *regs, +int regmap_multi_reg_write (struct regmap *map,const struct reg_default *regs,int num_regs);int regmap_raw_write_async (struct regmap *map,unsigned int reg,const void *val,size_t val_len);
Signature · 1 line
1.7.2.5
PATCH 2/4 regmap: Add bypassed version of regmap_multi_reg_write
Devices with more complex boot proceedures may occasionally apply the register patch manual. regmap_multi_reg_write is a logical way to do so, however the patch must be applied with cache bypass on, such that it doesn't override any user settings. This patch adds a regmap_multi_reg_write_bypassed function that applies a set of writes with the bypass enabled.
--- drivers/base/regmap/regmap.c | 75 ++++++++++++++++++++++++++++++++++------- include/linux/regmap.h | 3 ++ 2 files changed, 65 insertions(+), 13 deletions(-)
drivers/base/regmap/regmap.c +62 -13
@@ -1591,6 +1591,26 @@ out: }EXPORT_SYMBOL_GPL (regmap_bulk_write); +static int _regmap_multi_reg_write (struct regmap *map, +const struct reg_default *regs, +int num_regs) +{ +int i, ret; + +for (i =0 ; i < num_regs; i++) { +if (regs[i].reg % map->reg_stride) +return -EINVAL ; + ret =_regmap_write (map, regs[i].reg, regs[i].def); +if (ret !=0 ) { +dev_err (map->dev,"Failed to write %x = %x: %d\n" , + regs[i].reg, regs[i].def, ret); +return ret; + } + } + +return 0 ; +} +/* * regmap_multi_reg_write(): Write multiple registers to the device *
@@ -1610,28 +1630,57 @@ EXPORT_SYMBOL_GPL(regmap_bulk_write);int regmap_multi_reg_write (struct regmap *map,const struct reg_default *regs,int num_regs) { -int ret =0 , i; - -for (i =0 ; i < num_regs; i++) { -int reg = regs[i].reg; -if (reg % map->reg_stride) -return -EINVAL ; - } +int ret; map->lock (map->lock_arg); -for (i =0 ; i < num_regs; i++) { - ret =_regmap_write (map, regs[i].reg, regs[i].def); -if (ret !=0 ) - goto out; - } -out: + ret =_regmap_multi_reg_write (map, regs, num_regs); + map->unlock (map->lock_arg);return ret; }EXPORT_SYMBOL_GPL (regmap_multi_reg_write); +/* +* regmap_multi_reg_write_bypassed(): Write multiple registers to the +* device but not the cache +* +* where the set of register are supplied in any order +* +* @map: Register map to write to +* @regs: Array of structures containing register,value to be written +* @num_regs: Number of registers to write +* +* This function is intended to be used for writing a large block of data +* atomically to the device in single transfer for those I2C client devices +* that implement this alternative block write mode. +* +* A value of zero will be returned on success, a negative errno will +* be returned in error cases. +*/ +int regmap_multi_reg_write_bypassed (struct regmap *map, +const struct reg_default *regs, +int num_regs) +{ +int ret; +bool bypass; + + map->lock (map->lock_arg); + + bypass = map->cache_bypass; + map->cache_bypass = true; + + ret =_regmap_multi_reg_write (map, regs, num_regs); + + map->cache_bypass = bypass; + + map->unlock (map->lock_arg); + +return ret; +} +EXPORT_SYMBOL_GPL (regmap_multi_reg_write_bypassed); +/** * regmap_raw_write_async(): Write raw values to one or more registers * asynchronously
include/linux/regmap.h +3 -0
@@ -390,6 +390,9 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val, size_t val_count);int regmap_multi_reg_write (struct regmap *map,const struct reg_default *regs,int num_regs); +int regmap_multi_reg_write_bypassed (struct regmap *map, +const struct reg_default *regs, +int num_regs);int regmap_raw_write_async (struct regmap *map,unsigned int reg,const void *val,size_t val_len);int regmap_read (struct regmap *map,unsigned int reg,unsigned int *val);
Signature · 1 line
1.7.2.5
PATCH 3/4 regmap: Base regmap_register_patch on _regmap_multi_reg_write
In reply to Charles KeepaxSince we now have an internal version of regmap_multi_reg_write use this to apply the register patch.
--- drivers/base/regmap/regmap.c | 18 ++++-------------- 1 files changed, 4 insertions(+), 14 deletions(-)
drivers/base/regmap/regmap.c +4 -14
@@ -2245,7 +2245,7 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs, int num_regs) {struct reg_default *p; -int i, ret; +int ret;bool bypass; if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
@@ -2259,19 +2259,9 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs, map->cache_bypass = true; map->async = true; -/* Write out first; it's useful to apply even if we fail later. */ -for (i =0 ; i < num_regs; i++) { -if (regs[i].reg % map->reg_stride) { - ret = -EINVAL ; - goto out; - } - ret =_regmap_write (map, regs[i].reg, regs[i].def); -if (ret !=0 ) { -dev_err (map->dev,"Failed to write %x = %x: %d\n" , - regs[i].reg, regs[i].def, ret); - goto out; - } - } + ret =_regmap_multi_reg_write (map, regs, num_regs); +if (ret !=0 ) + goto out; p = krealloc(map->patch, sizeof(struct reg_default) * (map->patch_regs + num_regs),
Signature · 1 line
1.7.2.5
PATCH 4/4 mfd: arizona: Use new regmap features for manual register patch
In reply to Charles KeepaxOn the wm5102 the register patches are applied manually, rather than by the regmap core. This application is wrapped in calls to regcache_cache_bypass. However, this is dangerous as other threads may be accessing the hardware at the same time as the pm_runtime operations and if they do so during the period whilst cache_bypass is enabled those writes will miss the cache when they shouldn't.
Apply the register patch using the new regmap_multi_reg_write_bypassed function to avoid this problem. Also remove the call to regcache_cache_bypass from the hardware patch application as it is unneeded there and creates a similar window for writes to miss the cache.
--- drivers/mfd/arizona-core.c | 4 ---- drivers/mfd/wm5102-tables.c | 21 ++++----------------- 2 files changed, 4 insertions(+), 21 deletions(-)
drivers/mfd/arizona-core.c +0 -4
@@ -251,8 +251,6 @@ static int arizona_apply_hardware_patch(struct arizona* arizona)unsigned int fll, sysclk;int ret, err; -regcache_cache_bypass (arizona->regmap, true); -/* Cache existing FLL and SYSCLK settings */ ret =regmap_read (arizona->regmap,ARIZONA_FLL1_CONTROL_1 , &fll);if (ret !=0 ) {
@@ -322,8 +320,6 @@ err_fll: err); } -regcache_cache_bypass (arizona->regmap, false); -if (ret !=0 )return ret;else
drivers/mfd/wm5102-tables.c +4 -17
@@ -80,8 +80,7 @@ static const struct reg_default wm5102_revb_patch[] = {int wm5102_patch (struct arizona *arizona) {const struct reg_default *wm5102_patch; -int ret =0 ; -int i, patch_size; +int patch_size;switch (arizona->rev) {case 0 :
@@ -92,21 +91,9 @@ int wm5102_patch(struct arizona *arizona) patch_size =ARRAY_SIZE (wm5102_revb_patch); } -regcache_cache_bypass (arizona->regmap, true); - -for (i =0 ; i < patch_size; i++) { - ret =regmap_write (arizona->regmap, wm5102_patch[i].reg, - wm5102_patch[i].def); -if (ret !=0 ) { -dev_err (arizona->dev,"Failed to write %x = %x: %d\n" , - wm5102_patch[i].reg, wm5102_patch[i].def, ret); - goto out; - } - } - -out: -regcache_cache_bypass (arizona->regmap, false); -return ret; +return regmap_multi_reg_write_bypassed (arizona->regmap, + wm5102_patch, + patch_size); }static const struct regmap_irq wm5102_aod_irqs[ARIZONA_NUM_IRQ ] = {
Signature · 1 line
1.7.2.5
Re: [PATCH 4/4] mfd: arizona: Use new regmap features for manual register patch
Quoted 13 lines · Charles Keepax
On the wm5102 the register patches are applied manually, rather than by the regmap core. This application is wrapped in calls to
regcache_cache_bypass. However, this is dangerous as other threads may be accessing the hardware at the same time as thepm_runtimeoperations and if they do so during the period whilstcache_bypassis enabled those writes will miss the cache when they shouldn't.Apply the register patch using the new
regmap_multi_reg_write_bypassedfunction to avoid this problem. Also remove the call toregcache_cache_bypassfrom the hardware patch application as it is unneeded there and creates a similar window for writes to miss the cache.
Quoted 5 lines
Signed-off-by Charles Keepax <[email protected]>--- drivers/mfd/arizona-core.c | 4 ---- drivers/mfd/wm5102-tables.c | 21 ++++----------------- 2 files changed, 4 insertions(+), 21 deletions(-)
Signature · 4 lines
Lee Jones Linaro STMicroelectronics Landing Team Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog
Quoted 2 lines · Charles Keepax
There should be no need for the writes supplied to this function to be edited by it so mark them as const.
Applied all, thanks.