atlas-sensor.c 17.7 KB
Newer Older
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 10 11 12 13 14 15 16 17
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/irq.h>
#include <linux/irq_work.h>
#include <linux/i2c.h>
18
#include <linux/of_device.h>
19 20 21 22 23 24 25 26
#include <linux/regmap.h>
#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/pm_runtime.h>

27 28
#define ATLAS_REGMAP_NAME	"atlas_regmap"
#define ATLAS_DRV_NAME		"atlas"
29 30 31 32 33 34 35 36 37

#define ATLAS_REG_DEV_TYPE		0x00
#define ATLAS_REG_DEV_VERSION		0x01

#define ATLAS_REG_INT_CONTROL		0x04
#define ATLAS_REG_INT_CONTROL_EN	BIT(3)

#define ATLAS_REG_PWR_CONTROL		0x06

38 39 40 41 42
#define ATLAS_REG_PH_CALIB_STATUS	0x0d
#define ATLAS_REG_PH_CALIB_STATUS_MASK	0x07
#define ATLAS_REG_PH_CALIB_STATUS_LOW	BIT(0)
#define ATLAS_REG_PH_CALIB_STATUS_MID	BIT(1)
#define ATLAS_REG_PH_CALIB_STATUS_HIGH	BIT(2)
43

44 45 46 47 48 49 50
#define ATLAS_REG_EC_CALIB_STATUS		0x0f
#define ATLAS_REG_EC_CALIB_STATUS_MASK		0x0f
#define ATLAS_REG_EC_CALIB_STATUS_DRY		BIT(0)
#define ATLAS_REG_EC_CALIB_STATUS_SINGLE	BIT(1)
#define ATLAS_REG_EC_CALIB_STATUS_LOW		BIT(2)
#define ATLAS_REG_EC_CALIB_STATUS_HIGH		BIT(3)

51 52 53 54 55
#define ATLAS_REG_DO_CALIB_STATUS		0x09
#define ATLAS_REG_DO_CALIB_STATUS_MASK		0x03
#define ATLAS_REG_DO_CALIB_STATUS_PRESSURE	BIT(0)
#define ATLAS_REG_DO_CALIB_STATUS_DO		BIT(1)

56
#define ATLAS_REG_PH_TEMP_DATA		0x0e
57 58
#define ATLAS_REG_PH_DATA		0x16

59 60 61 62 63 64
#define ATLAS_REG_EC_PROBE		0x08
#define ATLAS_REG_EC_TEMP_DATA		0x10
#define ATLAS_REG_EC_DATA		0x18
#define ATLAS_REG_TDS_DATA		0x1c
#define ATLAS_REG_PSS_DATA		0x20

65 66 67
#define ATLAS_REG_ORP_CALIB_STATUS	0x0d
#define ATLAS_REG_ORP_DATA		0x0e

68 69 70
#define ATLAS_REG_DO_TEMP_DATA		0x12
#define ATLAS_REG_DO_DATA		0x22

71 72 73
#define ATLAS_PH_INT_TIME_IN_MS		450
#define ATLAS_EC_INT_TIME_IN_MS		650
#define ATLAS_ORP_INT_TIME_IN_MS	450
74
#define ATLAS_DO_INT_TIME_IN_MS		450
75

76 77
enum {
	ATLAS_PH_SM,
78
	ATLAS_EC_SM,
79
	ATLAS_ORP_SM,
80
	ATLAS_DO_SM,
81 82
};

83 84 85
struct atlas_data {
	struct i2c_client *client;
	struct iio_trigger *trig;
86
	struct atlas_device *chip;
87 88
	struct regmap *regmap;
	struct irq_work work;
89
	unsigned int interrupt_enabled;
90

91
	__be32 buffer[6]; /* 96-bit data + 32-bit pad + 64-bit timestamp */
92 93 94 95 96 97 98 99
};

static const struct regmap_config atlas_regmap_config = {
	.name = ATLAS_REGMAP_NAME,
	.reg_bits = 8,
	.val_bits = 8,
};

100 101 102 103 104 105 106 107 108 109
static int atlas_buffer_num_channels(const struct iio_chan_spec *spec)
{
	int idx = 0;

	for (; spec->type != IIO_TIMESTAMP; spec++)
		idx++;

	return idx;
};

