1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * STMicroelectronics accelerometers driver
4 *
5 * Copyright 2012-2013 STMicroelectronics Inc.
6 *
7 * Denis Ciocca <denis.ciocca@st.com>
8 */
9
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/mutex.h>
13 #include <linux/sysfs.h>
14 #include <linux/slab.h>
15 #include <linux/acpi.h>
16 #include <linux/iio/iio.h>
17 #include <linux/iio/sysfs.h>
18 #include <linux/iio/trigger.h>
19
20 #include <linux/iio/common/st_sensors.h>
21 #include "st_accel.h"
22
23 #define ST_ACCEL_NUMBER_DATA_CHANNELS 3
24
25 /* DEFAULT VALUE FOR SENSORS */
26 #define ST_ACCEL_DEFAULT_OUT_X_L_ADDR 0x28
27 #define ST_ACCEL_DEFAULT_OUT_Y_L_ADDR 0x2a
28 #define ST_ACCEL_DEFAULT_OUT_Z_L_ADDR 0x2c
29
30 /* FULLSCALE */
31 #define ST_ACCEL_FS_AVL_2G 2
32 #define ST_ACCEL_FS_AVL_4G 4
33 #define ST_ACCEL_FS_AVL_6G 6
34 #define ST_ACCEL_FS_AVL_8G 8
35 #define ST_ACCEL_FS_AVL_16G 16
36 #define ST_ACCEL_FS_AVL_100G 100
37 #define ST_ACCEL_FS_AVL_200G 200
38 #define ST_ACCEL_FS_AVL_400G 400
39
40 static const struct iio_mount_matrix *
st_accel_get_mount_matrix(const struct iio_dev * indio_dev,const struct iio_chan_spec * chan)41 st_accel_get_mount_matrix(const struct iio_dev *indio_dev,
42 const struct iio_chan_spec *chan)
43 {
44 struct st_sensor_data *adata = iio_priv(indio_dev);
45
46 return &adata->mount_matrix;
47 }
48
49 static const struct iio_chan_spec_ext_info st_accel_mount_matrix_ext_info[] = {
50 IIO_MOUNT_MATRIX(IIO_SHARED_BY_ALL, st_accel_get_mount_matrix),
51 { }
52 };
53
54 static const struct iio_chan_spec st_accel_8bit_channels[] = {
55 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
56 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
57 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 8, 8,
58 ST_ACCEL_DEFAULT_OUT_X_L_ADDR+1,
59 st_accel_mount_matrix_ext_info),
60 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
61 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
62 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 8, 8,
63 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR+1,
64 st_accel_mount_matrix_ext_info),
65 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
66 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
67 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 8, 8,
68 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR+1,
69 st_accel_mount_matrix_ext_info),
70 IIO_CHAN_SOFT_TIMESTAMP(3)
71 };
72
73 static const struct iio_chan_spec st_accel_12bit_channels[] = {
74 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
75 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
76 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 12, 16,
77 ST_ACCEL_DEFAULT_OUT_X_L_ADDR,
78 st_accel_mount_matrix_ext_info),
79 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
80 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
81 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 12, 16,
82 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR,
83 st_accel_mount_matrix_ext_info),
84 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
85 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
86 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 12, 16,
87 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR,
88 st_accel_mount_matrix_ext_info),
89 IIO_CHAN_SOFT_TIMESTAMP(3)
90 };
91
92 static const struct iio_chan_spec st_accel_16bit_channels[] = {
93 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
94 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
95 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
96 ST_ACCEL_DEFAULT_OUT_X_L_ADDR,
97 st_accel_mount_matrix_ext_info),
98 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
99 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
100 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
101 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR,
102 st_accel_mount_matrix_ext_info),
103 ST_SENSORS_LSM_CHANNELS_EXT(IIO_ACCEL,
104 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
105 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
106 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR,
107 st_accel_mount_matrix_ext_info),
108 IIO_CHAN_SOFT_TIMESTAMP(3)
109 };
110
111 static const struct st_sensor_settings st_accel_sensors_settings[] = {
112 {
113 .wai = 0x33,
114 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
115 .sensors_supported = {
116 [0] = LIS3DH_ACCEL_DEV_NAME,
117 [1] = LSM303DLHC_ACCEL_DEV_NAME,
118 [2] = LSM330D_ACCEL_DEV_NAME,
119 [3] = LSM330DL_ACCEL_DEV_NAME,
120 [4] = LSM330DLC_ACCEL_DEV_NAME,
121 [5] = LSM303AGR_ACCEL_DEV_NAME,
122 [6] = LIS2DH12_ACCEL_DEV_NAME,
123 [7] = LIS3DE_ACCEL_DEV_NAME,
124 },
125 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
126 .odr = {
127 .addr = 0x20,
128 .mask = 0xf0,
129 .odr_avl = {
130 { .hz = 1, .value = 0x01, },
131 { .hz = 10, .value = 0x02, },
132 { .hz = 25, .value = 0x03, },
133 { .hz = 50, .value = 0x04, },
134 { .hz = 100, .value = 0x05, },
135 { .hz = 200, .value = 0x06, },
136 { .hz = 400, .value = 0x07, },
137 { .hz = 1600, .value = 0x08, },
138 },
139 },
140 .pw = {
141 .addr = 0x20,
142 .mask = 0xf0,
143 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
144 },
145 .enable_axis = {
146 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
147 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
148 },
149 .fs = {
150 .addr = 0x23,
151 .mask = 0x30,
152 .fs_avl = {
153 [0] = {
154 .num = ST_ACCEL_FS_AVL_2G,
155 .value = 0x00,
156 .gain = IIO_G_TO_M_S_2(1000),
157 },
158 [1] = {
159 .num = ST_ACCEL_FS_AVL_4G,
160 .value = 0x01,
161 .gain = IIO_G_TO_M_S_2(2000),
162 },
163 [2] = {
164 .num = ST_ACCEL_FS_AVL_8G,
165 .value = 0x02,
166 .gain = IIO_G_TO_M_S_2(4000),
167 },
168 [3] = {
169 .num = ST_ACCEL_FS_AVL_16G,
170 .value = 0x03,
171 .gain = IIO_G_TO_M_S_2(12000),
172 },
173 },
174 },
175 .bdu = {
176 .addr = 0x23,
177 .mask = 0x80,
178 },
179 .drdy_irq = {
180 .int1 = {
181 .addr = 0x22,
182 .mask = 0x10,
183 },
184 .addr_ihl = 0x25,
185 .mask_ihl = 0x02,
186 .stat_drdy = {
187 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
188 .mask = 0x07,
189 },
190 },
191 .sim = {
192 .addr = 0x23,
193 .value = BIT(0),
194 },
195 .multi_read_bit = true,
196 .bootime = 2,
197 },
198 {
199 .wai = 0x32,
200 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
201 .sensors_supported = {
202 [0] = LIS331DLH_ACCEL_DEV_NAME,
203 [1] = LSM303DL_ACCEL_DEV_NAME,
204 [2] = LSM303DLH_ACCEL_DEV_NAME,
205 [3] = LSM303DLM_ACCEL_DEV_NAME,
206 },
207 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
208 .odr = {
209 .addr = 0x20,
210 .mask = 0x18,
211 .odr_avl = {
212 { .hz = 50, .value = 0x00, },
213 { .hz = 100, .value = 0x01, },
214 { .hz = 400, .value = 0x02, },
215 { .hz = 1000, .value = 0x03, },
216 },
217 },
218 .pw = {
219 .addr = 0x20,
220 .mask = 0xe0,
221 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
222 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
223 },
224 .enable_axis = {
225 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
226 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
227 },
228 .fs = {
229 .addr = 0x23,
230 .mask = 0x30,
231 .fs_avl = {
232 [0] = {
233 .num = ST_ACCEL_FS_AVL_2G,
234 .value = 0x00,
235 .gain = IIO_G_TO_M_S_2(1000),
236 },
237 [1] = {
238 .num = ST_ACCEL_FS_AVL_4G,
239 .value = 0x01,
240 .gain = IIO_G_TO_M_S_2(2000),
241 },
242 [2] = {
243 .num = ST_ACCEL_FS_AVL_8G,
244 .value = 0x03,
245 .gain = IIO_G_TO_M_S_2(3900),
246 },
247 },
248 },
249 .bdu = {
250 .addr = 0x23,
251 .mask = 0x80,
252 },
253 .drdy_irq = {
254 .int1 = {
255 .addr = 0x22,
256 .mask = 0x02,
257 .addr_od = 0x22,
258 .mask_od = 0x40,
259 },
260 .int2 = {
261 .addr = 0x22,
262 .mask = 0x10,
263 .addr_od = 0x22,
264 .mask_od = 0x40,
265 },
266 .addr_ihl = 0x22,
267 .mask_ihl = 0x80,
268 .stat_drdy = {
269 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
270 .mask = 0x07,
271 },
272 },
273 .sim = {
274 .addr = 0x23,
275 .value = BIT(0),
276 },
277 .multi_read_bit = true,
278 .bootime = 2,
279 },
280 {
281 .wai = 0x40,
282 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
283 .sensors_supported = {
284 [0] = LSM330_ACCEL_DEV_NAME,
285 },
286 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
287 .odr = {
288 .addr = 0x20,
289 .mask = 0xf0,
290 .odr_avl = {
291 { .hz = 3, .value = 0x01, },
292 { .hz = 6, .value = 0x02, },
293 { .hz = 12, .value = 0x03, },
294 { .hz = 25, .value = 0x04, },
295 { .hz = 50, .value = 0x05, },
296 { .hz = 100, .value = 0x06, },
297 { .hz = 200, .value = 0x07, },
298 { .hz = 400, .value = 0x08, },
299 { .hz = 800, .value = 0x09, },
300 { .hz = 1600, .value = 0x0a, },
301 },
302 },
303 .pw = {
304 .addr = 0x20,
305 .mask = 0xf0,
306 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
307 },
308 .enable_axis = {
309 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
310 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
311 },
312 .fs = {
313 .addr = 0x24,
314 .mask = 0x38,
315 .fs_avl = {
316 [0] = {
317 .num = ST_ACCEL_FS_AVL_2G,
318 .value = 0x00,
319 .gain = IIO_G_TO_M_S_2(61),
320 },
321 [1] = {
322 .num = ST_ACCEL_FS_AVL_4G,
323 .value = 0x01,
324 .gain = IIO_G_TO_M_S_2(122),
325 },
326 [2] = {
327 .num = ST_ACCEL_FS_AVL_6G,
328 .value = 0x02,
329 .gain = IIO_G_TO_M_S_2(183),
330 },
331 [3] = {
332 .num = ST_ACCEL_FS_AVL_8G,
333 .value = 0x03,
334 .gain = IIO_G_TO_M_S_2(244),
335 },
336 [4] = {
337 .num = ST_ACCEL_FS_AVL_16G,
338 .value = 0x04,
339 .gain = IIO_G_TO_M_S_2(732),
340 },
341 },
342 },
343 .bdu = {
344 .addr = 0x20,
345 .mask = 0x08,
346 },
347 .drdy_irq = {
348 .int1 = {
349 .addr = 0x23,
350 .mask = 0x80,
351 },
352 .addr_ihl = 0x23,
353 .mask_ihl = 0x40,
354 .stat_drdy = {
355 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
356 .mask = 0x07,
357 },
358 .ig1 = {
359 .en_addr = 0x23,
360 .en_mask = 0x08,
361 },
362 },
363 .sim = {
364 .addr = 0x24,
365 .value = BIT(0),
366 },
367 .multi_read_bit = false,
368 .bootime = 2,
369 },
370 {
371 .wai = 0x3a,
372 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
373 .sensors_supported = {
374 [0] = LIS3LV02DL_ACCEL_DEV_NAME,
375 },
376 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
377 .odr = {
378 .addr = 0x20,
379 .mask = 0x30, /* DF1 and DF0 */
380 .odr_avl = {
381 { .hz = 40, .value = 0x00, },
382 { .hz = 160, .value = 0x01, },
383 { .hz = 640, .value = 0x02, },
384 { .hz = 2560, .value = 0x03, },
385 },
386 },
387 .pw = {
388 .addr = 0x20,
389 .mask = 0xc0,
390 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
391 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
392 },
393 .enable_axis = {
394 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
395 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
396 },
397 .fs = {
398 .addr = 0x21,
399 .mask = 0x80,
400 .fs_avl = {
401 [0] = {
402 .num = ST_ACCEL_FS_AVL_2G,
403 .value = 0x00,
404 .gain = IIO_G_TO_M_S_2(1000),
405 },
406 [1] = {
407 .num = ST_ACCEL_FS_AVL_6G,
408 .value = 0x01,
409 .gain = IIO_G_TO_M_S_2(3000),
410 },
411 },
412 },
413 .bdu = {
414 .addr = 0x21,
415 .mask = 0x40,
416 },
417 /*
418 * Data Alignment Setting - needs to be set to get
419 * left-justified data like all other sensors.
420 */
421 .das = {
422 .addr = 0x21,
423 .mask = 0x01,
424 },
425 .drdy_irq = {
426 .int1 = {
427 .addr = 0x21,
428 .mask = 0x04,
429 },
430 .stat_drdy = {
431 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
432 .mask = 0x07,
433 },
434 },
435 .sim = {
436 .addr = 0x21,
437 .value = BIT(1),
438 },
439 .multi_read_bit = true,
440 .bootime = 2, /* guess */
441 },
442 {
443 .wai = 0x3b,
444 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
445 .sensors_supported = {
446 [0] = LIS331DL_ACCEL_DEV_NAME,
447 [1] = LIS302DL_ACCEL_DEV_NAME,
448 },
449 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
450 .odr = {
451 .addr = 0x20,
452 .mask = 0x80,
453 .odr_avl = {
454 { .hz = 100, .value = 0x00, },
455 { .hz = 400, .value = 0x01, },
456 },
457 },
458 .pw = {
459 .addr = 0x20,
460 .mask = 0x40,
461 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
462 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
463 },
464 .enable_axis = {
465 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
466 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
467 },
468 .fs = {
469 .addr = 0x20,
470 .mask = 0x20,
471 /*
472 * TODO: check these resulting gain settings, these are
473 * not in the datsheet
474 */
475 .fs_avl = {
476 [0] = {
477 .num = ST_ACCEL_FS_AVL_2G,
478 .value = 0x00,
479 .gain = IIO_G_TO_M_S_2(18000),
480 },
481 [1] = {
482 .num = ST_ACCEL_FS_AVL_8G,
483 .value = 0x01,
484 .gain = IIO_G_TO_M_S_2(72000),
485 },
486 },
487 },
488 .drdy_irq = {
489 .int1 = {
490 .addr = 0x22,
491 .mask = 0x04,
492 .addr_od = 0x22,
493 .mask_od = 0x40,
494 },
495 .int2 = {
496 .addr = 0x22,
497 .mask = 0x20,
498 .addr_od = 0x22,
499 .mask_od = 0x40,
500 },
501 .addr_ihl = 0x22,
502 .mask_ihl = 0x80,
503 .stat_drdy = {
504 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
505 .mask = 0x07,
506 },
507 },
508 .sim = {
509 .addr = 0x21,
510 .value = BIT(7),
511 },
512 .multi_read_bit = false,
513 .bootime = 2, /* guess */
514 },
515 {
516 .wai = 0x32,
517 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
518 .sensors_supported = {
519 [0] = H3LIS331DL_ACCEL_DEV_NAME,
520 },
521 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
522 .odr = {
523 .addr = 0x20,
524 .mask = 0x18,
525 .odr_avl = {
526 { .hz = 50, .value = 0x00, },
527 { .hz = 100, .value = 0x01, },
528 { .hz = 400, .value = 0x02, },
529 { .hz = 1000, .value = 0x03, },
530 },
531 },
532 .pw = {
533 .addr = 0x20,
534 .mask = 0x20,
535 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
536 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
537 },
538 .enable_axis = {
539 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
540 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
541 },
542 .fs = {
543 .addr = 0x23,
544 .mask = 0x30,
545 .fs_avl = {
546 [0] = {
547 .num = ST_ACCEL_FS_AVL_100G,
548 .value = 0x00,
549 .gain = IIO_G_TO_M_S_2(49000),
550 },
551 [1] = {
552 .num = ST_ACCEL_FS_AVL_200G,
553 .value = 0x01,
554 .gain = IIO_G_TO_M_S_2(98000),
555 },
556 [2] = {
557 .num = ST_ACCEL_FS_AVL_400G,
558 .value = 0x03,
559 .gain = IIO_G_TO_M_S_2(195000),
560 },
561 },
562 },
563 .bdu = {
564 .addr = 0x23,
565 .mask = 0x80,
566 },
567 .drdy_irq = {
568 .int1 = {
569 .addr = 0x22,
570 .mask = 0x02,
571 },
572 .int2 = {
573 .addr = 0x22,
574 .mask = 0x10,
575 },
576 .addr_ihl = 0x22,
577 .mask_ihl = 0x80,
578 },
579 .sim = {
580 .addr = 0x23,
581 .value = BIT(0),
582 },
583 .multi_read_bit = true,
584 .bootime = 2,
585 },
586 {
587 .wai = 0x32,
588 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
589 .sensors_supported = {
590 [0] = IIS328DQ_ACCEL_DEV_NAME,
591 },
592 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
593 .odr = {
594 .addr = 0x20,
595 .mask = 0x18,
596 .odr_avl = {
597 { .hz = 50, .value = 0x00, },
598 { .hz = 100, .value = 0x01, },
599 { .hz = 400, .value = 0x02, },
600 { .hz = 1000, .value = 0x03, },
601 },
602 },
603 .pw = {
604 .addr = 0x20,
605 .mask = 0x20,
606 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
607 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
608 },
609 .enable_axis = {
610 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
611 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
612 },
613 .fs = {
614 .addr = 0x23,
615 .mask = 0x30,
616 .fs_avl = {
617 [0] = {
618 .num = ST_ACCEL_FS_AVL_100G,
619 .value = 0x00,
620 .gain = IIO_G_TO_M_S_2(980),
621 },
622 [1] = {
623 .num = ST_ACCEL_FS_AVL_200G,
624 .value = 0x01,
625 .gain = IIO_G_TO_M_S_2(1950),
626 },
627 [2] = {
628 .num = ST_ACCEL_FS_AVL_400G,
629 .value = 0x03,
630 .gain = IIO_G_TO_M_S_2(3910),
631 },
632 },
633 },
634 .bdu = {
635 .addr = 0x23,
636 .mask = 0x80,
637 },
638 .drdy_irq = {
639 .int1 = {
640 .addr = 0x22,
641 .mask = 0x02,
642 },
643 .int2 = {
644 .addr = 0x22,
645 .mask = 0x10,
646 },
647 .addr_ihl = 0x22,
648 .mask_ihl = 0x80,
649 },
650 .sim = {
651 .addr = 0x23,
652 .value = BIT(0),
653 },
654 .multi_read_bit = true,
655 .bootime = 2,
656 },
657 {
658 /* No WAI register present */
659 .sensors_supported = {
660 [0] = LIS3L02DQ_ACCEL_DEV_NAME,
661 },
662 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
663 .odr = {
664 .addr = 0x20,
665 .mask = 0x30,
666 .odr_avl = {
667 { .hz = 280, .value = 0x00, },
668 { .hz = 560, .value = 0x01, },
669 { .hz = 1120, .value = 0x02, },
670 { .hz = 4480, .value = 0x03, },
671 },
672 },
673 .pw = {
674 .addr = 0x20,
675 .mask = 0xc0,
676 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
677 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
678 },
679 .enable_axis = {
680 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
681 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
682 },
683 .fs = {
684 .fs_avl = {
685 [0] = {
686 .num = ST_ACCEL_FS_AVL_2G,
687 .gain = IIO_G_TO_M_S_2(488),
688 },
689 },
690 },
691 /*
692 * The part has a BDU bit but if set the data is never
693 * updated so don't set it.
694 */
695 .bdu = {
696 },
697 .drdy_irq = {
698 .int1 = {
699 .addr = 0x21,
700 .mask = 0x04,
701 },
702 .stat_drdy = {
703 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
704 .mask = 0x07,
705 },
706 },
707 .sim = {
708 .addr = 0x21,
709 .value = BIT(1),
710 },
711 .multi_read_bit = false,
712 .bootime = 2,
713 },
714 {
715 .wai = 0x33,
716 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
717 .sensors_supported = {
718 [0] = LNG2DM_ACCEL_DEV_NAME,
719 },
720 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
721 .odr = {
722 .addr = 0x20,
723 .mask = 0xf0,
724 .odr_avl = {
725 { .hz = 1, .value = 0x01, },
726 { .hz = 10, .value = 0x02, },
727 { .hz = 25, .value = 0x03, },
728 { .hz = 50, .value = 0x04, },
729 { .hz = 100, .value = 0x05, },
730 { .hz = 200, .value = 0x06, },
731 { .hz = 400, .value = 0x07, },
732 { .hz = 1600, .value = 0x08, },
733 },
734 },
735 .pw = {
736 .addr = 0x20,
737 .mask = 0xf0,
738 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
739 },
740 .enable_axis = {
741 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
742 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
743 },
744 .fs = {
745 .addr = 0x23,
746 .mask = 0x30,
747 .fs_avl = {
748 [0] = {
749 .num = ST_ACCEL_FS_AVL_2G,
750 .value = 0x00,
751 .gain = IIO_G_TO_M_S_2(15600),
752 },
753 [1] = {
754 .num = ST_ACCEL_FS_AVL_4G,
755 .value = 0x01,
756 .gain = IIO_G_TO_M_S_2(31200),
757 },
758 [2] = {
759 .num = ST_ACCEL_FS_AVL_8G,
760 .value = 0x02,
761 .gain = IIO_G_TO_M_S_2(62500),
762 },
763 [3] = {
764 .num = ST_ACCEL_FS_AVL_16G,
765 .value = 0x03,
766 .gain = IIO_G_TO_M_S_2(187500),
767 },
768 },
769 },
770 .drdy_irq = {
771 .int1 = {
772 .addr = 0x22,
773 .mask = 0x10,
774 },
775 .addr_ihl = 0x25,
776 .mask_ihl = 0x02,
777 .stat_drdy = {
778 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
779 .mask = 0x07,
780 },
781 },
782 .sim = {
783 .addr = 0x23,
784 .value = BIT(0),
785 },
786 .multi_read_bit = true,
787 .bootime = 2,
788 },
789 {
790 .wai = 0x44,
791 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
792 .sensors_supported = {
793 [0] = LIS2DW12_ACCEL_DEV_NAME,
794 },
795 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
796 .odr = {
797 .addr = 0x20,
798 .mask = 0xf0,
799 .odr_avl = {
800 { .hz = 1, .value = 0x01, },
801 { .hz = 12, .value = 0x02, },
802 { .hz = 25, .value = 0x03, },
803 { .hz = 50, .value = 0x04, },
804 { .hz = 100, .value = 0x05, },
805 { .hz = 200, .value = 0x06, },
806 },
807 },
808 .pw = {
809 .addr = 0x20,
810 .mask = 0xf0,
811 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
812 },
813 .fs = {
814 .addr = 0x25,
815 .mask = 0x30,
816 .fs_avl = {
817 [0] = {
818 .num = ST_ACCEL_FS_AVL_2G,
819 .value = 0x00,
820 .gain = IIO_G_TO_M_S_2(976),
821 },
822 [1] = {
823 .num = ST_ACCEL_FS_AVL_4G,
824 .value = 0x01,
825 .gain = IIO_G_TO_M_S_2(1952),
826 },
827 [2] = {
828 .num = ST_ACCEL_FS_AVL_8G,
829 .value = 0x02,
830 .gain = IIO_G_TO_M_S_2(3904),
831 },
832 [3] = {
833 .num = ST_ACCEL_FS_AVL_16G,
834 .value = 0x03,
835 .gain = IIO_G_TO_M_S_2(7808),
836 },
837 },
838 },
839 .bdu = {
840 .addr = 0x21,
841 .mask = 0x08,
842 },
843 .drdy_irq = {
844 .int1 = {
845 .addr = 0x23,
846 .mask = 0x01,
847 .addr_od = 0x22,
848 .mask_od = 0x20,
849 },
850 .int2 = {
851 .addr = 0x24,
852 .mask = 0x01,
853 .addr_od = 0x22,
854 .mask_od = 0x20,
855 },
856 .addr_ihl = 0x22,
857 .mask_ihl = 0x08,
858 .stat_drdy = {
859 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
860 .mask = 0x01,
861 },
862 },
863 .sim = {
864 .addr = 0x21,
865 .value = BIT(0),
866 },
867 .multi_read_bit = false,
868 .bootime = 2,
869 },
870 {
871 .wai = 0x11,
872 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
873 .sensors_supported = {
874 [0] = LIS3DHH_ACCEL_DEV_NAME,
875 },
876 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
877 .odr = {
878 /* just ODR = 1100Hz available */
879 .odr_avl = {
880 { .hz = 1100, .value = 0x00, },
881 },
882 },
883 .pw = {
884 .addr = 0x20,
885 .mask = 0x80,
886 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
887 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
888 },
889 .fs = {
890 .fs_avl = {
891 [0] = {
892 .num = ST_ACCEL_FS_AVL_2G,
893 .gain = IIO_G_TO_M_S_2(76),
894 },
895 },
896 },
897 .bdu = {
898 .addr = 0x20,
899 .mask = 0x01,
900 },
901 .drdy_irq = {
902 .int1 = {
903 .addr = 0x21,
904 .mask = 0x80,
905 .addr_od = 0x23,
906 .mask_od = 0x04,
907 },
908 .int2 = {
909 .addr = 0x22,
910 .mask = 0x80,
911 .addr_od = 0x23,
912 .mask_od = 0x08,
913 },
914 .stat_drdy = {
915 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
916 .mask = 0x07,
917 },
918 },
919 .multi_read_bit = false,
920 .bootime = 2,
921 },
922 {
923 .wai = 0x33,
924 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
925 .sensors_supported = {
926 [0] = LIS2DE12_ACCEL_DEV_NAME,
927 },
928 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
929 .odr = {
930 .addr = 0x20,
931 .mask = 0xf0,
932 .odr_avl = {
933 { .hz = 1, .value = 0x01, },
934 { .hz = 10, .value = 0x02, },
935 { .hz = 25, .value = 0x03, },
936 { .hz = 50, .value = 0x04, },
937 { .hz = 100, .value = 0x05, },
938 { .hz = 200, .value = 0x06, },
939 { .hz = 400, .value = 0x07, },
940 { .hz = 1620, .value = 0x08, },
941 { .hz = 5376, .value = 0x09, },
942 },
943 },
944 .pw = {
945 .addr = 0x20,
946 .mask = 0xf0,
947 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
948 },
949 .enable_axis = {
950 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
951 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
952 },
953 .fs = {
954 .addr = 0x23,
955 .mask = 0x30,
956 .fs_avl = {
957 [0] = {
958 .num = ST_ACCEL_FS_AVL_2G,
959 .value = 0x00,
960 .gain = IIO_G_TO_M_S_2(15600),
961 },
962 [1] = {
963 .num = ST_ACCEL_FS_AVL_4G,
964 .value = 0x01,
965 .gain = IIO_G_TO_M_S_2(31200),
966 },
967 [2] = {
968 .num = ST_ACCEL_FS_AVL_8G,
969 .value = 0x02,
970 .gain = IIO_G_TO_M_S_2(62500),
971 },
972 [3] = {
973 .num = ST_ACCEL_FS_AVL_16G,
974 .value = 0x03,
975 .gain = IIO_G_TO_M_S_2(187500),
976 },
977 },
978 },
979 .drdy_irq = {
980 .int1 = {
981 .addr = 0x22,
982 .mask = 0x10,
983 },
984 .addr_ihl = 0x25,
985 .mask_ihl = 0x02,
986 .stat_drdy = {
987 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
988 .mask = 0x07,
989 },
990 },
991 .sim = {
992 .addr = 0x23,
993 .value = BIT(0),
994 },
995 .multi_read_bit = true,
996 .bootime = 2,
997 },
998 {
999 .wai = 0x43,
1000 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
1001 .sensors_supported = {
1002 [0] = LIS2DS12_ACCEL_DEV_NAME,
1003 },
1004 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
1005 .odr = {
1006 .addr = 0x20,
1007 .mask = 0xf0,
1008 .odr_avl = {
1009 { .hz = 10, .value = 0x01, },
1010 { .hz = 50, .value = 0x02, },
1011 { .hz = 100, .value = 0x03, },
1012 { .hz = 200, .value = 0x04, },
1013 { .hz = 400, .value = 0x05, },
1014 { .hz = 800, .value = 0x06, },
1015 },
1016 },
1017 .pw = {
1018 .addr = 0x20,
1019 .mask = 0xf0,
1020 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
1021 },
1022 .enable_axis = {
1023 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
1024 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
1025 },
1026 .fs = {
1027 .addr = 0x20,
1028 .mask = 0x0c,
1029 .fs_avl = {
1030 [0] = {
1031 .num = ST_ACCEL_FS_AVL_2G,
1032 .value = 0x00,
1033 .gain = IIO_G_TO_M_S_2(61),
1034 },
1035 [1] = {
1036 .num = ST_ACCEL_FS_AVL_4G,
1037 .value = 0x02,
1038 .gain = IIO_G_TO_M_S_2(122),
1039 },
1040 [2] = {
1041 .num = ST_ACCEL_FS_AVL_8G,
1042 .value = 0x03,
1043 .gain = IIO_G_TO_M_S_2(244),
1044 },
1045 [3] = {
1046 .num = ST_ACCEL_FS_AVL_16G,
1047 .value = 0x01,
1048 .gain = IIO_G_TO_M_S_2(488),
1049 },
1050 },
1051 },
1052 .bdu = {
1053 .addr = 0x20,
1054 .mask = 0x01,
1055 },
1056 .drdy_irq = {
1057 .int1 = {
1058 .addr = 0x23,
1059 .mask = 0x01,
1060 },
1061 .int2 = {
1062 .addr = 0x24,
1063 .mask = 0x01,
1064 },
1065 .addr_ihl = 0x22,
1066 .mask_ihl = 0x02,
1067 .stat_drdy = {
1068 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
1069 .mask = 0x01,
1070 },
1071 },
1072 .sim = {
1073 .addr = 0x21,
1074 .value = BIT(0),
1075 },
1076 .multi_read_bit = true,
1077 .bootime = 2,
1078 },
1079 {
1080 .wai = 0x41,
1081 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
1082 .sensors_supported = {
1083 [0] = LIS2HH12_ACCEL_DEV_NAME,
1084 [1] = LSM303C_ACCEL_DEV_NAME,
1085 },
1086 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
1087 .odr = {
1088 .addr = 0x20,
1089 .mask = 0x70,
1090 .odr_avl = {
1091 { .hz = 10, .value = 0x01, },
1092 { .hz = 50, .value = 0x02, },
1093 { .hz = 100, .value = 0x03, },
1094 { .hz = 200, .value = 0x04, },
1095 { .hz = 400, .value = 0x05, },
1096 { .hz = 800, .value = 0x06, },
1097 },
1098 },
1099 .pw = {
1100 .addr = 0x20,
1101 .mask = 0x70,
1102 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
1103 },
1104 .enable_axis = {
1105 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
1106 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
1107 },
1108 .fs = {
1109 .addr = 0x23,
1110 .mask = 0x30,
1111 .fs_avl = {
1112 [0] = {
1113 .num = ST_ACCEL_FS_AVL_2G,
1114 .value = 0x00,
1115 .gain = IIO_G_TO_M_S_2(61),
1116 },
1117 [1] = {
1118 .num = ST_ACCEL_FS_AVL_4G,
1119 .value = 0x02,
1120 .gain = IIO_G_TO_M_S_2(122),
1121 },
1122 [2] = {
1123 .num = ST_ACCEL_FS_AVL_8G,
1124 .value = 0x03,
1125 .gain = IIO_G_TO_M_S_2(244),
1126 },
1127 },
1128 },
1129 .bdu = {
1130 .addr = 0x20,
1131 .mask = 0x08,
1132 },
1133 .drdy_irq = {
1134 .int1 = {
1135 .addr = 0x22,
1136 .mask = 0x01,
1137 },
1138 .int2 = {
1139 .addr = 0x25,
1140 .mask = 0x01,
1141 },
1142 .addr_ihl = 0x24,
1143 .mask_ihl = 0x02,
1144 .stat_drdy = {
1145 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
1146 .mask = 0x07,
1147 },
1148 },
1149 .sim = {
1150 .addr = 0x23,
1151 .value = BIT(0),
1152 },
1153 .multi_read_bit = true,
1154 .bootime = 2,
1155 },
1156 {
1157 .wai = 0x49,
1158 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
1159 .sensors_supported = {
1160 [0] = LSM9DS0_IMU_DEV_NAME,
1161 [1] = LSM303D_IMU_DEV_NAME,
1162 },
1163 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
1164 .odr = {
1165 .addr = 0x20,
1166 .mask = GENMASK(7, 4),
1167 .odr_avl = {
1168 { 3, 0x01, },
1169 { 6, 0x02, },
1170 { 12, 0x03, },
1171 { 25, 0x04, },
1172 { 50, 0x05, },
1173 { 100, 0x06, },
1174 { 200, 0x07, },
1175 { 400, 0x08, },
1176 { 800, 0x09, },
1177 { 1600, 0x0a, },
1178 },
1179 },
1180 .pw = {
1181 .addr = 0x20,
1182 .mask = GENMASK(7, 4),
1183 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
1184 },
1185 .enable_axis = {
1186 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
1187 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
1188 },
1189 .fs = {
1190 .addr = 0x21,
1191 .mask = GENMASK(5, 3),
1192 .fs_avl = {
1193 [0] = {
1194 .num = ST_ACCEL_FS_AVL_2G,
1195 .value = 0x00,
1196 .gain = IIO_G_TO_M_S_2(61),
1197 },
1198 [1] = {
1199 .num = ST_ACCEL_FS_AVL_4G,
1200 .value = 0x01,
1201 .gain = IIO_G_TO_M_S_2(122),
1202 },
1203 [2] = {
1204 .num = ST_ACCEL_FS_AVL_6G,
1205 .value = 0x02,
1206 .gain = IIO_G_TO_M_S_2(183),
1207 },
1208 [3] = {
1209 .num = ST_ACCEL_FS_AVL_8G,
1210 .value = 0x03,
1211 .gain = IIO_G_TO_M_S_2(244),
1212 },
1213 [4] = {
1214 .num = ST_ACCEL_FS_AVL_16G,
1215 .value = 0x04,
1216 .gain = IIO_G_TO_M_S_2(732),
1217 },
1218 },
1219 },
1220 .bdu = {
1221 .addr = 0x20,
1222 .mask = BIT(3),
1223 },
1224 .drdy_irq = {
1225 .int1 = {
1226 .addr = 0x22,
1227 .mask = BIT(2),
1228 },
1229 .int2 = {
1230 .addr = 0x23,
1231 .mask = BIT(3),
1232 },
1233 .stat_drdy = {
1234 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
1235 .mask = GENMASK(2, 0),
1236 },
1237 },
1238 .sim = {
1239 .addr = 0x21,
1240 .value = BIT(0),
1241 },
1242 .multi_read_bit = true,
1243 .bootime = 2,
1244 },
1245 {
1246 /*
1247 * Not an ST part. Register-compatible with the LIS2DH, even
1248 * though the WAI value is different.
1249 */
1250 .wai = 0x11,
1251 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
1252 .sensors_supported = {
1253 [0] = SC7A20_ACCEL_DEV_NAME,
1254 },
1255 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
1256 .odr = {
1257 .addr = 0x20,
1258 .mask = 0xf0,
1259 .odr_avl = {
1260 { .hz = 1, .value = 0x01, },
1261 { .hz = 10, .value = 0x02, },
1262 { .hz = 25, .value = 0x03, },
1263 { .hz = 50, .value = 0x04, },
1264 { .hz = 100, .value = 0x05, },
1265 { .hz = 200, .value = 0x06, },
1266 { .hz = 400, .value = 0x07, },
1267 { .hz = 1600, .value = 0x08, },
1268 },
1269 },
1270 .pw = {
1271 .addr = 0x20,
1272 .mask = 0xf0,
1273 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
1274 },
1275 .enable_axis = {
1276 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
1277 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
1278 },
1279 .fs = {
1280 .addr = 0x23,
1281 .mask = 0x30,
1282 .fs_avl = {
1283 [0] = {
1284 .num = ST_ACCEL_FS_AVL_2G,
1285 .value = 0x00,
1286 .gain = IIO_G_TO_M_S_2(1000),
1287 },
1288 [1] = {
1289 .num = ST_ACCEL_FS_AVL_4G,
1290 .value = 0x01,
1291 .gain = IIO_G_TO_M_S_2(2000),
1292 },
1293 [2] = {
1294 .num = ST_ACCEL_FS_AVL_8G,
1295 .value = 0x02,
1296 .gain = IIO_G_TO_M_S_2(4000),
1297 },
1298 [3] = {
1299 .num = ST_ACCEL_FS_AVL_16G,
1300 .value = 0x03,
1301 .gain = IIO_G_TO_M_S_2(12000),
1302 },
1303 },
1304 },
1305 .bdu = {
1306 .addr = 0x23,
1307 .mask = 0x80,
1308 },
1309 .drdy_irq = {
1310 .int1 = {
1311 .addr = 0x22,
1312 .mask = 0x10,
1313 },
1314 .addr_ihl = 0x25,
1315 .mask_ihl = 0x02,
1316 .stat_drdy = {
1317 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
1318 .mask = 0x07,
1319 },
1320 },
1321 .sim = {
1322 .addr = 0x23,
1323 .value = BIT(0),
1324 },
1325 .multi_read_bit = true,
1326 .bootime = 2,
1327 },
1328 };
1329
1330 /* Default accel DRDY is available on INT1 pin */
1331 static const struct st_sensors_platform_data default_accel_pdata = {
1332 .drdy_int_pin = 1,
1333 };
1334
st_accel_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * ch,int * val,int * val2,long mask)1335 static int st_accel_read_raw(struct iio_dev *indio_dev,
1336 struct iio_chan_spec const *ch, int *val,
1337 int *val2, long mask)
1338 {
1339 int err;
1340 struct st_sensor_data *adata = iio_priv(indio_dev);
1341
1342 switch (mask) {
1343 case IIO_CHAN_INFO_RAW:
1344 err = st_sensors_read_info_raw(indio_dev, ch, val);
1345 if (err < 0)
1346 goto read_error;
1347
1348 return IIO_VAL_INT;
1349 case IIO_CHAN_INFO_SCALE:
1350 *val = adata->current_fullscale->gain / 1000000;
1351 *val2 = adata->current_fullscale->gain % 1000000;
1352 return IIO_VAL_INT_PLUS_MICRO;
1353 case IIO_CHAN_INFO_SAMP_FREQ:
1354 *val = adata->odr;
1355 return IIO_VAL_INT;
1356 default:
1357 return -EINVAL;
1358 }
1359
1360 read_error:
1361 return err;
1362 }
1363
st_accel_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)1364 static int st_accel_write_raw(struct iio_dev *indio_dev,
1365 struct iio_chan_spec const *chan, int val, int val2, long mask)
1366 {
1367 switch (mask) {
1368 case IIO_CHAN_INFO_SCALE: {
1369 int gain;
1370
1371 gain = val * 1000000 + val2;
1372 return st_sensors_set_fullscale_by_gain(indio_dev, gain);
1373 }
1374 case IIO_CHAN_INFO_SAMP_FREQ:
1375 if (val2)
1376 return -EINVAL;
1377
1378 return st_sensors_set_odr(indio_dev, val);
1379 default:
1380 return -EINVAL;
1381 }
1382 }
1383
1384 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
1385 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available);
1386
1387 static struct attribute *st_accel_attributes[] = {
1388 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
1389 &iio_dev_attr_in_accel_scale_available.dev_attr.attr,
1390 NULL,
1391 };
1392
1393 static const struct attribute_group st_accel_attribute_group = {
1394 .attrs = st_accel_attributes,
1395 };
1396
1397 static const struct iio_info accel_info = {
1398 .attrs = &st_accel_attribute_group,
1399 .read_raw = &st_accel_read_raw,
1400 .write_raw = &st_accel_write_raw,
1401 .debugfs_reg_access = &st_sensors_debugfs_reg_access,
1402 };
1403
1404 #ifdef CONFIG_IIO_TRIGGER
1405 static const struct iio_trigger_ops st_accel_trigger_ops = {
1406 .set_trigger_state = ST_ACCEL_TRIGGER_SET_STATE,
1407 .validate_device = st_sensors_validate_device,
1408 };
1409 #define ST_ACCEL_TRIGGER_OPS (&st_accel_trigger_ops)
1410 #else
1411 #define ST_ACCEL_TRIGGER_OPS NULL
1412 #endif
1413
1414 #ifdef CONFIG_ACPI
1415 /* Read ST-specific _ONT orientation data from ACPI and generate an
1416 * appropriate mount matrix.
1417 */
apply_acpi_orientation(struct iio_dev * indio_dev)1418 static int apply_acpi_orientation(struct iio_dev *indio_dev)
1419 {
1420 struct st_sensor_data *adata = iio_priv(indio_dev);
1421 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
1422 struct acpi_device *adev;
1423 union acpi_object *ont;
1424 union acpi_object *elements;
1425 acpi_status status;
1426 struct device *parent = indio_dev->dev.parent;
1427 int ret = -EINVAL;
1428 unsigned int val;
1429 int i, j;
1430 int final_ont[3][3] = { { 0 }, };
1431
1432 /* For some reason, ST's _ONT translation does not apply directly
1433 * to the data read from the sensor. Another translation must be
1434 * performed first, as described by the matrix below. Perhaps
1435 * ST required this specific translation for the first product
1436 * where the device was mounted?
1437 */
1438 const int default_ont[3][3] = {
1439 { 0, 1, 0 },
1440 { -1, 0, 0 },
1441 { 0, 0, -1 },
1442 };
1443
1444
1445 adev = ACPI_COMPANION(parent);
1446 if (!adev)
1447 return -ENXIO;
1448
1449 /* Read _ONT data, which should be a package of 6 integers. */
1450 status = acpi_evaluate_object(adev->handle, "_ONT", NULL, &buffer);
1451 if (status == AE_NOT_FOUND) {
1452 return -ENXIO;
1453 } else if (ACPI_FAILURE(status)) {
1454 dev_warn(parent, "failed to execute _ONT: %d\n", status);
1455 return status;
1456 }
1457
1458 ont = buffer.pointer;
1459 if (ont->type != ACPI_TYPE_PACKAGE || ont->package.count != 6)
1460 goto out;
1461
1462 /* The first 3 integers provide axis order information.
1463 * e.g. 0 1 2 would indicate normal X,Y,Z ordering.
1464 * e.g. 1 0 2 indicates that data arrives in order Y,X,Z.
1465 */
1466 elements = ont->package.elements;
1467 for (i = 0; i < 3; i++) {
1468 if (elements[i].type != ACPI_TYPE_INTEGER)
1469 goto out;
1470
1471 val = elements[i].integer.value;
1472 if (val > 2)
1473 goto out;
1474
1475 /* Avoiding full matrix multiplication, we simply reorder the
1476 * columns in the default_ont matrix according to the
1477 * ordering provided by _ONT.
1478 */
1479 final_ont[0][i] = default_ont[0][val];
1480 final_ont[1][i] = default_ont[1][val];
1481 final_ont[2][i] = default_ont[2][val];
1482 }
1483
1484 /* The final 3 integers provide sign flip information.
1485 * 0 means no change, 1 means flip.
1486 * e.g. 0 0 1 means that Z data should be sign-flipped.
1487 * This is applied after the axis reordering from above.
1488 */
1489 elements += 3;
1490 for (i = 0; i < 3; i++) {
1491 if (elements[i].type != ACPI_TYPE_INTEGER)
1492 goto out;
1493
1494 val = elements[i].integer.value;
1495 if (val != 0 && val != 1)
1496 goto out;
1497 if (!val)
1498 continue;
1499
1500 /* Flip the values in the indicated column */
1501 final_ont[0][i] *= -1;
1502 final_ont[1][i] *= -1;
1503 final_ont[2][i] *= -1;
1504 }
1505
1506 /* Convert our integer matrix to a string-based iio_mount_matrix */
1507 for (i = 0; i < 3; i++) {
1508 for (j = 0; j < 3; j++) {
1509 int matrix_val = final_ont[i][j];
1510 char *str_value;
1511
1512 switch (matrix_val) {
1513 case -1:
1514 str_value = "-1";
1515 break;
1516 case 0:
1517 str_value = "0";
1518 break;
1519 case 1:
1520 str_value = "1";
1521 break;
1522 default:
1523 goto out;
1524 }
1525 adata->mount_matrix.rotation[i * 3 + j] = str_value;
1526 }
1527 }
1528
1529 ret = 0;
1530 dev_info(parent, "computed mount matrix from ACPI\n");
1531
1532 out:
1533 kfree(buffer.pointer);
1534 if (ret)
1535 dev_dbg(parent,
1536 "failed to apply ACPI orientation data: %d\n", ret);
1537
1538 return ret;
1539 }
1540 #else /* !CONFIG_ACPI */
apply_acpi_orientation(struct iio_dev * indio_dev)1541 static int apply_acpi_orientation(struct iio_dev *indio_dev)
1542 {
1543 return -EINVAL;
1544 }
1545 #endif
1546
1547 /*
1548 * st_accel_get_settings() - get sensor settings from device name
1549 * @name: device name buffer reference.
1550 *
1551 * Return: valid reference on success, NULL otherwise.
1552 */
st_accel_get_settings(const char * name)1553 const struct st_sensor_settings *st_accel_get_settings(const char *name)
1554 {
1555 int index = st_sensors_get_settings_index(name,
1556 st_accel_sensors_settings,
1557 ARRAY_SIZE(st_accel_sensors_settings));
1558 if (index < 0)
1559 return NULL;
1560
1561 return &st_accel_sensors_settings[index];
1562 }
1563 EXPORT_SYMBOL_NS(st_accel_get_settings, "IIO_ST_SENSORS");
1564
st_accel_common_probe(struct iio_dev * indio_dev)1565 int st_accel_common_probe(struct iio_dev *indio_dev)
1566 {
1567 struct st_sensor_data *adata = iio_priv(indio_dev);
1568 struct device *parent = indio_dev->dev.parent;
1569 struct st_sensors_platform_data *pdata = dev_get_platdata(parent);
1570 int err;
1571
1572 indio_dev->modes = INDIO_DIRECT_MODE;
1573 indio_dev->info = &accel_info;
1574
1575 err = st_sensors_verify_id(indio_dev);
1576 if (err < 0)
1577 return err;
1578
1579 adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS;
1580 indio_dev->channels = adata->sensor_settings->ch;
1581 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
1582
1583 /*
1584 * First try specific ACPI methods to retrieve orientation then try the
1585 * generic function.
1586 */
1587 err = apply_acpi_orientation(indio_dev);
1588 if (err) {
1589 err = iio_read_mount_matrix(parent, &adata->mount_matrix);
1590 if (err)
1591 return err;
1592 }
1593
1594 adata->current_fullscale = &adata->sensor_settings->fs.fs_avl[0];
1595 adata->odr = adata->sensor_settings->odr.odr_avl[0].hz;
1596
1597 if (!pdata)
1598 pdata = (struct st_sensors_platform_data *)&default_accel_pdata;
1599
1600 err = st_sensors_init_sensor(indio_dev, pdata);
1601 if (err < 0)
1602 return err;
1603
1604 err = st_accel_allocate_ring(indio_dev);
1605 if (err < 0)
1606 return err;
1607
1608 if (adata->irq > 0) {
1609 err = st_sensors_allocate_trigger(indio_dev,
1610 ST_ACCEL_TRIGGER_OPS);
1611 if (err < 0)
1612 return err;
1613 }
1614
1615 return devm_iio_device_register(parent, indio_dev);
1616 }
1617 EXPORT_SYMBOL_NS(st_accel_common_probe, "IIO_ST_SENSORS");
1618
1619 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
1620 MODULE_DESCRIPTION("STMicroelectronics accelerometers driver");
1621 MODULE_LICENSE("GPL v2");
1622 MODULE_IMPORT_NS("IIO_ST_SENSORS");
1623