6 files changed, 185 insertions, 54 deletions

diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 4b1f9265887f..01e21037d8fe 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -450,8 +450,18 @@ static void fw_load_abort(struct firmware_priv *fw_priv)
 {
         struct firmware_buf *buf = fw_priv->buf;
 
+        /*
+         * There is a small window in which user can write to 'loading'
+         * between loading done and disappearance of 'loading'
+         */
+        if (test_bit(FW_STATUS_DONE, &buf->status))
+                return;
+
         set_bit(FW_STATUS_ABORT, &buf->status);
         complete_all(&buf->completion);
+
+        /* avoid user action after loading abort */
+        fw_priv->buf = NULL;
 }
 
 #define is_fw_load_aborted(buf) \
@@ -528,7 +538,12 @@ static ssize_t firmware_loading_show(struct device *dev,
                                      struct device_attribute *attr, char *buf)
 {
         struct firmware_priv *fw_priv = to_firmware_priv(dev);
-        int loading = test_bit(FW_STATUS_LOADING, &fw_priv->buf->status);
+        int loading = 0;
+
+        mutex_lock(&fw_lock);
+        if (fw_priv->buf)
+                loading = test_bit(FW_STATUS_LOADING, &fw_priv->buf->status);
+        mutex_unlock(&fw_lock);
 
         return sprintf(buf, "%d\n", loading);
 }
@@ -570,12 +585,12 @@ static ssize_t firmware_loading_store(struct device *dev,
                                       const char *buf, size_t count)
 {
         struct firmware_priv *fw_priv = to_firmware_priv(dev);
-        struct firmware_buf *fw_buf = fw_priv->buf;
+        struct firmware_buf *fw_buf;
         int loading = simple_strtol(buf, NULL, 10);
         int i;
 
         mutex_lock(&fw_lock);
-
+        fw_buf = fw_priv->buf;
         if (!fw_buf)
                 goto out;
 
@@ -777,10 +792,6 @@ static void firmware_class_timeout_work(struct work_struct *work)
                         struct firmware_priv, timeout_work.work);
 
         mutex_lock(&fw_lock);
-        if (test_bit(FW_STATUS_DONE, &(fw_priv->buf->status))) {
-                mutex_unlock(&fw_lock);
-                return;
-        }
         fw_load_abort(fw_priv);
         mutex_unlock(&fw_lock);
 }
@@ -861,8 +872,6 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
 
         cancel_delayed_work_sync(&fw_priv->timeout_work);
 
-        fw_priv->buf = NULL;
-
         device_remove_file(f_dev, &dev_attr_loading);
 err_del_bin_attr:
         device_remove_bin_file(f_dev, &firmware_attr_data);
diff --git a/drivers/base/regmap/internal.h b/drivers/base/regmap/internal.h
index c5f6ebd0466d..29c83160ca29 100644
--- a/drivers/base/regmap/internal.h
+++ b/drivers/base/regmap/internal.h
@@ -52,6 +52,7 @@ struct regmap_async {
 struct regmap {
         struct mutex mutex;
         spinlock_t spinlock;
+        unsigned long spinlock_flags;
         regmap_lock lock;
         regmap_unlock unlock;
         void *lock_arg; /* This is passed to lock/unlock functions */
@@ -148,6 +149,7 @@ struct regcache_ops {
         int (*read)(struct regmap *map, unsigned int reg, unsigned int *value);
         int (*write)(struct regmap *map, unsigned int reg, unsigned int value);
         int (*sync)(struct regmap *map, unsigned int min, unsigned int max);
+        int (*drop)(struct regmap *map, unsigned int min, unsigned int max);
 };
 
 bool regmap_writeable(struct regmap *map, unsigned int reg);
diff --git a/drivers/base/regmap/regcache-rbtree.c b/drivers/base/regmap/regcache-rbtree.c
index aa0875f6f1b7..5c1435c4e210 100644
--- a/drivers/base/regmap/regcache-rbtree.c
+++ b/drivers/base/regmap/regcache-rbtree.c
@@ -143,7 +143,7 @@ static int rbtree_show(struct seq_file *s, void *ignored)
         int registers = 0;
         int this_registers, average;
 
-        map->lock(map);
+        map->lock(map->lock_arg);
 
         mem_size = sizeof(*rbtree_ctx);
         mem_size += BITS_TO_LONGS(map->cache_present_nbits) * sizeof(long);
@@ -170,7 +170,7 @@ static int rbtree_show(struct seq_file *s, void *ignored)
         seq_printf(s, "%d nodes, %d registers, average %d registers, used %zu bytes\n",
                    nodes, registers, average, mem_size);
 
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 
         return 0;
 }
@@ -304,6 +304,48 @@ static int regcache_rbtree_insert_to_block(struct regmap *map,
         return 0;
 }
 
+static struct regcache_rbtree_node *
+regcache_rbtree_node_alloc(struct regmap *map, unsigned int reg)
+{
+        struct regcache_rbtree_node *rbnode;
+        const struct regmap_range *range;
+        int i;
+
+        rbnode = kzalloc(sizeof(*rbnode), GFP_KERNEL);
+        if (!rbnode)
+                return NULL;
+
+        /* If there is a read table then use it to guess at an allocation */
+        if (map->rd_table) {
+                for (i = 0; i < map->rd_table->n_yes_ranges; i++) {
+                        if (regmap_reg_in_range(reg,
+                                                &map->rd_table->yes_ranges[i]))
+                                break;
+                }
+
+                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->base_reg = range->range_min;
+                }
+        }
+
+        if (!rbnode->blklen) {
+                rbnode->blklen = sizeof(*rbnode);
+                rbnode->base_reg = reg;
+        }
+
+        rbnode->block = kmalloc(rbnode->blklen * map->cache_word_size,
+                                GFP_KERNEL);
+        if (!rbnode->block) {
+                kfree(rbnode);
+                return NULL;
+        }
+
+        return rbnode;
+}
+
 static int regcache_rbtree_write(struct regmap *map, unsigned int reg,
                                  unsigned int value)
 {
@@ -354,23 +396,15 @@ static int regcache_rbtree_write(struct regmap *map, unsigned int reg,
                                 return 0;
                         }
                 }