110
static const struct iio_chan_spec atlas_ph_channels[] = {
111 112
	{
		.type = IIO_PH,
113
		.address = ATLAS_REG_PH_DATA,
114 115 116 117 118 119 120 121 122 123 124 125 126
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
		.scan_index = 0,
		.scan_type = {
			.sign = 'u',
			.realbits = 32,
			.storagebits = 32,
			.endianness = IIO_BE,
		},
	},
	IIO_CHAN_SOFT_TIMESTAMP(1),
	{
		.type = IIO_TEMP,
127
		.address = ATLAS_REG_PH_TEMP_DATA,
128 129 130 131 132 133 134
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
		.output = 1,
		.scan_index = -1
	},
};

135
#define ATLAS_CONCENTRATION_CHANNEL(_idx, _addr) \
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
	{\
		.type = IIO_CONCENTRATION, \
		.indexed = 1, \
		.channel = _idx, \
		.address = _addr, \
		.info_mask_separate = \
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), \
		.scan_index = _idx + 1, \
		.scan_type = { \
			.sign = 'u', \
			.realbits = 32, \
			.storagebits = 32, \
			.endianness = IIO_BE, \
		}, \
	}

static const struct iio_chan_spec atlas_ec_channels[] = {
	{
		.type = IIO_ELECTRICALCONDUCTIVITY,
		.address = ATLAS_REG_EC_DATA,
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
		.scan_index = 0,
		.scan_type = {
			.sign = 'u',
			.realbits = 32,
			.storagebits = 32,
			.endianness = IIO_BE,
		},
	},
166 167
	ATLAS_CONCENTRATION_CHANNEL(0, ATLAS_REG_TDS_DATA),
	ATLAS_CONCENTRATION_CHANNEL(1, ATLAS_REG_PSS_DATA),
168 169 170 171 172 173 174 175 176 177 178
	IIO_CHAN_SOFT_TIMESTAMP(3),
	{
		.type = IIO_TEMP,
		.address = ATLAS_REG_EC_TEMP_DATA,
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
		.output = 1,
		.scan_index = -1
	},
};

179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
static const struct iio_chan_spec atlas_orp_channels[] = {
	{
		.type = IIO_VOLTAGE,
		.address = ATLAS_REG_ORP_DATA,
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
		.scan_index = 0,
		.scan_type = {
			.sign = 's',
			.realbits = 32,
			.storagebits = 32,
			.endianness = IIO_BE,
		},
	},
	IIO_CHAN_SOFT_TIMESTAMP(1),
};

196 197 198 199 200 201 202 203 204 205 206 207 208
static const struct iio_chan_spec atlas_do_channels[] = {
	ATLAS_CONCENTRATION_CHANNEL(0, ATLAS_REG_DO_DATA),
	IIO_CHAN_SOFT_TIMESTAMP(1),
	{
		.type = IIO_TEMP,
		.address = ATLAS_REG_DO_TEMP_DATA,
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
		.output = 1,
		.scan_index = -1
	},
};

209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235
static int atlas_check_ph_calibration(struct atlas_data *data)
{
	struct device *dev = &data->client->dev;
	int ret;
	unsigned int val;

	ret = regmap_read(data->regmap, ATLAS_REG_PH_CALIB_STATUS, &val);
	if (ret)
		return ret;

	if (!(val & ATLAS_REG_PH_CALIB_STATUS_MASK)) {
		dev_warn(dev, "device has not been calibrated\n");
		return 0;
	}

	if (!(val & ATLAS_REG_PH_CALIB_STATUS_LOW))
		dev_warn(dev, "device missing low point calibration\n");

	if (!(val & ATLAS_REG_PH_CALIB_STATUS_MID))
		dev_warn(dev, "device missing mid point calibration\n");

	if (!(val & ATLAS_REG_PH_CALIB_STATUS_HIGH))
		dev_warn(dev, "device missing high point calibration\n");

	return 0;
}

