775 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/*3 * atlas-sensor.c - Support for Atlas Scientific OEM SM sensors4 *5 * Copyright (C) 2015-2019 Konsulko Group6 * 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 0x0031#define ATLAS_REG_DEV_VERSION 0x0132 33#define ATLAS_REG_INT_CONTROL 0x0434#define ATLAS_REG_INT_CONTROL_EN BIT(3)35 36#define ATLAS_REG_PWR_CONTROL 0x0637 38#define ATLAS_REG_PH_CALIB_STATUS 0x0d39#define ATLAS_REG_PH_CALIB_STATUS_MASK 0x0740#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 0x0f45#define ATLAS_REG_EC_CALIB_STATUS_MASK 0x0f46#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 0x0952#define ATLAS_REG_DO_CALIB_STATUS_MASK 0x0353#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 0x0e57 58#define ATLAS_REG_PH_TEMP_DATA 0x0e59#define ATLAS_REG_PH_DATA 0x1660 61#define ATLAS_REG_EC_PROBE 0x0862#define ATLAS_REG_EC_TEMP_DATA 0x1063#define ATLAS_REG_EC_DATA 0x1864#define ATLAS_REG_TDS_DATA 0x1c65#define ATLAS_REG_PSS_DATA 0x2066 67#define ATLAS_REG_ORP_CALIB_STATUS 0x0d68#define ATLAS_REG_ORP_DATA 0x0e69 70#define ATLAS_REG_DO_TEMP_DATA 0x1271#define ATLAS_REG_DO_DATA 0x2272 73#define ATLAS_PH_INT_TIME_IN_MS 45074#define ATLAS_EC_INT_TIME_IN_MS 65075#define ATLAS_ORP_INT_TIME_IN_MS 45076#define ATLAS_DO_INT_TIME_IN_MS 45077#define ATLAS_RTD_INT_TIME_IN_MS 45078 79enum {80 ATLAS_PH_SM,81 ATLAS_EC_SM,82 ATLAS_ORP_SM,83 ATLAS_DO_SM,84 ATLAS_RTD_SM,85};86 87struct atlas_data {88 struct i2c_client *client;89 struct iio_trigger *trig;90 const 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 98static const struct regmap_config atlas_regmap_config = {99 .name = ATLAS_REGMAP_NAME,100 .reg_bits = 8,101 .val_bits = 8,102};103 104static 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 114static 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 = -1136 },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 156static 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 = -1180 },181};182 183static 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 200static 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 = -1222 },223};224 225static 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 241static 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 268static 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 307static 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 323static 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 347struct 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 356static const 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 393static int atlas_set_powermode(struct atlas_data *data, int on)394{395 return regmap_write(data->regmap, ATLAS_REG_PWR_CONTROL, on);396}397 398static 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 408static 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 420static 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 437static const struct iio_buffer_setup_ops atlas_buffer_setup_ops = {438 .postenable = atlas_buffer_postenable,439 .predisable = atlas_buffer_predisable,440};441 442static void atlas_work_handler(struct irq_work *work)443{444 struct atlas_data *data = container_of(work, struct atlas_data, work);445 446 iio_trigger_poll(data->trig);447}448 449static irqreturn_t atlas_trigger_handler(int irq, void *private)450{451 struct iio_poll_func *pf = private;452 struct iio_dev *indio_dev = pf->indio_dev;453 struct atlas_data *data = iio_priv(indio_dev);454 int channels = atlas_buffer_num_channels(data->chip->channels);455 int ret;456 457 ret = regmap_bulk_read(data->regmap, data->chip->data_reg,458 &data->buffer, sizeof(__be32) * channels);459 460 if (!ret)461 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,462 iio_get_time_ns(indio_dev));463 464 iio_trigger_notify_done(indio_dev->trig);465 466 return IRQ_HANDLED;467}468 469static irqreturn_t atlas_interrupt_handler(int irq, void *private)470{471 struct iio_dev *indio_dev = private;472 struct atlas_data *data = iio_priv(indio_dev);473 474 irq_work_queue(&data->work);475 476 return IRQ_HANDLED;477}478 479static int atlas_read_measurement(struct atlas_data *data, int reg, __be32 *val)480{481 struct device *dev = &data->client->dev;482 int suspended = pm_runtime_suspended(dev);483 int ret;484 485 ret = pm_runtime_resume_and_get(dev);486 if (ret)487 return ret;488 489 if (suspended)490 msleep(data->chip->delay);491 492 ret = regmap_bulk_read(data->regmap, reg, val, sizeof(*val));493 494 pm_runtime_mark_last_busy(dev);495 pm_runtime_put_autosuspend(dev);496 497 return ret;498}499 500static int atlas_read_raw(struct iio_dev *indio_dev,501 struct iio_chan_spec const *chan,502 int *val, int *val2, long mask)503{504 struct atlas_data *data = iio_priv(indio_dev);505 506 switch (mask) {507 case IIO_CHAN_INFO_PROCESSED:508 case IIO_CHAN_INFO_RAW: {509 int ret;510 __be32 reg;511 512 switch (chan->type) {513 case IIO_TEMP:514 ret = regmap_bulk_read(data->regmap, chan->address,515 ®, sizeof(reg));516 break;517 case IIO_PH:518 case IIO_CONCENTRATION:519 case IIO_ELECTRICALCONDUCTIVITY:520 case IIO_VOLTAGE:521 ret = iio_device_claim_direct_mode(indio_dev);522 if (ret)523 return ret;524 525 ret = atlas_read_measurement(data, chan->address, ®);526 527 iio_device_release_direct_mode(indio_dev);528 break;529 default:530 ret = -EINVAL;531 }532 533 if (!ret) {534 *val = be32_to_cpu(reg);535 ret = IIO_VAL_INT;536 }537 return ret;538 }539 case IIO_CHAN_INFO_SCALE:540 switch (chan->type) {541 case IIO_TEMP:542 *val = 10;543 return IIO_VAL_INT;544 case IIO_PH:545 *val = 1; /* 0.001 */546 *val2 = 1000;547 break;548 case IIO_ELECTRICALCONDUCTIVITY:549 *val = 1; /* 0.00001 */550 *val2 = 100000;551 break;552 case IIO_CONCENTRATION:553 *val = 0; /* 0.000000001 */554 *val2 = 1000;555 return IIO_VAL_INT_PLUS_NANO;556 case IIO_VOLTAGE:557 *val = 1; /* 0.1 */558 *val2 = 10;559 break;560 default:561 return -EINVAL;562 }563 return IIO_VAL_FRACTIONAL;564 }565 566 return -EINVAL;567}568 569static int atlas_write_raw(struct iio_dev *indio_dev,570 struct iio_chan_spec const *chan,571 int val, int val2, long mask)572{573 struct atlas_data *data = iio_priv(indio_dev);574 __be32 reg = cpu_to_be32(val / 10);575 576 if (val2 != 0 || val < 0 || val > 20000)577 return -EINVAL;578 579 if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_TEMP)580 return -EINVAL;581 582 return regmap_bulk_write(data->regmap, chan->address,583 ®, sizeof(reg));584}585 586static const struct iio_info atlas_info = {587 .read_raw = atlas_read_raw,588 .write_raw = atlas_write_raw,589};590 591static const struct i2c_device_id atlas_id[] = {592 { "atlas-ph-sm", (kernel_ulong_t)&atlas_devices[ATLAS_PH_SM] },593 { "atlas-ec-sm", (kernel_ulong_t)&atlas_devices[ATLAS_EC_SM] },594 { "atlas-orp-sm", (kernel_ulong_t)&atlas_devices[ATLAS_ORP_SM] },595 { "atlas-do-sm", (kernel_ulong_t)&atlas_devices[ATLAS_DO_SM] },596 { "atlas-rtd-sm", (kernel_ulong_t)&atlas_devices[ATLAS_RTD_SM] },597 {}598};599MODULE_DEVICE_TABLE(i2c, atlas_id);600 601static const struct of_device_id atlas_dt_ids[] = {602 { .compatible = "atlas,ph-sm", .data = &atlas_devices[ATLAS_PH_SM] },603 { .compatible = "atlas,ec-sm", .data = &atlas_devices[ATLAS_EC_SM] },604 { .compatible = "atlas,orp-sm", .data = &atlas_devices[ATLAS_ORP_SM] },605 { .compatible = "atlas,do-sm", .data = &atlas_devices[ATLAS_DO_SM] },606 { .compatible = "atlas,rtd-sm", .data = &atlas_devices[ATLAS_RTD_SM] },607 { }608};609MODULE_DEVICE_TABLE(of, atlas_dt_ids);610 611static int atlas_probe(struct i2c_client *client)612{613 struct atlas_data *data;614 const struct atlas_device *chip;615 struct iio_trigger *trig;616 struct iio_dev *indio_dev;617 int ret;618 619 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));620 if (!indio_dev)621 return -ENOMEM;622 623 chip = i2c_get_match_data(client);624 625 indio_dev->info = &atlas_info;626 indio_dev->name = ATLAS_DRV_NAME;627 indio_dev->channels = chip->channels;628 indio_dev->num_channels = chip->num_channels;629 indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE;630 631 trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",632 indio_dev->name, iio_device_id(indio_dev));633 634 if (!trig)635 return -ENOMEM;636 637 data = iio_priv(indio_dev);638 data->client = client;639 data->trig = trig;640 data->chip = chip;641 iio_trigger_set_drvdata(trig, indio_dev);642 643 i2c_set_clientdata(client, indio_dev);644 645 data->regmap = devm_regmap_init_i2c(client, &atlas_regmap_config);646 if (IS_ERR(data->regmap)) {647 dev_err(&client->dev, "regmap initialization failed\n");648 return PTR_ERR(data->regmap);649 }650 651 ret = pm_runtime_set_active(&client->dev);652 if (ret)653 return ret;654 655 ret = chip->calibration(data);656 if (ret)657 return ret;658 659 ret = iio_trigger_register(trig);660 if (ret) {661 dev_err(&client->dev, "failed to register trigger\n");662 return ret;663 }664 665 ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,666 &atlas_trigger_handler, &atlas_buffer_setup_ops);667 if (ret) {668 dev_err(&client->dev, "cannot setup iio trigger\n");669 goto unregister_trigger;670 }671 672 init_irq_work(&data->work, atlas_work_handler);673 674 if (client->irq > 0) {675 /* interrupt pin toggles on new conversion */676 ret = devm_request_threaded_irq(&client->dev, client->irq,677 NULL, atlas_interrupt_handler,678 IRQF_TRIGGER_RISING |679 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,680 "atlas_irq",681 indio_dev);682 683 if (ret)684 dev_warn(&client->dev,685 "request irq (%d) failed\n", client->irq);686 else687 data->interrupt_enabled = 1;688 }689 690 ret = atlas_set_powermode(data, 1);691 if (ret) {692 dev_err(&client->dev, "cannot power device on");693 goto unregister_buffer;694 }695 696 pm_runtime_enable(&client->dev);697 pm_runtime_set_autosuspend_delay(&client->dev, 2500);698 pm_runtime_use_autosuspend(&client->dev);699 700 ret = iio_device_register(indio_dev);701 if (ret) {702 dev_err(&client->dev, "unable to register device\n");703 goto unregister_pm;704 }705 706 return 0;707 708unregister_pm:709 pm_runtime_disable(&client->dev);710 atlas_set_powermode(data, 0);711 712unregister_buffer:713 iio_triggered_buffer_cleanup(indio_dev);714 715unregister_trigger:716 iio_trigger_unregister(data->trig);717 718 return ret;719}720 721static void atlas_remove(struct i2c_client *client)722{723 struct iio_dev *indio_dev = i2c_get_clientdata(client);724 struct atlas_data *data = iio_priv(indio_dev);725 int ret;726 727 iio_device_unregister(indio_dev);728 iio_triggered_buffer_cleanup(indio_dev);729 iio_trigger_unregister(data->trig);730 731 pm_runtime_disable(&client->dev);732 pm_runtime_set_suspended(&client->dev);733 734 ret = atlas_set_powermode(data, 0);735 if (ret)736 dev_err(&client->dev, "Failed to power down device (%pe)\n",737 ERR_PTR(ret));738}739 740static int atlas_runtime_suspend(struct device *dev)741{742 struct atlas_data *data =743 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));744 745 return atlas_set_powermode(data, 0);746}747 748static int atlas_runtime_resume(struct device *dev)749{750 struct atlas_data *data =751 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));752 753 return atlas_set_powermode(data, 1);754}755 756static const struct dev_pm_ops atlas_pm_ops = {757 RUNTIME_PM_OPS(atlas_runtime_suspend, atlas_runtime_resume, NULL)758};759 760static struct i2c_driver atlas_driver = {761 .driver = {762 .name = ATLAS_DRV_NAME,763 .of_match_table = atlas_dt_ids,764 .pm = pm_ptr(&atlas_pm_ops),765 },766 .probe = atlas_probe,767 .remove = atlas_remove,768 .id_table = atlas_id,769};770module_i2c_driver(atlas_driver);771 772MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");773MODULE_DESCRIPTION("Atlas Scientific SM sensors");774MODULE_LICENSE("GPL");775