drivers/staging/iio/adc/ad7291.c

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