2 * BMI160 - Bosch IMU (accel, gyro plus external magnetometer)
4 * Copyright (c) 2016, Intel Corporation.
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.
10 * IIO core driver for BMI160, with support for I2C/SPI busses
12 * TODO: magnetometer, interrupts, hardware FIFO
14 #include <linux/module.h>
15 #include <linux/regmap.h>
16 #include <linux/acpi.h>
17 #include <linux/delay.h>
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 #include <linux/iio/sysfs.h>
27 #define BMI160_REG_CHIP_ID 0x00
28 #define BMI160_CHIP_ID_VAL 0xD1
30 #define BMI160_REG_PMU_STATUS 0x03
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
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)
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
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)
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
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
67 #define BMI160_REG_DUMMY 0x7F
69 #define BMI160_ACCEL_PMU_MIN_USLEEP 3800
70 #define BMI160_GYRO_PMU_MIN_USLEEP 80000
71 #define BMI160_SOFTRESET_USLEEP 1000
73 #define BMI160_CHANNEL(_type, _axis, _index) { \
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, \
85 .endianness = IIO_LE, \
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,
101 BMI160_SCAN_TIMESTAMP,
104 enum bmi160_sensor_type {
108 BMI160_NUM_SENSORS /* must be last */
112 struct regmap *regmap;
114 * Ensure natural alignment for timestamp if present.
115 * Max length needed: 2 * 3 channels + 4 bytes padding + 8 byte ts.
116 * If fewer channels are enabled, less space may be needed, as
117 * long as the timestamp is still aligned to 8 bytes.
119 __le16 buf[12] __aligned(8);
122 const struct regmap_config bmi160_regmap_config = {
126 EXPORT_SYMBOL(bmi160_regmap_config);
129 u8 data; /* LSB byte register for X-axis */
138 static struct bmi160_regs bmi160_regs[] = {
140 .data = BMI160_REG_DATA_ACCEL_XOUT_L,
141 .config = BMI160_REG_ACCEL_CONFIG,
142 .config_odr_mask = BMI160_ACCEL_CONFIG_ODR_MASK,
143 .config_bwp_mask = BMI160_ACCEL_CONFIG_BWP_MASK,
144 .range = BMI160_REG_ACCEL_RANGE,
145 .pmu_cmd_normal = BMI160_CMD_ACCEL_PM_NORMAL,
146 .pmu_cmd_suspend = BMI160_CMD_ACCEL_PM_SUSPEND,
149 .data = BMI160_REG_DATA_GYRO_XOUT_L,
150 .config = BMI160_REG_GYRO_CONFIG,
151 .config_odr_mask = BMI160_GYRO_CONFIG_ODR_MASK,
152 .config_bwp_mask = BMI160_GYRO_CONFIG_BWP_MASK,
153 .range = BMI160_REG_GYRO_RANGE,
154 .pmu_cmd_normal = BMI160_CMD_GYRO_PM_NORMAL,
155 .pmu_cmd_suspend = BMI160_CMD_GYRO_PM_SUSPEND,
159 static unsigned long bmi160_pmu_time[] = {
160 [BMI160_ACCEL] = BMI160_ACCEL_PMU_MIN_USLEEP,
161 [BMI160_GYRO] = BMI160_GYRO_PMU_MIN_USLEEP,
164 struct bmi160_scale {
175 static const struct bmi160_scale bmi160_accel_scale[] = {
176 { BMI160_ACCEL_RANGE_2G, 598},
177 { BMI160_ACCEL_RANGE_4G, 1197},
178 { BMI160_ACCEL_RANGE_8G, 2394},
179 { BMI160_ACCEL_RANGE_16G, 4788},
182 static const struct bmi160_scale bmi160_gyro_scale[] = {
183 { BMI160_GYRO_RANGE_2000DPS, 1065},
184 { BMI160_GYRO_RANGE_1000DPS, 532},
185 { BMI160_GYRO_RANGE_500DPS, 266},
186 { BMI160_GYRO_RANGE_250DPS, 133},
187 { BMI160_GYRO_RANGE_125DPS, 66},
190 struct bmi160_scale_item {
191 const struct bmi160_scale *tbl;
195 static const struct bmi160_scale_item bmi160_scale_table[] = {
197 .tbl = bmi160_accel_scale,
198 .num = ARRAY_SIZE(bmi160_accel_scale),
201 .tbl = bmi160_gyro_scale,
202 .num = ARRAY_SIZE(bmi160_gyro_scale),
206 static const struct bmi160_odr bmi160_accel_odr[] = {
221 static const struct bmi160_odr bmi160_gyro_odr[] = {
232 struct bmi160_odr_item {
233 const struct bmi160_odr *tbl;
237 static const struct bmi160_odr_item bmi160_odr_table[] = {
239 .tbl = bmi160_accel_odr,
240 .num = ARRAY_SIZE(bmi160_accel_odr),
243 .tbl = bmi160_gyro_odr,
244 .num = ARRAY_SIZE(bmi160_gyro_odr),
248 static const struct iio_chan_spec bmi160_channels[] = {
249 BMI160_CHANNEL(IIO_ACCEL, X, BMI160_SCAN_ACCEL_X),
250 BMI160_CHANNEL(IIO_ACCEL, Y, BMI160_SCAN_ACCEL_Y),
251 BMI160_CHANNEL(IIO_ACCEL, Z, BMI160_SCAN_ACCEL_Z),
252 BMI160_CHANNEL(IIO_ANGL_VEL, X, BMI160_SCAN_GYRO_X),
253 BMI160_CHANNEL(IIO_ANGL_VEL, Y, BMI160_SCAN_GYRO_Y),
254 BMI160_CHANNEL(IIO_ANGL_VEL, Z, BMI160_SCAN_GYRO_Z),
255 IIO_CHAN_SOFT_TIMESTAMP(BMI160_SCAN_TIMESTAMP),
258 static enum bmi160_sensor_type bmi160_to_sensor(enum iio_chan_type iio_type)
271 int bmi160_set_mode(struct bmi160_data *data, enum bmi160_sensor_type t,
278 cmd = bmi160_regs[t].pmu_cmd_normal;
280 cmd = bmi160_regs[t].pmu_cmd_suspend;
282 ret = regmap_write(data->regmap, BMI160_REG_CMD, cmd);
286 usleep_range(bmi160_pmu_time[t], bmi160_pmu_time[t] + 1000);
292 int bmi160_set_scale(struct bmi160_data *data, enum bmi160_sensor_type t,
297 for (i = 0; i < bmi160_scale_table[t].num; i++)
298 if (bmi160_scale_table[t].tbl[i].uscale == uscale)
301 if (i == bmi160_scale_table[t].num)
304 return regmap_write(data->regmap, bmi160_regs[t].range,
305 bmi160_scale_table[t].tbl[i].bits);
309 int bmi160_get_scale(struct bmi160_data *data, enum bmi160_sensor_type t,
314 ret = regmap_read(data->regmap, bmi160_regs[t].range, &val);
318 for (i = 0; i < bmi160_scale_table[t].num; i++)
319 if (bmi160_scale_table[t].tbl[i].bits == val) {
320 *uscale = bmi160_scale_table[t].tbl[i].uscale;
327 static int bmi160_get_data(struct bmi160_data *data, int chan_type,
333 enum bmi160_sensor_type t = bmi160_to_sensor(chan_type);
335 reg = bmi160_regs[t].data + (axis - IIO_MOD_X) * sizeof(__le16);
337 ret = regmap_bulk_read(data->regmap, reg, &sample, sizeof(__le16));
341 *val = sign_extend32(le16_to_cpu(sample), 15);
347 int bmi160_set_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
352 for (i = 0; i < bmi160_odr_table[t].num; i++)
353 if (bmi160_odr_table[t].tbl[i].odr == odr &&
354 bmi160_odr_table[t].tbl[i].uodr == uodr)
357 if (i >= bmi160_odr_table[t].num)
360 return regmap_update_bits(data->regmap,
361 bmi160_regs[t].config,
362 bmi160_regs[t].config_odr_mask,
363 bmi160_odr_table[t].tbl[i].bits);
366 static int bmi160_get_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
371 ret = regmap_read(data->regmap, bmi160_regs[t].config, &val);
375 val &= bmi160_regs[t].config_odr_mask;
377 for (i = 0; i < bmi160_odr_table[t].num; i++)
378 if (val == bmi160_odr_table[t].tbl[i].bits)
381 if (i >= bmi160_odr_table[t].num)
384 *odr = bmi160_odr_table[t].tbl[i].odr;
385 *uodr = bmi160_odr_table[t].tbl[i].uodr;
390 static irqreturn_t bmi160_trigger_handler(int irq, void *p)
392 struct iio_poll_func *pf = p;
393 struct iio_dev *indio_dev = pf->indio_dev;
394 struct bmi160_data *data = iio_priv(indio_dev);
395 int i, ret, j = 0, base = BMI160_REG_DATA_MAGN_XOUT_L;
398 for_each_set_bit(i, indio_dev->active_scan_mask,
399 indio_dev->masklength) {
400 ret = regmap_bulk_read(data->regmap, base + i * sizeof(__le16),
401 &sample, sizeof(__le16));
404 data->buf[j++] = sample;
407 iio_push_to_buffers_with_timestamp(indio_dev, data->buf,
408 iio_get_time_ns(indio_dev));
410 iio_trigger_notify_done(indio_dev->trig);
414 static int bmi160_read_raw(struct iio_dev *indio_dev,
415 struct iio_chan_spec const *chan,
416 int *val, int *val2, long mask)
419 struct bmi160_data *data = iio_priv(indio_dev);
422 case IIO_CHAN_INFO_RAW:
423 ret = bmi160_get_data(data, chan->type, chan->channel2, val);
427 case IIO_CHAN_INFO_SCALE:
429 ret = bmi160_get_scale(data,
430 bmi160_to_sensor(chan->type), val2);
431 return ret < 0 ? ret : IIO_VAL_INT_PLUS_MICRO;
432 case IIO_CHAN_INFO_SAMP_FREQ:
433 ret = bmi160_get_odr(data, bmi160_to_sensor(chan->type),
435 return ret < 0 ? ret : IIO_VAL_INT_PLUS_MICRO;
443 static int bmi160_write_raw(struct iio_dev *indio_dev,
444 struct iio_chan_spec const *chan,
445 int val, int val2, long mask)
447 struct bmi160_data *data = iio_priv(indio_dev);
450 case IIO_CHAN_INFO_SCALE:
451 return bmi160_set_scale(data,
452 bmi160_to_sensor(chan->type), val2);
454 case IIO_CHAN_INFO_SAMP_FREQ:
455 return bmi160_set_odr(data, bmi160_to_sensor(chan->type),
465 IIO_CONST_ATTR(in_accel_sampling_frequency_available,
466 "0.78125 1.5625 3.125 6.25 12.5 25 50 100 200 400 800 1600");
468 IIO_CONST_ATTR(in_anglvel_sampling_frequency_available,
469 "25 50 100 200 400 800 1600 3200");
471 IIO_CONST_ATTR(in_accel_scale_available,
472 "0.000598 0.001197 0.002394 0.004788");
474 IIO_CONST_ATTR(in_anglvel_scale_available,
475 "0.001065 0.000532 0.000266 0.000133 0.000066");
477 static struct attribute *bmi160_attrs[] = {
478 &iio_const_attr_in_accel_sampling_frequency_available.dev_attr.attr,
479 &iio_const_attr_in_anglvel_sampling_frequency_available.dev_attr.attr,
480 &iio_const_attr_in_accel_scale_available.dev_attr.attr,
481 &iio_const_attr_in_anglvel_scale_available.dev_attr.attr,
485 static const struct attribute_group bmi160_attrs_group = {
486 .attrs = bmi160_attrs,
489 static const struct iio_info bmi160_info = {
490 .driver_module = THIS_MODULE,
491 .read_raw = bmi160_read_raw,
492 .write_raw = bmi160_write_raw,
493 .attrs = &bmi160_attrs_group,
496 static const char *bmi160_match_acpi_device(struct device *dev)
498 const struct acpi_device_id *id;
500 id = acpi_match_device(dev->driver->acpi_match_table, dev);
504 return dev_name(dev);
507 static int bmi160_chip_init(struct bmi160_data *data, bool use_spi)
511 struct device *dev = regmap_get_device(data->regmap);
513 ret = regmap_write(data->regmap, BMI160_REG_CMD, BMI160_CMD_SOFTRESET);
517 usleep_range(BMI160_SOFTRESET_USLEEP, BMI160_SOFTRESET_USLEEP + 1);
520 * CS rising edge is needed before starting SPI, so do a dummy read
521 * See Section 3.2.1, page 86 of the datasheet
524 ret = regmap_read(data->regmap, BMI160_REG_DUMMY, &val);
529 ret = regmap_read(data->regmap, BMI160_REG_CHIP_ID, &val);
531 dev_err(dev, "Error reading chip id\n");
534 if (val != BMI160_CHIP_ID_VAL) {
535 dev_err(dev, "Wrong chip id, got %x expected %x\n",
536 val, BMI160_CHIP_ID_VAL);
540 ret = bmi160_set_mode(data, BMI160_ACCEL, true);
544 ret = bmi160_set_mode(data, BMI160_GYRO, true);
551 static void bmi160_chip_uninit(struct bmi160_data *data)
553 bmi160_set_mode(data, BMI160_GYRO, false);
554 bmi160_set_mode(data, BMI160_ACCEL, false);
557 int bmi160_core_probe(struct device *dev, struct regmap *regmap,
558 const char *name, bool use_spi)
560 struct iio_dev *indio_dev;
561 struct bmi160_data *data;
564 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
568 data = iio_priv(indio_dev);
569 dev_set_drvdata(dev, indio_dev);
570 data->regmap = regmap;
572 ret = bmi160_chip_init(data, use_spi);
576 if (!name && ACPI_HANDLE(dev))
577 name = bmi160_match_acpi_device(dev);
579 indio_dev->dev.parent = dev;
580 indio_dev->channels = bmi160_channels;
581 indio_dev->num_channels = ARRAY_SIZE(bmi160_channels);
582 indio_dev->name = name;
583 indio_dev->modes = INDIO_DIRECT_MODE;
584 indio_dev->info = &bmi160_info;
586 ret = iio_triggered_buffer_setup(indio_dev, NULL,
587 bmi160_trigger_handler, NULL);
591 ret = iio_device_register(indio_dev);
597 iio_triggered_buffer_cleanup(indio_dev);
599 bmi160_chip_uninit(data);
602 EXPORT_SYMBOL_GPL(bmi160_core_probe);
604 void bmi160_core_remove(struct device *dev)
606 struct iio_dev *indio_dev = dev_get_drvdata(dev);
607 struct bmi160_data *data = iio_priv(indio_dev);
609 iio_device_unregister(indio_dev);
610 iio_triggered_buffer_cleanup(indio_dev);
611 bmi160_chip_uninit(data);
613 EXPORT_SYMBOL_GPL(bmi160_core_remove);
615 MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com");
616 MODULE_DESCRIPTION("Bosch BMI160 driver");
617 MODULE_LICENSE("GPL v2");