Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-18 18:11:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

regmap: allow to disable all locking mechanisms

Browse Source 
We have a use case in the at24 EEPROM driver (recently converted to
using regmap instead of raw i2c/smbus calls) where we read from/write
to the regmap in a loop, while protecting the entire loop with
a mutex.

Currently this implicitly makes us use two mutexes - one in the driver
and one in regmap. While browsing the code for similar use cases I
noticed a significant number of places where locking *seems* redundant.

Allow users to completely disable any locking mechanisms in regmap
config.

Signed-off-by: Bartosz Golaszewski <brgl@bgdev.pl>
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Bartosz Golaszewski 2017-12-06 15:26:21 +01:00 committed by Mark Brown
parent 4fbd8d194f
commit c9b41fcf27
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
2 changed files with 13 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
drivers/base/regmap/regmap.c
View File

@ -459,6 +459,11 @@ static void regmap_unlock_hwlock_irqrestore(void *__map)
}
#endif
static void regmap_lock_unlock_empty(void *__map)
{
}
static void regmap_lock_mutex(void *__map)
{
struct regmap *map = __map;
@ -669,7 +674,9 @@ struct regmap *__regmap_init(struct device *dev,
goto err;
}
if (config->lock && config->unlock) {
if (config->disable_locking) {
map->lock = map->unlock = regmap_lock_unlock_empty;
} else if (config->lock && config->unlock) {
map->lock = config->lock;
map->unlock = config->unlock;
map->lock_arg = config->lock_arg;

5
include/linux/regmap.h
View File

@ -264,6 +264,9 @@ typedef void (*regmap_unlock)(void *);
* field is NULL but precious_table (see below) is not, the
* check is performed on such table (a register is precious if
* it belongs to one of the ranges specified by precious_table).
* @disable_locking: This regmap is either protected by external means or
* is guaranteed not be be accessed from multiple threads.
* Don't use any locking mechanisms.
* @lock: Optional lock callback (overrides regmap's default lock
* function, based on spinlock or mutex).
* @unlock: As above for unlocking.
@ -333,6 +336,8 @@ struct regmap_config {
bool (*readable_reg)(struct device *dev, unsigned int reg);
bool (*volatile_reg)(struct device *dev, unsigned int reg);
bool (*precious_reg)(struct device *dev, unsigned int reg);
bool disable_locking;
regmap_lock lock;
regmap_unlock unlock;
void *lock_arg;