Merge tag 'regmap-v4.6' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap

Pull regmap updates from Mark Brown:
 "This has been a very busy release for regmap, not just in cleaning up
  the mess we got ourselves into with the endianness handling but also
  in other areas too:

   - Fixes for the endianness handling so that we now explicitly default
     to little endian (the code used to do this by accident).  This
     fixes handling of explictly specified endianness on big endian
     systems.

   - Optimisation of the implementation of register striding.

   - A refectoring of the _update_bits() code to reduce duplication.

   - Fixes and enhancements for the interrupt implementation which make
     it easier to use in a wider range of systems"

* tag 'regmap-v4.6' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap: (28 commits)
  regmap: irq: add devm apis for regmap_{add,del}_irq_chip
  regmap: replace regmap_write_bits()
  regmap: irq: Enable irq retriggering for nested irqs
  regmap: add regmap_fields_force_xxx() macros
  regmap: add regmap_field_force_xxx() macros
  regmap: merge regmap_fields_update_bits() into macro
  regmap: merge regmap_fields_write() into macro
  regmap: add regmap_fields_update_bits_base()
  regmap: merge regmap_field_update_bits() into macro
  regmap: merge regmap_field_write() into macro
  regmap: add regmap_field_update_bits_base()
  regmap: merge regmap_update_bits_check_async() into macro
  regmap: merge regmap_update_bits_check() into macro
  regmap: merge regmap_update_bits_async() into macro
  regmap: merge regmap_update_bits() into macro
  regmap: add regmap_update_bits_base()
  regcache: flat: Introduce register strider order
  regcache: Introduce the index parsing API by stride order
  regmap: core: Introduce register stride order
  regmap: irq: add devm apis for regmap_{add,del}_irq_chip
  ...

18 files changed, 438 insertions, 385 deletions

diff --git a/Documentation/devicetree/bindings/regmap/regmap.txt b/Documentation/devicetree/bindings/regmap/regmap.txt
index b494f8b8ef72..e98a9652ccc8 100644
--- a/Documentation/devicetree/bindings/regmap/regmap.txt
+++ b/Documentation/devicetree/bindings/regmap/regmap.txt
@@ -5,15 +5,18 @@ Index     Device     Endianness properties
 ---------------------------------------------------
 1         BE         'big-endian'
 2         LE         'little-endian'
+3         Native     'native-endian'
 
 For one device driver, which will run in different scenarios above
 on different SoCs using the devicetree, we need one way to simplify
 this.
 
-Required properties:
-- {big,little}-endian: these are boolean properties, if absent
-  meaning that the CPU and the Device are in the same endianness mode,
-  these properties are for register values and all the buffers only.
+Optional properties:
+- {big,little,native}-endian: these are boolean properties, if absent
+  then the implementation will choose a default based on the device
+  being controlled.  These properties are for register values and all
+  the buffers only.  Native endian means that the CPU and device have
+  the same endianness.
 
 Examples:
 Scenario 1 : CPU in LE mode & device in LE mode.
