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

Pull regmap updates from Mark Brown:
 "A quiet release for regmap, some cleanups, fixes and:

   - Improved node coalescing for rbtree, reducing memory usage and
     improving performance during syncs.
   - Support for registering multiple register patches.
   - A quirk for handling interrupts that need to be clear when masked
     in regmap-irq"

* tag 'regmap-v3.12' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap:
  regmap: rbtree: Make cache_present bitmap per node
  regmap: rbtree: Reduce number of nodes, take 2
  regmap: rbtree: Simplify adjacent node look-up
  regmap: debugfs: Fix continued read from registers file
  regcache-rbtree: Fix reg_stride != 1
  regmap: Allow multiple patches to be registered
  regmap: regcache: allow read-only regs to be cached
  regmap: fix regcache_reg_present() for empty cache
  regmap: core: allow a virtual range to cover its own data window
  regmap: irq: document mask/wake_invert flags
  regmap: irq: make flags bool and put them in a bitfield
  regmap: irq: Allow to acknowledge masked interrupts during initialization
  regmap: Provide __acquires/__releases annotations

6 files changed, 194 insertions, 131 deletions

diff --git a/drivers/base/regmap/internal.h b/drivers/base/regmap/internal.h
index 29c83160ca29..57f777835d97 100644
--- a/drivers/base/regmap/internal.h
+++ b/drivers/base/regmap/internal.h
@@ -128,9 +128,6 @@ struct regmap {
         void *cache;
         u32 cache_dirty;
 
-        unsigned long *cache_present;
-        unsigned int cache_present_nbits;
-
         struct reg_default *patch;
         int patch_regs;
 
@@ -203,6 +200,7 @@ int regcache_write(struct regmap *map,
                         unsigned int reg, unsigned int value);
 int regcache_sync(struct regmap *map);
 int regcache_sync_block(struct regmap *map, void *block,
+                        unsigned long *cache_present,
                         unsigned int block_base, unsigned int start,
                         unsigned int end);
 
@@ -218,16 +216,6 @@ unsigned int regcache_get_val(struct regmap *map, const void *base,
 bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,
                       unsigned int val);
 int regcache_lookup_reg(struct regmap *map, unsigned int reg);
-int regcache_set_reg_present(struct regmap *map, unsigned int reg);
-
-static inline bool regcache_reg_present(struct regmap *map, unsigned int reg)
-{
-        if (!map->cache_present)
-                return true;
-        if (reg > map->cache_present_nbits)
-                return false;
-        return map->cache_present[BIT_WORD(reg)] & BIT_MASK(reg);
-}
 
 int _regmap_raw_write(struct regmap *map, unsigned int reg,
                       const void *val, size_t val_len, bool async);
diff --git a/drivers/base/regmap/regcache-rbtree.c b/drivers/base/regmap/regcache-rbtree.c
index 0fccc99881fd..930cad4e5df8 100644
--- a/drivers/base/regmap/regcache-rbtree.c
+++ b/drivers/base/regmap/regcache-rbtree.c
@@ -29,6 +29,8 @@ struct regcache_rbtree_node {
         unsigned int base_reg;
         /* block of adjacent registers */
         void *block;
+        /* Which registers are present */
+        long *cache_present;
         /* number of registers available in the block */
         unsigned int blklen;
 } __attribute__ ((packed));
@@ -57,6 +59,7 @@ static void regcache_rbtree_set_register(struct regmap *map,
                                          struct regcache_rbtree_node *rbnode,
                                          unsigned int idx, unsigned int val)
 {
+        set_bit(idx, rbnode->cache_present);
         regcache_set_val(map, rbnode->block, idx, val);
 }
 
@@ -146,13 +149,13 @@ static int rbtree_show(struct seq_file *s, void *ignored)
         map->lock(map->lock_arg);
 
         mem_size = sizeof(*rbtree_ctx);
-        mem_size += BITS_TO_LONGS(map->cache_present_nbits) * sizeof(long);
 
         for (node = rb_first(&rbtree_ctx->root); node != NULL;
              node = rb_next(node)) {
                 n = container_of(node, struct regcache_rbtree_node, node);
                 mem_size += sizeof(*n);
                 mem_size += (n->blklen * map->cache_word_size);
+                mem_size += BITS_TO_LONGS(n->blklen) * sizeof(long);
 
                 regcache_rbtree_get_base_top_reg(map, n, &base, &top);
                 this_registers = ((top - base) / map->reg_stride) + 1;
@@ -245,6 +248,7 @@ static int regcache_rbtree_exit(struct regmap *map)
                 rbtree_node = rb_entry(next, struct regcache_rbtree_node, node);
                 next = rb_next(&rbtree_node->node);
                 rb_erase(&rbtree_node->node, &rbtree_ctx->root);
+                kfree(rbtree_node->cache_present);
                 kfree(rbtree_node->block);
                 kfree(rbtree_node);
         }
@@ -265,7 +269,7 @@ static int regcache_rbtree_read(struct regmap *map,
         rbnode = regcache_rbtree_lookup(map, reg);
         if (rbnode) {
                 reg_tmp = (reg - rbnode->base_reg) / map->reg_stride;
-                if (!regcache_reg_present(map, reg))
+                if (!test_bit(reg_tmp, rbnode->cache_present))
                         return -ENOENT;
                 *value = regcache_rbtree_get_register(map, rbnode, reg_tmp);
         } else {
@@ -278,27 +282,45 @@ static int regcache_rbtree_read(struct regmap *map,
 
 static int regcache_rbtree_insert_to_block(struct regmap *map,
                                            struct regcache_rbtree_node *rbnode,
-                                           unsigned int pos, unsigned int reg,
+                                           unsigned int base_reg,
+                                           unsigned int top_reg,
+                                           unsigned int reg,
                                            unsigned int value)
 {
+        unsigned int blklen;
+        unsigned int pos, offset;
+        unsigned long *present;
         u8 *blk;
 
+        blklen = (top_reg - base_reg) / map->reg_stride + 1;
+        pos = (reg - base_reg) / map->reg_stride;
+        offset = (rbnode->base_reg - base_reg) / map->reg_stride;
+
         blk = krealloc(rbnode->block,
-                       (rbnode->blklen + 1) * map->cache_word_size,
+                       blklen * map->cache_word_size,
                        GFP_KERNEL);
         if (!blk)
                 return -ENOMEM;
 
+        present = krealloc(rbnode->cache_present,
+                    BITS_TO_LONGS(blklen) * sizeof(*present), GFP_KERNEL);
+        if (!present) {
+                kfree(blk);
+                return -ENOMEM;
+        }
+
         /* insert the register value in the correct place in the rbnode block */
-        memmove(blk + (pos + 1) * map->cache_word_size,
-                blk + pos * map->cache_word_size,
-                (rbnode->blklen - pos) * map->cache_word_size);
+        if (pos == 0) {
+                memmove(blk + offset * map->cache_word_size,
+                        blk, rbnode->blklen * map->cache_word_size);
+                bitmap_shift_right(present, present, offset, blklen);
+        }
 
         /* update the rbnode block, its size and the base register */
         rbnode->block = blk;
-        rbnode->blklen++;
-        if (!pos)
-                rbnode->base_reg = reg;
+        rbnode->blklen = blklen;
+        rbnode->base_reg = base_reg;
+        rbnode->cache_present = present;
 
         regcache_rbtree_set_register(map, rbnode, pos, value);
         return 0;
@@ -325,8 +347,8 @@ regcache_rbtree_node_alloc(struct regmap *map, unsigned int reg)
 
                 if (i != map->rd_table->n_yes_ranges) {
                         range = &map->rd_table->yes_ranges[i];
-                        rbnode->blklen = range->range_max - range->range_min
-                                + 1;
+                        rbnode->blklen = (range->range_max - range->range_min) /
+                                map->reg_stride + 1;
                         rbnode->base_reg = range->range_min;
                 }
         }
@@ -338,12 +360,21 @@ regcache_rbtree_node_alloc(struct regmap *map, unsigned int reg)
 
         rbnode->block = kmalloc(rbnode->blklen * map->cache_word_size,
                                 GFP_KERNEL);
-        if (!rbnode->block) {
-                kfree(rbnode);
-                return NULL;
-        }
+        if (!rbnode->block)
+                goto err_free;
+
+        rbnode->cache_present = kzalloc(BITS_TO_LONGS(rbnode->blklen) *
+                sizeof(*rbnode->cache_present), GFP_KERNEL);
+        if (!rbnode->cache_present)
+                goto err_free_block;
 
         return rbnode;
+
+err_free_block:
+        kfree(rbnode->block);
+err_free:
+        kfree(rbnode);
+        return NULL;
 }
 
 static int regcache_rbtree_write(struct regmap *map, unsigned int reg,
@@ -353,15 +384,9 @@ static int regcache_rbtree_write(struct regmap *map, unsigned int reg,
         struct regcache_rbtree_node *rbnode, *rbnode_tmp;
         struct rb_node *node;
         unsigned int reg_tmp;
-        unsigned int pos;
-        int i;
         int ret;
 
         rbtree_ctx = map->cache;
-        /* update the reg_present bitmap, make space if necessary */
-        ret = regcache_set_reg_present(map, reg);
-        if (ret < 0)
-                return ret;
 
         /* if we can't locate it in the cached rbnode we'll have
          * to traverse the rbtree looking for it.
@@ -371,30 +396,43 @@ static int regcache_rbtree_write(struct regmap *map, unsigned int reg,
                 reg_tmp = (reg - rbnode->base_reg) / map->reg_stride;
                 regcache_rbtree_set_register(map, rbnode, reg_tmp, value);
         } else {
+                unsigned int base_reg, top_reg;
+                unsigned int new_base_reg, new_top_reg;
+                unsigned int min, max;
+                unsigned int max_dist;
+
+                max_dist = map->reg_stride * sizeof(*rbnode_tmp) /
+                        map->cache_word_size;
+                if (reg < max_dist)
+                        min = 0;
+                else
+                        min = reg - max_dist;
+                max = reg + max_dist;
+
                 /* look for an adjacent register to the one we are about to add */
                 for (node = rb_first(&rbtree_ctx->root); node;
                      node = rb_next(node)) {
                         rbnode_tmp = rb_entry(node, struct regcache_rbtree_node,
                                               node);
-                        for (i = 0; i < rbnode_tmp->blklen; i++) {
-                                reg_tmp = rbnode_tmp->base_reg +
-                                                (i * map->reg_stride);
-                                if (abs(reg_tmp - reg) != map->reg_stride)
-                                        continue;
-                                /* decide where in the block to place our register */
-                                if (reg_tmp + map->reg_stride == reg)
-                                        pos = i + 1;
-                                else
-                                        pos = i;
-                                ret = regcache_rbtree_insert_to_block(map,
-                                                                      rbnode_tmp,
-                                                                      pos, reg,
-                                                                      value);
-                                if (ret)
-                                        return ret;
-                                rbtree_ctx->cached_rbnode = rbnode_tmp;
-                                return 0;
+
+                        regcache_rbtree_get_base_top_reg(map, rbnode_tmp,
+                                &base_reg, &top_reg);
+
+                        if (base_reg <= max && top_reg >= min) {
+                                new_base_reg = min(reg, base_reg);
+                                new_top_reg = max(reg, top_reg);
+                        } else {
+                                continue;
                         }
+
+                        ret = regcache_rbtree_insert_to_block(map, rbnode_tmp,
+                                                              new_base_reg,
+                                                              new_top_reg, reg,
+                                                              value);
+                        if (ret)
+                                return ret;
+                        rbtree_ctx->cached_rbnode = rbnode_tmp;
+                        return 0;
                 }
 
                 /* We did not manage to find a place to insert it in
@@ -418,30 +456,34 @@ static int regcache_rbtree_sync(struct regmap *map, unsigned int min,
         struct regcache_rbtree_ctx *rbtree_ctx;
         struct rb_node *node;
         struct regcache_rbtree_node *rbnode;
+        unsigned int base_reg, top_reg;
+        unsigned int start, end;
         int ret;
-        int base, end;
 
         rbtree_ctx = map->cache;
         for (node = rb_first(&rbtree_ctx->root); node; node = rb_next(node)) {
                 rbnode = rb_entry(node, struct regcache_rbtree_node, node);
 
-                if (rbnode->base_reg > max)
+                regcache_rbtree_get_base_top_reg(map, rbnode, &base_reg,
+                        &top_reg);
+                if (base_reg > max)
                         break;
-                if (rbnode->base_reg + rbnode->blklen < min)
+                if (top_reg < min)
                         continue;
 
-                if (min > rbnode->base_reg)
-                        base = min - rbnode->base_reg;
+                if (min > base_reg)
+                        start = (min - base_reg) / map->reg_stride;
                 else
-                        base = 0;
+                        start = 0;
 
-                if (max < rbnode->base_reg + rbnode->blklen)
-                        end = max - rbnode->base_reg + 1;
+                if (max < top_reg)
+                        end = (max - base_reg) / map->reg_stride + 1;
                 else
                         end = rbnode->blklen;
 
-                ret = regcache_sync_block(map, rbnode->block, rbnode->base_reg,
-                                          base, end);
+                ret = regcache_sync_block(map, rbnode->block,
+                                          rbnode->cache_present,
+                                          rbnode->base_reg, start, end);
                 if (ret != 0)
                         return ret;
         }
@@ -449,6 +491,42 @@ static int regcache_rbtree_sync(struct regmap *map, unsigned int min,
         return regmap_async_complete(map);
 }
 
+static int regcache_rbtree_drop(struct regmap *map, unsigned int min,
+                                unsigned int max)
+{
+        struct regcache_rbtree_ctx *rbtree_ctx;
+        struct regcache_rbtree_node *rbnode;
+        struct rb_node *node;
+        unsigned int base_reg, top_reg;
+        unsigned int start, end;
+
+        rbtree_ctx = map->cache;
+        for (node = rb_first(&rbtree_ctx->root); node; node = rb_next(node)) {
+                rbnode = rb_entry(node, struct regcache_rbtree_node, node);
+
+                regcache_rbtree_get_base_top_reg(map, rbnode, &base_reg,
+                        &top_reg);
+                if (base_reg > max)
+                        break;
+                if (top_reg < min)
+                        continue;
+
+                if (min > base_reg)
+                        start = (min - base_reg) / map->reg_stride;
+                else
+                        start = 0;
+
+                if (max < top_reg)
+                        end = (max - base_reg) / map->reg_stride + 1;
+                else
+                        end = rbnode->blklen;
+
+                bitmap_clear(rbnode->cache_present, start, end - start);
+        }
+
+        return 0;
+}
+
 struct regcache_ops regcache_rbtree_ops = {
         .type = REGCACHE_RBTREE,
         .name = "rbtree",
@@ -456,5 +534,6 @@ struct regcache_ops regcache_rbtree_ops = {
         .exit = regcache_rbtree_exit,
         .read = regcache_rbtree_read,
         .write = regcache_rbtree_write,
-        .sync = regcache_rbtree_sync
+        .sync = regcache_rbtree_sync,
+        .drop = regcache_rbtree_drop,
 };
diff --git a/drivers/base/regmap/regcache.c b/drivers/base/regmap/regcache.c
index 3455f833e473..d6c2d691b6e8 100644
--- a/drivers/base/regmap/regcache.c
+++ b/drivers/base/regmap/regcache.c
@@ -121,8 +121,6 @@ int regcache_init(struct regmap *map, const struct regmap_config *config)
         map->reg_defaults_raw = config->reg_defaults_raw;
         map->cache_word_size = DIV_ROUND_UP(config->val_bits, 8);
         map->cache_size_raw = map->cache_word_size * config->num_reg_defaults_raw;
-        map->cache_present = NULL;
-        map->cache_present_nbits = 0;
 
         map->cache = NULL;
         map->cache_ops = cache_types[i];
@@ -181,7 +179,6 @@ void regcache_exit(struct regmap *map)
 
         BUG_ON(!map->cache_ops);
 
-        kfree(map->cache_present);
         kfree(map->reg_defaults);
         if (map->cache_free)
                 kfree(map->reg_defaults_raw);
@@ -241,9 +238,6 @@ int regcache_write(struct regmap *map,
 
         BUG_ON(!map->cache_ops);
 
-        if (!regmap_writeable(map, reg))
-                return -EIO;
-
         if (!regmap_volatile(map, reg))
                 return map->cache_ops->write(map, reg, value);
 
@@ -410,22 +404,16 @@ EXPORT_SYMBOL_GPL(regcache_sync_region);
 int regcache_drop_region(struct regmap *map, unsigned int min,
                          unsigned int max)
 {
-        unsigned int reg;
         int ret = 0;
 
-        if (!map->cache_present && !(map->cache_ops && map->cache_ops->drop))
+        if (!map->cache_ops || !map->cache_ops->drop)
                 return -EINVAL;
 
         map->lock(map->lock_arg);
 
         trace_regcache_drop_region(map->dev, min, max);
 
-        if (map->cache_present)
-                for (reg = min; reg < max + 1; reg++)
-                        clear_bit(reg, map->cache_present);
-
-        if (map->cache_ops && map->cache_ops->drop)
-                ret = map->cache_ops->drop(map, min, max);
+        ret = map->cache_ops->drop(map, min, max);
 
         map->unlock(map->lock_arg);
 
@@ -493,42 +481,6 @@ void regcache_cache_bypass(struct regmap *map, bool enable)
 }
 EXPORT_SYMBOL_GPL(regcache_cache_bypass);
 
-int regcache_set_reg_present(struct regmap *map, unsigned int reg)
-{
-        unsigned long *cache_present;
-        unsigned int cache_present_size;
-        unsigned int nregs;
-        int i;
-
-        nregs = reg + 1;
-        cache_present_size = BITS_TO_LONGS(nregs);
-        cache_present_size *= sizeof(long);
-
-        if (!map->cache_present) {
-                cache_present = kmalloc(cache_present_size, GFP_KERNEL);
-                if (!cache_present)
-                        return -ENOMEM;
-                bitmap_zero(cache_present, nregs);
-                map->cache_present = cache_present;
-                map->cache_present_nbits = nregs;
-        }
-
-        if (nregs > map->cache_present_nbits) {
-                cache_present = krealloc(map->cache_present,
-                                         cache_present_size, GFP_KERNEL);
-                if (!cache_present)
-                        return -ENOMEM;
-                for (i = 0; i < nregs; i++)
-                        if (i >= map->cache_present_nbits)
-                                clear_bit(i, cache_present);
-                map->cache_present = cache_present;
-                map->cache_present_nbits = nregs;
-        }
-
-        set_bit(reg, map->cache_present);
-        return 0;
-}
-
 bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,
                       unsigned int val)
 {
@@ -620,7 +572,16 @@ int regcache_lookup_reg(struct regmap *map, unsigned int reg)
                 return -ENOENT;
 }
 
+static bool regcache_reg_present(unsigned long *cache_present, unsigned int idx)
+{
+        if (!cache_present)
+                return true;
+
+        return test_bit(idx, cache_present);
+}
+
 static int regcache_sync_block_single(struct regmap *map, void *block,
+                                      unsigned long *cache_present,
                                       unsigned int block_base,
                                       unsigned int start, unsigned int end)
 {
@@ -630,7 +591,7 @@ static int regcache_sync_block_single(struct regmap *map, void *block,
         for (i = start; i < end; i++) {
                 regtmp = block_base + (i * map->reg_stride);
 
-                if (!regcache_reg_present(map, regtmp))
+                if (!regcache_reg_present(cache_present, i))
                         continue;
 
                 val = regcache_get_val(map, block, i);
@@ -681,6 +642,7 @@ static int regcache_sync_block_raw_flush(struct regmap *map, const void **data,
 }
 
 static int regcache_sync_block_raw(struct regmap *map, void *block,
+                            unsigned long *cache_present,
                             unsigned int block_base, unsigned int start,
                             unsigned int end)
 {
@@ -693,7 +655,7 @@ static int regcache_sync_block_raw(struct regmap *map, void *block,
         for (i = start; i < end; i++) {
                 regtmp = block_base + (i * map->reg_stride);
 
-                if (!regcache_reg_present(map, regtmp)) {
+                if (!regcache_reg_present(cache_present, i)) {
                         ret = regcache_sync_block_raw_flush(map, &data,
                                                             base, regtmp);
                         if (ret != 0)
@@ -724,13 +686,14 @@ static int regcache_sync_block_raw(struct regmap *map, void *block,
 }
 
 int regcache_sync_block(struct regmap *map, void *block,
+                        unsigned long *cache_present,
                         unsigned int block_base, unsigned int start,
                         unsigned int end)
 {
         if (regmap_can_raw_write(map))
-                return regcache_sync_block_raw(map, block, block_base,
-                                               start, end);
+                return regcache_sync_block_raw(map, block, cache_present,
+                                               block_base, start, end);
         else
-                return regcache_sync_block_single(map, block, block_base,
-                                                  start, end);
+                return regcache_sync_block_single(map, block, cache_present,
+                                                  block_base, start, end);
 }
diff --git a/drivers/base/regmap/regmap-debugfs.c b/drivers/base/regmap/regmap-debugfs.c
index 53495753fbdb..6c2652a8ad50 100644
--- a/drivers/base/regmap/regmap-debugfs.c
+++ b/drivers/base/regmap/regmap-debugfs.c
@@ -85,8 +85,8 @@ static unsigned int regmap_debugfs_get_dump_start(struct regmap *map,
         unsigned int reg_offset;
 
         /* Suppress the cache if we're using a subrange */
-        if (from)
-                return from;
+        if (base)
+                return base;
 
         /*
          * If we don't have a cache build one so we don't have to do a
diff --git a/drivers/base/regmap/regmap-irq.c b/drivers/base/regmap/regmap-irq.c
index 1643e889bafc..d10456ffd811 100644
--- a/drivers/base/regmap/regmap-irq.c
+++ b/drivers/base/regmap/regmap-irq.c
@@ -418,6 +418,31 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
                                 reg, ret);
                         goto err_alloc;
                 }
+
+                if (!chip->init_ack_masked)
+                        continue;
+
+                /* Ack masked but set interrupts */
+                reg = chip->status_base +
+                        (i * map->reg_stride * d->irq_reg_stride);
+                ret = regmap_read(map, reg, &d->status_buf[i]);
+                if (ret != 0) {
+                        dev_err(map->dev, "Failed to read IRQ status: %d\n",
+                                ret);
+                        goto err_alloc;
+                }
+
+                if (d->status_buf[i] && chip->ack_base) {
+                        reg = chip->ack_base +
+                                (i * map->reg_stride * d->irq_reg_stride);
+                        ret = regmap_write(map, reg,
+                                        d->status_buf[i] & d->mask_buf[i]);
+                        if (ret != 0) {
+                                dev_err(map->dev, "Failed to ack 0x%x: %d\n",
+                                        reg, ret);
+                                goto err_alloc;
+                        }
+                }
         }
 
         /* Wake is disabled by default */
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index e0d0c7d8a5c5..7d689a15c500 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -303,6 +303,7 @@ static void regmap_unlock_mutex(void *__map)
 }
 
 static void regmap_lock_spinlock(void *__map)
+__acquires(&map->spinlock)
 {
         struct regmap *map = __map;
         unsigned long flags;
@@ -312,6 +313,7 @@ static void regmap_lock_spinlock(void *__map)
 }
 
 static void regmap_unlock_spinlock(void *__map)
+__releases(&map->spinlock)
 {
         struct regmap *map = __map;
         spin_unlock_irqrestore(&map->spinlock, map->spinlock_flags);
@@ -687,6 +689,10 @@ skip_format_initialization:
                         unsigned win_max = win_min +
                                            config->ranges[j].window_len - 1;
 
+                        /* Allow data window inside its own virtual range */
+                        if (j == i)
+                                continue;
+
                         if (range_cfg->range_min <= sel_reg &&
                             sel_reg <= range_cfg->range_max) {
                                 dev_err(map->dev,
@@ -1261,6 +1267,9 @@ int _regmap_write(struct regmap *map, unsigned int reg,
         int ret;
         void *context = _regmap_map_get_context(map);
 
+        if (!regmap_writeable(map, reg))
+                return -EIO;
+
         if (!map->cache_bypass && !map->defer_caching) {
                 ret = regcache_write(map, reg, val);
                 if (ret != 0)
@@ -1888,13 +1897,10 @@ EXPORT_SYMBOL_GPL(regmap_async_complete);
 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
                           int num_regs)
 {
+        struct reg_default *p;
         int i, ret;
         bool bypass;
 
-        /* If needed the implementation can be extended to support this */
-        if (map->patch)
-                return -EBUSY;
-
         map->lock(map->lock_arg);
 
         bypass = map->cache_bypass;
@@ -1911,11 +1917,13 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
                 }
         }
 
-        map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL);
-        if (map->patch != NULL) {
-                memcpy(map->patch, regs,
-                       num_regs * sizeof(struct reg_default));
-                map->patch_regs = num_regs;
+        p = krealloc(map->patch,
+                     sizeof(struct reg_default) * (map->patch_regs + num_regs),
+                     GFP_KERNEL);
+        if (p) {
+                memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
+                map->patch = p;
+                map->patch_regs += num_regs;
         } else {
                 ret = -ENOMEM;
         }