bma180.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * bma180.c - IIO driver for Bosch BMA180 triaxial acceleration sensor
   4 *
   5 * Copyright 2013 Oleksandr Kravchenko <x0199363@ti.com>
   6 *
   7 * Support for BMA250 (c) Peter Meerwald <pmeerw@pmeerw.net>
   8 *
   9 * SPI is not supported by driver
  10 * BMA023/BMA150/SMB380: 7-bit I2C slave address 0x38
  11 * BMA180: 7-bit I2C slave address 0x40 or 0x41
  12 * BMA250: 7-bit I2C slave address 0x18 or 0x19
  13 */
  14
  15#include <linux/module.h>
  16#include <linux/mod_devicetable.h>
  17#include <linux/i2c.h>
  18#include <linux/interrupt.h>
  19#include <linux/delay.h>
  20#include <linux/bitops.h>
  21#include <linux/regulator/consumer.h>
  22#include <linux/slab.h>
  23#include <linux/string.h>
  24#include <linux/types.h>
  25#include <linux/iio/iio.h>
  26#include <linux/iio/sysfs.h>
  27#include <linux/iio/buffer.h>
  28#include <linux/iio/trigger.h>
  29#include <linux/iio/trigger_consumer.h>
  30#include <linux/iio/triggered_buffer.h>
  31
  32enum chip_ids {
  33	BMA023,
  34	BMA150,
  35	BMA180,
  36	BMA250,
  37};
  38
  39struct bma180_data;
  40
  41struct bma180_part_info {
  42	u8 chip_id;
  43	const struct iio_chan_spec *channels;
  44	unsigned int num_channels;
  45	const int *scale_table;
  46	unsigned int num_scales;
  47	const int *bw_table;
  48	unsigned int num_bw;
  49	int temp_offset;
  50
  51	u8 int_reset_reg, int_reset_mask;
  52	u8 sleep_reg, sleep_mask;
  53	u8 bw_reg, bw_mask, bw_offset;
  54	u8 scale_reg, scale_mask;
  55	u8 power_reg, power_mask, lowpower_val;
  56	u8 int_enable_reg, int_enable_mask;
  57	u8 softreset_reg, softreset_val;
  58
  59	int (*chip_config)(struct bma180_data *data);
  60	void (*chip_disable)(struct bma180_data *data);
  61};
  62
  63/* Register set */
  64#define BMA023_CTRL_REG0	0x0a
  65#define BMA023_CTRL_REG1	0x0b
  66#define BMA023_CTRL_REG2	0x14
  67#define BMA023_CTRL_REG3	0x15
  68
  69#define BMA023_RANGE_MASK	GENMASK(4, 3) /* Range of accel values */
  70#define BMA023_BW_MASK		GENMASK(2, 0) /* Accel bandwidth */
  71#define BMA023_SLEEP		BIT(0)
  72#define BMA023_INT_RESET_MASK	BIT(6)
  73#define BMA023_NEW_DATA_INT	BIT(5) /* Intr every new accel data is ready */
  74#define BMA023_RESET_VAL	BIT(1)
  75
  76#define BMA180_CHIP_ID		0x00 /* Need to distinguish BMA180 from other */
  77#define BMA180_ACC_X_LSB	0x02 /* First of 6 registers of accel data */
  78#define BMA180_TEMP		0x08
  79#define BMA180_CTRL_REG0	0x0d
  80#define BMA180_RESET		0x10
  81#define BMA180_BW_TCS		0x20
  82#define BMA180_CTRL_REG3	0x21
  83#define BMA180_TCO_Z		0x30
  84#define BMA180_OFFSET_LSB1	0x35
  85
  86/* BMA180_CTRL_REG0 bits */
  87#define BMA180_DIS_WAKE_UP	BIT(0) /* Disable wake up mode */
  88#define BMA180_SLEEP		BIT(1) /* 1 - chip will sleep */
  89#define BMA180_EE_W		BIT(4) /* Unlock writing to addr from 0x20 */
  90#define BMA180_RESET_INT	BIT(6) /* Reset pending interrupts */
  91
  92/* BMA180_CTRL_REG3 bits */
  93#define BMA180_NEW_DATA_INT	BIT(1) /* Intr every new accel data is ready */
  94
  95/* BMA180_OFFSET_LSB1 skipping mode bit */
  96#define BMA180_SMP_SKIP		BIT(0)
  97
  98/* Bit masks for registers bit fields */
  99#define BMA180_RANGE		0x0e /* Range of measured accel values */
 100#define BMA180_BW		0xf0 /* Accel bandwidth */
 101#define BMA180_MODE_CONFIG	0x03 /* Config operation modes */
 102
 103/* We have to write this value in reset register to do soft reset */
 104#define BMA180_RESET_VAL	0xb6
 105
 106#define BMA023_ID_REG_VAL	0x02
 107#define BMA180_ID_REG_VAL	0x03
 108#define BMA250_ID_REG_VAL	0x03
 109
 110/* Chip power modes */
 111#define BMA180_LOW_POWER	0x03
 112
 113#define BMA250_RANGE_REG	0x0f
 114#define BMA250_BW_REG		0x10
 115#define BMA250_POWER_REG	0x11
 116#define BMA250_RESET_REG	0x14
 117#define BMA250_INT_ENABLE_REG	0x17
 118#define BMA250_INT_MAP_REG	0x1a
 119#define BMA250_INT_RESET_REG	0x21
 120
 121#define BMA250_RANGE_MASK	GENMASK(3, 0) /* Range of accel values */
 122#define BMA250_BW_MASK		GENMASK(4, 0) /* Accel bandwidth */
 123#define BMA250_BW_OFFSET	8
 124#define BMA250_SUSPEND_MASK	BIT(7) /* chip will sleep */
 125#define BMA250_LOWPOWER_MASK	BIT(6)
 126#define BMA250_DATA_INTEN_MASK	BIT(4)
 127#define BMA250_INT1_DATA_MASK	BIT(0)
 128#define BMA250_INT_RESET_MASK	BIT(7) /* Reset pending interrupts */
 129
 130struct bma180_data {
 131	struct regulator *vdd_supply;
 132	struct regulator *vddio_supply;
 133	struct i2c_client *client;
 134	struct iio_trigger *trig;
 135	const struct bma180_part_info *part_info;
 136	struct iio_mount_matrix orientation;
 137	struct mutex mutex;
 138	bool sleep_state;
 139	int scale;
 140	int bw;
 141	bool pmode;
 142};
 143
 144enum bma180_chan {
 145	AXIS_X,
 146	AXIS_Y,
 147	AXIS_Z,
 148	TEMP
 149};
 150
 151static int bma023_bw_table[] = { 25, 50, 100, 190, 375, 750, 1500 }; /* Hz */
 152static int bma023_scale_table[] = { 2452, 4903, 9709, };
 153
 154static int bma180_bw_table[] = { 10, 20, 40, 75, 150, 300 }; /* Hz */
 155static int bma180_scale_table[] = { 1275, 1863, 2452, 3727, 4903, 9709, 19417 };
 156
 157static int bma250_bw_table[] = { 8, 16, 31, 63, 125, 250, 500, 1000 }; /* Hz */
 158static int bma250_scale_table[] = { 0, 0, 0, 38344, 0, 76590, 0, 0, 153180, 0,
 159	0, 0, 306458 };
 160
 161static int bma180_get_data_reg(struct bma180_data *data, enum bma180_chan chan)
 162{
 163	int ret;
 164
 165	if (data->sleep_state)
 166		return -EBUSY;
 167
 168	switch (chan) {
 169	case TEMP:
 170		ret = i2c_smbus_read_byte_data(data->client, BMA180_TEMP);
 171		if (ret < 0)
 172			dev_err(&data->client->dev, "failed to read temp register\n");
 173		break;
 174	default:
 175		ret = i2c_smbus_read_word_data(data->client,
 176			BMA180_ACC_X_LSB + chan * 2);
 177		if (ret < 0)
 178			dev_err(&data->client->dev,
 179				"failed to read accel_%c register\n",
 180				'x' + chan);
 181	}
 182
 183	return ret;
 184}
 185
 186static int bma180_set_bits(struct bma180_data *data, u8 reg, u8 mask, u8 val)
 187{
 188	int ret = i2c_smbus_read_byte_data(data->client, reg);
 189	u8 reg_val = (ret & ~mask) | (val << (ffs(mask) - 1));
 190
 191	if (ret < 0)
 192		return ret;
 193
 194	return i2c_smbus_write_byte_data(data->client, reg, reg_val);
 195}
 196
 197static int bma180_reset_intr(struct bma180_data *data)
 198{
 199	int ret = bma180_set_bits(data, data->part_info->int_reset_reg,
 200		data->part_info->int_reset_mask, 1);
 201
 202	if (ret)
 203		dev_err(&data->client->dev, "failed to reset interrupt\n");
 204
 205	return ret;
 206}
 207
 208static int bma180_set_new_data_intr_state(struct bma180_data *data, bool state)
 209{
 210	int ret = bma180_set_bits(data, data->part_info->int_enable_reg,
 211			data->part_info->int_enable_mask, state);
 212	if (ret)
 213		goto err;
 214	ret = bma180_reset_intr(data);
 215	if (ret)
 216		goto err;
 217
 218	return 0;
 219
 220err:
 221	dev_err(&data->client->dev,
 222		"failed to set new data interrupt state %d\n", state);
 223	return ret;
 224}
 225
 226static int bma180_set_sleep_state(struct bma180_data *data, bool state)
 227{
 228	int ret = bma180_set_bits(data, data->part_info->sleep_reg,
 229		data->part_info->sleep_mask, state);
 230
 231	if (ret) {
 232		dev_err(&data->client->dev,
 233			"failed to set sleep state %d\n", state);
 234		return ret;
 235	}
 236	data->sleep_state = state;
 237
 238	return 0;
 239}
 240
 241static int bma180_set_ee_writing_state(struct bma180_data *data, bool state)
 242{
 243	int ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_EE_W, state);
 244
 245	if (ret)
 246		dev_err(&data->client->dev,
 247			"failed to set ee writing state %d\n", state);
 248
 249	return ret;
 250}
 251
 252static int bma180_set_bw(struct bma180_data *data, int val)
 253{
 254	int ret, i;
 255
 256	if (data->sleep_state)
 257		return -EBUSY;
 258
 259	for (i = 0; i < data->part_info->num_bw; ++i) {
 260		if (data->part_info->bw_table[i] == val) {
 261			ret = bma180_set_bits(data, data->part_info->bw_reg,
 262				data->part_info->bw_mask,
 263				i + data->part_info->bw_offset);
 264			if (ret) {
 265				dev_err(&data->client->dev,
 266					"failed to set bandwidth\n");
 267				return ret;
 268			}
 269			data->bw = val;
 270			return 0;
 271		}
 272	}
 273
 274	return -EINVAL;
 275}
 276
 277static int bma180_set_scale(struct bma180_data *data, int val)
 278{
 279	int ret, i;
 280
 281	if (data->sleep_state)
 282		return -EBUSY;
 283
 284	for (i = 0; i < data->part_info->num_scales; ++i)
 285		if (data->part_info->scale_table[i] == val) {
 286			ret = bma180_set_bits(data, data->part_info->scale_reg,
 287				data->part_info->scale_mask, i);
 288			if (ret) {
 289				dev_err(&data->client->dev,
 290					"failed to set scale\n");
 291				return ret;
 292			}
 293			data->scale = val;
 294			return 0;
 295		}
 296
 297	return -EINVAL;
 298}
 299
 300static int bma180_set_pmode(struct bma180_data *data, bool mode)
 301{
 302	u8 reg_val = mode ? data->part_info->lowpower_val : 0;
 303	int ret = bma180_set_bits(data, data->part_info->power_reg,
 304		data->part_info->power_mask, reg_val);
 305
 306	if (ret) {
 307		dev_err(&data->client->dev, "failed to set power mode\n");
 308		return ret;
 309	}
 310	data->pmode = mode;
 311
 312	return 0;
 313}
 314
 315static int bma180_soft_reset(struct bma180_data *data)
 316{
 317	int ret = i2c_smbus_write_byte_data(data->client,
 318		data->part_info->softreset_reg,
 319		data->part_info->softreset_val);
 320
 321	if (ret)
 322		dev_err(&data->client->dev, "failed to reset the chip\n");
 323
 324	return ret;
 325}
 326
 327static int bma180_chip_init(struct bma180_data *data)
 328{
 329	/* Try to read chip_id register. It must return 0x03. */
 330	int ret = i2c_smbus_read_byte_data(data->client, BMA180_CHIP_ID);
 331
 332	if (ret < 0)
 333		return ret;
 334	if (ret != data->part_info->chip_id) {
 335		dev_err(&data->client->dev, "wrong chip ID %d expected %d\n",
 336			ret, data->part_info->chip_id);
 337		return -ENODEV;
 338	}
 339
 340	ret = bma180_soft_reset(data);
 341	if (ret)
 342		return ret;
 343	/*
 344	 * No serial transaction should occur within minimum 10 us
 345	 * after soft_reset command
 346	 */
 347	msleep(20);
 348
 349	return bma180_set_new_data_intr_state(data, false);
 350}
 351
 352static int bma023_chip_config(struct bma180_data *data)
 353{
 354	int ret = bma180_chip_init(data);
 355
 356	if (ret)
 357		goto err;
 358
 359	ret = bma180_set_bw(data, 50); /* 50 Hz */
 360	if (ret)
 361		goto err;
 362	ret = bma180_set_scale(data, 2452); /* 2 G */
 363	if (ret)
 364		goto err;
 365
 366	return 0;
 367
 368err:
 369	dev_err(&data->client->dev, "failed to config the chip\n");
 370	return ret;
 371}
 372
 373static int bma180_chip_config(struct bma180_data *data)
 374{
 375	int ret = bma180_chip_init(data);
 376
 377	if (ret)
 378		goto err;
 379	ret = bma180_set_pmode(data, false);
 380	if (ret)
 381		goto err;
 382	ret = bma180_set_bits(data, BMA180_CTRL_REG0, BMA180_DIS_WAKE_UP, 1);
 383	if (ret)
 384		goto err;
 385	ret = bma180_set_ee_writing_state(data, true);
 386	if (ret)
 387		goto err;
 388	ret = bma180_set_bits(data, BMA180_OFFSET_LSB1, BMA180_SMP_SKIP, 1);
 389	if (ret)
 390		goto err;
 391	ret = bma180_set_bw(data, 20); /* 20 Hz */
 392	if (ret)
 393		goto err;
 394	ret = bma180_set_scale(data, 2452); /* 2 G */
 395	if (ret)
 396		goto err;
 397
 398	return 0;
 399
 400err:
 401	dev_err(&data->client->dev, "failed to config the chip\n");
 402	return ret;
 403}
 404
 405static int bma250_chip_config(struct bma180_data *data)
 406{
 407	int ret = bma180_chip_init(data);
 408
 409	if (ret)
 410		goto err;
 411	ret = bma180_set_pmode(data, false);
 412	if (ret)
 413		goto err;
 414	ret = bma180_set_bw(data, 16); /* 16 Hz */
 415	if (ret)
 416		goto err;
 417	ret = bma180_set_scale(data, 38344); /* 2 G */
 418	if (ret)
 419		goto err;
 420	/*
 421	 * This enables dataready interrupt on the INT1 pin
 422	 * FIXME: support using the INT2 pin
 423	 */
 424	ret = bma180_set_bits(data, BMA250_INT_MAP_REG, BMA250_INT1_DATA_MASK, 1);
 425	if (ret)
 426		goto err;
 427
 428	return 0;
 429
 430err:
 431	dev_err(&data->client->dev, "failed to config the chip\n");
 432	return ret;
 433}
 434
 435static void bma023_chip_disable(struct bma180_data *data)
 436{
 437	if (bma180_set_sleep_state(data, true))
 438		goto err;
 439
 440	return;
 441
 442err:
 443	dev_err(&data->client->dev, "failed to disable the chip\n");
 444}
 445
 446static void bma180_chip_disable(struct bma180_data *data)
 447{
 448	if (bma180_set_new_data_intr_state(data, false))
 449		goto err;
 450	if (bma180_set_ee_writing_state(data, false))
 451		goto err;
 452	if (bma180_set_sleep_state(data, true))
 453		goto err;
 454
 455	return;
 456
 457err:
 458	dev_err(&data->client->dev, "failed to disable the chip\n");
 459}
 460
 461static void bma250_chip_disable(struct bma180_data *data)
 462{
 463	if (bma180_set_new_data_intr_state(data, false))
 464		goto err;
 465	if (bma180_set_sleep_state(data, true))
 466		goto err;
 467
 468	return;
 469
 470err:
 471	dev_err(&data->client->dev, "failed to disable the chip\n");
 472}
 473
 474static ssize_t bma180_show_avail(char *buf, const int *vals, unsigned int n,
 475				 bool micros)
 476{
 477	size_t len = 0;
 478	int i;
 479
 480	for (i = 0; i < n; i++) {
 481		if (!vals[i])
 482			continue;
 483		len += scnprintf(buf + len, PAGE_SIZE - len,
 484			micros ? "0.%06d " : "%d ", vals[i]);
 485	}
 486	buf[len - 1] = '\n';
 487
 488	return len;
 489}
 490
 491static ssize_t bma180_show_filter_freq_avail(struct device *dev,
 492				struct device_attribute *attr, char *buf)
 493{
 494	struct bma180_data *data = iio_priv(dev_to_iio_dev(dev));
 495
 496	return bma180_show_avail(buf, data->part_info->bw_table,
 497		data->part_info->num_bw, false);
 498}
 499
 500static ssize_t bma180_show_scale_avail(struct device *dev,
 501				struct device_attribute *attr, char *buf)
 502{
 503	struct bma180_data *data = iio_priv(dev_to_iio_dev(dev));
 504
 505	return bma180_show_avail(buf, data->part_info->scale_table,
 506		data->part_info->num_scales, true);
 507}
 508
 509static IIO_DEVICE_ATTR(in_accel_filter_low_pass_3db_frequency_available,
 510	S_IRUGO, bma180_show_filter_freq_avail, NULL, 0);
 511
 512static IIO_DEVICE_ATTR(in_accel_scale_available,
 513	S_IRUGO, bma180_show_scale_avail, NULL, 0);
 514
 515static struct attribute *bma180_attributes[] = {
 516	&iio_dev_attr_in_accel_filter_low_pass_3db_frequency_available.
 517		dev_attr.attr,
 518	&iio_dev_attr_in_accel_scale_available.dev_attr.attr,
 519	NULL,
 520};
 521
 522static const struct attribute_group bma180_attrs_group = {
 523	.attrs = bma180_attributes,
 524};
 525
 526static int bma180_read_raw(struct iio_dev *indio_dev,
 527		struct iio_chan_spec const *chan, int *val, int *val2,
 528		long mask)
 529{
 530	struct bma180_data *data = iio_priv(indio_dev);
 531	int ret;
 532
 533	switch (mask) {
 534	case IIO_CHAN_INFO_RAW:
 535		if (!iio_device_claim_direct(indio_dev))
 536			return -EBUSY;
 537
 538		mutex_lock(&data->mutex);
 539		ret = bma180_get_data_reg(data, chan->scan_index);
 540		mutex_unlock(&data->mutex);
 541		iio_device_release_direct(indio_dev);
 542		if (ret < 0)
 543			return ret;
 544		if (chan->scan_type.sign == 's') {
 545			*val = sign_extend32(ret >> chan->scan_type.shift,
 546				chan->scan_type.realbits - 1);
 547		} else {
 548			*val = ret;
 549		}
 550		return IIO_VAL_INT;
 551	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 552		*val = data->bw;
 553		return IIO_VAL_INT;
 554	case IIO_CHAN_INFO_SCALE:
 555		switch (chan->type) {
 556		case IIO_ACCEL:
 557			*val = 0;
 558			*val2 = data->scale;
 559			return IIO_VAL_INT_PLUS_MICRO;
 560		case IIO_TEMP:
 561			*val = 500;
 562			return IIO_VAL_INT;
 563		default:
 564			return -EINVAL;
 565		}
 566	case IIO_CHAN_INFO_OFFSET:
 567		*val = data->part_info->temp_offset;
 568		return IIO_VAL_INT;
 569	default:
 570		return -EINVAL;
 571	}
 572}
 573
 574static int bma180_write_raw(struct iio_dev *indio_dev,
 575		struct iio_chan_spec const *chan, int val, int val2, long mask)
 576{
 577	struct bma180_data *data = iio_priv(indio_dev);
 578	int ret;
 579
 580	switch (mask) {
 581	case IIO_CHAN_INFO_SCALE:
 582		if (val)
 583			return -EINVAL;
 584		mutex_lock(&data->mutex);
 585		ret = bma180_set_scale(data, val2);
 586		mutex_unlock(&data->mutex);
 587		return ret;
 588	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 589		if (val2)
 590			return -EINVAL;
 591		mutex_lock(&data->mutex);
 592		ret = bma180_set_bw(data, val);
 593		mutex_unlock(&data->mutex);
 594		return ret;
 595	default:
 596		return -EINVAL;
 597	}
 598}
 599
 600static const struct iio_info bma180_info = {
 601	.attrs			= &bma180_attrs_group,
 602	.read_raw		= bma180_read_raw,
 603	.write_raw		= bma180_write_raw,
 604};
 605
 606static const char * const bma180_power_modes[] = { "low_noise", "low_power" };
 607
 608static int bma180_get_power_mode(struct iio_dev *indio_dev,
 609		const struct iio_chan_spec *chan)
 610{
 611	struct bma180_data *data = iio_priv(indio_dev);
 612
 613	return data->pmode;
 614}
 615
 616static int bma180_set_power_mode(struct iio_dev *indio_dev,
 617		const struct iio_chan_spec *chan, unsigned int mode)
 618{
 619	struct bma180_data *data = iio_priv(indio_dev);
 620	int ret;
 621
 622	mutex_lock(&data->mutex);
 623	ret = bma180_set_pmode(data, mode);
 624	mutex_unlock(&data->mutex);
 625
 626	return ret;
 627}
 628
 629static const struct iio_mount_matrix *
 630bma180_accel_get_mount_matrix(const struct iio_dev *indio_dev,
 631				const struct iio_chan_spec *chan)
 632{
 633	struct bma180_data *data = iio_priv(indio_dev);
 634
 635	return &data->orientation;
 636}
 637
 638static const struct iio_enum bma180_power_mode_enum = {
 639	.items = bma180_power_modes,
 640	.num_items = ARRAY_SIZE(bma180_power_modes),
 641	.get = bma180_get_power_mode,
 642	.set = bma180_set_power_mode,
 643};
 644
 645static const struct iio_chan_spec_ext_info bma023_ext_info[] = {
 646	IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, bma180_accel_get_mount_matrix),
 647	{ }
 648};
 649
 650static const struct iio_chan_spec_ext_info bma180_ext_info[] = {
 651	IIO_ENUM("power_mode", IIO_SHARED_BY_TYPE, &bma180_power_mode_enum),
 652	IIO_ENUM_AVAILABLE("power_mode", IIO_SHARED_BY_TYPE, &bma180_power_mode_enum),
 653	IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, bma180_accel_get_mount_matrix),
 654	{ }
 655};
 656
 657#define BMA023_ACC_CHANNEL(_axis, _bits) {				\
 658	.type = IIO_ACCEL,						\
 659	.modified = 1,							\
 660	.channel2 = IIO_MOD_##_axis,					\
 661	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),			\
 662	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |		\
 663		BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),	\
 664	.scan_index = AXIS_##_axis,					\
 665	.scan_type = {							\
 666		.sign = 's',						\
 667		.realbits = _bits,					\
 668		.storagebits = 16,					\
 669		.shift = 16 - _bits,					\
 670	},								\
 671	.ext_info = bma023_ext_info,					\
 672}
 673
 674#define BMA150_TEMP_CHANNEL {						\
 675	.type = IIO_TEMP,						\
 676	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |			\
 677		BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET),	\
 678	.scan_index = TEMP,						\
 679	.scan_type = {							\
 680		.sign = 'u',						\
 681		.realbits = 8,						\
 682		.storagebits = 16,					\
 683	},								\
 684}
 685
 686#define BMA180_ACC_CHANNEL(_axis, _bits) {				\
 687	.type = IIO_ACCEL,						\
 688	.modified = 1,							\
 689	.channel2 = IIO_MOD_##_axis,					\
 690	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),			\
 691	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |		\
 692		BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),	\
 693	.scan_index = AXIS_##_axis,					\
 694	.scan_type = {							\
 695		.sign = 's',						\
 696		.realbits = _bits,					\
 697		.storagebits = 16,					\
 698		.shift = 16 - _bits,					\
 699	},								\
 700	.ext_info = bma180_ext_info,					\
 701}
 702
 703#define BMA180_TEMP_CHANNEL {						\
 704	.type = IIO_TEMP,						\
 705	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |			\
 706		BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET),	\
 707	.scan_index = TEMP,						\
 708	.scan_type = {							\
 709		.sign = 's',						\
 710		.realbits = 8,						\
 711		.storagebits = 16,					\
 712	},								\
 713}
 714
 715static const struct iio_chan_spec bma023_channels[] = {
 716	BMA023_ACC_CHANNEL(X, 10),
 717	BMA023_ACC_CHANNEL(Y, 10),
 718	BMA023_ACC_CHANNEL(Z, 10),
 719	IIO_CHAN_SOFT_TIMESTAMP(4),
 720};
 721
 722static const struct iio_chan_spec bma150_channels[] = {
 723	BMA023_ACC_CHANNEL(X, 10),
 724	BMA023_ACC_CHANNEL(Y, 10),
 725	BMA023_ACC_CHANNEL(Z, 10),
 726	BMA150_TEMP_CHANNEL,
 727	IIO_CHAN_SOFT_TIMESTAMP(4),
 728};
 729
 730static const struct iio_chan_spec bma180_channels[] = {
 731	BMA180_ACC_CHANNEL(X, 14),
 732	BMA180_ACC_CHANNEL(Y, 14),
 733	BMA180_ACC_CHANNEL(Z, 14),
 734	BMA180_TEMP_CHANNEL,
 735	IIO_CHAN_SOFT_TIMESTAMP(4),
 736};
 737
 738static const struct iio_chan_spec bma250_channels[] = {
 739	BMA180_ACC_CHANNEL(X, 10),
 740	BMA180_ACC_CHANNEL(Y, 10),
 741	BMA180_ACC_CHANNEL(Z, 10),
 742	BMA180_TEMP_CHANNEL,
 743	IIO_CHAN_SOFT_TIMESTAMP(4),
 744};
 745
 746static const struct bma180_part_info bma180_part_info[] = {
 747	[BMA023] = {
 748		.chip_id = BMA023_ID_REG_VAL,
 749		.channels = bma023_channels,
 750		.num_channels = ARRAY_SIZE(bma023_channels),
 751		.scale_table = bma023_scale_table,
 752		.num_scales = ARRAY_SIZE(bma023_scale_table),
 753		.bw_table = bma023_bw_table,
 754		.num_bw = ARRAY_SIZE(bma023_bw_table),
 755		/* No temperature channel */
 756		.temp_offset = 0,
 757		.int_reset_reg = BMA023_CTRL_REG0,
 758		.int_reset_mask = BMA023_INT_RESET_MASK,
 759		.sleep_reg = BMA023_CTRL_REG0,
 760		.sleep_mask = BMA023_SLEEP,
 761		.bw_reg = BMA023_CTRL_REG2,
 762		.bw_mask = BMA023_BW_MASK,
 763		.scale_reg = BMA023_CTRL_REG2,
 764		.scale_mask = BMA023_RANGE_MASK,
 765		/* No power mode on bma023 */
 766		.power_reg = 0,
 767		.power_mask = 0,
 768		.lowpower_val = 0,
 769		.int_enable_reg = BMA023_CTRL_REG3,
 770		.int_enable_mask = BMA023_NEW_DATA_INT,
 771		.softreset_reg = BMA023_CTRL_REG0,
 772		.softreset_val = BMA023_RESET_VAL,
 773		.chip_config = bma023_chip_config,
 774		.chip_disable = bma023_chip_disable,
 775	},
 776	[BMA150] = {
 777		.chip_id = BMA023_ID_REG_VAL,
 778		.channels = bma150_channels,
 779		.num_channels = ARRAY_SIZE(bma150_channels),
 780		.scale_table = bma023_scale_table,
 781		.num_scales = ARRAY_SIZE(bma023_scale_table),
 782		.bw_table = bma023_bw_table,
 783		.num_bw = ARRAY_SIZE(bma023_bw_table),
 784		.temp_offset = -60, /* 0 LSB @ -30 degree C */
 785		.int_reset_reg = BMA023_CTRL_REG0,
 786		.int_reset_mask = BMA023_INT_RESET_MASK,
 787		.sleep_reg = BMA023_CTRL_REG0,
 788		.sleep_mask = BMA023_SLEEP,
 789		.bw_reg = BMA023_CTRL_REG2,
 790		.bw_mask = BMA023_BW_MASK,
 791		.scale_reg = BMA023_CTRL_REG2,
 792		.scale_mask = BMA023_RANGE_MASK,
 793		/* No power mode on bma150 */
 794		.power_reg = 0,
 795		.power_mask = 0,
 796		.lowpower_val = 0,
 797		.int_enable_reg = BMA023_CTRL_REG3,
 798		.int_enable_mask = BMA023_NEW_DATA_INT,
 799		.softreset_reg = BMA023_CTRL_REG0,
 800		.softreset_val = BMA023_RESET_VAL,
 801		.chip_config = bma023_chip_config,
 802		.chip_disable = bma023_chip_disable,
 803	},
 804	[BMA180] = {
 805		.chip_id = BMA180_ID_REG_VAL,
 806		.channels = bma180_channels,
 807		.num_channels = ARRAY_SIZE(bma180_channels),
 808		.scale_table = bma180_scale_table,
 809		.num_scales = ARRAY_SIZE(bma180_scale_table),
 810		.bw_table = bma180_bw_table,
 811		.num_bw = ARRAY_SIZE(bma180_bw_table),
 812		.temp_offset = 48, /* 0 LSB @ 24 degree C */
 813		.int_reset_reg = BMA180_CTRL_REG0,
 814		.int_reset_mask = BMA180_RESET_INT,
 815		.sleep_reg = BMA180_CTRL_REG0,
 816		.sleep_mask = BMA180_SLEEP,
 817		.bw_reg = BMA180_BW_TCS,
 818		.bw_mask = BMA180_BW,
 819		.scale_reg = BMA180_OFFSET_LSB1,
 820		.scale_mask = BMA180_RANGE,
 821		.power_reg = BMA180_TCO_Z,
 822		.power_mask = BMA180_MODE_CONFIG,
 823		.lowpower_val = BMA180_LOW_POWER,
 824		.int_enable_reg = BMA180_CTRL_REG3,
 825		.int_enable_mask = BMA180_NEW_DATA_INT,
 826		.softreset_reg = BMA180_RESET,
 827		.softreset_val = BMA180_RESET_VAL,
 828		.chip_config = bma180_chip_config,
 829		.chip_disable = bma180_chip_disable,
 830	},
 831	[BMA250] = {
 832		.chip_id = BMA250_ID_REG_VAL,
 833		.channels = bma250_channels,
 834		.num_channels = ARRAY_SIZE(bma250_channels),
 835		.scale_table = bma250_scale_table,
 836		.num_scales = ARRAY_SIZE(bma250_scale_table),
 837		.bw_table = bma250_bw_table,
 838		.num_bw = ARRAY_SIZE(bma250_bw_table),
 839		.temp_offset = 48, /* 0 LSB @ 24 degree C */
 840		.int_reset_reg = BMA250_INT_RESET_REG,
 841		.int_reset_mask = BMA250_INT_RESET_MASK,
 842		.sleep_reg = BMA250_POWER_REG,
 843		.sleep_mask = BMA250_SUSPEND_MASK,
 844		.bw_reg = BMA250_BW_REG,
 845		.bw_mask = BMA250_BW_MASK,
 846		.bw_offset = BMA250_BW_OFFSET,
 847		.scale_reg = BMA250_RANGE_REG,
 848		.scale_mask = BMA250_RANGE_MASK,
 849		.power_reg = BMA250_POWER_REG,
 850		.power_mask = BMA250_LOWPOWER_MASK,
 851		.lowpower_val = 1,
 852		.int_enable_reg = BMA250_INT_ENABLE_REG,
 853		.int_enable_mask = BMA250_DATA_INTEN_MASK,
 854		.softreset_reg = BMA250_RESET_REG,
 855		.softreset_val = BMA180_RESET_VAL,
 856		.chip_config = bma250_chip_config,
 857		.chip_disable = bma250_chip_disable,
 858	},
 859};
 860
 861static irqreturn_t bma180_trigger_handler(int irq, void *p)
 862{
 863	struct iio_poll_func *pf = p;
 864	struct iio_dev *indio_dev = pf->indio_dev;
 865	struct bma180_data *data = iio_priv(indio_dev);
 866	s64 time_ns = iio_get_time_ns(indio_dev);
 867	int bit, ret, i = 0;
 868	struct {
 869		s16 chan[4];
 870		aligned_s64 timestamp;
 871	} scan = { };
 872
 873	mutex_lock(&data->mutex);
 874
 875	iio_for_each_active_channel(indio_dev, bit) {
 876		ret = bma180_get_data_reg(data, bit);
 877		if (ret < 0) {
 878			mutex_unlock(&data->mutex);
 879			goto err;
 880		}
 881		scan.chan[i++] = ret;
 882	}
 883
 884	mutex_unlock(&data->mutex);
 885
 886	iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan), time_ns);
 887err:
 888	iio_trigger_notify_done(indio_dev->trig);
 889
 890	return IRQ_HANDLED;
 891}
 892
 893static int bma180_data_rdy_trigger_set_state(struct iio_trigger *trig,
 894		bool state)
 895{
 896	struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 897	struct bma180_data *data = iio_priv(indio_dev);
 898
 899	return bma180_set_new_data_intr_state(data, state);
 900}
 901
 902static void bma180_trig_reen(struct iio_trigger *trig)
 903{
 904	struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 905	struct bma180_data *data = iio_priv(indio_dev);
 906	int ret;
 907
 908	ret = bma180_reset_intr(data);
 909	if (ret)
 910		dev_err(&data->client->dev, "failed to reset interrupt\n");
 911}
 912
 913static const struct iio_trigger_ops bma180_trigger_ops = {
 914	.set_trigger_state = bma180_data_rdy_trigger_set_state,
 915	.reenable = bma180_trig_reen,
 916};
 917
 918static int bma180_probe(struct i2c_client *client)
 919{
 920	const struct i2c_device_id *id = i2c_client_get_device_id(client);
 921	struct device *dev = &client->dev;
 922	struct bma180_data *data;
 923	struct iio_dev *indio_dev;
 924	int ret;
 925
 926	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
 927	if (!indio_dev)
 928		return -ENOMEM;
 929
 930	data = iio_priv(indio_dev);
 931	i2c_set_clientdata(client, indio_dev);
 932	data->client = client;
 933	data->part_info = i2c_get_match_data(client);
 934
 935	ret = iio_read_mount_matrix(dev, &data->orientation);
 936	if (ret)
 937		return ret;
 938
 939	data->vdd_supply = devm_regulator_get(dev, "vdd");
 940	if (IS_ERR(data->vdd_supply))
 941		return dev_err_probe(dev, PTR_ERR(data->vdd_supply),
 942				     "Failed to get vdd regulator\n");
 943
 944	data->vddio_supply = devm_regulator_get(dev, "vddio");
 945	if (IS_ERR(data->vddio_supply))
 946		return dev_err_probe(dev, PTR_ERR(data->vddio_supply),
 947				     "Failed to get vddio regulator\n");
 948
 949	/* Typical voltage 2.4V these are min and max */
 950	ret = regulator_set_voltage(data->vdd_supply, 1620000, 3600000);
 951	if (ret)
 952		return ret;
 953	ret = regulator_set_voltage(data->vddio_supply, 1200000, 3600000);
 954	if (ret)
 955		return ret;
 956	ret = regulator_enable(data->vdd_supply);
 957	if (ret) {
 958		dev_err(dev, "Failed to enable vdd regulator: %d\n", ret);
 959		return ret;
 960	}
 961	ret = regulator_enable(data->vddio_supply);
 962	if (ret) {
 963		dev_err(dev, "Failed to enable vddio regulator: %d\n", ret);
 964		goto err_disable_vdd;
 965	}
 966	/* Wait to make sure we started up properly (3 ms at least) */
 967	usleep_range(3000, 5000);
 968
 969	ret = data->part_info->chip_config(data);
 970	if (ret < 0)
 971		goto err_chip_disable;
 972
 973	mutex_init(&data->mutex);
 974	indio_dev->channels = data->part_info->channels;
 975	indio_dev->num_channels = data->part_info->num_channels;
 976	indio_dev->name = id->name;
 977	indio_dev->modes = INDIO_DIRECT_MODE;
 978	indio_dev->info = &bma180_info;
 979
 980	if (client->irq > 0) {
 981		data->trig = iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
 982					       iio_device_id(indio_dev));
 983		if (!data->trig) {
 984			ret = -ENOMEM;
 985			goto err_chip_disable;
 986		}
 987
 988		ret = devm_request_irq(dev, client->irq,
 989				       iio_trigger_generic_data_rdy_poll,
 990				       IRQF_TRIGGER_RISING | IRQF_NO_THREAD,
 991				       "bma180_event", data->trig);
 992		if (ret) {
 993			dev_err(dev, "unable to request IRQ\n");
 994			goto err_trigger_free;
 995		}
 996
 997		data->trig->ops = &bma180_trigger_ops;
 998		iio_trigger_set_drvdata(data->trig, indio_dev);
 999
1000		ret = iio_trigger_register(data->trig);
1001		if (ret)
1002			goto err_trigger_free;
1003
1004		indio_dev->trig = iio_trigger_get(data->trig);
1005	}
1006
1007	ret = iio_triggered_buffer_setup(indio_dev, NULL,
1008			bma180_trigger_handler, NULL);
1009	if (ret < 0) {
1010		dev_err(dev, "unable to setup iio triggered buffer\n");
1011		goto err_trigger_unregister;
1012	}
1013
1014	ret = iio_device_register(indio_dev);
1015	if (ret < 0) {
1016		dev_err(dev, "unable to register iio device\n");
1017		goto err_buffer_cleanup;
1018	}
1019
1020	return 0;
1021
1022err_buffer_cleanup:
1023	iio_triggered_buffer_cleanup(indio_dev);
1024err_trigger_unregister:
1025	if (data->trig)
1026		iio_trigger_unregister(data->trig);
1027err_trigger_free:
1028	iio_trigger_free(data->trig);
1029err_chip_disable:
1030	data->part_info->chip_disable(data);
1031	regulator_disable(data->vddio_supply);
1032err_disable_vdd:
1033	regulator_disable(data->vdd_supply);
1034
1035	return ret;
1036}
1037
1038static void bma180_remove(struct i2c_client *client)
1039{
1040	struct iio_dev *indio_dev = i2c_get_clientdata(client);
1041	struct bma180_data *data = iio_priv(indio_dev);
1042
1043	iio_device_unregister(indio_dev);
1044	iio_triggered_buffer_cleanup(indio_dev);
1045	if (data->trig) {
1046		iio_trigger_unregister(data->trig);
1047		iio_trigger_free(data->trig);
1048	}
1049
1050	mutex_lock(&data->mutex);
1051	data->part_info->chip_disable(data);
1052	mutex_unlock(&data->mutex);
1053	regulator_disable(data->vddio_supply);
1054	regulator_disable(data->vdd_supply);
1055}
1056
1057static int bma180_suspend(struct device *dev)
1058{
1059	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1060	struct bma180_data *data = iio_priv(indio_dev);
1061	int ret;
1062
1063	mutex_lock(&data->mutex);
1064	ret = bma180_set_sleep_state(data, true);
1065	mutex_unlock(&data->mutex);
1066
1067	return ret;
1068}
1069
1070static int bma180_resume(struct device *dev)
1071{
1072	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1073	struct bma180_data *data = iio_priv(indio_dev);
1074	int ret;
1075
1076	mutex_lock(&data->mutex);
1077	ret = bma180_set_sleep_state(data, false);
1078	mutex_unlock(&data->mutex);
1079
1080	return ret;
1081}
1082
1083static DEFINE_SIMPLE_DEV_PM_OPS(bma180_pm_ops, bma180_suspend, bma180_resume);
1084
1085static const struct i2c_device_id bma180_ids[] = {
1086	{ "bma023", (kernel_ulong_t)&bma180_part_info[BMA023] },
1087	{ "bma150", (kernel_ulong_t)&bma180_part_info[BMA150] },
1088	{ "bma180", (kernel_ulong_t)&bma180_part_info[BMA180] },
1089	{ "bma250", (kernel_ulong_t)&bma180_part_info[BMA250] },
1090	{ "smb380", (kernel_ulong_t)&bma180_part_info[BMA150] },
1091	{ }
1092};
1093
1094MODULE_DEVICE_TABLE(i2c, bma180_ids);
1095
1096static const struct of_device_id bma180_of_match[] = {
1097	{
1098		.compatible = "bosch,bma023",
1099		.data = &bma180_part_info[BMA023]
1100	},
1101	{
1102		.compatible = "bosch,bma150",
1103		.data = &bma180_part_info[BMA150]
1104	},
1105	{
1106		.compatible = "bosch,bma180",
1107		.data = &bma180_part_info[BMA180]
1108	},
1109	{
1110		.compatible = "bosch,bma250",
1111		.data = &bma180_part_info[BMA250]
1112	},
1113	{
1114		.compatible = "bosch,smb380",
1115		.data = &bma180_part_info[BMA150]
1116	},
1117	{ }
1118};
1119MODULE_DEVICE_TABLE(of, bma180_of_match);
1120
1121static struct i2c_driver bma180_driver = {
1122	.driver = {
1123		.name	= "bma180",
1124		.pm	= pm_sleep_ptr(&bma180_pm_ops),
1125		.of_match_table = bma180_of_match,
1126	},
1127	.probe		= bma180_probe,
1128	.remove		= bma180_remove,
1129	.id_table	= bma180_ids,
1130};
1131
1132module_i2c_driver(bma180_driver);
1133
1134MODULE_AUTHOR("Kravchenko Oleksandr <x0199363@ti.com>");
1135MODULE_AUTHOR("Texas Instruments, Inc.");
1136MODULE_DESCRIPTION("Bosch BMA023/BMA1x0/BMA250 triaxial acceleration sensor");
1137MODULE_LICENSE("GPL");