kernel/linux.git/drivers/base/regmap/regcache.c, branch v7.3-rc1

Merge tag 'regmap-v7.3' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap

2026-08-19T16:32:57+00:00

Pull regmap updates from Mark Brown: "This is a relatively busy release, though it's mostly cleanup work. We did add some new hooks for regmap-irq to support some driver work, that should also come in as part of a shared branch with the relevant driver work in the GPIO subsystem" * tag 'regmap-v7.3' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap: regmap: clean up kernel-doc comments regcache: Validate cache_only state in regcache_sync_region() regcache: Warn if regcache_sync() is called in cache_only mode regcache: Mark cache dirty if selector register rewrite fails regcache: Preserve cache synchronization errors in regcache_sync() regmap: maple: Workaround for another false-positive compiler warning regcache: Make ->exit() callback return void

regcache: Sort the local copy of an unsorted reg_defaults array

2026-08-06T12:01:39+00:00

regcache_lookup_reg() bsearch()es the reg_defaults array, which requires it to be sorted by ascending register address. Entries following a descending step are never found, so regcache_reg_needs_sync() reports that they need a sync and they are written to the device on every regcache_sync() even when they were never touched. Detect the misordering while reg_defaults is validated against the register stride and sort the local copy. The check needs no new loop and sort() only runs for the affected drivers, which are also warned about. Note that sort() is not stable, so for arrays with duplicated register addresses it remains unspecified which entry is found. Signed-off-by: Peter Ujfalusi Reviewed-by: Charles Keepax Tested-by: Charles Keepax Link: https://patch.msgid.link/20260805132250.2637-1-peter.ujfalusi@linux.intel.com Signed-off-by: Mark Brown

regcache: Use a consistent sort for defaults table

2026-08-06T11:59:47+00:00

When we look up registers in the defaults table we use a binary search, and we have a regcache_sort_defaults() API to help drivers that constuct their defaults tables on the fly. Unfortunately the lookup and the sort don't use the same comparison function, and to make matters worse the comparison function used during lookups is written for signed register numbers rather than the unsigned ones we actually have so can produce suprising results when some of the addresses have the top bit set. Standardise on the more explicitly coded function to ensure consistent results. Reviewed-by: Peter Ujfalusi Reviewed-by: Charles Keepax Tested-by: Charles Keepax Link: https://patch.msgid.link/20260805-regmap-regcache-sort-v1-1-162186aad8b9@kernel.org Signed-off-by: Mark Brown

regcache: Warn if regcache_sync() is called in cache_only mode

2026-07-20T17:45:15+00:00

phucduc.bui@gmail.com did a bit of work to help people avoid running into silly errors. Link: https://patch.msgid.link/20260720033238.52479-1-phucduc.bui@gmail.com

regcache: Validate cache_only state in regcache_sync_region()

2026-07-20T17:45:14+00:00

Add a WARN_ON() check to ensure regcache_sync_region() is not called while cache_only is enabled. Signed-off-by: bui duc phuc Link: https://patch.msgid.link/20260720033238.52479-2-phucduc.bui@gmail.com Signed-off-by: Mark Brown

regcache: Warn if regcache_sync() is called in cache_only mode

2026-07-20T17:45:13+00:00

Calling regcache_sync() while cache_only is enabled is invalid API usage, since writes are intentionally kept in the cache and cannot be synchronized to hardware. Document that callers must disable cache_only before calling regcache_sync(), and reject incorrect usage with a WARN_ON() and -EINVAL. Signed-off-by: bui duc phuc Link: https://patch.msgid.link/20260720033238.52479-1-phucduc.bui@gmail.com Signed-off-by: Mark Brown

regcache: Mark cache dirty if selector register rewrite fails

2026-07-13T17:52:43+00:00

After a successful cache synchronization, regcache_sync() clears cache_dirty. If rewriting a selector register later fails, the cache and hardware become inconsistent while the cache still appears clean. Update cache_dirty to reflect the cache and hardware state when selector register rewriting fails. Signed-off-by: bui duc phuc Link: https://patch.msgid.link/20260713050312.38729-3-phucduc.bui@gmail.com Signed-off-by: Mark Brown

regcache: Preserve cache synchronization errors in regcache_sync()

2026-07-13T17:52:42+00:00

regcache_sync() currently stores the return value from both cache synchronization and selector register rewriting in the same variable. As a result, a successful selector register rewrite can overwrite an earlier cache synchronization error, causing regcache_sync() to return success even though synchronization failed. Track the two operations with separate return variables and preserve the cache synchronization error. Errors from rewriting selector registers are returned only if cache synchronization completed successfully. Signed-off-by: bui duc phuc Link: https://patch.msgid.link/20260713050312.38729-2-phucduc.bui@gmail.com Signed-off-by: Mark Brown

regcache: Do not overwrite error code when finalizing cache after error

2026-06-16T13:13:48+00:00

During regcache initialization, if an error occurs in the cache_ops->populate callback, and if cache operations include an exit callback, the error code from populate() is overwritten with the return value from exit(). This hides the error condition from the caller of regcache_init(), and can cause NULL pointer dereferences when the regcache is later accessed. Fixes: 94a3a95f0315 ("regcache: Add ->populate() callback to separate from ->init()") Signed-off-by: Francesco Lavra Link: https://patch.msgid.link/20260616114429.1852456-1-flavra@baylibre.com Signed-off-by: Mark Brown

regcache: Move HW readback after cache initialisation

2026-03-05T15:23:01+00:00

Make sure that cache is initialised before calling any IO using regmap, this makes sure that we won't access NULL or invalid pointers in the cache which hasn't been initialised. As a side effect it also makes the ordering of cleaning up the resources in regcache_exit() to be the same (and correct) as in the error path of regcache_init(). This is not a problem right now as they do not have dependencies, but it makes code robust against potential changes in the future. Signed-off-by: Andy Shevchenko Link: https://patch.msgid.link/20260305085449.3184020-4-andriy.shevchenko@linux.intel.com Signed-off-by: Mark Brown