regmap-irq: Fix inverted handling of unmask registers

To me "unmask" suggests that we write 1s to the register when
an interrupt is enabled. This also makes sense because it's the
opposite of what the "mask" register does (write 1s to disable
an interrupt).

But regmap-irq does the opposite: for a disabled interrupt, it
writes 1s to "unmask" and 0s to "mask". This is surprising and
deviates from the usual way mask registers are handled.

Additionally, mask_invert didn't interact with unmask registers
properly -- it caused them to be ignored entirely.

Fix this by making mask and unmask registers orthogonal, using
the following behavior:

* Mask registers are written with 1s for disabled interrupts.
* Unmask registers are written with 1s for enabled interrupts.

This behavior supports both normal or inverted mask registers
and separate set/clear registers via different combinations of
mask_base/unmask_base.

The old unmask register behavior is deprecated. Drivers need to
opt-in to the new behavior by setting mask_unmask_non_inverted.
Warnings are issued if the driver relies on deprecated behavior.
Chips that only set one of mask_base/unmask_base don't have to
use the mask_unmask_non_inverted flag because that use case was
previously not supported.

The mask_invert flag is also deprecated in favor of describing
inverted mask registers as unmask registers.

Signed-off-by: Aidan MacDonald <aidanmacdonald.0x0@gmail.com>
Link: https://lore.kernel.org/r/20220623211420.918875-11-aidanmacdonald.0x0@gmail.com
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/drivers/base/regmap/regmap-irq.c b/drivers/base/regmap/regmap-irq.c
index 8cbc62c3d638c6c0e62e458185a556fded287a28..2c724ae185c4081f2b42c52b20a298ff47ea5e8e 100644 (file)
--- a/drivers/base/regmap/regmap-irq.c
+++ b/drivers/base/regmap/regmap-irq.c
@@ -30,6 +30,9 @@ struct regmap_irq_chip_data {
        int irq;
        int wake_count;
 
+       unsigned int mask_base;
+       unsigned int unmask_base;
+
        void *status_reg_buf;
        unsigned int *main_status_buf;
        unsigned int *status_buf;
@@ -95,7 +98,6 @@ static void regmap_irq_sync_unlock(struct irq_data *data)
        struct regmap *map = d->map;
        int i, j, ret;
        u32 reg;
-       u32 unmask_offset;
        u32 val;
 
        if (d->chip->runtime_pm) {
@@ -124,35 +126,23 @@ static void regmap_irq_sync_unlock(struct irq_data *data)
         * suppress pointless writes.
         */
        for (i = 0; i < d->chip->num_regs; i++) {
-               if (!d->chip->mask_base)
-                       continue;
-
-               reg = sub_irq_reg(d, d->chip->mask_base, i);
-               if (d->chip->mask_invert) {
+               if (d->mask_base) {
+                       reg = sub_irq_reg(d, d->mask_base, i);
                        ret = regmap_update_bits(d->map, reg,
-                                        d->mask_buf_def[i], ~d->mask_buf[i]);
-               } else if (d->chip->unmask_base) {
-                       /* set mask with mask_base register */
+                                       d->mask_buf_def[i], d->mask_buf[i]);
+                       if (ret)
+                               dev_err(d->map->dev, "Failed to sync masks in %x\n",
+                                       reg);
+               }
+
+               if (d->unmask_base) {
+                       reg = sub_irq_reg(d, d->unmask_base, i);
                        ret = regmap_update_bits(d->map, reg,
                                        d->mask_buf_def[i], ~d->mask_buf[i]);
-                       if (ret < 0)
-                               dev_err(d->map->dev,
-                                       "Failed to sync unmasks in %x\n",
+                       if (ret)
+                               dev_err(d->map->dev, "Failed to sync masks in %x\n",
                                        reg);
-                       unmask_offset = d->chip->unmask_base -
-                                                       d->chip->mask_base;
-                       /* clear mask with unmask_base register */
-                       ret = regmap_update_bits(d->map,
-                                       reg + unmask_offset,
-                                       d->mask_buf_def[i],
-                                       d->mask_buf[i]);
-               } else {
-                       ret = regmap_update_bits(d->map, reg,
-                                        d->mask_buf_def[i], d->mask_buf[i]);
                }
-               if (ret != 0)
-                       dev_err(d->map->dev, "Failed to sync masks in %x\n",
-                               reg);
 
                reg = sub_irq_reg(d, d->chip->wake_base, i);
                if (d->wake_buf) {
@@ -704,7 +694,6 @@ int regmap_add_irq_chip_fwnode(struct fwnode_handle *fwnode,
        int ret = -ENOMEM;
        int num_type_reg;
        u32 reg;
-       u32 unmask_offset;
 
        if (chip->num_regs <= 0)
                return -EINVAL;
@@ -832,6 +821,42 @@ int regmap_add_irq_chip_fwnode(struct fwnode_handle *fwnode,
        d->chip = chip;
        d->irq_base = irq_base;
 
+       if (chip->mask_base && chip->unmask_base &&
+           !chip->mask_unmask_non_inverted) {
+               /*
+                * Chips that specify both mask_base and unmask_base used to
+                * get inverted mask behavior by default, with no way to ask
+                * for the normal, non-inverted behavior. This "inverted by
+                * default" behavior is deprecated, but we have to support it
+                * until existing drivers have been fixed.
+                *
+                * Existing drivers should be updated by swapping mask_base
+                * and unmask_base and setting mask_unmask_non_inverted=true.
+                * New drivers should always set the flag.
+                */
+               dev_warn(map->dev, "mask_base and unmask_base are inverted, please fix it");
+
+               /* Might as well warn about mask_invert while we're at it... */
+               if (chip->mask_invert)
+                       dev_warn(map->dev, "mask_invert=true ignored");
+
+               d->mask_base = chip->unmask_base;
+               d->unmask_base = chip->mask_base;
+       } else if (chip->mask_invert) {
+               /*
+                * Swap the roles of mask_base and unmask_base if the bits are
+                * inverted. This is deprecated, drivers should use unmask_base
+                * directly.
+                */
+               dev_warn(map->dev, "mask_invert=true is deprecated; please switch to unmask_base");
+
+               d->mask_base = chip->unmask_base;
+               d->unmask_base = chip->mask_base;
+       } else {
+               d->mask_base = chip->mask_base;
+               d->unmask_base = chip->unmask_base;
+       }
+
        if (chip->irq_reg_stride)
                d->irq_reg_stride = chip->irq_reg_stride;
        else
@@ -854,28 +879,27 @@ int regmap_add_irq_chip_fwnode(struct fwnode_handle *fwnode,
        /* Mask all the interrupts by default */
        for (i = 0; i < chip->num_regs; i++) {
                d->mask_buf[i] = d->mask_buf_def[i];
-               if (!chip->mask_base)
-                       continue;
-
-               reg = sub_irq_reg(d, d->chip->mask_base, i);
 
-               if (chip->mask_invert)
+               if (d->mask_base) {
+                       reg = sub_irq_reg(d, d->mask_base, i);
                        ret = regmap_update_bits(d->map, reg,
-                                        d->mask_buf[i], ~d->mask_buf[i]);
-               else if (d->chip->unmask_base) {
-                       unmask_offset = d->chip->unmask_base -
-                                       d->chip->mask_base;
-                       ret = regmap_update_bits(d->map,
-                                       reg + unmask_offset,
-                                       d->mask_buf[i],
-                                       d->mask_buf[i]);
-               } else
+                                       d->mask_buf_def[i], d->mask_buf[i]);
+                       if (ret) {
+                               dev_err(map->dev, "Failed to set masks in 0x%x: %d\n",
+                                       reg, ret);
+                               goto err_alloc;
+                       }
+               }
+
+               if (d->unmask_base) {
+                       reg = sub_irq_reg(d, d->unmask_base, i);
                        ret = regmap_update_bits(d->map, reg,
-                                        d->mask_buf[i], d->mask_buf[i]);
-               if (ret != 0) {
-                       dev_err(map->dev, "Failed to set masks in 0x%x: %d\n",
-                               reg, ret);
-                       goto err_alloc;
+                                       d->mask_buf_def[i], ~d->mask_buf[i]);
+                       if (ret) {
+                               dev_err(map->dev, "Failed to set masks in 0x%x: %d\n",
+                                       reg, ret);
+                               goto err_alloc;
+                       }
                }
 
                if (!chip->init_ack_masked)

diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index c9a9bbbb626120dcb2f8746e93647c755746eec4..c9c9e39750ed74391c8d577bd94d30860f1b5d8e 100644 (file)
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -1467,9 +1467,10 @@ struct regmap_irq_sub_irq_map {
  *                main_status set.
  *
  * @status_base: Base status register address.
- * @mask_base:   Base mask register address.
- * @unmask_base:  Base unmask register address. for chips who have
- *                separate mask and unmask registers
+ * @mask_base:   Base mask register address. Mask bits are set to 1 when an
+ *               interrupt is masked, 0 when unmasked.
+ * @unmask_base:  Base unmask register address. Unmask bits are set to 1 when
+ *                an interrupt is unmasked and 0 when masked.
  * @ack_base:    Base ack address. If zero then the chip is clear on read.
  *               Using zero value is possible with @use_ack bit.
  * @wake_base:   Base address for wake enables.  If zero unsupported.
@@ -1481,6 +1482,16 @@ struct regmap_irq_sub_irq_map {
  * @irq_reg_stride:  Stride to use for chips where registers are not contiguous.
  * @init_ack_masked: Ack all masked interrupts once during initalization.
  * @mask_invert: Inverted mask register: cleared bits are masked out.
+ *              Deprecated; prefer describing an inverted mask register as
+ *              an unmask register.
+ * @mask_unmask_non_inverted: Controls mask bit inversion for chips that set
+ *     both @mask_base and @unmask_base. If false, mask and unmask bits are
+ *     inverted (which is deprecated behavior); if true, bits will not be
+ *     inverted and the registers keep their normal behavior. Note that if
+ *     you use only one of @mask_base or @unmask_base, this flag has no
+ *     effect and is unnecessary. Any new drivers that set both @mask_base
+ *     and @unmask_base should set this to true to avoid relying on the
+ *     deprecated behavior.
  * @use_ack:     Use @ack register even if it is zero.
  * @ack_invert:  Inverted ack register: cleared bits for ack.
  * @clear_ack:  Use this to set 1 and 0 or vice-versa to clear interrupts.
@@ -1546,6 +1557,7 @@ struct regmap_irq_chip {
        unsigned int irq_reg_stride;
        unsigned int init_ack_masked:1;
        unsigned int mask_invert:1;
+       unsigned int mask_unmask_non_inverted:1;
        unsigned int use_ack:1;
        unsigned int ack_invert:1;
        unsigned int clear_ack:1;