-                /* we did not manage to find a place to insert it in an existing
-                 * block so create a new rbnode with a single register in its block.
-                 * This block will get populated further if any other adjacent
-                 * registers get modified in the future.
+
+                /* We did not manage to find a place to insert it in
+                 * an existing block so create a new rbnode.
                  */
-                rbnode = kzalloc(sizeof *rbnode, GFP_KERNEL);
+                rbnode = regcache_rbtree_node_alloc(map, reg);
                 if (!rbnode)
                         return -ENOMEM;
-                rbnode->blklen = sizeof(*rbnode);
-                rbnode->base_reg = reg;
-                rbnode->block = kmalloc(rbnode->blklen * map->cache_word_size,
-                                        GFP_KERNEL);
-                if (!rbnode->block) {
-                        kfree(rbnode);
-                        return -ENOMEM;
-                }
-                regcache_rbtree_set_register(map, rbnode, 0, value);
+                regcache_rbtree_set_register(map, rbnode,
+                                             reg - rbnode->base_reg, value);
                 regcache_rbtree_insert(map, &rbtree_ctx->root, rbnode);
                 rbtree_ctx->cached_rbnode = rbnode;
         }
@@ -391,8 +425,6 @@ static int regcache_rbtree_sync(struct regmap *map, unsigned int min,
         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 < min)
-                        continue;
                 if (rbnode->base_reg > max)
                         break;
                 if (rbnode->base_reg + rbnode->blklen < min)
diff --git a/drivers/base/regmap/regcache.c b/drivers/base/regmap/regcache.c
index 75923f2396bd..e69102696533 100644
--- a/drivers/base/regmap/regcache.c
+++ b/drivers/base/regmap/regcache.c
@@ -250,6 +250,38 @@ int regcache_write(struct regmap *map,
         return 0;
 }
 
+static int regcache_default_sync(struct regmap *map, unsigned int min,
+                                 unsigned int max)
+{
+        unsigned int reg;
+
+        for (reg = min; reg <= max; reg++) {
+                unsigned int val;
+                int ret;
+
+                if (regmap_volatile(map, reg))
+                        continue;
+
+                ret = regcache_read(map, reg, &val);
+                if (ret)
+                        return ret;
+
+                /* Is this the hardware default?  If so skip. */
+                ret = regcache_lookup_reg(map, reg);
+                if (ret >= 0 && val == map->reg_defaults[ret].def)
+                        continue;
+
+                map->cache_bypass = 1;
+                ret = _regmap_write(map, reg, val);
+                map->cache_bypass = 0;
+                if (ret)
+                        return ret;
+                dev_dbg(map->dev, "Synced register %#x, value %#x\n", reg, val);
+        }
+
+        return 0;
+}
+
 /**
  * regcache_sync: Sync the register cache with the hardware.
  *
@@ -268,9 +300,9 @@ int regcache_sync(struct regmap *map)
         const char *name;
         unsigned int bypass;
 
-        BUG_ON(!map->cache_ops || !map->cache_ops->sync);
+        BUG_ON(!map->cache_ops);
 
-        map->lock(map);
+        map->lock(map->lock_arg);
         /* Remember the initial bypass state */
         bypass = map->cache_bypass;
         dev_dbg(map->dev, "Syncing %s cache\n",
@@ -297,7 +329,10 @@ int regcache_sync(struct regmap *map)
         }
         map->cache_bypass = 0;
 
