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 = 1; /* 0.01 */
 457                         *val2 = 100;
 458                         break;
 459                 case IIO_PH:
 460                         *val = 1; /* 0.001 */
 461                         *val2 = 1000;
 462                         break;
 463                 case IIO_ELECTRICALCONDUCTIVITY:
 464                         *val = 1; /* 0.00001 */
 465                         *val2 = 100000;
 466                         break;
 467                 case IIO_CONCENTRATION:
 468                         *val = 0; /* 0.000000001 */
 469                         *val2 = 1000;
 470                         return IIO_VAL_INT_PLUS_NANO;
 471                 case IIO_VOLTAGE:
 472                         *val = 1; /* 0.1 */
 473                         *val2 = 10;
 474                         break;
 475                 default:
 476                         return -EINVAL;
 477                 }
 478                 return IIO_VAL_FRACTIONAL;
 479         }
 480
 481         return -EINVAL;
 482 }
 483
 484 static int atlas_write_raw(struct iio_dev *indio_dev,
 485                            struct iio_chan_spec const *chan,
 486                            int val, int val2, long mask)
 487 {
 488         struct atlas_data *data = iio_priv(indio_dev);
 489         __be32 reg = cpu_to_be32(val);
 490
 491         if (val2 != 0 || val < 0 || val > 20000)
 492                 return -EINVAL;
 493
 494         if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_TEMP)
 495                 return -EINVAL;
 496
 497         return regmap_bulk_write(data->regmap, chan->address,
 498                                  &reg, sizeof(reg));
 499 }
 500
 501 static const struct iio_info atlas_info = {
 502         .driver_module = THIS_MODULE,
 503         .read_raw = atlas_read_raw,
 504         .write_raw = atlas_write_raw,
 505 };
 506
 507 static const struct i2c_device_id atlas_id[] = {
 508         { "atlas-ph-sm", ATLAS_PH_SM},
 509         { "atlas-ec-sm", ATLAS_EC_SM},
 510         { "atlas-orp-sm", ATLAS_ORP_SM},
 511         {}
 512 };
 513 MODULE_DEVICE_TABLE(i2c, atlas_id);
 514
 515 static const struct of_device_id atlas_dt_ids[] = {
 516         { .compatible = "atlas,ph-sm", .data = (void *)ATLAS_PH_SM, },
 517         { .compatible = "atlas,ec-sm", .data = (void *)ATLAS_EC_SM, },
 518         { .compatible = "atlas,orp-sm", .data = (void *)ATLAS_ORP_SM, },
 519         { }
 520 };
 521 MODULE_DEVICE_TABLE(of, atlas_dt_ids);
 522
 523 static int atlas_probe(struct i2c_client *client,
 524                        const struct i2c_device_id *id)
 525 {
 526         struct atlas_data *data;
 527         struct atlas_device *chip;
 528         const struct of_device_id *of_id;
 529         struct iio_trigger *trig;
 530         struct iio_dev *indio_dev;
 531         int ret;
 532
 533         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 534         if (!indio_dev)
 535                 return -ENOMEM;
 536
 537         of_id = of_match_device(atlas_dt_ids, &client->dev);
 538         if (!of_id)
 539                 chip = &atlas_devices[id->driver_data];
 540         else
 541                 chip = &atlas_devices[(unsigned long)of_id->data];
 542
 543         indio_dev->info = &atlas_info;
 544         indio_dev->name = ATLAS_DRV_NAME;
 545         indio_dev->channels = chip->channels;
 546         indio_dev->num_channels = chip->num_channels;
 547         indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE;
 548         indio_dev->dev.parent = &client->dev;
 549
 550         trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
 551                                       indio_dev->name, indio_dev->id);
 552
 553         if (!trig)
 554                 return -ENOMEM;
 555
 556         data = iio_priv(indio_dev);
 557         data->client = client;
 558         data->trig = trig;
 559         data->chip = chip;
 560         trig->dev.parent = indio_dev->dev.parent;
 561         trig->ops = &atlas_interrupt_trigger_ops;
 562         iio_trigger_set_drvdata(trig, indio_dev);
 563
 564         i2c_set_clientdata(client, indio_dev);
 565
 566         data->regmap = devm_regmap_init_i2c(client, &atlas_regmap_config);
 567         if (IS_ERR(data->regmap)) {
 568                 dev_err(&client->dev, "regmap initialization failed\n");
 569                 return PTR_ERR(data->regmap);
 570         }
 571
 572         ret = pm_runtime_set_active(&client->dev);
 573         if (ret)
 574                 return ret;
 575
 576         if (client->irq <= 0) {
 577                 dev_err(&client->dev, "no valid irq defined\n");
 578                 return -EINVAL;
 579         }
 580
 581         ret = chip->calibration(data);
 582         if (ret)
 583                 return ret;
 584
 585         ret = iio_trigger_register(trig);
 586         if (ret) {
 587                 dev_err(&client->dev, "failed to register trigger\n");
 588                 return ret;
 589         }
 590
 591         ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
 592                 &atlas_trigger_handler, &atlas_buffer_setup_ops);
 593         if (ret) {
 594                 dev_err(&client->dev, "cannot setup iio trigger\n");
 595                 goto unregister_trigger;
 596         }
 597
 598         init_irq_work(&data->work, atlas_work_handler);
 599
 600         /* interrupt pin toggles on new conversion */
 601         ret = devm_request_threaded_irq(&client->dev, client->irq,
 602                                         NULL, atlas_interrupt_handler,
 603                                         IRQF_TRIGGER_RISING |
 604                                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 605                                         "atlas_irq",
 606                                         indio_dev);
 607         if (ret) {
 608                 dev_err(&client->dev, "request irq (%d) failed\n", client->irq);
 609                 goto unregister_buffer;
 610         }
 611
 612         ret = atlas_set_powermode(data, 1);
 613         if (ret) {
 614                 dev_err(&client->dev, "cannot power device on");
 615                 goto unregister_buffer;
 616         }
 617
 618         pm_runtime_enable(&client->dev);
 619         pm_runtime_set_autosuspend_delay(&client->dev, 2500);
 620         pm_runtime_use_autosuspend(&client->dev);
 621
 622         ret = iio_device_register(indio_dev);
 623         if (ret) {
 624                 dev_err(&client->dev, "unable to register device\n");
 625                 goto unregister_pm;
 626         }
 627
 628         return 0;
 629
 630 unregister_pm:
 631         pm_runtime_disable(&client->dev);
 632         atlas_set_powermode(data, 0);
 633
 634 unregister_buffer:
 635         iio_triggered_buffer_cleanup(indio_dev);
 636
 637 unregister_trigger:
 638         iio_trigger_unregister(data->trig);
 639
 640         return ret;
 641 }
 642
 643 static int atlas_remove(struct i2c_client *client)
 644 {
 645         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 646         struct atlas_data *data = iio_priv(indio_dev);
 647
 648         iio_device_unregister(indio_dev);
 649         iio_triggered_buffer_cleanup(indio_dev);
 650         iio_trigger_unregister(data->trig);
 651
 652         pm_runtime_disable(&client->dev);
 653         pm_runtime_set_suspended(&client->dev);
 654         pm_runtime_put_noidle(&client->dev);
 655
 656         return atlas_set_powermode(data, 0);
 657 }
 658
 659 #ifdef CONFIG_PM
 660 static int atlas_runtime_suspend(struct device *dev)
 661 {
 662         struct atlas_data *data =
 663                      iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
 664
 665         return atlas_set_powermode(data, 0);
 666 }
 667
 668 static int atlas_runtime_resume(struct device *dev)
 669 {
 670         struct atlas_data *data =
 671                      iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
 672
 673         return atlas_set_powermode(data, 1);
 674 }
 675 #endif
 676
 677 static const struct dev_pm_ops atlas_pm_ops = {
 678         SET_RUNTIME_PM_OPS(atlas_runtime_suspend,
 679                            atlas_runtime_resume, NULL)
 680 };
 681
 682 static struct i2c_driver atlas_driver = {
 683         .driver = {
 684                 .name   = ATLAS_DRV_NAME,
 685                 .of_match_table = of_match_ptr(atlas_dt_ids),
 686                 .pm     = &atlas_pm_ops,
 687         },
 688         .probe          = atlas_probe,
 689         .remove         = atlas_remove,
 690         .id_table       = atlas_id,
 691 };
 692 module_i2c_driver(atlas_driver);
 693
 694 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
 695 MODULE_DESCRIPTION("Atlas Scientific pH-SM sensor");
 696 MODULE_LICENSE("GPL");