regmap: Base regmap_register_patch on _regmap_multi_reg_write

[deliverable/linux.git] / drivers / base / regmap / regmap.c

diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index 6a19515f8a458b3719fce7325f265a60a4d147a4..35ab7baffcc597b7f4bb4bf0b25f100d181468f6 100644 (file)
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -1576,6 +1576,26 @@ out:
 }
 EXPORT_SYMBOL_GPL(regmap_bulk_write);
 
+static int _regmap_multi_reg_write(struct regmap *map,
+                                  const struct reg_default *regs,
+                                  int num_regs)
+{
+       int i, ret;
+
+       for (i = 0; i < num_regs; i++) {
+               if (regs[i].reg % map->reg_stride)
+                       return -EINVAL;
+               ret = _regmap_write(map, regs[i].reg, regs[i].def);
+               if (ret != 0) {
+                       dev_err(map->dev, "Failed to write %x = %x: %d\n",
+                               regs[i].reg, regs[i].def, ret);
+                       return ret;
+               }
+       }
+
+       return 0;
+}
+
 /*
  * regmap_multi_reg_write(): Write multiple registers to the device
  *
@@ -1592,31 +1612,60 @@ EXPORT_SYMBOL_GPL(regmap_bulk_write);
  * A value of zero will be returned on success, a negative errno will
  * be returned in error cases.
  */
-int regmap_multi_reg_write(struct regmap *map, struct reg_default *regs,
-                               int num_regs)
+int regmap_multi_reg_write(struct regmap *map, const struct reg_default *regs,
+                          int num_regs)
 {
-       int ret = 0, i;
-
-       for (i = 0; i < num_regs; i++) {
-               int reg = regs[i].reg;
-               if (reg % map->reg_stride)
-                       return -EINVAL;
-       }
+       int ret;
 
        map->lock(map->lock_arg);
 
-       for (i = 0; i < num_regs; i++) {
-               ret = _regmap_write(map, regs[i].reg, regs[i].def);
-               if (ret != 0)
-                       goto out;
-       }
-out:
+       ret = _regmap_multi_reg_write(map, regs, num_regs);
+
        map->unlock(map->lock_arg);
 
        return ret;
 }
 EXPORT_SYMBOL_GPL(regmap_multi_reg_write);
 
+/*
+ * regmap_multi_reg_write_bypassed(): Write multiple registers to the
+ *                                    device but not the cache
+ *
+ * where the set of register are supplied in any order
+ *
+ * @map: Register map to write to
+ * @regs: Array of structures containing register,value to be written
+ * @num_regs: Number of registers to write
+ *
+ * This function is intended to be used for writing a large block of data
+ * atomically to the device in single transfer for those I2C client devices
+ * that implement this alternative block write mode.
+ *
+ * A value of zero will be returned on success, a negative errno will
+ * be returned in error cases.
+ */
+int regmap_multi_reg_write_bypassed(struct regmap *map,
+                                   const struct reg_default *regs,
+                                   int num_regs)
+{
+       int ret;
+       bool bypass;
+
+       map->lock(map->lock_arg);
+
+       bypass = map->cache_bypass;
+       map->cache_bypass = true;
+
+       ret = _regmap_multi_reg_write(map, regs, num_regs);
+
+       map->cache_bypass = bypass;
+
+       map->unlock(map->lock_arg);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);
+
 /**
  * regmap_raw_write_async(): Write raw values to one or more registers
  *                           asynchronously
@@ -2178,7 +2227,7 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
                          int num_regs)
 {
        struct reg_default *p;
-       int i, ret;
+       int ret;
        bool bypass;
 
        if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
@@ -2192,15 +2241,9 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
        map->cache_bypass = true;
        map->async = true;
 
-       /* Write out first; it's useful to apply even if we fail later. */
-       for (i = 0; i < num_regs; i++) {
-               ret = _regmap_write(map, regs[i].reg, regs[i].def);
-               if (ret != 0) {
-                       dev_err(map->dev, "Failed to write %x = %x: %d\n",
-                               regs[i].reg, regs[i].def, ret);
-                       goto out;
-               }
-       }
+       ret = _regmap_multi_reg_write(map, regs, num_regs);
+       if (ret != 0)
+               goto out;
 
        p = krealloc(map->patch,
                     sizeof(struct reg_default) * (map->patch_regs + num_regs),