]> git.kernelconcepts.de Git - karo-tx-linux.git/commitdiff
Merge remote-tracking branch 'regmap/topic/update-bits' into regmap-next
authorMark Brown <broonie@kernel.org>
Sat, 5 Mar 2016 12:30:41 +0000 (21:30 +0900)
committerMark Brown <broonie@kernel.org>
Sat, 5 Mar 2016 12:30:41 +0000 (21:30 +0900)
drivers/base/regmap/regmap.c
include/linux/regmap.h

index 8c25635164be5d20268c976ca201ed02bdbd5d77..df2d2ef5d6b38bf374ab8ed3158d80e301a92852 100644 (file)
@@ -1698,100 +1698,63 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
 EXPORT_SYMBOL_GPL(regmap_raw_write);
 
 /**
- * regmap_field_write(): Write a value to a single register field
- *
- * @field: Register field to write to
- * @val: Value to be written
- *
- * A value of zero will be returned on success, a negative errno will
- * be returned in error cases.
- */
-int regmap_field_write(struct regmap_field *field, unsigned int val)
-{
-       return regmap_update_bits(field->regmap, field->reg,
-                               field->mask, val << field->shift);
-}
-EXPORT_SYMBOL_GPL(regmap_field_write);
-
-/**
- * regmap_field_update_bits(): Perform a read/modify/write cycle
- *                              on the register field
+ * regmap_field_update_bits_base():
+ *     Perform a read/modify/write cycle on the register field
+ *     with change, async, force option
  *
  * @field: Register field to write to
  * @mask: Bitmask to change
  * @val: Value to be written
+ * @change: Boolean indicating if a write was done
+ * @async: Boolean indicating asynchronously
+ * @force: Boolean indicating use force update
  *
  * A value of zero will be returned on success, a negative errno will
  * be returned in error cases.
  */
-int regmap_field_update_bits(struct regmap_field *field, unsigned int mask, unsigned int val)
+int regmap_field_update_bits_base(struct regmap_field *field,
+                                 unsigned int mask, unsigned int val,
+                                 bool *change, bool async, bool force)
 {
        mask = (mask << field->shift) & field->mask;
 
-       return regmap_update_bits(field->regmap, field->reg,
-                                 mask, val << field->shift);
-}
-EXPORT_SYMBOL_GPL(regmap_field_update_bits);
-
-/**
- * regmap_fields_write(): Write a value to a single register field with port ID
- *
- * @field: Register field to write to
- * @id: port ID
- * @val: Value to be written
- *
- * A value of zero will be returned on success, a negative errno will
- * be returned in error cases.
- */
-int regmap_fields_write(struct regmap_field *field, unsigned int id,
-                       unsigned int val)
-{
-       if (id >= field->id_size)
-               return -EINVAL;
-
-       return regmap_update_bits(field->regmap,
-                                 field->reg + (field->id_offset * id),
-                                 field->mask, val << field->shift);
-}
-EXPORT_SYMBOL_GPL(regmap_fields_write);
-
-int regmap_fields_force_write(struct regmap_field *field, unsigned int id,
-                       unsigned int val)
-{
-       if (id >= field->id_size)
-               return -EINVAL;
-
-       return regmap_write_bits(field->regmap,
-                                 field->reg + (field->id_offset * id),
-                                 field->mask, val << field->shift);
+       return regmap_update_bits_base(field->regmap, field->reg,
+                                      mask, val << field->shift,
+                                      change, async, force);
 }
-EXPORT_SYMBOL_GPL(regmap_fields_force_write);
+EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
 
 /**
- * regmap_fields_update_bits():        Perform a read/modify/write cycle
- *                              on the register field
+ * regmap_fields_update_bits_base():
+ *     Perform a read/modify/write cycle on the register field
+ *     with change, async, force option
  *
  * @field: Register field to write to
  * @id: port ID
  * @mask: Bitmask to change
  * @val: Value to be written
+ * @change: Boolean indicating if a write was done
+ * @async: Boolean indicating asynchronously
+ * @force: Boolean indicating use force update
  *
  * A value of zero will be returned on success, a negative errno will
  * be returned in error cases.
  */
