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 
79 enum {
80 	ATLAS_PH_SM,
81 	ATLAS_EC_SM,
82 	ATLAS_ORP_SM,
83 	ATLAS_DO_SM,
84 	ATLAS_RTD_SM,
85 };
86 
87 struct 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 
98 static const struct regmap_config atlas_regmap_config = {
99 	.name = ATLAS_REGMAP_NAME,
100 	.reg_bits = 8,
101 	.val_bits = 8,
102 };
103 
104 static 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 
114 static 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 
156 static 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 
183 static 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 
200 static 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 
225 static 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 
241 static 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 
268 static 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 
307 static 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 
323 static 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 
347 struct 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 
356 static 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 
393 static int atlas_set_powermode(struct atlas_data *data, int on)
394 {
395 	return regmap_write(data->regmap, ATLAS_REG_PWR_CONTROL, on);
396 }
397 
398 static 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 
408 static 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 
422 static 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 
439 static const struct iio_trigger_ops atlas_interrupt_trigger_ops = {
440 };
441 
442 static const struct iio_buffer_setup_ops atlas_buffer_setup_ops = {
443 	.postenable = atlas_buffer_postenable,
444 	.predisable = atlas_buffer_predisable,
445 };
446 
447 static 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 
454 static 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 
474 static 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 
484 static 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 
507 static 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 
576 static 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 
593 static const struct iio_info atlas_info = {
594 	.read_raw = atlas_read_raw,
595 	.write_raw = atlas_write_raw,
596 };
597 
598 static 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 };
606 MODULE_DEVICE_TABLE(i2c, atlas_id);
607 
608 static 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 };
616 MODULE_DEVICE_TABLE(of, atlas_dt_ids);
617 
618 static 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 
723 unregister_pm:
724 	pm_runtime_disable(&client->dev);
725 	atlas_set_powermode(data, 0);
726 
727 unregister_buffer:
728 	iio_triggered_buffer_cleanup(indio_dev);
729 
730 unregister_trigger:
731 	iio_trigger_unregister(data->trig);
732 
733 	return ret;
734 }
735 
736 static 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
753 static 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 
761 static 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 
770 static const struct dev_pm_ops atlas_pm_ops = {
771 	SET_RUNTIME_PM_OPS(atlas_runtime_suspend,
772 			   atlas_runtime_resume, NULL)
773 };
774 
775 static 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 };
785 module_i2c_driver(atlas_driver);
786 
787 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
788 MODULE_DESCRIPTION("Atlas Scientific SM sensors");
789 MODULE_LICENSE("GPL");
790