net: ipa: introduce ipa_reg field masks

Add register field descriptors to the ipa_reg structure.  A field in
a register is defined by a field mask, which is a 32-bit mask having
a single contiguous range of bits set.

For each register that has at least one field defined, an enumerated
type will identify the register's fields.  The ipa_reg structure for
that register will include an array fmask[] of field masks, indexed
by that enumerated type.  Each field mask defines the position and
bit width of a field.  An additional "fcount" records how many
fields (masks) are defined for a given register.

Introduce two macros to be used to define registers that have at
least one field.

Introduce a few new functions related to field masks.  The first
simply returns a field mask, given an IPA register pointer and field
mask ID.  A variant of that is meant to be used for the special case
of single-bit field masks.

Next, ipa_reg_encode(), identifies a field with an IPA register
pointer and a field ID, and takes a value to represent in that
field.  The result encodes the value in the appropriate place to be
stored in the register.  This is roughly modeled after the bitmask
operations (like u32_encode_bits()).

Another function (ipa_reg_decode()) similarly identifies a register
field, but the value supplied to it represents a full register
value.  The value encoded in the field is extracted from the value
and returned.  This is also roughly modeled after bitmask operations
(such as u32_get_bits()).

Finally, ipa_reg_field_max() returns the maximum value representable
by a field.

Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/drivers/net/ipa/ipa_reg.h b/drivers/net/ipa/ipa_reg.h
index 49eec53a375ecc9fff36fb8bf8cf306d603b70fb..a616b0c3d59a637c1bf928dcfe51530c4697de6a 100644 (file)
--- a/drivers/net/ipa/ipa_reg.h
+++ b/drivers/net/ipa/ipa_reg.h
@@ -125,11 +125,15 @@ enum ipa_reg_id {
  * struct ipa_reg - An IPA register descriptor
  * @offset:    Register offset relative to base of the "ipa-reg" memory
  * @stride:    Distance between two instances, if parameterized
+ * @fcount:    Number of entries in the @fmask array
+ * @fmask:     Array of mask values defining position and width of fields
  * @name:      Upper-case name of the IPA register
  */
 struct ipa_reg {
        u32 offset;
        u32 stride;
+       u32 fcount;
+       const u32 *fmask;                       /* BIT(nr) or GENMASK(h, l) */
        const char *name;
 };
 
@@ -145,6 +149,18 @@ struct ipa_reg {
                .stride = __stride,                                     \
        }
 
+#define IPA_REG_FIELDS(__NAME, __name, __offset)                       \
+       IPA_REG_STRIDE_FIELDS(__NAME, __name, __offset, 0)
+
+#define IPA_REG_STRIDE_FIELDS(__NAME, __name, __offset, __stride)      \
+       static const struct ipa_reg ipa_reg_ ## __name = {              \
+               .name   = #__NAME,                                      \
+               .offset = __offset,                                     \
+               .stride = __stride,                                     \
+               .fcount = ARRAY_SIZE(ipa_reg_ ## __name ## _fmask),     \
+               .fmask  = ipa_reg_ ## __name ## _fmask,                 \
+       }
+
 /**
  * struct ipa_regs - Description of registers supported by hardware
  * @reg_count: Number of registers in the @reg[] array
@@ -746,6 +762,58 @@ extern const struct ipa_regs ipa_regs_v4_5;
 extern const struct ipa_regs ipa_regs_v4_9;
 extern const struct ipa_regs ipa_regs_v4_11;
 
+/* Return the field mask for a field in a register */
+static inline u32 ipa_reg_fmask(const struct ipa_reg *reg, u32 field_id)
+{
+       if (!reg || WARN_ON(field_id >= reg->fcount))
+               return 0;
+
+       return reg->fmask[field_id];
+}
+
+/* Return the mask for a single-bit field in a register */
+static inline u32 ipa_reg_bit(const struct ipa_reg *reg, u32 field_id)
+{
+       u32 fmask = ipa_reg_fmask(reg, field_id);
+
+       WARN_ON(!is_power_of_2(fmask));
+
+       return fmask;
+}
+
+/* Encode a value into the given field of a register */
+static inline u32
+ipa_reg_encode(const struct ipa_reg *reg, u32 field_id, u32 val)
+{
+       u32 fmask = ipa_reg_fmask(reg, field_id);
+
+       if (!fmask)
+               return 0;
+
+       val <<= __ffs(fmask);
+       if (WARN_ON(val & ~fmask))
+               return 0;
+
+       return val;
+}
+
+/* Given a register value, decode (extract) the value in the given field */
+static inline u32
+ipa_reg_decode(const struct ipa_reg *reg, u32 field_id, u32 val)
+{
+       u32 fmask = ipa_reg_fmask(reg, field_id);
+
+       return fmask ? (val & fmask) >> __ffs(fmask) : 0;
+}
+
+/* Return the maximum value representable by the given field; always 2^n - 1 */
+static inline u32 ipa_reg_field_max(const struct ipa_reg *reg, u32 field_id)
+{
+       u32 fmask = ipa_reg_fmask(reg, field_id);
+
+       return fmask ? fmask >> __ffs(fmask) : 0;
+}
+
 const struct ipa_reg *ipa_reg(struct ipa *ipa, enum ipa_reg_id reg_id);
 
 /* Returns 0 for NULL reg; warning will have already been issued */