drivers/iio/accel/kxsd9.c - third_party/linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * kxsd9.c	simple support for the Kionix KXSD9 3D
  *		accelerometer.
  *
  * Copyright (c) 2008-2009 Jonathan Cameron <jic23@kernel.org>
  *
  * The i2c interface is very similar, so shouldn't be a problem once
  * I have a suitable wire made up.
  *
  * TODO:	Support the motion detector
  */

 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/sysfs.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/regmap.h>
 #include <linux/bitops.h>
 #include <linux/delay.h>
 #include <linux/regulator/consumer.h>
 #include <linux/pm_runtime.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include <linux/iio/triggered_buffer.h>
 #include <linux/iio/trigger_consumer.h>

 #include "kxsd9.h"

 #define KXSD9_REG_X		0x00
 #define KXSD9_REG_Y		0x02
 #define KXSD9_REG_Z		0x04
 #define KXSD9_REG_AUX		0x06
 #define KXSD9_REG_RESET		0x0a
 #define KXSD9_REG_CTRL_C	0x0c

 #define KXSD9_CTRL_C_FS_MASK	0x03
 #define KXSD9_CTRL_C_FS_8G	0x00
 #define KXSD9_CTRL_C_FS_6G	0x01
 #define KXSD9_CTRL_C_FS_4G	0x02
 #define KXSD9_CTRL_C_FS_2G	0x03
 #define KXSD9_CTRL_C_MOT_LAT	BIT(3)
 #define KXSD9_CTRL_C_MOT_LEV	BIT(4)
 #define KXSD9_CTRL_C_LP_MASK	0xe0
 #define KXSD9_CTRL_C_LP_NONE	0x00
 #define KXSD9_CTRL_C_LP_2000HZC	BIT(5)
 #define KXSD9_CTRL_C_LP_2000HZB	BIT(6)
 #define KXSD9_CTRL_C_LP_2000HZA	(BIT(5)|BIT(6))
 #define KXSD9_CTRL_C_LP_1000HZ	BIT(7)
 #define KXSD9_CTRL_C_LP_500HZ	(BIT(7)|BIT(5))
 #define KXSD9_CTRL_C_LP_100HZ	(BIT(7)|BIT(6))
 #define KXSD9_CTRL_C_LP_50HZ	(BIT(7)|BIT(6)|BIT(5))

 #define KXSD9_REG_CTRL_B	0x0d

 #define KXSD9_CTRL_B_CLK_HLD	BIT(7)
 #define KXSD9_CTRL_B_ENABLE	BIT(6)
 #define KXSD9_CTRL_B_ST		BIT(5) /* Self-test */

 #define KXSD9_REG_CTRL_A	0x0e

 /**
  * struct kxsd9_state - device related storage
  * @dev: pointer to the parent device
  * @map: regmap to the device
  * @orientation: mounting matrix, flipped axis etc
  * @regs: regulators for this device, VDD and IOVDD
  * @scale: the current scaling setting
  */
 struct kxsd9_state {
 	struct device *dev;
 	struct regmap *map;
 	struct iio_mount_matrix orientation;
 	struct regulator_bulk_data regs[2];
 	u8 scale;
 };

 #define KXSD9_SCALE_2G "0.011978"
 #define KXSD9_SCALE_4G "0.023927"
 #define KXSD9_SCALE_6G "0.035934"
 #define KXSD9_SCALE_8G "0.047853"

 /* reverse order */
 static const int kxsd9_micro_scales[4] = { 47853, 35934, 23927, 11978 };

 #define KXSD9_ZERO_G_OFFSET -2048

 /*
  * Regulator names
  */
 static const char kxsd9_reg_vdd[] = "vdd";
 static const char kxsd9_reg_iovdd[] = "iovdd";

 static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro)
 {
 	int ret, i;
 	struct kxsd9_state *st = iio_priv(indio_dev);
 	bool foundit = false;

 	for (i = 0; i < 4; i++)
 		if (micro == kxsd9_micro_scales[i]) {
 			foundit = true;
 			break;
 		}
 	if (!foundit)
 		return -EINVAL;

 	ret = regmap_update_bits(st->map,
 				 KXSD9_REG_CTRL_C,
 				 KXSD9_CTRL_C_FS_MASK,
 				 i);
 	if (ret < 0)
 		goto error_ret;

 	/* Cached scale when the sensor is powered down */
 	st->scale = i;

 error_ret:
 	return ret;
 }

 static IIO_CONST_ATTR(accel_scale_available,
 		KXSD9_SCALE_2G " "
 		KXSD9_SCALE_4G " "
 		KXSD9_SCALE_6G " "
 		KXSD9_SCALE_8G);

 static struct attribute *kxsd9_attributes[] = {
 	&iio_const_attr_accel_scale_available.dev_attr.attr,
 	NULL,
 };

 static int kxsd9_write_raw(struct iio_dev *indio_dev,
 			   struct iio_chan_spec const *chan,
 			   int val,
 			   int val2,
 			   long mask)
 {
 	int ret = -EINVAL;
 	struct kxsd9_state *st = iio_priv(indio_dev);

 	pm_runtime_get_sync(st->dev);

 	if (mask == IIO_CHAN_INFO_SCALE) {
 		/* Check no integer component */
 		if (val)
 			return -EINVAL;
 		ret = kxsd9_write_scale(indio_dev, val2);
 	}

 	pm_runtime_mark_last_busy(st->dev);
 	pm_runtime_put_autosuspend(st->dev);

 	return ret;
 }

 static int kxsd9_read_raw(struct iio_dev *indio_dev,
 			  struct iio_chan_spec const *chan,
 			  int *val, int *val2, long mask)
 {
 	int ret = -EINVAL;
 	struct kxsd9_state *st = iio_priv(indio_dev);
 	unsigned int regval;
 	__be16 raw_val;
 	u16 nval;

 	pm_runtime_get_sync(st->dev);

 	switch (mask) {
 	case IIO_CHAN_INFO_RAW:
 		ret = regmap_bulk_read(st->map, chan->address, &raw_val,
 				       sizeof(raw_val));
 		if (ret)
 			goto error_ret;
 		nval = be16_to_cpu(raw_val);
 		/* Only 12 bits are valid */
 		nval >>= 4;
 		*val = nval;
 		ret = IIO_VAL_INT;
 		break;
 	case IIO_CHAN_INFO_OFFSET:
 		/* This has a bias of -2048 */
 		*val = KXSD9_ZERO_G_OFFSET;
 		ret = IIO_VAL_INT;
 		break;
 	case IIO_CHAN_INFO_SCALE:
 		ret = regmap_read(st->map,
 				  KXSD9_REG_CTRL_C,
 				  &regval);
 		if (ret < 0)
 			goto error_ret;
 		*val = 0;
 		*val2 = kxsd9_micro_scales[regval & KXSD9_CTRL_C_FS_MASK];
 		ret = IIO_VAL_INT_PLUS_MICRO;
 		break;
 	}

 error_ret:
 	pm_runtime_mark_last_busy(st->dev);
 	pm_runtime_put_autosuspend(st->dev);

 	return ret;
 };

 static irqreturn_t kxsd9_trigger_handler(int irq, void *p)
 {
 	const struct iio_poll_func *pf = p;
 	struct iio_dev *indio_dev = pf->indio_dev;
 	struct kxsd9_state *st = iio_priv(indio_dev);
 	/*
 	 * Ensure correct positioning and alignment of timestamp.
 	 * No need to zero initialize as all elements written.
 	 */
 	struct {
 		__be16 chan[4];
 		s64 ts __aligned(8);
 	} hw_values;
 	int ret;

 	ret = regmap_bulk_read(st->map,
 			       KXSD9_REG_X,
 			       hw_values.chan,
 			       sizeof(hw_values.chan));
 	if (ret) {
 		dev_err(st->dev, "error reading data: %d\n", ret);
 		goto out;
 	}

 	iio_push_to_buffers_with_timestamp(indio_dev,
 					   &hw_values,
 					   iio_get_time_ns(indio_dev));
 out:
 	iio_trigger_notify_done(indio_dev->trig);

 	return IRQ_HANDLED;
 }

 static int kxsd9_buffer_preenable(struct iio_dev *indio_dev)
 {
 	struct kxsd9_state *st = iio_priv(indio_dev);

 	pm_runtime_get_sync(st->dev);

 	return 0;
 }

 static int kxsd9_buffer_postdisable(struct iio_dev *indio_dev)
 {
 	struct kxsd9_state *st = iio_priv(indio_dev);

 	pm_runtime_mark_last_busy(st->dev);
 	pm_runtime_put_autosuspend(st->dev);

 	return 0;
 }

 static const struct iio_buffer_setup_ops kxsd9_buffer_setup_ops = {
 	.preenable = kxsd9_buffer_preenable,
 	.postenable = iio_triggered_buffer_postenable,
 	.predisable = iio_triggered_buffer_predisable,
 	.postdisable = kxsd9_buffer_postdisable,
 };

 static const struct iio_mount_matrix *
 kxsd9_get_mount_matrix(const struct iio_dev *indio_dev,
 		       const struct iio_chan_spec *chan)
 {
 	struct kxsd9_state *st = iio_priv(indio_dev);

 	return &st->orientation;
 }

 static const struct iio_chan_spec_ext_info kxsd9_ext_info[] = {
 	IIO_MOUNT_MATRIX(IIO_SHARED_BY_TYPE, kxsd9_get_mount_matrix),
 	{ },
 };

 #define KXSD9_ACCEL_CHAN(axis, index)						\
 	{								\
 		.type = IIO_ACCEL,					\
 		.modified = 1,						\
 		.channel2 = IIO_MOD_##axis,				\
 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),		\
 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |	\
 					BIT(IIO_CHAN_INFO_OFFSET),	\
 		.ext_info = kxsd9_ext_info,				\
 		.address = KXSD9_REG_##axis,				\
 		.scan_index = index,					\
 		.scan_type = {                                          \
 			.sign = 'u',					\
 			.realbits = 12,					\
 			.storagebits = 16,				\
 			.shift = 4,					\
 			.endianness = IIO_BE,				\
 		},							\
 	}

 static const struct iio_chan_spec kxsd9_channels[] = {
 	KXSD9_ACCEL_CHAN(X, 0),
 	KXSD9_ACCEL_CHAN(Y, 1),
 	KXSD9_ACCEL_CHAN(Z, 2),
 	{
 		.type = IIO_VOLTAGE,
 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 		.indexed = 1,
 		.address = KXSD9_REG_AUX,
 		.scan_index = 3,
 		.scan_type = {
 			.sign = 'u',
 			.realbits = 12,
 			.storagebits = 16,
 			.shift = 4,
 			.endianness = IIO_BE,
 		},
 	},
 	IIO_CHAN_SOFT_TIMESTAMP(4),
 };

 static const struct attribute_group kxsd9_attribute_group = {
 	.attrs = kxsd9_attributes,
 };

 static int kxsd9_power_up(struct kxsd9_state *st)
 {
 	int ret;

 	/* Enable the regulators */
 	ret = regulator_bulk_enable(ARRAY_SIZE(st->regs), st->regs);
 	if (ret) {
 		dev_err(st->dev, "Cannot enable regulators\n");
 		return ret;
 	}

 	/* Power up */
 	ret = regmap_write(st->map,
 			   KXSD9_REG_CTRL_B,
 			   KXSD9_CTRL_B_ENABLE);
 	if (ret)
 		return ret;

 	/*
 	 * Set 1000Hz LPF, 2g fullscale, motion wakeup threshold 1g,
 	 * latched wakeup
 	 */
 	ret = regmap_write(st->map,
 			   KXSD9_REG_CTRL_C,
 			   KXSD9_CTRL_C_LP_1000HZ |
 			   KXSD9_CTRL_C_MOT_LEV	|
 			   KXSD9_CTRL_C_MOT_LAT |
 			   st->scale);
 	if (ret)
 		return ret;

 	/*
 	 * Power-up time depends on the LPF setting, but typ 15.9 ms, let's
 	 * set 20 ms to allow for some slack.
 	 */
 	msleep(20);

 	return 0;
 };

 static int kxsd9_power_down(struct kxsd9_state *st)
 {
 	int ret;

 	/*
 	 * Set into low power mode - since there may be more users of the
 	 * regulators this is the first step of the power saving: it will
 	 * make sure we conserve power even if there are others users on the
 	 * regulators.
 	 */
 	ret = regmap_update_bits(st->map,
 				 KXSD9_REG_CTRL_B,
 				 KXSD9_CTRL_B_ENABLE,
 				 0);
 	if (ret)
 		return ret;

 	/* Disable the regulators */
 	ret = regulator_bulk_disable(ARRAY_SIZE(st->regs), st->regs);
 	if (ret) {
 		dev_err(st->dev, "Cannot disable regulators\n");
 		return ret;
 	}

 	return 0;
 }

 static const struct iio_info kxsd9_info = {
 	.read_raw = &kxsd9_read_raw,
 	.write_raw = &kxsd9_write_raw,
 	.attrs = &kxsd9_attribute_group,
 };

 /* Four channels apart from timestamp, scan mask = 0x0f */
 static const unsigned long kxsd9_scan_masks[] = { 0xf, 0 };

 int kxsd9_common_probe(struct device *dev,
 		       struct regmap *map,
 		       const char *name)
 {
 	struct iio_dev *indio_dev;
 	struct kxsd9_state *st;
 	int ret;

 	indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
 	if (!indio_dev)
 		return -ENOMEM;

 	st = iio_priv(indio_dev);
 	st->dev = dev;
 	st->map = map;

 	indio_dev->channels = kxsd9_channels;
 	indio_dev->num_channels = ARRAY_SIZE(kxsd9_channels);
 	indio_dev->name = name;
 	indio_dev->dev.parent = dev;
 	indio_dev->info = &kxsd9_info;
 	indio_dev->modes = INDIO_DIRECT_MODE;
 	indio_dev->available_scan_masks = kxsd9_scan_masks;

 	/* Read the mounting matrix, if present */
 	ret = iio_read_mount_matrix(dev, "mount-matrix", &st->orientation);
 	if (ret)
 		return ret;

 	/* Fetch and turn on regulators */
 	st->regs[0].supply = kxsd9_reg_vdd;
 	st->regs[1].supply = kxsd9_reg_iovdd;
 	ret = devm_regulator_bulk_get(dev,
 				      ARRAY_SIZE(st->regs),
 				      st->regs);
 	if (ret) {
 		dev_err(dev, "Cannot get regulators\n");
 		return ret;
 	}
 	/* Default scaling */
 	st->scale = KXSD9_CTRL_C_FS_2G;

 	kxsd9_power_up(st);

 	ret = iio_triggered_buffer_setup(indio_dev,
 					 iio_pollfunc_store_time,
 					 kxsd9_trigger_handler,
 					 &kxsd9_buffer_setup_ops);
 	if (ret) {
 		dev_err(dev, "triggered buffer setup failed\n");
 		goto err_power_down;
 	}

 	ret = iio_device_register(indio_dev);
 	if (ret)
 		goto err_cleanup_buffer;

 	dev_set_drvdata(dev, indio_dev);

 	/* Enable runtime PM */
 	pm_runtime_get_noresume(dev);
 	pm_runtime_set_active(dev);
 	pm_runtime_enable(dev);
 	/*
 	 * Set autosuspend to two orders of magnitude larger than the
 	 * start-up time. 20ms start-up time means 2000ms autosuspend,
 	 * i.e. 2 seconds.
 	 */
 	pm_runtime_set_autosuspend_delay(dev, 2000);
 	pm_runtime_use_autosuspend(dev);
 	pm_runtime_put(dev);

 	return 0;

 err_cleanup_buffer:
 	iio_triggered_buffer_cleanup(indio_dev);
 err_power_down:
 	kxsd9_power_down(st);

 	return ret;
 }
 EXPORT_SYMBOL(kxsd9_common_probe);

 int kxsd9_common_remove(struct device *dev)
 {
 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
 	struct kxsd9_state *st = iio_priv(indio_dev);

 	iio_triggered_buffer_cleanup(indio_dev);
 	iio_device_unregister(indio_dev);
 	pm_runtime_get_sync(dev);
 	pm_runtime_put_noidle(dev);
 	pm_runtime_disable(dev);
 	kxsd9_power_down(st);

 	return 0;
 }
 EXPORT_SYMBOL(kxsd9_common_remove);

 #ifdef CONFIG_PM
 static int kxsd9_runtime_suspend(struct device *dev)
 {
 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
 	struct kxsd9_state *st = iio_priv(indio_dev);

 	return kxsd9_power_down(st);
 }

 static int kxsd9_runtime_resume(struct device *dev)
 {
 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
 	struct kxsd9_state *st = iio_priv(indio_dev);

 	return kxsd9_power_up(st);
 }
 #endif /* CONFIG_PM */

 const struct dev_pm_ops kxsd9_dev_pm_ops = {
 	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
 				pm_runtime_force_resume)
 	SET_RUNTIME_PM_OPS(kxsd9_runtime_suspend,
 			   kxsd9_runtime_resume, NULL)
 };
 EXPORT_SYMBOL(kxsd9_dev_pm_ops);

 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
 MODULE_DESCRIPTION("Kionix KXSD9 driver");
 MODULE_LICENSE("GPL v2");
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* kxsd9.c simple support for the Kionix KXSD9 3D
	* accelerometer.
	*
	* Copyright (c) 2008-2009 Jonathan Cameron <jic23@kernel.org>
	*
	* The i2c interface is very similar, so shouldn't be a problem once
	* I have a suitable wire made up.
	*
	* TODO: Support the motion detector
	*/

	#include <linux/device.h>
	#include <linux/kernel.h>
	#include <linux/sysfs.h>
	#include <linux/slab.h>
	#include <linux/module.h>
	#include <linux/regmap.h>
	#include <linux/bitops.h>
	#include <linux/delay.h>
	#include <linux/regulator/consumer.h>
	#include <linux/pm_runtime.h>
	#include <linux/iio/iio.h>
	#include <linux/iio/sysfs.h>
	#include <linux/iio/buffer.h>
	#include <linux/iio/triggered_buffer.h>
	#include <linux/iio/trigger_consumer.h>

	#include "kxsd9.h"

	#define KXSD9_REG_X 0x00
	#define KXSD9_REG_Y 0x02
	#define KXSD9_REG_Z 0x04
	#define KXSD9_REG_AUX 0x06
	#define KXSD9_REG_RESET 0x0a
	#define KXSD9_REG_CTRL_C 0x0c

	#define KXSD9_CTRL_C_FS_MASK 0x03
	#define KXSD9_CTRL_C_FS_8G 0x00
	#define KXSD9_CTRL_C_FS_6G 0x01
	#define KXSD9_CTRL_C_FS_4G 0x02
	#define KXSD9_CTRL_C_FS_2G 0x03
	#define KXSD9_CTRL_C_MOT_LAT BIT(3)
	#define KXSD9_CTRL_C_MOT_LEV BIT(4)
	#define KXSD9_CTRL_C_LP_MASK 0xe0
	#define KXSD9_CTRL_C_LP_NONE 0x00
	#define KXSD9_CTRL_C_LP_2000HZC BIT(5)
	#define KXSD9_CTRL_C_LP_2000HZB BIT(6)
	#define KXSD9_CTRL_C_LP_2000HZA (BIT(5)\|BIT(6))
	#define KXSD9_CTRL_C_LP_1000HZ BIT(7)
	#define KXSD9_CTRL_C_LP_500HZ (BIT(7)\|BIT(5))
	#define KXSD9_CTRL_C_LP_100HZ (BIT(7)\|BIT(6))
	#define KXSD9_CTRL_C_LP_50HZ (BIT(7)\|BIT(6)\|BIT(5))

	#define KXSD9_REG_CTRL_B 0x0d

	#define KXSD9_CTRL_B_CLK_HLD BIT(7)
	#define KXSD9_CTRL_B_ENABLE BIT(6)
	#define KXSD9_CTRL_B_ST BIT(5) /* Self-test */

	#define KXSD9_REG_CTRL_A 0x0e

	/**
	* struct kxsd9_state - device related storage
	* @dev: pointer to the parent device
	* @map: regmap to the device
	* @orientation: mounting matrix, flipped axis etc
	* @regs: regulators for this device, VDD and IOVDD
	* @scale: the current scaling setting
	*/
	struct kxsd9_state {
	struct device *dev;
	struct regmap *map;
	struct iio_mount_matrix orientation;
	struct regulator_bulk_data regs[2];
	u8 scale;
	};

	#define KXSD9_SCALE_2G "0.011978"
	#define KXSD9_SCALE_4G "0.023927"
	#define KXSD9_SCALE_6G "0.035934"
	#define KXSD9_SCALE_8G "0.047853"

	/* reverse order */
	static const int kxsd9_micro_scales[4] = { 47853, 35934, 23927, 11978 };

	#define KXSD9_ZERO_G_OFFSET -2048

	/*
	* Regulator names
	*/
	static const char kxsd9_reg_vdd[] = "vdd";
	static const char kxsd9_reg_iovdd[] = "iovdd";

	static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro)
	{
	int ret, i;
	struct kxsd9_state *st = iio_priv(indio_dev);
	bool foundit = false;

	for (i = 0; i < 4; i++)
	if (micro == kxsd9_micro_scales[i]) {
	foundit = true;
	break;
	}
	if (!foundit)
	return -EINVAL;

	ret = regmap_update_bits(st->map,
	KXSD9_REG_CTRL_C,
	KXSD9_CTRL_C_FS_MASK,
	i);
	if (ret < 0)
	goto error_ret;

	/* Cached scale when the sensor is powered down */
	st->scale = i;

	error_ret:
	return ret;
	}

	static IIO_CONST_ATTR(accel_scale_available,
	KXSD9_SCALE_2G " "
	KXSD9_SCALE_4G " "
	KXSD9_SCALE_6G " "
	KXSD9_SCALE_8G);

	static struct attribute *kxsd9_attributes[] = {
	&iio_const_attr_accel_scale_available.dev_attr.attr,
	NULL,
	};

	static int kxsd9_write_raw(struct iio_dev *indio_dev,
	struct iio_chan_spec const *chan,
	int val,
	int val2,
	long mask)
	{
	int ret = -EINVAL;
	struct kxsd9_state *st = iio_priv(indio_dev);

	pm_runtime_get_sync(st->dev);

	if (mask == IIO_CHAN_INFO_SCALE) {
	/* Check no integer component */
	if (val)
	return -EINVAL;
	ret = kxsd9_write_scale(indio_dev, val2);
	}

	pm_runtime_mark_last_busy(st->dev);
	pm_runtime_put_autosuspend(st->dev);

	return ret;
	}

	static int kxsd9_read_raw(struct iio_dev *indio_dev,
	struct iio_chan_spec const *chan,
	int val, int val2, long mask)
	{
	int ret = -EINVAL;
	struct kxsd9_state *st = iio_priv(indio_dev);
	unsigned int regval;
	__be16 raw_val;
	u16 nval;

	pm_runtime_get_sync(st->dev);

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
	ret = regmap_bulk_read(st->map, chan->address, &raw_val,
	sizeof(raw_val));
	if (ret)
	goto error_ret;
	nval = be16_to_cpu(raw_val);
	/* Only 12 bits are valid */
	nval >>= 4;
	*val = nval;
	ret = IIO_VAL_INT;
	break;
	case IIO_CHAN_INFO_OFFSET:
	/* This has a bias of -2048 */
	*val = KXSD9_ZERO_G_OFFSET;
	ret = IIO_VAL_INT;
	break;
	case IIO_CHAN_INFO_SCALE:
	ret = regmap_read(st->map,
	KXSD9_REG_CTRL_C,
	&regval);
	if (ret < 0)
	goto error_ret;
	*val = 0;
	*val2 = kxsd9_micro_scales[regval & KXSD9_CTRL_C_FS_MASK];
	ret = IIO_VAL_INT_PLUS_MICRO;
	break;
	}

	error_ret:
	pm_runtime_mark_last_busy(st->dev);
	pm_runtime_put_autosuspend(st->dev);

	return ret;
	};

	static irqreturn_t kxsd9_trigger_handler(int irq, void *p)
	{
	const struct iio_poll_func *pf = p;
	struct iio_dev *indio_dev = pf->indio_dev;
	struct kxsd9_state *st = iio_priv(indio_dev);
	/*
	* Ensure correct positioning and alignment of timestamp.
	* No need to zero initialize as all elements written.
	*/
	struct {
	__be16 chan[4];
	s64 ts __aligned(8);
	} hw_values;
	int ret;

	ret = regmap_bulk_read(st->map,
	KXSD9_REG_X,
	hw_values.chan,
	sizeof(hw_values.chan));
	if (ret) {
	dev_err(st->dev, "error reading data: %d\n", ret);
	goto out;
	}

	iio_push_to_buffers_with_timestamp(indio_dev,
	&hw_values,
	iio_get_time_ns(indio_dev));
	out:
	iio_trigger_notify_done(indio_dev->trig);

	return IRQ_HANDLED;
	}

	static int kxsd9_buffer_preenable(struct iio_dev *indio_dev)
	{
	struct kxsd9_state *st = iio_priv(indio_dev);

	pm_runtime_get_sync(st->dev);

	return 0;
	}

	static int kxsd9_buffer_postdisable(struct iio_dev *indio_dev)
	{
	struct kxsd9_state *st = iio_priv(indio_dev);

	pm_runtime_mark_last_busy(st->dev);
	pm_runtime_put_autosuspend(st->dev);

	return 0;
	}

	static const struct iio_buffer_setup_ops kxsd9_buffer_setup_ops = {
	.preenable = kxsd9_buffer_preenable,
	.postenable = iio_triggered_buffer_postenable,
	.predisable = iio_triggered_buffer_predisable,
	.postdisable = kxsd9_buffer_postdisable,
	};

	static const struct iio_mount_matrix *
	kxsd9_get_mount_matrix(const struct iio_dev *indio_dev,
	const struct iio_chan_spec *chan)
	{
	struct kxsd9_state *st = iio_priv(indio_dev);

	return &st->orientation;
	}

	static const struct iio_chan_spec_ext_info kxsd9_ext_info[] = {
	IIO_MOUNT_MATRIX(IIO_SHARED_BY_TYPE, kxsd9_get_mount_matrix),
	{ },
	};

	#define KXSD9_ACCEL_CHAN(axis, index) \
	{ \
	.type = IIO_ACCEL, \
	.modified = 1, \
	.channel2 = IIO_MOD_##axis, \
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \| \
	BIT(IIO_CHAN_INFO_OFFSET), \
	.ext_info = kxsd9_ext_info, \
	.address = KXSD9_REG_##axis, \
	.scan_index = index, \
	.scan_type = { \
	.sign = 'u', \
	.realbits = 12, \
	.storagebits = 16, \
	.shift = 4, \
	.endianness = IIO_BE, \
	}, \
	}

	static const struct iio_chan_spec kxsd9_channels[] = {
	KXSD9_ACCEL_CHAN(X, 0),
	KXSD9_ACCEL_CHAN(Y, 1),
	KXSD9_ACCEL_CHAN(Z, 2),
	{
	.type = IIO_VOLTAGE,
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
	.indexed = 1,
	.address = KXSD9_REG_AUX,
	.scan_index = 3,
	.scan_type = {
	.sign = 'u',
	.realbits = 12,
	.storagebits = 16,
	.shift = 4,
	.endianness = IIO_BE,
	},
	},
	IIO_CHAN_SOFT_TIMESTAMP(4),
	};

	static const struct attribute_group kxsd9_attribute_group = {
	.attrs = kxsd9_attributes,
	};

	static int kxsd9_power_up(struct kxsd9_state *st)
	{
	int ret;

	/* Enable the regulators */
	ret = regulator_bulk_enable(ARRAY_SIZE(st->regs), st->regs);
	if (ret) {
	dev_err(st->dev, "Cannot enable regulators\n");
	return ret;
	}

	/* Power up */
	ret = regmap_write(st->map,
	KXSD9_REG_CTRL_B,
	KXSD9_CTRL_B_ENABLE);
	if (ret)
	return ret;

	/*
	* Set 1000Hz LPF, 2g fullscale, motion wakeup threshold 1g,
	* latched wakeup
	*/
	ret = regmap_write(st->map,
	KXSD9_REG_CTRL_C,
	KXSD9_CTRL_C_LP_1000HZ \|
	KXSD9_CTRL_C_MOT_LEV \|
	KXSD9_CTRL_C_MOT_LAT \|
	st->scale);
	if (ret)
	return ret;

	/*
	* Power-up time depends on the LPF setting, but typ 15.9 ms, let's
	* set 20 ms to allow for some slack.
	*/
	msleep(20);

	return 0;
	};

	static int kxsd9_power_down(struct kxsd9_state *st)
	{
	int ret;

	/*
	* Set into low power mode - since there may be more users of the
	* regulators this is the first step of the power saving: it will
	* make sure we conserve power even if there are others users on the
	* regulators.
	*/
	ret = regmap_update_bits(st->map,
	KXSD9_REG_CTRL_B,
	KXSD9_CTRL_B_ENABLE,
	0);
	if (ret)
	return ret;

	/* Disable the regulators */
	ret = regulator_bulk_disable(ARRAY_SIZE(st->regs), st->regs);
	if (ret) {
	dev_err(st->dev, "Cannot disable regulators\n");
	return ret;
	}

	return 0;
	}

	static const struct iio_info kxsd9_info = {
	.read_raw = &kxsd9_read_raw,
	.write_raw = &kxsd9_write_raw,
	.attrs = &kxsd9_attribute_group,
	};

	/* Four channels apart from timestamp, scan mask = 0x0f */
	static const unsigned long kxsd9_scan_masks[] = { 0xf, 0 };

	int kxsd9_common_probe(struct device *dev,
	struct regmap *map,
	const char *name)
	{
	struct iio_dev *indio_dev;
	struct kxsd9_state *st;
	int ret;

	indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
	if (!indio_dev)
	return -ENOMEM;

	st = iio_priv(indio_dev);
	st->dev = dev;
	st->map = map;

	indio_dev->channels = kxsd9_channels;
	indio_dev->num_channels = ARRAY_SIZE(kxsd9_channels);
	indio_dev->name = name;
	indio_dev->dev.parent = dev;
	indio_dev->info = &kxsd9_info;
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->available_scan_masks = kxsd9_scan_masks;

	/* Read the mounting matrix, if present */
	ret = iio_read_mount_matrix(dev, "mount-matrix", &st->orientation);
	if (ret)
	return ret;

	/* Fetch and turn on regulators */
	st->regs[0].supply = kxsd9_reg_vdd;
	st->regs[1].supply = kxsd9_reg_iovdd;
	ret = devm_regulator_bulk_get(dev,
	ARRAY_SIZE(st->regs),
	st->regs);
	if (ret) {
	dev_err(dev, "Cannot get regulators\n");
	return ret;
	}
	/* Default scaling */
	st->scale = KXSD9_CTRL_C_FS_2G;

	kxsd9_power_up(st);

	ret = iio_triggered_buffer_setup(indio_dev,
	iio_pollfunc_store_time,
	kxsd9_trigger_handler,
	&kxsd9_buffer_setup_ops);
	if (ret) {
	dev_err(dev, "triggered buffer setup failed\n");
	goto err_power_down;
	}

	ret = iio_device_register(indio_dev);
	if (ret)
	goto err_cleanup_buffer;

	dev_set_drvdata(dev, indio_dev);

	/* Enable runtime PM */
	pm_runtime_get_noresume(dev);
	pm_runtime_set_active(dev);
	pm_runtime_enable(dev);
	/*
	* Set autosuspend to two orders of magnitude larger than the
	* start-up time. 20ms start-up time means 2000ms autosuspend,
	* i.e. 2 seconds.
	*/
	pm_runtime_set_autosuspend_delay(dev, 2000);
	pm_runtime_use_autosuspend(dev);
	pm_runtime_put(dev);

	return 0;

	err_cleanup_buffer:
	iio_triggered_buffer_cleanup(indio_dev);
	err_power_down:
	kxsd9_power_down(st);

	return ret;
	}
	EXPORT_SYMBOL(kxsd9_common_probe);

	int kxsd9_common_remove(struct device *dev)
	{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct kxsd9_state *st = iio_priv(indio_dev);

	iio_triggered_buffer_cleanup(indio_dev);
	iio_device_unregister(indio_dev);
	pm_runtime_get_sync(dev);
	pm_runtime_put_noidle(dev);
	pm_runtime_disable(dev);
	kxsd9_power_down(st);

	return 0;
	}
	EXPORT_SYMBOL(kxsd9_common_remove);

	#ifdef CONFIG_PM
	static int kxsd9_runtime_suspend(struct device *dev)
	{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct kxsd9_state *st = iio_priv(indio_dev);

	return kxsd9_power_down(st);
	}

	static int kxsd9_runtime_resume(struct device *dev)
	{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct kxsd9_state *st = iio_priv(indio_dev);

	return kxsd9_power_up(st);
	}
	#endif /* CONFIG_PM */

	const struct dev_pm_ops kxsd9_dev_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
	pm_runtime_force_resume)
	SET_RUNTIME_PM_OPS(kxsd9_runtime_suspend,
	kxsd9_runtime_resume, NULL)
	};
	EXPORT_SYMBOL(kxsd9_dev_pm_ops);

	MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
	MODULE_DESCRIPTION("Kionix KXSD9 driver");
	MODULE_LICENSE("GPL v2");