[mirror_ubuntu-artful-kernel.git] / drivers / iio / imu / bmi160 / bmi160_core.c

/*
 * BMI160 - Bosch IMU (accel, gyro plus external magnetometer)
 *
 * Copyright (c) 2016, Intel Corporation.
 *
 * This file is subject to the terms and conditions of version 2 of
 * the GNU General Public License.  See the file COPYING in the main
 * directory of this archive for more details.
 *
 * IIO core driver for BMI160, with support for I2C/SPI busses
 *
 * TODO: magnetometer, interrupts, hardware FIFO
 */
#include <linux/module.h>
#include <linux/regmap.h>
#include <linux/acpi.h>
#include <linux/delay.h>

#include <linux/iio/iio.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/buffer.h>
#include <linux/iio/sysfs.h>

#include "bmi160.h"

#define BMI160_REG_CHIP_ID	0x00
#define BMI160_CHIP_ID_VAL	0xD1

#define BMI160_REG_PMU_STATUS	0x03

/* X axis data low byte address, the rest can be obtained using axis offset */
#define BMI160_REG_DATA_MAGN_XOUT_L	0x04
#define BMI160_REG_DATA_GYRO_XOUT_L	0x0C
#define BMI160_REG_DATA_ACCEL_XOUT_L	0x12

#define BMI160_REG_ACCEL_CONFIG		0x40
#define BMI160_ACCEL_CONFIG_ODR_MASK	GENMASK(3, 0)
#define BMI160_ACCEL_CONFIG_BWP_MASK	GENMASK(6, 4)

#define BMI160_REG_ACCEL_RANGE		0x41
#define BMI160_ACCEL_RANGE_2G		0x03
#define BMI160_ACCEL_RANGE_4G		0x05
#define BMI160_ACCEL_RANGE_8G		0x08
#define BMI160_ACCEL_RANGE_16G		0x0C

#define BMI160_REG_GYRO_CONFIG		0x42
#define BMI160_GYRO_CONFIG_ODR_MASK	GENMASK(3, 0)
#define BMI160_GYRO_CONFIG_BWP_MASK	GENMASK(5, 4)

#define BMI160_REG_GYRO_RANGE		0x43
#define BMI160_GYRO_RANGE_2000DPS	0x00
#define BMI160_GYRO_RANGE_1000DPS	0x01
#define BMI160_GYRO_RANGE_500DPS	0x02
#define BMI160_GYRO_RANGE_250DPS	0x03
#define BMI160_GYRO_RANGE_125DPS	0x04

#define BMI160_REG_CMD			0x7E
#define BMI160_CMD_ACCEL_PM_SUSPEND	0x10
#define BMI160_CMD_ACCEL_PM_NORMAL	0x11
#define BMI160_CMD_ACCEL_PM_LOW_POWER	0x12
#define BMI160_CMD_GYRO_PM_SUSPEND	0x14
#define BMI160_CMD_GYRO_PM_NORMAL	0x15
#define BMI160_CMD_GYRO_PM_FAST_STARTUP	0x17
#define BMI160_CMD_SOFTRESET		0xB6

#define BMI160_REG_DUMMY		0x7F

#define BMI160_ACCEL_PMU_MIN_USLEEP	3800
#define BMI160_GYRO_PMU_MIN_USLEEP	80000
#define BMI160_SOFTRESET_USLEEP		1000

#define BMI160_CHANNEL(_type, _axis, _index) {			\
	.type = _type,						\
	.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_SAMP_FREQ),			\
	.scan_index = _index,					\
	.scan_type = {						\
		.sign = 's',					\
		.realbits = 16,					\
		.storagebits = 16,				\
		.endianness = IIO_LE,				\
	},							\
}

/* scan indexes follow DATA register order */
enum bmi160_scan_axis {
	BMI160_SCAN_EXT_MAGN_X = 0,
	BMI160_SCAN_EXT_MAGN_Y,
	BMI160_SCAN_EXT_MAGN_Z,
	BMI160_SCAN_RHALL,
	BMI160_SCAN_GYRO_X,
	BMI160_SCAN_GYRO_Y,
	BMI160_SCAN_GYRO_Z,
	BMI160_SCAN_ACCEL_X,
	BMI160_SCAN_ACCEL_Y,
	BMI160_SCAN_ACCEL_Z,
	BMI160_SCAN_TIMESTAMP,
};

enum bmi160_sensor_type {
	BMI160_ACCEL	= 0,
	BMI160_GYRO,
	BMI160_EXT_MAGN,
	BMI160_NUM_SENSORS /* must be last */
};

struct bmi160_data {
	struct regmap *regmap;
};

const struct regmap_config bmi160_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
};
EXPORT_SYMBOL(bmi160_regmap_config);

struct bmi160_regs {
	u8 data; /* LSB byte register for X-axis */
	u8 config;
	u8 config_odr_mask;
	u8 config_bwp_mask;
	u8 range;
	u8 pmu_cmd_normal;
	u8 pmu_cmd_suspend;
};

static struct bmi160_regs bmi160_regs[] = {
	[BMI160_ACCEL] = {
		.data	= BMI160_REG_DATA_ACCEL_XOUT_L,
		.config	= BMI160_REG_ACCEL_CONFIG,
		.config_odr_mask = BMI160_ACCEL_CONFIG_ODR_MASK,
		.config_bwp_mask = BMI160_ACCEL_CONFIG_BWP_MASK,
		.range	= BMI160_REG_ACCEL_RANGE,
		.pmu_cmd_normal = BMI160_CMD_ACCEL_PM_NORMAL,
		.pmu_cmd_suspend = BMI160_CMD_ACCEL_PM_SUSPEND,
	},
	[BMI160_GYRO] = {
		.data	= BMI160_REG_DATA_GYRO_XOUT_L,
		.config	= BMI160_REG_GYRO_CONFIG,
		.config_odr_mask = BMI160_GYRO_CONFIG_ODR_MASK,
		.config_bwp_mask = BMI160_GYRO_CONFIG_BWP_MASK,
		.range	= BMI160_REG_GYRO_RANGE,
		.pmu_cmd_normal = BMI160_CMD_GYRO_PM_NORMAL,
		.pmu_cmd_suspend = BMI160_CMD_GYRO_PM_SUSPEND,
	},
};

