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