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