5 files changed, 225 insertions, 50 deletions

diff --git a/drivers/base/regmap/internal.h b/drivers/base/regmap/internal.h
index 57f777835d97..6873b4ce03f9 100644
--- a/drivers/base/regmap/internal.h
+++ b/drivers/base/regmap/internal.h
@@ -44,7 +44,6 @@ struct regmap_format {
 
 struct regmap_async {
         struct list_head list;
-        struct work_struct cleanup;
         struct regmap *map;
         void *work_buf;
 };
@@ -64,9 +63,11 @@ struct regmap {
         void *bus_context;
         const char *name;
 
+        bool async;
         spinlock_t async_lock;
         wait_queue_head_t async_waitq;
         struct list_head async_list;
+        struct list_head async_free;
         int async_ret;
 
 #ifdef CONFIG_DEBUG_FS
@@ -218,7 +219,7 @@ bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,
 int regcache_lookup_reg(struct regmap *map, unsigned int reg);
 
 int _regmap_raw_write(struct regmap *map, unsigned int reg,
-                      const void *val, size_t val_len, bool async);
+                      const void *val, size_t val_len);
 
 void regmap_async_complete_cb(struct regmap_async *async, int ret);
 
diff --git a/drivers/base/regmap/regcache.c b/drivers/base/regmap/regcache.c
index d6c2d691b6e8..d4dd77134814 100644
--- a/drivers/base/regmap/regcache.c
+++ b/drivers/base/regmap/regcache.c
@@ -307,6 +307,8 @@ int regcache_sync(struct regmap *map)
         if (!map->cache_dirty)
                 goto out;
 
+        map->async = true;
+
         /* Apply any patch first */
         map->cache_bypass = 1;
         for (i = 0; i < map->patch_regs; i++) {
@@ -332,11 +334,15 @@ int regcache_sync(struct regmap *map)
                 map->cache_dirty = false;
 
 out:
-        trace_regcache_sync(map->dev, name, "stop");
         /* Restore the bypass state */
+        map->async = false;
         map->cache_bypass = bypass;
         map->unlock(map->lock_arg);
 
+        regmap_async_complete(map);
+
+        trace_regcache_sync(map->dev, name, "stop");
+
         return ret;
 }
 EXPORT_SYMBOL_GPL(regcache_sync);
@@ -375,17 +381,23 @@ int regcache_sync_region(struct regmap *map, unsigned int min,
         if (!map->cache_dirty)
                 goto out;
 
+        map->async = true;
+
         if (map->cache_ops->sync)
                 ret = map->cache_ops->sync(map, min, max);
         else
                 ret = regcache_default_sync(map, min, max);
 
 out:
-        trace_regcache_sync(map->dev, name, "stop region");
         /* Restore the bypass state */
         map->cache_bypass = bypass;
+        map->async = false;
         map->unlock(map->lock_arg);
 
+        regmap_async_complete(map);
+
+        trace_regcache_sync(map->dev, name, "stop region");
+
         return ret;
 }
 EXPORT_SYMBOL_GPL(regcache_sync_region);
@@ -631,8 +643,7 @@ static int regcache_sync_block_raw_flush(struct regmap *map, const void **data,
 
         map->cache_bypass = 1;
 
-        ret = _regmap_raw_write(map, base, *data, count * val_bytes,
-                                false);
+        ret = _regmap_raw_write(map, base, *data, count * val_bytes);
 
         map->cache_bypass = 0;
 
diff --git a/drivers/base/regmap/regmap-spi.c b/drivers/base/regmap/regmap-spi.c
index 4c506bd940f3..37f12ae7aada 100644
--- a/drivers/base/regmap/regmap-spi.c
+++ b/drivers/base/regmap/regmap-spi.c
@@ -73,7 +73,8 @@ static int regmap_spi_async_write(void *context,
 
         spi_message_init(&async->m);
         spi_message_add_tail(&async->t[0], &async->m);
-        spi_message_add_tail(&async->t[1], &async->m);
+        if (val)
+                spi_message_add_tail(&async->t[1], &async->m);
 
         async->m.complete = regmap_spi_complete;
         async->m.context = async;
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index c1245cae0f43..d0ce2fef43a3 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -42,15 +42,6 @@ static int _regmap_bus_formatted_write(void *context, unsigned int reg,
 static int _regmap_bus_raw_write(void *context, unsigned int reg,
                                  unsigned int val);
 
-static void async_cleanup(struct work_struct *work)
-{
-        struct regmap_async *async = container_of(work, struct regmap_async,
-                                                  cleanup);
-
-        kfree(async->work_buf);
-        kfree(async);
-}
-
 bool regmap_reg_in_ranges(unsigned int reg,
                           const struct regmap_range *ranges,
                           unsigned int nranges)
@@ -465,6 +456,7 @@ struct regmap *regmap_init(struct device *dev,
 
         spin_lock_init(&map->async_lock);
         INIT_LIST_HEAD(&map->async_list);
+        INIT_LIST_HEAD(&map->async_free);
         init_waitqueue_head(&map->async_waitq);
 
         if (config->read_flag_mask || config->write_flag_mask) {
@@ -942,12 +934,22 @@ EXPORT_SYMBOL_GPL(regmap_reinit_cache);
  */
 void regmap_exit(struct regmap *map)
 {
+        struct regmap_async *async;
+
         regcache_exit(map);
         regmap_debugfs_exit(map);
         regmap_range_exit(map);
         if (map->bus && map->bus->free_context)
                 map->bus->free_context(map->bus_context);
         kfree(map->work_buf);
+        while (!list_empty(&map->async_free)) {
+                async = list_first_entry_or_null(&map->async_free,
+                                                 struct regmap_async,
+                                                 list);
+                list_del(&async->list);
+                kfree(async->work_buf);
+                kfree(async);
+        }
         kfree(map);
 }