Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...

[pandora-kernel.git] / drivers / base / regmap / regcache.c

diff --git a/drivers/base/regmap/regcache.c b/drivers/base/regmap/regcache.c
index 00609bf..afcfef8 100644 (file)
--- a/drivers/base/regmap/regcache.c
+++ b/drivers/base/regmap/regcache.c
@@ -12,6 +12,8 @@
 
 #include <linux/slab.h>
 #include <trace/events/regmap.h>
+#include <linux/bsearch.h>
+#include <linux/sort.h>
 
 #include "internal.h"
 
@@ -82,8 +84,10 @@ int regcache_init(struct regmap *map)
        int i;
        void *tmp_buf;
 
-       if (map->cache_type == REGCACHE_NONE)
+       if (map->cache_type == REGCACHE_NONE) {
+               map->cache_bypass = true;
                return 0;
+       }
 
        for (i = 0; i < ARRAY_SIZE(cache_types); i++)
                if (cache_types[i]->type == map->cache_type)
@@ -115,8 +119,8 @@ int regcache_init(struct regmap *map)
                if (!tmp_buf)
                        return -ENOMEM;
                map->reg_defaults = tmp_buf;
-       } else {
-               /* Some devices such as PMIC's don't have cache defaults,
+       } else if (map->num_reg_defaults_raw) {
+               /* Some devices such as PMICs don't have cache defaults,
                 * we cope with this by reading back the HW registers and
                 * crafting the cache defaults by hand.
                 */
@@ -221,23 +225,90 @@ EXPORT_SYMBOL_GPL(regcache_write);
  */
 int regcache_sync(struct regmap *map)
 {
-       int ret;
+       int ret = 0;
+       unsigned int val;
+       unsigned int i;
        const char *name;
+       unsigned int bypass;
 
        BUG_ON(!map->cache_ops);
 
+       mutex_lock(&map->lock);
+       /* Remember the initial bypass state */
+       bypass = map->cache_bypass;
+       dev_dbg(map->dev, "Syncing %s cache\n",
+               map->cache_ops->name);
+       name = map->cache_ops->name;
+       trace_regcache_sync(map->dev, name, "start");
        if (map->cache_ops->sync) {
-               dev_dbg(map->dev, "Syncing %s cache\n",
-                       map->cache_ops->name);
-               name = map->cache_ops->name;
-               trace_regcache_sync(map->dev, name, "start");
                ret = map->cache_ops->sync(map);
-               trace_regcache_sync(map->dev, name, "stop");
+       } else {
+               for (i = 0; i < map->num_reg_defaults; i++) {
+                       ret = regcache_read(map, i, &val);
+                       if (ret < 0)
+                               goto out;
+                       map->cache_bypass = 1;
+                       ret = _regmap_write(map, i, val);
+                       map->cache_bypass = 0;
+                       if (ret < 0)
+                               goto out;
+                       dev_dbg(map->dev, "Synced register %#x, value %#x\n",
+                               map->reg_defaults[i].reg,
+                               map->reg_defaults[i].def);
+               }
+
        }
-       return 0;
+out:
+       trace_regcache_sync(map->dev, name, "stop");
+       /* Restore the bypass state */
+       map->cache_bypass = bypass;
+       mutex_unlock(&map->lock);
+
+       return ret;
 }
 EXPORT_SYMBOL_GPL(regcache_sync);
 
+/**
+ * regcache_cache_only: Put a register map into cache only mode
+ *
+ * @map: map to configure
+ * @cache_only: flag if changes should be written to the hardware
+ *
+ * When a register map is marked as cache only writes to the register
+ * map API will only update the register cache, they will not cause
+ * any hardware changes.  This is useful for allowing portions of
+ * drivers to act as though the device were functioning as normal when
+ * it is disabled for power saving reasons.
+ */
+void regcache_cache_only(struct regmap *map, bool enable)
+{
+       mutex_lock(&map->lock);
+       WARN_ON(map->cache_bypass && enable);
+       map->cache_only = enable;
+       mutex_unlock(&map->lock);
+}
+EXPORT_SYMBOL_GPL(regcache_cache_only);
+
+/**
+ * regcache_cache_bypass: Put a register map into cache bypass mode
+ *
+ * @map: map to configure
+ * @cache_bypass: flag if changes should not be written to the hardware
+ *
+ * When a register map is marked with the cache bypass option, writes
+ * to the register map API will only update the hardware and not the
+ * the cache directly.  This is useful when syncing the cache back to
+ * the hardware.
+ */
+void regcache_cache_bypass(struct regmap *map, bool enable)
+{
+       mutex_lock(&map->lock);
+       WARN_ON(map->cache_only && enable);
+       map->cache_bypass = enable;
+       mutex_unlock(&map->lock);
+}
+EXPORT_SYMBOL_GPL(regcache_cache_bypass);
+
 bool regcache_set_val(void *base, unsigned int idx,
                      unsigned int val, unsigned int word_size)
 {
@@ -285,14 +356,29 @@ unsigned int regcache_get_val(const void *base, unsigned int idx,
        return -1;
 }
 
+static int regcache_default_cmp(const void *a, const void *b)
+{
+       const struct reg_default *_a = a;
+       const struct reg_default *_b = b;
+
+       return _a->reg - _b->reg;
+}
+
 int regcache_lookup_reg(struct regmap *map, unsigned int reg)
 {
-       unsigned int i;
+       struct reg_default key;
+       struct reg_default *r;
 
-       for (i = 0; i < map->num_reg_defaults; i++)
-               if (map->reg_defaults[i].reg == reg)
-                       return i;
-       return -1;
+       key.reg = reg;
+       key.def = 0;
+
+       r = bsearch(&key, map->reg_defaults, map->num_reg_defaults,
+                   sizeof(struct reg_default), regcache_default_cmp);
+
+       if (r)
+               return r - map->reg_defaults;
+       else
+               return -ENOENT;
 }
 
 int regcache_insert_reg(struct regmap *map, unsigned int reg,
@@ -309,5 +395,7 @@ int regcache_insert_reg(struct regmap *map, unsigned int reg,
        map->num_reg_defaults++;
        map->reg_defaults[map->num_reg_defaults - 1].reg = reg;
        map->reg_defaults[map->num_reg_defaults - 1].def = val;
+       sort(map->reg_defaults, map->num_reg_defaults,
+            sizeof(struct reg_default), regcache_default_cmp, NULL);
        return 0;
 }