-int regmap_fields_update_bits(struct regmap_field *field,  unsigned int id,
-                             unsigned int mask, unsigned int val)
+int regmap_fields_update_bits_base(struct regmap_field *field,  unsigned int id,
+                                  unsigned int mask, unsigned int val,
+                                  bool *change, bool async, bool force)
 {
        if (id >= field->id_size)
                return -EINVAL;
 
        mask = (mask << field->shift) & field->mask;
 
-       return regmap_update_bits(field->regmap,
-                                 field->reg + (field->id_offset * id),
-                                 mask, val << field->shift);
+       return regmap_update_bits_base(field->regmap,
+                                      field->reg + (field->id_offset * id),
+                                      mask, val << field->shift,
+                                      change, async, force);
 }
-EXPORT_SYMBOL_GPL(regmap_fields_update_bits);
+EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
 
 /*
  * regmap_bulk_write(): Write multiple registers to the device
@@ -2660,138 +2623,36 @@ static int _regmap_update_bits(struct regmap *map, unsigned int reg,
 }
 
 /**
- * regmap_update_bits: Perform a read/modify/write cycle on the register map
- *
- * @map: Register map to update
- * @reg: Register to update
- * @mask: Bitmask to change
- * @val: New value for bitmask
- *
- * Returns zero for success, a negative number on error.
- */
-int regmap_update_bits(struct regmap *map, unsigned int reg,
-                      unsigned int mask, unsigned int val)
-{
-       int ret;
-
-       map->lock(map->lock_arg);
-       ret = _regmap_update_bits(map, reg, mask, val, NULL, false);
-       map->unlock(map->lock_arg);
-
-       return ret;
-}
-EXPORT_SYMBOL_GPL(regmap_update_bits);
-
-/**
- * regmap_write_bits: Perform a read/modify/write cycle on the register map
- *
- * @map: Register map to update
- * @reg: Register to update
- * @mask: Bitmask to change
- * @val: New value for bitmask
- *
- * Returns zero for success, a negative number on error.
- */
-int regmap_write_bits(struct regmap *map, unsigned int reg,
-                     unsigned int mask, unsigned int val)
-{
-       int ret;
-
-       map->lock(map->lock_arg);
-       ret = _regmap_update_bits(map, reg, mask, val, NULL, true);
-       map->unlock(map->lock_arg);
-
-       return ret;
-}
-EXPORT_SYMBOL_GPL(regmap_write_bits);
-
-/**
- * regmap_update_bits_async: Perform a read/modify/write cycle on the register
- *                           map asynchronously
- *
- * @map: Register map to update
- * @reg: Register to update
- * @mask: Bitmask to change
- * @val: New value for bitmask
- *
- * With most buses the read must be done synchronously so this is most
- * useful for devices with a cache which do not need to interact with
- * the hardware to determine the current register value.
- *
- * Returns zero for success, a negative number on error.
- */
-int regmap_update_bits_async(struct regmap *map, unsigned int reg,
-                            unsigned int mask, unsigned int val)
-{
-       int ret;
-
-       map->lock(map->lock_arg);
-
-       map->async = true;
-
-       ret = _regmap_update_bits(map, reg, mask, val, NULL, false);
-
-       map->async = false;
-
-       map->unlock(map->lock_arg);
-
-       return ret;
-}
-EXPORT_SYMBOL_GPL(regmap_update_bits_async);
-
-/**
- * regmap_update_bits_check: Perform a read/modify/write cycle on the
- *                           register map and report if updated
- *
- * @map: Register map to update
- * @reg: Register to update
- * @mask: Bitmask to change
- * @val: New value for bitmask
- * @change: Boolean indicating if a write was done
- *
- * Returns zero for success, a negative number on error.
- */
-int regmap_update_bits_check(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, false);
-       map->unlock(map->lock_arg);
-       return ret;
-}
-EXPORT_SYMBOL_GPL(regmap_update_bits_check);
-
-/**
- * regmap_update_bits_check_async: Perform a read/modify/write cycle on the
- *                                 register map asynchronously and report if
- *                                 updated
+ * regmap_update_bits_base:
+ *     Perform a read/modify/write cycle on the
+ *     register map with change, async, force option
  *
  * @map: Register map to update
  * @reg: Register to update
  * @mask: Bitmask to change
  * @val: New value for bitmask
  * @change: Boolean indicating if a write was done
+ * @async: Boolean indicating asynchronously
+ * @force: Boolean indicating use force update
  *
+ * if async was true,
  * With most buses the read must be done synchronously so this is most
  * useful for devices with a cache which do not need to interact with
  * the hardware to determine the current register value.
  *
  * Returns zero for success, a negative number on error.
  */