static unsigned long bmi160_pmu_time[] = {
	[BMI160_ACCEL] = BMI160_ACCEL_PMU_MIN_USLEEP,
	[BMI160_GYRO] = BMI160_GYRO_PMU_MIN_USLEEP,
};

struct bmi160_scale {
	u8 bits;
	int uscale;
};

struct bmi160_odr {
	u8 bits;
	int odr;
	int uodr;
};

static const struct bmi160_scale bmi160_accel_scale[] = {
	{ BMI160_ACCEL_RANGE_2G, 598},
	{ BMI160_ACCEL_RANGE_4G, 1197},
	{ BMI160_ACCEL_RANGE_8G, 2394},
	{ BMI160_ACCEL_RANGE_16G, 4788},
};

static const struct bmi160_scale bmi160_gyro_scale[] = {
	{ BMI160_GYRO_RANGE_2000DPS, 1065},
	{ BMI160_GYRO_RANGE_1000DPS, 532},
	{ BMI160_GYRO_RANGE_500DPS, 266},
	{ BMI160_GYRO_RANGE_250DPS, 133},
	{ BMI160_GYRO_RANGE_125DPS, 66},
};

struct bmi160_scale_item {
	const struct bmi160_scale *tbl;
	int num;
};

static const struct  bmi160_scale_item bmi160_scale_table[] = {
	[BMI160_ACCEL] = {
		.tbl	= bmi160_accel_scale,
		.num	= ARRAY_SIZE(bmi160_accel_scale),
	},
	[BMI160_GYRO] = {
		.tbl	= bmi160_gyro_scale,
		.num	= ARRAY_SIZE(bmi160_gyro_scale),
	},
};

static const struct bmi160_odr bmi160_accel_odr[] = {
	{0x01, 0, 781250},
	{0x02, 1, 562500},
	{0x03, 3, 125000},
	{0x04, 6, 250000},
	{0x05, 12, 500000},
	{0x06, 25, 0},
	{0x07, 50, 0},
	{0x08, 100, 0},
	{0x09, 200, 0},
	{0x0A, 400, 0},
	{0x0B, 800, 0},
	{0x0C, 1600, 0},
};

static const struct bmi160_odr bmi160_gyro_odr[] = {
	{0x06, 25, 0},
	{0x07, 50, 0},
	{0x08, 100, 0},
	{0x09, 200, 0},
	{0x0A, 400, 0},
	{0x0B, 800, 0},
	{0x0C, 1600, 0},
	{0x0D, 3200, 0},
};

struct bmi160_odr_item {
	const struct bmi160_odr *tbl;
	int num;
};

static const struct  bmi160_odr_item bmi160_odr_table[] = {
	[BMI160_ACCEL] = {
		.tbl	= bmi160_accel_odr,
		.num	= ARRAY_SIZE(bmi160_accel_odr),
	},
	[BMI160_GYRO] = {
		.tbl	= bmi160_gyro_odr,
		.num	= ARRAY_SIZE(bmi160_gyro_odr),
	},
};

static const struct iio_chan_spec bmi160_channels[] = {
	BMI160_CHANNEL(IIO_ACCEL, X, BMI160_SCAN_ACCEL_X),
	BMI160_CHANNEL(IIO_ACCEL, Y, BMI160_SCAN_ACCEL_Y),
	BMI160_CHANNEL(IIO_ACCEL, Z, BMI160_SCAN_ACCEL_Z),
	BMI160_CHANNEL(IIO_ANGL_VEL, X, BMI160_SCAN_GYRO_X),
	BMI160_CHANNEL(IIO_ANGL_VEL, Y, BMI160_SCAN_GYRO_Y),
	BMI160_CHANNEL(IIO_ANGL_VEL, Z, BMI160_SCAN_GYRO_Z),
	IIO_CHAN_SOFT_TIMESTAMP(BMI160_SCAN_TIMESTAMP),
};

static enum bmi160_sensor_type bmi160_to_sensor(enum iio_chan_type iio_type)
{
	switch (iio_type) {
	case IIO_ACCEL:
		return BMI160_ACCEL;
	case IIO_ANGL_VEL:
		return BMI160_GYRO;
	default:
		return -EINVAL;
	}
}

static
int bmi160_set_mode(struct bmi160_data *data, enum bmi160_sensor_type t,
		    bool mode)
{
	int ret;
	u8 cmd;

	if (mode)
		cmd = bmi160_regs[t].pmu_cmd_normal;
	else
		cmd = bmi160_regs[t].pmu_cmd_suspend;

	ret = regmap_write(data->regmap, BMI160_REG_CMD, cmd);
	if (ret < 0)
		return ret;

	usleep_range(bmi160_pmu_time[t], bmi160_pmu_time[t] + 1000);

	return 0;
}

static
int bmi160_set_scale(struct bmi160_data *data, enum bmi160_sensor_type t,
		     int uscale)
{
	int i;

	for (i = 0; i < bmi160_scale_table[t].num; i++)
		if (bmi160_scale_table[t].tbl[i].uscale == uscale)
			break;

	if (i == bmi160_scale_table[t].num)
		return -EINVAL;

	return regmap_write(data->regmap, bmi160_regs[t].range,
			    bmi160_scale_table[t].tbl[i].bits);
}

