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
atlas_check_ph_calibration(struct atlas_data * data)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
atlas_check_ec_calibration(struct atlas_data * data)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
atlas_check_orp_calibration(struct atlas_data * data)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
atlas_set_powermode(struct atlas_data * data,int on)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
atlas_set_interrupt(struct atlas_data * data,bool state)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
atlas_buffer_postenable(struct iio_dev * indio_dev)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
atlas_buffer_predisable(struct iio_dev * indio_dev)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
atlas_work_handler(struct irq_work * work)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
atlas_trigger_handler(int irq,void * private)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
atlas_interrupt_handler(int irq,void * private)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
atlas_read_measurement(struct atlas_data * data,int reg,__be32 * val)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
atlas_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)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 *) ®, 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, ®);
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
atlas_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)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 ®, 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
atlas_probe(struct i2c_client * client,const struct i2c_device_id * id)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
atlas_remove(struct i2c_client * client)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
atlas_runtime_suspend(struct device * dev)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
atlas_runtime_resume(struct device * dev)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");
696