Unverified Commit c9b41fcf authored by Bartosz Golaszewski's avatar Bartosz Golaszewski Committed by Mark Brown
Browse files

regmap: allow to disable all locking mechanisms 



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: default avatarBartosz Golaszewski <brgl@bgdev.pl>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 4fbd8d19

drivers/base/regmap/regmap.c

+8 −1
Original line number Diff line number Diff line
@@ -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;

include/linux/regmap.h

+5 −0
Original line number Diff line number Diff line
@@ -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;

CRA Git | Maintained and supported by SUSTech CRA and CCSE