236 237 238 239 240
static int atlas_check_ec_calibration(struct atlas_data *data)
{
	struct device *dev = &data->client->dev;
	int ret;
	unsigned int val;
241
	__be16	rval;
242

243
	ret = regmap_bulk_read(data->regmap, ATLAS_REG_EC_PROBE, &rval, 2);
244 245 246
	if (ret)
		return ret;

247 248
	val = be16_to_cpu(rval);
	dev_info(dev, "probe set to K = %d.%.2d", val / 100, val % 100);
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274

	ret = regmap_read(data->regmap, ATLAS_REG_EC_CALIB_STATUS, &val);
	if (ret)
		return ret;

	if (!(val & ATLAS_REG_EC_CALIB_STATUS_MASK)) {
		dev_warn(dev, "device has not been calibrated\n");
		return 0;
	}

	if (!(val & ATLAS_REG_EC_CALIB_STATUS_DRY))
		dev_warn(dev, "device missing dry point calibration\n");

	if (val & ATLAS_REG_EC_CALIB_STATUS_SINGLE) {
		dev_warn(dev, "device using single point calibration\n");
	} else {
		if (!(val & ATLAS_REG_EC_CALIB_STATUS_LOW))
			dev_warn(dev, "device missing low point calibration\n");

		if (!(val & ATLAS_REG_EC_CALIB_STATUS_HIGH))
			dev_warn(dev, "device missing high point calibration\n");
	}

	return 0;
}

275 276 277 278 279 280 281 282 283 284 285 286 287 288
static int atlas_check_orp_calibration(struct atlas_data *data)
{
	struct device *dev = &data->client->dev;
	int ret;
	unsigned int val;

	ret = regmap_read(data->regmap, ATLAS_REG_ORP_CALIB_STATUS, &val);
	if (ret)
		return ret;

	if (!val)
		dev_warn(dev, "device has not been calibrated\n");

	return 0;
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
}

static int atlas_check_do_calibration(struct atlas_data *data)
{
	struct device *dev = &data->client->dev;
	int ret;
	unsigned int val;

	ret = regmap_read(data->regmap, ATLAS_REG_DO_CALIB_STATUS, &val);
	if (ret)
		return ret;

	if (!(val & ATLAS_REG_DO_CALIB_STATUS_MASK)) {
		dev_warn(dev, "device has not been calibrated\n");
		return 0;
	}

	if (!(val & ATLAS_REG_DO_CALIB_STATUS_PRESSURE))
		dev_warn(dev, "device missing atmospheric pressure calibration\n");

	if (!(val & ATLAS_REG_DO_CALIB_STATUS_DO))
		dev_warn(dev, "device missing dissolved oxygen calibration\n");

	return 0;
}
314

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
struct atlas_device {
	const struct iio_chan_spec *channels;
	int num_channels;
	int data_reg;

	int (*calibration)(struct atlas_data *data);
	int delay;
};

static struct atlas_device atlas_devices[] = {
	[ATLAS_PH_SM] = {
				.channels = atlas_ph_channels,
				.num_channels = 3,
				.data_reg = ATLAS_REG_PH_DATA,
				.calibration = &atlas_check_ph_calibration,
330
				.delay = ATLAS_PH_INT_TIME_IN_MS,
331
	},
332 333 334 335 336
	[ATLAS_EC_SM] = {
				.channels = atlas_ec_channels,
				.num_channels = 5,
				.data_reg = ATLAS_REG_EC_DATA,
				.calibration = &atlas_check_ec_calibration,
337
				.delay = ATLAS_EC_INT_TIME_IN_MS,
338
	},
339 340 341 342 343
	[ATLAS_ORP_SM] = {
				.channels = atlas_orp_channels,
				.num_channels = 2,
				.data_reg = ATLAS_REG_ORP_DATA,
				.calibration = &atlas_check_orp_calibration,
344
				.delay = ATLAS_ORP_INT_TIME_IN_MS,
345
	},
346 347 348 349 350 351 352
	[ATLAS_DO_SM] = {
				.channels = atlas_do_channels,
				.num_channels = 3,
				.data_reg = ATLAS_REG_DO_DATA,
				.calibration = &atlas_check_do_calibration,
				.delay = ATLAS_DO_INT_TIME_IN_MS,
	},
353 354
};

355 356 357 358 359 360 361
static int atlas_set_powermode(struct atlas_data *data, int on)
{
	return regmap_write(data->regmap, ATLAS_REG_PWR_CONTROL, on);
}

