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/of_device.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		0x00
 31#define ATLAS_REG_DEV_VERSION		0x01
 32
 33#define ATLAS_REG_INT_CONTROL		0x04
 34#define ATLAS_REG_INT_CONTROL_EN	BIT(3)
 35
 36#define ATLAS_REG_PWR_CONTROL		0x06
 37
 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)
 43
 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)
 50
 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)
 55
 56#define ATLAS_REG_RTD_DATA		0x0e
 57
 58#define ATLAS_REG_PH_TEMP_DATA		0x0e
 59#define ATLAS_REG_PH_DATA		0x16
 60
 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
 66
 67#define ATLAS_REG_ORP_CALIB_STATUS	0x0d
 68#define ATLAS_REG_ORP_DATA		0x0e
 69
 70#define ATLAS_REG_DO_TEMP_DATA		0x12
 71#define ATLAS_REG_DO_DATA		0x22
 72
 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
 78
 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	struct atlas_device *chip;
 91	struct regmap *regmap;
 92	struct irq_work work;
 93	unsigned int interrupt_enabled;
 94
 95	__be32 buffer[6]; /* 96-bit data + 32-bit pad + 64-bit timestamp */
 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 = -1
136	},
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 = -1
180	},
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 = -1
222	},
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 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_get_sync(&data->client->dev);
414	if (ret < 0) {
415		pm_runtime_put_noidle(&data->client->dev);
416		return ret;
417	}
418
419	return atlas_set_interrupt(data, true);
420}
421
422static int atlas_buffer_predisable(struct iio_dev *indio_dev)
423{
424	struct atlas_data *data = iio_priv(indio_dev);
425	int ret;
426
427	ret = atlas_set_interrupt(data, false);
428	if (ret)
429		return ret;
430
431	pm_runtime_mark_last_busy(&data->client->dev);
432	ret = pm_runtime_put_autosuspend(&data->client->dev);
433	if (ret)
434		return ret;
435
436	return 0;
437}
438
439static const struct iio_trigger_ops atlas_interrupt_trigger_ops = {
440};
441
442static const struct iio_buffer_setup_ops atlas_buffer_setup_ops = {
443	.postenable = atlas_buffer_postenable,
444	.predisable = atlas_buffer_predisable,
445};
446
447static void atlas_work_handler(struct irq_work *work)
448{
449	struct atlas_data *data = container_of(work, struct atlas_data, work);
450
451	iio_trigger_poll(data->trig);
452}
453
454static irqreturn_t atlas_trigger_handler(int irq, void *private)
455{
456	struct iio_poll_func *pf = private;
457	struct iio_dev *indio_dev = pf->indio_dev;
458	struct atlas_data *data = iio_priv(indio_dev);
459	int channels = atlas_buffer_num_channels(data->chip->channels);
460	int ret;
461
462	ret = regmap_bulk_read(data->regmap, data->chip->data_reg,
463			      &data->buffer, sizeof(__be32) * channels);
464
465	if (!ret)
466		iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
467				iio_get_time_ns(indio_dev));
468
469	iio_trigger_notify_done(indio_dev->trig);
470
471	return IRQ_HANDLED;
472}
473
474static irqreturn_t atlas_interrupt_handler(int irq, void *private)
475{
476	struct iio_dev *indio_dev = private;
477	struct atlas_data *data = iio_priv(indio_dev);
478
479	irq_work_queue(&data->work);
480
481	return IRQ_HANDLED;
482}
483
484static int atlas_read_measurement(struct atlas_data *data, int reg, __be32 *val)
485{
486	struct device *dev = &data->client->dev;
487	int suspended = pm_runtime_suspended(dev);
488	int ret;
489
490	ret = pm_runtime_get_sync(dev);
491	if (ret < 0) {
492		pm_runtime_put_noidle(dev);
493		return ret;
494	}
495
496	if (suspended)
497		msleep(data->chip->delay);
498
499	ret = regmap_bulk_read(data->regmap, reg, val, sizeof(*val));
500
501	pm_runtime_mark_last_busy(dev);
502	pm_runtime_put_autosuspend(dev);
503
504	return ret;
505}
506
507static int atlas_read_raw(struct iio_dev *indio_dev,
508			  struct iio_chan_spec const *chan,
509			  int *val, int *val2, long mask)
510{
511	struct atlas_data *data = iio_priv(indio_dev);
512
513	switch (mask) {
514	case IIO_CHAN_INFO_PROCESSED:
515	case IIO_CHAN_INFO_RAW: {
516		int ret;
517		__be32 reg;
518
519		switch (chan->type) {
520		case IIO_TEMP:
521			ret = regmap_bulk_read(data->regmap, chan->address,
522					       &reg, sizeof(reg));
523			break;
524		case IIO_PH:
525		case IIO_CONCENTRATION:
526		case IIO_ELECTRICALCONDUCTIVITY:
527		case IIO_VOLTAGE:
528			ret = iio_device_claim_direct_mode(indio_dev);
529			if (ret)
530				return ret;
531
532			ret = atlas_read_measurement(data, chan->address, &reg);
533
534			iio_device_release_direct_mode(indio_dev);
535			break;
536		default:
537			ret = -EINVAL;
538		}
539
540		if (!ret) {
541			*val = be32_to_cpu(reg);
542			ret = IIO_VAL_INT;
543		}
544		return ret;
545	}
546	case IIO_CHAN_INFO_SCALE:
547		switch (chan->type) {
548		case IIO_TEMP:
549			*val = 10;
550			return IIO_VAL_INT;
551		case IIO_PH:
552			*val = 1; /* 0.001 */
553			*val2 = 1000;
554			break;
555		case IIO_ELECTRICALCONDUCTIVITY:
556			*val = 1; /* 0.00001 */
557			*val2 = 100000;
558			break;
559		case IIO_CONCENTRATION:
560			*val = 0; /* 0.000000001 */
561			*val2 = 1000;
562			return IIO_VAL_INT_PLUS_NANO;
563		case IIO_VOLTAGE:
564			*val = 1; /* 0.1 */
565			*val2 = 10;
566			break;
567		default:
568			return -EINVAL;
569		}
570		return IIO_VAL_FRACTIONAL;
571	}
572
573	return -EINVAL;
574}
575
576static int atlas_write_raw(struct iio_dev *indio_dev,
577			   struct iio_chan_spec const *chan,
578			   int val, int val2, long mask)
579{
580	struct atlas_data *data = iio_priv(indio_dev);
581	__be32 reg = cpu_to_be32(val / 10);
582
583	if (val2 != 0 || val < 0 || val > 20000)
584		return -EINVAL;
585
586	if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_TEMP)
587		return -EINVAL;
588
589	return regmap_bulk_write(data->regmap, chan->address,
590				 &reg, sizeof(reg));
591}
592
593static const struct iio_info atlas_info = {
594	.read_raw = atlas_read_raw,
595	.write_raw = atlas_write_raw,
596};
597
598static const struct i2c_device_id atlas_id[] = {
599	{ "atlas-ph-sm", ATLAS_PH_SM},
600	{ "atlas-ec-sm", ATLAS_EC_SM},
601	{ "atlas-orp-sm", ATLAS_ORP_SM},
602	{ "atlas-do-sm", ATLAS_DO_SM},
603	{ "atlas-rtd-sm", ATLAS_RTD_SM},
604	{}
605};
606MODULE_DEVICE_TABLE(i2c, atlas_id);
607
608static const struct of_device_id atlas_dt_ids[] = {
609	{ .compatible = "atlas,ph-sm", .data = (void *)ATLAS_PH_SM, },
610	{ .compatible = "atlas,ec-sm", .data = (void *)ATLAS_EC_SM, },
611	{ .compatible = "atlas,orp-sm", .data = (void *)ATLAS_ORP_SM, },
612	{ .compatible = "atlas,do-sm", .data = (void *)ATLAS_DO_SM, },
613	{ .compatible = "atlas,rtd-sm", .data = (void *)ATLAS_RTD_SM, },
614	{ }
615};
616MODULE_DEVICE_TABLE(of, atlas_dt_ids);
617
618static int atlas_probe(struct i2c_client *client,
619		       const struct i2c_device_id *id)
620{
621	struct atlas_data *data;
622	struct atlas_device *chip;
623	const struct of_device_id *of_id;
624	struct iio_trigger *trig;
625	struct iio_dev *indio_dev;
626	int ret;
627
628	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
629	if (!indio_dev)
630		return -ENOMEM;
631
632	of_id = of_match_device(atlas_dt_ids, &client->dev);
633	if (!of_id)
634		chip = &atlas_devices[id->driver_data];
635	else
636		chip = &atlas_devices[(unsigned long)of_id->data];
637
638	indio_dev->info = &atlas_info;
639	indio_dev->name = ATLAS_DRV_NAME;
640	indio_dev->channels = chip->channels;
641	indio_dev->num_channels = chip->num_channels;
642	indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE;
643
644	trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
645				      indio_dev->name, indio_dev->id);
646
647	if (!trig)
648		return -ENOMEM;
649
650	data = iio_priv(indio_dev);
651	data->client = client;
652	data->trig = trig;
653	data->chip = chip;
654	trig->dev.parent = indio_dev->dev.parent;
655	trig->ops = &atlas_interrupt_trigger_ops;
656	iio_trigger_set_drvdata(trig, indio_dev);
657
658	i2c_set_clientdata(client, indio_dev);
659
660	data->regmap = devm_regmap_init_i2c(client, &atlas_regmap_config);
661	if (IS_ERR(data->regmap)) {
662		dev_err(&client->dev, "regmap initialization failed\n");
663		return PTR_ERR(data->regmap);
664	}
665
666	ret = pm_runtime_set_active(&client->dev);
667	if (ret)
668		return ret;
669
670	ret = chip->calibration(data);
671	if (ret)
672		return ret;
673
674	ret = iio_trigger_register(trig);
675	if (ret) {
676		dev_err(&client->dev, "failed to register trigger\n");
677		return ret;
678	}
679
680	ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
681		&atlas_trigger_handler, &atlas_buffer_setup_ops);
682	if (ret) {
683		dev_err(&client->dev, "cannot setup iio trigger\n");
684		goto unregister_trigger;
685	}
686
687	init_irq_work(&data->work, atlas_work_handler);
688
689	if (client->irq > 0) {
690		/* interrupt pin toggles on new conversion */
691		ret = devm_request_threaded_irq(&client->dev, client->irq,
692				NULL, atlas_interrupt_handler,
693				IRQF_TRIGGER_RISING |
694				IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
695				"atlas_irq",
696				indio_dev);
697
698		if (ret)
699			dev_warn(&client->dev,
700				"request irq (%d) failed\n", client->irq);
701		else
702			data->interrupt_enabled = 1;
703	}
704
705	ret = atlas_set_powermode(data, 1);
706	if (ret) {
707		dev_err(&client->dev, "cannot power device on");
708		goto unregister_buffer;
709	}
710
711	pm_runtime_enable(&client->dev);
712	pm_runtime_set_autosuspend_delay(&client->dev, 2500);
713	pm_runtime_use_autosuspend(&client->dev);
714
715	ret = iio_device_register(indio_dev);
716	if (ret) {
717		dev_err(&client->dev, "unable to register device\n");
718		goto unregister_pm;
719	}
720
721	return 0;
722
723unregister_pm:
724	pm_runtime_disable(&client->dev);
725	atlas_set_powermode(data, 0);
726
727unregister_buffer:
728	iio_triggered_buffer_cleanup(indio_dev);
729
730unregister_trigger:
731	iio_trigger_unregister(data->trig);
732
733	return ret;
734}
735
736static int atlas_remove(struct i2c_client *client)
737{
738	struct iio_dev *indio_dev = i2c_get_clientdata(client);
739	struct atlas_data *data = iio_priv(indio_dev);
740
741	iio_device_unregister(indio_dev);
742	iio_triggered_buffer_cleanup(indio_dev);
743	iio_trigger_unregister(data->trig);
744
745	pm_runtime_disable(&client->dev);
746	pm_runtime_set_suspended(&client->dev);
747	pm_runtime_put_noidle(&client->dev);
748
749	return atlas_set_powermode(data, 0);
750}
751
752#ifdef CONFIG_PM
753static int atlas_runtime_suspend(struct device *dev)
754{
755	struct atlas_data *data =
756		     iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
757
758	return atlas_set_powermode(data, 0);
759}
760
761static int atlas_runtime_resume(struct device *dev)
762{
763	struct atlas_data *data =
764		     iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
765
766	return atlas_set_powermode(data, 1);
767}
768#endif
769
770static const struct dev_pm_ops atlas_pm_ops = {
771	SET_RUNTIME_PM_OPS(atlas_runtime_suspend,
772			   atlas_runtime_resume, NULL)
773};
774
775static struct i2c_driver atlas_driver = {
776	.driver = {
777		.name	= ATLAS_DRV_NAME,
778		.of_match_table	= of_match_ptr(atlas_dt_ids),
779		.pm	= &atlas_pm_ops,
780	},
781	.probe		= atlas_probe,
782	.remove		= atlas_remove,
783	.id_table	= atlas_id,
784};
785module_i2c_driver(atlas_driver);
786
787MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
788MODULE_DESCRIPTION("Atlas Scientific SM sensors");
789MODULE_LICENSE("GPL");