-int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
-                                  unsigned int mask, unsigned int val,
-                                  bool *change)
+int regmap_update_bits_base(struct regmap *map, unsigned int reg,
+                           unsigned int mask, unsigned int val,
+                           bool *change, bool async, bool force)
 {
        int ret;
 
        map->lock(map->lock_arg);
 
-       map->async = true;
+       map->async = async;
 
-       ret = _regmap_update_bits(map, reg, mask, val, change, false);
+       ret = _regmap_update_bits(map, reg, mask, val, change, force);
 
        map->async = false;
 
@@ -2799,7 +2660,7 @@ int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
 
        return ret;
 }
-EXPORT_SYMBOL_GPL(regmap_update_bits_check_async);
+EXPORT_SYMBOL_GPL(regmap_update_bits_base);
 
 void regmap_async_complete_cb(struct regmap_async *async, int ret)
 {
index 182602bca923478984c8b6bb860040f5602e21c7..3dc08ce15426e67eff3cd1c785544c6877603e97 100644 (file)
@@ -65,6 +65,36 @@ struct reg_sequence {
        unsigned int delay_us;
 };
 
+#define        regmap_update_bits(map, reg, mask, val) \
+       regmap_update_bits_base(map, reg, mask, val, NULL, false, false)
+#define        regmap_update_bits_async(map, reg, mask, val)\
+       regmap_update_bits_base(map, reg, mask, val, NULL, true, false)
+#define        regmap_update_bits_check(map, reg, mask, val, change)\
+       regmap_update_bits_base(map, reg, mask, val, change, false, false)
+#define        regmap_update_bits_check_async(map, reg, mask, val, change)\
+       regmap_update_bits_base(map, reg, mask, val, change, true, false)
+
+#define        regmap_write_bits(map, reg, mask, val) \
+       regmap_update_bits_base(map, reg, mask, val, NULL, false, true)
+
+#define        regmap_field_write(field, val) \
+       regmap_field_update_bits_base(field, ~0, val, NULL, false, false)
+#define        regmap_field_force_write(field, val) \
+       regmap_field_update_bits_base(field, ~0, val, NULL, false, true)
+#define        regmap_field_update_bits(field, mask, val)\
+       regmap_field_update_bits_base(field, mask, val, NULL, false, false)
+#define        regmap_field_force_update_bits(field, mask, val) \
+       regmap_field_update_bits_base(field, mask, val, NULL, false, true)
+
+#define        regmap_fields_write(field, id, val) \
+       regmap_fields_update_bits_base(field, id, ~0, val, NULL, false, false)
+#define        regmap_fields_force_write(field, id, val) \
+       regmap_fields_update_bits_base(field, id, ~0, val, NULL, false, true)
+#define        regmap_fields_update_bits(field, id, mask, val)\
+       regmap_fields_update_bits_base(field, id, mask, val, NULL, false, false)
+#define        regmap_fields_force_update_bits(field, id, mask, val) \
+       regmap_fields_update_bits_base(field, id, mask, val, NULL, false, true)
+
 #ifdef CONFIG_REGMAP
 
 enum regmap_endian {
@@ -691,18 +721,9 @@ int regmap_raw_read(struct regmap *map, unsigned int reg,
                    void *val, size_t val_len);
 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
                     size_t val_count);
-int regmap_update_bits(struct regmap *map, unsigned int reg,
-                      unsigned int mask, unsigned int val);
-int regmap_write_bits(struct regmap *map, unsigned int reg,
-                      unsigned int mask, unsigned int val);
-int regmap_update_bits_async(struct regmap *map, unsigned int reg,
-                            unsigned int mask, unsigned int val);
-int regmap_update_bits_check(struct regmap *map, unsigned int reg,
-                            unsigned int mask, unsigned int val,
-                            bool *change);
-int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
-                                  unsigned int mask, unsigned int val,
-                                  bool *change);
+int regmap_update_bits_base(struct regmap *map, unsigned int reg,
+                           unsigned int mask, unsigned int val,
+                           bool *change, bool async, bool force);
 int regmap_get_val_bytes(struct regmap *map);
 int regmap_get_max_register(struct regmap *map);
 int regmap_get_reg_stride(struct regmap *map);
