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 *
bmi323_get_mount_matrix(const struct iio_dev * idev,const struct iio_chan_spec * chan)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
bmi323_iio_to_sensor(enum iio_chan_type iio_type)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
bmi323_set_mode(struct bmi323_data * data,enum bmi323_sensor_type sensor,enum bmi323_opr_mode mode)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 */
bmi323_write_ext_reg(struct bmi323_data * data,unsigned int ext_addr,unsigned int ext_data)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 */
bmi323_read_ext_reg(struct bmi323_data * data,unsigned int ext_addr,unsigned int * ext_data)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
bmi323_update_ext_reg(struct bmi323_data * data,unsigned int ext_addr,unsigned int mask,unsigned int ext_data)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
bmi323_get_error_status(struct bmi323_data * data)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
bmi323_feature_engine_events(struct bmi323_data * data,const unsigned int event_mask,bool state)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
bmi323_step_wtrmrk_en(struct bmi323_data * data,bool state)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
bmi323_motion_config_reg(enum iio_event_direction dir)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
bmi323_motion_event_en(struct bmi323_data * data,enum iio_event_direction dir,bool state)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
bmi323_tap_event_en(struct bmi323_data * data,enum iio_event_direction dir,bool state)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
in_accel_gesture_tap_wait_dur_show(struct device * dev,struct device_attribute * attr,char * buf)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
in_accel_gesture_tap_wait_dur_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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
in_accel_gesture_tap_wait_timeout_show(struct device * dev,struct device_attribute * attr,char * buf)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
in_accel_gesture_tap_wait_timeout_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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
bmi323_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,bool state)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
bmi323_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)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
bmi323_write_event_value(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)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
bmi323_read_event_value(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)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
__bmi323_fifo_flush(struct iio_dev * indio_dev)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
bmi323_set_watermark(struct iio_dev * indio_dev,unsigned int val)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
bmi323_fifo_disable(struct bmi323_data * data)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
bmi323_buffer_predisable(struct iio_dev * indio_dev)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
bmi323_update_watermark(struct bmi323_data * data)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
bmi323_fifo_enable(struct bmi323_data * data)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
bmi323_buffer_preenable(struct iio_dev * indio_dev)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
bmi323_buffer_postenable(struct iio_dev * indio_dev)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
hwfifo_watermark_show(struct device * dev,struct device_attribute * attr,char * buf)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
hwfifo_enabled_show(struct device * dev,struct device_attribute * attr,char * buf)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
bmi323_irq_thread_handler(int irq,void * private)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
bmi323_set_drdy_irq(struct bmi323_data * data,enum bmi323_irq_pin irq_pin)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
bmi323_data_rdy_trigger_set_state(struct iio_trigger * trig,bool state)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
bmi323_trigger_handler(int irq,void * p)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
bmi323_set_average(struct bmi323_data * data,enum bmi323_sensor_type sensor,int avg)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
bmi323_get_average(struct bmi323_data * data,enum bmi323_sensor_type sensor,int * avg)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
bmi323_enable_steps(struct bmi323_data * data,int val)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
bmi323_read_steps(struct bmi323_data * data,int * val)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
bmi323_read_axis(struct bmi323_data * data,struct iio_chan_spec const * chan,int * val)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
bmi323_get_temp_data(struct bmi323_data * data,int * val)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
bmi323_get_odr(struct bmi323_data * data,enum bmi323_sensor_type sensor,int * odr,int * uodr)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
bmi323_configure_power_mode(struct bmi323_data * data,enum bmi323_sensor_type sensor,int odr_index)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
bmi323_set_odr(struct bmi323_data * data,enum bmi323_sensor_type sensor,int odr,int uodr)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
bmi323_get_scale(struct bmi323_data * data,enum bmi323_sensor_type sensor,int * val2)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
bmi323_set_scale(struct bmi323_data * data,enum bmi323_sensor_type sensor,int val,int val2)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
bmi323_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)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
bmi323_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)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
bmi323_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)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
bmi323_int_pin_config(struct bmi323_data * data,enum bmi323_irq_pin irq_pin,bool active_high,bool open_drain,bool latch)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
bmi323_trigger_probe(struct bmi323_data * data,struct iio_dev * indio_dev)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
bmi323_feature_engine_enable(struct bmi323_data * data,bool en)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
bmi323_disable(void * data_ptr)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
bmi323_set_bw(struct bmi323_data * data,enum bmi323_sensor_type sensor,enum bmi323_3db_bw bw)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
bmi323_init(struct bmi323_data * data)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
bmi323_init_reset(struct bmi323_data * data)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
bmi323_core_probe(struct device * dev)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
bmi323_core_runtime_suspend(struct device * dev)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
bmi323_core_runtime_resume(struct device * dev)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