iio: adc: ad4130: Fix comparison of channel setups

Checking the binary representation of two structs (of the same type)
for equality doesn't have the same semantic as comparing all members for
equality. The former might find a difference where the latter doesn't in
the presence of padding or when ambiguous types like float or bool are
involved. (Floats typically have different representations for single
values, like -0.0 vs +0.0, or 0.5 * 2² vs 0.25 * 2³. The type bool has
at least 8 bits and the raw values 1 and 2 (probably) both evaluate to
true, but memcmp finds a difference.)

When searching for a channel that already has the configuration we need,
the comparison by member is the one that is needed.

Convert the comparison accordingly to compare the members one after
another. Also add a static_assert guard to (somewhat) ensure that when
struct ad4130_setup_info is expanded, the comparison is adapted, too.

This issue is somewhat theoretic, but using memcmp() on a struct is a
bad pattern that is worth fixing.

Fixes: 62094060cf3a ("iio: adc: ad4130: add AD4130 driver")
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
Link: https://patch.msgid.link/20250303114659.1672695-12-u.kleine-koenig@baylibre.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/adc/ad4130.c b/drivers/iio/adc/ad4130.c
index f3ae41214326e98bf97e65514e348f0c9cb0adff..af0b2be1bab0f7b3dd170acf7d09505acb7a3708 100644 (file)
--- a/drivers/iio/adc/ad4130.c
+++ b/drivers/iio/adc/ad4130.c
@@ -224,6 +224,10 @@ enum ad4130_pin_function {
        AD4130_PIN_FN_VBIAS = BIT(3),
 };
 
+/*
+ * If you make adaptations in this struct, you most likely also have to adapt
+ * ad4130_setup_info_eq(), too.
+ */
 struct ad4130_setup_info {
        unsigned int                    iout0_val;
        unsigned int                    iout1_val;
@@ -592,6 +596,40 @@ static irqreturn_t ad4130_irq_handler(int irq, void *private)
        return IRQ_HANDLED;
 }
 
+static bool ad4130_setup_info_eq(struct ad4130_setup_info *a,
+                                struct ad4130_setup_info *b)
+{
+       /*
+        * This is just to make sure that the comparison is adapted after
+        * struct ad4130_setup_info was changed.
+        */
+       static_assert(sizeof(*a) ==
+                     sizeof(struct {
+                                    unsigned int iout0_val;
+                                    unsigned int iout1_val;
+                                    unsigned int burnout;
+                                    unsigned int pga;
+                                    unsigned int fs;
+                                    u32 ref_sel;
+                                    enum ad4130_filter_mode filter_mode;
+                                    bool ref_bufp;
+                                    bool ref_bufm;
+                            }));
+
+       if (a->iout0_val != b->iout0_val ||
+           a->iout1_val != b->iout1_val ||
+           a->burnout != b->burnout ||
+           a->pga != b->pga ||
+           a->fs != b->fs ||
+           a->ref_sel != b->ref_sel ||
+           a->filter_mode != b->filter_mode ||
+           a->ref_bufp != b->ref_bufp ||
+           a->ref_bufm != b->ref_bufm)
+               return false;
+
+       return true;
+}
+
 static int ad4130_find_slot(struct ad4130_state *st,
                            struct ad4130_setup_info *target_setup_info,
                            unsigned int *slot, bool *overwrite)
@@ -605,8 +643,7 @@ static int ad4130_find_slot(struct ad4130_state *st,
                struct ad4130_slot_info *slot_info = &st->slots_info[i];
 
                /* Immediately accept a matching setup info. */
-               if (!memcmp(target_setup_info, &slot_info->setup,
-                           sizeof(*target_setup_info))) {
+               if (ad4130_setup_info_eq(target_setup_info, &slot_info->setup)) {
                        *slot = i;
                        return 0;
                }