atlas-sensor.c

  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
 78enum {
 79	ATLAS_PH_SM,
 80	ATLAS_EC_SM,
 81	ATLAS_ORP_SM,
 82	ATLAS_DO_SM,
 83	ATLAS_RTD_SM,
 84};
 85
 86struct 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
 97static const struct regmap_config atlas_regmap_config = {
 98	.name = "atlas_regmap",
 99	.reg_bits = 8,
100	.val_bits = 8,
101};
102
103static 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
113static 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
155static 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
182static 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
199static 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
224static 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
240static 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
267static 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
306static 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
322static 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
346struct 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
355static 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
392static int atlas_set_powermode(struct atlas_data *data, int on)
393{
394	return regmap_write(data->regmap, ATLAS_REG_PWR_CONTROL, on);
395}
396
397static 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
407static 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
419static 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
435static const struct iio_buffer_setup_ops atlas_buffer_setup_ops = {
436	.postenable = atlas_buffer_postenable,
437	.predisable = atlas_buffer_predisable,
438};
439
440static 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
447static 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
468static 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
478static 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
498static 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					       &reg, 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, &reg);
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
566static 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				 &reg, sizeof(reg));
581}
582
583static const struct iio_info atlas_info = {
584	.read_raw = atlas_read_raw,
585	.write_raw = atlas_write_raw,
586};
587
588static 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};
596MODULE_DEVICE_TABLE(i2c, atlas_id);
597
598static 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};
606MODULE_DEVICE_TABLE(of, atlas_dt_ids);
607
608static 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
705unregister_pm:
706	pm_runtime_disable(&client->dev);
707	atlas_set_powermode(data, 0);
708
709unregister_buffer:
710	iio_triggered_buffer_cleanup(indio_dev);
711
712unregister_trigger:
713	iio_trigger_unregister(data->trig);
714
715	return ret;
716}
717
718static 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
737static 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
745static 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
753static const struct dev_pm_ops atlas_pm_ops = {
754	RUNTIME_PM_OPS(atlas_runtime_suspend, atlas_runtime_resume, NULL)
755};
756
757static 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};
767module_i2c_driver(atlas_driver);
768
769MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
770MODULE_DESCRIPTION("Atlas Scientific SM sensors");
771MODULE_LICENSE("GPL");