iio: dac: ad5791: Include chip_info in device match tables

Include a chip info struct in device SPI and device OF match tables to
provide channel definitions for each particular ADC model and drop
device enum.

Suggested-by: Nuno Sa <nuno.sa@analog.com>
Reviewed-by: David Lechner <dlechner@baylibre.com>
Signed-off-by: Axel Haslam <ahaslam@baylibre.com>
Link: https://patch.msgid.link/20241031071746.848694-4-ahaslam@baylibre.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/dac/ad5791.c b/drivers/iio/dac/ad5791.c
index 553431bf0232b4792ee7555fd0833f55e2668f34..f6b9a40241f385f87d15542d3f94085fc3fdd9e8 100644 (file)
--- a/drivers/iio/dac/ad5791.c
+++ b/drivers/iio/dac/ad5791.c
@@ -61,11 +61,14 @@
 
 /**
  * struct ad5791_chip_info - chip specific information
+ * @name:              name of the dac chip
+ * @channel:           channel specification
  * @get_lin_comp:      function pointer to the device specific function
  */
-
 struct ad5791_chip_info {
-       int (*get_lin_comp)     (unsigned int span);
+       const char *name;
+       const struct iio_chan_spec channel;
+       int (*get_lin_comp)(unsigned int span);
 };
 
 /**
@@ -98,13 +101,6 @@ struct ad5791_state {
        } data[3] __aligned(IIO_DMA_MINALIGN);
 };
 
-enum ad5791_supported_device_ids {
-       ID_AD5760,
-       ID_AD5780,
-       ID_AD5781,
-       ID_AD5791,
-};
-
 static int ad5791_spi_write(struct ad5791_state *st, u8 addr, u32 val)
 {
        st->data[0].d32 = cpu_to_be32(AD5791_CMD_WRITE |
@@ -228,20 +224,6 @@ static int ad5780_get_lin_comp(unsigned int span)
        else
                return AD5780_LINCOMP_10_20;
 }
-static const struct ad5791_chip_info ad5791_chip_info_tbl[] = {
-       [ID_AD5760] = {
-               .get_lin_comp = ad5780_get_lin_comp,
-       },
-       [ID_AD5780] = {
-               .get_lin_comp = ad5780_get_lin_comp,
-       },
-       [ID_AD5781] = {
-               .get_lin_comp = ad5791_get_lin_comp,
-       },
-       [ID_AD5791] = {
-               .get_lin_comp = ad5791_get_lin_comp,
-       },
-};
 
 static int ad5791_read_raw(struct iio_dev *indio_dev,
                           struct iio_chan_spec const *chan,
@@ -289,30 +271,34 @@ static const struct iio_chan_spec_ext_info ad5791_ext_info[] = {
        { },
 };
 
-#define AD5791_CHAN(bits, _shift) {                    \
-       .type = IIO_VOLTAGE,                            \
-       .output = 1,                                    \
-       .indexed = 1,                                   \
-       .address = AD5791_ADDR_DAC0,                    \
-       .channel = 0,                                   \
-       .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
-       .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
-               BIT(IIO_CHAN_INFO_OFFSET),              \
-       .scan_type = {                                  \
-               .sign = 'u',                            \
-               .realbits = (bits),                     \
-               .storagebits = 24,                      \
-               .shift = (_shift),                      \
-       },                                              \
-       .ext_info = ad5791_ext_info,                    \
+#define AD5791_DEFINE_CHIP_INFO(_name, bits, _shift, _lin_comp)                \
+static const struct ad5791_chip_info _name##_chip_info = {             \
+       .name = #_name,                                                 \
+       .get_lin_comp = &(_lin_comp),                                   \
+       .channel = {                                                    \
+                       .type = IIO_VOLTAGE,                            \
+                       .output = 1,                                    \
+                       .indexed = 1,                                   \
+                       .address = AD5791_ADDR_DAC0,                    \
+                       .channel = 0,                                   \
+                       .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
+                       .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
+                               BIT(IIO_CHAN_INFO_OFFSET),              \
+                       .scan_type = {                                  \
+                               .sign = 'u',                            \
+                               .realbits = (bits),                     \
+                               .storagebits = 24,                      \
+                               .shift = (_shift),                      \
+                       },                                              \
+                       .ext_info = ad5791_ext_info,                    \
+       },                                                              \
 }
 
-static const struct iio_chan_spec ad5791_channels[] = {
-       [ID_AD5760] = AD5791_CHAN(16, 4),
-       [ID_AD5780] = AD5791_CHAN(18, 2),
-       [ID_AD5781] = AD5791_CHAN(18, 2),
-       [ID_AD5791] = AD5791_CHAN(20, 0)
-};
+AD5791_DEFINE_CHIP_INFO(ad5760, 16, 4, ad5780_get_lin_comp);
+AD5791_DEFINE_CHIP_INFO(ad5780, 18, 2, ad5780_get_lin_comp);
+AD5791_DEFINE_CHIP_INFO(ad5781, 18, 2, ad5791_get_lin_comp);
+AD5791_DEFINE_CHIP_INFO(ad5790, 20, 0, ad5791_get_lin_comp);
+AD5791_DEFINE_CHIP_INFO(ad5791, 20, 0, ad5791_get_lin_comp);
 
 static int ad5791_write_raw(struct iio_dev *indio_dev,
                            struct iio_chan_spec const *chan,
@@ -400,9 +386,9 @@ static int ad5791_probe(struct spi_device *spi)
        if (ret)
                goto error_disable_reg_neg;
 
-       st->chip_info = &ad5791_chip_info_tbl[spi_get_device_id(spi)
-                                             ->driver_data];
-
+       st->chip_info = spi_get_device_match_data(spi);
+       if (!st->chip_info)
+               return dev_err_probe(&spi->dev, -EINVAL, "no chip info\n");
 
        st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info->get_lin_comp(st->vref_mv))
                  | (use_rbuf_gain2 ? 0 : AD5791_CTRL_RBUF) |
@@ -416,10 +402,9 @@ static int ad5791_probe(struct spi_device *spi)
        spi_set_drvdata(spi, indio_dev);
        indio_dev->info = &ad5791_info;
        indio_dev->modes = INDIO_DIRECT_MODE;
-       indio_dev->channels
-               = &ad5791_channels[spi_get_device_id(spi)->driver_data];
+       indio_dev->channels = &st->chip_info->channel;
        indio_dev->num_channels = 1;
-       indio_dev->name = spi_get_device_id(st->spi)->name;
+       indio_dev->name = st->chip_info->name;
        ret = iio_device_register(indio_dev);
        if (ret)
                goto error_disable_reg_neg;
@@ -448,19 +433,30 @@ static void ad5791_remove(struct spi_device *spi)
                regulator_disable(st->reg_vss);
 }
 
+static const struct of_device_id ad5791_of_match[] = {
+       { .compatible = "adi,ad5760", .data = &ad5760_chip_info },
+       { .compatible = "adi,ad5780", .data = &ad5780_chip_info },
+       { .compatible = "adi,ad5781", .data = &ad5781_chip_info },
+       { .compatible = "adi,ad5790", .data = &ad5790_chip_info },
+       { .compatible = "adi,ad5791", .data = &ad5791_chip_info },
+       { }
+};
+MODULE_DEVICE_TABLE(of, ad5791_of_match);
+
 static const struct spi_device_id ad5791_id[] = {
-       {"ad5760", ID_AD5760},
-       {"ad5780", ID_AD5780},
-       {"ad5781", ID_AD5781},
-       {"ad5790", ID_AD5791},
-       {"ad5791", ID_AD5791},
-       {}
+       { "ad5760", (kernel_ulong_t)&ad5760_chip_info },
+       { "ad5780", (kernel_ulong_t)&ad5780_chip_info },
+       { "ad5781", (kernel_ulong_t)&ad5781_chip_info },
+       { "ad5790", (kernel_ulong_t)&ad5790_chip_info },
+       { "ad5791", (kernel_ulong_t)&ad5791_chip_info },
+       { }
 };
 MODULE_DEVICE_TABLE(spi, ad5791_id);
 
 static struct spi_driver ad5791_driver = {
        .driver = {
                   .name = "ad5791",
+                  .of_match_table = ad5791_of_match,
                   },
        .probe = ad5791_probe,
        .remove = ad5791_remove,