drivers/iio/chemical/atlas-sensor.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * atlas-sensor.c - Support for Atlas Scientific OEM SM sensors
   4  *
   5  * Copyright (C) 2015-2019 Konsulko Group
   6  * Author: Matt Ranostay <matt.ranostay@konsulko.com>
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/init.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/delay.h>
  13 #include <linux/mutex.h>
  14 #include <linux/err.h>
  15 #include <linux/irq.h>
  16 #include <linux/irq_work.h>
  17 #include <linux/i2c.h>
  18 #include <linux/mod_devicetable.h>
  19 #include <linux/regmap.h>
  20 #include <linux/iio/iio.h>
  21 #include <linux/iio/buffer.h>
  22 #include <linux/iio/trigger.h>
  23 #include <linux/iio/trigger_consumer.h>
  24 #include <linux/iio/triggered_buffer.h>
  25 #include <linux/pm_runtime.h>
  26
  27 #define ATLAS_REGMAP_NAME       "atlas_regmap"
  28 #define ATLAS_DRV_NAME          "atlas"
  29
  30 #define ATLAS_REG_DEV_TYPE              0x00
  31 #define ATLAS_REG_DEV_VERSION           0x01
  32
  33 #define ATLAS_REG_INT_CONTROL           0x04
  34 #define ATLAS_REG_INT_CONTROL_EN        BIT(3)
  35
  36 #define ATLAS_REG_PWR_CONTROL           0x06
  37
  38 #define ATLAS_REG_PH_CALIB_STATUS       0x0d
  39 #define ATLAS_REG_PH_CALIB_STATUS_MASK  0x07
  40 #define ATLAS_REG_PH_CALIB_STATUS_LOW   BIT(0)
  41 #define ATLAS_REG_PH_CALIB_STATUS_MID   BIT(1)
  42 #define ATLAS_REG_PH_CALIB_STATUS_HIGH  BIT(2)
  43
  44 #define ATLAS_REG_EC_CALIB_STATUS               0x0f
  45 #define ATLAS_REG_EC_CALIB_STATUS_MASK          0x0f
  46 #define ATLAS_REG_EC_CALIB_STATUS_DRY           BIT(0)
  47 #define ATLAS_REG_EC_CALIB_STATUS_SINGLE        BIT(1)
  48 #define ATLAS_REG_EC_CALIB_STATUS_LOW           BIT(2)
  49 #define ATLAS_REG_EC_CALIB_STATUS_HIGH          BIT(3)
  50
  51 #define ATLAS_REG_DO_CALIB_STATUS               0x09
  52 #define ATLAS_REG_DO_CALIB_STATUS_MASK          0x03
  53 #define ATLAS_REG_DO_CALIB_STATUS_PRESSURE      BIT(0)
  54 #define ATLAS_REG_DO_CALIB_STATUS_DO            BIT(1)
  55
  56 #define ATLAS_REG_RTD_DATA              0x0e
  57
  58 #define ATLAS_REG_PH_TEMP_DATA          0x0e
  59 #define ATLAS_REG_PH_DATA               0x16
  60
  61 #define ATLAS_REG_EC_PROBE              0x08
  62 #define ATLAS_REG_EC_TEMP_DATA          0x10
  63 #define ATLAS_REG_EC_DATA               0x18
  64 #define ATLAS_REG_TDS_DATA              0x1c
  65 #define ATLAS_REG_PSS_DATA              0x20
  66
  67 #define ATLAS_REG_ORP_CALIB_STATUS      0x0d
  68 #define ATLAS_REG_ORP_DATA              0x0e
  69
  70 #define ATLAS_REG_DO_TEMP_DATA          0x12
  71 #define ATLAS_REG_DO_DATA               0x22
  72
  73 #define ATLAS_PH_INT_TIME_IN_MS         450
  74 #define ATLAS_EC_INT_TIME_IN_MS         650
  75 #define ATLAS_ORP_INT_TIME_IN_MS        450
  76 #define ATLAS_DO_INT_TIME_IN_MS         450
  77 #define ATLAS_RTD_INT_TIME_IN_MS        450
  78
  79 enum {
  80         ATLAS_PH_SM,
  81         ATLAS_EC_SM,
  82         ATLAS_ORP_SM,
  83         ATLAS_DO_SM,
  84         ATLAS_RTD_SM,
  85 };
  86
  87 struct atlas_data {
  88         struct i2c_client *client;
  89         struct iio_trigger *trig;
  90         struct atlas_device *chip;
  91         struct regmap *regmap;
  92         struct irq_work work;
  93         unsigned int interrupt_enabled;
  94         /* 96-bit data + 32-bit pad + 64-bit timestamp */
  95         __be32 buffer[6] __aligned(8);
  96 };
  97
  98 static const struct regmap_config atlas_regmap_config = {
  99         .name = ATLAS_REGMAP_NAME,
 100         .reg_bits = 8,
 101         .val_bits = 8,
 102 };
 103
 104 static int atlas_buffer_num_channels(const struct iio_chan_spec *spec)
 105 {
 106         int idx = 0;
 107
 108         for (; spec->type != IIO_TIMESTAMP; spec++)
 109                 idx++;
 110
 111         return idx;
 112 };
 113
 114 static const struct iio_chan_spec atlas_ph_channels[] = {
 115         {
 116                 .type = IIO_PH,
 117                 .address = ATLAS_REG_PH_DATA,
 118                 .info_mask_separate =
 119                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 120                 .scan_index = 0,
 121                 .scan_type = {
 122                         .sign = 'u',
 123                         .realbits = 32,
 124                         .storagebits = 32,
 125                         .endianness = IIO_BE,
 126                 },
 127         },
 128         IIO_CHAN_SOFT_TIMESTAMP(1),
 129         {
 130                 .type = IIO_TEMP,
 131                 .address = ATLAS_REG_PH_TEMP_DATA,
 132                 .info_mask_separate =
 133                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 134                 .output = 1,
 135                 .scan_index = -1
 136         },
 137 };
 138
 139 #define ATLAS_CONCENTRATION_CHANNEL(_idx, _addr) \
 140         {\
 141                 .type = IIO_CONCENTRATION, \
 142                 .indexed = 1, \
 143                 .channel = _idx, \
 144                 .address = _addr, \
 145                 .info_mask_separate = \
 146                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), \
 147                 .scan_index = _idx + 1, \
 148                 .scan_type = { \
 149                         .sign = 'u', \
 150                         .realbits = 32, \
 151                         .storagebits = 32, \
 152                         .endianness = IIO_BE, \
 153                 }, \
 154         }
 155
 156 static const struct iio_chan_spec atlas_ec_channels[] = {
 157         {
 158                 .type = IIO_ELECTRICALCONDUCTIVITY,
 159                 .address = ATLAS_REG_EC_DATA,
 160                 .info_mask_separate =
 161                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 162                 .scan_index = 0,
 163                 .scan_type = {
 164                         .sign = 'u',
 165                         .realbits = 32,
 166                         .storagebits = 32,
 167                         .endianness = IIO_BE,
 168                 },
 169         },
 170         ATLAS_CONCENTRATION_CHANNEL(0, ATLAS_REG_TDS_DATA),
 171         ATLAS_CONCENTRATION_CHANNEL(1, ATLAS_REG_PSS_DATA),
 172         IIO_CHAN_SOFT_TIMESTAMP(3),
 173         {
 174                 .type = IIO_TEMP,
 175                 .address = ATLAS_REG_EC_TEMP_DATA,
 176                 .info_mask_separate =
 177                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 178                 .output = 1,
 179                 .scan_index = -1
 180         },
 181 };
 182
 183 static const struct iio_chan_spec atlas_orp_channels[] = {
 184         {
 185                 .type = IIO_VOLTAGE,
 186                 .address = ATLAS_REG_ORP_DATA,
 187                 .info_mask_separate =
 188                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 189                 .scan_index = 0,
 190                 .scan_type = {
 191                         .sign = 's',
 192                         .realbits = 32,
 193                         .storagebits = 32,
 194                         .endianness = IIO_BE,
 195                 },
 196         },
 197         IIO_CHAN_SOFT_TIMESTAMP(1),
 198 };
 199
 200 static const struct iio_chan_spec atlas_do_channels[] = {
 201         {
 202                 .type = IIO_CONCENTRATION,
 203                 .address = ATLAS_REG_DO_DATA,
 204                 .info_mask_separate =
 205                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 206                 .scan_index = 0,
 207                 .scan_type = {
 208                         .sign = 'u',
 209                         .realbits = 32,
 210                         .storagebits = 32,
 211                         .endianness = IIO_BE,
 212                 },
 213         },
 214         IIO_CHAN_SOFT_TIMESTAMP(1),
 215         {
 216                 .type = IIO_TEMP,
 217                 .address = ATLAS_REG_DO_TEMP_DATA,
 218                 .info_mask_separate =
 219                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
 220                 .output = 1,
 221                 .scan_index = -1
 222         },
 223 };
 224
 225 static const struct iio_chan_spec atlas_rtd_channels[] = {
 226         {
 227                 .type = IIO_TEMP,
 228                 .address = ATLAS_REG_RTD_DATA,
 229                 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
 230                 .scan_index = 0,
 231                 .scan_type = {
 232                         .sign = 's',
 233                         .realbits = 32,
 234                         .storagebits = 32,
 235                         .endianness = IIO_BE,
 236                 },
 237         },
 238         IIO_CHAN_SOFT_TIMESTAMP(1),
 239 };
 240
 241 static int atlas_check_ph_calibration(struct atlas_data *data)
 242 {
 243         struct device *dev = &data->client->dev;
 244         int ret;
 245         unsigned int val;
 246
 247         ret = regmap_read(data->regmap, ATLAS_REG_PH_CALIB_STATUS, &val);
 248         if (ret)
 249                 return ret;
 250
 251         if (!(val & ATLAS_REG_PH_CALIB_STATUS_MASK)) {
 252                 dev_warn(dev, "device has not been calibrated\n");
 253                 return 0;
 254         }
 255
 256         if (!(val & ATLAS_REG_PH_CALIB_STATUS_LOW))
 257                 dev_warn(dev, "device missing low point calibration\n");
 258
 259         if (!(val & ATLAS_REG_PH_CALIB_STATUS_MID))
 260                 dev_warn(dev, "device missing mid point calibration\n");
 261
 262         if (!(val & ATLAS_REG_PH_CALIB_STATUS_HIGH))
 263                 dev_warn(dev, "device missing high point calibration\n");
 264
 265         return 0;
 266 }
 267
 268 static int atlas_check_ec_calibration(struct atlas_data *data)
 269 {
 270         struct device *dev = &data->client->dev;
 271         int ret;
 272         unsigned int val;
 273         __be16  rval;
 274
 275         ret = regmap_bulk_read(data->regmap, ATLAS_REG_EC_PROBE, &rval, 2);
 276         if (ret)
 277                 return ret;
 278
 279         val = be16_to_cpu(rval);
 280         dev_info(dev, "probe set to K = %d.%.2d", val / 100, val % 100);
 281
 282         ret = regmap_read(data->regmap, ATLAS_REG_EC_CALIB_STATUS, &val);
 283         if (ret)
 284                 return ret;
 285
 286         if (!(val & ATLAS_REG_EC_CALIB_STATUS_MASK)) {
 287                 dev_warn(dev, "device has not been calibrated\n");
 288                 return 0;
 289         }
 290
 291         if (!(val & ATLAS_REG_EC_CALIB_STATUS_DRY))
 292                 dev_warn(dev, "device missing dry point calibration\n");
 293
 294         if (val & ATLAS_REG_EC_CALIB_STATUS_SINGLE) {
 295                 dev_warn(dev, "device using single point calibration\n");
 296         } else {
 297                 if (!(val & ATLAS_REG_EC_CALIB_STATUS_LOW))
 298                         dev_warn(dev, "device missing low point calibration\n");
 299
 300                 if (!(val & ATLAS_REG_EC_CALIB_STATUS_HIGH))
 301                         dev_warn(dev, "device missing high point calibration\n");
 302         }
 303
 304         return 0;
 305 }
 306
 307 static int atlas_check_orp_calibration(struct atlas_data *data)
 308 {
 309         struct device *dev = &data->client->dev;
 310         int ret;
 311         unsigned int val;
 312
 313         ret = regmap_read(data->regmap, ATLAS_REG_ORP_CALIB_STATUS, &val);
 314         if (ret)
 315                 return ret;
 316
 317         if (!val)
 318                 dev_warn(dev, "device has not been calibrated\n");
 319
 320         return 0;
 321 }
 322
 323 static int atlas_check_do_calibration(struct atlas_data *data)
 324 {
 325         struct device *dev = &data->client->dev;
 326         int ret;
 327         unsigned int val;
 328
 329         ret = regmap_read(data->regmap, ATLAS_REG_DO_CALIB_STATUS, &val);
 330         if (ret)
 331                 return ret;
 332
 333         if (!(val & ATLAS_REG_DO_CALIB_STATUS_MASK)) {
 334                 dev_warn(dev, "device has not been calibrated\n");
 335                 return 0;
 336         }
 337
 338         if (!(val & ATLAS_REG_DO_CALIB_STATUS_PRESSURE))
 339                 dev_warn(dev, "device missing atmospheric pressure calibration\n");
 340
 341         if (!(val & ATLAS_REG_DO_CALIB_STATUS_DO))
 342                 dev_warn(dev, "device missing dissolved oxygen calibration\n");
 343
 344         return 0;
 345 }
 346
 347 struct atlas_device {
 348         const struct iio_chan_spec *channels;
 349         int num_channels;
 350         int data_reg;
 351
 352         int (*calibration)(struct atlas_data *data);
 353         int delay;
 354 };
 355
 356 static struct atlas_device atlas_devices[] = {
 357         [ATLAS_PH_SM] = {
 358                                 .channels = atlas_ph_channels,
 359                                 .num_channels = 3,
 360                                 .data_reg = ATLAS_REG_PH_DATA,
 361                                 .calibration = &atlas_check_ph_calibration,
 362                                 .delay = ATLAS_PH_INT_TIME_IN_MS,
 363         },
 364         [ATLAS_EC_SM] = {
 365                                 .channels = atlas_ec_channels,
 366                                 .num_channels = 5,
 367                                 .data_reg = ATLAS_REG_EC_DATA,
 368                                 .calibration = &atlas_check_ec_calibration,
 369                                 .delay = ATLAS_EC_INT_TIME_IN_MS,
 370         },
 371         [ATLAS_ORP_SM] = {
 372                                 .channels = atlas_orp_channels,
 373                                 .num_channels = 2,
 374                                 .data_reg = ATLAS_REG_ORP_DATA,
 375                                 .calibration = &atlas_check_orp_calibration,
 376                                 .delay = ATLAS_ORP_INT_TIME_IN_MS,
 377         },
 378         [ATLAS_DO_SM] = {
 379                                 .channels = atlas_do_channels,
 380                                 .num_channels = 3,
 381                                 .data_reg = ATLAS_REG_DO_DATA,
 382                                 .calibration = &atlas_check_do_calibration,
 383                                 .delay = ATLAS_DO_INT_TIME_IN_MS,
 384         },
 385         [ATLAS_RTD_SM] = {
 386                                 .channels = atlas_rtd_channels,
 387                                 .num_channels = 2,
 388                                 .data_reg = ATLAS_REG_RTD_DATA,
 389                                 .delay = ATLAS_RTD_INT_TIME_IN_MS,
 390         },
 391 };
 392
 393 static int atlas_set_powermode(struct atlas_data *data, int on)
 394 {
 395         return regmap_write(data->regmap, ATLAS_REG_PWR_CONTROL, on);
 396 }
 397
 398 static int atlas_set_interrupt(struct atlas_data *data, bool state)
 399 {
 400         if (!data->interrupt_enabled)
 401                 return 0;
 402
 403         return regmap_update_bits(data->regmap, ATLAS_REG_INT_CONTROL,
 404                                   ATLAS_REG_INT_CONTROL_EN,
 405                                   state ? ATLAS_REG_INT_CONTROL_EN : 0);
 406 }
 407
 408 static int atlas_buffer_postenable(struct iio_dev *indio_dev)
 409 {
 410         struct atlas_data *data = iio_priv(indio_dev);
 411         int ret;
 412
 413         ret = pm_runtime_resume_and_get(&data->client->dev);
 414         if (ret)
 415                 return ret;
 416
 417         return atlas_set_interrupt(data, true);
 418 }
 419
 420 static int atlas_buffer_predisable(struct iio_dev *indio_dev)
 421 {
 422         struct atlas_data *data = iio_priv(indio_dev);
 423         int ret;
 424
 425         ret = atlas_set_interrupt(data, false);
 426         if (ret)
 427                 return ret;
 428
 429         pm_runtime_mark_last_busy(&data->client->dev);
 430         ret = pm_runtime_put_autosuspend(&data->client->dev);
 431         if (ret)
 432                 return ret;
 433
 434         return 0;
 435 }
 436
 437 static const struct iio_trigger_ops atlas_interrupt_trigger_ops = {
 438 };
 439
 440 static const struct iio_buffer_setup_ops atlas_buffer_setup_ops = {
 441         .postenable = atlas_buffer_postenable,
 442         .predisable = atlas_buffer_predisable,
 443 };
 444
 445 static void atlas_work_handler(struct irq_work *work)
 446 {
 447         struct atlas_data *data = container_of(work, struct atlas_data, work);
 448
 449         iio_trigger_poll(data->trig);
 450 }
 451
 452 static irqreturn_t atlas_trigger_handler(int irq, void *private)
 453 {
 454         struct iio_poll_func *pf = private;
 455         struct iio_dev *indio_dev = pf->indio_dev;
 456         struct atlas_data *data = iio_priv(indio_dev);
 457         int channels = atlas_buffer_num_channels(data->chip->channels);
 458         int ret;
 459
 460         ret = regmap_bulk_read(data->regmap, data->chip->data_reg,
 461                               &data->buffer, sizeof(__be32) * channels);
 462
 463         if (!ret)
 464                 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
 465                                 iio_get_time_ns(indio_dev));
 466
 467         iio_trigger_notify_done(indio_dev->trig);
 468
 469         return IRQ_HANDLED;
 470 }
 471
 472 static irqreturn_t atlas_interrupt_handler(int irq, void *private)
 473 {
 474         struct iio_dev *indio_dev = private;
 475         struct atlas_data *data = iio_priv(indio_dev);
 476
 477         irq_work_queue(&data->work);
 478
 479         return IRQ_HANDLED;
 480 }
 481
 482 static int atlas_read_measurement(struct atlas_data *data, int reg, __be32 *val)
 483 {
 484         struct device *dev = &data->client->dev;
 485         int suspended = pm_runtime_suspended(dev);
 486         int ret;
 487
 488         ret = pm_runtime_resume_and_get(dev);
 489         if (ret)
 490                 return ret;
 491
 492         if (suspended)
 493                 msleep(data->chip->delay);
 494
 495         ret = regmap_bulk_read(data->regmap, reg, val, sizeof(*val));
 496
 497         pm_runtime_mark_last_busy(dev);
 498         pm_runtime_put_autosuspend(dev);
 499
 500         return ret;
 501 }
 502
 503 static int atlas_read_raw(struct iio_dev *indio_dev,
 504                           struct iio_chan_spec const *chan,
 505                           int *val, int *val2, long mask)
 506 {
 507         struct atlas_data *data = iio_priv(indio_dev);
 508
 509         switch (mask) {
 510         case IIO_CHAN_INFO_PROCESSED:
 511         case IIO_CHAN_INFO_RAW: {
 512                 int ret;
 513                 __be32 reg;
 514
 515                 switch (chan->type) {
 516                 case IIO_TEMP:
 517                         ret = regmap_bulk_read(data->regmap, chan->address,
 518                                                &reg, sizeof(reg));
 519                         break;
 520                 case IIO_PH:
 521                 case IIO_CONCENTRATION:
 522                 case IIO_ELECTRICALCONDUCTIVITY:
 523                 case IIO_VOLTAGE:
 524                         ret = iio_device_claim_direct_mode(indio_dev);
 525                         if (ret)
 526                                 return ret;
 527
 528                         ret = atlas_read_measurement(data, chan->address, &reg);
 529
 530                         iio_device_release_direct_mode(indio_dev);
 531                         break;
 532                 default:
 533                         ret = -EINVAL;
 534                 }
 535
 536                 if (!ret) {
 537                         *val = be32_to_cpu(reg);
 538                         ret = IIO_VAL_INT;
 539                 }
 540                 return ret;
 541         }
 542         case IIO_CHAN_INFO_SCALE:
 543                 switch (chan->type) {
 544                 case IIO_TEMP:
 545                         *val = 10;
 546                         return IIO_VAL_INT;
 547                 case IIO_PH:
 548                         *val = 1; /* 0.001 */
 549                         *val2 = 1000;
 550                         break;
 551                 case IIO_ELECTRICALCONDUCTIVITY:
 552                         *val = 1; /* 0.00001 */
 553                         *val2 = 100000;
 554                         break;
 555                 case IIO_CONCENTRATION:
 556                         *val = 0; /* 0.000000001 */
 557                         *val2 = 1000;
 558                         return IIO_VAL_INT_PLUS_NANO;
 559                 case IIO_VOLTAGE:
 560                         *val = 1; /* 0.1 */
 561                         *val2 = 10;
 562                         break;
 563                 default:
 564                         return -EINVAL;
 565                 }
 566                 return IIO_VAL_FRACTIONAL;
 567         }
 568
 569         return -EINVAL;
 570 }
 571
 572 static int atlas_write_raw(struct iio_dev *indio_dev,
 573                            struct iio_chan_spec const *chan,
 574                            int val, int val2, long mask)
 575 {
 576         struct atlas_data *data = iio_priv(indio_dev);
 577         __be32 reg = cpu_to_be32(val / 10);
 578
 579         if (val2 != 0 || val < 0 || val > 20000)
 580                 return -EINVAL;
 581
 582         if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_TEMP)
 583                 return -EINVAL;
 584
 585         return regmap_bulk_write(data->regmap, chan->address,
 586                                  &reg, sizeof(reg));
 587 }
 588
 589 static const struct iio_info atlas_info = {
 590         .read_raw = atlas_read_raw,
 591         .write_raw = atlas_write_raw,
 592 };
 593
 594 static const struct i2c_device_id atlas_id[] = {
 595         { "atlas-ph-sm", ATLAS_PH_SM},
 596         { "atlas-ec-sm", ATLAS_EC_SM},
 597         { "atlas-orp-sm", ATLAS_ORP_SM},
 598         { "atlas-do-sm", ATLAS_DO_SM},
 599         { "atlas-rtd-sm", ATLAS_RTD_SM},
 600         {}
 601 };
 602 MODULE_DEVICE_TABLE(i2c, atlas_id);
 603
 604 static const struct of_device_id atlas_dt_ids[] = {
 605         { .compatible = "atlas,ph-sm", .data = (void *)ATLAS_PH_SM, },
 606         { .compatible = "atlas,ec-sm", .data = (void *)ATLAS_EC_SM, },
 607         { .compatible = "atlas,orp-sm", .data = (void *)ATLAS_ORP_SM, },
 608         { .compatible = "atlas,do-sm", .data = (void *)ATLAS_DO_SM, },
 609         { .compatible = "atlas,rtd-sm", .data = (void *)ATLAS_RTD_SM, },
 610         { }
 611 };
 612 MODULE_DEVICE_TABLE(of, atlas_dt_ids);
 613
 614 static int atlas_probe(struct i2c_client *client,
 615                        const struct i2c_device_id *id)
 616 {
 617         struct atlas_data *data;
 618         struct atlas_device *chip;
 619         struct iio_trigger *trig;
 620         struct iio_dev *indio_dev;
 621         int ret;
 622
 623         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 624         if (!indio_dev)
 625                 return -ENOMEM;
 626
 627         if (!dev_fwnode(&client->dev))
 628                 chip = &atlas_devices[id->driver_data];
 629         else
 630                 chip = &atlas_devices[(unsigned long)device_get_match_data(&client->dev)];
 631
 632         indio_dev->info = &atlas_info;
 633         indio_dev->name = ATLAS_DRV_NAME;
 634         indio_dev->channels = chip->channels;
 635         indio_dev->num_channels = chip->num_channels;
 636         indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE;
 637
 638         trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
 639                                       indio_dev->name, iio_device_id(indio_dev));
 640
 641         if (!trig)
 642                 return -ENOMEM;
 643
 644         data = iio_priv(indio_dev);
 645         data->client = client;
 646         data->trig = trig;
 647         data->chip = chip;
 648         trig->ops = &atlas_interrupt_trigger_ops;
 649         iio_trigger_set_drvdata(trig, indio_dev);
 650
 651         i2c_set_clientdata(client, indio_dev);
 652
 653         data->regmap = devm_regmap_init_i2c(client, &atlas_regmap_config);
 654         if (IS_ERR(data->regmap)) {
 655                 dev_err(&client->dev, "regmap initialization failed\n");
 656                 return PTR_ERR(data->regmap);
 657         }
 658
 659         ret = pm_runtime_set_active(&client->dev);
 660         if (ret)
 661                 return ret;
 662
 663         ret = chip->calibration(data);
 664         if (ret)
 665                 return ret;
 666
 667         ret = iio_trigger_register(trig);
 668         if (ret) {
 669                 dev_err(&client->dev, "failed to register trigger\n");
 670                 return ret;
 671         }
 672
 673         ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
 674                 &atlas_trigger_handler, &atlas_buffer_setup_ops);
 675         if (ret) {
 676                 dev_err(&client->dev, "cannot setup iio trigger\n");
 677                 goto unregister_trigger;
 678         }
 679
 680         init_irq_work(&data->work, atlas_work_handler);
 681
 682         if (client->irq > 0) {
 683                 /* interrupt pin toggles on new conversion */
 684                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 685                                 NULL, atlas_interrupt_handler,
 686                                 IRQF_TRIGGER_RISING |
 687                                 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 688                                 "atlas_irq",
 689                                 indio_dev);
 690
 691                 if (ret)
 692                         dev_warn(&client->dev,
 693                                 "request irq (%d) failed\n", client->irq);
 694                 else
 695                         data->interrupt_enabled = 1;
 696         }
 697
 698         ret = atlas_set_powermode(data, 1);
 699         if (ret) {
 700                 dev_err(&client->dev, "cannot power device on");
 701                 goto unregister_buffer;
 702         }
 703
 704         pm_runtime_enable(&client->dev);
 705         pm_runtime_set_autosuspend_delay(&client->dev, 2500);
 706         pm_runtime_use_autosuspend(&client->dev);
 707
 708         ret = iio_device_register(indio_dev);
 709         if (ret) {
 710                 dev_err(&client->dev, "unable to register device\n");
 711                 goto unregister_pm;
 712         }
 713
 714         return 0;
 715
 716 unregister_pm:
 717         pm_runtime_disable(&client->dev);
 718         atlas_set_powermode(data, 0);
 719
 720 unregister_buffer:
 721         iio_triggered_buffer_cleanup(indio_dev);
 722
 723 unregister_trigger:
 724         iio_trigger_unregister(data->trig);
 725
 726         return ret;
 727 }
 728
 729 static int atlas_remove(struct i2c_client *client)
 730 {
 731         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 732         struct atlas_data *data = iio_priv(indio_dev);
 733
 734         iio_device_unregister(indio_dev);
 735         iio_triggered_buffer_cleanup(indio_dev);
 736         iio_trigger_unregister(data->trig);
 737
 738         pm_runtime_disable(&client->dev);
 739         pm_runtime_set_suspended(&client->dev);
 740
 741         return atlas_set_powermode(data, 0);
 742 }
 743
 744 #ifdef CONFIG_PM
 745 static int atlas_runtime_suspend(struct device *dev)
 746 {
 747         struct atlas_data *data =
 748                      iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
 749
 750         return atlas_set_powermode(data, 0);
 751 }
 752
 753 static int atlas_runtime_resume(struct device *dev)
 754 {
 755         struct atlas_data *data =
 756                      iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
 757
 758         return atlas_set_powermode(data, 1);
 759 }
 760 #endif
 761
 762 static const struct dev_pm_ops atlas_pm_ops = {
 763         SET_RUNTIME_PM_OPS(atlas_runtime_suspend,
 764                            atlas_runtime_resume, NULL)
 765 };
 766
 767 static struct i2c_driver atlas_driver = {
 768         .driver = {
 769                 .name   = ATLAS_DRV_NAME,
 770                 .of_match_table = atlas_dt_ids,
 771                 .pm     = &atlas_pm_ops,
 772         },
 773         .probe          = atlas_probe,
 774         .remove         = atlas_remove,
 775         .id_table       = atlas_id,
 776 };
 777 module_i2c_driver(atlas_driver);
 778
 779 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
 780 MODULE_DESCRIPTION("Atlas Scientific SM sensors");
 781 MODULE_LICENSE("GPL");