1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2020 Invensense, Inc. 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/device.h> 8 #include <linux/mutex.h> 9 #include <linux/pm_runtime.h> 10 #include <linux/regmap.h> 11 #include <linux/delay.h> 12 13 #include <linux/iio/buffer.h> 14 #include <linux/iio/common/inv_sensors_timestamp.h> 15 #include <linux/iio/iio.h> 16 17 #include "inv_icm42600.h" 18 #include "inv_icm42600_buffer.h" 19 20 /* FIFO header: 1 byte */ 21 #define INV_ICM42600_FIFO_HEADER_MSG BIT(7) 22 #define INV_ICM42600_FIFO_HEADER_ACCEL BIT(6) 23 #define INV_ICM42600_FIFO_HEADER_GYRO BIT(5) 24 #define INV_ICM42600_FIFO_HEADER_TMST_FSYNC GENMASK(3, 2) 25 #define INV_ICM42600_FIFO_HEADER_ODR_ACCEL BIT(1) 26 #define INV_ICM42600_FIFO_HEADER_ODR_GYRO BIT(0) 27 28 struct inv_icm42600_fifo_1sensor_packet { 29 uint8_t header; 30 struct inv_icm42600_fifo_sensor_data data; 31 int8_t temp; 32 } __packed; 33 #define INV_ICM42600_FIFO_1SENSOR_PACKET_SIZE 8 34 35 struct inv_icm42600_fifo_2sensors_packet { 36 uint8_t header; 37 struct inv_icm42600_fifo_sensor_data accel; 38 struct inv_icm42600_fifo_sensor_data gyro; 39 int8_t temp; 40 __be16 timestamp; 41 } __packed; 42 #define INV_ICM42600_FIFO_2SENSORS_PACKET_SIZE 16 43 44 ssize_t inv_icm42600_fifo_decode_packet(const void *packet, const void **accel, 45 const void **gyro, const int8_t **temp, 46 const void **timestamp, unsigned int *odr) 47 { 48 const struct inv_icm42600_fifo_1sensor_packet *pack1 = packet; 49 const struct inv_icm42600_fifo_2sensors_packet *pack2 = packet; 50 uint8_t header = *((const uint8_t *)packet); 51 52 /* FIFO empty */ 53 if (header & INV_ICM42600_FIFO_HEADER_MSG) { 54 *accel = NULL; 55 *gyro = NULL; 56 *temp = NULL; 57 *timestamp = NULL; 58 *odr = 0; 59 return 0; 60 } 61 62 /* handle odr flags */ 63 *odr = 0; 64 if (header & INV_ICM42600_FIFO_HEADER_ODR_GYRO) 65 *odr |= INV_ICM42600_SENSOR_GYRO; 66 if (header & INV_ICM42600_FIFO_HEADER_ODR_ACCEL) 67 *odr |= INV_ICM42600_SENSOR_ACCEL; 68 69 /* accel + gyro */ 70 if ((header & INV_ICM42600_FIFO_HEADER_ACCEL) && 71 (header & INV_ICM42600_FIFO_HEADER_GYRO)) { 72 *accel = &pack2->accel; 73 *gyro = &pack2->gyro; 74 *temp = &pack2->temp; 75 *timestamp = &pack2->timestamp; 76 return INV_ICM42600_FIFO_2SENSORS_PACKET_SIZE; 77 } 78 79 /* accel only */ 80 if (header & INV_ICM42600_FIFO_HEADER_ACCEL) { 81 *accel = &pack1->data; 82 *gyro = NULL; 83 *temp = &pack1->temp; 84 *timestamp = NULL; 85 return INV_ICM42600_FIFO_1SENSOR_PACKET_SIZE; 86 } 87 88 /* gyro only */ 89 if (header & INV_ICM42600_FIFO_HEADER_GYRO) { 90 *accel = NULL; 91 *gyro = &pack1->data; 92 *temp = &pack1->temp; 93 *timestamp = NULL; 94 return INV_ICM42600_FIFO_1SENSOR_PACKET_SIZE; 95 } 96 97 /* invalid packet if here */ 98 return -EINVAL; 99 } 100 101 void inv_icm42600_buffer_update_fifo_period(struct inv_icm42600_state *st) 102 { 103 uint32_t period_gyro, period_accel, period; 104 105 if (st->fifo.en & INV_ICM42600_SENSOR_GYRO) 106 period_gyro = inv_icm42600_odr_to_period(st->conf.gyro.odr); 107 else 108 period_gyro = U32_MAX; 109 110 if (st->fifo.en & INV_ICM42600_SENSOR_ACCEL) 111 period_accel = inv_icm42600_odr_to_period(st->conf.accel.odr); 112 else 113 period_accel = U32_MAX; 114 115 if (period_gyro <= period_accel) 116 period = period_gyro; 117 else 118 period = period_accel; 119 120 st->fifo.period = period; 121 } 122 123 int inv_icm42600_buffer_set_fifo_en(struct inv_icm42600_state *st, 124 unsigned int fifo_en) 125 { 126 unsigned int mask, val; 127 int ret; 128 129 /* update only FIFO EN bits */ 130 mask = INV_ICM42600_FIFO_CONFIG1_TMST_FSYNC_EN | 131 INV_ICM42600_FIFO_CONFIG1_TEMP_EN | 132 INV_ICM42600_FIFO_CONFIG1_GYRO_EN | 133 INV_ICM42600_FIFO_CONFIG1_ACCEL_EN; 134 135 val = 0; 136 if (fifo_en & INV_ICM42600_SENSOR_GYRO) 137 val |= INV_ICM42600_FIFO_CONFIG1_GYRO_EN; 138 if (fifo_en & INV_ICM42600_SENSOR_ACCEL) 139 val |= INV_ICM42600_FIFO_CONFIG1_ACCEL_EN; 140 if (fifo_en & INV_ICM42600_SENSOR_TEMP) 141 val |= INV_ICM42600_FIFO_CONFIG1_TEMP_EN; 142 143 ret = regmap_update_bits(st->map, INV_ICM42600_REG_FIFO_CONFIG1, mask, val); 144 if (ret) 145 return ret; 146 147 st->fifo.en = fifo_en; 148 inv_icm42600_buffer_update_fifo_period(st); 149 150 return 0; 151 } 152 153 static size_t inv_icm42600_get_packet_size(unsigned int fifo_en) 154 { 155 size_t packet_size; 156 157 if ((fifo_en & INV_ICM42600_SENSOR_GYRO) && 158 (fifo_en & INV_ICM42600_SENSOR_ACCEL)) 159 packet_size = INV_ICM42600_FIFO_2SENSORS_PACKET_SIZE; 160 else 161 packet_size = INV_ICM42600_FIFO_1SENSOR_PACKET_SIZE; 162 163 return packet_size; 164 } 165 166 static unsigned int inv_icm42600_wm_truncate(unsigned int watermark, 167 size_t packet_size) 168 { 169 size_t wm_size; 170 unsigned int wm; 171 172 wm_size = watermark * packet_size; 173 if (wm_size > INV_ICM42600_FIFO_WATERMARK_MAX) 174 wm_size = INV_ICM42600_FIFO_WATERMARK_MAX; 175 176 wm = wm_size / packet_size; 177 178 return wm; 179 } 180 181 /** 182 * inv_icm42600_buffer_update_watermark - update watermark FIFO threshold 183 * @st: driver internal state 184 * 185 * Returns 0 on success, a negative error code otherwise. 186 * 187 * FIFO watermark threshold is computed based on the required watermark values 188 * set for gyro and accel sensors. Since watermark is all about acceptable data 189 * latency, use the smallest setting between the 2. It means choosing the 190 * smallest latency but this is not as simple as choosing the smallest watermark 191 * value. Latency depends on watermark and ODR. It requires several steps: 192 * 1) compute gyro and accel latencies and choose the smallest value. 193 * 2) adapt the choosen latency so that it is a multiple of both gyro and accel 194 * ones. Otherwise it is possible that you don't meet a requirement. (for 195 * example with gyro @100Hz wm 4 and accel @100Hz with wm 6, choosing the 196 * value of 4 will not meet accel latency requirement because 6 is not a 197 * multiple of 4. You need to use the value 2.) 198 * 3) Since all periods are multiple of each others, watermark is computed by 199 * dividing this computed latency by the smallest period, which corresponds 200 * to the FIFO frequency. Beware that this is only true because we are not 201 * using 500Hz frequency which is not a multiple of the others. 202 */ 203 int inv_icm42600_buffer_update_watermark(struct inv_icm42600_state *st) 204 { 205 size_t packet_size, wm_size; 206 unsigned int wm_gyro, wm_accel, watermark; 207 uint32_t period_gyro, period_accel, period; 208 uint32_t latency_gyro, latency_accel, latency; 209 bool restore; 210 __le16 raw_wm; 211 int ret; 212 213 packet_size = inv_icm42600_get_packet_size(st->fifo.en); 214 215 /* compute sensors latency, depending on sensor watermark and odr */ 216 wm_gyro = inv_icm42600_wm_truncate(st->fifo.watermark.gyro, packet_size); 217 wm_accel = inv_icm42600_wm_truncate(st->fifo.watermark.accel, packet_size); 218 /* use us for odr to avoid overflow using 32 bits values */ 219 period_gyro = inv_icm42600_odr_to_period(st->conf.gyro.odr) / 1000UL; 220 period_accel = inv_icm42600_odr_to_period(st->conf.accel.odr) / 1000UL; 221 latency_gyro = period_gyro * wm_gyro; 222 latency_accel = period_accel * wm_accel; 223 224 /* 0 value for watermark means that the sensor is turned off */ 225 if (latency_gyro == 0) { 226 watermark = wm_accel; 227 } else if (latency_accel == 0) { 228 watermark = wm_gyro; 229 } else { 230 /* compute the smallest latency that is a multiple of both */ 231 if (latency_gyro <= latency_accel) 232 latency = latency_gyro - (latency_accel % latency_gyro); 233 else 234 latency = latency_accel - (latency_gyro % latency_accel); 235 /* use the shortest period */ 236 if (period_gyro <= period_accel) 237 period = period_gyro; 238 else 239 period = period_accel; 240 /* all this works because periods are multiple of each others */ 241 watermark = latency / period; 242 if (watermark < 1) 243 watermark = 1; 244 } 245 246 /* compute watermark value in bytes */ 247 wm_size = watermark * packet_size; 248 249 /* changing FIFO watermark requires to turn off watermark interrupt */ 250 ret = regmap_update_bits_check(st->map, INV_ICM42600_REG_INT_SOURCE0, 251 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN, 252 0, &restore); 253 if (ret) 254 return ret; 255 256 raw_wm = INV_ICM42600_FIFO_WATERMARK_VAL(wm_size); 257 memcpy(st->buffer, &raw_wm, sizeof(raw_wm)); 258 ret = regmap_bulk_write(st->map, INV_ICM42600_REG_FIFO_WATERMARK, 259 st->buffer, sizeof(raw_wm)); 260 if (ret) 261 return ret; 262 263 /* restore watermark interrupt */ 264 if (restore) { 265 ret = regmap_update_bits(st->map, INV_ICM42600_REG_INT_SOURCE0, 266 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN, 267 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN); 268 if (ret) 269 return ret; 270 } 271 272 return 0; 273 } 274 275 static int inv_icm42600_buffer_preenable(struct iio_dev *indio_dev) 276 { 277 struct inv_icm42600_state *st = iio_device_get_drvdata(indio_dev); 278 struct device *dev = regmap_get_device(st->map); 279 struct inv_icm42600_sensor_state *sensor_st = iio_priv(indio_dev); 280 struct inv_sensors_timestamp *ts = &sensor_st->ts; 281 282 pm_runtime_get_sync(dev); 283 284 mutex_lock(&st->lock); 285 inv_sensors_timestamp_reset(ts); 286 mutex_unlock(&st->lock); 287 288 return 0; 289 } 290 291 /* 292 * update_scan_mode callback is turning sensors on and setting data FIFO enable 293 * bits. 294 */ 295 static int inv_icm42600_buffer_postenable(struct iio_dev *indio_dev) 296 { 297 struct inv_icm42600_state *st = iio_device_get_drvdata(indio_dev); 298 int ret; 299 300 mutex_lock(&st->lock); 301 302 /* exit if FIFO is already on */ 303 if (st->fifo.on) { 304 ret = 0; 305 goto out_on; 306 } 307 308 /* set FIFO threshold interrupt */ 309 ret = regmap_update_bits(st->map, INV_ICM42600_REG_INT_SOURCE0, 310 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN, 311 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN); 312 if (ret) 313 goto out_unlock; 314 315 /* flush FIFO data */ 316 ret = regmap_write(st->map, INV_ICM42600_REG_SIGNAL_PATH_RESET, 317 INV_ICM42600_SIGNAL_PATH_RESET_FIFO_FLUSH); 318 if (ret) 319 goto out_unlock; 320 321 /* set FIFO in streaming mode */ 322 ret = regmap_write(st->map, INV_ICM42600_REG_FIFO_CONFIG, 323 INV_ICM42600_FIFO_CONFIG_STREAM); 324 if (ret) 325 goto out_unlock; 326 327 /* workaround: first read of FIFO count after reset is always 0 */ 328 ret = regmap_bulk_read(st->map, INV_ICM42600_REG_FIFO_COUNT, st->buffer, 2); 329 if (ret) 330 goto out_unlock; 331 332 out_on: 333 /* increase FIFO on counter */ 334 st->fifo.on++; 335 out_unlock: 336 mutex_unlock(&st->lock); 337 return ret; 338 } 339 340 static int inv_icm42600_buffer_predisable(struct iio_dev *indio_dev) 341 { 342 struct inv_icm42600_state *st = iio_device_get_drvdata(indio_dev); 343 int ret; 344 345 mutex_lock(&st->lock); 346 347 /* exit if there are several sensors using the FIFO */ 348 if (st->fifo.on > 1) { 349 ret = 0; 350 goto out_off; 351 } 352 353 /* set FIFO in bypass mode */ 354 ret = regmap_write(st->map, INV_ICM42600_REG_FIFO_CONFIG, 355 INV_ICM42600_FIFO_CONFIG_BYPASS); 356 if (ret) 357 goto out_unlock; 358 359 /* flush FIFO data */ 360 ret = regmap_write(st->map, INV_ICM42600_REG_SIGNAL_PATH_RESET, 361 INV_ICM42600_SIGNAL_PATH_RESET_FIFO_FLUSH); 362 if (ret) 363 goto out_unlock; 364 365 /* disable FIFO threshold interrupt */ 366 ret = regmap_update_bits(st->map, INV_ICM42600_REG_INT_SOURCE0, 367 INV_ICM42600_INT_SOURCE0_FIFO_THS_INT1_EN, 0); 368 if (ret) 369 goto out_unlock; 370 371 out_off: 372 /* decrease FIFO on counter */ 373 st->fifo.on--; 374 out_unlock: 375 mutex_unlock(&st->lock); 376 return ret; 377 } 378 379 static int inv_icm42600_buffer_postdisable(struct iio_dev *indio_dev) 380 { 381 struct inv_icm42600_state *st = iio_device_get_drvdata(indio_dev); 382 struct device *dev = regmap_get_device(st->map); 383 unsigned int sensor; 384 unsigned int *watermark; 385 struct inv_icm42600_sensor_conf conf = INV_ICM42600_SENSOR_CONF_INIT; 386 unsigned int sleep_temp = 0; 387 unsigned int sleep_sensor = 0; 388 unsigned int sleep; 389 int ret; 390 391 if (indio_dev == st->indio_gyro) { 392 sensor = INV_ICM42600_SENSOR_GYRO; 393 watermark = &st->fifo.watermark.gyro; 394 } else if (indio_dev == st->indio_accel) { 395 sensor = INV_ICM42600_SENSOR_ACCEL; 396 watermark = &st->fifo.watermark.accel; 397 } else { 398 return -EINVAL; 399 } 400 401 mutex_lock(&st->lock); 402 403 ret = inv_icm42600_buffer_set_fifo_en(st, st->fifo.en & ~sensor); 404 if (ret) 405 goto out_unlock; 406 407 *watermark = 0; 408 ret = inv_icm42600_buffer_update_watermark(st); 409 if (ret) 410 goto out_unlock; 411 412 conf.mode = INV_ICM42600_SENSOR_MODE_OFF; 413 if (sensor == INV_ICM42600_SENSOR_GYRO) 414 ret = inv_icm42600_set_gyro_conf(st, &conf, &sleep_sensor); 415 else 416 ret = inv_icm42600_set_accel_conf(st, &conf, &sleep_sensor); 417 if (ret) 418 goto out_unlock; 419 420 /* if FIFO is off, turn temperature off */ 421 if (!st->fifo.on) 422 ret = inv_icm42600_set_temp_conf(st, false, &sleep_temp); 423 424 out_unlock: 425 mutex_unlock(&st->lock); 426 427 /* sleep maximum required time */ 428 sleep = max(sleep_sensor, sleep_temp); 429 if (sleep) 430 msleep(sleep); 431 432 pm_runtime_mark_last_busy(dev); 433 pm_runtime_put_autosuspend(dev); 434 435 return ret; 436 } 437 438 const struct iio_buffer_setup_ops inv_icm42600_buffer_ops = { 439 .preenable = inv_icm42600_buffer_preenable, 440 .postenable = inv_icm42600_buffer_postenable, 441 .predisable = inv_icm42600_buffer_predisable, 442 .postdisable = inv_icm42600_buffer_postdisable, 443 }; 444 445 int inv_icm42600_buffer_fifo_read(struct inv_icm42600_state *st, 446 unsigned int max) 447 { 448 size_t max_count; 449 __be16 *raw_fifo_count; 450 ssize_t i, size; 451 const void *accel, *gyro, *timestamp; 452 const int8_t *temp; 453 unsigned int odr; 454 int ret; 455 456 /* reset all samples counters */ 457 st->fifo.count = 0; 458 st->fifo.nb.gyro = 0; 459 st->fifo.nb.accel = 0; 460 st->fifo.nb.total = 0; 461 462 /* compute maximum FIFO read size */ 463 if (max == 0) 464 max_count = sizeof(st->fifo.data); 465 else 466 max_count = max * inv_icm42600_get_packet_size(st->fifo.en); 467 468 /* read FIFO count value */ 469 raw_fifo_count = (__be16 *)st->buffer; 470 ret = regmap_bulk_read(st->map, INV_ICM42600_REG_FIFO_COUNT, 471 raw_fifo_count, sizeof(*raw_fifo_count)); 472 if (ret) 473 return ret; 474 st->fifo.count = be16_to_cpup(raw_fifo_count); 475 476 /* check and clamp FIFO count value */ 477 if (st->fifo.count == 0) 478 return 0; 479 if (st->fifo.count > max_count) 480 st->fifo.count = max_count; 481 482 /* read all FIFO data in internal buffer */ 483 ret = regmap_noinc_read(st->map, INV_ICM42600_REG_FIFO_DATA, 484 st->fifo.data, st->fifo.count); 485 if (ret) 486 return ret; 487 488 /* compute number of samples for each sensor */ 489 for (i = 0; i < st->fifo.count; i += size) { 490 size = inv_icm42600_fifo_decode_packet(&st->fifo.data[i], 491 &accel, &gyro, &temp, ×tamp, &odr); 492 if (size <= 0) 493 break; 494 if (gyro != NULL && inv_icm42600_fifo_is_data_valid(gyro)) 495 st->fifo.nb.gyro++; 496 if (accel != NULL && inv_icm42600_fifo_is_data_valid(accel)) 497 st->fifo.nb.accel++; 498 st->fifo.nb.total++; 499 } 500 501 return 0; 502 } 503 504 int inv_icm42600_buffer_fifo_parse(struct inv_icm42600_state *st) 505 { 506 struct inv_icm42600_sensor_state *gyro_st = iio_priv(st->indio_gyro); 507 struct inv_icm42600_sensor_state *accel_st = iio_priv(st->indio_accel); 508 struct inv_sensors_timestamp *ts; 509 int ret; 510 511 if (st->fifo.nb.total == 0) 512 return 0; 513 514 /* handle gyroscope timestamp and FIFO data parsing */ 515 if (st->fifo.nb.gyro > 0) { 516 ts = &gyro_st->ts; 517 inv_sensors_timestamp_interrupt(ts, st->fifo.nb.gyro, 518 st->timestamp.gyro); 519 ret = inv_icm42600_gyro_parse_fifo(st->indio_gyro); 520 if (ret) 521 return ret; 522 } 523 524 /* handle accelerometer timestamp and FIFO data parsing */ 525 if (st->fifo.nb.accel > 0) { 526 ts = &accel_st->ts; 527 inv_sensors_timestamp_interrupt(ts, st->fifo.nb.accel, 528 st->timestamp.accel); 529 ret = inv_icm42600_accel_parse_fifo(st->indio_accel); 530 if (ret) 531 return ret; 532 } 533 534 return 0; 535 } 536 537 int inv_icm42600_buffer_hwfifo_flush(struct inv_icm42600_state *st, 538 unsigned int count) 539 { 540 struct inv_icm42600_sensor_state *gyro_st = iio_priv(st->indio_gyro); 541 struct inv_icm42600_sensor_state *accel_st = iio_priv(st->indio_accel); 542 struct inv_sensors_timestamp *ts; 543 int64_t gyro_ts, accel_ts; 544 int ret; 545 546 gyro_ts = iio_get_time_ns(st->indio_gyro); 547 accel_ts = iio_get_time_ns(st->indio_accel); 548 549 ret = inv_icm42600_buffer_fifo_read(st, count); 550 if (ret) 551 return ret; 552 553 if (st->fifo.nb.total == 0) 554 return 0; 555 556 if (st->fifo.nb.gyro > 0) { 557 ts = &gyro_st->ts; 558 inv_sensors_timestamp_interrupt(ts, st->fifo.nb.gyro, gyro_ts); 559 ret = inv_icm42600_gyro_parse_fifo(st->indio_gyro); 560 if (ret) 561 return ret; 562 } 563 564 if (st->fifo.nb.accel > 0) { 565 ts = &accel_st->ts; 566 inv_sensors_timestamp_interrupt(ts, st->fifo.nb.accel, accel_ts); 567 ret = inv_icm42600_accel_parse_fifo(st->indio_accel); 568 if (ret) 569 return ret; 570 } 571 572 return 0; 573 } 574 575 int inv_icm42600_buffer_init(struct inv_icm42600_state *st) 576 { 577 unsigned int val; 578 int ret; 579 580 /* 581 * Default FIFO configuration (bits 7 to 5) 582 * - use invalid value 583 * - FIFO count in bytes 584 * - FIFO count in big endian 585 */ 586 val = INV_ICM42600_INTF_CONFIG0_FIFO_COUNT_ENDIAN; 587 ret = regmap_update_bits(st->map, INV_ICM42600_REG_INTF_CONFIG0, 588 GENMASK(7, 5), val); 589 if (ret) 590 return ret; 591 592 /* 593 * Enable FIFO partial read and continuous watermark interrupt. 594 * Disable all FIFO EN bits. 595 */ 596 val = INV_ICM42600_FIFO_CONFIG1_RESUME_PARTIAL_RD | 597 INV_ICM42600_FIFO_CONFIG1_WM_GT_TH; 598 return regmap_update_bits(st->map, INV_ICM42600_REG_FIFO_CONFIG1, 599 GENMASK(6, 5) | GENMASK(3, 0), val); 600 } 601