github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-07 06:17:02 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

regcache: extract locked helpers to replace open-coded lock/unlock pairs

Browse Source 
The previous patch ("regcache: use the regmap scoped lock guard")
deliberately left regcache_init() with explicit map->lock()/unlock()
calls because the function has a goto err_* cleanup ladder and mixing
goto with cleanup helpers in the same function is discouraged by
cleanup.h.

Solve this by extracting two static helpers:

  regcache_locked_op()  - acquires the regmap lock via guard(regmap),
                          invokes an int-returning cache_ops callback
                          (init, populate), and returns its result.
                          Returns 0 when the callback is NULL.

  regcache_locked_exit() - acquires the regmap lock via guard(regmap)
                           and invokes the void-returning exit
                           callback.  Returns immediately when the
                           callback is NULL.

Because the lock scope is now entirely inside the helper functions,
it never crosses a goto target in the caller, so the cleanup.h
concern does not apply.

Convert all four remaining open-coded lock/unlock sites in
regcache_init() (init, populate, error-path exit) and the
scoped_guard in regcache_exit() to use these helpers.

No functional change.

Assisted-by: LLM
Signed-off-by: Peng Fan <peng.fan@nxp.com>
Link: https://patch.msgid.link/20261002-regmap-lock-2nd-v2-1-e172b0501c52@nxp.com
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Peng Fan 2026-10-02 21:11:17 +08:00 committed by Mark Brown
parent 012c37f094
commit 81556a7aec
1 changed files with 29 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
drivers/base/regmap/regcache.c
View File

@ -121,6 +121,28 @@ static void regcache_hw_exit(struct regmap *map)
kfree(map->reg_defaults_raw);
}
static int regcache_locked_op(struct regmap *map,
int (*op)(struct regmap *map),
const char *action)
{
if (!op)
return 0;
dev_dbg(map->dev, "%s %s cache\n", action, map->cache_ops->name);
guard(regmap)(map);
return op(map);
}
static void regcache_locked_exit(struct regmap *map)
{
if (!map->cache_ops->exit)
return;
dev_dbg(map->dev, "Destroying %s cache\n", map->cache_ops->name);
guard(regmap)(map);
map->cache_ops->exit(map);
}
int regcache_init(struct regmap *map, const struct regmap_config *config)
{
bool sort_defaults = false;
@ -222,15 +244,9 @@ int regcache_init(struct regmap *map, const struct regmap_config *config)
map->max_register_is_set = true;
}
if (map->cache_ops->init) {
dev_dbg(map->dev, "Initializing %s cache\n",
map->cache_ops->name);
map->lock(map->lock_arg);
ret = map->cache_ops->init(map);
map->unlock(map->lock_arg);
if (ret)
goto err_free_reg_defaults;
}
ret = regcache_locked_op(map, map->cache_ops->init, "Initializing");
if (ret)
goto err_free_reg_defaults;
/*
* Some devices such as PMICs don't have cache defaults,
@ -243,12 +259,8 @@ int regcache_init(struct regmap *map, const struct regmap_config *config)
goto err_exit;
}
if (map->cache_ops->populate &&
(map->num_reg_defaults || map->reg_default_cb)) {
dev_dbg(map->dev, "Populating %s cache\n", map->cache_ops->name);
map->lock(map->lock_arg);
ret = map->cache_ops->populate(map);
map->unlock(map->lock_arg);
if (map->num_reg_defaults || map->reg_default_cb) {
ret = regcache_locked_op(map, map->cache_ops->populate, "Populating");
if (ret)
goto err_free;
}
@ -257,12 +269,7 @@ int regcache_init(struct regmap *map, const struct regmap_config *config)
err_free:
regcache_hw_exit(map);
err_exit:
if (map->cache_ops->exit) {
dev_dbg(map->dev, "Destroying %s cache\n", map->cache_ops->name);
map->lock(map->lock_arg);
map->cache_ops->exit(map);
map->unlock(map->lock_arg);
}
regcache_locked_exit(map);
err_free_reg_defaults:
kfree(map->reg_defaults);
@ -277,13 +284,7 @@ void regcache_exit(struct regmap *map)
BUG_ON(!map->cache_ops);
regcache_hw_exit(map);
if (map->cache_ops->exit) {
dev_dbg(map->dev, "Destroying %s cache\n",
map->cache_ops->name);
scoped_guard(regmap, map)
map->cache_ops->exit(map);
}
regcache_locked_exit(map);
kfree(map->reg_defaults);
}