Unverified Commit 1cbddedb authored by Mark Brown's avatar Mark Brown
Browse files

Merge tag 'regmap-noinc-read' into regmap-4.19 

regmap: Support non-incrementing registers

Some devices have individual registers that don't autoincrement the
register address during bulk reads but instead repeatedly read the same
value, for example for monitoring GPIOs or ADCs.  Add support for these.
parents 75eb3a67 74fe7b55

drivers/base/regmap/internal.h

+3 −0
Original line number Original line Diff line number Diff line
@@ -94,10 +94,12 @@ struct regmap { 
	bool (*readable_reg)(struct device *dev, unsigned int reg);

	bool (*readable_reg)(struct device *dev, unsigned int reg);

	bool (*volatile_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 (*precious_reg)(struct device *dev, unsigned int reg);

	bool (*readable_noinc_reg)(struct device *dev, unsigned int reg);

	const struct regmap_access_table *wr_table;

	const struct regmap_access_table *wr_table;

	const struct regmap_access_table *rd_table;

	const struct regmap_access_table *rd_table;

	const struct regmap_access_table *volatile_table;

	const struct regmap_access_table *volatile_table;

	const struct regmap_access_table *precious_table;

	const struct regmap_access_table *precious_table;

	const struct regmap_access_table *rd_noinc_table;





	int (*reg_read)(void *context, unsigned int reg, unsigned int *val);

	int (*reg_read)(void *context, unsigned int reg, unsigned int *val);

	int (*reg_write)(void *context, unsigned int reg, unsigned int val);

	int (*reg_write)(void *context, unsigned int reg, unsigned int val);
@@ -181,6 +183,7 @@ bool regmap_writeable(struct regmap *map, unsigned int reg); 
bool regmap_readable(struct regmap *map, unsigned int reg);

bool regmap_readable(struct regmap *map, unsigned int reg);

bool regmap_volatile(struct regmap *map, unsigned int reg);

bool regmap_volatile(struct regmap *map, unsigned int reg);

bool regmap_precious(struct regmap *map, unsigned int reg);

bool regmap_precious(struct regmap *map, unsigned int reg);

bool regmap_readable_noinc(struct regmap *map, unsigned int reg);





int _regmap_write(struct regmap *map, unsigned int reg,

int _regmap_write(struct regmap *map, unsigned int reg,

		  unsigned int val);

		  unsigned int val);

drivers/base/regmap/regmap.c

+78 −1
Original line number Original line Diff line number Diff line
@@ -168,6 +168,17 @@ bool regmap_precious(struct regmap *map, unsigned int reg) 
	return false;

	return false;

}

}





bool regmap_readable_noinc(struct regmap *map, unsigned int reg)

{

	if (map->readable_noinc_reg)

		return map->readable_noinc_reg(map->dev, reg);



	if (map->rd_noinc_table)

		return regmap_check_range_table(map, reg, map->rd_noinc_table);



	return true;

}



static bool regmap_volatile_range(struct regmap *map, unsigned int reg,

static bool regmap_volatile_range(struct regmap *map, unsigned int reg,

	size_t num)

	size_t num)

