drivers/iio/frequency/admfm2000.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ADMFM2000 Dual Microwave Down Converter
   4  *
   5  * Copyright 2024 Analog Devices Inc.
   6  */
   7
   8 #include <linux/device.h>
   9 #include <linux/err.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/iio/iio.h>
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/mod_devicetable.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/property.h>
  17
  18 #define ADMFM2000_MIXER_MODE            0
  19 #define ADMFM2000_DIRECT_IF_MODE        1
  20 #define ADMFM2000_DSA_GPIOS             5
  21 #define ADMFM2000_MODE_GPIOS            2
  22 #define ADMFM2000_MAX_GAIN              0
  23 #define ADMFM2000_MIN_GAIN              -31000
  24 #define ADMFM2000_DEFAULT_GAIN          -0x20
  25
  26 struct admfm2000_state {
  27         struct mutex                    lock; /* protect sensor state */
  28         struct gpio_desc                *sw1_ch[2];
  29         struct gpio_desc                *sw2_ch[2];
  30         struct gpio_desc                *dsa1_gpios[5];
  31         struct gpio_desc                *dsa2_gpios[5];
  32         u32                             gain[2];
  33 };
  34
  35 static int admfm2000_mode(struct iio_dev *indio_dev, u32 chan, u32 mode)
  36 {
  37         struct admfm2000_state *st = iio_priv(indio_dev);
  38         int i;
  39
  40         switch (mode) {
  41         case ADMFM2000_MIXER_MODE:
  42                 for (i = 0; i < ADMFM2000_MODE_GPIOS; i++) {
  43                         gpiod_set_value_cansleep(st->sw1_ch[i], (chan == 0) ? 1 : 0);
  44                         gpiod_set_value_cansleep(st->sw2_ch[i], (chan == 0) ? 0 : 1);
  45                 }
  46                 return 0;
  47         case ADMFM2000_DIRECT_IF_MODE:
  48                 for (i = 0; i < ADMFM2000_MODE_GPIOS; i++) {
  49                         gpiod_set_value_cansleep(st->sw1_ch[i], (chan == 0) ? 0 : 1);
  50                         gpiod_set_value_cansleep(st->sw2_ch[i], (chan == 0) ? 1 : 0);
  51                 }
  52                 return 0;
  53         default:
  54                 return -EINVAL;
  55         }
  56 }
  57
  58 static int admfm2000_attenuation(struct iio_dev *indio_dev, u32 chan, u32 value)
  59 {
  60         struct admfm2000_state *st = iio_priv(indio_dev);
  61         int i;
  62
  63         switch (chan) {
  64         case 0:
  65                 for (i = 0; i < ADMFM2000_DSA_GPIOS; i++)
  66                         gpiod_set_value_cansleep(st->dsa1_gpios[i], value & (1 << i));
  67                 return 0;
  68         case 1:
  69                 for (i = 0; i < ADMFM2000_DSA_GPIOS; i++)
  70                         gpiod_set_value_cansleep(st->dsa2_gpios[i], value & (1 << i));
  71                 return 0;
  72         default:
  73                 return -EINVAL;
  74         }
  75 }
  76
  77 static int admfm2000_read_raw(struct iio_dev *indio_dev,
  78                               struct iio_chan_spec const *chan, int *val,
  79                               int *val2, long mask)
  80 {
  81         struct admfm2000_state *st = iio_priv(indio_dev);
  82         int gain;
  83
  84         switch (mask) {
  85         case IIO_CHAN_INFO_HARDWAREGAIN:
  86                 mutex_lock(&st->lock);
  87                 gain = ~(st->gain[chan->channel]) * -1000;
  88                 *val = gain / 1000;
  89                 *val2 = (gain % 1000) * 1000;
  90                 mutex_unlock(&st->lock);
  91
  92                 return IIO_VAL_INT_PLUS_MICRO_DB;
  93         default:
  94                 return -EINVAL;
  95         }
  96 }
  97
  98 static int admfm2000_write_raw(struct iio_dev *indio_dev,
  99                                struct iio_chan_spec const *chan, int val,
 100                                int val2, long mask)
 101 {
 102         struct admfm2000_state *st = iio_priv(indio_dev);
 103         int gain, ret;
 104
 105         if (val < 0)
 106                 gain = (val * 1000) - (val2 / 1000);
 107         else
 108                 gain = (val * 1000) + (val2 / 1000);
 109
 110         if (gain > ADMFM2000_MAX_GAIN || gain < ADMFM2000_MIN_GAIN)
 111                 return -EINVAL;
 112
 113         switch (mask) {
 114         case IIO_CHAN_INFO_HARDWAREGAIN:
 115                 mutex_lock(&st->lock);
 116                 st->gain[chan->channel] = ~((abs(gain) / 1000) & 0x1F);
 117
 118                 ret = admfm2000_attenuation(indio_dev, chan->channel,
 119                                             st->gain[chan->channel]);
 120                 mutex_unlock(&st->lock);
 121                 return ret;
 122         default:
 123                 return -EINVAL;
 124         }
 125 }
 126
 127 static int admfm2000_write_raw_get_fmt(struct iio_dev *indio_dev,
 128                                        struct iio_chan_spec const *chan,
 129                                        long mask)
 130 {
 131         switch (mask) {
 132         case IIO_CHAN_INFO_HARDWAREGAIN:
 133                 return IIO_VAL_INT_PLUS_MICRO_DB;
 134         default:
 135                 return -EINVAL;
 136         }
 137 }
 138
 139 static const struct iio_info admfm2000_info = {
 140         .read_raw = &admfm2000_read_raw,
 141         .write_raw = &admfm2000_write_raw,
 142         .write_raw_get_fmt = &admfm2000_write_raw_get_fmt,
 143 };
 144
 145 #define ADMFM2000_CHAN(_channel) {                                      \
 146         .type = IIO_VOLTAGE,                                            \
 147         .output = 1,                                                    \
 148         .indexed = 1,                                                   \
 149         .channel = _channel,                                            \
 150         .info_mask_separate = BIT(IIO_CHAN_INFO_HARDWAREGAIN),          \
 151 }
 152
 153 static const struct iio_chan_spec admfm2000_channels[] = {
 154         ADMFM2000_CHAN(0),
 155         ADMFM2000_CHAN(1),
 156 };
 157
 158 static int admfm2000_channel_config(struct admfm2000_state *st,
 159                                     struct iio_dev *indio_dev)
 160 {
 161         struct platform_device *pdev = to_platform_device(indio_dev->dev.parent);
 162         struct device *dev = &pdev->dev;
 163         struct gpio_desc **dsa;
 164         struct gpio_desc **sw;
 165         int ret, i;
 166         bool mode;
 167         u32 reg;
 168
 169         device_for_each_child_node_scoped(dev, child) {
 170                 ret = fwnode_property_read_u32(child, "reg", &reg);
 171                 if (ret)
 172                         return dev_err_probe(dev, ret,
 173                                              "Failed to get reg property\n");
 174
 175                 if (reg >= indio_dev->num_channels)
 176                         return dev_err_probe(dev, -EINVAL, "reg bigger than: %d\n",
 177                                              indio_dev->num_channels);
 178
 179                 if (fwnode_property_present(child, "adi,mixer-mode"))
 180                         mode = ADMFM2000_MIXER_MODE;
 181                 else
 182                         mode = ADMFM2000_DIRECT_IF_MODE;
 183
 184                 switch (reg) {
 185                 case 0:
 186                         sw = st->sw1_ch;
 187                         dsa = st->dsa1_gpios;
 188                         break;
 189                 case 1:
 190                         sw = st->sw2_ch;
 191                         dsa = st->dsa2_gpios;
 192                         break;
 193                 default:
 194                         return -EINVAL;
 195                 }
 196
 197                 for (i = 0; i < ADMFM2000_MODE_GPIOS; i++) {
 198                         sw[i] = devm_fwnode_gpiod_get_index(dev, child, "switch",
 199                                                             i, GPIOD_OUT_LOW, NULL);
 200                         if (IS_ERR(sw[i]))
 201                                 return dev_err_probe(dev, PTR_ERR(sw[i]),
 202                                                      "Failed to get gpios\n");
 203                 }
 204
 205                 for (i = 0; i < ADMFM2000_DSA_GPIOS; i++) {
 206                         dsa[i] = devm_fwnode_gpiod_get_index(dev, child,
 207                                                              "attenuation", i,
 208                                                              GPIOD_OUT_LOW, NULL);
 209                         if (IS_ERR(dsa[i]))
 210                                 return dev_err_probe(dev, PTR_ERR(dsa[i]),
 211                                                      "Failed to get gpios\n");
 212                 }
 213
 214                 ret = admfm2000_mode(indio_dev, reg, mode);
 215                 if (ret)
 216                         return ret;
 217         }
 218
 219         return 0;
 220 }
 221
 222 static int admfm2000_probe(struct platform_device *pdev)
 223 {
 224         struct device *dev = &pdev->dev;
 225         struct admfm2000_state *st;
 226         struct iio_dev *indio_dev;
 227         int ret;
 228
 229         indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
 230         if (!indio_dev)
 231                 return -ENOMEM;
 232
 233         st = iio_priv(indio_dev);
 234
 235         indio_dev->name = "admfm2000";
 236         indio_dev->num_channels = ARRAY_SIZE(admfm2000_channels);
 237         indio_dev->channels = admfm2000_channels;
 238         indio_dev->info = &admfm2000_info;
 239         indio_dev->modes = INDIO_DIRECT_MODE;
 240
 241         st->gain[0] = ADMFM2000_DEFAULT_GAIN;
 242         st->gain[1] = ADMFM2000_DEFAULT_GAIN;
 243
 244         mutex_init(&st->lock);
 245
 246         ret = admfm2000_channel_config(st, indio_dev);
 247         if (ret)
 248                 return ret;
 249
 250         return devm_iio_device_register(dev, indio_dev);
 251 }
 252
 253 static const struct of_device_id admfm2000_of_match[] = {
 254         { .compatible = "adi,admfm2000" },
 255         { }
 256 };
 257 MODULE_DEVICE_TABLE(of, admfm2000_of_match);
 258
 259 static struct platform_driver admfm2000_driver = {
 260         .driver = {
 261                 .name = "admfm2000",
 262                 .of_match_table = admfm2000_of_match,
 263         },
 264         .probe = admfm2000_probe,
 265 };
 266 module_platform_driver(admfm2000_driver);
 267
 268 MODULE_AUTHOR("Kim Seer Paller <[email protected]>");
 269 MODULE_DESCRIPTION("ADMFM2000 Dual Microwave Down Converter");
 270 MODULE_LICENSE("GPL");