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", ®); 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 <kimseer.paller@analog.com>"); 269 MODULE_DESCRIPTION("ADMFM2000 Dual Microwave Down Converter"); 270 MODULE_LICENSE("GPL"); 271