static int atlas_set_interrupt(struct atlas_data *data, bool state)
{
362 363 364
	if (!data->interrupt_enabled)
		return 0;

365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
	return regmap_update_bits(data->regmap, ATLAS_REG_INT_CONTROL,
				  ATLAS_REG_INT_CONTROL_EN,
				  state ? ATLAS_REG_INT_CONTROL_EN : 0);
}

static int atlas_buffer_postenable(struct iio_dev *indio_dev)
{
	struct atlas_data *data = iio_priv(indio_dev);
	int ret;

	ret = iio_triggered_buffer_postenable(indio_dev);
	if (ret)
		return ret;

	ret = pm_runtime_get_sync(&data->client->dev);
	if (ret < 0) {
		pm_runtime_put_noidle(&data->client->dev);
		return ret;
	}

	return atlas_set_interrupt(data, true);
}

static int atlas_buffer_predisable(struct iio_dev *indio_dev)
{
	struct atlas_data *data = iio_priv(indio_dev);
	int ret;

393
	ret = atlas_set_interrupt(data, false);
394 395 396
	if (ret)
		return ret;

397 398
	pm_runtime_mark_last_busy(&data->client->dev);
	ret = pm_runtime_put_autosuspend(&data->client->dev);
399 400 401
	if (ret)
		return ret;

402
	return iio_triggered_buffer_predisable(indio_dev);
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
}

static const struct iio_trigger_ops atlas_interrupt_trigger_ops = {
};

static const struct iio_buffer_setup_ops atlas_buffer_setup_ops = {
	.postenable = atlas_buffer_postenable,
	.predisable = atlas_buffer_predisable,
};

static void atlas_work_handler(struct irq_work *work)
{
	struct atlas_data *data = container_of(work, struct atlas_data, work);

	iio_trigger_poll(data->trig);
}

static irqreturn_t atlas_trigger_handler(int irq, void *private)
{
	struct iio_poll_func *pf = private;
	struct iio_dev *indio_dev = pf->indio_dev;
	struct atlas_data *data = iio_priv(indio_dev);
425
	int channels = atlas_buffer_num_channels(data->chip->channels);
426 427
	int ret;

428 429
	ret = regmap_bulk_read(data->regmap, data->chip->data_reg,
			      (u8 *) &data->buffer,
430
			      sizeof(__be32) * channels);
431

432
	if (!ret)
433
		iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
434
				iio_get_time_ns(indio_dev));
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450

	iio_trigger_notify_done(indio_dev->trig);

	return IRQ_HANDLED;
}

static irqreturn_t atlas_interrupt_handler(int irq, void *private)
{
	struct iio_dev *indio_dev = private;
	struct atlas_data *data = iio_priv(indio_dev);

	irq_work_queue(&data->work);

	return IRQ_HANDLED;
}

451
static int atlas_read_measurement(struct atlas_data *data, int reg, __be32 *val)
452 453 454 455 456 457 458 459 460 461 462 463
{
	struct device *dev = &data->client->dev;
	int suspended = pm_runtime_suspended(dev);
	int ret;

	ret = pm_runtime_get_sync(dev);
	if (ret < 0) {
		pm_runtime_put_noidle(dev);
		return ret;
	}

	if (suspended)
464
		msleep(data->chip->delay);
465

466
	ret = regmap_bulk_read(data->regmap, reg, (u8 *) val, sizeof(*val));
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490

	pm_runtime_mark_last_busy(dev);
	pm_runtime_put_autosuspend(dev);

	return ret;
}