static
int bmi160_get_scale(struct bmi160_data *data, enum bmi160_sensor_type t,
		     int *uscale)
{
	int i, ret, val;

	ret = regmap_read(data->regmap, bmi160_regs[t].range, &val);
	if (ret < 0)
		return ret;

	for (i = 0; i < bmi160_scale_table[t].num; i++)
		if (bmi160_scale_table[t].tbl[i].bits == val) {
			*uscale = bmi160_scale_table[t].tbl[i].uscale;
			return 0;
		}

	return -EINVAL;
}

static int bmi160_get_data(struct bmi160_data *data, int chan_type,
			   int axis, int *val)
{
	u8 reg;
	int ret;
	__le16 sample;
	enum bmi160_sensor_type t = bmi160_to_sensor(chan_type);

	reg = bmi160_regs[t].data + (axis - IIO_MOD_X) * sizeof(__le16);

	ret = regmap_bulk_read(data->regmap, reg, &sample, sizeof(__le16));
	if (ret < 0)
		return ret;

	*val = sign_extend32(le16_to_cpu(sample), 15);

	return 0;
}

static
int bmi160_set_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
		   int odr, int uodr)
{
	int i;

	for (i = 0; i < bmi160_odr_table[t].num; i++)
		if (bmi160_odr_table[t].tbl[i].odr == odr &&
		    bmi160_odr_table[t].tbl[i].uodr == uodr)
			break;

	if (i >= bmi160_odr_table[t].num)
		return -EINVAL;

	return regmap_update_bits(data->regmap,
				  bmi160_regs[t].config,
				  bmi160_regs[t].config_odr_mask,
				  bmi160_odr_table[t].tbl[i].bits);
}

static int bmi160_get_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
			  int *odr, int *uodr)
{
	int i, val, ret;

	ret = regmap_read(data->regmap, bmi160_regs[t].config, &val);
	if (ret < 0)
		return ret;

	val &= bmi160_regs[t].config_odr_mask;

	for (i = 0; i < bmi160_odr_table[t].num; i++)
		if (val == bmi160_odr_table[t].tbl[i].bits)
			break;

	if (i >= bmi160_odr_table[t].num)
		return -EINVAL;

	*odr = bmi160_odr_table[t].tbl[i].odr;
	*uodr = bmi160_odr_table[t].tbl[i].uodr;

	return 0;
}

static irqreturn_t bmi160_trigger_handler(int irq, void *p)
{
	struct iio_poll_func *pf = p;
	struct iio_dev *indio_dev = pf->indio_dev;
	struct bmi160_data *data = iio_priv(indio_dev);
	__le16 buf[16];
	/* 3 sens x 3 axis x __le16 + 3 x __le16 pad + 4 x __le16 tstamp */
	int i, ret, j = 0, base = BMI160_REG_DATA_MAGN_XOUT_L;
	__le16 sample;

	for_each_set_bit(i, indio_dev->active_scan_mask,
			 indio_dev->masklength) {
		ret = regmap_bulk_read(data->regmap, base + i * sizeof(__le16),
				       &sample, sizeof(__le16));
		if (ret < 0)
			goto done;
		buf[j++] = sample;
	}

	iio_push_to_buffers_with_timestamp(indio_dev, buf,
					   iio_get_time_ns(indio_dev));
done:
	iio_trigger_notify_done(indio_dev->trig);
	return IRQ_HANDLED;
}

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

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		ret = bmi160_get_data(data, chan->type, chan->channel2, val);
		if (ret < 0)
			return ret;
		return IIO_VAL_INT;
	case IIO_CHAN_INFO_SCALE:
		*val = 0;
		ret = bmi160_get_scale(data,
				       bmi160_to_sensor(chan->type), val2);
		return ret < 0 ? ret : IIO_VAL_INT_PLUS_MICRO;
	case IIO_CHAN_INFO_SAMP_FREQ:
		ret = bmi160_get_odr(data, bmi160_to_sensor(chan->type),
				     val, val2);
		return ret < 0 ? ret : IIO_VAL_INT_PLUS_MICRO;
	default:
		return -EINVAL;
	}

	return 0;
}

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

	switch (mask) {
	case IIO_CHAN_INFO_SCALE:
		return bmi160_set_scale(data,
					bmi160_to_sensor(chan->type), val2);
		break;
	case IIO_CHAN_INFO_SAMP_FREQ:
		return bmi160_set_odr(data, bmi160_to_sensor(chan->type),
				      val, val2);
	default:
		return -EINVAL;
	}

	return 0;
}

static
IIO_CONST_ATTR(in_accel_sampling_frequency_available,
	       "0.78125 1.5625 3.125 6.25 12.5 25 50 100 200 400 800 1600");
static
IIO_CONST_ATTR(in_anglvel_sampling_frequency_available,
	       "25 50 100 200 400 800 1600 3200");
static
IIO_CONST_ATTR(in_accel_scale_available,
	       "0.000598 0.001197 0.002394 0.004788");
static
IIO_CONST_ATTR(in_anglvel_scale_available,
	       "0.001065 0.000532 0.000266 0.000133 0.000066");

static struct attribute *bmi160_attrs[] = {
	&iio_const_attr_in_accel_sampling_frequency_available.dev_attr.attr,
	&iio_const_attr_in_anglvel_sampling_frequency_available.dev_attr.attr,
	&iio_const_attr_in_accel_scale_available.dev_attr.attr,
	&iio_const_attr_in_anglvel_scale_available.dev_attr.attr,
	NULL,
};

static const struct attribute_group bmi160_attrs_group = {
	.attrs = bmi160_attrs,
};

static const struct iio_info bmi160_info = {
	.driver_module = THIS_MODULE,
	.read_raw = bmi160_read_raw,
	.write_raw = bmi160_write_raw,
	.attrs = &bmi160_attrs_group,
};

static const char *bmi160_match_acpi_device(struct device *dev)
{
	const struct acpi_device_id *id;

	id = acpi_match_device(dev->driver->acpi_match_table, dev);
	if (!id)
		return NULL;

	return dev_name(dev);
}

