1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * AD7091RX Analog to Digital converter driver 4 * 5 * Copyright 2014-2019 Analog Devices Inc. 6 */ 7 8 #include <linux/bitops.h> 9 #include <linux/iio/events.h> 10 #include <linux/iio/iio.h> 11 #include <linux/interrupt.h> 12 #include <linux/module.h> 13 #include <linux/regmap.h> 14 #include <linux/regulator/consumer.h> 15 16 #include "ad7091r-base.h" 17 18 #define AD7091R_REG_RESULT 0 19 #define AD7091R_REG_CHANNEL 1 20 #define AD7091R_REG_CONF 2 21 #define AD7091R_REG_ALERT 3 22 #define AD7091R_REG_CH_LOW_LIMIT(ch) ((ch) * 3 + 4) 23 #define AD7091R_REG_CH_HIGH_LIMIT(ch) ((ch) * 3 + 5) 24 #define AD7091R_REG_CH_HYSTERESIS(ch) ((ch) * 3 + 6) 25 26 /* AD7091R_REG_RESULT */ 27 #define AD7091R_REG_RESULT_CH_ID(x) (((x) >> 13) & 0x3) 28 #define AD7091R_REG_RESULT_CONV_RESULT(x) ((x) & 0xfff) 29 30 /* AD7091R_REG_CONF */ 31 #define AD7091R_REG_CONF_AUTO BIT(8) 32 #define AD7091R_REG_CONF_CMD BIT(10) 33 34 #define AD7091R_REG_CONF_MODE_MASK \ 35 (AD7091R_REG_CONF_AUTO | AD7091R_REG_CONF_CMD) 36 37 enum ad7091r_mode { 38 AD7091R_MODE_SAMPLE, 39 AD7091R_MODE_COMMAND, 40 AD7091R_MODE_AUTOCYCLE, 41 }; 42 43 struct ad7091r_state { 44 struct device *dev; 45 struct regmap *map; 46 struct regulator *vref; 47 const struct ad7091r_chip_info *chip_info; 48 enum ad7091r_mode mode; 49 struct mutex lock; /*lock to prevent concurent reads */ 50 }; 51 52 static int ad7091r_set_mode(struct ad7091r_state *st, enum ad7091r_mode mode) 53 { 54 int ret, conf; 55 56 switch (mode) { 57 case AD7091R_MODE_SAMPLE: 58 conf = 0; 59 break; 60 case AD7091R_MODE_COMMAND: 61 conf = AD7091R_REG_CONF_CMD; 62 break; 63 case AD7091R_MODE_AUTOCYCLE: 64 conf = AD7091R_REG_CONF_AUTO; 65 break; 66 default: 67 return -EINVAL; 68 } 69 70 ret = regmap_update_bits(st->map, AD7091R_REG_CONF, 71 AD7091R_REG_CONF_MODE_MASK, conf); 72 if (ret) 73 return ret; 74 75 st->mode = mode; 76 77 return 0; 78 } 79 80 static int ad7091r_set_channel(struct ad7091r_state *st, unsigned int channel) 81 { 82 unsigned int dummy; 83 int ret; 84 85 /* AD7091R_REG_CHANNEL specified which channels to be converted */ 86 ret = regmap_write(st->map, AD7091R_REG_CHANNEL, 87 BIT(channel) | (BIT(channel) << 8)); 88 if (ret) 89 return ret; 90 91 /* 92 * There is a latency of one conversion before the channel conversion 93 * sequence is updated 94 */ 95 return regmap_read(st->map, AD7091R_REG_RESULT, &dummy); 96 } 97 98 static int ad7091r_read_one(struct iio_dev *iio_dev, 99 unsigned int channel, unsigned int *read_val) 100 { 101 struct ad7091r_state *st = iio_priv(iio_dev); 102 unsigned int val; 103 int ret; 104 105 ret = ad7091r_set_channel(st, channel); 106 if (ret) 107 return ret; 108 109 ret = regmap_read(st->map, AD7091R_REG_RESULT, &val); 110 if (ret) 111 return ret; 112 113 if (AD7091R_REG_RESULT_CH_ID(val) != channel) 114 return -EIO; 115 116 *read_val = AD7091R_REG_RESULT_CONV_RESULT(val); 117 118 return 0; 119 } 120 121 static int ad7091r_read_raw(struct iio_dev *iio_dev, 122 struct iio_chan_spec const *chan, 123 int *val, int *val2, long m) 124 { 125 struct ad7091r_state *st = iio_priv(iio_dev); 126 unsigned int read_val; 127 int ret; 128 129 mutex_lock(&st->lock); 130 131 switch (m) { 132 case IIO_CHAN_INFO_RAW: 133 if (st->mode != AD7091R_MODE_COMMAND) { 134 ret = -EBUSY; 135 goto unlock; 136 } 137 138 ret = ad7091r_read_one(iio_dev, chan->channel, &read_val); 139 if (ret) 140 goto unlock; 141 142 *val = read_val; 143 ret = IIO_VAL_INT; 144 break; 145 146 case IIO_CHAN_INFO_SCALE: 147 if (st->vref) { 148 ret = regulator_get_voltage(st->vref); 149 if (ret < 0) 150 goto unlock; 151 152 *val = ret / 1000; 153 } else { 154 *val = st->chip_info->vref_mV; 155 } 156 157 *val2 = chan->scan_type.realbits; 158 ret = IIO_VAL_FRACTIONAL_LOG2; 159 break; 160 161 default: 162 ret = -EINVAL; 163 break; 164 } 165 166 unlock: 167 mutex_unlock(&st->lock); 168 return ret; 169 } 170 171 static const struct iio_info ad7091r_info = { 172 .read_raw = ad7091r_read_raw, 173 }; 174 175 static irqreturn_t ad7091r_event_handler(int irq, void *private) 176 { 177 struct ad7091r_state *st = (struct ad7091r_state *) private; 178 struct iio_dev *iio_dev = dev_get_drvdata(st->dev); 179 unsigned int i, read_val; 180 int ret; 181 s64 timestamp = iio_get_time_ns(iio_dev); 182 183 ret = regmap_read(st->map, AD7091R_REG_ALERT, &read_val); 184 if (ret) 185 return IRQ_HANDLED; 186 187 for (i = 0; i < st->chip_info->num_channels; i++) { 188 if (read_val & BIT(i * 2)) 189 iio_push_event(iio_dev, 190 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, i, 191 IIO_EV_TYPE_THRESH, 192 IIO_EV_DIR_RISING), timestamp); 193 if (read_val & BIT(i * 2 + 1)) 194 iio_push_event(iio_dev, 195 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, i, 196 IIO_EV_TYPE_THRESH, 197 IIO_EV_DIR_FALLING), timestamp); 198 } 199 200 return IRQ_HANDLED; 201 } 202 203 static void ad7091r_remove(void *data) 204 { 205 struct ad7091r_state *st = data; 206 207 regulator_disable(st->vref); 208 } 209 210 int ad7091r_probe(struct device *dev, const char *name, 211 const struct ad7091r_chip_info *chip_info, 212 struct regmap *map, int irq) 213 { 214 struct iio_dev *iio_dev; 215 struct ad7091r_state *st; 216 int ret; 217 218 iio_dev = devm_iio_device_alloc(dev, sizeof(*st)); 219 if (!iio_dev) 220 return -ENOMEM; 221 222 st = iio_priv(iio_dev); 223 st->dev = dev; 224 st->chip_info = chip_info; 225 st->map = map; 226 227 iio_dev->dev.parent = dev; 228 iio_dev->name = name; 229 iio_dev->info = &ad7091r_info; 230 iio_dev->modes = INDIO_DIRECT_MODE; 231 232 iio_dev->num_channels = chip_info->num_channels; 233 iio_dev->channels = chip_info->channels; 234 235 if (irq) { 236 ret = devm_request_threaded_irq(dev, irq, NULL, 237 ad7091r_event_handler, 238 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, name, st); 239 if (ret) 240 return ret; 241 } 242 243 st->vref = devm_regulator_get_optional(dev, "vref"); 244 if (IS_ERR(st->vref)) { 245 if (PTR_ERR(st->vref) == -EPROBE_DEFER) 246 return -EPROBE_DEFER; 247 st->vref = NULL; 248 } else { 249 ret = regulator_enable(st->vref); 250 if (ret) 251 return ret; 252 ret = devm_add_action_or_reset(dev, ad7091r_remove, st); 253 if (ret) 254 return ret; 255 } 256 257 /* Use command mode by default to convert only desired channels*/ 258 ret = ad7091r_set_mode(st, AD7091R_MODE_COMMAND); 259 if (ret) 260 return ret; 261 262 return devm_iio_device_register(dev, iio_dev); 263 } 264 EXPORT_SYMBOL_GPL(ad7091r_probe); 265 266 static bool ad7091r_writeable_reg(struct device *dev, unsigned int reg) 267 { 268 switch (reg) { 269 case AD7091R_REG_RESULT: 270 case AD7091R_REG_ALERT: 271 return false; 272 default: 273 return true; 274 } 275 } 276 277 static bool ad7091r_volatile_reg(struct device *dev, unsigned int reg) 278 { 279 switch (reg) { 280 case AD7091R_REG_RESULT: 281 case AD7091R_REG_ALERT: 282 return true; 283 default: 284 return false; 285 } 286 } 287 288 const struct regmap_config ad7091r_regmap_config = { 289 .reg_bits = 8, 290 .val_bits = 16, 291 .writeable_reg = ad7091r_writeable_reg, 292 .volatile_reg = ad7091r_volatile_reg, 293 }; 294 EXPORT_SYMBOL_GPL(ad7091r_regmap_config); 295 296 MODULE_AUTHOR("Beniamin Bia <beniamin.bia@analog.com>"); 297 MODULE_DESCRIPTION("Analog Devices AD7091Rx multi-channel converters"); 298 MODULE_LICENSE("GPL v2"); 299