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