static int atlas_read_raw(struct iio_dev *indio_dev,
			  struct iio_chan_spec const *chan,
			  int *val, int *val2, long mask)
{
	struct atlas_data *data = iio_priv(indio_dev);

	switch (mask) {
	case IIO_CHAN_INFO_RAW: {
		int ret;
		__be32 reg;

		switch (chan->type) {
		case IIO_TEMP:
			ret = regmap_bulk_read(data->regmap, chan->address,
					      (u8 *) &reg, sizeof(reg));
			break;
		case IIO_PH:
491 492
		case IIO_CONCENTRATION:
		case IIO_ELECTRICALCONDUCTIVITY:
493
		case IIO_VOLTAGE:
494 495 496
			ret = iio_device_claim_direct_mode(indio_dev);
			if (ret)
				return ret;
497

498
			ret = atlas_read_measurement(data, chan->address, &reg);
499

500
			iio_device_release_direct_mode(indio_dev);
501 502 503 504 505 506 507 508 509 510 511 512 513 514
			break;
		default:
			ret = -EINVAL;
		}

		if (!ret) {
			*val = be32_to_cpu(reg);
			ret = IIO_VAL_INT;
		}
		return ret;
	}
	case IIO_CHAN_INFO_SCALE:
		switch (chan->type) {
		case IIO_TEMP:
515 516
			*val = 10;
			return IIO_VAL_INT;
517 518 519 520
		case IIO_PH:
			*val = 1; /* 0.001 */
			*val2 = 1000;
			break;
521 522
		case IIO_ELECTRICALCONDUCTIVITY:
			*val = 1; /* 0.00001 */
523
			*val2 = 100000;
524 525 526 527 528
			break;
		case IIO_CONCENTRATION:
			*val = 0; /* 0.000000001 */
			*val2 = 1000;
			return IIO_VAL_INT_PLUS_NANO;
529 530 531 532
		case IIO_VOLTAGE:
			*val = 1; /* 0.1 */
			*val2 = 10;
			break;
533 534 535 536 537 538 539 540 541 542 543 544 545 546
		default:
			return -EINVAL;
		}
		return IIO_VAL_FRACTIONAL;
	}

	return -EINVAL;
}

static int atlas_write_raw(struct iio_dev *indio_dev,
			   struct iio_chan_spec const *chan,
			   int val, int val2, long mask)
{
	struct atlas_data *data = iio_priv(indio_dev);
547
	__be32 reg = cpu_to_be32(val / 10);
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563

	if (val2 != 0 || val < 0 || val > 20000)
		return -EINVAL;

	if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_TEMP)
		return -EINVAL;

	return regmap_bulk_write(data->regmap, chan->address,
				 &reg, sizeof(reg));
}

static const struct iio_info atlas_info = {
	.read_raw = atlas_read_raw,
	.write_raw = atlas_write_raw,
};

564 565
static const struct i2c_device_id atlas_id[] = {
	{ "atlas-ph-sm", ATLAS_PH_SM},
566
	{ "atlas-ec-sm", ATLAS_EC_SM},
567
	{ "atlas-orp-sm", ATLAS_ORP_SM},
568
	{ "atlas-do-sm", ATLAS_DO_SM},
569 570 571
	{}
};
MODULE_DEVICE_TABLE(i2c, atlas_id);
572

573 574
static const struct of_device_id atlas_dt_ids[] = {
	{ .compatible = "atlas,ph-sm", .data = (void *)ATLAS_PH_SM, },
575
	{ .compatible = "atlas,ec-sm", .data = (void *)ATLAS_EC_SM, },
576
	{ .compatible = "atlas,orp-sm", .data = (void *)ATLAS_ORP_SM, },
577
	{ .compatible = "atlas,do-sm", .data = (void *)ATLAS_DO_SM, },
578
	{ }
579
};
580
MODULE_DEVICE_TABLE(of, atlas_dt_ids);
581 582 583 584 585

static int atlas_probe(struct i2c_client *client,
		       const struct i2c_device_id *id)
{
	struct atlas_data *data;
586 587
	struct atlas_device *chip;
	const struct of_device_id *of_id;
588 589 590 591 592 593 594 595
	struct iio_trigger *trig;
	struct iio_dev *indio_dev;
	int ret;

	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
	if (!indio_dev)
		return -ENOMEM;

596 597 598 599 600 601
	of_id = of_match_device(atlas_dt_ids, &client->dev);
	if (!of_id)
		chip = &atlas_devices[id->driver_data];
	else
		chip = &atlas_devices[(unsigned long)of_id->data];

602 603
	indio_dev->info = &atlas_info;
	indio_dev->name = ATLAS_DRV_NAME;
604 605
	indio_dev->channels = chip->channels;
	indio_dev->num_channels = chip->num_channels;
606 607 608 609 610 611 612 613 614 615 616 617
	indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE;
	indio_dev->dev.parent = &client->dev;

	trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
				      indio_dev->name, indio_dev->id);

	if (!trig)
		return -ENOMEM;

	data = iio_priv(indio_dev);
	data->client = client;
	data->trig = trig;
