Merge remote-tracking branches 'regmap/topic/cache', 'regmap/topic/irq', 'regmap...

[karo-tx-linux.git] / drivers / base / regmap / regmap.c

diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index c69bbc06dfbb58b8fe727f17d41d766343cd2bec..d0a072463a04ff1c4d3f83cbd66de587be4c5e44 100644 (file)
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -380,6 +380,28 @@ static void regmap_range_exit(struct regmap *map)
        kfree(map->selector_work_buf);
 }
 
+int regmap_attach_dev(struct device *dev, struct regmap *map,
+                     const struct regmap_config *config)
+{
+       struct regmap **m;
+
+       map->dev = dev;
+
+       regmap_debugfs_init(map, config->name);
+
+       /* Add a devres resource for dev_get_regmap() */
+       m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
+       if (!m) {
+               regmap_debugfs_exit(map);
+               return -ENOMEM;
+       }
+       *m = map;
+       devres_add(dev, m);
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(regmap_attach_dev);
+
 /**
  * regmap_init(): Initialise register map
  *
@@ -397,7 +419,7 @@ struct regmap *regmap_init(struct device *dev,
                           void *bus_context,
                           const struct regmap_config *config)
 {
-       struct regmap *map, **m;
+       struct regmap *map;
        int ret = -EINVAL;
        enum regmap_endian reg_endian, val_endian;
        int i, j;
@@ -719,7 +741,7 @@ skip_format_initialization:
                new->window_start = range_cfg->window_start;
                new->window_len = range_cfg->window_len;
 
-               if (_regmap_range_add(map, new) == false) {
+               if (!_regmap_range_add(map, new)) {
                        dev_err(map->dev, "Failed to add range %d\n", i);
                        kfree(new);
                        goto err_range;
@@ -735,25 +757,18 @@ skip_format_initialization:
                }
        }
 
-       regmap_debugfs_init(map, config->name);
-
        ret = regcache_init(map, config);
        if (ret != 0)
                goto err_range;
 
-       /* Add a devres resource for dev_get_regmap() */
-       m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
-       if (!m) {
-               ret = -ENOMEM;
-               goto err_debugfs;
-       }
-       *m = map;
-       devres_add(dev, m);
+       if (dev)
+               ret = regmap_attach_dev(dev, map, config);
+               if (ret != 0)
+                       goto err_regcache;
 
        return map;
 
-err_debugfs:
-       regmap_debugfs_exit(map);
+err_regcache:
        regcache_exit(map);
 err_range:
        regmap_range_exit(map);
@@ -1521,12 +1536,12 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
        if (reg % map->reg_stride)
                return -EINVAL;
 
-       map->lock(map->lock_arg);
        /*
         * Some devices don't support bulk write, for
         * them we have a series of single write operations.
         */
        if (!map->bus || map->use_single_rw) {
+               map->lock(map->lock_arg);
                for (i = 0; i < val_count; i++) {
                        unsigned int ival;
 
@@ -1555,24 +1570,25 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
                        if (ret != 0)
                                goto out;
                }
+out:
+               map->unlock(map->lock_arg);
        } else {
                void *wval;
 
                wval = kmemdup(val, val_count * val_bytes, GFP_KERNEL);
                if (!wval) {
-                       ret = -ENOMEM;
                        dev_err(map->dev, "Error in memory allocation\n");
-                       goto out;
+                       return -ENOMEM;
                }
                for (i = 0; i < val_count * val_bytes; i += val_bytes)
                        map->format.parse_inplace(wval + i);
 
+               map->lock(map->lock_arg);
                ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count);
+               map->unlock(map->lock_arg);
 
                kfree(wval);
        }
-out:
-       map->unlock(map->lock_arg);
        return ret;
 }
 EXPORT_SYMBOL_GPL(regmap_bulk_write);
@@ -1941,6 +1957,9 @@ static int _regmap_read(struct regmap *map, unsigned int reg,
        if (map->cache_only)
                return -EBUSY;
 
+       if (!regmap_readable(map, reg))
+               return -EIO;
+
        ret = map->reg_read(context, reg, val);
        if (ret == 0) {
 #ifdef LOG_DEVICE
@@ -2171,9 +2190,11 @@ static int _regmap_update_bits(struct regmap *map, unsigned int reg,
 
        if (tmp != orig) {
                ret = _regmap_write(map, reg, tmp);
-               *change = true;
+               if (change)
+                       *change = true;
        } else {
-               *change = false;
+               if (change)
+                       *change = false;
        }
 
        return ret;
@@ -2192,11 +2213,10 @@ static int _regmap_update_bits(struct regmap *map, unsigned int reg,
 int regmap_update_bits(struct regmap *map, unsigned int reg,
                       unsigned int mask, unsigned int val)
 {
-       bool change;
        int ret;
 
        map->lock(map->lock_arg);
-       ret = _regmap_update_bits(map, reg, mask, val, &change);
+       ret = _regmap_update_bits(map, reg, mask, val, NULL);
        map->unlock(map->lock_arg);
 
        return ret;
@@ -2221,14 +2241,13 @@ EXPORT_SYMBOL_GPL(regmap_update_bits);
 int regmap_update_bits_async(struct regmap *map, unsigned int reg,
                             unsigned int mask, unsigned int val)
 {
-       bool change;
        int ret;
 
        map->lock(map->lock_arg);
 
        map->async = true;
 
-       ret = _regmap_update_bits(map, reg, mask, val, &change);
+       ret = _regmap_update_bits(map, reg, mask, val, NULL);
 
        map->async = false;
 
@@ -2378,6 +2397,9 @@ EXPORT_SYMBOL_GPL(regmap_async_complete);
  * apply them immediately.  Typically this is used to apply
  * corrections to be applied to the device defaults on startup, such
  * as the updates some vendors provide to undocumented registers.
+ *
+ * The caller must ensure that this function cannot be called
+ * concurrently with either itself or regcache_sync().
  */
 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
                          int num_regs)
@@ -2390,6 +2412,17 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
            num_regs))
                return 0;
 
+       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 {
+               return -ENOMEM;
+       }
+
        map->lock(map->lock_arg);
 
        bypass = map->cache_bypass;
@@ -2401,17 +2434,6 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
        if (ret != 0)
                goto out;
 
-       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;
-       }
-
 out:
        map->async = false;
        map->cache_bypass = bypass;
@@ -2439,6 +2461,18 @@ int regmap_get_val_bytes(struct regmap *map)
 }
 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
 
+int regmap_parse_val(struct regmap *map, const void *buf,
+                       unsigned int *val)
+{
+       if (!map->format.parse_val)
+               return -EINVAL;
+
+       *val = map->format.parse_val(buf);
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(regmap_parse_val);
+
 static int __init regmap_initcall(void)
 {
        regmap_debugfs_initcall();