1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * AD7291 8-Channel, I2C, 12-Bit SAR ADC with Temperature Sensor 4 * 5 * Copyright 2010-2011 Analog Devices Inc. 6 */ 7 8 #include <linux/device.h> 9 #include <linux/err.h> 10 #include <linux/i2c.h> 11 #include <linux/interrupt.h> 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/mutex.h> 15 #include <linux/regulator/consumer.h> 16 #include <linux/slab.h> 17 #include <linux/sysfs.h> 18 19 #include <linux/iio/iio.h> 20 #include <linux/iio/sysfs.h> 21 #include <linux/iio/events.h> 22 23 /* 24 * Simplified handling 25 * 26 * If no events enabled - single polled channel read 27 * If event enabled direct reads disable unless channel 28 * is in the read mask. 29 * 30 * The noise-delayed bit as per datasheet suggestion is always enabled. 31 */ 32 33 /* 34 * AD7291 registers definition 35 */ 36 #define AD7291_COMMAND 0x00 37 #define AD7291_VOLTAGE 0x01 38 #define AD7291_T_SENSE 0x02 39 #define AD7291_T_AVERAGE 0x03 40 #define AD7291_DATA_HIGH(x) ((x) * 3 + 0x4) 41 #define AD7291_DATA_LOW(x) ((x) * 3 + 0x5) 42 #define AD7291_HYST(x) ((x) * 3 + 0x6) 43 #define AD7291_VOLTAGE_ALERT_STATUS 0x1F 44 #define AD7291_T_ALERT_STATUS 0x20 45 46 #define AD7291_BITS 12 47 #define AD7291_VOLTAGE_LIMIT_COUNT 8 48 49 50 /* 51 * AD7291 command 52 */ 53 #define AD7291_AUTOCYCLE BIT(0) 54 #define AD7291_RESET BIT(1) 55 #define AD7291_ALERT_CLEAR BIT(2) 56 #define AD7291_ALERT_POLARITY BIT(3) 57 #define AD7291_EXT_REF BIT(4) 58 #define AD7291_NOISE_DELAY BIT(5) 59 #define AD7291_T_SENSE_MASK BIT(7) 60 #define AD7291_VOLTAGE_MASK GENMASK(15, 8) 61 #define AD7291_VOLTAGE_OFFSET 8 62 63 /* 64 * AD7291 value masks 65 */ 66 #define AD7291_VALUE_MASK GENMASK(11, 0) 67 68 /* 69 * AD7291 alert register bits 70 */ 71 #define AD7291_T_LOW BIT(0) 72 #define AD7291_T_HIGH BIT(1) 73 #define AD7291_T_AVG_LOW BIT(2) 74 #define AD7291_T_AVG_HIGH BIT(3) 75 #define AD7291_V_LOW(x) BIT((x) * 2) 76 #define AD7291_V_HIGH(x) BIT((x) * 2 + 1) 77 78 79 struct ad7291_chip_info { 80 struct i2c_client *client; 81 struct regulator *reg; 82 u16 command; 83 u16 c_mask; /* Active voltage channels for events */ 84 struct mutex state_lock; 85 }; 86 87 static int ad7291_i2c_read(struct ad7291_chip_info *chip, u8 reg, u16 *data) 88 { 89 struct i2c_client *client = chip->client; 90 int ret = 0; 91 92 ret = i2c_smbus_read_word_swapped(client, reg); 93 if (ret < 0) { 94 dev_err(&client->dev, "I2C read error\n"); 95 return ret; 96 } 97 98 *data = ret; 99 100 return 0; 101 } 102 103 static int ad7291_i2c_write(struct ad7291_chip_info *chip, u8 reg, u16 data) 104 { 105 return i2c_smbus_write_word_swapped(chip->client, reg, data); 106 } 107 108 static irqreturn_t ad7291_event_handler(int irq, void *private) 109 { 110 struct iio_dev *indio_dev = private; 111 struct ad7291_chip_info *chip = iio_priv(private); 112 u16 t_status, v_status; 113 u16 command; 114 int i; 115 s64 timestamp = iio_get_time_ns(indio_dev); 116 117 if (ad7291_i2c_read(chip, AD7291_T_ALERT_STATUS, &t_status)) 118 return IRQ_HANDLED; 119 120 if (ad7291_i2c_read(chip, AD7291_VOLTAGE_ALERT_STATUS, &v_status)) 121 return IRQ_HANDLED; 122 123 if (!(t_status || v_status)) 124 return IRQ_HANDLED; 125 126 command = chip->command | AD7291_ALERT_CLEAR; 127 ad7291_i2c_write(chip, AD7291_COMMAND, command); 128 129 command = chip->command & ~AD7291_ALERT_CLEAR; 130 ad7291_i2c_write(chip, AD7291_COMMAND, command); 131 132 /* For now treat t_sense and t_sense_average the same */ 133 if ((t_status & AD7291_T_LOW) || (t_status & AD7291_T_AVG_LOW)) 134 iio_push_event(indio_dev, 135 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 136 0, 137 IIO_EV_TYPE_THRESH, 138 IIO_EV_DIR_FALLING), 139 timestamp); 140 if ((t_status & AD7291_T_HIGH) || (t_status & AD7291_T_AVG_HIGH)) 141 iio_push_event(indio_dev, 142 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 143 0, 144 IIO_EV_TYPE_THRESH, 145 IIO_EV_DIR_RISING), 146 timestamp); 147 148 for (i = 0; i < AD7291_VOLTAGE_LIMIT_COUNT; i++) { 149 if (v_status & AD7291_V_LOW(i)) 150 iio_push_event(indio_dev, 151 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 152 i, 153 IIO_EV_TYPE_THRESH, 154 IIO_EV_DIR_FALLING), 155 timestamp); 156 if (v_status & AD7291_V_HIGH(i)) 157 iio_push_event(indio_dev, 158 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 159 i, 160 IIO_EV_TYPE_THRESH, 161 IIO_EV_DIR_RISING), 162 timestamp); 163 } 164 165 return IRQ_HANDLED; 166 } 167 168 static unsigned int ad7291_threshold_reg(const struct iio_chan_spec *chan, 169 enum iio_event_direction dir, 170 enum iio_event_info info) 171 { 172 unsigned int offset; 173 174 switch (chan->type) { 175 case IIO_VOLTAGE: 176 offset = chan->channel; 177 break; 178 case IIO_TEMP: 179 offset = AD7291_VOLTAGE_OFFSET; 180 break; 181 default: 182 return 0; 183 } 184 185 switch (info) { 186 case IIO_EV_INFO_VALUE: 187 if (dir == IIO_EV_DIR_FALLING) 188 return AD7291_DATA_HIGH(offset); 189 else 190 return AD7291_DATA_LOW(offset); 191 case IIO_EV_INFO_HYSTERESIS: 192 return AD7291_HYST(offset); 193 default: 194 break; 195 } 196 return 0; 197 } 198 199 static int ad7291_read_event_value(struct iio_dev *indio_dev, 200 const struct iio_chan_spec *chan, 201 enum iio_event_type type, 202 enum iio_event_direction dir, 203 enum iio_event_info info, 204 int *val, int *val2) 205 { 206 struct ad7291_chip_info *chip = iio_priv(indio_dev); 207 int ret; 208 u16 uval; 209 210 ret = ad7291_i2c_read(chip, ad7291_threshold_reg(chan, dir, info), 211 &uval); 212 if (ret < 0) 213 return ret; 214 215 if (info == IIO_EV_INFO_HYSTERESIS || chan->type == IIO_VOLTAGE) 216 *val = uval & AD7291_VALUE_MASK; 217 218 else 219 *val = sign_extend32(uval, 11); 220 221 return IIO_VAL_INT; 222 } 223 224 static int ad7291_write_event_value(struct iio_dev *indio_dev, 225 const struct iio_chan_spec *chan, 226 enum iio_event_type type, 227 enum iio_event_direction dir, 228 enum iio_event_info info, 229 int val, int val2) 230 { 231 struct ad7291_chip_info *chip = iio_priv(indio_dev); 232 233 if (info == IIO_EV_INFO_HYSTERESIS || chan->type == IIO_VOLTAGE) { 234 if (val > AD7291_VALUE_MASK || val < 0) 235 return -EINVAL; 236 } else { 237 if (val > 2047 || val < -2048) 238 return -EINVAL; 239 } 240 241 return ad7291_i2c_write(chip, ad7291_threshold_reg(chan, dir, info), 242 val); 243 } 244 245 static int ad7291_read_event_config(struct iio_dev *indio_dev, 246 const struct iio_chan_spec *chan, 247 enum iio_event_type type, 248 enum iio_event_direction dir) 249 { 250 struct ad7291_chip_info *chip = iio_priv(indio_dev); 251 /* 252 * To be enabled the channel must simply be on. If any are enabled 253 * we are in continuous sampling mode 254 */ 255 256 switch (chan->type) { 257 case IIO_VOLTAGE: 258 return !!(chip->c_mask & BIT(15 - chan->channel)); 259 case IIO_TEMP: 260 /* always on */ 261 return 1; 262 default: 263 return -EINVAL; 264 } 265 266 } 267 268 static int ad7291_write_event_config(struct iio_dev *indio_dev, 269 const struct iio_chan_spec *chan, 270 enum iio_event_type type, 271 enum iio_event_direction dir, 272 int state) 273 { 274 int ret = 0; 275 struct ad7291_chip_info *chip = iio_priv(indio_dev); 276 unsigned int mask; 277 u16 regval; 278 279 mutex_lock(&chip->state_lock); 280 regval = chip->command; 281 /* 282 * To be enabled the channel must simply be on. If any are enabled 283 * use continuous sampling mode. 284 * Possible to disable temp as well but that makes single read tricky. 285 */ 286 287 mask = BIT(15 - chan->channel); 288 289 switch (chan->type) { 290 case IIO_VOLTAGE: 291 if ((!state) && (chip->c_mask & mask)) 292 chip->c_mask &= ~mask; 293 else if (state && (!(chip->c_mask & mask))) 294 chip->c_mask |= mask; 295 else 296 break; 297 298 regval &= ~AD7291_AUTOCYCLE; 299 regval |= chip->c_mask; 300 if (chip->c_mask) /* Enable autocycle? */ 301 regval |= AD7291_AUTOCYCLE; 302 303 ret = ad7291_i2c_write(chip, AD7291_COMMAND, regval); 304 if (ret < 0) 305 goto error_ret; 306 307 chip->command = regval; 308 break; 309 default: 310 ret = -EINVAL; 311 } 312 313 error_ret: 314 mutex_unlock(&chip->state_lock); 315 return ret; 316 } 317 318 static int ad7291_read_raw(struct iio_dev *indio_dev, 319 struct iio_chan_spec const *chan, 320 int *val, 321 int *val2, 322 long mask) 323 { 324 int ret; 325 struct ad7291_chip_info *chip = iio_priv(indio_dev); 326 u16 regval; 327 328 switch (mask) { 329 case IIO_CHAN_INFO_RAW: 330 switch (chan->type) { 331 case IIO_VOLTAGE: 332 mutex_lock(&chip->state_lock); 333 /* If in autocycle mode drop through */ 334 if (chip->command & AD7291_AUTOCYCLE) { 335 mutex_unlock(&chip->state_lock); 336 return -EBUSY; 337 } 338 /* Enable this channel alone */ 339 regval = chip->command & (~AD7291_VOLTAGE_MASK); 340 regval |= BIT(15 - chan->channel); 341 ret = ad7291_i2c_write(chip, AD7291_COMMAND, regval); 342 if (ret < 0) { 343 mutex_unlock(&chip->state_lock); 344 return ret; 345 } 346 /* Read voltage */ 347 ret = i2c_smbus_read_word_swapped(chip->client, 348 AD7291_VOLTAGE); 349 if (ret < 0) { 350 mutex_unlock(&chip->state_lock); 351 return ret; 352 } 353 *val = ret & AD7291_VALUE_MASK; 354 mutex_unlock(&chip->state_lock); 355 return IIO_VAL_INT; 356 case IIO_TEMP: 357 /* Assumes tsense bit of command register always set */ 358 ret = i2c_smbus_read_word_swapped(chip->client, 359 AD7291_T_SENSE); 360 if (ret < 0) 361 return ret; 362 *val = sign_extend32(ret, 11); 363 return IIO_VAL_INT; 364 default: 365 return -EINVAL; 366 } 367 case IIO_CHAN_INFO_AVERAGE_RAW: 368 ret = i2c_smbus_read_word_swapped(chip->client, 369 AD7291_T_AVERAGE); 370 if (ret < 0) 371 return ret; 372 *val = sign_extend32(ret, 11); 373 return IIO_VAL_INT; 374 case IIO_CHAN_INFO_SCALE: 375 switch (chan->type) { 376 case IIO_VOLTAGE: 377 if (chip->reg) { 378 int vref; 379 380 vref = regulator_get_voltage(chip->reg); 381 if (vref < 0) 382 return vref; 383 *val = vref / 1000; 384 } else { 385 *val = 2500; 386 } 387 *val2 = AD7291_BITS; 388 return IIO_VAL_FRACTIONAL_LOG2; 389 case IIO_TEMP: 390 /* 391 * One LSB of the ADC corresponds to 0.25 deg C. 392 * The temperature reading is in 12-bit twos 393 * complement format 394 */ 395 *val = 250; 396 return IIO_VAL_INT; 397 default: 398 return -EINVAL; 399 } 400 default: 401 return -EINVAL; 402 } 403 } 404 405 static const struct iio_event_spec ad7291_events[] = { 406 { 407 .type = IIO_EV_TYPE_THRESH, 408 .dir = IIO_EV_DIR_RISING, 409 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 410 BIT(IIO_EV_INFO_ENABLE), 411 }, { 412 .type = IIO_EV_TYPE_THRESH, 413 .dir = IIO_EV_DIR_FALLING, 414 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 415 BIT(IIO_EV_INFO_ENABLE), 416 }, { 417 .type = IIO_EV_TYPE_THRESH, 418 .dir = IIO_EV_DIR_EITHER, 419 .mask_separate = BIT(IIO_EV_INFO_HYSTERESIS), 420 }, 421 }; 422 423 #define AD7291_VOLTAGE_CHAN(_chan) \ 424 { \ 425 .type = IIO_VOLTAGE, \ 426 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 427 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 428 .indexed = 1, \ 429 .channel = _chan, \ 430 .event_spec = ad7291_events, \ 431 .num_event_specs = ARRAY_SIZE(ad7291_events), \ 432 } 433 434 static const struct iio_chan_spec ad7291_channels[] = { 435 AD7291_VOLTAGE_CHAN(0), 436 AD7291_VOLTAGE_CHAN(1), 437 AD7291_VOLTAGE_CHAN(2), 438 AD7291_VOLTAGE_CHAN(3), 439 AD7291_VOLTAGE_CHAN(4), 440 AD7291_VOLTAGE_CHAN(5), 441 AD7291_VOLTAGE_CHAN(6), 442 AD7291_VOLTAGE_CHAN(7), 443 { 444 .type = IIO_TEMP, 445 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 446 BIT(IIO_CHAN_INFO_AVERAGE_RAW) | 447 BIT(IIO_CHAN_INFO_SCALE), 448 .indexed = 1, 449 .channel = 0, 450 .event_spec = ad7291_events, 451 .num_event_specs = ARRAY_SIZE(ad7291_events), 452 } 453 }; 454 455 static const struct iio_info ad7291_info = { 456 .read_raw = &ad7291_read_raw, 457 .read_event_config = &ad7291_read_event_config, 458 .write_event_config = &ad7291_write_event_config, 459 .read_event_value = &ad7291_read_event_value, 460 .write_event_value = &ad7291_write_event_value, 461 }; 462 463 static void ad7291_reg_disable(void *reg) 464 { 465 regulator_disable(reg); 466 } 467 468 static int ad7291_probe(struct i2c_client *client) 469 { 470 const struct i2c_device_id *id = i2c_client_get_device_id(client); 471 struct ad7291_chip_info *chip; 472 struct iio_dev *indio_dev; 473 int ret; 474 475 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip)); 476 if (!indio_dev) 477 return -ENOMEM; 478 chip = iio_priv(indio_dev); 479 480 mutex_init(&chip->state_lock); 481 482 chip->client = client; 483 484 chip->command = AD7291_NOISE_DELAY | 485 AD7291_T_SENSE_MASK | /* Tsense always enabled */ 486 AD7291_ALERT_POLARITY; /* set irq polarity low level */ 487 488 chip->reg = devm_regulator_get_optional(&client->dev, "vref"); 489 if (IS_ERR(chip->reg)) { 490 if (PTR_ERR(chip->reg) != -ENODEV) 491 return PTR_ERR(chip->reg); 492 493 chip->reg = NULL; 494 } 495 496 if (chip->reg) { 497 ret = regulator_enable(chip->reg); 498 if (ret) 499 return ret; 500 501 ret = devm_add_action_or_reset(&client->dev, ad7291_reg_disable, 502 chip->reg); 503 if (ret) 504 return ret; 505 506 chip->command |= AD7291_EXT_REF; 507 } 508 509 indio_dev->name = id->name; 510 indio_dev->channels = ad7291_channels; 511 indio_dev->num_channels = ARRAY_SIZE(ad7291_channels); 512 513 indio_dev->info = &ad7291_info; 514 indio_dev->modes = INDIO_DIRECT_MODE; 515 516 ret = ad7291_i2c_write(chip, AD7291_COMMAND, AD7291_RESET); 517 if (ret) 518 return -EIO; 519 520 ret = ad7291_i2c_write(chip, AD7291_COMMAND, chip->command); 521 if (ret) 522 return -EIO; 523 524 if (client->irq > 0) { 525 ret = devm_request_threaded_irq(&client->dev, client->irq, 526 NULL, 527 &ad7291_event_handler, 528 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 529 id->name, 530 indio_dev); 531 if (ret) 532 return ret; 533 } 534 535 return devm_iio_device_register(&client->dev, indio_dev); 536 } 537 538 static const struct i2c_device_id ad7291_id[] = { 539 { "ad7291", 0 }, 540 {} 541 }; 542 543 MODULE_DEVICE_TABLE(i2c, ad7291_id); 544 545 static const struct of_device_id ad7291_of_match[] = { 546 { .compatible = "adi,ad7291" }, 547 {} 548 }; 549 MODULE_DEVICE_TABLE(of, ad7291_of_match); 550 551 static struct i2c_driver ad7291_driver = { 552 .driver = { 553 .name = KBUILD_MODNAME, 554 .of_match_table = ad7291_of_match, 555 }, 556 .probe_new = ad7291_probe, 557 .id_table = ad7291_id, 558 }; 559 module_i2c_driver(ad7291_driver); 560 561 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>"); 562 MODULE_DESCRIPTION("Analog Devices AD7291 ADC driver"); 563 MODULE_LICENSE("GPL v2"); 564