{

{
@@ -766,10 +777,12 @@ struct regmap *__regmap_init(struct device *dev, 
	map->rd_table = config->rd_table;

	map->rd_table = config->rd_table;

	map->volatile_table = config->volatile_table;

	map->volatile_table = config->volatile_table;

	map->precious_table = config->precious_table;

	map->precious_table = config->precious_table;

	map->rd_noinc_table = config->rd_noinc_table;

	map->writeable_reg = config->writeable_reg;

	map->writeable_reg = config->writeable_reg;

	map->readable_reg = config->readable_reg;

	map->readable_reg = config->readable_reg;

	map->volatile_reg = config->volatile_reg;

	map->volatile_reg = config->volatile_reg;

	map->precious_reg = config->precious_reg;

	map->precious_reg = config->precious_reg;

	map->readable_noinc_reg = config->readable_noinc_reg;

	map->cache_type = config->cache_type;

	map->cache_type = config->cache_type;





	spin_lock_init(&map->async_lock);

	spin_lock_init(&map->async_lock);
@@ -1285,6 +1298,7 @@ int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config) 
	map->readable_reg = config->readable_reg;

	map->readable_reg = config->readable_reg;

	map->volatile_reg = config->volatile_reg;

	map->volatile_reg = config->volatile_reg;

	map->precious_reg = config->precious_reg;

	map->precious_reg = config->precious_reg;

	map->readable_noinc_reg = config->readable_noinc_reg;

	map->cache_type = config->cache_type;

	map->cache_type = config->cache_type;





	regmap_debugfs_init(map, config->name);

	regmap_debugfs_init(map, config->name);
@@ -2564,7 +2578,70 @@ int regmap_raw_read(struct regmap *map, unsigned int reg, void *val, 
EXPORT_SYMBOL_GPL(regmap_raw_read);

EXPORT_SYMBOL_GPL(regmap_raw_read);





/**

/**

 * regmap_field_read() - Read a value to a single register field

 * regmap_noinc_read(): Read data from a register without incrementing the

 *			register number

 *

 * @map: Register map to read from

 * @reg: Register to read from

 * @val: Pointer to data buffer

 * @val_len: Length of output buffer in bytes.

 *

 * The regmap API usually assumes that bulk bus read operations will read a

 * range of registers. Some devices have certain registers for which a read

 * operation read will read from an internal FIFO.

 *

 * The target register must be volatile but registers after it can be

 * completely unrelated cacheable registers.

 *

 * This will attempt multiple reads as required to read val_len bytes.

 *

 * A value of zero will be returned on success, a negative errno will be

 * returned in error cases.

 */

int regmap_noinc_read(struct regmap *map, unsigned int reg,

		      void *val, size_t val_len)

{

	size_t read_len;

	int ret;



	if (!map->bus)

		return -EINVAL;

	if (!map->bus->read)

		return -ENOTSUPP;

	if (val_len % map->format.val_bytes)

		return -EINVAL;

	if (!IS_ALIGNED(reg, map->reg_stride))

		return -EINVAL;

	if (val_len == 0)

		return -EINVAL;



	map->lock(map->lock_arg);



	if (!regmap_volatile(map, reg) || !regmap_readable_noinc(map, reg)) {

		ret = -EINVAL;

		goto out_unlock;

	}



	while (val_len) {

		if (map->max_raw_read && map->max_raw_read < val_len)

			read_len = map->max_raw_read;

		else

			read_len = val_len;

		ret = _regmap_raw_read(map, reg, val, read_len);

		if (ret)

			goto out_unlock;

		val = ((u8 *)val) + read_len;

		val_len -= read_len;

	}



out_unlock:

	map->unlock(map->lock_arg);

	return ret;

}

EXPORT_SYMBOL_GPL(regmap_noinc_read);



/**

 * regmap_field_read(): Read a value to a single register field

 *

 *

 * @field: Register field to read from

 * @field: Register field to read from

 * @val: Pointer to store read value

 * @val: Pointer to store read value

include/linux/regmap.h

+19 −0
Original line number Original line Diff line number Diff line
@@ -268,6 +268,13 @@ typedef void (*regmap_unlock)(void *); 
 *                field is NULL but precious_table (see below) is not, the

 *                field is NULL but precious_table (see below) is not, the

 *                check is performed on such table (a register is precious if

 *                check is performed on such table (a register is precious if

 *                it belongs to one of the ranges specified by precious_table).

 *                it belongs to one of the ranges specified by precious_table).

 * @readable_noinc_reg: Optional callback returning true if the register

 *			supports multiple read operations without incrementing

 *			the register number. If this field is NULL but

 *			rd_noinc_table (see below) is not, the check is

 *			performed on such table (a register is no increment

 *			readable if it belongs to one of the ranges specified

 *			by rd_noinc_table).

 * @disable_locking: This regmap is either protected by external means or

 * @disable_locking: This regmap is either protected by external means or

 *                   is guaranteed not be be accessed from multiple threads.

 *                   is guaranteed not be be accessed from multiple threads.

 *                   Don't use any locking mechanisms.

 *                   Don't use any locking mechanisms.
@@ -295,6 +302,7 @@ typedef void (*regmap_unlock)(void *); 
 * @rd_table:     As above, for read access.

 * @rd_table:     As above, for read access.

 * @volatile_table: As above, for volatile registers.

 * @volatile_table: As above, for volatile registers.

 * @precious_table: As above, for precious registers.

 * @precious_table: As above, for precious registers.

 * @rd_noinc_table: As above, for no increment readable registers.

 * @reg_defaults: Power on reset values for registers (for use with

 * @reg_defaults: Power on reset values for registers (for use with

 *                register cache support).

 *                register cache support).

 * @num_reg_defaults: Number of elements in reg_defaults.

 * @num_reg_defaults: Number of elements in reg_defaults.
@@ -344,6 +352,7 @@ struct regmap_config { 
	bool (*readable_reg)(struct device *dev, unsigned int reg);

	bool (*readable_reg)(struct device *dev, unsigned int reg);

	bool (*volatile_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 (*precious_reg)(struct device *dev, unsigned int reg);

	bool (*readable_noinc_reg)(struct device *dev, unsigned int reg);





	bool disable_locking;

	bool disable_locking;

	regmap_lock lock;

	regmap_lock lock;
@@ -360,6 +369,7 @@ struct regmap_config { 
	const struct regmap_access_table *rd_table;

	const struct regmap_access_table *rd_table;

	const struct regmap_access_table *volatile_table;

	const struct regmap_access_table *volatile_table;

	const struct regmap_access_table *precious_table;

	const struct regmap_access_table *precious_table;

	const struct regmap_access_table *rd_noinc_table;

	const struct reg_default *reg_defaults;

	const struct reg_default *reg_defaults;

	unsigned int num_reg_defaults;

	unsigned int num_reg_defaults;

	enum regcache_type cache_type;

	enum regcache_type cache_type;
@@ -981,6 +991,8 @@ int regmap_raw_write_async(struct regmap *map, unsigned int reg, 
int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);

int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);

int regmap_raw_read(struct regmap *map, unsigned int reg,

int regmap_raw_read(struct regmap *map, unsigned int reg,

		    void *val, size_t val_len);

		    void *val, size_t val_len);

int regmap_noinc_read(struct regmap *map, unsigned int reg,

		      void *val, size_t val_len);

int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,

int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,

		     size_t val_count);

		     size_t val_count);

int regmap_update_bits_base(struct regmap *map, unsigned int reg,

int regmap_update_bits_base(struct regmap *map, unsigned int reg,
@@ -1231,6 +1243,13 @@ static inline int regmap_raw_read(struct regmap *map, unsigned int reg, 
	return -EINVAL;

	return -EINVAL;

}

}





static inline int regmap_noinc_read(struct regmap *map, unsigned int reg,

				    void *val, size_t val_len)

{

	WARN_ONCE(1, "regmap API is disabled");

	return -EINVAL;

}



static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,

static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,

				   void *val, size_t val_count)

				   void *val, size_t val_count)

{

{

CRA Git | Maintained and supported by SUSTech CRA and CCSE