diff --git a/arch/mips/boot/dts/brcm/bcm6328.dtsi b/arch/mips/boot/dts/brcm/bcm6328.dtsi
index d61b1616b604..9d19236f53e7 100644
--- a/arch/mips/boot/dts/brcm/bcm6328.dtsi
+++ b/arch/mips/boot/dts/brcm/bcm6328.dtsi
@@ -74,7 +74,7 @@
                 timer: timer@10000040 {
                         compatible = "syscon";
                         reg = <0x10000040 0x2c>;
-                        little-endian;
+                        native-endian;
                 };
 
                 reboot {
diff --git a/arch/mips/boot/dts/brcm/bcm6368.dtsi b/arch/mips/boot/dts/brcm/bcm6368.dtsi
index 9c8d3fe28b31..1f6b9b5cddb4 100644
--- a/arch/mips/boot/dts/brcm/bcm6368.dtsi
+++ b/arch/mips/boot/dts/brcm/bcm6368.dtsi
@@ -54,7 +54,7 @@
                 periph_cntl: syscon@10000000 {
                         compatible = "syscon";
                         reg = <0x10000000 0x14>;
-                        little-endian;
+                        native-endian;
                 };
 
                 reboot: syscon-reboot@10000008 {
diff --git a/arch/mips/boot/dts/brcm/bcm7125.dtsi b/arch/mips/boot/dts/brcm/bcm7125.dtsi
index 1a7efa883c5e..3ae16053a0c9 100644
--- a/arch/mips/boot/dts/brcm/bcm7125.dtsi
+++ b/arch/mips/boot/dts/brcm/bcm7125.dtsi
@@ -98,7 +98,7 @@
                 sun_top_ctrl: syscon@404000 {
                         compatible = "brcm,bcm7125-sun-top-ctrl", "syscon";
                         reg = <0x404000 0x60c>;
-                        little-endian;
+                        native-endian;
                 };
 
                 reboot {
diff --git a/arch/mips/boot/dts/brcm/bcm7346.dtsi b/arch/mips/boot/dts/brcm/bcm7346.dtsi
index d4bf52cfcf17..be7991917d29 100644
--- a/arch/mips/boot/dts/brcm/bcm7346.dtsi
+++ b/arch/mips/boot/dts/brcm/bcm7346.dtsi
@@ -118,7 +118,7 @@
                 sun_top_ctrl: syscon@404000 {
                         compatible = "brcm,bcm7346-sun-top-ctrl", "syscon";
                         reg = <0x404000 0x51c>;
-                        little-endian;
+                        native-endian;
                 };
 
                 reboot {
diff --git a/arch/mips/boot/dts/brcm/bcm7358.dtsi b/arch/mips/boot/dts/brcm/bcm7358.dtsi
index 8e2501694d03..060805be619a 100644
--- a/arch/mips/boot/dts/brcm/bcm7358.dtsi
+++ b/arch/mips/boot/dts/brcm/bcm7358.dtsi
@@ -112,7 +112,7 @@
                 sun_top_ctrl: syscon@404000 {
                         compatible = "brcm,bcm7358-sun-top-ctrl", "syscon";
                         reg = <0x404000 0x51c>;
-                        little-endian;
+                        native-endian;
                 };
 
                 reboot {
diff --git a/arch/mips/boot/dts/brcm/bcm7360.dtsi b/arch/mips/boot/dts/brcm/bcm7360.dtsi
index 7e5f76040fb8..bcdb09bfe07b 100644
--- a/arch/mips/boot/dts/brcm/bcm7360.dtsi
+++ b/arch/mips/boot/dts/brcm/bcm7360.dtsi
@@ -112,7 +112,7 @@
                 sun_top_ctrl: syscon@404000 {
                         compatible = "brcm,bcm7360-sun-top-ctrl", "syscon";
                         reg = <0x404000 0x51c>;
-                        little-endian;
+                        native-endian;
                 };
 
                 reboot {
diff --git a/arch/mips/boot/dts/brcm/bcm7362.dtsi b/arch/mips/boot/dts/brcm/bcm7362.dtsi
index c739ea77acb0..d3b1b762e6c3 100644
--- a/arch/mips/boot/dts/brcm/bcm7362.dtsi
+++ b/arch/mips/boot/dts/brcm/bcm7362.dtsi
@@ -118,7 +118,7 @@
                 sun_top_ctrl: syscon@404000 {
                         compatible = "brcm,bcm7362-sun-top-ctrl", "syscon";
                         reg = <0x404000 0x51c>;
-                        little-endian;
+                        native-endian;
                 };
 
                 reboot {
diff --git a/arch/mips/boot/dts/brcm/bcm7420.dtsi b/arch/mips/boot/dts/brcm/bcm7420.dtsi
index 5f55d0a50a28..3302a1b8a5c9 100644
--- a/arch/mips/boot/dts/brcm/bcm7420.dtsi
+++ b/arch/mips/boot/dts/brcm/bcm7420.dtsi
@@ -99,7 +99,7 @@
                 sun_top_ctrl: syscon@404000 {
                         compatible = "brcm,bcm7420-sun-top-ctrl", "syscon";
                         reg = <0x404000 0x60c>;
-                        little-endian;
+                        native-endian;
                 };
 
                 reboot {
diff --git a/arch/mips/boot/dts/brcm/bcm7425.dtsi b/arch/mips/boot/dts/brcm/bcm7425.dtsi
index e24d41ab4e30..15b27aae15a9 100644
--- a/arch/mips/boot/dts/brcm/bcm7425.dtsi
+++ b/arch/mips/boot/dts/brcm/bcm7425.dtsi
@@ -100,7 +100,7 @@
                 sun_top_ctrl: syscon@404000 {
                         compatible = "brcm,bcm7425-sun-top-ctrl", "syscon";
                         reg = <0x404000 0x51c>;
-                        little-endian;
+                        native-endian;
                 };
 
                 reboot {
diff --git a/arch/mips/boot/dts/brcm/bcm7435.dtsi b/arch/mips/boot/dts/brcm/bcm7435.dtsi
index 8b9432cc062b..adb33e355043 100644
--- a/arch/mips/boot/dts/brcm/bcm7435.dtsi
+++ b/arch/mips/boot/dts/brcm/bcm7435.dtsi
@@ -114,7 +114,7 @@
                 sun_top_ctrl: syscon@404000 {
                         compatible = "brcm,bcm7425-sun-top-ctrl", "syscon";
                         reg = <0x404000 0x51c>;
-                        little-endian;
+                        native-endian;
                 };
 
                 reboot {
diff --git a/drivers/base/regmap/internal.h b/drivers/base/regmap/internal.h
index 3df977054781..5c79526245c2 100644
--- a/drivers/base/regmap/internal.h
+++ b/drivers/base/regmap/internal.h
@@ -110,6 +110,7 @@ struct regmap {
         /* number of bits to (left) shift the reg value when formatting*/
         int reg_shift;
         int reg_stride;
+        int reg_stride_order;
 
         /* regcache specific members */
         const struct regcache_ops *cache_ops;
@@ -263,4 +264,19 @@ static inline const char *regmap_name(const struct regmap *map)
         return map->name;
 }
 
+static inline unsigned int regmap_get_offset(const struct regmap *map,
+                                             unsigned int index)
+{
+        if (map->reg_stride_order >= 0)
+                return index << map->reg_stride_order;
+        else
+                return index * map->reg_stride;
+}
+
+static inline unsigned int regcache_get_index_by_order(const struct regmap *map,
+                                                       unsigned int reg)
+{
+        return reg >> map->reg_stride_order;
+}
+
 #endif
diff --git a/drivers/base/regmap/regcache-flat.c b/drivers/base/regmap/regcache-flat.c
index 686c9e0b930e..3ee72550b1e3 100644
--- a/drivers/base/regmap/regcache-flat.c
+++ b/drivers/base/regmap/regcache-flat.c
@@ -16,20 +16,30 @@
 
 #include "internal.h"
 
+static inline unsigned int regcache_flat_get_index(const struct regmap *map,
+                                                   unsigned int reg)
+{
+        return regcache_get_index_by_order(map, reg);
+}
+
 static int regcache_flat_init(struct regmap *map)
 {
         int i;
         unsigned int *cache;
 
-        map->cache = kcalloc(map->max_register + 1, sizeof(unsigned int),
-                             GFP_KERNEL);
+        if (!map || map->reg_stride_order < 0)
+                return -EINVAL;
+
+        map->cache = kcalloc(regcache_flat_get_index(map, map->max_register)
+                             + 1, sizeof(unsigned int), GFP_KERNEL);
         if (!map->cache)
                 return -ENOMEM;
 
         cache = map->cache;
 
         for (i = 0; i < map->num_reg_defaults; i++)
-                cache[map->reg_defaults[i].reg] = map->reg_defaults[i].def;
+                cache[regcache_flat_get_index(map, map->reg_defaults[i].reg)] =
+                                map->reg_defaults[i].def;
 
         return 0;
 }
@@ -47,7 +57,7 @@ static int regcache_flat_read(struct regmap *map,
 {
         unsigned int *cache = map->cache;
 
-        *value = cache[reg];
+        *value = cache[regcache_flat_get_index(map, reg)];
 
         return 0;
 }
@@ -57,7 +67,7 @@ static int regcache_flat_write(struct regmap *map, unsigned int reg,
 {
         unsigned int *cache = map->cache;
 
-        cache[reg] = value;
+        cache[regcache_flat_get_index(map, reg)] = value;
 
         return 0;
 }
diff --git a/drivers/base/regmap/regcache.c b/drivers/base/regmap/regcache.c
index 348be3a35410..4170b7d95276 100644
--- a/drivers/base/regmap/regcache.c
+++ b/drivers/base/regmap/regcache.c
@@ -30,7 +30,7 @@ static int regcache_hw_init(struct regmap *map)
         int i, j;
         int ret;
         int count;
-        unsigned int val;
+        unsigned int reg, val;
         void *tmp_buf;
 
         if (!map->num_reg_defaults_raw)
@@ -57,7 +57,7 @@ static int regcache_hw_init(struct regmap *map)
                 bool cache_bypass = map->cache_bypass;
                 dev_warn(map->dev, "No cache defaults, reading back from HW\n");
 
-                /* Bypass the cache access till data read from HW*/
+                /* Bypass the cache access till data read from HW */
                 map->cache_bypass = true;
                 tmp_buf = kmalloc(map->cache_size_raw, GFP_KERNEL);
                 if (!tmp_buf) {
@@ -65,29 +65,48 @@ static int regcache_hw_init(struct regmap *map)
                         goto err_free;
                 }
                 ret = regmap_raw_read(map, 0, tmp_buf,
-                                      map->num_reg_defaults_raw);
+                                      map->cache_size_raw);
                 map->cache_bypass = cache_bypass;
-                if (ret < 0)
-                        goto err_cache_free;
-
-                map->reg_defaults_raw = tmp_buf;
-                map->cache_free = 1;
+                if (ret == 0) {
+                        map->reg_defaults_raw = tmp_buf;
+                        map->cache_free = 1;
+                } else {
+                        kfree(tmp_buf);
+                }
         }
 
         /* fill the reg_defaults */
         for (i = 0, j = 0; i < map->num_reg_defaults_raw; i++) {
-                if (regmap_volatile(map, i * map->reg_stride))
+                reg = i * map->reg_stride;
+
+                if (!regmap_readable(map, reg))
                         continue;
-                val = regcache_get_val(map, map->reg_defaults_raw, i);
-                map->reg_defaults[j].reg = i * map->reg_stride;
+
+                if (regmap_volatile(map, reg))
+                        continue;
+
+                if (map->reg_defaults_raw) {
+                        val = regcache_get_val(map, map->reg_defaults_raw, i);
+                } else {
+                        bool cache_bypass = map->cache_bypass;
+
+                        map->cache_bypass = true;
+                        ret = regmap_read(map, reg, &val);
+                        map->cache_bypass = cache_bypass;
+                        if (ret != 0) {
+                                dev_err(map->dev, "Failed to read %d: %d\n",
+                                        reg, ret);
+                                goto err_free;
+                        }
+                }
+
+                map->reg_defaults[j].reg = reg;
                 map->reg_defaults[j].def = val;
                 j++;
         }
 
         return 0;
 
-err_cache_free:
-        kfree(tmp_buf);
 err_free:
         kfree(map->reg_defaults);
 
diff --git a/drivers/base/regmap/regmap-irq.c b/drivers/base/regmap/regmap-irq.c
index 9b0d202414d0..26f799e71c82 100644
--- a/drivers/base/regmap/regmap-irq.c
+++ b/drivers/base/regmap/regmap-irq.c
@@ -379,6 +379,7 @@ static int regmap_irq_map(struct irq_domain *h, unsigned int virq,
         irq_set_chip_data(virq, data);
         irq_set_chip(virq, &data->irq_chip);
         irq_set_nested_thread(virq, 1);
+        irq_set_parent(virq, data->irq);
         irq_set_noprobe(virq);
 
         return 0;
@@ -655,13 +656,34 @@ EXPORT_SYMBOL_GPL(regmap_add_irq_chip);
  *
  * @irq: Primary IRQ for the device
  * @d:   regmap_irq_chip_data allocated by regmap_add_irq_chip()
+ *
+ * This function also dispose all mapped irq on chip.
  */
 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *d)
 {
+        unsigned int virq;
+        int hwirq;
+
         if (!d)
                 return;
 
         free_irq(irq, d);
+
+        /* Dispose all virtual irq from irq domain before removing it */
+        for (hwirq = 0; hwirq < d->chip->num_irqs; hwirq++) {
+                /* Ignore hwirq if holes in the IRQ list */
+                if (!d->chip->irqs[hwirq].mask)
+                        continue;
+
+                /*
+                 * Find the virtual irq of hwirq on chip and if it is
+                 * there then dispose it
+                 */
+                virq = irq_find_mapping(d->domain, hwirq);
+                if (virq)
+                        irq_dispose_mapping(virq);
+        }
+
         irq_domain_remove(d->domain);
         kfree(d->type_buf);
         kfree(d->type_buf_def);
@@ -674,6 +696,88 @@ void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *d)
 }
 EXPORT_SYMBOL_GPL(regmap_del_irq_chip);
 
+static void devm_regmap_irq_chip_release(struct device *dev, void *res)
+{
+        struct regmap_irq_chip_data *d = *(struct regmap_irq_chip_data **)res;
+
+        regmap_del_irq_chip(d->irq, d);
+}
+
+static int devm_regmap_irq_chip_match(struct device *dev, void *res, void *data)
+
+{
+        struct regmap_irq_chip_data **r = res;
+
+        if (!r || !*r) {
+                WARN_ON(!r || !*r);
+                return 0;
+        }
+        return *r == data;
+}
+
+/**
+ * devm_regmap_add_irq_chip(): Resource manager regmap_add_irq_chip()
+ *
+ * @dev:       The device pointer on which irq_chip belongs to.
+ * @map:       The regmap for the device.
+ * @irq:       The IRQ the device uses to signal interrupts
+ * @irq_flags: The IRQF_ flags to use for the primary interrupt.
+ * @chip:      Configuration for the interrupt controller.
+ * @data:      Runtime data structure for the controller, allocated on success
+ *
+ * Returns 0 on success or an errno on failure.
+ *
+ * The regmap_irq_chip data automatically be released when the device is
+ * unbound.
+ */
+int devm_regmap_add_irq_chip(struct device *dev, struct regmap *map, int irq,
+                             int irq_flags, int irq_base,
+                             const struct regmap_irq_chip *chip,
+                             struct regmap_irq_chip_data **data)
+{
+        struct regmap_irq_chip_data **ptr, *d;
+        int ret;
+
+        ptr = devres_alloc(devm_regmap_irq_chip_release, sizeof(*ptr),
+                           GFP_KERNEL);
+        if (!ptr)
+                return -ENOMEM;
+
+        ret = regmap_add_irq_chip(map, irq, irq_flags, irq_base,
+                                  chip, &d);
+        if (ret < 0) {
+                devres_free(ptr);
+                return ret;
+        }
+
+        *ptr = d;
+        devres_add(dev, ptr);
+        *data = d;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(devm_regmap_add_irq_chip);
+
+/**
+ * devm_regmap_del_irq_chip(): Resource managed regmap_del_irq_chip()
+ *
+ * @dev: Device for which which resource was allocated.
+ * @irq: Primary IRQ for the device
+ * @d:   regmap_irq_chip_data allocated by regmap_add_irq_chip()
+ */
+void devm_regmap_del_irq_chip(struct device *dev, int irq,
+                              struct regmap_irq_chip_data *data)
+{
+        int rc;
+
+        WARN_ON(irq != data->irq);
+        rc = devres_release(dev, devm_regmap_irq_chip_release,
+                            devm_regmap_irq_chip_match, data);
+
+        if (rc != 0)
+                WARN_ON(rc);
+}
+EXPORT_SYMBOL_GPL(devm_regmap_del_irq_chip);
+
 /**
  * regmap_irq_chip_get_base(): Retrieve interrupt base for a regmap IRQ chip
  *
diff --git a/drivers/base/regmap/regmap-mmio.c b/drivers/base/regmap/regmap-mmio.c
index eea51569f0eb..7526906ca080 100644
--- a/drivers/base/regmap/regmap-mmio.c
+++ b/drivers/base/regmap/regmap-mmio.c
@@ -25,26 +25,14 @@
 
 struct regmap_mmio_context {
         void __iomem *regs;
-        unsigned reg_bytes;
         unsigned val_bytes;
-        unsigned pad_bytes;
         struct clk *clk;
-};
 
-static inline void regmap_mmio_regsize_check(size_t reg_size)
-{
-        switch (reg_size) {
-        case 1:
-        case 2:
-        case 4:
-#ifdef CONFIG_64BIT
-        case 8:
-#endif
-                break;
-        default:
-                BUG();
-        }
-}
+        void (*reg_write)(struct regmap_mmio_context *ctx,
+                          unsigned int reg, unsigned int val);
+        unsigned int (*reg_read)(struct regmap_mmio_context *ctx,
+                                 unsigned int reg);
+};
 
 static int regmap_mmio_regbits_check(size_t reg_bits)
 {
@@ -88,72 +76,62 @@ static int regmap_mmio_get_min_stride(size_t val_bits)
         return min_stride;
 }
 
-static inline void regmap_mmio_count_check(size_t count, u32 offset)
+static void regmap_mmio_write8(struct regmap_mmio_context *ctx,
+                                unsigned int reg,
+                                unsigned int val)
+{
+        writeb(val, ctx->regs + reg);
+}
+
+static void regmap_mmio_write16le(struct regmap_mmio_context *ctx,
+                                  unsigned int reg,
+                                  unsigned int val)
 {
-        BUG_ON(count <= offset);
+        writew(val, ctx->regs + reg);
 }
 
-static inline unsigned int
-regmap_mmio_get_offset(const void *reg, size_t reg_size)
+static void regmap_mmio_write16be(struct regmap_mmio_context *ctx,
+                                  unsigned int reg,
+                                  unsigned int val)
 {
-        switch (reg_size) {
-        case 1:
-                return *(u8 *)reg;
-        case 2:
-                return *(u16 *)reg;
-        case 4:
-                return *(u32 *)reg;
+        iowrite16be(val, ctx->regs + reg);
+}
+
+static void regmap_mmio_write32le(struct regmap_mmio_context *ctx,
+                                  unsigned int reg,
+                                  unsigned int val)
+{
+        writel(val, ctx->regs + reg);
+}
+
+static void regmap_mmio_write32be(struct regmap_mmio_context *ctx,
+                                  unsigned int reg,
+                                  unsigned int val)
+{
+        iowrite32be(val, ctx->regs + reg);
+}
+
 #ifdef CONFIG_64BIT
-        case 8:
-                return *(u64 *)reg;
-#endif
-        default:
-                BUG();
-        }
+static void regmap_mmio_write64le(struct regmap_mmio_context *ctx,
+                                  unsigned int reg,
+                                  unsigned int val)
+{
+        writeq(val, ctx->regs + reg);
 }
+#endif
 
-static int regmap_mmio_gather_write(void *context,
-                                    const void *reg, size_t reg_size,
-                                    const void *val, size_t val_size)
+static int regmap_mmio_write(void *context, unsigned int reg, unsigned int val)
 {
         struct regmap_mmio_context *ctx = context;
-        unsigned int offset;
         int ret;
 
-        regmap_mmio_regsize_check(reg_size);
-
         if (!IS_ERR(ctx->clk)) {
                 ret = clk_enable(ctx->clk);
                 if (ret < 0)
                         return ret;
         }
 
-        offset = regmap_mmio_get_offset(reg, reg_size);
-
-        while (val_size) {
-                switch (ctx->val_bytes) {
-                case 1:
-                        writeb(*(u8 *)val, ctx->regs + offset);
-                        break;
-                case 2:
-                        writew(*(u16 *)val, ctx->regs + offset);
-                        break;
-                case 4:
-                        writel(*(u32 *)val, ctx->regs + offset);
-                        break;
-#ifdef CONFIG_64BIT
-                case 8:
-                        writeq(*(u64 *)val, ctx->regs + offset);
-                        break;
-#endif
-                default:
-                        /* Should be caught by regmap_mmio_check_config */
-                        BUG();
-                }
-                val_size -= ctx->val_bytes;
-                val += ctx->val_bytes;
-                offset += ctx->val_bytes;
-        }
+        ctx->reg_write(ctx, reg, val);
 
         if (!IS_ERR(ctx->clk))
                 clk_disable(ctx->clk);
@@ -161,59 +139,56 @@ static int regmap_mmio_gather_write(void *context,
         return 0;
 }
 
-static int regmap_mmio_write(void *context, const void *data, size_t count)
+static unsigned int regmap_mmio_read8(struct regmap_mmio_context *ctx,
+                                      unsigned int reg)
 {
-        struct regmap_mmio_context *ctx = context;
-        unsigned int offset = ctx->reg_bytes + ctx->pad_bytes;
+        return readb(ctx->regs + reg);
+}
+
+static unsigned int regmap_mmio_read16le(struct regmap_mmio_context *ctx,
+                                         unsigned int reg)
+{
+        return readw(ctx->regs + reg);
+}
+
+static unsigned int regmap_mmio_read16be(struct regmap_mmio_context *ctx,
+                                         unsigned int reg)
+{
+        return ioread16be(ctx->regs + reg);
+}
+
+static unsigned int regmap_mmio_read32le(struct regmap_mmio_context *ctx,
+                                         unsigned int reg)
+{
+        return readl(ctx->regs + reg);
+}
 
-        regmap_mmio_count_check(count, offset);
+static unsigned int regmap_mmio_read32be(struct regmap_mmio_context *ctx,
+                                         unsigned int reg)
+{
+        return ioread32be(ctx->regs + reg);
+}
 
-        return regmap_mmio_gather_write(context, data, ctx->reg_bytes,
-                                        data + offset, count - offset);
+#ifdef CONFIG_64BIT
+static unsigned int regmap_mmio_read64le(struct regmap_mmio_context *ctx,
+                                         unsigned int reg)
+{
+        return readq(ctx->regs + reg);
 }
+#endif
 
-static int regmap_mmio_read(void *context,
-                            const void *reg, size_t reg_size,
-                            void *val, size_t val_size)
+static int regmap_mmio_read(void *context, unsigned int reg, unsigned int *val)
 {
         struct regmap_mmio_context *ctx = context;
-        unsigned int offset;
         int ret;
 
-        regmap_mmio_regsize_check(reg_size);
-
         if (!IS_ERR(ctx->clk)) {
                 ret = clk_enable(ctx->clk);
                 if (ret < 0)
                         return ret;
         }
 
-        offset = regmap_mmio_get_offset(reg, reg_size);
-
-        while (val_size) {
-                switch (ctx->val_bytes) {
-                case 1:
-                        *(u8 *)val = readb(ctx->regs + offset);
-                        break;
-                case 2:
-                        *(u16 *)val = readw(ctx->regs + offset);
-                        break;
-                case 4:
-                        *(u32 *)val = readl(ctx->regs + offset);
-                        break;
-#ifdef CONFIG_64BIT
-                case 8:
-                        *(u64 *)val = readq(ctx->regs + offset);
-                        break;
-#endif
-                default:
-                        /* Should be caught by regmap_mmio_check_config */
-                        BUG();
-                }
-                val_size -= ctx->val_bytes;
-                val += ctx->val_bytes;
-                offset += ctx->val_bytes;
-        }
+        *val = ctx->reg_read(ctx, reg);
 
         if (!IS_ERR(ctx->clk))
                 clk_disable(ctx->clk);
@@ -232,14 +207,11 @@ static void regmap_mmio_free_context(void *context)
         kfree(context);
 }
 
-static struct regmap_bus regmap_mmio = {
+static const struct regmap_bus regmap_mmio = {
         .fast_io = true,
-        .write = regmap_mmio_write,
-        .gather_write = regmap_mmio_gather_write,
-        .read = regmap_mmio_read,
+        .reg_write = regmap_mmio_write,
+        .reg_read = regmap_mmio_read,
         .free_context = regmap_mmio_free_context,
-        .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
-        .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
 };
 
 static struct regmap_mmio_context *regmap_mmio_gen_context(struct device *dev,
@@ -265,24 +237,71 @@ static struct regmap_mmio_context *regmap_mmio_gen_context(struct device *dev,
         if (config->reg_stride < min_stride)
                 return ERR_PTR(-EINVAL);
 
-        switch (config->reg_format_endian) {
-        case REGMAP_ENDIAN_DEFAULT:
-        case REGMAP_ENDIAN_NATIVE:
-                break;
-        default:
-                return ERR_PTR(-EINVAL);
-        }
-
         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
         if (!ctx)
                 return ERR_PTR(-ENOMEM);
 
         ctx->regs = regs;
         ctx->val_bytes = config->val_bits / 8;
-        ctx->reg_bytes = config->reg_bits / 8;
-        ctx->pad_bytes = config->pad_bits / 8;
         ctx->clk = ERR_PTR(-ENODEV);
 
+        switch (config->reg_format_endian) {
+        case REGMAP_ENDIAN_DEFAULT:
+        case REGMAP_ENDIAN_LITTLE:
+#ifdef __LITTLE_ENDIAN
+        case REGMAP_ENDIAN_NATIVE:
+#endif
+                switch (config->val_bits) {
+                case 8:
+                        ctx->reg_read = regmap_mmio_read8;
+                        ctx->reg_write = regmap_mmio_write8;
+                        break;
+                case 16:
+                        ctx->reg_read = regmap_mmio_read16le;
+                        ctx->reg_write = regmap_mmio_write16le;
+                        break;
+                case 32:
+                        ctx->reg_read = regmap_mmio_read32le;
+                        ctx->reg_write = regmap_mmio_write32le;
+                        break;
+#ifdef CONFIG_64BIT
+                case 64:
+                        ctx->reg_read = regmap_mmio_read64le;
+                        ctx->reg_write = regmap_mmio_write64le;
+                        break;
+#endif
+                default:
+                        ret = -EINVAL;
+                        goto err_free;
+                }
+                break;
+        case REGMAP_ENDIAN_BIG:
+#ifdef __BIG_ENDIAN
+        case REGMAP_ENDIAN_NATIVE:
+#endif
+                switch (config->val_bits) {
+                case 8:
+                        ctx->reg_read = regmap_mmio_read8;
+                        ctx->reg_write = regmap_mmio_write8;
+                        break;
+                case 16:
+                        ctx->reg_read = regmap_mmio_read16be;
+                        ctx->reg_write = regmap_mmio_write16be;
+                        break;
+                case 32:
+                        ctx->reg_read = regmap_mmio_read32be;
+                        ctx->reg_write = regmap_mmio_write32be;
+                        break;
+                default:
+                        ret = -EINVAL;
+                        goto err_free;
+                }
+                break;
+        default:
+                ret = -EINVAL;
+                goto err_free;
+        }
+
         if (clk_id == NULL)
                 return ctx;
 
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index ee54e841de4a..df2d2ef5d6b3 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -19,6 +19,7 @@
 #include <linux/rbtree.h>
 #include <linux/sched.h>
 #include <linux/delay.h>
+#include <linux/log2.h>
 
 #define CREATE_TRACE_POINTS
 #include "trace.h"
@@ -557,6 +558,8 @@ enum regmap_endian regmap_get_val_endian(struct device *dev,
                         endian = REGMAP_ENDIAN_BIG;
                 else if (of_property_read_bool(np, "little-endian"))
                         endian = REGMAP_ENDIAN_LITTLE;
+                else if (of_property_read_bool(np, "native-endian"))
+                        endian = REGMAP_ENDIAN_NATIVE;
 
                 /* If the endianness was specified in DT, use that */
                 if (endian != REGMAP_ENDIAN_DEFAULT)
@@ -638,6 +641,10 @@ struct regmap *__regmap_init(struct device *dev,
                 map->reg_stride = config->reg_stride;
         else
                 map->reg_stride = 1;
+        if (is_power_of_2(map->reg_stride))
+                map->reg_stride_order = ilog2(map->reg_stride);
+        else
+                map->reg_stride_order = -1;
         map->use_single_read = config->use_single_rw || !bus || !bus->read;
         map->use_single_write = config->use_single_rw || !bus || !bus->write;
         map->can_multi_write = config->can_multi_write && bus && bus->write;
@@ -1308,7 +1315,7 @@ int _regmap_raw_write(struct regmap *map, unsigned int reg,
         if (map->writeable_reg)
                 for (i = 0; i < val_len / map->format.val_bytes; i++)
                         if (!map->writeable_reg(map->dev,
-                                                reg + (i * map->reg_stride)))
+                                               reg + regmap_get_offset(map, i)))
                                 return -EINVAL;
 
         if (!map->cache_bypass && map->format.parse_val) {
@@ -1316,7 +1323,8 @@ int _regmap_raw_write(struct regmap *map, unsigned int reg,
                 int val_bytes = map->format.val_bytes;
                 for (i = 0; i < val_len / val_bytes; i++) {
                         ival = map->format.parse_val(val + (i * val_bytes));
-                        ret = regcache_write(map, reg + (i * map->reg_stride),
+                        ret = regcache_write(map,
+                                             reg + regmap_get_offset(map, i),
                                              ival);
                         if (ret) {
                                 dev_err(map->dev,
@@ -1690,100 +1698,63 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
 EXPORT_SYMBOL_GPL(regmap_raw_write);
 
 /**
- * regmap_field_write(): Write a value to a single register field
- *
- * @field: Register field to write to
- * @val: Value to be written
- *
- * A value of zero will be returned on success, a negative errno will
- * be returned in error cases.
- */
-int regmap_field_write(struct regmap_field *field, unsigned int val)
-{
-        return regmap_update_bits(field->regmap, field->reg,
-                                field->mask, val << field->shift);
-}
-EXPORT_SYMBOL_GPL(regmap_field_write);
-
-/**
- * regmap_field_update_bits():  Perform a read/modify/write cycle
- *                              on the register field
+ * regmap_field_update_bits_base():
+ *      Perform a read/modify/write cycle on the register field
+ *      with change, async, force option
  *
  * @field: Register field to write to
  * @mask: Bitmask to change
  * @val: Value to be written
+ * @change: Boolean indicating if a write was done
+ * @async: Boolean indicating asynchronously
+ * @force: Boolean indicating use force update
  *
  * A value of zero will be returned on success, a negative errno will
  * be returned in error cases.
  */
-int regmap_field_update_bits(struct regmap_field *field, unsigned int mask, unsigned int val)
+int regmap_field_update_bits_base(struct regmap_field *field,
+                                  unsigned int mask, unsigned int val,
+                                  bool *change, bool async, bool force)
 {
         mask = (mask << field->shift) & field->mask;
 
-        return regmap_update_bits(field->regmap, field->reg,
-                                  mask, val << field->shift);
+        return regmap_update_bits_base(field->regmap, field->reg,
+                                       mask, val << field->shift,
+                                       change, async, force);
 }
-EXPORT_SYMBOL_GPL(regmap_field_update_bits);
+EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
 
 /**
- * regmap_fields_write(): Write a value to a single register field with port ID
- *
- * @field: Register field to write to
- * @id: port ID
- * @val: Value to be written
- *
- * A value of zero will be returned on success, a negative errno will
- * be returned in error cases.
- */
-int regmap_fields_write(struct regmap_field *field, unsigned int id,
-                        unsigned int val)
-{
-        if (id >= field->id_size)
-                return -EINVAL;
-
-        return regmap_update_bits(field->regmap,
-                                  field->reg + (field->id_offset * id),
-                                  field->mask, val << field->shift);
-}
-EXPORT_SYMBOL_GPL(regmap_fields_write);
-
-int regmap_fields_force_write(struct regmap_field *field, unsigned int id,
-                        unsigned int val)
-{
-        if (id >= field->id_size)
-                return -EINVAL;
-
-        return regmap_write_bits(field->regmap,
-                                  field->reg + (field->id_offset * id),
-                                  field->mask, val << field->shift);
-}
-EXPORT_SYMBOL_GPL(regmap_fields_force_write);
-
-/**
- * regmap_fields_update_bits(): Perform a read/modify/write cycle
- *                              on the register field
+ * regmap_fields_update_bits_base():
+ *      Perform a read/modify/write cycle on the register field
+ *      with change, async, force option
  *
  * @field: Register field to write to
  * @id: port ID
  * @mask: Bitmask to change
  * @val: Value to be written
+ * @change: Boolean indicating if a write was done
+ * @async: Boolean indicating asynchronously
+ * @force: Boolean indicating use force update
  *
  * A value of zero will be returned on success, a negative errno will
  * be returned in error cases.
  */
-int regmap_fields_update_bits(struct regmap_field *field,  unsigned int id,
-                              unsigned int mask, unsigned int val)
+int regmap_fields_update_bits_base(struct regmap_field *field,  unsigned int id,
+                                   unsigned int mask, unsigned int val,
+                                   bool *change, bool async, bool force)
 {
         if (id >= field->id_size)
                 return -EINVAL;
 
         mask = (mask << field->shift) & field->mask;
 
-        return regmap_update_bits(field->regmap,
-                                  field->reg + (field->id_offset * id),
-                                  mask, val << field->shift);
+        return regmap_update_bits_base(field->regmap,
+                                       field->reg + (field->id_offset * id),
+                                       mask, val << field->shift,
+                                       change, async, force);
 }
-EXPORT_SYMBOL_GPL(regmap_fields_update_bits);
+EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
 
 /*
  * regmap_bulk_write(): Write multiple registers to the device
@@ -1846,8 +1817,9 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
                                 goto out;
                         }
 
-                        ret = _regmap_write(map, reg + (i * map->reg_stride),
-                                        ival);
+                        ret = _regmap_write(map,
+                                            reg + regmap_get_offset(map, i),
+                                            ival);
                         if (ret != 0)
                                 goto out;
                 }
@@ -2253,6 +2225,9 @@ static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
 
         WARN_ON(!map->bus);
 
+        if (!map->bus || !map->bus->read)
+                return -EINVAL;
+
         range = _regmap_range_lookup(map, reg);
         if (range) {
                 ret = _regmap_select_page(map, &reg, range,
@@ -2416,7 +2391,7 @@ int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
                  * cost as we expect to hit the cache.
                  */
                 for (i = 0; i < val_count; i++) {
-                        ret = _regmap_read(map, reg + (i * map->reg_stride),
+                        ret = _regmap_read(map, reg + regmap_get_offset(map, i),
                                            &v);
                         if (ret != 0)
                                 goto out;
@@ -2568,7 +2543,7 @@ int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
         } else {
                 for (i = 0; i < val_count; i++) {
                         unsigned int ival;
-                        ret = regmap_read(map, reg + (i * map->reg_stride),
+                        ret = regmap_read(map, reg + regmap_get_offset(map, i),
                                           &ival);
                         if (ret != 0)
                                 return ret;
@@ -2648,138 +2623,36 @@ static int _regmap_update_bits(struct regmap *map, unsigned int reg,
 }
 
 /**
- * regmap_update_bits: Perform a read/modify/write cycle on the register map
- *
- * @map: Register map to update
- * @reg: Register to update
- * @mask: Bitmask to change
- * @val: New value for bitmask
- *
- * Returns zero for success, a negative number on error.
- */
-int regmap_update_bits(struct regmap *map, unsigned int reg,
-                       unsigned int mask, unsigned int val)
-{
-        int ret;
-
-        map->lock(map->lock_arg);
-        ret = _regmap_update_bits(map, reg, mask, val, NULL, false);
-        map->unlock(map->lock_arg);
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(regmap_update_bits);
-
-/**
- * regmap_write_bits: Perform a read/modify/write cycle on the register map
- *
- * @map: Register map to update
- * @reg: Register to update
- * @mask: Bitmask to change
- * @val: New value for bitmask
- *
- * Returns zero for success, a negative number on error.
- */
-int regmap_write_bits(struct regmap *map, unsigned int reg,
-                      unsigned int mask, unsigned int val)
-{
-        int ret;
-
-        map->lock(map->lock_arg);
-        ret = _regmap_update_bits(map, reg, mask, val, NULL, true);
-        map->unlock(map->lock_arg);
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(regmap_write_bits);
-
-/**
- * regmap_update_bits_async: Perform a read/modify/write cycle on the register
- *                           map asynchronously
- *
- * @map: Register map to update
- * @reg: Register to update
- * @mask: Bitmask to change
- * @val: New value for bitmask
- *
- * With most buses the read must be done synchronously so this is most
- * useful for devices with a cache which do not need to interact with
- * the hardware to determine the current register value.
- *
- * Returns zero for success, a negative number on error.
- */
-int regmap_update_bits_async(struct regmap *map, unsigned int reg,
-                             unsigned int mask, unsigned int val)
-{
-        int ret;
-
-        map->lock(map->lock_arg);
-
-        map->async = true;
-
-        ret = _regmap_update_bits(map, reg, mask, val, NULL, false);
-
-        map->async = false;
-
-        map->unlock(map->lock_arg);
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(regmap_update_bits_async);
-
-/**
- * regmap_update_bits_check: Perform a read/modify/write cycle on the
- *                           register map and report if updated
- *
- * @map: Register map to update
- * @reg: Register to update
- * @mask: Bitmask to change
- * @val: New value for bitmask
- * @change: Boolean indicating if a write was done
- *
- * Returns zero for success, a negative number on error.
- */
-int regmap_update_bits_check(struct regmap *map, unsigned int reg,
-                             unsigned int mask, unsigned int val,
-                             bool *change)
-{
-        int ret;
-
-        map->lock(map->lock_arg);
-        ret = _regmap_update_bits(map, reg, mask, val, change, false);
-        map->unlock(map->lock_arg);
-        return ret;
-}
-EXPORT_SYMBOL_GPL(regmap_update_bits_check);
-
-/**
- * regmap_update_bits_check_async: Perform a read/modify/write cycle on the
- *                                 register map asynchronously and report if
- *                                 updated
+ * regmap_update_bits_base:
+ *      Perform a read/modify/write cycle on the
+ *      register map with change, async, force option
  *
  * @map: Register map to update
  * @reg: Register to update
  * @mask: Bitmask to change
  * @val: New value for bitmask
  * @change: Boolean indicating if a write was done
+ * @async: Boolean indicating asynchronously
+ * @force: Boolean indicating use force update
  *
+ * if async was true,
  * With most buses the read must be done synchronously so this is most
  * useful for devices with a cache which do not need to interact with
  * the hardware to determine the current register value.
  *
  * Returns zero for success, a negative number on error.
  */
-int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
-                                   unsigned int mask, unsigned int val,
-                                   bool *change)
+int regmap_update_bits_base(struct regmap *map, unsigned int reg,
+                            unsigned int mask, unsigned int val,
+                            bool *change, bool async, bool force)
 {
         int ret;
 
         map->lock(map->lock_arg);
 
-        map->async = true;
+        map->async = async;
 
-        ret = _regmap_update_bits(map, reg, mask, val, change, false);
+        ret = _regmap_update_bits(map, reg, mask, val, change, force);
 
         map->async = false;
 
@@ -2787,7 +2660,7 @@ int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
 
         return ret;
 }
-EXPORT_SYMBOL_GPL(regmap_update_bits_check_async);
+EXPORT_SYMBOL_GPL(regmap_update_bits_base);
 
 void regmap_async_complete_cb(struct regmap_async *async, int ret)
 {
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 18394343f489..3dc08ce15426 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -65,6 +65,36 @@ struct reg_sequence {
         unsigned int delay_us;
 };
 
+#define regmap_update_bits(map, reg, mask, val) \
+        regmap_update_bits_base(map, reg, mask, val, NULL, false, false)
+#define regmap_update_bits_async(map, reg, mask, val)\
+        regmap_update_bits_base(map, reg, mask, val, NULL, true, false)
+#define regmap_update_bits_check(map, reg, mask, val, change)\
+        regmap_update_bits_base(map, reg, mask, val, change, false, false)
+#define regmap_update_bits_check_async(map, reg, mask, val, change)\
+        regmap_update_bits_base(map, reg, mask, val, change, true, false)
+
+#define regmap_write_bits(map, reg, mask, val) \
+        regmap_update_bits_base(map, reg, mask, val, NULL, false, true)
+
+#define regmap_field_write(field, val) \
+        regmap_field_update_bits_base(field, ~0, val, NULL, false, false)
+#define regmap_field_force_write(field, val) \
+        regmap_field_update_bits_base(field, ~0, val, NULL, false, true)
+#define regmap_field_update_bits(field, mask, val)\
+        regmap_field_update_bits_base(field, mask, val, NULL, false, false)
+#define regmap_field_force_update_bits(field, mask, val) \
+        regmap_field_update_bits_base(field, mask, val, NULL, false, true)
+
+#define regmap_fields_write(field, id, val) \
+        regmap_fields_update_bits_base(field, id, ~0, val, NULL, false, false)
+#define regmap_fields_force_write(field, id, val) \
+        regmap_fields_update_bits_base(field, id, ~0, val, NULL, false, true)
+#define regmap_fields_update_bits(field, id, mask, val)\
+        regmap_fields_update_bits_base(field, id, mask, val, NULL, false, false)
+#define regmap_fields_force_update_bits(field, id, mask, val) \
+        regmap_fields_update_bits_base(field, id, mask, val, NULL, false, true)
+
 #ifdef CONFIG_REGMAP
 
 enum regmap_endian {
@@ -162,7 +192,7 @@ typedef void (*regmap_unlock)(void *);
  *                This field is a duplicate of a similar file in
  *                'struct regmap_bus' and serves exact same purpose.
  *                 Use it only for "no-bus" cases.
- * @max_register: Optional, specifies the maximum valid register index.
+ * @max_register: Optional, specifies the maximum valid register address.
  * @wr_table:     Optional, points to a struct regmap_access_table specifying
  *                valid ranges for write access.
  * @rd_table:     As above, for read access.
@@ -691,18 +721,9 @@ int regmap_raw_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,
                      size_t val_count);
-int regmap_update_bits(struct regmap *map, unsigned int reg,
-                       unsigned int mask, unsigned int val);
-int regmap_write_bits(struct regmap *map, unsigned int reg,
-                       unsigned int mask, unsigned int val);
-int regmap_update_bits_async(struct regmap *map, unsigned int reg,
-                             unsigned int mask, unsigned int val);
-int regmap_update_bits_check(struct regmap *map, unsigned int reg,
-                             unsigned int mask, unsigned int val,
-                             bool *change);
-int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
-                                   unsigned int mask, unsigned int val,
-                                   bool *change);
+int regmap_update_bits_base(struct regmap *map, unsigned int reg,
+                            unsigned int mask, unsigned int val,
+                            bool *change, bool async, bool force);
 int regmap_get_val_bytes(struct regmap *map);
 int regmap_get_max_register(struct regmap *map);
 int regmap_get_reg_stride(struct regmap *map);
@@ -770,18 +791,14 @@ struct regmap_field *devm_regmap_field_alloc(struct device *dev,
 void devm_regmap_field_free(struct device *dev, struct regmap_field *field);
 
 int regmap_field_read(struct regmap_field *field, unsigned int *val);
-int regmap_field_write(struct regmap_field *field, unsigned int val);
-int regmap_field_update_bits(struct regmap_field *field,
-                             unsigned int mask, unsigned int val);
-
-int regmap_fields_write(struct regmap_field *field, unsigned int id,
-                        unsigned int val);
-int regmap_fields_force_write(struct regmap_field *field, unsigned int id,
-                        unsigned int val);
+int regmap_field_update_bits_base(struct regmap_field *field,
+                                  unsigned int mask, unsigned int val,
+                                  bool *change, bool async, bool force);
 int regmap_fields_read(struct regmap_field *field, unsigned int id,
                        unsigned int *val);
-int regmap_fields_update_bits(struct regmap_field *field,  unsigned int id,
-                              unsigned int mask, unsigned int val);
+int regmap_fields_update_bits_base(struct regmap_field *field,  unsigned int id,
+                                   unsigned int mask, unsigned int val,
+                                   bool *change, bool async, bool force);
 
 /**
  * Description of an IRQ for the generic regmap irq_chip.
@@ -868,6 +885,14 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
                         int irq_base, const struct regmap_irq_chip *chip,
                         struct regmap_irq_chip_data **data);
 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
+
+int devm_regmap_add_irq_chip(struct device *dev, struct regmap *map, int irq,
+                             int irq_flags, int irq_base,
+                             const struct regmap_irq_chip *chip,
+                             struct regmap_irq_chip_data **data);
+void devm_regmap_del_irq_chip(struct device *dev, int irq,
+                              struct regmap_irq_chip_data *data);
+
 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
 int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
 struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
@@ -937,42 +962,26 @@ static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
         return -EINVAL;
 }
 
-static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
-                                     unsigned int mask, unsigned int val)
-{
-        WARN_ONCE(1, "regmap API is disabled");
-        return -EINVAL;
-}
-
-static inline int regmap_write_bits(struct regmap *map, unsigned int reg,
-                                     unsigned int mask, unsigned int val)
-{
-        WARN_ONCE(1, "regmap API is disabled");
-        return -EINVAL;
-}
-
-static inline int regmap_update_bits_async(struct regmap *map,
-                                           unsigned int reg,
-                                           unsigned int mask, unsigned int val)
+static inline int regmap_update_bits_base(struct regmap *map, unsigned int reg,
+                                          unsigned int mask, unsigned int val,
+                                          bool *change, bool async, bool force)
 {
         WARN_ONCE(1, "regmap API is disabled");
         return -EINVAL;
 }
 
-static inline int regmap_update_bits_check(struct regmap *map,
-                                           unsigned int reg,
-                                           unsigned int mask, unsigned int val,
-                                           bool *change)
+static inline int regmap_field_update_bits_base(struct regmap_field *field,
+                                        unsigned int mask, unsigned int val,
+                                        bool *change, bool async, bool force)
 {
         WARN_ONCE(1, "regmap API is disabled");
         return -EINVAL;
 }
 
-static inline int regmap_update_bits_check_async(struct regmap *map,
-                                                 unsigned int reg,
-                                                 unsigned int mask,
-                                                 unsigned int val,
-                                                 bool *change)
+static inline int regmap_fields_update_bits_base(struct regmap_field *field,
+                                   unsigned int id,
+                                   unsigned int mask, unsigned int val,
+                                   bool *change, bool async, bool force)
 {
         WARN_ONCE(1, "regmap API is disabled");
         return -EINVAL;