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.

2 files changed, 81 insertions, 1 deletions

diff --git a/drivers/base/regmap/internal.h b/drivers/base/regmap/internal.h
index 53785e0e297a..a6bf34d6394e 100644
--- a/drivers/base/regmap/internal.h
+++ b/drivers/base/regmap/internal.h
@@ -94,10 +94,12 @@ struct regmap {
         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 (*readable_noinc_reg)(struct device *dev, unsigned int reg);
         const struct regmap_access_table *wr_table;
         const struct regmap_access_table *rd_table;
         const struct regmap_access_table *volatile_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_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_volatile(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,
                   unsigned int val);
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index 3bc84885eb91..0360a90ad6b6 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -168,6 +168,17 @@ bool regmap_precious(struct regmap *map, unsigned int reg)
         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,
         size_t num)
 {
@@ -766,10 +777,12 @@ struct regmap *__regmap_init(struct device *dev,
         map->rd_table = config->rd_table;
         map->volatile_table = config->volatile_table;
         map->precious_table = config->precious_table;
+        map->rd_noinc_table = config->rd_noinc_table;
         map->writeable_reg = config->writeable_reg;
         map->readable_reg = config->readable_reg;
         map->volatile_reg = config->volatile_reg;
         map->precious_reg = config->precious_reg;
+        map->readable_noinc_reg = config->readable_noinc_reg;
         map->cache_type = config->cache_type;
 
         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->volatile_reg = config->volatile_reg;
         map->precious_reg = config->precious_reg;
+        map->readable_noinc_reg = config->readable_noinc_reg;
         map->cache_type = config->cache_type;
 
         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);
 
 /**
- * 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
  * @val: Pointer to store read value