1 // SPDX-License-Identifier: GPL-2.0+
3 * atlas-sensor.c - Support for Atlas Scientific OEM SM sensors
5 * Copyright (C) 2015-2019 Konsulko Group
6 * Author: Matt Ranostay <matt.ranostay@konsulko.com>
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>
27 #define ATLAS_REGMAP_NAME "atlas_regmap"
28 #define ATLAS_DRV_NAME "atlas"
30 #define ATLAS_REG_DEV_TYPE 0x00
31 #define ATLAS_REG_DEV_VERSION 0x01
33 #define ATLAS_REG_INT_CONTROL 0x04
34 #define ATLAS_REG_INT_CONTROL_EN BIT(3)
36 #define ATLAS_REG_PWR_CONTROL 0x06
38 #define ATLAS_REG_PH_CALIB_STATUS 0x0d
39 #define ATLAS_REG_PH_CALIB_STATUS_MASK 0x07
40 #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)
44 #define ATLAS_REG_EC_CALIB_STATUS 0x0f
45 #define ATLAS_REG_EC_CALIB_STATUS_MASK 0x0f
46 #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)
51 #define ATLAS_REG_DO_CALIB_STATUS 0x09
52 #define ATLAS_REG_DO_CALIB_STATUS_MASK 0x03
53 #define ATLAS_REG_DO_CALIB_STATUS_PRESSURE BIT(0)
54 #define ATLAS_REG_DO_CALIB_STATUS_DO BIT(1)
56 #define ATLAS_REG_RTD_DATA 0x0e
58 #define ATLAS_REG_PH_TEMP_DATA 0x0e
59 #define ATLAS_REG_PH_DATA 0x16
61 #define ATLAS_REG_EC_PROBE 0x08
62 #define ATLAS_REG_EC_TEMP_DATA 0x10
63 #define ATLAS_REG_EC_DATA 0x18
64 #define ATLAS_REG_TDS_DATA 0x1c
65 #define ATLAS_REG_PSS_DATA 0x20
67 #define ATLAS_REG_ORP_CALIB_STATUS 0x0d
68 #define ATLAS_REG_ORP_DATA 0x0e
70 #define ATLAS_REG_DO_TEMP_DATA 0x12
71 #define ATLAS_REG_DO_DATA 0x22
73 #define ATLAS_PH_INT_TIME_IN_MS 450
74 #define ATLAS_EC_INT_TIME_IN_MS 650
75 #define ATLAS_ORP_INT_TIME_IN_MS 450
76 #define ATLAS_DO_INT_TIME_IN_MS 450
77 #define ATLAS_RTD_INT_TIME_IN_MS 450
88 struct i2c_client *client;
89 struct iio_trigger *trig;
90 struct atlas_device *chip;
91 struct regmap *regmap;
93 unsigned int interrupt_enabled;
94 /* 96-bit data + 32-bit pad + 64-bit timestamp */
95 __be32 buffer[6] __aligned(8);
98 static const struct regmap_config atlas_regmap_config = {
99 .name = ATLAS_REGMAP_NAME,
104 static int atlas_buffer_num_channels(const struct iio_chan_spec *spec)
108 for (; spec->type != IIO_TIMESTAMP; spec++)
114 static const struct iio_chan_spec atlas_ph_channels[] = {
117 .address = ATLAS_REG_PH_DATA,
118 .info_mask_separate =
119 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
125 .endianness = IIO_BE,
128 IIO_CHAN_SOFT_TIMESTAMP(1),
131 .address = ATLAS_REG_PH_TEMP_DATA,
132 .info_mask_separate =
133 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
139 #define ATLAS_CONCENTRATION_CHANNEL(_idx, _addr) \
141 .type = IIO_CONCENTRATION, \
145 .info_mask_separate = \
146 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), \
147 .scan_index = _idx + 1, \
152 .endianness = IIO_BE, \
156 static const struct iio_chan_spec atlas_ec_channels[] = {
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),
167 .endianness = IIO_BE,
170 ATLAS_CONCENTRATION_CHANNEL(0, ATLAS_REG_TDS_DATA),
171 ATLAS_CONCENTRATION_CHANNEL(1, ATLAS_REG_PSS_DATA),
172 IIO_CHAN_SOFT_TIMESTAMP(3),
175 .address = ATLAS_REG_EC_TEMP_DATA,
176 .info_mask_separate =
177 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
183 static const struct iio_chan_spec atlas_orp_channels[] = {
186 .address = ATLAS_REG_ORP_DATA,
187 .info_mask_separate =
188 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
194 .endianness = IIO_BE,
197 IIO_CHAN_SOFT_TIMESTAMP(1),
200 static const struct iio_chan_spec atlas_do_channels[] = {
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),
211 .endianness = IIO_BE,
214 IIO_CHAN_SOFT_TIMESTAMP(1),
217 .address = ATLAS_REG_DO_TEMP_DATA,
218 .info_mask_separate =
219 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
225 static const struct iio_chan_spec atlas_rtd_channels[] = {
228 .address = ATLAS_REG_RTD_DATA,
229 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
235 .endianness = IIO_BE,
238 IIO_CHAN_SOFT_TIMESTAMP(1),
241 static int atlas_check_ph_calibration(struct atlas_data *data)
243 struct device *dev = &data->client->dev;
247 ret = regmap_read(data->regmap, ATLAS_REG_PH_CALIB_STATUS, &val);
251 if (!(val & ATLAS_REG_PH_CALIB_STATUS_MASK)) {
252 dev_warn(dev, "device has not been calibrated\n");
256 if (!(val & ATLAS_REG_PH_CALIB_STATUS_LOW))
257 dev_warn(dev, "device missing low point calibration\n");
259 if (!(val & ATLAS_REG_PH_CALIB_STATUS_MID))
260 dev_warn(dev, "device missing mid point calibration\n");
262 if (!(val & ATLAS_REG_PH_CALIB_STATUS_HIGH))
263 dev_warn(dev, "device missing high point calibration\n");
268 static int atlas_check_ec_calibration(struct atlas_data *data)
270 struct device *dev = &data->client->dev;
275 ret = regmap_bulk_read(data->regmap, ATLAS_REG_EC_PROBE, &rval, 2);
279 val = be16_to_cpu(rval);
280 dev_info(dev, "probe set to K = %d.%.2d", val / 100, val % 100);
282 ret = regmap_read(data->regmap, ATLAS_REG_EC_CALIB_STATUS, &val);
286 if (!(val & ATLAS_REG_EC_CALIB_STATUS_MASK)) {
287 dev_warn(dev, "device has not been calibrated\n");
291 if (!(val & ATLAS_REG_EC_CALIB_STATUS_DRY))
292 dev_warn(dev, "device missing dry point calibration\n");
294 if (val & ATLAS_REG_EC_CALIB_STATUS_SINGLE) {
295 dev_warn(dev, "device using single point calibration\n");
297 if (!(val & ATLAS_REG_EC_CALIB_STATUS_LOW))
298 dev_warn(dev, "device missing low point calibration\n");
300 if (!(val & ATLAS_REG_EC_CALIB_STATUS_HIGH))
301 dev_warn(dev, "device missing high point calibration\n");
307 static int atlas_check_orp_calibration(struct atlas_data *data)
309 struct device *dev = &data->client->dev;
313 ret = regmap_read(data->regmap, ATLAS_REG_ORP_CALIB_STATUS, &val);
318 dev_warn(dev, "device has not been calibrated\n");
323 static int atlas_check_do_calibration(struct atlas_data *data)
325 struct device *dev = &data->client->dev;
329 ret = regmap_read(data->regmap, ATLAS_REG_DO_CALIB_STATUS, &val);
333 if (!(val & ATLAS_REG_DO_CALIB_STATUS_MASK)) {
334 dev_warn(dev, "device has not been calibrated\n");
338 if (!(val & ATLAS_REG_DO_CALIB_STATUS_PRESSURE))
339 dev_warn(dev, "device missing atmospheric pressure calibration\n");
341 if (!(val & ATLAS_REG_DO_CALIB_STATUS_DO))
342 dev_warn(dev, "device missing dissolved oxygen calibration\n");
347 struct atlas_device {
348 const struct iio_chan_spec *channels;
352 int (*calibration)(struct atlas_data *data);
356 static struct atlas_device atlas_devices[] = {
358 .channels = atlas_ph_channels,
360 .data_reg = ATLAS_REG_PH_DATA,
361 .calibration = &atlas_check_ph_calibration,
362 .delay = ATLAS_PH_INT_TIME_IN_MS,
365 .channels = atlas_ec_channels,
367 .data_reg = ATLAS_REG_EC_DATA,
368 .calibration = &atlas_check_ec_calibration,
369 .delay = ATLAS_EC_INT_TIME_IN_MS,
372 .channels = atlas_orp_channels,
374 .data_reg = ATLAS_REG_ORP_DATA,
375 .calibration = &atlas_check_orp_calibration,
376 .delay = ATLAS_ORP_INT_TIME_IN_MS,
379 .channels = atlas_do_channels,
381 .data_reg = ATLAS_REG_DO_DATA,
382 .calibration = &atlas_check_do_calibration,
383 .delay = ATLAS_DO_INT_TIME_IN_MS,
386 .channels = atlas_rtd_channels,
388 .data_reg = ATLAS_REG_RTD_DATA,
389 .delay = ATLAS_RTD_INT_TIME_IN_MS,
393 static int atlas_set_powermode(struct atlas_data *data, int on)
395 return regmap_write(data->regmap, ATLAS_REG_PWR_CONTROL, on);
398 static int atlas_set_interrupt(struct atlas_data *data, bool state)
400 if (!data->interrupt_enabled)
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);
408 static int atlas_buffer_postenable(struct iio_dev *indio_dev)
410 struct atlas_data *data = iio_priv(indio_dev);
413 ret = pm_runtime_resume_and_get(&data->client->dev);
417 return atlas_set_interrupt(data, true);
420 static int atlas_buffer_predisable(struct iio_dev *indio_dev)
422 struct atlas_data *data = iio_priv(indio_dev);
425 ret = atlas_set_interrupt(data, false);
429 pm_runtime_mark_last_busy(&data->client->dev);
430 ret = pm_runtime_put_autosuspend(&data->client->dev);
437 static const struct iio_trigger_ops atlas_interrupt_trigger_ops = {
440 static const struct iio_buffer_setup_ops atlas_buffer_setup_ops = {
441 .postenable = atlas_buffer_postenable,
442 .predisable = atlas_buffer_predisable,
445 static void atlas_work_handler(struct irq_work *work)
447 struct atlas_data *data = container_of(work, struct atlas_data, work);
449 iio_trigger_poll(data->trig);
452 static irqreturn_t atlas_trigger_handler(int irq, void *private)
454 struct iio_poll_func *pf = private;
455 struct iio_dev *indio_dev = pf->indio_dev;
456 struct atlas_data *data = iio_priv(indio_dev);
457 int channels = atlas_buffer_num_channels(data->chip->channels);
460 ret = regmap_bulk_read(data->regmap, data->chip->data_reg,
461 &data->buffer, sizeof(__be32) * channels);
464 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
465 iio_get_time_ns(indio_dev));
467 iio_trigger_notify_done(indio_dev->trig);
472 static irqreturn_t atlas_interrupt_handler(int irq, void *private)
474 struct iio_dev *indio_dev = private;
475 struct atlas_data *data = iio_priv(indio_dev);
477 irq_work_queue(&data->work);
482 static int atlas_read_measurement(struct atlas_data *data, int reg, __be32 *val)
484 struct device *dev = &data->client->dev;
485 int suspended = pm_runtime_suspended(dev);
488 ret = pm_runtime_resume_and_get(dev);
493 msleep(data->chip->delay);
495 ret = regmap_bulk_read(data->regmap, reg, val, sizeof(*val));
497 pm_runtime_mark_last_busy(dev);
498 pm_runtime_put_autosuspend(dev);
503 static int atlas_read_raw(struct iio_dev *indio_dev,
504 struct iio_chan_spec const *chan,
505 int *val, int *val2, long mask)
507 struct atlas_data *data = iio_priv(indio_dev);
510 case IIO_CHAN_INFO_PROCESSED:
511 case IIO_CHAN_INFO_RAW: {
515 switch (chan->type) {
517 ret = regmap_bulk_read(data->regmap, chan->address,
521 case IIO_CONCENTRATION:
522 case IIO_ELECTRICALCONDUCTIVITY:
524 ret = iio_device_claim_direct_mode(indio_dev);
528 ret = atlas_read_measurement(data, chan->address, ®);
530 iio_device_release_direct_mode(indio_dev);
537 *val = be32_to_cpu(reg);
542 case IIO_CHAN_INFO_SCALE:
543 switch (chan->type) {
548 *val = 1; /* 0.001 */
551 case IIO_ELECTRICALCONDUCTIVITY:
552 *val = 1; /* 0.00001 */
555 case IIO_CONCENTRATION:
556 *val = 0; /* 0.000000001 */
558 return IIO_VAL_INT_PLUS_NANO;
566 return IIO_VAL_FRACTIONAL;
572 static int atlas_write_raw(struct iio_dev *indio_dev,
573 struct iio_chan_spec const *chan,
574 int val, int val2, long mask)
576 struct atlas_data *data = iio_priv(indio_dev);
577 __be32 reg = cpu_to_be32(val / 10);
579 if (val2 != 0 || val < 0 || val > 20000)
582 if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_TEMP)
585 return regmap_bulk_write(data->regmap, chan->address,
589 static const struct iio_info atlas_info = {
590 .read_raw = atlas_read_raw,
591 .write_raw = atlas_write_raw,
594 static const struct i2c_device_id atlas_id[] = {
595 { "atlas-ph-sm", ATLAS_PH_SM},
596 { "atlas-ec-sm", ATLAS_EC_SM},
597 { "atlas-orp-sm", ATLAS_ORP_SM},
598 { "atlas-do-sm", ATLAS_DO_SM},
599 { "atlas-rtd-sm", ATLAS_RTD_SM},
602 MODULE_DEVICE_TABLE(i2c, atlas_id);
604 static const struct of_device_id atlas_dt_ids[] = {
605 { .compatible = "atlas,ph-sm", .data = (void *)ATLAS_PH_SM, },
606 { .compatible = "atlas,ec-sm", .data = (void *)ATLAS_EC_SM, },
607 { .compatible = "atlas,orp-sm", .data = (void *)ATLAS_ORP_SM, },
608 { .compatible = "atlas,do-sm", .data = (void *)ATLAS_DO_SM, },
609 { .compatible = "atlas,rtd-sm", .data = (void *)ATLAS_RTD_SM, },
612 MODULE_DEVICE_TABLE(of, atlas_dt_ids);
614 static int atlas_probe(struct i2c_client *client,
615 const struct i2c_device_id *id)
617 struct atlas_data *data;
618 struct atlas_device *chip;
619 struct iio_trigger *trig;
620 struct iio_dev *indio_dev;
623 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
627 if (!dev_fwnode(&client->dev))
628 chip = &atlas_devices[id->driver_data];
630 chip = &atlas_devices[(unsigned long)device_get_match_data(&client->dev)];
632 indio_dev->info = &atlas_info;
633 indio_dev->name = ATLAS_DRV_NAME;
634 indio_dev->channels = chip->channels;
635 indio_dev->num_channels = chip->num_channels;
636 indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE;
638 trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
639 indio_dev->name, iio_device_id(indio_dev));
644 data = iio_priv(indio_dev);
645 data->client = client;
648 trig->ops = &atlas_interrupt_trigger_ops;
649 iio_trigger_set_drvdata(trig, indio_dev);
651 i2c_set_clientdata(client, indio_dev);
653 data->regmap = devm_regmap_init_i2c(client, &atlas_regmap_config);
654 if (IS_ERR(data->regmap)) {
655 dev_err(&client->dev, "regmap initialization failed\n");
656 return PTR_ERR(data->regmap);
659 ret = pm_runtime_set_active(&client->dev);
663 ret = chip->calibration(data);
667 ret = iio_trigger_register(trig);
669 dev_err(&client->dev, "failed to register trigger\n");
673 ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
674 &atlas_trigger_handler, &atlas_buffer_setup_ops);
676 dev_err(&client->dev, "cannot setup iio trigger\n");
677 goto unregister_trigger;
680 init_irq_work(&data->work, atlas_work_handler);
682 if (client->irq > 0) {
683 /* interrupt pin toggles on new conversion */
684 ret = devm_request_threaded_irq(&client->dev, client->irq,
685 NULL, atlas_interrupt_handler,
686 IRQF_TRIGGER_RISING |
687 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
692 dev_warn(&client->dev,
693 "request irq (%d) failed\n", client->irq);
695 data->interrupt_enabled = 1;
698 ret = atlas_set_powermode(data, 1);
700 dev_err(&client->dev, "cannot power device on");
701 goto unregister_buffer;
704 pm_runtime_enable(&client->dev);
705 pm_runtime_set_autosuspend_delay(&client->dev, 2500);
706 pm_runtime_use_autosuspend(&client->dev);
708 ret = iio_device_register(indio_dev);
710 dev_err(&client->dev, "unable to register device\n");
717 pm_runtime_disable(&client->dev);
718 atlas_set_powermode(data, 0);
721 iio_triggered_buffer_cleanup(indio_dev);
724 iio_trigger_unregister(data->trig);
729 static int atlas_remove(struct i2c_client *client)
731 struct iio_dev *indio_dev = i2c_get_clientdata(client);
732 struct atlas_data *data = iio_priv(indio_dev);
734 iio_device_unregister(indio_dev);
735 iio_triggered_buffer_cleanup(indio_dev);
736 iio_trigger_unregister(data->trig);
738 pm_runtime_disable(&client->dev);
739 pm_runtime_set_suspended(&client->dev);
741 return atlas_set_powermode(data, 0);
745 static int atlas_runtime_suspend(struct device *dev)
747 struct atlas_data *data =
748 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
750 return atlas_set_powermode(data, 0);
753 static int atlas_runtime_resume(struct device *dev)
755 struct atlas_data *data =
756 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
758 return atlas_set_powermode(data, 1);
762 static const struct dev_pm_ops atlas_pm_ops = {
763 SET_RUNTIME_PM_OPS(atlas_runtime_suspend,
764 atlas_runtime_resume, NULL)
767 static struct i2c_driver atlas_driver = {
769 .name = ATLAS_DRV_NAME,
770 .of_match_table = atlas_dt_ids,
773 .probe = atlas_probe,
774 .remove = atlas_remove,
775 .id_table = atlas_id,
777 module_i2c_driver(atlas_driver);
779 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
780 MODULE_DESCRIPTION("Atlas Scientific SM sensors");
781 MODULE_LICENSE("GPL");