[linux-2.6-block.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 "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	3200
#define BMI160_ACCEL_PMU_MAX_USLEEP	3800
#define BMI160_GYRO_PMU_MIN_USLEEP	55000
#define BMI160_GYRO_PMU_MAX_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,
	},
};

struct bmi160_pmu_time {
	unsigned long min;
	unsigned long max;
};

static struct bmi160_pmu_time bmi160_pmu_time[] = {
	[BMI160_ACCEL] = {
		.min = BMI160_ACCEL_PMU_MIN_USLEEP,
		.max = BMI160_ACCEL_PMU_MAX_USLEEP
	},
	[BMI160_GYRO] = {
		.min = BMI160_GYRO_PMU_MIN_USLEEP,
		.max = 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].min, bmi160_pmu_time[t].max);

	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);
	s16 buf[16]; /* 3 sens x 3 axis x s16 + 3 x s16 pad + 4 x s16 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());
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 const struct iio_info bmi160_info = {
	.driver_module = THIS_MODULE,
	.read_raw = bmi160_read_raw,
	.write_raw = bmi160_write_raw,
};

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