1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 3 #include <linux/bitfield.h> 4 #include <linux/firmware.h> 5 #include <linux/i2c.h> 6 #include <linux/module.h> 7 #include <linux/regmap.h> 8 9 #include <linux/iio/iio.h> 10 #include <linux/iio/sysfs.h> 11 #include <linux/iio/triggered_buffer.h> 12 #include <linux/iio/trigger_consumer.h> 13 14 #include "bmi270.h" 15 16 #define BMI270_CHIP_ID_REG 0x00 17 18 /* Checked to prevent sending incompatible firmware to BMI160 devices */ 19 #define BMI160_CHIP_ID_VAL 0xD1 20 21 #define BMI260_CHIP_ID_VAL 0x27 22 #define BMI270_CHIP_ID_VAL 0x24 23 #define BMI270_CHIP_ID_MSK GENMASK(7, 0) 24 25 #define BMI270_ACCEL_X_REG 0x0c 26 #define BMI270_ANG_VEL_X_REG 0x12 27 28 #define BMI270_INTERNAL_STATUS_REG 0x21 29 #define BMI270_INTERNAL_STATUS_MSG_MSK GENMASK(3, 0) 30 #define BMI270_INTERNAL_STATUS_MSG_INIT_OK 0x01 31 32 #define BMI270_INTERNAL_STATUS_AXES_REMAP_ERR_MSK BIT(5) 33 #define BMI270_INTERNAL_STATUS_ODR_50HZ_ERR_MSK BIT(6) 34 35 #define BMI270_ACC_CONF_REG 0x40 36 #define BMI270_ACC_CONF_ODR_MSK GENMASK(3, 0) 37 #define BMI270_ACC_CONF_ODR_100HZ 0x08 38 #define BMI270_ACC_CONF_BWP_MSK GENMASK(6, 4) 39 #define BMI270_ACC_CONF_BWP_NORMAL_MODE 0x02 40 #define BMI270_ACC_CONF_FILTER_PERF_MSK BIT(7) 41 42 #define BMI270_ACC_CONF_RANGE_REG 0x41 43 #define BMI270_ACC_CONF_RANGE_MSK GENMASK(1, 0) 44 45 #define BMI270_GYR_CONF_REG 0x42 46 #define BMI270_GYR_CONF_ODR_MSK GENMASK(3, 0) 47 #define BMI270_GYR_CONF_ODR_200HZ 0x09 48 #define BMI270_GYR_CONF_BWP_MSK GENMASK(5, 4) 49 #define BMI270_GYR_CONF_BWP_NORMAL_MODE 0x02 50 #define BMI270_GYR_CONF_NOISE_PERF_MSK BIT(6) 51 #define BMI270_GYR_CONF_FILTER_PERF_MSK BIT(7) 52 53 #define BMI270_GYR_CONF_RANGE_REG 0x43 54 #define BMI270_GYR_CONF_RANGE_MSK GENMASK(2, 0) 55 56 #define BMI270_INIT_CTRL_REG 0x59 57 #define BMI270_INIT_CTRL_LOAD_DONE_MSK BIT(0) 58 59 #define BMI270_INIT_DATA_REG 0x5e 60 61 #define BMI270_PWR_CONF_REG 0x7c 62 #define BMI270_PWR_CONF_ADV_PWR_SAVE_MSK BIT(0) 63 #define BMI270_PWR_CONF_FIFO_WKUP_MSK BIT(1) 64 #define BMI270_PWR_CONF_FUP_EN_MSK BIT(2) 65 66 #define BMI270_PWR_CTRL_REG 0x7d 67 #define BMI270_PWR_CTRL_AUX_EN_MSK BIT(0) 68 #define BMI270_PWR_CTRL_GYR_EN_MSK BIT(1) 69 #define BMI270_PWR_CTRL_ACCEL_EN_MSK BIT(2) 70 #define BMI270_PWR_CTRL_TEMP_EN_MSK BIT(3) 71 72 #define BMI260_INIT_DATA_FILE "bmi260-init-data.fw" 73 #define BMI270_INIT_DATA_FILE "bmi270-init-data.fw" 74 75 enum bmi270_scan { 76 BMI270_SCAN_ACCEL_X, 77 BMI270_SCAN_ACCEL_Y, 78 BMI270_SCAN_ACCEL_Z, 79 BMI270_SCAN_GYRO_X, 80 BMI270_SCAN_GYRO_Y, 81 BMI270_SCAN_GYRO_Z, 82 BMI270_SCAN_TIMESTAMP, 83 }; 84 85 static const unsigned long bmi270_avail_scan_masks[] = { 86 (BIT(BMI270_SCAN_ACCEL_X) | 87 BIT(BMI270_SCAN_ACCEL_Y) | 88 BIT(BMI270_SCAN_ACCEL_Z) | 89 BIT(BMI270_SCAN_GYRO_X) | 90 BIT(BMI270_SCAN_GYRO_Y) | 91 BIT(BMI270_SCAN_GYRO_Z)), 92 0 93 }; 94 95 const struct bmi270_chip_info bmi260_chip_info = { 96 .name = "bmi260", 97 .chip_id = BMI260_CHIP_ID_VAL, 98 .fw_name = BMI260_INIT_DATA_FILE, 99 }; 100 EXPORT_SYMBOL_NS_GPL(bmi260_chip_info, IIO_BMI270); 101 102 const struct bmi270_chip_info bmi270_chip_info = { 103 .name = "bmi270", 104 .chip_id = BMI270_CHIP_ID_VAL, 105 .fw_name = BMI270_INIT_DATA_FILE, 106 }; 107 EXPORT_SYMBOL_NS_GPL(bmi270_chip_info, IIO_BMI270); 108 109 enum bmi270_sensor_type { 110 BMI270_ACCEL = 0, 111 BMI270_GYRO, 112 }; 113 114 struct bmi270_scale { 115 int scale; 116 int uscale; 117 }; 118 119 struct bmi270_odr { 120 int odr; 121 int uodr; 122 }; 123 124 static const struct bmi270_scale bmi270_accel_scale[] = { 125 { 0, 598 }, 126 { 0, 1197 }, 127 { 0, 2394 }, 128 { 0, 4788 }, 129 }; 130 131 static const struct bmi270_scale bmi270_gyro_scale[] = { 132 { 0, 1065 }, 133 { 0, 532 }, 134 { 0, 266 }, 135 { 0, 133 }, 136 { 0, 66 }, 137 }; 138 139 struct bmi270_scale_item { 140 const struct bmi270_scale *tbl; 141 int num; 142 }; 143 144 static const struct bmi270_scale_item bmi270_scale_table[] = { 145 [BMI270_ACCEL] = { 146 .tbl = bmi270_accel_scale, 147 .num = ARRAY_SIZE(bmi270_accel_scale), 148 }, 149 [BMI270_GYRO] = { 150 .tbl = bmi270_gyro_scale, 151 .num = ARRAY_SIZE(bmi270_gyro_scale), 152 }, 153 }; 154 155 static const struct bmi270_odr bmi270_accel_odr[] = { 156 { 0, 781250 }, 157 { 1, 562500 }, 158 { 3, 125000 }, 159 { 6, 250000 }, 160 { 12, 500000 }, 161 { 25, 0 }, 162 { 50, 0 }, 163 { 100, 0 }, 164 { 200, 0 }, 165 { 400, 0 }, 166 { 800, 0 }, 167 { 1600, 0 }, 168 }; 169 170 static const u8 bmi270_accel_odr_vals[] = { 171 0x01, 172 0x02, 173 0x03, 174 0x04, 175 0x05, 176 0x06, 177 0x07, 178 0x08, 179 0x09, 180 0x0A, 181 0x0B, 182 0x0C, 183 }; 184 185 static const struct bmi270_odr bmi270_gyro_odr[] = { 186 { 25, 0 }, 187 { 50, 0 }, 188 { 100, 0 }, 189 { 200, 0 }, 190 { 400, 0 }, 191 { 800, 0 }, 192 { 1600, 0 }, 193 { 3200, 0 }, 194 }; 195 196 static const u8 bmi270_gyro_odr_vals[] = { 197 0x06, 198 0x07, 199 0x08, 200 0x09, 201 0x0A, 202 0x0B, 203 0x0C, 204 0x0D, 205 }; 206 207 struct bmi270_odr_item { 208 const struct bmi270_odr *tbl; 209 const u8 *vals; 210 int num; 211 }; 212 213 static const struct bmi270_odr_item bmi270_odr_table[] = { 214 [BMI270_ACCEL] = { 215 .tbl = bmi270_accel_odr, 216 .vals = bmi270_accel_odr_vals, 217 .num = ARRAY_SIZE(bmi270_accel_odr), 218 }, 219 [BMI270_GYRO] = { 220 .tbl = bmi270_gyro_odr, 221 .vals = bmi270_gyro_odr_vals, 222 .num = ARRAY_SIZE(bmi270_gyro_odr), 223 }, 224 }; 225 226 static int bmi270_set_scale(struct bmi270_data *data, int chan_type, int uscale) 227 { 228 int i; 229 int reg, mask; 230 struct bmi270_scale_item bmi270_scale_item; 231 232 switch (chan_type) { 233 case IIO_ACCEL: 234 reg = BMI270_ACC_CONF_RANGE_REG; 235 mask = BMI270_ACC_CONF_RANGE_MSK; 236 bmi270_scale_item = bmi270_scale_table[BMI270_ACCEL]; 237 break; 238 case IIO_ANGL_VEL: 239 reg = BMI270_GYR_CONF_RANGE_REG; 240 mask = BMI270_GYR_CONF_RANGE_MSK; 241 bmi270_scale_item = bmi270_scale_table[BMI270_GYRO]; 242 break; 243 default: 244 return -EINVAL; 245 } 246 247 for (i = 0; i < bmi270_scale_item.num; i++) { 248 if (bmi270_scale_item.tbl[i].uscale != uscale) 249 continue; 250 251 return regmap_update_bits(data->regmap, reg, mask, i); 252 } 253 254 return -EINVAL; 255 } 256 257 static int bmi270_get_scale(struct bmi270_data *bmi270_device, int chan_type, 258 int *uscale) 259 { 260 int ret; 261 unsigned int val; 262 struct bmi270_scale_item bmi270_scale_item; 263 264 switch (chan_type) { 265 case IIO_ACCEL: 266 ret = regmap_read(bmi270_device->regmap, 267 BMI270_ACC_CONF_RANGE_REG, &val); 268 if (ret) 269 return ret; 270 271 val = FIELD_GET(BMI270_ACC_CONF_RANGE_MSK, val); 272 bmi270_scale_item = bmi270_scale_table[BMI270_ACCEL]; 273 break; 274 case IIO_ANGL_VEL: 275 ret = regmap_read(bmi270_device->regmap, 276 BMI270_GYR_CONF_RANGE_REG, &val); 277 if (ret) 278 return ret; 279 280 val = FIELD_GET(BMI270_GYR_CONF_RANGE_MSK, val); 281 bmi270_scale_item = bmi270_scale_table[BMI270_GYRO]; 282 break; 283 default: 284 return -EINVAL; 285 } 286 287 if (val >= bmi270_scale_item.num) 288 return -EINVAL; 289 290 *uscale = bmi270_scale_item.tbl[val].uscale; 291 return 0; 292 } 293 294 static int bmi270_set_odr(struct bmi270_data *data, int chan_type, int odr, 295 int uodr) 296 { 297 int i; 298 int reg, mask; 299 struct bmi270_odr_item bmi270_odr_item; 300 301 switch (chan_type) { 302 case IIO_ACCEL: 303 reg = BMI270_ACC_CONF_REG; 304 mask = BMI270_ACC_CONF_ODR_MSK; 305 bmi270_odr_item = bmi270_odr_table[BMI270_ACCEL]; 306 break; 307 case IIO_ANGL_VEL: 308 reg = BMI270_GYR_CONF_REG; 309 mask = BMI270_GYR_CONF_ODR_MSK; 310 bmi270_odr_item = bmi270_odr_table[BMI270_GYRO]; 311 break; 312 default: 313 return -EINVAL; 314 } 315 316 for (i = 0; i < bmi270_odr_item.num; i++) { 317 if (bmi270_odr_item.tbl[i].odr != odr || 318 bmi270_odr_item.tbl[i].uodr != uodr) 319 continue; 320 321 return regmap_update_bits(data->regmap, reg, mask, 322 bmi270_odr_item.vals[i]); 323 } 324 325 return -EINVAL; 326 } 327 328 static int bmi270_get_odr(struct bmi270_data *data, int chan_type, int *odr, 329 int *uodr) 330 { 331 int i, val, ret; 332 struct bmi270_odr_item bmi270_odr_item; 333 334 switch (chan_type) { 335 case IIO_ACCEL: 336 ret = regmap_read(data->regmap, BMI270_ACC_CONF_REG, &val); 337 if (ret) 338 return ret; 339 340 val = FIELD_GET(BMI270_ACC_CONF_ODR_MSK, val); 341 bmi270_odr_item = bmi270_odr_table[BMI270_ACCEL]; 342 break; 343 case IIO_ANGL_VEL: 344 ret = regmap_read(data->regmap, BMI270_GYR_CONF_REG, &val); 345 if (ret) 346 return ret; 347 348 val = FIELD_GET(BMI270_GYR_CONF_ODR_MSK, val); 349 bmi270_odr_item = bmi270_odr_table[BMI270_GYRO]; 350 break; 351 default: 352 return -EINVAL; 353 } 354 355 for (i = 0; i < bmi270_odr_item.num; i++) { 356 if (val != bmi270_odr_item.vals[i]) 357 continue; 358 359 *odr = bmi270_odr_item.tbl[i].odr; 360 *uodr = bmi270_odr_item.tbl[i].uodr; 361 return 0; 362 } 363 364 return -EINVAL; 365 } 366 367 static irqreturn_t bmi270_trigger_handler(int irq, void *p) 368 { 369 struct iio_poll_func *pf = p; 370 struct iio_dev *indio_dev = pf->indio_dev; 371 struct bmi270_data *bmi270_device = iio_priv(indio_dev); 372 int ret; 373 374 ret = regmap_bulk_read(bmi270_device->regmap, BMI270_ACCEL_X_REG, 375 &bmi270_device->data.channels, 376 sizeof(bmi270_device->data.channels)); 377 378 if (ret) 379 goto done; 380 381 iio_push_to_buffers_with_timestamp(indio_dev, &bmi270_device->data, 382 pf->timestamp); 383 done: 384 iio_trigger_notify_done(indio_dev->trig); 385 return IRQ_HANDLED; 386 } 387 388 static int bmi270_get_data(struct bmi270_data *bmi270_device, 389 int chan_type, int axis, int *val) 390 { 391 __le16 sample; 392 int reg; 393 int ret; 394 395 switch (chan_type) { 396 case IIO_ACCEL: 397 reg = BMI270_ACCEL_X_REG + (axis - IIO_MOD_X) * 2; 398 break; 399 case IIO_ANGL_VEL: 400 reg = BMI270_ANG_VEL_X_REG + (axis - IIO_MOD_X) * 2; 401 break; 402 default: 403 return -EINVAL; 404 } 405 406 ret = regmap_bulk_read(bmi270_device->regmap, reg, &sample, sizeof(sample)); 407 if (ret) 408 return ret; 409 410 *val = sign_extend32(le16_to_cpu(sample), 15); 411 412 return 0; 413 } 414 415 static int bmi270_read_raw(struct iio_dev *indio_dev, 416 struct iio_chan_spec const *chan, 417 int *val, int *val2, long mask) 418 { 419 int ret; 420 struct bmi270_data *bmi270_device = iio_priv(indio_dev); 421 422 switch (mask) { 423 case IIO_CHAN_INFO_RAW: 424 ret = bmi270_get_data(bmi270_device, chan->type, chan->channel2, val); 425 if (ret) 426 return ret; 427 428 return IIO_VAL_INT; 429 case IIO_CHAN_INFO_SCALE: 430 *val = 0; 431 ret = bmi270_get_scale(bmi270_device, chan->type, val2); 432 return ret ? ret : IIO_VAL_INT_PLUS_MICRO; 433 case IIO_CHAN_INFO_SAMP_FREQ: 434 ret = bmi270_get_odr(bmi270_device, chan->type, val, val2); 435 return ret ? ret : IIO_VAL_INT_PLUS_MICRO; 436 default: 437 return -EINVAL; 438 } 439 } 440 441 static int bmi270_write_raw(struct iio_dev *indio_dev, 442 struct iio_chan_spec const *chan, 443 int val, int val2, long mask) 444 { 445 struct bmi270_data *data = iio_priv(indio_dev); 446 447 switch (mask) { 448 case IIO_CHAN_INFO_SCALE: 449 return bmi270_set_scale(data, chan->type, val2); 450 case IIO_CHAN_INFO_SAMP_FREQ: 451 return bmi270_set_odr(data, chan->type, val, val2); 452 default: 453 return -EINVAL; 454 } 455 } 456 457 static int bmi270_read_avail(struct iio_dev *indio_dev, 458 struct iio_chan_spec const *chan, 459 const int **vals, int *type, int *length, 460 long mask) 461 { 462 switch (mask) { 463 case IIO_CHAN_INFO_SCALE: 464 *type = IIO_VAL_INT_PLUS_MICRO; 465 switch (chan->type) { 466 case IIO_ANGL_VEL: 467 *vals = (const int *)bmi270_gyro_scale; 468 *length = ARRAY_SIZE(bmi270_gyro_scale) * 2; 469 return IIO_AVAIL_LIST; 470 case IIO_ACCEL: 471 *vals = (const int *)bmi270_accel_scale; 472 *length = ARRAY_SIZE(bmi270_accel_scale) * 2; 473 return IIO_AVAIL_LIST; 474 default: 475 return -EINVAL; 476 } 477 case IIO_CHAN_INFO_SAMP_FREQ: 478 *type = IIO_VAL_INT_PLUS_MICRO; 479 switch (chan->type) { 480 case IIO_ANGL_VEL: 481 *vals = (const int *)bmi270_gyro_odr; 482 *length = ARRAY_SIZE(bmi270_gyro_odr) * 2; 483 return IIO_AVAIL_LIST; 484 case IIO_ACCEL: 485 *vals = (const int *)bmi270_accel_odr; 486 *length = ARRAY_SIZE(bmi270_accel_odr) * 2; 487 return IIO_AVAIL_LIST; 488 default: 489 return -EINVAL; 490 } 491 default: 492 return -EINVAL; 493 } 494 } 495 496 static const struct iio_info bmi270_info = { 497 .read_raw = bmi270_read_raw, 498 .write_raw = bmi270_write_raw, 499 .read_avail = bmi270_read_avail, 500 }; 501 502 #define BMI270_ACCEL_CHANNEL(_axis) { \ 503 .type = IIO_ACCEL, \ 504 .modified = 1, \ 505 .channel2 = IIO_MOD_##_axis, \ 506 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 507 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 508 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 509 .info_mask_shared_by_type_available = \ 510 BIT(IIO_CHAN_INFO_SCALE) | \ 511 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 512 .scan_index = BMI270_SCAN_ACCEL_##_axis, \ 513 .scan_type = { \ 514 .sign = 's', \ 515 .realbits = 16, \ 516 .storagebits = 16, \ 517 .endianness = IIO_LE, \ 518 }, \ 519 } 520 521 #define BMI270_ANG_VEL_CHANNEL(_axis) { \ 522 .type = IIO_ANGL_VEL, \ 523 .modified = 1, \ 524 .channel2 = IIO_MOD_##_axis, \ 525 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 526 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 527 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 528 .info_mask_shared_by_type_available = \ 529 BIT(IIO_CHAN_INFO_SCALE) | \ 530 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 531 .scan_index = BMI270_SCAN_GYRO_##_axis, \ 532 .scan_type = { \ 533 .sign = 's', \ 534 .realbits = 16, \ 535 .storagebits = 16, \ 536 .endianness = IIO_LE, \ 537 }, \ 538 } 539 540 static const struct iio_chan_spec bmi270_channels[] = { 541 BMI270_ACCEL_CHANNEL(X), 542 BMI270_ACCEL_CHANNEL(Y), 543 BMI270_ACCEL_CHANNEL(Z), 544 BMI270_ANG_VEL_CHANNEL(X), 545 BMI270_ANG_VEL_CHANNEL(Y), 546 BMI270_ANG_VEL_CHANNEL(Z), 547 IIO_CHAN_SOFT_TIMESTAMP(BMI270_SCAN_TIMESTAMP), 548 }; 549 550 static int bmi270_validate_chip_id(struct bmi270_data *bmi270_device) 551 { 552 int chip_id; 553 int ret; 554 struct device *dev = bmi270_device->dev; 555 struct regmap *regmap = bmi270_device->regmap; 556 557 ret = regmap_read(regmap, BMI270_CHIP_ID_REG, &chip_id); 558 if (ret) 559 return dev_err_probe(dev, ret, "Failed to read chip id"); 560 561 /* 562 * Some manufacturers use "BMI0160" for both the BMI160 and 563 * BMI260. If the device is actually a BMI160, the bmi160 564 * driver should handle it and this driver should not. 565 */ 566 if (chip_id == BMI160_CHIP_ID_VAL) 567 return -ENODEV; 568 569 if (chip_id != bmi270_device->chip_info->chip_id) 570 dev_info(dev, "Unexpected chip id 0x%x", chip_id); 571 572 if (chip_id == bmi260_chip_info.chip_id) 573 bmi270_device->chip_info = &bmi260_chip_info; 574 else if (chip_id == bmi270_chip_info.chip_id) 575 bmi270_device->chip_info = &bmi270_chip_info; 576 577 return 0; 578 } 579 580 static int bmi270_write_calibration_data(struct bmi270_data *bmi270_device) 581 { 582 int ret; 583 int status = 0; 584 const struct firmware *init_data; 585 struct device *dev = bmi270_device->dev; 586 struct regmap *regmap = bmi270_device->regmap; 587 588 ret = regmap_clear_bits(regmap, BMI270_PWR_CONF_REG, 589 BMI270_PWR_CONF_ADV_PWR_SAVE_MSK); 590 if (ret) 591 return dev_err_probe(dev, ret, 592 "Failed to write power configuration"); 593 594 /* 595 * After disabling advanced power save, all registers are accessible 596 * after a 450us delay. This delay is specified in table A of the 597 * datasheet. 598 */ 599 usleep_range(450, 1000); 600 601 ret = regmap_clear_bits(regmap, BMI270_INIT_CTRL_REG, 602 BMI270_INIT_CTRL_LOAD_DONE_MSK); 603 if (ret) 604 return dev_err_probe(dev, ret, 605 "Failed to prepare device to load init data"); 606 607 ret = request_firmware(&init_data, 608 bmi270_device->chip_info->fw_name, dev); 609 if (ret) 610 return dev_err_probe(dev, ret, "Failed to load init data file"); 611 612 ret = regmap_bulk_write(regmap, BMI270_INIT_DATA_REG, 613 init_data->data, init_data->size); 614 release_firmware(init_data); 615 if (ret) 616 return dev_err_probe(dev, ret, "Failed to write init data"); 617 618 ret = regmap_set_bits(regmap, BMI270_INIT_CTRL_REG, 619 BMI270_INIT_CTRL_LOAD_DONE_MSK); 620 if (ret) 621 return dev_err_probe(dev, ret, 622 "Failed to stop device initialization"); 623 624 /* 625 * Wait at least 140ms for the device to complete configuration. 626 * This delay is specified in table C of the datasheet. 627 */ 628 usleep_range(140000, 160000); 629 630 ret = regmap_read(regmap, BMI270_INTERNAL_STATUS_REG, &status); 631 if (ret) 632 return dev_err_probe(dev, ret, "Failed to read internal status"); 633 634 if (status != BMI270_INTERNAL_STATUS_MSG_INIT_OK) 635 return dev_err_probe(dev, -ENODEV, "Device failed to initialize"); 636 637 return 0; 638 } 639 640 static int bmi270_configure_imu(struct bmi270_data *bmi270_device) 641 { 642 int ret; 643 struct device *dev = bmi270_device->dev; 644 struct regmap *regmap = bmi270_device->regmap; 645 646 ret = regmap_set_bits(regmap, BMI270_PWR_CTRL_REG, 647 BMI270_PWR_CTRL_AUX_EN_MSK | 648 BMI270_PWR_CTRL_GYR_EN_MSK | 649 BMI270_PWR_CTRL_ACCEL_EN_MSK); 650 if (ret) 651 return dev_err_probe(dev, ret, "Failed to enable accelerometer and gyroscope"); 652 653 ret = regmap_set_bits(regmap, BMI270_ACC_CONF_REG, 654 FIELD_PREP(BMI270_ACC_CONF_ODR_MSK, 655 BMI270_ACC_CONF_ODR_100HZ) | 656 FIELD_PREP(BMI270_ACC_CONF_BWP_MSK, 657 BMI270_ACC_CONF_BWP_NORMAL_MODE) | 658 BMI270_PWR_CONF_ADV_PWR_SAVE_MSK); 659 if (ret) 660 return dev_err_probe(dev, ret, "Failed to configure accelerometer"); 661 662 ret = regmap_set_bits(regmap, BMI270_GYR_CONF_REG, 663 FIELD_PREP(BMI270_GYR_CONF_ODR_MSK, 664 BMI270_GYR_CONF_ODR_200HZ) | 665 FIELD_PREP(BMI270_GYR_CONF_BWP_MSK, 666 BMI270_GYR_CONF_BWP_NORMAL_MODE) | 667 BMI270_PWR_CONF_ADV_PWR_SAVE_MSK); 668 if (ret) 669 return dev_err_probe(dev, ret, "Failed to configure gyroscope"); 670 671 /* Enable FIFO_WKUP, Disable ADV_PWR_SAVE and FUP_EN */ 672 ret = regmap_write(regmap, BMI270_PWR_CONF_REG, 673 BMI270_PWR_CONF_FIFO_WKUP_MSK); 674 if (ret) 675 return dev_err_probe(dev, ret, "Failed to set power configuration"); 676 677 return 0; 678 } 679 680 static int bmi270_chip_init(struct bmi270_data *bmi270_device) 681 { 682 int ret; 683 684 ret = bmi270_validate_chip_id(bmi270_device); 685 if (ret) 686 return ret; 687 688 ret = bmi270_write_calibration_data(bmi270_device); 689 if (ret) 690 return ret; 691 692 return bmi270_configure_imu(bmi270_device); 693 } 694 695 int bmi270_core_probe(struct device *dev, struct regmap *regmap, 696 const struct bmi270_chip_info *chip_info) 697 { 698 int ret; 699 struct bmi270_data *bmi270_device; 700 struct iio_dev *indio_dev; 701 702 indio_dev = devm_iio_device_alloc(dev, sizeof(*bmi270_device)); 703 if (!indio_dev) 704 return -ENOMEM; 705 706 bmi270_device = iio_priv(indio_dev); 707 bmi270_device->dev = dev; 708 bmi270_device->regmap = regmap; 709 bmi270_device->chip_info = chip_info; 710 711 ret = bmi270_chip_init(bmi270_device); 712 if (ret) 713 return ret; 714 715 indio_dev->channels = bmi270_channels; 716 indio_dev->num_channels = ARRAY_SIZE(bmi270_channels); 717 indio_dev->name = chip_info->name; 718 indio_dev->available_scan_masks = bmi270_avail_scan_masks; 719 indio_dev->modes = INDIO_DIRECT_MODE; 720 indio_dev->info = &bmi270_info; 721 722 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, 723 iio_pollfunc_store_time, 724 bmi270_trigger_handler, NULL); 725 if (ret) 726 return ret; 727 728 return devm_iio_device_register(dev, indio_dev); 729 } 730 EXPORT_SYMBOL_NS_GPL(bmi270_core_probe, IIO_BMI270); 731 732 MODULE_AUTHOR("Alex Lanzano"); 733 MODULE_DESCRIPTION("BMI270 driver"); 734 MODULE_LICENSE("GPL"); 735