iio: adc: xilinx-ams: refactor alarm mapping to table-driven approach

Replace multiple open-coded switch statements that map between
scan_index, alarm bits, and register offsets with a centralized
table-driven approach.

Introduce a struct-based alarm_map to describe the relationship
between scan indices and alarm offsets, and add a helper to
translate scan_index to event IDs. This removes duplicated logic
across ams_get_alarm_offset(), ams_event_to_channel(), and
ams_get_alarm_mask().

The new approach improves maintainability, reduces code size,
and makes it easier to extend or modify alarm mappings in the
future, while preserving existing behavior.

Signed-off-by: Guilherme Ivo Bozi <guilherme.bozi@usp.br>
Reviewed-by: Salih Erim <salih.erim@amd.com>
Tested-by: Salih Erim <salih.erim@amd.com>
Signed-off-by: Jonathan Cameron <jic23@kernel.org>

diff --git a/drivers/iio/adc/xilinx-ams.c b/drivers/iio/adc/xilinx-ams.c
index 70a1f97f6dad1068df9b45f59b59ac7e82922549..d38c4401dfce1fd74b6174500282fc237211deb5 100644 (file)
--- a/drivers/iio/adc/xilinx-ams.c
+++ b/drivers/iio/adc/xilinx-ams.c
@@ -102,6 +102,7 @@
 #define AMS_PS_SEQ_MASK                        GENMASK(21, 0)
 #define AMS_PL_SEQ_MASK                        GENMASK_ULL(59, 22)
 
+#define AMS_ALARM_NONE                 0x000 /* not a real offset */
 #define AMS_ALARM_TEMP                 0x140
 #define AMS_ALARM_SUPPLY1              0x144
 #define AMS_ALARM_SUPPLY2              0x148
@@ -763,9 +764,49 @@ static int ams_read_raw(struct iio_dev *indio_dev,
        }
 }
 
+struct ams_alarm_map {
+       enum ams_ps_pl_seq scan_index;
+       unsigned int base_offset;
+};
+
+/*
+ * Array index matches enum ams_alarm_bit.
+ * Entries with base_offset == AMS_ALARM_NONE are unused/invalid
+ * (e.g. RESERVED) and must be skipped.
+ */
+static const struct ams_alarm_map alarm_map[] = {
+       [AMS_ALARM_BIT_TEMP] = { AMS_SEQ_TEMP, AMS_ALARM_TEMP },
+       [AMS_ALARM_BIT_SUPPLY1] = { AMS_SEQ_SUPPLY1, AMS_ALARM_SUPPLY1 },
+       [AMS_ALARM_BIT_SUPPLY2] = { AMS_SEQ_SUPPLY2, AMS_ALARM_SUPPLY2 },
+       [AMS_ALARM_BIT_SUPPLY3] = { AMS_SEQ_SUPPLY3, AMS_ALARM_SUPPLY3 },
+       [AMS_ALARM_BIT_SUPPLY4] = { AMS_SEQ_SUPPLY4, AMS_ALARM_SUPPLY4 },
+       [AMS_ALARM_BIT_SUPPLY5] = { AMS_SEQ_SUPPLY5, AMS_ALARM_SUPPLY5 },
+       [AMS_ALARM_BIT_SUPPLY6] = { AMS_SEQ_SUPPLY6, AMS_ALARM_SUPPLY6 },
+       [AMS_ALARM_BIT_RESERVED] = { 0, AMS_ALARM_NONE },
+       [AMS_ALARM_BIT_SUPPLY7] = { AMS_SEQ_SUPPLY7, AMS_ALARM_SUPPLY7 },
+       [AMS_ALARM_BIT_SUPPLY8] = { AMS_SEQ_SUPPLY8, AMS_ALARM_SUPPLY8 },
+       [AMS_ALARM_BIT_SUPPLY9] = { AMS_SEQ_SUPPLY9, AMS_ALARM_SUPPLY9 },
+       [AMS_ALARM_BIT_SUPPLY10] = { AMS_SEQ_SUPPLY10, AMS_ALARM_SUPPLY10 },
+       [AMS_ALARM_BIT_VCCAMS] = { AMS_SEQ_VCCAMS, AMS_ALARM_VCCAMS },
+       [AMS_ALARM_BIT_TEMP_REMOTE] = { AMS_SEQ_TEMP_REMOTE, AMS_ALARM_TEMP_REMOTE },
+};
+
+static int ams_scan_index_to_event(int scan_index)
+{
+       for (unsigned int i = 0; i < ARRAY_SIZE(alarm_map); i++) {
+               if (alarm_map[i].base_offset == AMS_ALARM_NONE)
+                       continue;
+
+               if (alarm_map[i].scan_index == scan_index)
+                       return i;
+       }
+
+       return -EINVAL;
+}
+
 static int ams_get_alarm_offset(int scan_index, enum iio_event_direction dir)
 {
-       int offset;
+       int offset, event;
 
        if (scan_index >= AMS_PS_SEQ_MAX)
                scan_index -= AMS_PS_SEQ_MAX;
@@ -779,36 +820,11 @@ static int ams_get_alarm_offset(int scan_index, enum iio_event_direction dir)
                offset = 0;
        }
 