static int bmi160_chip_init(struct bmi160_data *data, bool use_spi)
{
	int ret;
	unsigned int val;
	struct device *dev = regmap_get_device(data->regmap);

	ret = regmap_write(data->regmap, BMI160_REG_CMD, BMI160_CMD_SOFTRESET);
	if (ret < 0)
		return ret;

	usleep_range(BMI160_SOFTRESET_USLEEP, BMI160_SOFTRESET_USLEEP + 1);

	/*
	 * CS rising edge is needed before starting SPI, so do a dummy read
	 * See Section 3.2.1, page 86 of the datasheet
	 */
	if (use_spi) {
		ret = regmap_read(data->regmap, BMI160_REG_DUMMY, &val);
		if (ret < 0)
			return ret;
	}

	ret = regmap_read(data->regmap, BMI160_REG_CHIP_ID, &val);
	if (ret < 0) {
		dev_err(dev, "Error reading chip id\n");
		return ret;
	}
	if (val != BMI160_CHIP_ID_VAL) {
		dev_err(dev, "Wrong chip id, got %x expected %x\n",
			val, BMI160_CHIP_ID_VAL);
		return -ENODEV;
	}

	ret = bmi160_set_mode(data, BMI160_ACCEL, true);
	if (ret < 0)
		return ret;

	ret = bmi160_set_mode(data, BMI160_GYRO, true);
	if (ret < 0)
		return ret;

	return 0;
}

static void bmi160_chip_uninit(struct bmi160_data *data)
{
	bmi160_set_mode(data, BMI160_GYRO, false);
	bmi160_set_mode(data, BMI160_ACCEL, false);
}

int bmi160_core_probe(struct device *dev, struct regmap *regmap,
		      const char *name, bool use_spi)
{
	struct iio_dev *indio_dev;
	struct bmi160_data *data;
	int ret;

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

	data = iio_priv(indio_dev);
	dev_set_drvdata(dev, indio_dev);
	data->regmap = regmap;

	ret = bmi160_chip_init(data, use_spi);
	if (ret < 0)
		return ret;

	if (!name && ACPI_HANDLE(dev))
		name = bmi160_match_acpi_device(dev);

	indio_dev->dev.parent = dev;
	indio_dev->channels = bmi160_channels;
	indio_dev->num_channels = ARRAY_SIZE(bmi160_channels);
	indio_dev->name = name;
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->info = &bmi160_info;

	ret = iio_triggered_buffer_setup(indio_dev, NULL,
					 bmi160_trigger_handler, NULL);
	if (ret < 0)
		goto uninit;

	ret = iio_device_register(indio_dev);
	if (ret < 0)
		goto buffer_cleanup;

	return 0;
buffer_cleanup:
	iio_triggered_buffer_cleanup(indio_dev);
uninit:
	bmi160_chip_uninit(data);
	return ret;
}
EXPORT_SYMBOL_GPL(bmi160_core_probe);

void bmi160_core_remove(struct device *dev)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct bmi160_data *data = iio_priv(indio_dev);

	iio_device_unregister(indio_dev);
	iio_triggered_buffer_cleanup(indio_dev);
	bmi160_chip_uninit(data);
}
EXPORT_SYMBOL_GPL(bmi160_core_remove);

MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com");
MODULE_DESCRIPTION("Bosch BMI160 driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
77c4ad2d DB	1	/*
	2	* BMI160 - Bosch IMU (accel, gyro plus external magnetometer)
	3	*
	4	* Copyright (c) 2016, Intel Corporation.
	5	*
	6	* This file is subject to the terms and conditions of version 2 of
	7	* the GNU General Public License. See the file COPYING in the main
	8	* directory of this archive for more details.
	9	*
	10	* IIO core driver for BMI160, with support for I2C/SPI busses
	11	*
	12	* TODO: magnetometer, interrupts, hardware FIFO
	13	*/
	14	#include <linux/module.h>
	15	#include <linux/regmap.h>
	16	#include <linux/acpi.h>
	17	#include <linux/delay.h>
	18
	19	#include <linux/iio/iio.h>
	20	#include <linux/iio/triggered_buffer.h>
	21	#include <linux/iio/trigger_consumer.h>
	22	#include <linux/iio/buffer.h>
216912e3	23	#include <linux/iio/sysfs.h>
77c4ad2d DB	24
	25	#include "bmi160.h"
	26
	27	#define BMI160_REG_CHIP_ID 0x00
	28	#define BMI160_CHIP_ID_VAL 0xD1
	29
	30	#define BMI160_REG_PMU_STATUS 0x03
	31
	32	/* X axis data low byte address, the rest can be obtained using axis offset */
	33	#define BMI160_REG_DATA_MAGN_XOUT_L 0x04
	34	#define BMI160_REG_DATA_GYRO_XOUT_L 0x0C
	35	#define BMI160_REG_DATA_ACCEL_XOUT_L 0x12
	36
	37	#define BMI160_REG_ACCEL_CONFIG 0x40
	38	#define BMI160_ACCEL_CONFIG_ODR_MASK GENMASK(3, 0)
	39	#define BMI160_ACCEL_CONFIG_BWP_MASK GENMASK(6, 4)
	40
	41	#define BMI160_REG_ACCEL_RANGE 0x41
	42	#define BMI160_ACCEL_RANGE_2G 0x03
	43	#define BMI160_ACCEL_RANGE_4G 0x05
	44	#define BMI160_ACCEL_RANGE_8G 0x08
	45	#define BMI160_ACCEL_RANGE_16G 0x0C
	46
	47	#define BMI160_REG_GYRO_CONFIG 0x42
	48	#define BMI160_GYRO_CONFIG_ODR_MASK GENMASK(3, 0)
	49	#define BMI160_GYRO_CONFIG_BWP_MASK GENMASK(5, 4)
	50
	51	#define BMI160_REG_GYRO_RANGE 0x43
	52	#define BMI160_GYRO_RANGE_2000DPS 0x00
	53	#define BMI160_GYRO_RANGE_1000DPS 0x01
	54	#define BMI160_GYRO_RANGE_500DPS 0x02
	55	#define BMI160_GYRO_RANGE_250DPS 0x03
	56	#define BMI160_GYRO_RANGE_125DPS 0x04
	57
	58	#define BMI160_REG_CMD 0x7E
	59	#define BMI160_CMD_ACCEL_PM_SUSPEND 0x10
	60	#define BMI160_CMD_ACCEL_PM_NORMAL 0x11
	61	#define BMI160_CMD_ACCEL_PM_LOW_POWER 0x12
	62	#define BMI160_CMD_GYRO_PM_SUSPEND 0x14
	63	#define BMI160_CMD_GYRO_PM_NORMAL 0x15
	64	#define BMI160_CMD_GYRO_PM_FAST_STARTUP 0x17
	65	#define BMI160_CMD_SOFTRESET 0xB6
	66
	67	#define BMI160_REG_DUMMY 0x7F
	68
01d1f7a9 MN	69	#define BMI160_ACCEL_PMU_MIN_USLEEP 3800
01d1f7a9 MN	70	#define BMI160_GYRO_PMU_MIN_USLEEP 80000
77c4ad2d DB	71	#define BMI160_SOFTRESET_USLEEP 1000
	72
	73	#define BMI160_CHANNEL(_type, _axis, _index) { \
	74	.type = _type, \
	75	.modified = 1, \
	76	.channel2 = IIO_MOD_##_axis, \
	77	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
	78	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \| \
	79	BIT(IIO_CHAN_INFO_SAMP_FREQ), \
	80	.scan_index = _index, \
	81	.scan_type = { \
	82	.sign = 's', \
	83	.realbits = 16, \
	84	.storagebits = 16, \
	85	.endianness = IIO_LE, \
	86	}, \
	87	}
	88
	89	/* scan indexes follow DATA register order */
	90	enum bmi160_scan_axis {
	91	BMI160_SCAN_EXT_MAGN_X = 0,
	92	BMI160_SCAN_EXT_MAGN_Y,
	93	BMI160_SCAN_EXT_MAGN_Z,
	94	BMI160_SCAN_RHALL,
	95	BMI160_SCAN_GYRO_X,
	96	BMI160_SCAN_GYRO_Y,
	97	BMI160_SCAN_GYRO_Z,
	98	BMI160_SCAN_ACCEL_X,
	99	BMI160_SCAN_ACCEL_Y,
	100	BMI160_SCAN_ACCEL_Z,
	101	BMI160_SCAN_TIMESTAMP,
	102	};
	103
	104	enum bmi160_sensor_type {
	105	BMI160_ACCEL = 0,
	106	BMI160_GYRO,
	107	BMI160_EXT_MAGN,
	108	BMI160_NUM_SENSORS /* must be last */
	109	};
	110
	111	struct bmi160_data {
	112	struct regmap *regmap;
	113	};
	114
	115	const struct regmap_config bmi160_regmap_config = {
	116	.reg_bits = 8,
	117	.val_bits = 8,
	118	};
	119	EXPORT_SYMBOL(bmi160_regmap_config);
	120
	121	struct bmi160_regs {
	122	u8 data; /* LSB byte register for X-axis */
	123	u8 config;
	124	u8 config_odr_mask;
	125	u8 config_bwp_mask;
	126	u8 range;
	127	u8 pmu_cmd_normal;
	128	u8 pmu_cmd_suspend;
	129	};
	130
	131	static struct bmi160_regs bmi160_regs[] = {
	132	[BMI160_ACCEL] = {
	133	.data = BMI160_REG_DATA_ACCEL_XOUT_L,
	134	.config = BMI160_REG_ACCEL_CONFIG,
135	.config_odr_mask = BMI160_ACCEL_CONFIG_ODR_MASK,
136	.config_bwp_mask = BMI160_ACCEL_CONFIG_BWP_MASK,
137	.range = BMI160_REG_ACCEL_RANGE,
138	.pmu_cmd_normal = BMI160_CMD_ACCEL_PM_NORMAL,
139	.pmu_cmd_suspend = BMI160_CMD_ACCEL_PM_SUSPEND,
140	},
141	[BMI160_GYRO] = {
142	.data = BMI160_REG_DATA_GYRO_XOUT_L,
143	.config = BMI160_REG_GYRO_CONFIG,
144	.config_odr_mask = BMI160_GYRO_CONFIG_ODR_MASK,
145	.config_bwp_mask = BMI160_GYRO_CONFIG_BWP_MASK,
146	.range = BMI160_REG_GYRO_RANGE,
147	.pmu_cmd_normal = BMI160_CMD_GYRO_PM_NORMAL,
148	.pmu_cmd_suspend = BMI160_CMD_GYRO_PM_SUSPEND,
149	},
150	};
151
01d1f7a9 MN	152	static unsigned long bmi160_pmu_time[] = {
	153	[BMI160_ACCEL] = BMI160_ACCEL_PMU_MIN_USLEEP,
	154	[BMI160_GYRO] = BMI160_GYRO_PMU_MIN_USLEEP,
77c4ad2d DB	155	};
	156
	157	struct bmi160_scale {
	158	u8 bits;
	159	int uscale;
	160	};
	161
	162	struct bmi160_odr {
	163	u8 bits;
	164	int odr;
	165	int uodr;
	166	};
	167
	168	static const struct bmi160_scale bmi160_accel_scale[] = {
	169	{ BMI160_ACCEL_RANGE_2G, 598},
	170	{ BMI160_ACCEL_RANGE_4G, 1197},
	171	{ BMI160_ACCEL_RANGE_8G, 2394},
	172	{ BMI160_ACCEL_RANGE_16G, 4788},
	173	};
	174
	175	static const struct bmi160_scale bmi160_gyro_scale[] = {
	176	{ BMI160_GYRO_RANGE_2000DPS, 1065},
	177	{ BMI160_GYRO_RANGE_1000DPS, 532},
	178	{ BMI160_GYRO_RANGE_500DPS, 266},
	179	{ BMI160_GYRO_RANGE_250DPS, 133},
	180	{ BMI160_GYRO_RANGE_125DPS, 66},
	181	};
	182
	183	struct bmi160_scale_item {
	184	const struct bmi160_scale *tbl;
	185	int num;
	186	};
	187
	188	static const struct bmi160_scale_item bmi160_scale_table[] = {
	189	[BMI160_ACCEL] = {
	190	.tbl = bmi160_accel_scale,
	191	.num = ARRAY_SIZE(bmi160_accel_scale),
	192	},
	193	[BMI160_GYRO] = {
	194	.tbl = bmi160_gyro_scale,
	195	.num = ARRAY_SIZE(bmi160_gyro_scale),
	196	},
	197	};
	198
	199	static const struct bmi160_odr bmi160_accel_odr[] = {
5ec97ba0 DB	200	{0x01, 0, 781250},
	201	{0x02, 1, 562500},
	202	{0x03, 3, 125000},
	203	{0x04, 6, 250000},
	204	{0x05, 12, 500000},
77c4ad2d DB	205	{0x06, 25, 0},
	206	{0x07, 50, 0},
	207	{0x08, 100, 0},
	208	{0x09, 200, 0},
	209	{0x0A, 400, 0},
	210	{0x0B, 800, 0},
	211	{0x0C, 1600, 0},
	212	};
	213
	214	static const struct bmi160_odr bmi160_gyro_odr[] = {
	215	{0x06, 25, 0},
	216	{0x07, 50, 0},
	217	{0x08, 100, 0},
	218	{0x09, 200, 0},
	219	{0x0A, 400, 0},
5ec97ba0	220	{0x0B, 800, 0},
77c4ad2d DB	221	{0x0C, 1600, 0},
	222	{0x0D, 3200, 0},
	223	};
	224
	225	struct bmi160_odr_item {
	226	const struct bmi160_odr *tbl;
	227	int num;
	228	};
	229
	230	static const struct bmi160_odr_item bmi160_odr_table[] = {
	231	[BMI160_ACCEL] = {
	232	.tbl = bmi160_accel_odr,
	233	.num = ARRAY_SIZE(bmi160_accel_odr),
	234	},
	235	[BMI160_GYRO] = {
	236	.tbl = bmi160_gyro_odr,
	237	.num = ARRAY_SIZE(bmi160_gyro_odr),
	238	},
	239	};
	240
	241	static const struct iio_chan_spec bmi160_channels[] = {
	242	BMI160_CHANNEL(IIO_ACCEL, X, BMI160_SCAN_ACCEL_X),
	243	BMI160_CHANNEL(IIO_ACCEL, Y, BMI160_SCAN_ACCEL_Y),
	244	BMI160_CHANNEL(IIO_ACCEL, Z, BMI160_SCAN_ACCEL_Z),
	245	BMI160_CHANNEL(IIO_ANGL_VEL, X, BMI160_SCAN_GYRO_X),
	246	BMI160_CHANNEL(IIO_ANGL_VEL, Y, BMI160_SCAN_GYRO_Y),
	247	BMI160_CHANNEL(IIO_ANGL_VEL, Z, BMI160_SCAN_GYRO_Z),
	248	IIO_CHAN_SOFT_TIMESTAMP(BMI160_SCAN_TIMESTAMP),
	249	};
	250
	251	static enum bmi160_sensor_type bmi160_to_sensor(enum iio_chan_type iio_type)
	252	{
	253	switch (iio_type) {
	254	case IIO_ACCEL:
	255	return BMI160_ACCEL;
	256	case IIO_ANGL_VEL:
	257	return BMI160_GYRO;
	258	default:
	259	return -EINVAL;
	260	}
	261	}
	262
	263	static
	264	int bmi160_set_mode(struct bmi160_data *data, enum bmi160_sensor_type t,
	265	bool mode)
	266	{
	267	int ret;
	268	u8 cmd;
	269
	270	if (mode)
	271	cmd = bmi160_regs[t].pmu_cmd_normal;
	272	else
	273	cmd = bmi160_regs[t].pmu_cmd_suspend;
	274
	275	ret = regmap_write(data->regmap, BMI160_REG_CMD, cmd);
	276	if (ret < 0)
	277	return ret;
	278
01d1f7a9	279	usleep_range(bmi160_pmu_time[t], bmi160_pmu_time[t] + 1000);
77c4ad2d DB	280
	281	return 0;
	282	}
	283
	284	static
	285	int bmi160_set_scale(struct bmi160_data *data, enum bmi160_sensor_type t,
	286	int uscale)
	287	{
	288	int i;
	289
	290	for (i = 0; i < bmi160_scale_table[t].num; i++)
	291	if (bmi160_scale_table[t].tbl[i].uscale == uscale)
	292	break;
	293
	294	if (i == bmi160_scale_table[t].num)
	295	return -EINVAL;
	296
	297	return regmap_write(data->regmap, bmi160_regs[t].range,
	298	bmi160_scale_table[t].tbl[i].bits);
	299	}
	300
	301	static
	302	int bmi160_get_scale(struct bmi160_data *data, enum bmi160_sensor_type t,
	303	int *uscale)
	304	{
	305	int i, ret, val;
	306
	307	ret = regmap_read(data->regmap, bmi160_regs[t].range, &val);
	308	if (ret < 0)
	309	return ret;
	310
	311	for (i = 0; i < bmi160_scale_table[t].num; i++)
	312	if (bmi160_scale_table[t].tbl[i].bits == val) {
	313	*uscale = bmi160_scale_table[t].tbl[i].uscale;
	314	return 0;
	315	}
	316
	317	return -EINVAL;
	318	}
	319
	320	static int bmi160_get_data(struct bmi160_data *data, int chan_type,
	321	int axis, int *val)
	322	{
	323	u8 reg;
	324	int ret;
	325	__le16 sample;
	326	enum bmi160_sensor_type t = bmi160_to_sensor(chan_type);
	327
	328	reg = bmi160_regs[t].data + (axis - IIO_MOD_X) * sizeof(__le16);
	329
	330	ret = regmap_bulk_read(data->regmap, reg, &sample, sizeof(__le16));
	331	if (ret < 0)
	332	return ret;
	333
	334	*val = sign_extend32(le16_to_cpu(sample), 15);
	335
	336	return 0;
	337	}
	338
	339	static
	340	int bmi160_set_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
	341	int odr, int uodr)
	342	{
	343	int i;
344
345	for (i = 0; i < bmi160_odr_table[t].num; i++)
346	if (bmi160_odr_table[t].tbl[i].odr == odr &&
347	bmi160_odr_table[t].tbl[i].uodr == uodr)
348	break;
349
350	if (i >= bmi160_odr_table[t].num)
351	return -EINVAL;
352
353	return regmap_update_bits(data->regmap,
354	bmi160_regs[t].config,
c25d3f37 DB	355	bmi160_regs[t].config_odr_mask,
c25d3f37 DB	356	bmi160_odr_table[t].tbl[i].bits);
77c4ad2d DB	357	}
	358
	359	static int bmi160_get_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
	360	int odr, int uodr)
	361	{
	362	int i, val, ret;
	363
	364	ret = regmap_read(data->regmap, bmi160_regs[t].config, &val);
	365	if (ret < 0)
	366	return ret;
	367
	368	val &= bmi160_regs[t].config_odr_mask;
	369
	370	for (i = 0; i < bmi160_odr_table[t].num; i++)
	371	if (val == bmi160_odr_table[t].tbl[i].bits)
	372	break;
	373
	374	if (i >= bmi160_odr_table[t].num)
	375	return -EINVAL;
	376
	377	*odr = bmi160_odr_table[t].tbl[i].odr;
	378	*uodr = bmi160_odr_table[t].tbl[i].uodr;
	379
	380	return 0;
	381	}
	382
	383	static irqreturn_t bmi160_trigger_handler(int irq, void *p)
	384	{
	385	struct iio_poll_func *pf = p;
	386	struct iio_dev *indio_dev = pf->indio_dev;
	387	struct bmi160_data *data = iio_priv(indio_dev);
dd4ba3fb	388	__le16 buf[16];
dd4ba3fb	389	/* 3 sens x 3 axis x __le16 + 3 x __le16 pad + 4 x __le16 tstamp */
77c4ad2d DB	390	int i, ret, j = 0, base = BMI160_REG_DATA_MAGN_XOUT_L;
	391	__le16 sample;
	392
	393	for_each_set_bit(i, indio_dev->active_scan_mask,
	394	indio_dev->masklength) {
	395	ret = regmap_bulk_read(data->regmap, base + i * sizeof(__le16),
	396	&sample, sizeof(__le16));
	397	if (ret < 0)
	398	goto done;
	399	buf[j++] = sample;
	400	}
	401
bc2b7dab GB	402	iio_push_to_buffers_with_timestamp(indio_dev, buf,
bc2b7dab GB	403	iio_get_time_ns(indio_dev));
77c4ad2d DB	404	done:
	405	iio_trigger_notify_done(indio_dev->trig);
	406	return IRQ_HANDLED;
	407	}
	408
	409	static int bmi160_read_raw(struct iio_dev *indio_dev,
	410	struct iio_chan_spec const *chan,
	411	int val, int val2, long mask)
	412	{
	413	int ret;
	414	struct bmi160_data *data = iio_priv(indio_dev);
	415
	416	switch (mask) {
	417	case IIO_CHAN_INFO_RAW:
	418	ret = bmi160_get_data(data, chan->type, chan->channel2, val);
	419	if (ret < 0)
	420	return ret;
	421	return IIO_VAL_INT;
	422	case IIO_CHAN_INFO_SCALE:
	423	*val = 0;
	424	ret = bmi160_get_scale(data,
	425	bmi160_to_sensor(chan->type), val2);
	426	return ret < 0 ? ret : IIO_VAL_INT_PLUS_MICRO;
	427	case IIO_CHAN_INFO_SAMP_FREQ:
	428	ret = bmi160_get_odr(data, bmi160_to_sensor(chan->type),
	429	val, val2);
	430	return ret < 0 ? ret : IIO_VAL_INT_PLUS_MICRO;
	431	default:
	432	return -EINVAL;
	433	}
	434
	435	return 0;
	436	}
	437
	438	static int bmi160_write_raw(struct iio_dev *indio_dev,
	439	struct iio_chan_spec const *chan,
	440	int val, int val2, long mask)
	441	{
	442	struct bmi160_data *data = iio_priv(indio_dev);
	443
	444	switch (mask) {
	445	case IIO_CHAN_INFO_SCALE:
	446	return bmi160_set_scale(data,
	447	bmi160_to_sensor(chan->type), val2);
	448	break;
	449	case IIO_CHAN_INFO_SAMP_FREQ:
	450	return bmi160_set_odr(data, bmi160_to_sensor(chan->type),
	451	val, val2);
	452	default:
	453	return -EINVAL;
	454	}
	455
	456	return 0;
	457	}
	458