-        ret = map->cache_ops->sync(map, 0, map->max_register);
+        if (map->cache_ops->sync)
+                ret = map->cache_ops->sync(map, 0, map->max_register);
+        else
+                ret = regcache_default_sync(map, 0, map->max_register);
 
         if (ret == 0)
                 map->cache_dirty = false;
@@ -306,7 +341,7 @@ out:
         trace_regcache_sync(map->dev, name, "stop");
         /* Restore the bypass state */
         map->cache_bypass = bypass;
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 
         return ret;
 }
@@ -331,9 +366,9 @@ int regcache_sync_region(struct regmap *map, unsigned int min,
         const char *name;
         unsigned int bypass;
 
-        BUG_ON(!map->cache_ops || !map->cache_ops->sync);
+        BUG_ON(!map->cache_ops);
 
-        map->lock(map);
+        map->lock(map->lock_arg);
 
         /* Remember the initial bypass state */
         bypass = map->cache_bypass;
@@ -346,19 +381,59 @@ int regcache_sync_region(struct regmap *map, unsigned int min,
         if (!map->cache_dirty)
                 goto out;
 
-        ret = map->cache_ops->sync(map, min, max);
+        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->unlock(map);
+        map->unlock(map->lock_arg);
 
         return ret;
 }
 EXPORT_SYMBOL_GPL(regcache_sync_region);
 
 /**
+ * regcache_drop_region: Discard part of the register cache
+ *
+ * @map: map to operate on
+ * @min: first register to discard
+ * @max: last register to discard
+ *
+ * Discard part of the register cache.
+ *
+ * Return a negative value on failure, 0 on success.
+ */
+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))
+                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);
+
+        map->unlock(map->lock_arg);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(regcache_drop_region);
+
+/**
  * regcache_cache_only: Put a register map into cache only mode
  *
  * @map: map to configure
@@ -372,11 +447,11 @@ EXPORT_SYMBOL_GPL(regcache_sync_region);
  */
 void regcache_cache_only(struct regmap *map, bool enable)
 {
-        map->lock(map);
+        map->lock(map->lock_arg);
         WARN_ON(map->cache_bypass && enable);
         map->cache_only = enable;
         trace_regmap_cache_only(map->dev, enable);
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 }
 EXPORT_SYMBOL_GPL(regcache_cache_only);
 
@@ -391,9 +466,9 @@ EXPORT_SYMBOL_GPL(regcache_cache_only);
  */
 void regcache_mark_dirty(struct regmap *map)
 {
-        map->lock(map);
+        map->lock(map->lock_arg);
         map->cache_dirty = true;
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 }
 EXPORT_SYMBOL_GPL(regcache_mark_dirty);
 
@@ -410,11 +485,11 @@ EXPORT_SYMBOL_GPL(regcache_mark_dirty);
  */
 void regcache_cache_bypass(struct regmap *map, bool enable)
 {
-        map->lock(map);
+        map->lock(map->lock_arg);
         WARN_ON(map->cache_only && enable);
         map->cache_bypass = enable;
         trace_regmap_cache_bypass(map->dev, enable);
-        map->unlock(map);
+        map->unlock(map->lock_arg);
 }
 EXPORT_SYMBOL_GPL(regcache_cache_bypass);
 
