Unverified Commit c20cc099 authored by Linus Walleij's avatar Linus Walleij Committed by Mark Brown
Browse files

regmap: Support accelerated noinc operations 



Several architectures have accelerated operations for MMIO
operations writing to a single register, such as writesb, writesw,
writesl, writesq, readsb, readsw, readsl and readsq but regmap
currently cannot use them because we have no hooks for providing
an accelerated noinc back-end for MMIO.

Solve this by providing reg_[read/write]_noinc callbacks for
the bus abstraction, so that the regmap-mmio bus can use this.

Currently I do not see a need to support this for custom regmaps
so it is only added to the bus.

Callbacks are passed a void * with the array of values and a
count which is the number of items of the byte chunk size for
the specific register width.

Signed-off-by: default avatarLinus Walleij <linus.walleij@linaro.org>
Link: https://lore.kernel.org/r/20220816204832.265837-1-linus.walleij@linaro.org


Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 77672e03

drivers/base/regmap/regmap.c

+120 −3
Original line number Diff line number Diff line
@@ -2129,6 +2129,99 @@ int regmap_raw_write(struct regmap *map, unsigned int reg, 
}

EXPORT_SYMBOL_GPL(regmap_raw_write);



static int regmap_noinc_readwrite(struct regmap *map, unsigned int reg,

				  void *val, unsigned int val_len, bool write)

{

	size_t val_bytes = map->format.val_bytes;

	size_t val_count = val_len / val_bytes;

	unsigned int lastval;

	u8 *u8p;

	u16 *u16p;

	u32 *u32p;

#ifdef CONFIG_64BIT

	u64 *u64p;

#endif

	int ret;

	int i;



	switch (val_bytes) {

	case 1:

		u8p = val;

		if (write)

			lastval = (unsigned int)u8p[val_count - 1];

		break;

	case 2:

		u16p = val;

		if (write)

			lastval = (unsigned int)u16p[val_count - 1];

		break;

	case 4:

		u32p = val;

		if (write)

			lastval = (unsigned int)u32p[val_count - 1];

		break;

#ifdef CONFIG_64BIT

	case 8:

		u64p = val;

		if (write)

			lastval = (unsigned int)u64p[val_count - 1];

		break;

#endif

	default:

		return -EINVAL;

	}



	/*

	 * Update the cache with the last value we write, the rest is just

	 * gone down in the hardware FIFO. We can't cache FIFOs. This makes

	 * sure a single read from the cache will work.

	 */

	if (write) {

		if (!map->cache_bypass && !map->defer_caching) {

			ret = regcache_write(map, reg, lastval);

			if (ret != 0)

				return ret;

			if (map->cache_only) {

				map->cache_dirty = true;

				return 0;

			}

		}

		ret = map->bus->reg_noinc_write(map->bus_context, reg, val, val_count);

	} else {

		ret = map->bus->reg_noinc_read(map->bus_context, reg, val, val_count);

	}



	if (!ret && regmap_should_log(map)) {

		dev_info(map->dev, "%x %s [", reg, write ? "<=" : "=>");

		for (i = 0; i < val_len; i++) {

			switch (val_bytes) {

			case 1:

				pr_cont("%x", u8p[i]);

				break;

			case 2:

				pr_cont("%x", u16p[i]);

				break;

			case 4:

				pr_cont("%x", u32p[i]);

				break;

#ifdef CONFIG_64BIT

			case 8:

				pr_cont("%llx", u64p[i]);

				break;

#endif

			default:

				break;

			}

			if (i == (val_len - 1))

				pr_cont("]\n");

			else

				pr_cont(",");

		}

	}



	return 0;

}



/**

 * regmap_noinc_write(): Write data from a register without incrementing the

 *			register number
@@ -2156,9 +2249,8 @@ int regmap_noinc_write(struct regmap *map, unsigned int reg, 
	size_t write_len;

	int ret;



	if (!map->write)

		return -ENOTSUPP;



	if (!map->write && !(map->bus && map->bus->reg_noinc_write))

		return -EINVAL;

	if (val_len % map->format.val_bytes)

		return -EINVAL;

	if (!IS_ALIGNED(reg, map->reg_stride))
@@ -2173,6 +2265,15 @@ int regmap_noinc_write(struct regmap *map, unsigned int reg, 
		goto out_unlock;

	}



	/*

	 * Use the accelerated operation if we can. The val drops the const

	 * typing in order to facilitate code reuse in regmap_noinc_readwrite().

	 */

	if (map->bus->reg_noinc_write) {

		ret = regmap_noinc_readwrite(map, reg, (void *)val, val_len, true);

		goto out_unlock;

	}



	while (val_len) {

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

			write_len = map->max_raw_write;
@@ -2943,6 +3044,22 @@ int regmap_noinc_read(struct regmap *map, unsigned int reg, 
		goto out_unlock;

	}



	/* Use the accelerated operation if we can */

	if (map->bus->reg_noinc_read) {

		/*

		 * We have not defined the FIFO semantics for cache, as the

		 * cache is just one value deep. Should we return the last

		 * written value? Just avoid this by always reading the FIFO

		 * even when using cache. Cache only will not work.

		 */

		if (map->cache_only) {

			ret = -EBUSY;

			goto out_unlock;

		}

		ret = regmap_noinc_readwrite(map, reg, val, val_len, false);

		goto out_unlock;

	}



	while (val_len) {

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

			read_len = map->max_raw_read;

include/linux/regmap.h

+8 −0
Original line number Diff line number Diff line
@@ -492,8 +492,12 @@ typedef int (*regmap_hw_read)(void *context, 
			      void *val_buf, size_t val_size);

typedef int (*regmap_hw_reg_read)(void *context, unsigned int reg,

				  unsigned int *val);

typedef int (*regmap_hw_reg_noinc_read)(void *context, unsigned int reg,

					void *val, size_t val_count);

typedef int (*regmap_hw_reg_write)(void *context, unsigned int reg,

				   unsigned int val);

typedef int (*regmap_hw_reg_noinc_write)(void *context, unsigned int reg,

					 const void *val, size_t val_count);

typedef int (*regmap_hw_reg_update_bits)(void *context, unsigned int reg,

					 unsigned int mask, unsigned int val);

typedef struct regmap_async *(*regmap_hw_async_alloc)(void);
@@ -514,6 +518,8 @@ typedef void (*regmap_hw_free_context)(void *context); 
 *               must serialise with respect to non-async I/O.

 * @reg_write: Write a single register value to the given register address. This

 *             write operation has to complete when returning from the function.

 * @reg_write_noinc: Write multiple register value to the same register. This

 *             write operation has to complete when returning from the function.

 * @reg_update_bits: Update bits operation to be used against volatile

 *                   registers, intended for devices supporting some mechanism

 *                   for setting clearing bits without having to
@@ -541,9 +547,11 @@ struct regmap_bus { 
	regmap_hw_gather_write gather_write;

	regmap_hw_async_write async_write;

	regmap_hw_reg_write reg_write;

	regmap_hw_reg_noinc_write reg_noinc_write;

	regmap_hw_reg_update_bits reg_update_bits;

	regmap_hw_read read;

	regmap_hw_reg_read reg_read;

	regmap_hw_reg_noinc_read reg_noinc_read;

	regmap_hw_free_context free_context;

	regmap_hw_async_alloc async_alloc;

	u8 read_flag_mask;