drivers/iio/adc/ad7291.c

   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 int ad7291_probe(struct i2c_client *client,
 464                         const struct i2c_device_id *id)
 465 {
 466         struct ad7291_chip_info *chip;
 467         struct iio_dev *indio_dev;
 468         int ret;
 469
 470         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip));
 471         if (!indio_dev)
 472                 return -ENOMEM;
 473         chip = iio_priv(indio_dev);
 474
 475         mutex_init(&chip->state_lock);
 476         /* this is only used for device removal purposes */
 477         i2c_set_clientdata(client, indio_dev);
 478
 479         chip->client = client;
 480
 481         chip->command = AD7291_NOISE_DELAY |
 482                         AD7291_T_SENSE_MASK | /* Tsense always enabled */
 483                         AD7291_ALERT_POLARITY; /* set irq polarity low level */
 484
 485         chip->reg = devm_regulator_get_optional(&client->dev, "vref");
 486         if (IS_ERR(chip->reg)) {
 487                 if (PTR_ERR(chip->reg) != -ENODEV)
 488                         return PTR_ERR(chip->reg);
 489
 490                 chip->reg = NULL;
 491         }
 492
 493         if (chip->reg) {
 494                 ret = regulator_enable(chip->reg);
 495                 if (ret)
 496                         return ret;
 497
 498                 chip->command |= AD7291_EXT_REF;
 499         }
 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->info = &ad7291_info;
 506         indio_dev->modes = INDIO_DIRECT_MODE;
 507
 508         ret = ad7291_i2c_write(chip, AD7291_COMMAND, AD7291_RESET);
 509         if (ret) {
 510                 ret = -EIO;
 511                 goto error_disable_reg;
 512         }
 513
 514         ret = ad7291_i2c_write(chip, AD7291_COMMAND, chip->command);
 515         if (ret) {
 516                 ret = -EIO;
 517                 goto error_disable_reg;
 518         }
 519
 520         if (client->irq > 0) {
 521                 ret = request_threaded_irq(client->irq,
 522                                            NULL,
 523                                            &ad7291_event_handler,
 524                                            IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 525                                            id->name,
 526                                            indio_dev);
 527                 if (ret)
 528                         goto error_disable_reg;
 529         }
 530
 531         ret = iio_device_register(indio_dev);
 532         if (ret)
 533                 goto error_unreg_irq;
 534
 535         return 0;
 536
 537 error_unreg_irq:
 538         if (client->irq)
 539                 free_irq(client->irq, indio_dev);
 540 error_disable_reg:
 541         if (chip->reg)
 542                 regulator_disable(chip->reg);
 543
 544         return ret;
 545 }
 546
 547 static int ad7291_remove(struct i2c_client *client)
 548 {
 549         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 550         struct ad7291_chip_info *chip = iio_priv(indio_dev);
 551
 552         iio_device_unregister(indio_dev);
 553
 554         if (client->irq)
 555                 free_irq(client->irq, indio_dev);
 556
 557         if (chip->reg)
 558                 regulator_disable(chip->reg);
 559
 560         return 0;
 561 }
 562
 563 static const struct i2c_device_id ad7291_id[] = {
 564         { "ad7291", 0 },
 565         {}
 566 };
 567
 568 MODULE_DEVICE_TABLE(i2c, ad7291_id);
 569
 570 static const struct of_device_id ad7291_of_match[] = {
 571         { .compatible = "adi,ad7291" },
 572         {}
 573 };
 574 MODULE_DEVICE_TABLE(of, ad7291_of_match);
 575
 576 static struct i2c_driver ad7291_driver = {
 577         .driver = {
 578                 .name = KBUILD_MODNAME,
 579                 .of_match_table = ad7291_of_match,
 580         },
 581         .probe = ad7291_probe,
 582         .remove = ad7291_remove,
 583         .id_table = ad7291_id,
 584 };
 585 module_i2c_driver(ad7291_driver);
 586
 587 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
 588 MODULE_DESCRIPTION("Analog Devices AD7291 ADC driver");
 589 MODULE_LICENSE("GPL v2");