diff --git a/drivers/base/regmap/regmap-debugfs.c b/drivers/base/regmap/regmap-debugfs.c
index 23b701f5fd2f..53495753fbdb 100644
--- a/drivers/base/regmap/regmap-debugfs.c
+++ b/drivers/base/regmap/regmap-debugfs.c
@@ -84,6 +84,10 @@ static unsigned int regmap_debugfs_get_dump_start(struct regmap *map,
         unsigned int fpos_offset;
         unsigned int reg_offset;
 
+        /* Suppress the cache if we're using a subrange */
+        if (from)
+                return from;
+
         /*
          * If we don't have a cache build one so we don't have to do a
          * linear scan each time.
@@ -145,7 +149,7 @@ static unsigned int regmap_debugfs_get_dump_start(struct regmap *map,
                         reg_offset = fpos_offset / map->debugfs_tot_len;
                         *pos = c->min + (reg_offset * map->debugfs_tot_len);
                         mutex_unlock(&map->cache_lock);
-                        return c->base_reg + reg_offset;
+                        return c->base_reg + (reg_offset * map->reg_stride);
                 }
 
                 *pos = c->max;
@@ -265,6 +269,7 @@ static ssize_t regmap_map_write_file(struct file *file,
         char *start = buf;
         unsigned long reg, value;
         struct regmap *map = file->private_data;
+        int ret;
 
         buf_size = min(count, (sizeof(buf)-1));
         if (copy_from_user(buf, user_buf, buf_size))
@@ -280,9 +285,11 @@ static ssize_t regmap_map_write_file(struct file *file,
                 return -EINVAL;
 
         /* Userspace has been fiddling around behind the kernel's back */
-        add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
+        add_taint(TAINT_USER, LOCKDEP_STILL_OK);
 
-        regmap_write(map, reg, value);
+        ret = regmap_write(map, reg, value);
+        if (ret < 0)
+                return ret;
         return buf_size;
 }
 #else
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index fef6f13b96bb..95920583e31e 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -65,9 +65,8 @@ bool regmap_reg_in_ranges(unsigned int reg,
 }
 EXPORT_SYMBOL_GPL(regmap_reg_in_ranges);
 
-static bool _regmap_check_range_table(struct regmap *map,
-                                      unsigned int reg,
-                                      const struct regmap_access_table *table)
+bool regmap_check_range_table(struct regmap *map, unsigned int reg,
+                              const struct regmap_access_table *table)
 {
         /* Check "no ranges" first */
         if (regmap_reg_in_ranges(reg, table->no_ranges, table->n_no_ranges))
@@ -80,6 +79,7 @@ static bool _regmap_check_range_table(struct regmap *map,
         return regmap_reg_in_ranges(reg, table->yes_ranges,
                                     table->n_yes_ranges);
 }
+EXPORT_SYMBOL_GPL(regmap_check_range_table);
 
 bool regmap_writeable(struct regmap *map, unsigned int reg)
 {
@@ -90,7 +90,7 @@ bool regmap_writeable(struct regmap *map, unsigned int reg)
                 return map->writeable_reg(map->dev, reg);
 
         if (map->wr_table)
-                return _regmap_check_range_table(map, reg, map->wr_table);
+                return regmap_check_range_table(map, reg, map->wr_table);
 
         return true;
 }
@@ -107,7 +107,7 @@ bool regmap_readable(struct regmap *map, unsigned int reg)
                 return map->readable_reg(map->dev, reg);
 
         if (map->rd_table)
-                return _regmap_check_range_table(map, reg, map->rd_table);
+                return regmap_check_range_table(map, reg, map->rd_table);
 
         return true;
 }
@@ -121,9 +121,12 @@ bool regmap_volatile(struct regmap *map, unsigned int reg)
                 return map->volatile_reg(map->dev, reg);
 
         if (map->volatile_table)
-                return _regmap_check_range_table(map, reg, map->volatile_table);
+                return regmap_check_range_table(map, reg, map->volatile_table);
 
-        return true;
+        if (map->cache_ops)
+                return false;
+        else
+                return true;
 }
 
 bool regmap_precious(struct regmap *map, unsigned int reg)
@@ -135,7 +138,7 @@ bool regmap_precious(struct regmap *map, unsigned int reg)
                 return map->precious_reg(map->dev, reg);
 
         if (map->precious_table)
-                return _regmap_check_range_table(map, reg, map->precious_table);
+                return regmap_check_range_table(map, reg, map->precious_table);
 
         return false;
 }
@@ -302,13 +305,16 @@ static void regmap_unlock_mutex(void *__map)
 static void regmap_lock_spinlock(void *__map)
 {
         struct regmap *map = __map;
-        spin_lock(&map->spinlock);
+        unsigned long flags;
+
+        spin_lock_irqsave(&map->spinlock, flags);
+        map->spinlock_flags = flags;
 }
 
 static void regmap_unlock_spinlock(void *__map)
 {
         struct regmap *map = __map;
-        spin_unlock(&map->spinlock);
+        spin_unlock_irqrestore(&map->spinlock, map->spinlock_flags);
 }
 
 static void dev_get_regmap_release(struct device *dev, void *res)