618
	data->chip = chip;
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
	trig->dev.parent = indio_dev->dev.parent;
	trig->ops = &atlas_interrupt_trigger_ops;
	iio_trigger_set_drvdata(trig, indio_dev);

	i2c_set_clientdata(client, indio_dev);

	data->regmap = devm_regmap_init_i2c(client, &atlas_regmap_config);
	if (IS_ERR(data->regmap)) {
		dev_err(&client->dev, "regmap initialization failed\n");
		return PTR_ERR(data->regmap);
	}

	ret = pm_runtime_set_active(&client->dev);
	if (ret)
		return ret;

635
	ret = chip->calibration(data);
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
	if (ret)
		return ret;

	ret = iio_trigger_register(trig);
	if (ret) {
		dev_err(&client->dev, "failed to register trigger\n");
		return ret;
	}

	ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
		&atlas_trigger_handler, &atlas_buffer_setup_ops);
	if (ret) {
		dev_err(&client->dev, "cannot setup iio trigger\n");
		goto unregister_trigger;
	}

	init_irq_work(&data->work, atlas_work_handler);

654 655 656 657 658 659 660 661 662 663 664 665 666 667
	if (client->irq > 0) {
		/* interrupt pin toggles on new conversion */
		ret = devm_request_threaded_irq(&client->dev, client->irq,
				NULL, atlas_interrupt_handler,
				IRQF_TRIGGER_RISING |
				IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
				"atlas_irq",
				indio_dev);

		if (ret)
			dev_warn(&client->dev,
				"request irq (%d) failed\n", client->irq);
		else
			data->interrupt_enabled = 1;
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
	}

	ret = atlas_set_powermode(data, 1);
	if (ret) {
		dev_err(&client->dev, "cannot power device on");
		goto unregister_buffer;
	}

	pm_runtime_enable(&client->dev);
	pm_runtime_set_autosuspend_delay(&client->dev, 2500);
	pm_runtime_use_autosuspend(&client->dev);

	ret = iio_device_register(indio_dev);
	if (ret) {
		dev_err(&client->dev, "unable to register device\n");
		goto unregister_pm;
	}

	return 0;

unregister_pm:
	pm_runtime_disable(&client->dev);
	atlas_set_powermode(data, 0);

unregister_buffer:
	iio_triggered_buffer_cleanup(indio_dev);

unregister_trigger:
	iio_trigger_unregister(data->trig);

	return ret;
}

static int atlas_remove(struct i2c_client *client)
{
	struct iio_dev *indio_dev = i2c_get_clientdata(client);
	struct atlas_data *data = iio_priv(indio_dev);

	iio_device_unregister(indio_dev);
	iio_triggered_buffer_cleanup(indio_dev);
	iio_trigger_unregister(data->trig);

	pm_runtime_disable(&client->dev);
	pm_runtime_set_suspended(&client->dev);
	pm_runtime_put_noidle(&client->dev);

	return atlas_set_powermode(data, 0);
}

#ifdef CONFIG_PM
static int atlas_runtime_suspend(struct device *dev)
{
	struct atlas_data *data =
		     iio_priv(i2c_get_clientdata(to_i2c_client(dev)));

	return atlas_set_powermode(data, 0);
}

static int atlas_runtime_resume(struct device *dev)
{
	struct atlas_data *data =
		     iio_priv(i2c_get_clientdata(to_i2c_client(dev)));

	return atlas_set_powermode(data, 1);
}
#endif

static const struct dev_pm_ops atlas_pm_ops = {
	SET_RUNTIME_PM_OPS(atlas_runtime_suspend,
			   atlas_runtime_resume, NULL)
};

static struct i2c_driver atlas_driver = {
	.driver = {
		.name	= ATLAS_DRV_NAME,
		.of_match_table	= of_match_ptr(atlas_dt_ids),
		.pm	= &atlas_pm_ops,
	},
	.probe		= atlas_probe,
	.remove		= atlas_remove,
	.id_table	= atlas_id,
};
module_i2c_driver(atlas_driver);

752
MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
753
MODULE_DESCRIPTION("Atlas Scientific SM sensors");
754
MODULE_LICENSE("GPL");