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