-       switch (scan_index) {
-       case AMS_SEQ_TEMP:
-               return AMS_ALARM_TEMP + offset;
-       case AMS_SEQ_SUPPLY1:
-               return AMS_ALARM_SUPPLY1 + offset;
-       case AMS_SEQ_SUPPLY2:
-               return AMS_ALARM_SUPPLY2 + offset;
-       case AMS_SEQ_SUPPLY3:
-               return AMS_ALARM_SUPPLY3 + offset;
-       case AMS_SEQ_SUPPLY4:
-               return AMS_ALARM_SUPPLY4 + offset;
-       case AMS_SEQ_SUPPLY5:
-               return AMS_ALARM_SUPPLY5 + offset;
-       case AMS_SEQ_SUPPLY6:
-               return AMS_ALARM_SUPPLY6 + offset;
-       case AMS_SEQ_SUPPLY7:
-               return AMS_ALARM_SUPPLY7 + offset;
-       case AMS_SEQ_SUPPLY8:
-               return AMS_ALARM_SUPPLY8 + offset;
-       case AMS_SEQ_SUPPLY9:
-               return AMS_ALARM_SUPPLY9 + offset;
-       case AMS_SEQ_SUPPLY10:
-               return AMS_ALARM_SUPPLY10 + offset;
-       case AMS_SEQ_VCCAMS:
-               return AMS_ALARM_VCCAMS + offset;
-       case AMS_SEQ_TEMP_REMOTE:
-               return AMS_ALARM_TEMP_REMOTE + offset;
-       default:
+       event = ams_scan_index_to_event(scan_index);
+       if (event < 0 || alarm_map[event].base_offset == AMS_ALARM_NONE)
                return 0;
-       }
+
+       return alarm_map[event].base_offset + offset;
 }
 
 static const struct iio_chan_spec *ams_event_to_channel(struct iio_dev *dev,
@@ -821,49 +837,13 @@ static const struct iio_chan_spec *ams_event_to_channel(struct iio_dev *dev,
                scan_index = AMS_PS_SEQ_MAX;
        }
 
-       switch (event) {
-       case AMS_ALARM_BIT_TEMP:
-               scan_index += AMS_SEQ_TEMP;
-               break;
-       case AMS_ALARM_BIT_SUPPLY1:
-               scan_index += AMS_SEQ_SUPPLY1;
-               break;
-       case AMS_ALARM_BIT_SUPPLY2:
-               scan_index += AMS_SEQ_SUPPLY2;
-               break;
-       case AMS_ALARM_BIT_SUPPLY3:
-               scan_index += AMS_SEQ_SUPPLY3;
-               break;
-       case AMS_ALARM_BIT_SUPPLY4:
-               scan_index += AMS_SEQ_SUPPLY4;
-               break;
-       case AMS_ALARM_BIT_SUPPLY5:
-               scan_index += AMS_SEQ_SUPPLY5;
-               break;
-       case AMS_ALARM_BIT_SUPPLY6:
-               scan_index += AMS_SEQ_SUPPLY6;
-               break;
-       case AMS_ALARM_BIT_SUPPLY7:
-               scan_index += AMS_SEQ_SUPPLY7;
-               break;
-       case AMS_ALARM_BIT_SUPPLY8:
-               scan_index += AMS_SEQ_SUPPLY8;
-               break;
-       case AMS_ALARM_BIT_SUPPLY9:
-               scan_index += AMS_SEQ_SUPPLY9;
-               break;
-       case AMS_ALARM_BIT_SUPPLY10:
-               scan_index += AMS_SEQ_SUPPLY10;
-               break;
-       case AMS_ALARM_BIT_VCCAMS:
-               scan_index += AMS_SEQ_VCCAMS;
-               break;
-       case AMS_ALARM_BIT_TEMP_REMOTE:
-               scan_index += AMS_SEQ_TEMP_REMOTE;
-               break;
-       default:
-               break;
-       }
+       if (event >= ARRAY_SIZE(alarm_map))
+               return NULL;
+
+       if (alarm_map[event].base_offset == AMS_ALARM_NONE)
+               return NULL;
+
+       scan_index += alarm_map[event].scan_index;
 
        for (i = 0; i < dev->num_channels; i++)
                if (dev->channels[i].scan_index == scan_index)
@@ -877,43 +857,18 @@ static const struct iio_chan_spec *ams_event_to_channel(struct iio_dev *dev,
 
 static int ams_get_alarm_mask(int scan_index)
 {
-       int bit = 0;
+       int bit = 0, event;
 
        if (scan_index >= AMS_PS_SEQ_MAX) {
                bit = AMS_PL_ALARM_START;
                scan_index -= AMS_PS_SEQ_MAX;
        }
 
-       switch (scan_index) {
-       case AMS_SEQ_TEMP:
-               return BIT(AMS_ALARM_BIT_TEMP + bit);
-       case AMS_SEQ_SUPPLY1:
-               return BIT(AMS_ALARM_BIT_SUPPLY1 + bit);
-       case AMS_SEQ_SUPPLY2:
-               return BIT(AMS_ALARM_BIT_SUPPLY2 + bit);
-       case AMS_SEQ_SUPPLY3:
-               return BIT(AMS_ALARM_BIT_SUPPLY3 + bit);
-       case AMS_SEQ_SUPPLY4:
-               return BIT(AMS_ALARM_BIT_SUPPLY4 + bit);
-       case AMS_SEQ_SUPPLY5:
-               return BIT(AMS_ALARM_BIT_SUPPLY5 + bit);
-       case AMS_SEQ_SUPPLY6:
-               return BIT(AMS_ALARM_BIT_SUPPLY6 + bit);
-       case AMS_SEQ_SUPPLY7:
-               return BIT(AMS_ALARM_BIT_SUPPLY7 + bit);
-       case AMS_SEQ_SUPPLY8:
-               return BIT(AMS_ALARM_BIT_SUPPLY8 + bit);
-       case AMS_SEQ_SUPPLY9:
-               return BIT(AMS_ALARM_BIT_SUPPLY9 + bit);
-       case AMS_SEQ_SUPPLY10:
-               return BIT(AMS_ALARM_BIT_SUPPLY10 + bit);
-       case AMS_SEQ_VCCAMS:
-               return BIT(AMS_ALARM_BIT_VCCAMS + bit);
-       case AMS_SEQ_TEMP_REMOTE:
-               return BIT(AMS_ALARM_BIT_TEMP_REMOTE + bit);
-       default:
+       event = ams_scan_index_to_event(scan_index);
+       if (event < 0)
                return 0;
-       }
+
+       return BIT(event + bit);
 }
 
 static int ams_read_event_config(struct iio_dev *indio_dev,