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