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: Linus Walleij <linus.walleij@linaro.org>
Link: https://lore.kernel.org/r/20220816204832.265837-1-linus.walleij@linaro.org
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index e371ace..41ff9f1 100644 (file)
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -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;

diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 8cccc24..ca3434d 100644 (file)
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -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;