1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * IIO core driver for Bosch BMI323 6-Axis IMU. 4 * 5 * Copyright (C) 2023, Jagath Jog J <jagathjog1996@gmail.com> 6 * 7 * Datasheet: https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmi323-ds000.pdf 8 */ 9 10 #include <linux/bitfield.h> 11 #include <linux/cleanup.h> 12 #include <linux/device.h> 13 #include <linux/interrupt.h> 14 #include <linux/minmax.h> 15 #include <linux/module.h> 16 #include <linux/mutex.h> 17 #include <linux/property.h> 18 #include <linux/regmap.h> 19 #include <linux/regulator/consumer.h> 20 #include <linux/units.h> 21 22 #include <linux/unaligned.h> 23 24 #include <linux/iio/buffer.h> 25 #include <linux/iio/events.h> 26 #include <linux/iio/iio.h> 27 #include <linux/iio/sysfs.h> 28 #include <linux/iio/trigger.h> 29 #include <linux/iio/trigger_consumer.h> 30 #include <linux/iio/triggered_buffer.h> 31 32 #include "bmi323.h" 33 34 enum bmi323_sensor_type { 35 BMI323_ACCEL, 36 BMI323_GYRO, 37 BMI323_SENSORS_CNT, 38 }; 39 40 enum bmi323_opr_mode { 41 ACC_GYRO_MODE_DISABLE = 0x00, 42 GYRO_DRIVE_MODE_ENABLED = 0x01, 43 ACC_GYRO_MODE_DUTYCYCLE = 0x03, 44 ACC_GYRO_MODE_CONTINOUS = 0x04, 45 ACC_GYRO_MODE_HIGH_PERF = 0x07, 46 }; 47 48 enum bmi323_state { 49 BMI323_IDLE, 50 BMI323_BUFFER_DRDY_TRIGGERED, 51 BMI323_BUFFER_FIFO, 52 }; 53 54 enum bmi323_irq_pin { 55 BMI323_IRQ_DISABLED, 56 BMI323_IRQ_INT1, 57 BMI323_IRQ_INT2, 58 }; 59 60 enum bmi323_3db_bw { 61 BMI323_BW_ODR_BY_2, 62 BMI323_BW_ODR_BY_4, 63 }; 64 65 enum bmi323_scan { 66 BMI323_ACCEL_X, 67 BMI323_ACCEL_Y, 68 BMI323_ACCEL_Z, 69 BMI323_GYRO_X, 70 BMI323_GYRO_Y, 71 BMI323_GYRO_Z, 72 BMI323_CHAN_MAX 73 }; 74 75 struct bmi323_hw { 76 u8 data; 77 u8 config; 78 const int (*scale_table)[2]; 79 int scale_table_len; 80 }; 81 82 /* 83 * The accelerometer supports +-2G/4G/8G/16G ranges, and the resolution of 84 * each sample is 16 bits, signed. 85 * At +-8G the scale can calculated by 86 * ((8 + 8) * 9.80665 / (2^16 - 1)) * 10^6 = 2394.23819 scale in micro 87 * 88 */ 89 static const int bmi323_accel_scale[][2] = { 90 { 0, 598 }, 91 { 0, 1197 }, 92 { 0, 2394 }, 93 { 0, 4788 }, 94 }; 95 96 static const int bmi323_gyro_scale[][2] = { 97 { 0, 66 }, 98 { 0, 133 }, 99 { 0, 266 }, 100 { 0, 532 }, 101 { 0, 1065 }, 102 }; 103 104 static const int bmi323_accel_gyro_avrg[] = {0, 2, 4, 8, 16, 32, 64}; 105 106 static const struct bmi323_hw bmi323_hw[2] = { 107 [BMI323_ACCEL] = { 108 .data = BMI323_ACCEL_X_REG, 109 .config = BMI323_ACC_CONF_REG, 110 .scale_table = bmi323_accel_scale, 111 .scale_table_len = ARRAY_SIZE(bmi323_accel_scale), 112 }, 113 [BMI323_GYRO] = { 114 .data = BMI323_GYRO_X_REG, 115 .config = BMI323_GYRO_CONF_REG, 116 .scale_table = bmi323_gyro_scale, 117 .scale_table_len = ARRAY_SIZE(bmi323_gyro_scale), 118 }, 119 }; 120 121 static const unsigned int bmi323_reg_savestate[] = { 122 BMI323_INT_MAP1_REG, 123 BMI323_INT_MAP2_REG, 124 BMI323_IO_INT_CTR_REG, 125 BMI323_IO_INT_CONF_REG, 126 BMI323_ACC_CONF_REG, 127 BMI323_GYRO_CONF_REG, 128 BMI323_FEAT_IO0_REG, 129 BMI323_FIFO_WTRMRK_REG, 130 BMI323_FIFO_CONF_REG 131 }; 132 133 static const unsigned int bmi323_ext_reg_savestate[] = { 134 BMI323_GEN_SET1_REG, 135 BMI323_TAP1_REG, 136 BMI323_TAP2_REG, 137 BMI323_TAP3_REG, 138 BMI323_FEAT_IO0_S_TAP_MSK, 139 BMI323_STEP_SC1_REG, 140 BMI323_ANYMO1_REG, 141 BMI323_NOMO1_REG, 142 BMI323_ANYMO1_REG + BMI323_MO2_OFFSET, 143 BMI323_NOMO1_REG + BMI323_MO2_OFFSET, 144 BMI323_ANYMO1_REG + BMI323_MO3_OFFSET, 145 BMI323_NOMO1_REG + BMI323_MO3_OFFSET 146 }; 147 148 struct bmi323_regs_runtime_pm { 149 unsigned int reg_settings[ARRAY_SIZE(bmi323_reg_savestate)]; 150 unsigned int ext_reg_settings[ARRAY_SIZE(bmi323_ext_reg_savestate)]; 151 }; 152 153 struct bmi323_data { 154 struct device *dev; 155 struct regmap *regmap; 156 struct iio_mount_matrix orientation; 157 enum bmi323_irq_pin irq_pin; 158 struct iio_trigger *trig; 159 enum bmi323_state state; 160 s64 fifo_tstamp, old_fifo_tstamp; 161 u32 odrns[BMI323_SENSORS_CNT]; 162 u32 odrhz[BMI323_SENSORS_CNT]; 163 unsigned int feature_events; 164 struct bmi323_regs_runtime_pm runtime_pm_status; 165 166 /* 167 * Lock to protect the members of device's private data from concurrent 168 * access and also to serialize the access of extended registers. 169 * See bmi323_write_ext_reg(..) for more info. 170 */ 171 struct mutex mutex; 172 int watermark; 173 __le16 fifo_buff[BMI323_FIFO_FULL_IN_WORDS] __aligned(IIO_DMA_MINALIGN); 174 struct { 175 __le16 channels[BMI323_CHAN_MAX]; 176 aligned_s64 ts; 177 } buffer; 178 __le16 steps_count[BMI323_STEP_LEN]; 179 }; 180 181 static const struct iio_mount_matrix * 182 bmi323_get_mount_matrix(const struct iio_dev *idev, 183 const struct iio_chan_spec *chan) 184 { 185 struct bmi323_data *data = iio_priv(idev); 186 187 return &data->orientation; 188 } 189 190 static const struct iio_chan_spec_ext_info bmi323_ext_info[] = { 191 IIO_MOUNT_MATRIX(IIO_SHARED_BY_TYPE, bmi323_get_mount_matrix), 192 { } 193 }; 194 195 static const struct iio_event_spec bmi323_step_wtrmrk_event = { 196 .type = IIO_EV_TYPE_CHANGE, 197 .dir = IIO_EV_DIR_NONE, 198 .mask_shared_by_type = BIT(IIO_EV_INFO_ENABLE) | 199 BIT(IIO_EV_INFO_VALUE), 200 }; 201 202 static const struct iio_event_spec bmi323_accel_event[] = { 203 { 204 .type = IIO_EV_TYPE_MAG, 205 .dir = IIO_EV_DIR_FALLING, 206 .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) | 207 BIT(IIO_EV_INFO_PERIOD) | 208 BIT(IIO_EV_INFO_HYSTERESIS) | 209 BIT(IIO_EV_INFO_ENABLE), 210 }, 211 { 212 .type = IIO_EV_TYPE_MAG, 213 .dir = IIO_EV_DIR_RISING, 214 .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) | 215 BIT(IIO_EV_INFO_PERIOD) | 216 BIT(IIO_EV_INFO_HYSTERESIS) | 217 BIT(IIO_EV_INFO_ENABLE), 218 }, 219 { 220 .type = IIO_EV_TYPE_GESTURE, 221 .dir = IIO_EV_DIR_SINGLETAP, 222 .mask_shared_by_type = BIT(IIO_EV_INFO_ENABLE) | 223 BIT(IIO_EV_INFO_VALUE) | 224 BIT(IIO_EV_INFO_RESET_TIMEOUT), 225 }, 226 { 227 .type = IIO_EV_TYPE_GESTURE, 228 .dir = IIO_EV_DIR_DOUBLETAP, 229 .mask_shared_by_type = BIT(IIO_EV_INFO_ENABLE) | 230 BIT(IIO_EV_INFO_VALUE) | 231 BIT(IIO_EV_INFO_RESET_TIMEOUT) | 232 BIT(IIO_EV_INFO_TAP2_MIN_DELAY), 233 }, 234 }; 235 236 #define BMI323_ACCEL_CHANNEL(_type, _axis, _index) { \ 237 .type = _type, \ 238 .modified = 1, \ 239 .channel2 = IIO_MOD_##_axis, \ 240 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 241 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \ 242 BIT(IIO_CHAN_INFO_SCALE) | \ 243 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \ 244 .info_mask_shared_by_type_available = \ 245 BIT(IIO_CHAN_INFO_SAMP_FREQ) | \ 246 BIT(IIO_CHAN_INFO_SCALE) | \ 247 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \ 248 .scan_index = _index, \ 249 .scan_type = { \ 250 .sign = 's', \ 251 .realbits = 16, \ 252 .storagebits = 16, \ 253 .endianness = IIO_LE, \ 254 }, \ 255 .ext_info = bmi323_ext_info, \ 256 .event_spec = bmi323_accel_event, \ 257 .num_event_specs = ARRAY_SIZE(bmi323_accel_event), \ 258 } 259 260 #define BMI323_GYRO_CHANNEL(_type, _axis, _index) { \ 261 .type = _type, \ 262 .modified = 1, \ 263 .channel2 = IIO_MOD_##_axis, \ 264 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 265 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \ 266 BIT(IIO_CHAN_INFO_SCALE) | \ 267 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \ 268 .info_mask_shared_by_type_available = \ 269 BIT(IIO_CHAN_INFO_SAMP_FREQ) | \ 270 BIT(IIO_CHAN_INFO_SCALE) | \ 271 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \ 272 .scan_index = _index, \ 273 .scan_type = { \ 274 .sign = 's', \ 275 .realbits = 16, \ 276 .storagebits = 16, \ 277 .endianness = IIO_LE, \ 278 }, \ 279 .ext_info = bmi323_ext_info, \ 280 } 281 282 static const struct iio_chan_spec bmi323_channels[] = { 283 BMI323_ACCEL_CHANNEL(IIO_ACCEL, X, BMI323_ACCEL_X), 284 BMI323_ACCEL_CHANNEL(IIO_ACCEL, Y, BMI323_ACCEL_Y), 285 BMI323_ACCEL_CHANNEL(IIO_ACCEL, Z, BMI323_ACCEL_Z), 286 BMI323_GYRO_CHANNEL(IIO_ANGL_VEL, X, BMI323_GYRO_X), 287 BMI323_GYRO_CHANNEL(IIO_ANGL_VEL, Y, BMI323_GYRO_Y), 288 BMI323_GYRO_CHANNEL(IIO_ANGL_VEL, Z, BMI323_GYRO_Z), 289 { 290 .type = IIO_TEMP, 291 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 292 BIT(IIO_CHAN_INFO_OFFSET) | 293 BIT(IIO_CHAN_INFO_SCALE), 294 .scan_index = -1, 295 }, 296 { 297 .type = IIO_STEPS, 298 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | 299 BIT(IIO_CHAN_INFO_ENABLE), 300 .scan_index = -1, 301 .event_spec = &bmi323_step_wtrmrk_event, 302 .num_event_specs = 1, 303 304 }, 305 IIO_CHAN_SOFT_TIMESTAMP(BMI323_CHAN_MAX), 306 }; 307 308 static const int bmi323_acc_gyro_odr[][2] = { 309 { 0, 781250 }, 310 { 1, 562500 }, 311 { 3, 125000 }, 312 { 6, 250000 }, 313 { 12, 500000 }, 314 { 25, 0 }, 315 { 50, 0 }, 316 { 100, 0 }, 317 { 200, 0 }, 318 { 400, 0 }, 319 { 800, 0 }, 320 }; 321 322 static const int bmi323_acc_gyro_odrns[] = { 323 1280 * MEGA, 324 640 * MEGA, 325 320 * MEGA, 326 160 * MEGA, 327 80 * MEGA, 328 40 * MEGA, 329 20 * MEGA, 330 10 * MEGA, 331 5 * MEGA, 332 2500 * KILO, 333 1250 * KILO, 334 }; 335 336 static enum bmi323_sensor_type bmi323_iio_to_sensor(enum iio_chan_type iio_type) 337 { 338 switch (iio_type) { 339 case IIO_ACCEL: 340 return BMI323_ACCEL; 341 case IIO_ANGL_VEL: 342 return BMI323_GYRO; 343 default: 344 return -EINVAL; 345 } 346 } 347 348 static int bmi323_set_mode(struct bmi323_data *data, 349 enum bmi323_sensor_type sensor, 350 enum bmi323_opr_mode mode) 351 { 352 guard(mutex)(&data->mutex); 353 return regmap_update_bits(data->regmap, bmi323_hw[sensor].config, 354 BMI323_ACC_GYRO_CONF_MODE_MSK, 355 FIELD_PREP(BMI323_ACC_GYRO_CONF_MODE_MSK, 356 mode)); 357 } 358 359 /* 360 * When writing data to extended register there must be no communication to 361 * any other register before write transaction is complete. 362 * See datasheet section 6.2 Extended Register Map Description. 363 */ 364 static int bmi323_write_ext_reg(struct bmi323_data *data, unsigned int ext_addr, 365 unsigned int ext_data) 366 { 367 int ret, feature_status; 368 369 ret = regmap_read(data->regmap, BMI323_FEAT_DATA_STATUS, 370 &feature_status); 371 if (ret) 372 return ret; 373 374 if (!FIELD_GET(BMI323_FEAT_DATA_TX_RDY_MSK, feature_status)) 375 return -EBUSY; 376 377 ret = regmap_write(data->regmap, BMI323_FEAT_DATA_ADDR, ext_addr); 378 if (ret) 379 return ret; 380 381 return regmap_write(data->regmap, BMI323_FEAT_DATA_TX, ext_data); 382 } 383 384 /* 385 * When reading data from extended register there must be no communication to 386 * any other register before read transaction is complete. 387 * See datasheet section 6.2 Extended Register Map Description. 388 */ 389 static int bmi323_read_ext_reg(struct bmi323_data *data, unsigned int ext_addr, 390 unsigned int *ext_data) 391 { 392 int ret, feature_status; 393 394 ret = regmap_read(data->regmap, BMI323_FEAT_DATA_STATUS, 395 &feature_status); 396 if (ret) 397 return ret; 398 399 if (!FIELD_GET(BMI323_FEAT_DATA_TX_RDY_MSK, feature_status)) 400 return -EBUSY; 401 402 ret = regmap_write(data->regmap, BMI323_FEAT_DATA_ADDR, ext_addr); 403 if (ret) 404 return ret; 405 406 return regmap_read(data->regmap, BMI323_FEAT_DATA_TX, ext_data); 407 } 408 409 static int bmi323_update_ext_reg(struct bmi323_data *data, 410 unsigned int ext_addr, 411 unsigned int mask, unsigned int ext_data) 412 { 413 unsigned int value; 414 int ret; 415 416 ret = bmi323_read_ext_reg(data, ext_addr, &value); 417 if (ret) 418 return ret; 419 420 set_mask_bits(&value, mask, ext_data); 421 422 return bmi323_write_ext_reg(data, ext_addr, value); 423 } 424 425 static int bmi323_get_error_status(struct bmi323_data *data) 426 { 427 int error, ret; 428 429 guard(mutex)(&data->mutex); 430 ret = regmap_read(data->regmap, BMI323_ERR_REG, &error); 431 if (ret) 432 return ret; 433 434 if (error) 435 dev_err(data->dev, "Sensor error 0x%x\n", error); 436 437 return error; 438 } 439 440 static int bmi323_feature_engine_events(struct bmi323_data *data, 441 const unsigned int event_mask, 442 bool state) 443 { 444 unsigned int value; 445 int ret; 446 447 ret = regmap_read(data->regmap, BMI323_FEAT_IO0_REG, &value); 448 if (ret) 449 return ret; 450 451 /* Register must be cleared before changing an active config */ 452 ret = regmap_write(data->regmap, BMI323_FEAT_IO0_REG, 0); 453 if (ret) 454 return ret; 455 456 if (state) 457 value |= event_mask; 458 else 459 value &= ~event_mask; 460 461 ret = regmap_write(data->regmap, BMI323_FEAT_IO0_REG, value); 462 if (ret) 463 return ret; 464 465 return regmap_write(data->regmap, BMI323_FEAT_IO_STATUS_REG, 466 BMI323_FEAT_IO_STATUS_MSK); 467 } 468 469 static int bmi323_step_wtrmrk_en(struct bmi323_data *data, bool state) 470 { 471 enum bmi323_irq_pin step_irq; 472 int ret; 473 474 guard(mutex)(&data->mutex); 475 if (!FIELD_GET(BMI323_FEAT_IO0_STP_CNT_MSK, data->feature_events)) 476 return -EINVAL; 477 478 if (state) 479 step_irq = data->irq_pin; 480 else 481 step_irq = BMI323_IRQ_DISABLED; 482 483 ret = bmi323_update_ext_reg(data, BMI323_STEP_SC1_REG, 484 BMI323_STEP_SC1_WTRMRK_MSK, 485 FIELD_PREP(BMI323_STEP_SC1_WTRMRK_MSK, 486 state)); 487 if (ret) 488 return ret; 489 490 return regmap_update_bits(data->regmap, BMI323_INT_MAP1_REG, 491 BMI323_STEP_CNT_MSK, 492 FIELD_PREP(BMI323_STEP_CNT_MSK, step_irq)); 493 } 494 495 static int bmi323_motion_config_reg(enum iio_event_direction dir) 496 { 497 switch (dir) { 498 case IIO_EV_DIR_RISING: 499 return BMI323_ANYMO1_REG; 500 case IIO_EV_DIR_FALLING: 501 return BMI323_NOMO1_REG; 502 default: 503 return -EINVAL; 504 } 505 } 506 507 static int bmi323_motion_event_en(struct bmi323_data *data, 508 enum iio_event_direction dir, bool state) 509 { 510 unsigned int state_value = state ? BMI323_FEAT_XYZ_MSK : 0; 511 int config, ret, msk, raw, field_value; 512 enum bmi323_irq_pin motion_irq; 513 int irq_msk, irq_field_val; 514 515 if (state) 516 motion_irq = data->irq_pin; 517 else 518 motion_irq = BMI323_IRQ_DISABLED; 519 520 switch (dir) { 521 case IIO_EV_DIR_RISING: 522 msk = BMI323_FEAT_IO0_XYZ_MOTION_MSK; 523 raw = 512; 524 config = BMI323_ANYMO1_REG; 525 irq_msk = BMI323_MOTION_MSK; 526 irq_field_val = FIELD_PREP(BMI323_MOTION_MSK, motion_irq); 527 field_value = FIELD_PREP(BMI323_FEAT_IO0_XYZ_MOTION_MSK, 528 state_value); 529 break; 530 case IIO_EV_DIR_FALLING: 531 msk = BMI323_FEAT_IO0_XYZ_NOMOTION_MSK; 532 raw = 0; 533 config = BMI323_NOMO1_REG; 534 irq_msk = BMI323_NOMOTION_MSK; 535 irq_field_val = FIELD_PREP(BMI323_NOMOTION_MSK, motion_irq); 536 field_value = FIELD_PREP(BMI323_FEAT_IO0_XYZ_NOMOTION_MSK, 537 state_value); 538 break; 539 default: 540 return -EINVAL; 541 } 542 543 guard(mutex)(&data->mutex); 544 ret = bmi323_feature_engine_events(data, msk, state); 545 if (ret) 546 return ret; 547 548 ret = bmi323_update_ext_reg(data, config, 549 BMI323_MO1_REF_UP_MSK, 550 FIELD_PREP(BMI323_MO1_REF_UP_MSK, 0)); 551 if (ret) 552 return ret; 553 554 /* Set initial value to avoid interrupts while enabling*/ 555 ret = bmi323_update_ext_reg(data, config, 556 BMI323_MO1_SLOPE_TH_MSK, 557 FIELD_PREP(BMI323_MO1_SLOPE_TH_MSK, raw)); 558 if (ret) 559 return ret; 560 561 ret = regmap_update_bits(data->regmap, BMI323_INT_MAP1_REG, irq_msk, 562 irq_field_val); 563 if (ret) 564 return ret; 565 566 set_mask_bits(&data->feature_events, msk, field_value); 567 568 return 0; 569 } 570 571 static int bmi323_tap_event_en(struct bmi323_data *data, 572 enum iio_event_direction dir, bool state) 573 { 574 enum bmi323_irq_pin tap_irq; 575 int ret, tap_enabled; 576 577 guard(mutex)(&data->mutex); 578 579 if (data->odrhz[BMI323_ACCEL] < 200) { 580 dev_err(data->dev, "Invalid accelerometer parameter\n"); 581 return -EINVAL; 582 } 583 584 switch (dir) { 585 case IIO_EV_DIR_SINGLETAP: 586 ret = bmi323_feature_engine_events(data, 587 BMI323_FEAT_IO0_S_TAP_MSK, 588 state); 589 if (ret) 590 return ret; 591 592 set_mask_bits(&data->feature_events, BMI323_FEAT_IO0_S_TAP_MSK, 593 FIELD_PREP(BMI323_FEAT_IO0_S_TAP_MSK, state)); 594 break; 595 case IIO_EV_DIR_DOUBLETAP: 596 ret = bmi323_feature_engine_events(data, 597 BMI323_FEAT_IO0_D_TAP_MSK, 598 state); 599 if (ret) 600 return ret; 601 602 set_mask_bits(&data->feature_events, BMI323_FEAT_IO0_D_TAP_MSK, 603 FIELD_PREP(BMI323_FEAT_IO0_D_TAP_MSK, state)); 604 break; 605 default: 606 return -EINVAL; 607 } 608 609 tap_enabled = FIELD_GET(BMI323_FEAT_IO0_S_TAP_MSK | 610 BMI323_FEAT_IO0_D_TAP_MSK, 611 data->feature_events); 612 613 if (tap_enabled) 614 tap_irq = data->irq_pin; 615 else 616 tap_irq = BMI323_IRQ_DISABLED; 617 618 ret = regmap_update_bits(data->regmap, BMI323_INT_MAP2_REG, 619 BMI323_TAP_MSK, 620 FIELD_PREP(BMI323_TAP_MSK, tap_irq)); 621 if (ret) 622 return ret; 623 624 if (!state) 625 return 0; 626 627 ret = bmi323_update_ext_reg(data, BMI323_TAP1_REG, 628 BMI323_TAP1_MAX_PEAKS_MSK, 629 FIELD_PREP(BMI323_TAP1_MAX_PEAKS_MSK, 630 0x04)); 631 if (ret) 632 return ret; 633 634 ret = bmi323_update_ext_reg(data, BMI323_TAP1_REG, 635 BMI323_TAP1_AXIS_SEL_MSK, 636 FIELD_PREP(BMI323_TAP1_AXIS_SEL_MSK, 637 BMI323_AXIS_XYZ_MSK)); 638 if (ret) 639 return ret; 640 641 return bmi323_update_ext_reg(data, BMI323_TAP1_REG, 642 BMI323_TAP1_TIMOUT_MSK, 643 FIELD_PREP(BMI323_TAP1_TIMOUT_MSK, 644 0)); 645 } 646 647 static ssize_t in_accel_gesture_tap_wait_dur_show(struct device *dev, 648 struct device_attribute *attr, 649 char *buf) 650 { 651 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 652 struct bmi323_data *data = iio_priv(indio_dev); 653 unsigned int reg_value, raw; 654 int ret, val[2]; 655 656 scoped_guard(mutex, &data->mutex) { 657 ret = bmi323_read_ext_reg(data, BMI323_TAP2_REG, ®_value); 658 if (ret) 659 return ret; 660 } 661 662 raw = FIELD_GET(BMI323_TAP2_MAX_DUR_MSK, reg_value); 663 val[0] = raw / BMI323_MAX_GES_DUR_SCALE; 664 val[1] = BMI323_RAW_TO_MICRO(raw, BMI323_MAX_GES_DUR_SCALE); 665 666 return iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, ARRAY_SIZE(val), 667 val); 668 } 669 670 static ssize_t in_accel_gesture_tap_wait_dur_store(struct device *dev, 671 struct device_attribute *attr, 672 const char *buf, size_t len) 673 { 674 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 675 struct bmi323_data *data = iio_priv(indio_dev); 676 int ret, val_int, val_fract, raw; 677 678 ret = iio_str_to_fixpoint(buf, 100000, &val_int, &val_fract); 679 if (ret) 680 return ret; 681 682 raw = BMI323_INT_MICRO_TO_RAW(val_int, val_fract, 683 BMI323_MAX_GES_DUR_SCALE); 684 if (!in_range(raw, 0, 64)) 685 return -EINVAL; 686 687 guard(mutex)(&data->mutex); 688 ret = bmi323_update_ext_reg(data, BMI323_TAP2_REG, 689 BMI323_TAP2_MAX_DUR_MSK, 690 FIELD_PREP(BMI323_TAP2_MAX_DUR_MSK, raw)); 691 if (ret) 692 return ret; 693 694 return len; 695 } 696 697 /* 698 * Maximum duration from first tap within the second tap is expected to happen. 699 * This timeout is applicable only if gesture_tap_wait_timeout is enabled. 700 */ 701 static IIO_DEVICE_ATTR_RW(in_accel_gesture_tap_wait_dur, 0); 702 703 static ssize_t in_accel_gesture_tap_wait_timeout_show(struct device *dev, 704 struct device_attribute *attr, 705 char *buf) 706 { 707 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 708 struct bmi323_data *data = iio_priv(indio_dev); 709 unsigned int reg_value, raw; 710 int ret; 711 712 scoped_guard(mutex, &data->mutex) { 713 ret = bmi323_read_ext_reg(data, BMI323_TAP1_REG, ®_value); 714 if (ret) 715 return ret; 716 } 717 718 raw = FIELD_GET(BMI323_TAP1_TIMOUT_MSK, reg_value); 719 720 return iio_format_value(buf, IIO_VAL_INT, 1, &raw); 721 } 722 723 static ssize_t in_accel_gesture_tap_wait_timeout_store(struct device *dev, 724 struct device_attribute *attr, 725 const char *buf, 726 size_t len) 727 { 728 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 729 struct bmi323_data *data = iio_priv(indio_dev); 730 bool val; 731 int ret; 732 733 ret = kstrtobool(buf, &val); 734 if (ret) 735 return ret; 736 737 guard(mutex)(&data->mutex); 738 ret = bmi323_update_ext_reg(data, BMI323_TAP1_REG, 739 BMI323_TAP1_TIMOUT_MSK, 740 FIELD_PREP(BMI323_TAP1_TIMOUT_MSK, val)); 741 if (ret) 742 return ret; 743 744 return len; 745 } 746 747 /* Enable/disable gesture confirmation with wait time */ 748 static IIO_DEVICE_ATTR_RW(in_accel_gesture_tap_wait_timeout, 0); 749 750 static IIO_CONST_ATTR(in_accel_gesture_tap_wait_dur_available, 751 "[0.0 0.04 2.52]"); 752 753 static IIO_CONST_ATTR(in_accel_gesture_doubletap_tap2_min_delay_available, 754 "[0.005 0.005 0.075]"); 755 756 static IIO_CONST_ATTR(in_accel_gesture_tap_reset_timeout_available, 757 "[0.04 0.04 0.6]"); 758 759 static IIO_CONST_ATTR(in_accel_gesture_tap_value_available, "[0.0 0.002 1.99]"); 760 761 static IIO_CONST_ATTR(in_accel_mag_value_available, "[0.0 0.002 7.99]"); 762 763 static IIO_CONST_ATTR(in_accel_mag_period_available, "[0.0 0.02 162.0]"); 764 765 static IIO_CONST_ATTR(in_accel_mag_hysteresis_available, "[0.0 0.002 1.99]"); 766 767 static struct attribute *bmi323_event_attributes[] = { 768 &iio_const_attr_in_accel_gesture_tap_value_available.dev_attr.attr, 769 &iio_const_attr_in_accel_gesture_tap_reset_timeout_available.dev_attr.attr, 770 &iio_const_attr_in_accel_gesture_doubletap_tap2_min_delay_available.dev_attr.attr, 771 &iio_const_attr_in_accel_gesture_tap_wait_dur_available.dev_attr.attr, 772 &iio_dev_attr_in_accel_gesture_tap_wait_timeout.dev_attr.attr, 773 &iio_dev_attr_in_accel_gesture_tap_wait_dur.dev_attr.attr, 774 &iio_const_attr_in_accel_mag_value_available.dev_attr.attr, 775 &iio_const_attr_in_accel_mag_period_available.dev_attr.attr, 776 &iio_const_attr_in_accel_mag_hysteresis_available.dev_attr.attr, 777 NULL 778 }; 779 780 static const struct attribute_group bmi323_event_attribute_group = { 781 .attrs = bmi323_event_attributes, 782 }; 783 784 static int bmi323_write_event_config(struct iio_dev *indio_dev, 785 const struct iio_chan_spec *chan, 786 enum iio_event_type type, 787 enum iio_event_direction dir, bool state) 788 { 789 struct bmi323_data *data = iio_priv(indio_dev); 790 791 switch (type) { 792 case IIO_EV_TYPE_MAG: 793 return bmi323_motion_event_en(data, dir, state); 794 case IIO_EV_TYPE_GESTURE: 795 return bmi323_tap_event_en(data, dir, state); 796 case IIO_EV_TYPE_CHANGE: 797 return bmi323_step_wtrmrk_en(data, state); 798 default: 799 return -EINVAL; 800 } 801 } 802 803 static int bmi323_read_event_config(struct iio_dev *indio_dev, 804 const struct iio_chan_spec *chan, 805 enum iio_event_type type, 806 enum iio_event_direction dir) 807 { 808 struct bmi323_data *data = iio_priv(indio_dev); 809 int ret, value, reg_val; 810 811 guard(mutex)(&data->mutex); 812 813 switch (chan->type) { 814 case IIO_ACCEL: 815 switch (dir) { 816 case IIO_EV_DIR_SINGLETAP: 817 ret = FIELD_GET(BMI323_FEAT_IO0_S_TAP_MSK, 818 data->feature_events); 819 break; 820 case IIO_EV_DIR_DOUBLETAP: 821 ret = FIELD_GET(BMI323_FEAT_IO0_D_TAP_MSK, 822 data->feature_events); 823 break; 824 case IIO_EV_DIR_RISING: 825 value = FIELD_GET(BMI323_FEAT_IO0_XYZ_MOTION_MSK, 826 data->feature_events); 827 ret = value ? 1 : 0; 828 break; 829 case IIO_EV_DIR_FALLING: 830 value = FIELD_GET(BMI323_FEAT_IO0_XYZ_NOMOTION_MSK, 831 data->feature_events); 832 ret = value ? 1 : 0; 833 break; 834 default: 835 ret = -EINVAL; 836 break; 837 } 838 return ret; 839 case IIO_STEPS: 840 ret = regmap_read(data->regmap, BMI323_INT_MAP1_REG, ®_val); 841 if (ret) 842 return ret; 843 844 return FIELD_GET(BMI323_STEP_CNT_MSK, reg_val) ? 1 : 0; 845 default: 846 return -EINVAL; 847 } 848 } 849 850 static int bmi323_write_event_value(struct iio_dev *indio_dev, 851 const struct iio_chan_spec *chan, 852 enum iio_event_type type, 853 enum iio_event_direction dir, 854 enum iio_event_info info, 855 int val, int val2) 856 { 857 struct bmi323_data *data = iio_priv(indio_dev); 858 unsigned int raw; 859 int reg; 860 861 guard(mutex)(&data->mutex); 862 863 switch (type) { 864 case IIO_EV_TYPE_GESTURE: 865 switch (info) { 866 case IIO_EV_INFO_VALUE: 867 if (!in_range(val, 0, 2)) 868 return -EINVAL; 869 870 raw = BMI323_INT_MICRO_TO_RAW(val, val2, 871 BMI323_TAP_THRES_SCALE); 872 873 return bmi323_update_ext_reg(data, BMI323_TAP2_REG, 874 BMI323_TAP2_THRES_MSK, 875 FIELD_PREP(BMI323_TAP2_THRES_MSK, 876 raw)); 877 case IIO_EV_INFO_RESET_TIMEOUT: 878 if (val || !in_range(val2, 40000, 560001)) 879 return -EINVAL; 880 881 raw = BMI323_INT_MICRO_TO_RAW(val, val2, 882 BMI323_QUITE_TIM_GES_SCALE); 883 884 return bmi323_update_ext_reg(data, BMI323_TAP3_REG, 885 BMI323_TAP3_QT_AFT_GES_MSK, 886 FIELD_PREP(BMI323_TAP3_QT_AFT_GES_MSK, 887 raw)); 888 case IIO_EV_INFO_TAP2_MIN_DELAY: 889 if (val || !in_range(val2, 5000, 70001)) 890 return -EINVAL; 891 892 raw = BMI323_INT_MICRO_TO_RAW(val, val2, 893 BMI323_DUR_BW_TAP_SCALE); 894 895 return bmi323_update_ext_reg(data, BMI323_TAP3_REG, 896 BMI323_TAP3_QT_BW_TAP_MSK, 897 FIELD_PREP(BMI323_TAP3_QT_BW_TAP_MSK, 898 raw)); 899 default: 900 return -EINVAL; 901 } 902 case IIO_EV_TYPE_MAG: 903 reg = bmi323_motion_config_reg(dir); 904 if (reg < 0) 905 return -EINVAL; 906 907 switch (info) { 908 case IIO_EV_INFO_VALUE: 909 if (!in_range(val, 0, 8)) 910 return -EINVAL; 911 912 raw = BMI323_INT_MICRO_TO_RAW(val, val2, 913 BMI323_MOTION_THRES_SCALE); 914 915 return bmi323_update_ext_reg(data, reg, 916 BMI323_MO1_SLOPE_TH_MSK, 917 FIELD_PREP(BMI323_MO1_SLOPE_TH_MSK, 918 raw)); 919 case IIO_EV_INFO_PERIOD: 920 if (!in_range(val, 0, 163)) 921 return -EINVAL; 922 923 raw = BMI323_INT_MICRO_TO_RAW(val, val2, 924 BMI323_MOTION_DURAT_SCALE); 925 926 return bmi323_update_ext_reg(data, 927 reg + BMI323_MO3_OFFSET, 928 BMI323_MO3_DURA_MSK, 929 FIELD_PREP(BMI323_MO3_DURA_MSK, 930 raw)); 931 case IIO_EV_INFO_HYSTERESIS: 932 if (!in_range(val, 0, 2)) 933 return -EINVAL; 934 935 raw = BMI323_INT_MICRO_TO_RAW(val, val2, 936 BMI323_MOTION_HYSTR_SCALE); 937 938 return bmi323_update_ext_reg(data, 939 reg + BMI323_MO2_OFFSET, 940 BMI323_MO2_HYSTR_MSK, 941 FIELD_PREP(BMI323_MO2_HYSTR_MSK, 942 raw)); 943 default: 944 return -EINVAL; 945 } 946 case IIO_EV_TYPE_CHANGE: 947 if (!in_range(val, 0, 20461)) 948 return -EINVAL; 949 950 raw = val / 20; 951 return bmi323_update_ext_reg(data, BMI323_STEP_SC1_REG, 952 BMI323_STEP_SC1_WTRMRK_MSK, 953 FIELD_PREP(BMI323_STEP_SC1_WTRMRK_MSK, 954 raw)); 955 default: 956 return -EINVAL; 957 } 958 } 959 960 static int bmi323_read_event_value(struct iio_dev *indio_dev, 961 const struct iio_chan_spec *chan, 962 enum iio_event_type type, 963 enum iio_event_direction dir, 964 enum iio_event_info info, 965 int *val, int *val2) 966 { 967 struct bmi323_data *data = iio_priv(indio_dev); 968 unsigned int raw, reg_value; 969 int ret, reg; 970 971 guard(mutex)(&data->mutex); 972 973 switch (type) { 974 case IIO_EV_TYPE_GESTURE: 975 switch (info) { 976 case IIO_EV_INFO_VALUE: 977 ret = bmi323_read_ext_reg(data, BMI323_TAP2_REG, 978 ®_value); 979 if (ret) 980 return ret; 981 982 raw = FIELD_GET(BMI323_TAP2_THRES_MSK, reg_value); 983 *val = raw / BMI323_TAP_THRES_SCALE; 984 *val2 = BMI323_RAW_TO_MICRO(raw, BMI323_TAP_THRES_SCALE); 985 return IIO_VAL_INT_PLUS_MICRO; 986 case IIO_EV_INFO_RESET_TIMEOUT: 987 ret = bmi323_read_ext_reg(data, BMI323_TAP3_REG, 988 ®_value); 989 if (ret) 990 return ret; 991 992 raw = FIELD_GET(BMI323_TAP3_QT_AFT_GES_MSK, reg_value); 993 *val = 0; 994 *val2 = BMI323_RAW_TO_MICRO(raw, 995 BMI323_QUITE_TIM_GES_SCALE); 996 return IIO_VAL_INT_PLUS_MICRO; 997 case IIO_EV_INFO_TAP2_MIN_DELAY: 998 ret = bmi323_read_ext_reg(data, BMI323_TAP3_REG, 999 ®_value); 1000 if (ret) 1001 return ret; 1002 1003 raw = FIELD_GET(BMI323_TAP3_QT_BW_TAP_MSK, reg_value); 1004 *val = 0; 1005 *val2 = BMI323_RAW_TO_MICRO(raw, 1006 BMI323_DUR_BW_TAP_SCALE); 1007 return IIO_VAL_INT_PLUS_MICRO; 1008 default: 1009 return -EINVAL; 1010 } 1011 case IIO_EV_TYPE_MAG: 1012 reg = bmi323_motion_config_reg(dir); 1013 if (reg < 0) 1014 return -EINVAL; 1015 1016 switch (info) { 1017 case IIO_EV_INFO_VALUE: 1018 ret = bmi323_read_ext_reg(data, reg, ®_value); 1019 if (ret) 1020 return ret; 1021 1022 raw = FIELD_GET(BMI323_MO1_SLOPE_TH_MSK, reg_value); 1023 *val = raw / BMI323_MOTION_THRES_SCALE; 1024 *val2 = BMI323_RAW_TO_MICRO(raw, 1025 BMI323_MOTION_THRES_SCALE); 1026 return IIO_VAL_INT_PLUS_MICRO; 1027 case IIO_EV_INFO_PERIOD: 1028 ret = bmi323_read_ext_reg(data, 1029 reg + BMI323_MO3_OFFSET, 1030 ®_value); 1031 if (ret) 1032 return ret; 1033 1034 raw = FIELD_GET(BMI323_MO3_DURA_MSK, reg_value); 1035 *val = raw / BMI323_MOTION_DURAT_SCALE; 1036 *val2 = BMI323_RAW_TO_MICRO(raw, 1037 BMI323_MOTION_DURAT_SCALE); 1038 return IIO_VAL_INT_PLUS_MICRO; 1039 case IIO_EV_INFO_HYSTERESIS: 1040 ret = bmi323_read_ext_reg(data, 1041 reg + BMI323_MO2_OFFSET, 1042 ®_value); 1043 if (ret) 1044 return ret; 1045 1046 raw = FIELD_GET(BMI323_MO2_HYSTR_MSK, reg_value); 1047 *val = raw / BMI323_MOTION_HYSTR_SCALE; 1048 *val2 = BMI323_RAW_TO_MICRO(raw, 1049 BMI323_MOTION_HYSTR_SCALE); 1050 return IIO_VAL_INT_PLUS_MICRO; 1051 default: 1052 return -EINVAL; 1053 } 1054 case IIO_EV_TYPE_CHANGE: 1055 ret = bmi323_read_ext_reg(data, BMI323_STEP_SC1_REG, 1056 ®_value); 1057 if (ret) 1058 return ret; 1059 1060 raw = FIELD_GET(BMI323_STEP_SC1_WTRMRK_MSK, reg_value); 1061 *val = raw * 20; 1062 return IIO_VAL_INT; 1063 default: 1064 return -EINVAL; 1065 } 1066 } 1067 1068 static int __bmi323_fifo_flush(struct iio_dev *indio_dev) 1069 { 1070 struct bmi323_data *data = iio_priv(indio_dev); 1071 int i, ret, fifo_lvl, frame_count, bit, index; 1072 __le16 *frame, *pchannels; 1073 u64 sample_period; 1074 s64 tstamp; 1075 1076 guard(mutex)(&data->mutex); 1077 ret = regmap_read(data->regmap, BMI323_FIFO_FILL_LEVEL_REG, &fifo_lvl); 1078 if (ret) 1079 return ret; 1080 1081 fifo_lvl = min(fifo_lvl, BMI323_FIFO_FULL_IN_WORDS); 1082 1083 frame_count = fifo_lvl / BMI323_FIFO_FRAME_LENGTH; 1084 if (!frame_count) 1085 return -EINVAL; 1086 1087 if (fifo_lvl % BMI323_FIFO_FRAME_LENGTH) 1088 dev_warn(data->dev, "Bad FIFO alignment\n"); 1089 1090 /* 1091 * Approximate timestamps for each of the sample based on the sampling 1092 * frequency, timestamp for last sample and number of samples. 1093 */ 1094 if (data->old_fifo_tstamp) { 1095 sample_period = data->fifo_tstamp - data->old_fifo_tstamp; 1096 do_div(sample_period, frame_count); 1097 } else { 1098 sample_period = data->odrns[BMI323_ACCEL]; 1099 } 1100 1101 tstamp = data->fifo_tstamp - (frame_count - 1) * sample_period; 1102 1103 ret = regmap_noinc_read(data->regmap, BMI323_FIFO_DATA_REG, 1104 &data->fifo_buff[0], 1105 fifo_lvl * BMI323_BYTES_PER_SAMPLE); 1106 if (ret) 1107 return ret; 1108 1109 for (i = 0; i < frame_count; i++) { 1110 frame = &data->fifo_buff[i * BMI323_FIFO_FRAME_LENGTH]; 1111 pchannels = &data->buffer.channels[0]; 1112 1113 index = 0; 1114 for_each_set_bit(bit, indio_dev->active_scan_mask, 1115 BMI323_CHAN_MAX) 1116 pchannels[index++] = frame[bit]; 1117 1118 iio_push_to_buffers_with_timestamp(indio_dev, &data->buffer, 1119 tstamp); 1120 1121 tstamp += sample_period; 1122 } 1123 1124 return frame_count; 1125 } 1126 1127 static int bmi323_set_watermark(struct iio_dev *indio_dev, unsigned int val) 1128 { 1129 struct bmi323_data *data = iio_priv(indio_dev); 1130 1131 val = min(val, (u32)BMI323_FIFO_FULL_IN_FRAMES); 1132 1133 guard(mutex)(&data->mutex); 1134 data->watermark = val; 1135 1136 return 0; 1137 } 1138 1139 static int bmi323_fifo_disable(struct bmi323_data *data) 1140 { 1141 int ret; 1142 1143 guard(mutex)(&data->mutex); 1144 ret = regmap_write(data->regmap, BMI323_FIFO_CONF_REG, 0); 1145 if (ret) 1146 return ret; 1147 1148 ret = regmap_update_bits(data->regmap, BMI323_INT_MAP2_REG, 1149 BMI323_FIFO_WTRMRK_MSK, 1150 FIELD_PREP(BMI323_FIFO_WTRMRK_MSK, 0)); 1151 if (ret) 1152 return ret; 1153 1154 data->fifo_tstamp = 0; 1155 data->state = BMI323_IDLE; 1156 1157 return 0; 1158 } 1159 1160 static int bmi323_buffer_predisable(struct iio_dev *indio_dev) 1161 { 1162 struct bmi323_data *data = iio_priv(indio_dev); 1163 1164 if (iio_device_get_current_mode(indio_dev) == INDIO_BUFFER_TRIGGERED) 1165 return 0; 1166 1167 return bmi323_fifo_disable(data); 1168 } 1169 1170 static int bmi323_update_watermark(struct bmi323_data *data) 1171 { 1172 int wtrmrk; 1173 1174 wtrmrk = data->watermark * BMI323_FIFO_FRAME_LENGTH; 1175 1176 return regmap_write(data->regmap, BMI323_FIFO_WTRMRK_REG, wtrmrk); 1177 } 1178 1179 static int bmi323_fifo_enable(struct bmi323_data *data) 1180 { 1181 int ret; 1182 1183 guard(mutex)(&data->mutex); 1184 ret = regmap_update_bits(data->regmap, BMI323_FIFO_CONF_REG, 1185 BMI323_FIFO_CONF_ACC_GYR_EN_MSK, 1186 FIELD_PREP(BMI323_FIFO_CONF_ACC_GYR_EN_MSK, 1187 BMI323_FIFO_ACC_GYR_MSK)); 1188 if (ret) 1189 return ret; 1190 1191 ret = regmap_update_bits(data->regmap, BMI323_INT_MAP2_REG, 1192 BMI323_FIFO_WTRMRK_MSK, 1193 FIELD_PREP(BMI323_FIFO_WTRMRK_MSK, 1194 data->irq_pin)); 1195 if (ret) 1196 return ret; 1197 1198 ret = bmi323_update_watermark(data); 1199 if (ret) 1200 return ret; 1201 1202 ret = regmap_write(data->regmap, BMI323_FIFO_CTRL_REG, 1203 BMI323_FIFO_FLUSH_MSK); 1204 if (ret) 1205 return ret; 1206 1207 data->state = BMI323_BUFFER_FIFO; 1208 1209 return 0; 1210 } 1211 1212 static int bmi323_buffer_preenable(struct iio_dev *indio_dev) 1213 { 1214 struct bmi323_data *data = iio_priv(indio_dev); 1215 1216 guard(mutex)(&data->mutex); 1217 /* 1218 * When the ODR of the accelerometer and gyroscope do not match, the 1219 * maximum ODR value between the accelerometer and gyroscope is used 1220 * for FIFO and the signal with lower ODR will insert dummy frame. 1221 * So allow buffer read only when ODR's of accelero and gyro are equal. 1222 * See datasheet section 5.7 "FIFO Data Buffering". 1223 */ 1224 if (data->odrns[BMI323_ACCEL] != data->odrns[BMI323_GYRO]) { 1225 dev_err(data->dev, "Accelero and Gyro ODR doesn't match\n"); 1226 return -EINVAL; 1227 } 1228 1229 return 0; 1230 } 1231 1232 static int bmi323_buffer_postenable(struct iio_dev *indio_dev) 1233 { 1234 struct bmi323_data *data = iio_priv(indio_dev); 1235 1236 if (iio_device_get_current_mode(indio_dev) == INDIO_BUFFER_TRIGGERED) 1237 return 0; 1238 1239 return bmi323_fifo_enable(data); 1240 } 1241 1242 static ssize_t hwfifo_watermark_show(struct device *dev, 1243 struct device_attribute *attr, char *buf) 1244 { 1245 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 1246 struct bmi323_data *data = iio_priv(indio_dev); 1247 int wm; 1248 1249 scoped_guard(mutex, &data->mutex) 1250 wm = data->watermark; 1251 1252 return sysfs_emit(buf, "%d\n", wm); 1253 } 1254 static IIO_DEVICE_ATTR_RO(hwfifo_watermark, 0); 1255 1256 static ssize_t hwfifo_enabled_show(struct device *dev, 1257 struct device_attribute *attr, 1258 char *buf) 1259 { 1260 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 1261 struct bmi323_data *data = iio_priv(indio_dev); 1262 bool state; 1263 1264 scoped_guard(mutex, &data->mutex) 1265 state = data->state == BMI323_BUFFER_FIFO; 1266 1267 return sysfs_emit(buf, "%d\n", state); 1268 } 1269 static IIO_DEVICE_ATTR_RO(hwfifo_enabled, 0); 1270 1271 static const struct iio_dev_attr *bmi323_fifo_attributes[] = { 1272 &iio_dev_attr_hwfifo_watermark, 1273 &iio_dev_attr_hwfifo_enabled, 1274 NULL 1275 }; 1276 1277 static const struct iio_buffer_setup_ops bmi323_buffer_ops = { 1278 .preenable = bmi323_buffer_preenable, 1279 .postenable = bmi323_buffer_postenable, 1280 .predisable = bmi323_buffer_predisable, 1281 }; 1282 1283 static irqreturn_t bmi323_irq_thread_handler(int irq, void *private) 1284 { 1285 struct iio_dev *indio_dev = private; 1286 struct bmi323_data *data = iio_priv(indio_dev); 1287 unsigned int status_addr, status, feature_event; 1288 s64 timestamp = iio_get_time_ns(indio_dev); 1289 int ret; 1290 1291 if (data->irq_pin == BMI323_IRQ_INT1) 1292 status_addr = BMI323_STATUS_INT1_REG; 1293 else 1294 status_addr = BMI323_STATUS_INT2_REG; 1295 1296 scoped_guard(mutex, &data->mutex) { 1297 ret = regmap_read(data->regmap, status_addr, &status); 1298 if (ret) 1299 return IRQ_NONE; 1300 } 1301 1302 if (!status || FIELD_GET(BMI323_STATUS_ERROR_MSK, status)) 1303 return IRQ_NONE; 1304 1305 if (FIELD_GET(BMI323_STATUS_FIFO_WTRMRK_MSK, status)) { 1306 data->old_fifo_tstamp = data->fifo_tstamp; 1307 data->fifo_tstamp = iio_get_time_ns(indio_dev); 1308 ret = __bmi323_fifo_flush(indio_dev); 1309 if (ret < 0) 1310 return IRQ_NONE; 1311 } 1312 1313 if (FIELD_GET(BMI323_STATUS_ACC_GYR_DRDY_MSK, status)) 1314 iio_trigger_poll_nested(data->trig); 1315 1316 if (FIELD_GET(BMI323_STATUS_MOTION_MSK, status)) 1317 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, 1318 IIO_MOD_X_OR_Y_OR_Z, 1319 IIO_EV_TYPE_MAG, 1320 IIO_EV_DIR_RISING), 1321 timestamp); 1322 1323 if (FIELD_GET(BMI323_STATUS_NOMOTION_MSK, status)) 1324 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, 1325 IIO_MOD_X_OR_Y_OR_Z, 1326 IIO_EV_TYPE_MAG, 1327 IIO_EV_DIR_FALLING), 1328 timestamp); 1329 1330 if (FIELD_GET(BMI323_STATUS_STP_WTR_MSK, status)) 1331 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_STEPS, 0, 1332 IIO_NO_MOD, 1333 IIO_EV_TYPE_CHANGE, 1334 IIO_EV_DIR_NONE), 1335 timestamp); 1336 1337 if (FIELD_GET(BMI323_STATUS_TAP_MSK, status)) { 1338 scoped_guard(mutex, &data->mutex) { 1339 ret = regmap_read(data->regmap, 1340 BMI323_FEAT_EVNT_EXT_REG, 1341 &feature_event); 1342 if (ret) 1343 return IRQ_NONE; 1344 } 1345 1346 if (FIELD_GET(BMI323_FEAT_EVNT_EXT_S_MSK, feature_event)) { 1347 iio_push_event(indio_dev, 1348 IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, 1349 IIO_MOD_X_OR_Y_OR_Z, 1350 IIO_EV_TYPE_GESTURE, 1351 IIO_EV_DIR_SINGLETAP), 1352 timestamp); 1353 } 1354 1355 if (FIELD_GET(BMI323_FEAT_EVNT_EXT_D_MSK, feature_event)) 1356 iio_push_event(indio_dev, 1357 IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, 1358 IIO_MOD_X_OR_Y_OR_Z, 1359 IIO_EV_TYPE_GESTURE, 1360 IIO_EV_DIR_DOUBLETAP), 1361 timestamp); 1362 } 1363 1364 return IRQ_HANDLED; 1365 } 1366 1367 static int bmi323_set_drdy_irq(struct bmi323_data *data, 1368 enum bmi323_irq_pin irq_pin) 1369 { 1370 int ret; 1371 1372 ret = regmap_update_bits(data->regmap, BMI323_INT_MAP2_REG, 1373 BMI323_GYR_DRDY_MSK, 1374 FIELD_PREP(BMI323_GYR_DRDY_MSK, irq_pin)); 1375 if (ret) 1376 return ret; 1377 1378 return regmap_update_bits(data->regmap, BMI323_INT_MAP2_REG, 1379 BMI323_ACC_DRDY_MSK, 1380 FIELD_PREP(BMI323_ACC_DRDY_MSK, irq_pin)); 1381 } 1382 1383 static int bmi323_data_rdy_trigger_set_state(struct iio_trigger *trig, 1384 bool state) 1385 { 1386 struct bmi323_data *data = iio_trigger_get_drvdata(trig); 1387 enum bmi323_irq_pin irq_pin; 1388 1389 guard(mutex)(&data->mutex); 1390 1391 if (data->state == BMI323_BUFFER_FIFO) { 1392 dev_warn(data->dev, "Can't set trigger when FIFO enabled\n"); 1393 return -EBUSY; 1394 } 1395 1396 if (state) { 1397 data->state = BMI323_BUFFER_DRDY_TRIGGERED; 1398 irq_pin = data->irq_pin; 1399 } else { 1400 data->state = BMI323_IDLE; 1401 irq_pin = BMI323_IRQ_DISABLED; 1402 } 1403 1404 return bmi323_set_drdy_irq(data, irq_pin); 1405 } 1406 1407 static const struct iio_trigger_ops bmi323_trigger_ops = { 1408 .set_trigger_state = &bmi323_data_rdy_trigger_set_state, 1409 }; 1410 1411 static irqreturn_t bmi323_trigger_handler(int irq, void *p) 1412 { 1413 struct iio_poll_func *pf = p; 1414 struct iio_dev *indio_dev = pf->indio_dev; 1415 struct bmi323_data *data = iio_priv(indio_dev); 1416 int ret, bit, index = 0; 1417 1418 /* Lock to protect the data->buffer */ 1419 guard(mutex)(&data->mutex); 1420 1421 if (*indio_dev->active_scan_mask == BMI323_ALL_CHAN_MSK) { 1422 ret = regmap_bulk_read(data->regmap, BMI323_ACCEL_X_REG, 1423 &data->buffer.channels, 1424 ARRAY_SIZE(data->buffer.channels)); 1425 if (ret) 1426 goto out; 1427 } else { 1428 for_each_set_bit(bit, indio_dev->active_scan_mask, 1429 BMI323_CHAN_MAX) { 1430 ret = regmap_raw_read(data->regmap, 1431 BMI323_ACCEL_X_REG + bit, 1432 &data->buffer.channels[index++], 1433 BMI323_BYTES_PER_SAMPLE); 1434 if (ret) 1435 goto out; 1436 } 1437 } 1438 1439 iio_push_to_buffers_with_timestamp(indio_dev, &data->buffer, 1440 iio_get_time_ns(indio_dev)); 1441 1442 out: 1443 iio_trigger_notify_done(indio_dev->trig); 1444 1445 return IRQ_HANDLED; 1446 } 1447 1448 static int bmi323_set_average(struct bmi323_data *data, 1449 enum bmi323_sensor_type sensor, int avg) 1450 { 1451 int raw = ARRAY_SIZE(bmi323_accel_gyro_avrg); 1452 1453 while (raw--) 1454 if (avg == bmi323_accel_gyro_avrg[raw]) 1455 break; 1456 if (raw < 0) 1457 return -EINVAL; 1458 1459 guard(mutex)(&data->mutex); 1460 return regmap_update_bits(data->regmap, bmi323_hw[sensor].config, 1461 BMI323_ACC_GYRO_CONF_AVG_MSK, 1462 FIELD_PREP(BMI323_ACC_GYRO_CONF_AVG_MSK, 1463 raw)); 1464 } 1465 1466 static int bmi323_get_average(struct bmi323_data *data, 1467 enum bmi323_sensor_type sensor, int *avg) 1468 { 1469 int ret, value, raw; 1470 1471 scoped_guard(mutex, &data->mutex) { 1472 ret = regmap_read(data->regmap, bmi323_hw[sensor].config, &value); 1473 if (ret) 1474 return ret; 1475 } 1476 1477 raw = FIELD_GET(BMI323_ACC_GYRO_CONF_AVG_MSK, value); 1478 *avg = bmi323_accel_gyro_avrg[raw]; 1479 1480 return IIO_VAL_INT; 1481 } 1482 1483 static int bmi323_enable_steps(struct bmi323_data *data, int val) 1484 { 1485 int ret; 1486 1487 guard(mutex)(&data->mutex); 1488 if (data->odrhz[BMI323_ACCEL] < 200) { 1489 dev_err(data->dev, "Invalid accelerometer parameter\n"); 1490 return -EINVAL; 1491 } 1492 1493 ret = bmi323_feature_engine_events(data, BMI323_FEAT_IO0_STP_CNT_MSK, 1494 val ? 1 : 0); 1495 if (ret) 1496 return ret; 1497 1498 set_mask_bits(&data->feature_events, BMI323_FEAT_IO0_STP_CNT_MSK, 1499 FIELD_PREP(BMI323_FEAT_IO0_STP_CNT_MSK, val ? 1 : 0)); 1500 1501 return 0; 1502 } 1503 1504 static int bmi323_read_steps(struct bmi323_data *data, int *val) 1505 { 1506 int ret; 1507 1508 guard(mutex)(&data->mutex); 1509 if (!FIELD_GET(BMI323_FEAT_IO0_STP_CNT_MSK, data->feature_events)) 1510 return -EINVAL; 1511 1512 ret = regmap_bulk_read(data->regmap, BMI323_FEAT_IO2_REG, 1513 data->steps_count, 1514 ARRAY_SIZE(data->steps_count)); 1515 if (ret) 1516 return ret; 1517 1518 *val = get_unaligned_le32(data->steps_count); 1519 1520 return IIO_VAL_INT; 1521 } 1522 1523 static int bmi323_read_axis(struct bmi323_data *data, 1524 struct iio_chan_spec const *chan, int *val) 1525 { 1526 enum bmi323_sensor_type sensor; 1527 unsigned int value; 1528 u8 addr; 1529 int ret; 1530 1531 ret = bmi323_get_error_status(data); 1532 if (ret) 1533 return -EINVAL; 1534 1535 sensor = bmi323_iio_to_sensor(chan->type); 1536 addr = bmi323_hw[sensor].data + (chan->channel2 - IIO_MOD_X); 1537 1538 scoped_guard(mutex, &data->mutex) { 1539 ret = regmap_read(data->regmap, addr, &value); 1540 if (ret) 1541 return ret; 1542 } 1543 1544 *val = sign_extend32(value, chan->scan_type.realbits - 1); 1545 1546 return IIO_VAL_INT; 1547 } 1548 1549 static int bmi323_get_temp_data(struct bmi323_data *data, int *val) 1550 { 1551 unsigned int value; 1552 int ret; 1553 1554 ret = bmi323_get_error_status(data); 1555 if (ret) 1556 return -EINVAL; 1557 1558 scoped_guard(mutex, &data->mutex) { 1559 ret = regmap_read(data->regmap, BMI323_TEMP_REG, &value); 1560 if (ret) 1561 return ret; 1562 } 1563 1564 *val = sign_extend32(value, 15); 1565 1566 return IIO_VAL_INT; 1567 } 1568 1569 static int bmi323_get_odr(struct bmi323_data *data, 1570 enum bmi323_sensor_type sensor, int *odr, int *uodr) 1571 { 1572 int ret, value, odr_raw; 1573 1574 scoped_guard(mutex, &data->mutex) { 1575 ret = regmap_read(data->regmap, bmi323_hw[sensor].config, &value); 1576 if (ret) 1577 return ret; 1578 } 1579 1580 odr_raw = FIELD_GET(BMI323_ACC_GYRO_CONF_ODR_MSK, value); 1581 *odr = bmi323_acc_gyro_odr[odr_raw - 1][0]; 1582 *uodr = bmi323_acc_gyro_odr[odr_raw - 1][1]; 1583 1584 return IIO_VAL_INT_PLUS_MICRO; 1585 } 1586 1587 static int bmi323_configure_power_mode(struct bmi323_data *data, 1588 enum bmi323_sensor_type sensor, 1589 int odr_index) 1590 { 1591 enum bmi323_opr_mode mode; 1592 1593 if (bmi323_acc_gyro_odr[odr_index][0] > 25) 1594 mode = ACC_GYRO_MODE_CONTINOUS; 1595 else 1596 mode = ACC_GYRO_MODE_DUTYCYCLE; 1597 1598 return bmi323_set_mode(data, sensor, mode); 1599 } 1600 1601 static int bmi323_set_odr(struct bmi323_data *data, 1602 enum bmi323_sensor_type sensor, int odr, int uodr) 1603 { 1604 int odr_raw, ret; 1605 1606 odr_raw = ARRAY_SIZE(bmi323_acc_gyro_odr); 1607 1608 while (odr_raw--) 1609 if (odr == bmi323_acc_gyro_odr[odr_raw][0] && 1610 uodr == bmi323_acc_gyro_odr[odr_raw][1]) 1611 break; 1612 if (odr_raw < 0) 1613 return -EINVAL; 1614 1615 ret = bmi323_configure_power_mode(data, sensor, odr_raw); 1616 if (ret) 1617 return -EINVAL; 1618 1619 guard(mutex)(&data->mutex); 1620 data->odrhz[sensor] = bmi323_acc_gyro_odr[odr_raw][0]; 1621 data->odrns[sensor] = bmi323_acc_gyro_odrns[odr_raw]; 1622 1623 odr_raw++; 1624 1625 return regmap_update_bits(data->regmap, bmi323_hw[sensor].config, 1626 BMI323_ACC_GYRO_CONF_ODR_MSK, 1627 FIELD_PREP(BMI323_ACC_GYRO_CONF_ODR_MSK, 1628 odr_raw)); 1629 } 1630 1631 static int bmi323_get_scale(struct bmi323_data *data, 1632 enum bmi323_sensor_type sensor, int *val2) 1633 { 1634 int ret, value, scale_raw; 1635 1636 scoped_guard(mutex, &data->mutex) { 1637 ret = regmap_read(data->regmap, bmi323_hw[sensor].config, 1638 &value); 1639 if (ret) 1640 return ret; 1641 } 1642 1643 scale_raw = FIELD_GET(BMI323_ACC_GYRO_CONF_SCL_MSK, value); 1644 *val2 = bmi323_hw[sensor].scale_table[scale_raw][1]; 1645 1646 return IIO_VAL_INT_PLUS_MICRO; 1647 } 1648 1649 static int bmi323_set_scale(struct bmi323_data *data, 1650 enum bmi323_sensor_type sensor, int val, int val2) 1651 { 1652 int scale_raw; 1653 1654 scale_raw = bmi323_hw[sensor].scale_table_len; 1655 1656 while (scale_raw--) 1657 if (val == bmi323_hw[sensor].scale_table[scale_raw][0] && 1658 val2 == bmi323_hw[sensor].scale_table[scale_raw][1]) 1659 break; 1660 if (scale_raw < 0) 1661 return -EINVAL; 1662 1663 guard(mutex)(&data->mutex); 1664 return regmap_update_bits(data->regmap, bmi323_hw[sensor].config, 1665 BMI323_ACC_GYRO_CONF_SCL_MSK, 1666 FIELD_PREP(BMI323_ACC_GYRO_CONF_SCL_MSK, 1667 scale_raw)); 1668 } 1669 1670 static int bmi323_read_avail(struct iio_dev *indio_dev, 1671 struct iio_chan_spec const *chan, 1672 const int **vals, int *type, int *length, 1673 long mask) 1674 { 1675 enum bmi323_sensor_type sensor; 1676 1677 switch (mask) { 1678 case IIO_CHAN_INFO_SAMP_FREQ: 1679 *type = IIO_VAL_INT_PLUS_MICRO; 1680 *vals = (const int *)bmi323_acc_gyro_odr; 1681 *length = ARRAY_SIZE(bmi323_acc_gyro_odr) * 2; 1682 return IIO_AVAIL_LIST; 1683 case IIO_CHAN_INFO_SCALE: 1684 sensor = bmi323_iio_to_sensor(chan->type); 1685 *type = IIO_VAL_INT_PLUS_MICRO; 1686 *vals = (const int *)bmi323_hw[sensor].scale_table; 1687 *length = bmi323_hw[sensor].scale_table_len * 2; 1688 return IIO_AVAIL_LIST; 1689 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 1690 *type = IIO_VAL_INT; 1691 *vals = (const int *)bmi323_accel_gyro_avrg; 1692 *length = ARRAY_SIZE(bmi323_accel_gyro_avrg); 1693 return IIO_AVAIL_LIST; 1694 default: 1695 return -EINVAL; 1696 } 1697 } 1698 1699 static int bmi323_write_raw(struct iio_dev *indio_dev, 1700 struct iio_chan_spec const *chan, int val, 1701 int val2, long mask) 1702 { 1703 struct bmi323_data *data = iio_priv(indio_dev); 1704 int ret; 1705 1706 switch (mask) { 1707 case IIO_CHAN_INFO_SAMP_FREQ: 1708 if (!iio_device_claim_direct(indio_dev)) 1709 return -EBUSY; 1710 ret = bmi323_set_odr(data, bmi323_iio_to_sensor(chan->type), 1711 val, val2); 1712 iio_device_release_direct(indio_dev); 1713 return ret; 1714 case IIO_CHAN_INFO_SCALE: 1715 if (!iio_device_claim_direct(indio_dev)) 1716 return -EBUSY; 1717 ret = bmi323_set_scale(data, bmi323_iio_to_sensor(chan->type), 1718 val, val2); 1719 iio_device_release_direct(indio_dev); 1720 return ret; 1721 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 1722 if (!iio_device_claim_direct(indio_dev)) 1723 return -EBUSY; 1724 ret = bmi323_set_average(data, bmi323_iio_to_sensor(chan->type), 1725 val); 1726 iio_device_release_direct(indio_dev); 1727 return ret; 1728 case IIO_CHAN_INFO_ENABLE: 1729 return bmi323_enable_steps(data, val); 1730 case IIO_CHAN_INFO_PROCESSED: { 1731 guard(mutex)(&data->mutex); 1732 1733 if (val || !FIELD_GET(BMI323_FEAT_IO0_STP_CNT_MSK, 1734 data->feature_events)) 1735 return -EINVAL; 1736 1737 /* Clear step counter value */ 1738 return bmi323_update_ext_reg(data, BMI323_STEP_SC1_REG, 1739 BMI323_STEP_SC1_RST_CNT_MSK, 1740 FIELD_PREP(BMI323_STEP_SC1_RST_CNT_MSK, 1741 1)); 1742 } 1743 default: 1744 return -EINVAL; 1745 } 1746 } 1747 1748 static int bmi323_read_raw(struct iio_dev *indio_dev, 1749 struct iio_chan_spec const *chan, int *val, 1750 int *val2, long mask) 1751 { 1752 struct bmi323_data *data = iio_priv(indio_dev); 1753 int ret; 1754 1755 switch (mask) { 1756 case IIO_CHAN_INFO_PROCESSED: 1757 return bmi323_read_steps(data, val); 1758 case IIO_CHAN_INFO_RAW: 1759 switch (chan->type) { 1760 case IIO_ACCEL: 1761 case IIO_ANGL_VEL: 1762 if (!iio_device_claim_direct(indio_dev)) 1763 return -EBUSY; 1764 ret = bmi323_read_axis(data, chan, val); 1765 iio_device_release_direct(indio_dev); 1766 return ret; 1767 case IIO_TEMP: 1768 return bmi323_get_temp_data(data, val); 1769 default: 1770 return -EINVAL; 1771 } 1772 case IIO_CHAN_INFO_SAMP_FREQ: 1773 return bmi323_get_odr(data, bmi323_iio_to_sensor(chan->type), 1774 val, val2); 1775 case IIO_CHAN_INFO_SCALE: 1776 switch (chan->type) { 1777 case IIO_ACCEL: 1778 case IIO_ANGL_VEL: 1779 *val = 0; 1780 return bmi323_get_scale(data, 1781 bmi323_iio_to_sensor(chan->type), 1782 val2); 1783 case IIO_TEMP: 1784 *val = BMI323_TEMP_SCALE / MEGA; 1785 *val2 = BMI323_TEMP_SCALE % MEGA; 1786 return IIO_VAL_INT_PLUS_MICRO; 1787 default: 1788 return -EINVAL; 1789 } 1790 case IIO_CHAN_INFO_OVERSAMPLING_RATIO: 1791 return bmi323_get_average(data, 1792 bmi323_iio_to_sensor(chan->type), 1793 val); 1794 case IIO_CHAN_INFO_OFFSET: 1795 switch (chan->type) { 1796 case IIO_TEMP: 1797 *val = BMI323_TEMP_OFFSET; 1798 return IIO_VAL_INT; 1799 default: 1800 return -EINVAL; 1801 } 1802 case IIO_CHAN_INFO_ENABLE: 1803 scoped_guard(mutex, &data->mutex) 1804 *val = FIELD_GET(BMI323_FEAT_IO0_STP_CNT_MSK, 1805 data->feature_events); 1806 return IIO_VAL_INT; 1807 default: 1808 return -EINVAL; 1809 } 1810 } 1811 1812 static const struct iio_info bmi323_info = { 1813 .read_raw = bmi323_read_raw, 1814 .write_raw = bmi323_write_raw, 1815 .read_avail = bmi323_read_avail, 1816 .hwfifo_set_watermark = bmi323_set_watermark, 1817 .write_event_config = bmi323_write_event_config, 1818 .read_event_config = bmi323_read_event_config, 1819 .write_event_value = bmi323_write_event_value, 1820 .read_event_value = bmi323_read_event_value, 1821 .event_attrs = &bmi323_event_attribute_group, 1822 }; 1823 1824 #define BMI323_SCAN_MASK_ACCEL_3AXIS \ 1825 (BIT(BMI323_ACCEL_X) | BIT(BMI323_ACCEL_Y) | BIT(BMI323_ACCEL_Z)) 1826 1827 #define BMI323_SCAN_MASK_GYRO_3AXIS \ 1828 (BIT(BMI323_GYRO_X) | BIT(BMI323_GYRO_Y) | BIT(BMI323_GYRO_Z)) 1829 1830 static const unsigned long bmi323_avail_scan_masks[] = { 1831 /* 3-axis accel */ 1832 BMI323_SCAN_MASK_ACCEL_3AXIS, 1833 /* 3-axis gyro */ 1834 BMI323_SCAN_MASK_GYRO_3AXIS, 1835 /* 3-axis accel + 3-axis gyro */ 1836 BMI323_SCAN_MASK_ACCEL_3AXIS | BMI323_SCAN_MASK_GYRO_3AXIS, 1837 0 1838 }; 1839 1840 static int bmi323_int_pin_config(struct bmi323_data *data, 1841 enum bmi323_irq_pin irq_pin, 1842 bool active_high, bool open_drain, bool latch) 1843 { 1844 unsigned int mask, field_value; 1845 int ret; 1846 1847 ret = regmap_update_bits(data->regmap, BMI323_IO_INT_CONF_REG, 1848 BMI323_IO_INT_LTCH_MSK, 1849 FIELD_PREP(BMI323_IO_INT_LTCH_MSK, latch)); 1850 if (ret) 1851 return ret; 1852 1853 ret = bmi323_update_ext_reg(data, BMI323_GEN_SET1_REG, 1854 BMI323_GEN_HOLD_DUR_MSK, 1855 FIELD_PREP(BMI323_GEN_HOLD_DUR_MSK, 0)); 1856 if (ret) 1857 return ret; 1858 1859 switch (irq_pin) { 1860 case BMI323_IRQ_INT1: 1861 mask = BMI323_IO_INT1_LVL_OD_OP_MSK; 1862 1863 field_value = FIELD_PREP(BMI323_IO_INT1_LVL_MSK, active_high) | 1864 FIELD_PREP(BMI323_IO_INT1_OD_MSK, open_drain) | 1865 FIELD_PREP(BMI323_IO_INT1_OP_EN_MSK, 1); 1866 break; 1867 case BMI323_IRQ_INT2: 1868 mask = BMI323_IO_INT2_LVL_OD_OP_MSK; 1869 1870 field_value = FIELD_PREP(BMI323_IO_INT2_LVL_MSK, active_high) | 1871 FIELD_PREP(BMI323_IO_INT2_OD_MSK, open_drain) | 1872 FIELD_PREP(BMI323_IO_INT2_OP_EN_MSK, 1); 1873 break; 1874 default: 1875 return -EINVAL; 1876 } 1877 1878 return regmap_update_bits(data->regmap, BMI323_IO_INT_CTR_REG, mask, 1879 field_value); 1880 } 1881 1882 static int bmi323_trigger_probe(struct bmi323_data *data, 1883 struct iio_dev *indio_dev) 1884 { 1885 bool open_drain, active_high, latch; 1886 struct fwnode_handle *fwnode; 1887 enum bmi323_irq_pin irq_pin; 1888 int ret, irq, irq_type; 1889 1890 fwnode = dev_fwnode(data->dev); 1891 if (!fwnode) 1892 return -ENODEV; 1893 1894 irq = fwnode_irq_get_byname(fwnode, "INT1"); 1895 if (irq > 0) { 1896 irq_pin = BMI323_IRQ_INT1; 1897 } else { 1898 irq = fwnode_irq_get_byname(fwnode, "INT2"); 1899 if (irq < 0) 1900 return 0; 1901 1902 irq_pin = BMI323_IRQ_INT2; 1903 } 1904 1905 irq_type = irq_get_trigger_type(irq); 1906 switch (irq_type) { 1907 case IRQF_TRIGGER_RISING: 1908 latch = false; 1909 active_high = true; 1910 break; 1911 case IRQF_TRIGGER_HIGH: 1912 latch = true; 1913 active_high = true; 1914 break; 1915 case IRQF_TRIGGER_FALLING: 1916 latch = false; 1917 active_high = false; 1918 break; 1919 case IRQF_TRIGGER_LOW: 1920 latch = true; 1921 active_high = false; 1922 break; 1923 default: 1924 return dev_err_probe(data->dev, -EINVAL, 1925 "Invalid interrupt type 0x%x specified\n", 1926 irq_type); 1927 } 1928 1929 open_drain = fwnode_property_read_bool(fwnode, "drive-open-drain"); 1930 1931 ret = bmi323_int_pin_config(data, irq_pin, active_high, open_drain, 1932 latch); 1933 if (ret) 1934 return dev_err_probe(data->dev, ret, 1935 "Failed to configure irq line\n"); 1936 1937 data->trig = devm_iio_trigger_alloc(data->dev, "%s-trig-%d", 1938 indio_dev->name, irq_pin); 1939 if (!data->trig) 1940 return -ENOMEM; 1941 1942 data->trig->ops = &bmi323_trigger_ops; 1943 iio_trigger_set_drvdata(data->trig, data); 1944 1945 ret = devm_request_threaded_irq(data->dev, irq, NULL, 1946 bmi323_irq_thread_handler, 1947 IRQF_ONESHOT, "bmi323-int", indio_dev); 1948 if (ret) 1949 return dev_err_probe(data->dev, ret, "Failed to request IRQ\n"); 1950 1951 ret = devm_iio_trigger_register(data->dev, data->trig); 1952 if (ret) 1953 return dev_err_probe(data->dev, ret, 1954 "Trigger registration failed\n"); 1955 1956 data->irq_pin = irq_pin; 1957 1958 return 0; 1959 } 1960 1961 static int bmi323_feature_engine_enable(struct bmi323_data *data, bool en) 1962 { 1963 unsigned int feature_status; 1964 int ret; 1965 1966 if (!en) 1967 return regmap_write(data->regmap, BMI323_FEAT_CTRL_REG, 0); 1968 1969 ret = regmap_write(data->regmap, BMI323_FEAT_IO2_REG, 0x012c); 1970 if (ret) 1971 return ret; 1972 1973 ret = regmap_write(data->regmap, BMI323_FEAT_IO_STATUS_REG, 1974 BMI323_FEAT_IO_STATUS_MSK); 1975 if (ret) 1976 return ret; 1977 1978 ret = regmap_write(data->regmap, BMI323_FEAT_CTRL_REG, 1979 BMI323_FEAT_ENG_EN_MSK); 1980 if (ret) 1981 return ret; 1982 1983 /* 1984 * It takes around 4 msec to enable the Feature engine, so check 1985 * the status of the feature engine every 2 msec for a maximum 1986 * of 5 trials. 1987 */ 1988 ret = regmap_read_poll_timeout(data->regmap, BMI323_FEAT_IO1_REG, 1989 feature_status, 1990 FIELD_GET(BMI323_FEAT_IO1_ERR_MSK, 1991 feature_status) == 1, 1992 BMI323_FEAT_ENG_POLL, 1993 BMI323_FEAT_ENG_TIMEOUT); 1994 if (ret) 1995 return dev_err_probe(data->dev, -EINVAL, 1996 "Failed to enable feature engine\n"); 1997 1998 return 0; 1999 } 2000 2001 static void bmi323_disable(void *data_ptr) 2002 { 2003 struct bmi323_data *data = data_ptr; 2004 2005 bmi323_set_mode(data, BMI323_ACCEL, ACC_GYRO_MODE_DISABLE); 2006 bmi323_set_mode(data, BMI323_GYRO, ACC_GYRO_MODE_DISABLE); 2007 2008 /* 2009 * Place the peripheral in its lowest power consuming state. 2010 */ 2011 regmap_write(data->regmap, BMI323_CMD_REG, BMI323_RST_VAL); 2012 } 2013 2014 static int bmi323_set_bw(struct bmi323_data *data, 2015 enum bmi323_sensor_type sensor, enum bmi323_3db_bw bw) 2016 { 2017 return regmap_update_bits(data->regmap, bmi323_hw[sensor].config, 2018 BMI323_ACC_GYRO_CONF_BW_MSK, 2019 FIELD_PREP(BMI323_ACC_GYRO_CONF_BW_MSK, bw)); 2020 } 2021 2022 static int bmi323_init(struct bmi323_data *data) 2023 { 2024 int ret, val; 2025 2026 /* 2027 * Perform soft reset to make sure the device is in a known state after 2028 * start up. A delay of 1.5 ms is required after reset. 2029 * See datasheet section 5.17 "Soft Reset". 2030 */ 2031 ret = regmap_write(data->regmap, BMI323_CMD_REG, BMI323_RST_VAL); 2032 if (ret) 2033 return ret; 2034 2035 usleep_range(1500, 2000); 2036 2037 /* 2038 * Dummy read is required to enable SPI interface after reset. 2039 * See datasheet section 7.2.1 "Protocol Selection". 2040 */ 2041 regmap_read(data->regmap, BMI323_CHIP_ID_REG, &val); 2042 2043 ret = regmap_read(data->regmap, BMI323_STATUS_REG, &val); 2044 if (ret) 2045 return ret; 2046 2047 if (!FIELD_GET(BMI323_STATUS_POR_MSK, val)) 2048 return dev_err_probe(data->dev, -EINVAL, 2049 "Sensor initialization error\n"); 2050 2051 ret = regmap_read(data->regmap, BMI323_CHIP_ID_REG, &val); 2052 if (ret) 2053 return ret; 2054 2055 if (FIELD_GET(BMI323_CHIP_ID_MSK, val) != BMI323_CHIP_ID_VAL) 2056 return dev_err_probe(data->dev, -EINVAL, "Chip ID mismatch\n"); 2057 2058 ret = bmi323_feature_engine_enable(data, true); 2059 if (ret) 2060 return ret; 2061 2062 ret = regmap_read(data->regmap, BMI323_ERR_REG, &val); 2063 if (ret) 2064 return ret; 2065 2066 if (val) 2067 return dev_err_probe(data->dev, -EINVAL, 2068 "Sensor power error = 0x%x\n", val); 2069 2070 return 0; 2071 } 2072 2073 static int bmi323_init_reset(struct bmi323_data *data) 2074 { 2075 int ret; 2076 2077 /* 2078 * Set the Bandwidth coefficient which defines the 3 dB cutoff 2079 * frequency in relation to the ODR. 2080 */ 2081 ret = bmi323_set_bw(data, BMI323_ACCEL, BMI323_BW_ODR_BY_2); 2082 if (ret) 2083 return ret; 2084 2085 ret = bmi323_set_bw(data, BMI323_GYRO, BMI323_BW_ODR_BY_2); 2086 if (ret) 2087 return ret; 2088 2089 ret = bmi323_set_odr(data, BMI323_ACCEL, 25, 0); 2090 if (ret) 2091 return ret; 2092 2093 ret = bmi323_set_odr(data, BMI323_GYRO, 25, 0); 2094 if (ret) 2095 return ret; 2096 2097 return devm_add_action_or_reset(data->dev, bmi323_disable, data); 2098 } 2099 2100 int bmi323_core_probe(struct device *dev) 2101 { 2102 static const char * const regulator_names[] = { "vdd", "vddio" }; 2103 struct iio_dev *indio_dev; 2104 struct bmi323_data *data; 2105 struct regmap *regmap; 2106 int ret; 2107 2108 regmap = dev_get_regmap(dev, NULL); 2109 if (!regmap) 2110 return dev_err_probe(dev, -ENODEV, "Failed to get regmap\n"); 2111 2112 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 2113 if (!indio_dev) 2114 return -ENOMEM; 2115 2116 ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(regulator_names), 2117 regulator_names); 2118 if (ret) 2119 return dev_err_probe(dev, ret, "Failed to enable regulators\n"); 2120 2121 data = iio_priv(indio_dev); 2122 data->dev = dev; 2123 data->regmap = regmap; 2124 data->irq_pin = BMI323_IRQ_DISABLED; 2125 data->state = BMI323_IDLE; 2126 mutex_init(&data->mutex); 2127 2128 ret = bmi323_init(data); 2129 if (ret) 2130 return -EINVAL; 2131 2132 ret = bmi323_init_reset(data); 2133 if (ret) 2134 return -EINVAL; 2135 2136 if (!iio_read_acpi_mount_matrix(dev, &data->orientation, "ROTM")) { 2137 ret = iio_read_mount_matrix(dev, &data->orientation); 2138 if (ret) 2139 return ret; 2140 } 2141 2142 indio_dev->name = "bmi323-imu"; 2143 indio_dev->info = &bmi323_info; 2144 indio_dev->channels = bmi323_channels; 2145 indio_dev->num_channels = ARRAY_SIZE(bmi323_channels); 2146 indio_dev->available_scan_masks = bmi323_avail_scan_masks; 2147 indio_dev->modes = INDIO_DIRECT_MODE | INDIO_BUFFER_SOFTWARE; 2148 dev_set_drvdata(data->dev, indio_dev); 2149 2150 ret = bmi323_trigger_probe(data, indio_dev); 2151 if (ret) 2152 return -EINVAL; 2153 2154 ret = devm_iio_triggered_buffer_setup_ext(data->dev, indio_dev, 2155 &iio_pollfunc_store_time, 2156 bmi323_trigger_handler, 2157 IIO_BUFFER_DIRECTION_IN, 2158 &bmi323_buffer_ops, 2159 bmi323_fifo_attributes); 2160 if (ret) 2161 return dev_err_probe(data->dev, ret, 2162 "Failed to setup trigger buffer\n"); 2163 2164 ret = devm_iio_device_register(data->dev, indio_dev); 2165 if (ret) 2166 return dev_err_probe(data->dev, ret, 2167 "Unable to register iio device\n"); 2168 2169 return bmi323_fifo_disable(data); 2170 } 2171 EXPORT_SYMBOL_NS_GPL(bmi323_core_probe, "IIO_BMI323"); 2172 2173 static int bmi323_core_runtime_suspend(struct device *dev) 2174 { 2175 struct iio_dev *indio_dev = dev_get_drvdata(dev); 2176 struct bmi323_data *data = iio_priv(indio_dev); 2177 struct bmi323_regs_runtime_pm *savestate = &data->runtime_pm_status; 2178 int ret; 2179 2180 guard(mutex)(&data->mutex); 2181 2182 ret = iio_device_suspend_triggering(indio_dev); 2183 if (ret) 2184 return ret; 2185 2186 /* Save registers meant to be restored by resume pm callback. */ 2187 for (unsigned int i = 0; i < ARRAY_SIZE(bmi323_reg_savestate); i++) { 2188 ret = regmap_read(data->regmap, bmi323_reg_savestate[i], 2189 &savestate->reg_settings[i]); 2190 if (ret) { 2191 dev_err(data->dev, 2192 "Error reading bmi323 reg 0x%x: %d\n", 2193 bmi323_reg_savestate[i], ret); 2194 return ret; 2195 } 2196 } 2197 2198 for (unsigned int i = 0; i < ARRAY_SIZE(bmi323_ext_reg_savestate); i++) { 2199 ret = bmi323_read_ext_reg(data, bmi323_ext_reg_savestate[i], 2200 &savestate->ext_reg_settings[i]); 2201 if (ret) { 2202 dev_err(data->dev, 2203 "Error reading bmi323 external reg 0x%x: %d\n", 2204 bmi323_ext_reg_savestate[i], ret); 2205 return ret; 2206 } 2207 } 2208 2209 /* Perform soft reset to place the device in its lowest power state. */ 2210 ret = regmap_write(data->regmap, BMI323_CMD_REG, BMI323_RST_VAL); 2211 if (ret) 2212 return ret; 2213 2214 return 0; 2215 } 2216 2217 static int bmi323_core_runtime_resume(struct device *dev) 2218 { 2219 struct iio_dev *indio_dev = dev_get_drvdata(dev); 2220 struct bmi323_data *data = iio_priv(indio_dev); 2221 struct bmi323_regs_runtime_pm *savestate = &data->runtime_pm_status; 2222 unsigned int val; 2223 int ret; 2224 2225 guard(mutex)(&data->mutex); 2226 2227 /* 2228 * Perform the device power-on and initial setup once again 2229 * after being reset in the lower power state by runtime-pm. 2230 */ 2231 ret = bmi323_init(data); 2232 if (ret) { 2233 dev_err(data->dev, "Device power-on and init failed: %d", ret); 2234 return ret; 2235 } 2236 2237 /* Register must be cleared before changing an active config */ 2238 ret = regmap_write(data->regmap, BMI323_FEAT_IO0_REG, 0); 2239 if (ret) { 2240 dev_err(data->dev, "Error stopping feature engine\n"); 2241 return ret; 2242 } 2243 2244 for (unsigned int i = 0; i < ARRAY_SIZE(bmi323_ext_reg_savestate); i++) { 2245 ret = bmi323_write_ext_reg(data, bmi323_ext_reg_savestate[i], 2246 savestate->ext_reg_settings[i]); 2247 if (ret) { 2248 dev_err(data->dev, 2249 "Error writing bmi323 external reg 0x%x: %d\n", 2250 bmi323_ext_reg_savestate[i], ret); 2251 return ret; 2252 } 2253 } 2254 2255 for (unsigned int i = 0; i < ARRAY_SIZE(bmi323_reg_savestate); i++) { 2256 ret = regmap_write(data->regmap, bmi323_reg_savestate[i], 2257 savestate->reg_settings[i]); 2258 if (ret) { 2259 dev_err(data->dev, 2260 "Error writing bmi323 reg 0x%x: %d\n", 2261 bmi323_reg_savestate[i], ret); 2262 return ret; 2263 } 2264 } 2265 2266 /* 2267 * Clear old FIFO samples that might be generated before suspend 2268 * or generated from a peripheral state not equal to the saved one. 2269 */ 2270 if (data->state == BMI323_BUFFER_FIFO) { 2271 ret = regmap_write(data->regmap, BMI323_FIFO_CTRL_REG, 2272 BMI323_FIFO_FLUSH_MSK); 2273 if (ret) { 2274 dev_err(data->dev, "Error flushing FIFO buffer: %d\n", ret); 2275 return ret; 2276 } 2277 } 2278 2279 ret = regmap_read(data->regmap, BMI323_ERR_REG, &val); 2280 if (ret) { 2281 dev_err(data->dev, 2282 "Error reading bmi323 error register: %d\n", ret); 2283 return ret; 2284 } 2285 2286 if (val) { 2287 dev_err(data->dev, 2288 "Sensor power error in PM = 0x%x\n", val); 2289 return -EINVAL; 2290 } 2291 2292 return iio_device_resume_triggering(indio_dev); 2293 } 2294 2295 const struct dev_pm_ops bmi323_core_pm_ops = { 2296 RUNTIME_PM_OPS(bmi323_core_runtime_suspend, 2297 bmi323_core_runtime_resume, NULL) 2298 }; 2299 EXPORT_SYMBOL_NS_GPL(bmi323_core_pm_ops, "IIO_BMI323"); 2300 2301 MODULE_DESCRIPTION("Bosch BMI323 IMU driver"); 2302 MODULE_AUTHOR("Jagath Jog J <jagathjog1996@gmail.com>"); 2303 MODULE_LICENSE("GPL"); 2304