216912e3 DB	459	static
	460	IIO_CONST_ATTR(in_accel_sampling_frequency_available,
	461	"0.78125 1.5625 3.125 6.25 12.5 25 50 100 200 400 800 1600");
	462	static
	463	IIO_CONST_ATTR(in_anglvel_sampling_frequency_available,
	464	"25 50 100 200 400 800 1600 3200");
	465	static
	466	IIO_CONST_ATTR(in_accel_scale_available,
	467	"0.000598 0.001197 0.002394 0.004788");
	468	static
	469	IIO_CONST_ATTR(in_anglvel_scale_available,
	470	"0.001065 0.000532 0.000266 0.000133 0.000066");
	471
	472	static struct attribute *bmi160_attrs[] = {
	473	&iio_const_attr_in_accel_sampling_frequency_available.dev_attr.attr,
	474	&iio_const_attr_in_anglvel_sampling_frequency_available.dev_attr.attr,
	475	&iio_const_attr_in_accel_scale_available.dev_attr.attr,
	476	&iio_const_attr_in_anglvel_scale_available.dev_attr.attr,
	477	NULL,
	478	};
	479
	480	static const struct attribute_group bmi160_attrs_group = {
	481	.attrs = bmi160_attrs,
	482	};
	483
77c4ad2d DB	484	static const struct iio_info bmi160_info = {
	485	.driver_module = THIS_MODULE,
	486	.read_raw = bmi160_read_raw,
	487	.write_raw = bmi160_write_raw,
216912e3	488	.attrs = &bmi160_attrs_group,
77c4ad2d DB	489	};
	490
	491	static const char bmi160_match_acpi_device(struct device dev)
	492	{
	493	const struct acpi_device_id *id;
	494
	495	id = acpi_match_device(dev->driver->acpi_match_table, dev);
	496	if (!id)
	497	return NULL;
	498
	499	return dev_name(dev);
	500	}
	501
	502	static int bmi160_chip_init(struct bmi160_data *data, bool use_spi)
	503	{
	504	int ret;
	505	unsigned int val;
	506	struct device *dev = regmap_get_device(data->regmap);
	507
	508	ret = regmap_write(data->regmap, BMI160_REG_CMD, BMI160_CMD_SOFTRESET);
	509	if (ret < 0)
	510	return ret;
	511
	512	usleep_range(BMI160_SOFTRESET_USLEEP, BMI160_SOFTRESET_USLEEP + 1);
	513
	514	/*
	515	* CS rising edge is needed before starting SPI, so do a dummy read
	516	* See Section 3.2.1, page 86 of the datasheet
	517	*/
	518	if (use_spi) {
	519	ret = regmap_read(data->regmap, BMI160_REG_DUMMY, &val);
	520	if (ret < 0)
	521	return ret;
	522	}
	523
	524	ret = regmap_read(data->regmap, BMI160_REG_CHIP_ID, &val);
	525	if (ret < 0) {
	526	dev_err(dev, "Error reading chip id\n");
	527	return ret;
	528	}
	529	if (val != BMI160_CHIP_ID_VAL) {
	530	dev_err(dev, "Wrong chip id, got %x expected %x\n",
	531	val, BMI160_CHIP_ID_VAL);
	532	return -ENODEV;
	533	}
	534
	535	ret = bmi160_set_mode(data, BMI160_ACCEL, true);
	536	if (ret < 0)
	537	return ret;
	538
	539	ret = bmi160_set_mode(data, BMI160_GYRO, true);
	540	if (ret < 0)
	541	return ret;
	542
	543	return 0;
	544	}
	545
	546	static void bmi160_chip_uninit(struct bmi160_data *data)
	547	{
	548	bmi160_set_mode(data, BMI160_GYRO, false);
	549	bmi160_set_mode(data, BMI160_ACCEL, false);
	550	}
	551
	552	int bmi160_core_probe(struct device dev, struct regmap regmap,
553	const char *name, bool use_spi)
554	{
555	struct iio_dev *indio_dev;
556	struct bmi160_data *data;
557	int ret;
558
559	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
560	if (!indio_dev)
561	return -ENOMEM;
562
563	data = iio_priv(indio_dev);
564	dev_set_drvdata(dev, indio_dev);
565	data->regmap = regmap;
566
567	ret = bmi160_chip_init(data, use_spi);
568	if (ret < 0)
569	return ret;
570
571	if (!name && ACPI_HANDLE(dev))
572	name = bmi160_match_acpi_device(dev);
573
574	indio_dev->dev.parent = dev;
575	indio_dev->channels = bmi160_channels;
576	indio_dev->num_channels = ARRAY_SIZE(bmi160_channels);
577	indio_dev->name = name;
578	indio_dev->modes = INDIO_DIRECT_MODE;
579	indio_dev->info = &bmi160_info;
580
581	ret = iio_triggered_buffer_setup(indio_dev, NULL,
582	bmi160_trigger_handler, NULL);
583	if (ret < 0)
584	goto uninit;
585
586	ret = iio_device_register(indio_dev);
587	if (ret < 0)
588	goto buffer_cleanup;
589
590	return 0;
591	buffer_cleanup:
592	iio_triggered_buffer_cleanup(indio_dev);
593	uninit:
594	bmi160_chip_uninit(data);
595	return ret;
596	}
597	EXPORT_SYMBOL_GPL(bmi160_core_probe);
598
599	void bmi160_core_remove(struct device *dev)
600	{
601	struct iio_dev *indio_dev = dev_get_drvdata(dev);
602	struct bmi160_data *data = iio_priv(indio_dev);
603
604	iio_device_unregister(indio_dev);
605	iio_triggered_buffer_cleanup(indio_dev);
606	bmi160_chip_uninit(data);
607	}
608	EXPORT_SYMBOL_GPL(bmi160_core_remove);
609
610	MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com");
611	MODULE_DESCRIPTION("Bosch BMI160 driver");
612	MODULE_LICENSE("GPL v2");