@@ -770,18 +791,14 @@ struct regmap_field *devm_regmap_field_alloc(struct device *dev,
 void devm_regmap_field_free(struct device *dev,        struct regmap_field *field);
 
 int regmap_field_read(struct regmap_field *field, unsigned int *val);
-int regmap_field_write(struct regmap_field *field, unsigned int val);
-int regmap_field_update_bits(struct regmap_field *field,
-                            unsigned int mask, unsigned int val);
-
-int regmap_fields_write(struct regmap_field *field, unsigned int id,
-                       unsigned int val);
-int regmap_fields_force_write(struct regmap_field *field, unsigned int id,
-                       unsigned int val);
+int regmap_field_update_bits_base(struct regmap_field *field,
+                                 unsigned int mask, unsigned int val,
+                                 bool *change, bool async, bool force);
 int regmap_fields_read(struct regmap_field *field, unsigned int id,
                       unsigned int *val);
-int regmap_fields_update_bits(struct regmap_field *field,  unsigned int id,
-                             unsigned int mask, unsigned int val);
+int regmap_fields_update_bits_base(struct regmap_field *field,  unsigned int id,
+                                  unsigned int mask, unsigned int val,
+                                  bool *change, bool async, bool force);
 
 /**
  * Description of an IRQ for the generic regmap irq_chip.
@@ -945,42 +962,26 @@ static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
        return -EINVAL;
 }
 
-static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
-                                    unsigned int mask, unsigned int val)
-{
-       WARN_ONCE(1, "regmap API is disabled");
-       return -EINVAL;
-}
-
-static inline int regmap_write_bits(struct regmap *map, unsigned int reg,
-                                    unsigned int mask, unsigned int val)
+static inline int regmap_update_bits_base(struct regmap *map, unsigned int reg,
+                                         unsigned int mask, unsigned int val,
+                                         bool *change, bool async, bool force)
 {
        WARN_ONCE(1, "regmap API is disabled");
        return -EINVAL;
 }
 
-static inline int regmap_update_bits_async(struct regmap *map,
-                                          unsigned int reg,
-                                          unsigned int mask, unsigned int val)
+static inline int regmap_field_update_bits_base(struct regmap_field *field,
+                                       unsigned int mask, unsigned int val,
+                                       bool *change, bool async, bool force)
 {
        WARN_ONCE(1, "regmap API is disabled");
        return -EINVAL;
 }
 
-static inline int regmap_update_bits_check(struct regmap *map,
-                                          unsigned int reg,
-                                          unsigned int mask, unsigned int val,
-                                          bool *change)
-{
-       WARN_ONCE(1, "regmap API is disabled");
-       return -EINVAL;
-}
-
-static inline int regmap_update_bits_check_async(struct regmap *map,
-                                                unsigned int reg,
-                                                unsigned int mask,
-                                                unsigned int val,
-                                                bool *change)
+static inline int regmap_fields_update_bits_base(struct regmap_field *field,
+                                  unsigned int id,
+                                  unsigned int mask, unsigned int val,
+                                  bool *change, bool async, bool force)
 {
        WARN_ONCE(1, "regmap API is disabled");
        return -EINVAL;