drivers/iio/chemical/atlas-ph-sensor.c

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