?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for-linus-20190706' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / iio / accel / st_accel_core.c
blobe02b799319790a682fe6d58fc0fcd38d0f365bbe
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/slab.h>
13 #include <linux/acpi.h>
14 #include <linux/errno.h>
15 #include <linux/types.h>
16 #include <linux/mutex.h>
17 #include <linux/interrupt.h>
18 #include <linux/i2c.h>
19 #include <linux/gpio.h>
20 #include <linux/irq.h>
21 #include <linux/iio/iio.h>
22 #include <linux/iio/sysfs.h>
23 #include <linux/iio/trigger.h>
24 #include <linux/iio/buffer.h>
25
26 #include <linux/iio/common/st_sensors.h>
27 #include "st_accel.h"
28
29 #define ST_ACCEL_NUMBER_DATA_CHANNELS 3
30
31 /* DEFAULT VALUE FOR SENSORS */
32 #define ST_ACCEL_DEFAULT_OUT_X_L_ADDR 0x28
33 #define ST_ACCEL_DEFAULT_OUT_Y_L_ADDR 0x2a
34 #define ST_ACCEL_DEFAULT_OUT_Z_L_ADDR 0x2c
35
36 /* FULLSCALE */
37 #define ST_ACCEL_FS_AVL_2G 2
38 #define ST_ACCEL_FS_AVL_4G 4
39 #define ST_ACCEL_FS_AVL_6G 6
40 #define ST_ACCEL_FS_AVL_8G 8
41 #define ST_ACCEL_FS_AVL_16G 16
42 #define ST_ACCEL_FS_AVL_100G 100
43 #define ST_ACCEL_FS_AVL_200G 200
44 #define ST_ACCEL_FS_AVL_400G 400
45
46 static const struct iio_chan_spec st_accel_8bit_channels[] = {
47 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
48 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
49 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 8, 8,
50 ST_ACCEL_DEFAULT_OUT_X_L_ADDR+1),
51 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
52 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
53 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 8, 8,
54 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR+1),
55 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
56 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
57 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 8, 8,
58 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR+1),
59 IIO_CHAN_SOFT_TIMESTAMP(3)
60 };
61
62 static const struct iio_chan_spec st_accel_12bit_channels[] = {
63 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
64 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
65 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 12, 16,
66 ST_ACCEL_DEFAULT_OUT_X_L_ADDR),
67 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
68 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
69 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 12, 16,
70 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR),
71 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
72 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
73 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 12, 16,
74 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR),
75 IIO_CHAN_SOFT_TIMESTAMP(3)
76 };
77
78 static const struct iio_chan_spec st_accel_16bit_channels[] = {
79 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
80 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
81 ST_SENSORS_SCAN_X, 1, IIO_MOD_X, 's', IIO_LE, 16, 16,
82 ST_ACCEL_DEFAULT_OUT_X_L_ADDR),
83 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
84 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
85 ST_SENSORS_SCAN_Y, 1, IIO_MOD_Y, 's', IIO_LE, 16, 16,
86 ST_ACCEL_DEFAULT_OUT_Y_L_ADDR),
87 ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
88 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
89 ST_SENSORS_SCAN_Z, 1, IIO_MOD_Z, 's', IIO_LE, 16, 16,
90 ST_ACCEL_DEFAULT_OUT_Z_L_ADDR),
91 IIO_CHAN_SOFT_TIMESTAMP(3)
92 };
93
94 static const struct st_sensor_settings st_accel_sensors_settings[] = {
95 {
96 .wai = 0x33,
97 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
98 .sensors_supported = {
99 [0] = LIS3DH_ACCEL_DEV_NAME,
100 [1] = LSM303DLHC_ACCEL_DEV_NAME,
101 [2] = LSM330D_ACCEL_DEV_NAME,
102 [3] = LSM330DL_ACCEL_DEV_NAME,
103 [4] = LSM330DLC_ACCEL_DEV_NAME,
104 [5] = LSM303AGR_ACCEL_DEV_NAME,
105 [6] = LIS2DH12_ACCEL_DEV_NAME,
106 [7] = LIS3DE_ACCEL_DEV_NAME,
107 },
108 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
109 .odr = {
110 .addr = 0x20,
111 .mask = 0xf0,
112 .odr_avl = {
113 { .hz = 1, .value = 0x01, },
114 { .hz = 10, .value = 0x02, },
115 { .hz = 25, .value = 0x03, },
116 { .hz = 50, .value = 0x04, },
117 { .hz = 100, .value = 0x05, },
118 { .hz = 200, .value = 0x06, },
119 { .hz = 400, .value = 0x07, },
120 { .hz = 1600, .value = 0x08, },
121 },
122 },
123 .pw = {
124 .addr = 0x20,
125 .mask = 0xf0,
126 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
127 },
128 .enable_axis = {
129 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
130 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
131 },
132 .fs = {
133 .addr = 0x23,
134 .mask = 0x30,
135 .fs_avl = {
136 [0] = {
137 .num = ST_ACCEL_FS_AVL_2G,
138 .value = 0x00,
139 .gain = IIO_G_TO_M_S_2(1000),
140 },
141 [1] = {
142 .num = ST_ACCEL_FS_AVL_4G,
143 .value = 0x01,
144 .gain = IIO_G_TO_M_S_2(2000),
145 },
146 [2] = {
147 .num = ST_ACCEL_FS_AVL_8G,
148 .value = 0x02,
149 .gain = IIO_G_TO_M_S_2(4000),
150 },
151 [3] = {
152 .num = ST_ACCEL_FS_AVL_16G,
153 .value = 0x03,
154 .gain = IIO_G_TO_M_S_2(12000),
155 },
156 },
157 },
158 .bdu = {
159 .addr = 0x23,
160 .mask = 0x80,
161 },
162 .drdy_irq = {
163 .int1 = {
164 .addr = 0x22,
165 .mask = 0x10,
166 },
167 .addr_ihl = 0x25,
168 .mask_ihl = 0x02,
169 .stat_drdy = {
170 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
171 .mask = 0x07,
172 },
173 },
174 .sim = {
175 .addr = 0x23,
176 .value = BIT(0),
177 },
178 .multi_read_bit = true,
179 .bootime = 2,
180 },
181 {
182 .wai = 0x32,
183 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
184 .sensors_supported = {
185 [0] = LIS331DLH_ACCEL_DEV_NAME,
186 [1] = LSM303DL_ACCEL_DEV_NAME,
187 [2] = LSM303DLH_ACCEL_DEV_NAME,
188 [3] = LSM303DLM_ACCEL_DEV_NAME,
189 },
190 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
191 .odr = {
192 .addr = 0x20,
193 .mask = 0x18,
194 .odr_avl = {
195 { .hz = 50, .value = 0x00, },
196 { .hz = 100, .value = 0x01, },
197 { .hz = 400, .value = 0x02, },
198 { .hz = 1000, .value = 0x03, },
199 },
200 },
201 .pw = {
202 .addr = 0x20,
203 .mask = 0xe0,
204 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
205 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
206 },
207 .enable_axis = {
208 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
209 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
210 },
211 .fs = {
212 .addr = 0x23,
213 .mask = 0x30,
214 .fs_avl = {
215 [0] = {
216 .num = ST_ACCEL_FS_AVL_2G,
217 .value = 0x00,
218 .gain = IIO_G_TO_M_S_2(1000),
219 },
220 [1] = {
221 .num = ST_ACCEL_FS_AVL_4G,
222 .value = 0x01,
223 .gain = IIO_G_TO_M_S_2(2000),
224 },
225 [2] = {
226 .num = ST_ACCEL_FS_AVL_8G,
227 .value = 0x03,
228 .gain = IIO_G_TO_M_S_2(3900),
229 },
230 },
231 },
232 .bdu = {
233 .addr = 0x23,
234 .mask = 0x80,
235 },
236 .drdy_irq = {
237 .int1 = {
238 .addr = 0x22,
239 .mask = 0x02,
240 .addr_od = 0x22,
241 .mask_od = 0x40,
242 },
243 .int2 = {
244 .addr = 0x22,
245 .mask = 0x10,
246 .addr_od = 0x22,
247 .mask_od = 0x40,
248 },
249 .addr_ihl = 0x22,
250 .mask_ihl = 0x80,
251 .stat_drdy = {
252 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
253 .mask = 0x07,
254 },
255 },
256 .sim = {
257 .addr = 0x23,
258 .value = BIT(0),
259 },
260 .multi_read_bit = true,
261 .bootime = 2,
262 },
263 {
264 .wai = 0x40,
265 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
266 .sensors_supported = {
267 [0] = LSM330_ACCEL_DEV_NAME,
268 },
269 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
270 .odr = {
271 .addr = 0x20,
272 .mask = 0xf0,
273 .odr_avl = {
274 { .hz = 3, .value = 0x01, },
275 { .hz = 6, .value = 0x02, },
276 { .hz = 12, .value = 0x03, },
277 { .hz = 25, .value = 0x04, },
278 { .hz = 50, .value = 0x05, },
279 { .hz = 100, .value = 0x06, },
280 { .hz = 200, .value = 0x07, },
281 { .hz = 400, .value = 0x08, },
282 { .hz = 800, .value = 0x09, },
283 { .hz = 1600, .value = 0x0a, },
284 },
285 },
286 .pw = {
287 .addr = 0x20,
288 .mask = 0xf0,
289 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
290 },
291 .enable_axis = {
292 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
293 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
294 },
295 .fs = {
296 .addr = 0x24,
297 .mask = 0x38,
298 .fs_avl = {
299 [0] = {
300 .num = ST_ACCEL_FS_AVL_2G,
301 .value = 0x00,
302 .gain = IIO_G_TO_M_S_2(61),
303 },
304 [1] = {
305 .num = ST_ACCEL_FS_AVL_4G,
306 .value = 0x01,
307 .gain = IIO_G_TO_M_S_2(122),
308 },
309 [2] = {
310 .num = ST_ACCEL_FS_AVL_6G,
311 .value = 0x02,
312 .gain = IIO_G_TO_M_S_2(183),
313 },
314 [3] = {
315 .num = ST_ACCEL_FS_AVL_8G,
316 .value = 0x03,
317 .gain = IIO_G_TO_M_S_2(244),
318 },
319 [4] = {
320 .num = ST_ACCEL_FS_AVL_16G,
321 .value = 0x04,
322 .gain = IIO_G_TO_M_S_2(732),
323 },
324 },
325 },
326 .bdu = {
327 .addr = 0x20,
328 .mask = 0x08,
329 },
330 .drdy_irq = {
331 .int1 = {
332 .addr = 0x23,
333 .mask = 0x80,
334 },
335 .addr_ihl = 0x23,
336 .mask_ihl = 0x40,
337 .stat_drdy = {
338 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
339 .mask = 0x07,
340 },
341 .ig1 = {
342 .en_addr = 0x23,
343 .en_mask = 0x08,
344 },
345 },
346 .sim = {
347 .addr = 0x24,
348 .value = BIT(0),
349 },
350 .multi_read_bit = false,
351 .bootime = 2,
352 },
353 {
354 .wai = 0x3a,
355 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
356 .sensors_supported = {
357 [0] = LIS3LV02DL_ACCEL_DEV_NAME,
358 },
359 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
360 .odr = {
361 .addr = 0x20,
362 .mask = 0x30, /* DF1 and DF0 */
363 .odr_avl = {
364 { .hz = 40, .value = 0x00, },
365 { .hz = 160, .value = 0x01, },
366 { .hz = 640, .value = 0x02, },
367 { .hz = 2560, .value = 0x03, },
368 },
369 },
370 .pw = {
371 .addr = 0x20,
372 .mask = 0xc0,
373 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
374 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
375 },
376 .enable_axis = {
377 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
378 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
379 },
380 .fs = {
381 .addr = 0x21,
382 .mask = 0x80,
383 .fs_avl = {
384 [0] = {
385 .num = ST_ACCEL_FS_AVL_2G,
386 .value = 0x00,
387 .gain = IIO_G_TO_M_S_2(1000),
388 },
389 [1] = {
390 .num = ST_ACCEL_FS_AVL_6G,
391 .value = 0x01,
392 .gain = IIO_G_TO_M_S_2(3000),
393 },
394 },
395 },
396 .bdu = {
397 .addr = 0x21,
398 .mask = 0x40,
399 },
400 /*
401 * Data Alignment Setting - needs to be set to get
402 * left-justified data like all other sensors.
403 */
404 .das = {
405 .addr = 0x21,
406 .mask = 0x01,
407 },
408 .drdy_irq = {
409 .int1 = {
410 .addr = 0x21,
411 .mask = 0x04,
412 },
413 .stat_drdy = {
414 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
415 .mask = 0x07,
416 },
417 },
418 .sim = {
419 .addr = 0x21,
420 .value = BIT(1),
421 },
422 .multi_read_bit = true,
423 .bootime = 2, /* guess */
424 },
425 {
426 .wai = 0x3b,
427 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
428 .sensors_supported = {
429 [0] = LIS331DL_ACCEL_DEV_NAME,
430 },
431 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
432 .odr = {
433 .addr = 0x20,
434 .mask = 0x80,
435 .odr_avl = {
436 { .hz = 100, .value = 0x00, },
437 { .hz = 400, .value = 0x01, },
438 },
439 },
440 .pw = {
441 .addr = 0x20,
442 .mask = 0x40,
443 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
444 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
445 },
446 .enable_axis = {
447 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
448 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
449 },
450 .fs = {
451 .addr = 0x20,
452 .mask = 0x20,
453 /*
454 * TODO: check these resulting gain settings, these are
455 * not in the datsheet
456 */
457 .fs_avl = {
458 [0] = {
459 .num = ST_ACCEL_FS_AVL_2G,
460 .value = 0x00,
461 .gain = IIO_G_TO_M_S_2(18000),
462 },
463 [1] = {
464 .num = ST_ACCEL_FS_AVL_8G,
465 .value = 0x01,
466 .gain = IIO_G_TO_M_S_2(72000),
467 },
468 },
469 },
470 .drdy_irq = {
471 .int1 = {
472 .addr = 0x22,
473 .mask = 0x04,
474 .addr_od = 0x22,
475 .mask_od = 0x40,
476 },
477 .int2 = {
478 .addr = 0x22,
479 .mask = 0x20,
480 .addr_od = 0x22,
481 .mask_od = 0x40,
482 },
483 .addr_ihl = 0x22,
484 .mask_ihl = 0x80,
485 .stat_drdy = {
486 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
487 .mask = 0x07,
488 },
489 },
490 .sim = {
491 .addr = 0x21,
492 .value = BIT(7),
493 },
494 .multi_read_bit = false,
495 .bootime = 2, /* guess */
496 },
497 {
498 .wai = 0x32,
499 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
500 .sensors_supported = {
501 [0] = H3LIS331DL_ACCEL_DEV_NAME,
502 },
503 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
504 .odr = {
505 .addr = 0x20,
506 .mask = 0x18,
507 .odr_avl = {
508 { .hz = 50, .value = 0x00, },
509 { .hz = 100, .value = 0x01, },
510 { .hz = 400, .value = 0x02, },
511 { .hz = 1000, .value = 0x03, },
512 },
513 },
514 .pw = {
515 .addr = 0x20,
516 .mask = 0x20,
517 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
518 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
519 },
520 .enable_axis = {
521 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
522 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
523 },
524 .fs = {
525 .addr = 0x23,
526 .mask = 0x30,
527 .fs_avl = {
528 [0] = {
529 .num = ST_ACCEL_FS_AVL_100G,
530 .value = 0x00,
531 .gain = IIO_G_TO_M_S_2(49000),
532 },
533 [1] = {
534 .num = ST_ACCEL_FS_AVL_200G,
535 .value = 0x01,
536 .gain = IIO_G_TO_M_S_2(98000),
537 },
538 [2] = {
539 .num = ST_ACCEL_FS_AVL_400G,
540 .value = 0x03,
541 .gain = IIO_G_TO_M_S_2(195000),
542 },
543 },
544 },
545 .bdu = {
546 .addr = 0x23,
547 .mask = 0x80,
548 },
549 .drdy_irq = {
550 .int1 = {
551 .addr = 0x22,
552 .mask = 0x02,
553 },
554 .int2 = {
555 .addr = 0x22,
556 .mask = 0x10,
557 },
558 .addr_ihl = 0x22,
559 .mask_ihl = 0x80,
560 },
561 .sim = {
562 .addr = 0x23,
563 .value = BIT(0),
564 },
565 .multi_read_bit = true,
566 .bootime = 2,
567 },
568 {
569 /* No WAI register present */
570 .sensors_supported = {
571 [0] = LIS3L02DQ_ACCEL_DEV_NAME,
572 },
573 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
574 .odr = {
575 .addr = 0x20,
576 .mask = 0x30,
577 .odr_avl = {
578 { .hz = 280, .value = 0x00, },
579 { .hz = 560, .value = 0x01, },
580 { .hz = 1120, .value = 0x02, },
581 { .hz = 4480, .value = 0x03, },
582 },
583 },
584 .pw = {
585 .addr = 0x20,
586 .mask = 0xc0,
587 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
588 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
589 },
590 .enable_axis = {
591 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
592 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
593 },
594 .fs = {
595 .fs_avl = {
596 [0] = {
597 .num = ST_ACCEL_FS_AVL_2G,
598 .gain = IIO_G_TO_M_S_2(488),
599 },
600 },
601 },
602 /*
603 * The part has a BDU bit but if set the data is never
604 * updated so don't set it.
605 */
606 .bdu = {
607 },
608 .drdy_irq = {
609 .int1 = {
610 .addr = 0x21,
611 .mask = 0x04,
612 },
613 .stat_drdy = {
614 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
615 .mask = 0x07,
616 },
617 },
618 .sim = {
619 .addr = 0x21,
620 .value = BIT(1),
621 },
622 .multi_read_bit = false,
623 .bootime = 2,
624 },
625 {
626 .wai = 0x33,
627 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
628 .sensors_supported = {
629 [0] = LNG2DM_ACCEL_DEV_NAME,
630 },
631 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
632 .odr = {
633 .addr = 0x20,
634 .mask = 0xf0,
635 .odr_avl = {
636 { .hz = 1, .value = 0x01, },
637 { .hz = 10, .value = 0x02, },
638 { .hz = 25, .value = 0x03, },
639 { .hz = 50, .value = 0x04, },
640 { .hz = 100, .value = 0x05, },
641 { .hz = 200, .value = 0x06, },
642 { .hz = 400, .value = 0x07, },
643 { .hz = 1600, .value = 0x08, },
644 },
645 },
646 .pw = {
647 .addr = 0x20,
648 .mask = 0xf0,
649 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
650 },
651 .enable_axis = {
652 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
653 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
654 },
655 .fs = {
656 .addr = 0x23,
657 .mask = 0x30,
658 .fs_avl = {
659 [0] = {
660 .num = ST_ACCEL_FS_AVL_2G,
661 .value = 0x00,
662 .gain = IIO_G_TO_M_S_2(15600),
663 },
664 [1] = {
665 .num = ST_ACCEL_FS_AVL_4G,
666 .value = 0x01,
667 .gain = IIO_G_TO_M_S_2(31200),
668 },
669 [2] = {
670 .num = ST_ACCEL_FS_AVL_8G,
671 .value = 0x02,
672 .gain = IIO_G_TO_M_S_2(62500),
673 },
674 [3] = {
675 .num = ST_ACCEL_FS_AVL_16G,
676 .value = 0x03,
677 .gain = IIO_G_TO_M_S_2(187500),
678 },
679 },
680 },
681 .drdy_irq = {
682 .int1 = {
683 .addr = 0x22,
684 .mask = 0x10,
685 },
686 .addr_ihl = 0x25,
687 .mask_ihl = 0x02,
688 .stat_drdy = {
689 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
690 .mask = 0x07,
691 },
692 },
693 .sim = {
694 .addr = 0x23,
695 .value = BIT(0),
696 },
697 .multi_read_bit = true,
698 .bootime = 2,
699 },
700 {
701 .wai = 0x44,
702 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
703 .sensors_supported = {
704 [0] = LIS2DW12_ACCEL_DEV_NAME,
705 },
706 .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
707 .odr = {
708 .addr = 0x20,
709 .mask = 0xf0,
710 .odr_avl = {
711 { .hz = 1, .value = 0x01, },
712 { .hz = 12, .value = 0x02, },
713 { .hz = 25, .value = 0x03, },
714 { .hz = 50, .value = 0x04, },
715 { .hz = 100, .value = 0x05, },
716 { .hz = 200, .value = 0x06, },
717 },
718 },
719 .pw = {
720 .addr = 0x20,
721 .mask = 0xf0,
722 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
723 },
724 .fs = {
725 .addr = 0x25,
726 .mask = 0x30,
727 .fs_avl = {
728 [0] = {
729 .num = ST_ACCEL_FS_AVL_2G,
730 .value = 0x00,
731 .gain = IIO_G_TO_M_S_2(976),
732 },
733 [1] = {
734 .num = ST_ACCEL_FS_AVL_4G,
735 .value = 0x01,
736 .gain = IIO_G_TO_M_S_2(1952),
737 },
738 [2] = {
739 .num = ST_ACCEL_FS_AVL_8G,
740 .value = 0x02,
741 .gain = IIO_G_TO_M_S_2(3904),
742 },
743 [3] = {
744 .num = ST_ACCEL_FS_AVL_16G,
745 .value = 0x03,
746 .gain = IIO_G_TO_M_S_2(7808),
747 },
748 },
749 },
750 .bdu = {
751 .addr = 0x21,
752 .mask = 0x08,
753 },
754 .drdy_irq = {
755 .int1 = {
756 .addr = 0x23,
757 .mask = 0x01,
758 .addr_od = 0x22,
759 .mask_od = 0x20,
760 },
761 .int2 = {
762 .addr = 0x24,
763 .mask = 0x01,
764 .addr_od = 0x22,
765 .mask_od = 0x20,
766 },
767 .addr_ihl = 0x22,
768 .mask_ihl = 0x08,
769 .stat_drdy = {
770 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
771 .mask = 0x01,
772 },
773 },
774 .sim = {
775 .addr = 0x21,
776 .value = BIT(0),
777 },
778 .multi_read_bit = false,
779 .bootime = 2,
780 },
781 {
782 .wai = 0x11,
783 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
784 .sensors_supported = {
785 [0] = LIS3DHH_ACCEL_DEV_NAME,
786 },
787 .ch = (struct iio_chan_spec *)st_accel_16bit_channels,
788 .odr = {
789 /* just ODR = 1100Hz available */
790 .odr_avl = {
791 { .hz = 1100, .value = 0x00, },
792 },
793 },
794 .pw = {
795 .addr = 0x20,
796 .mask = 0x80,
797 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
798 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
799 },
800 .fs = {
801 .fs_avl = {
802 [0] = {
803 .num = ST_ACCEL_FS_AVL_2G,
804 .gain = IIO_G_TO_M_S_2(76),
805 },
806 },
807 },
808 .bdu = {
809 .addr = 0x20,
810 .mask = 0x01,
811 },
812 .drdy_irq = {
813 .int1 = {
814 .addr = 0x21,
815 .mask = 0x80,
816 .addr_od = 0x23,
817 .mask_od = 0x04,
818 },
819 .int2 = {
820 .addr = 0x22,
821 .mask = 0x80,
822 .addr_od = 0x23,
823 .mask_od = 0x08,
824 },
825 .stat_drdy = {
826 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
827 .mask = 0x07,
828 },
829 },
830 .multi_read_bit = false,
831 .bootime = 2,
832 },
833 {
834 .wai = 0x33,
835 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
836 .sensors_supported = {
837 [0] = LIS2DE12_ACCEL_DEV_NAME,
838 },
839 .ch = (struct iio_chan_spec *)st_accel_8bit_channels,
840 .odr = {
841 .addr = 0x20,
842 .mask = 0xf0,
843 .odr_avl = {
844 { .hz = 1, .value = 0x01, },
845 { .hz = 10, .value = 0x02, },
846 { .hz = 25, .value = 0x03, },
847 { .hz = 50, .value = 0x04, },
848 { .hz = 100, .value = 0x05, },
849 { .hz = 200, .value = 0x06, },
850 { .hz = 400, .value = 0x07, },
851 { .hz = 1620, .value = 0x08, },
852 { .hz = 5376, .value = 0x09, },
853 },
854 },
855 .pw = {
856 .addr = 0x20,
857 .mask = 0xf0,
858 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
859 },
860 .enable_axis = {
861 .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
862 .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
863 },
864 .fs = {
865 .addr = 0x23,
866 .mask = 0x30,
867 .fs_avl = {
868 [0] = {
869 .num = ST_ACCEL_FS_AVL_2G,
870 .value = 0x00,
871 .gain = IIO_G_TO_M_S_2(15600),
872 },
873 [1] = {
874 .num = ST_ACCEL_FS_AVL_4G,
875 .value = 0x01,
876 .gain = IIO_G_TO_M_S_2(31200),
877 },
878 [2] = {
879 .num = ST_ACCEL_FS_AVL_8G,
880 .value = 0x02,
881 .gain = IIO_G_TO_M_S_2(62500),
882 },
883 [3] = {
884 .num = ST_ACCEL_FS_AVL_16G,
885 .value = 0x03,
886 .gain = IIO_G_TO_M_S_2(187500),
887 },
888 },
889 },
890 .drdy_irq = {
891 .int1 = {
892 .addr = 0x22,
893 .mask = 0x10,
894 },
895 .addr_ihl = 0x25,
896 .mask_ihl = 0x02,
897 .stat_drdy = {
898 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
899 .mask = 0x07,
900 },
901 },
902 .sim = {
903 .addr = 0x23,
904 .value = BIT(0),
905 },
906 .multi_read_bit = true,
907 .bootime = 2,
908 },
909 };
910
911 static int st_accel_read_raw(struct iio_dev *indio_dev,
912 struct iio_chan_spec const *ch, int *val,
913 int *val2, long mask)
914 {
915 int err;
916 struct st_sensor_data *adata = iio_priv(indio_dev);
917
918 switch (mask) {
919 case IIO_CHAN_INFO_RAW:
920 err = st_sensors_read_info_raw(indio_dev, ch, val);
921 if (err < 0)
922 goto read_error;
923
924 return IIO_VAL_INT;
925 case IIO_CHAN_INFO_SCALE:
926 *val = adata->current_fullscale->gain / 1000000;
927 *val2 = adata->current_fullscale->gain % 1000000;
928 return IIO_VAL_INT_PLUS_MICRO;
929 case IIO_CHAN_INFO_SAMP_FREQ:
930 *val = adata->odr;
931 return IIO_VAL_INT;
932 default:
933 return -EINVAL;
934 }
935
936 read_error:
937 return err;
938 }
939
940 static int st_accel_write_raw(struct iio_dev *indio_dev,
941 struct iio_chan_spec const *chan, int val, int val2, long mask)
942 {
943 int err;
944
945 switch (mask) {
946 case IIO_CHAN_INFO_SCALE: {
947 int gain;
948
949 gain = val * 1000000 + val2;
950 err = st_sensors_set_fullscale_by_gain(indio_dev, gain);
951 break;
952 }
953 case IIO_CHAN_INFO_SAMP_FREQ:
954 if (val2)
955 return -EINVAL;
956 mutex_lock(&indio_dev->mlock);
957 err = st_sensors_set_odr(indio_dev, val);
958 mutex_unlock(&indio_dev->mlock);
959 return err;
960 default:
961 return -EINVAL;
962 }
963
964 return err;
965 }
966
967 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
968 static ST_SENSORS_DEV_ATTR_SCALE_AVAIL(in_accel_scale_available);
969
970 static struct attribute *st_accel_attributes[] = {
971 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
972 &iio_dev_attr_in_accel_scale_available.dev_attr.attr,
973 NULL,
974 };
975
976 static const struct attribute_group st_accel_attribute_group = {
977 .attrs = st_accel_attributes,
978 };
979
980 static const struct iio_info accel_info = {
981 .attrs = &st_accel_attribute_group,
982 .read_raw = &st_accel_read_raw,
983 .write_raw = &st_accel_write_raw,
984 .debugfs_reg_access = &st_sensors_debugfs_reg_access,
985 };
986
987 #ifdef CONFIG_IIO_TRIGGER
988 static const struct iio_trigger_ops st_accel_trigger_ops = {
989 .set_trigger_state = ST_ACCEL_TRIGGER_SET_STATE,
990 .validate_device = st_sensors_validate_device,
991 };
992 #define ST_ACCEL_TRIGGER_OPS (&st_accel_trigger_ops)
993 #else
994 #define ST_ACCEL_TRIGGER_OPS NULL
995 #endif
996
997 static const struct iio_mount_matrix *
998 get_mount_matrix(const struct iio_dev *indio_dev,
999 const struct iio_chan_spec *chan)
1000 {
1001 struct st_sensor_data *adata = iio_priv(indio_dev);
1002
1003 return adata->mount_matrix;
1004 }
1005
1006 static const struct iio_chan_spec_ext_info mount_matrix_ext_info[] = {
1007 IIO_MOUNT_MATRIX(IIO_SHARED_BY_ALL, get_mount_matrix),
1008 { },
1009 };
1010
1011 /* Read ST-specific _ONT orientation data from ACPI and generate an
1012 * appropriate mount matrix.
1013 */
1014 static int apply_acpi_orientation(struct iio_dev *indio_dev,
1015 struct iio_chan_spec *channels)
1016 {
1017 #ifdef CONFIG_ACPI
1018 struct st_sensor_data *adata = iio_priv(indio_dev);
1019 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
1020 struct acpi_device *adev;
1021 union acpi_object *ont;
1022 union acpi_object *elements;
1023 acpi_status status;
1024 int ret = -EINVAL;
1025 unsigned int val;
1026 int i, j;
1027 int final_ont[3][3] = { { 0 }, };
1028
1029 /* For some reason, ST's _ONT translation does not apply directly
1030 * to the data read from the sensor. Another translation must be
1031 * performed first, as described by the matrix below. Perhaps
1032 * ST required this specific translation for the first product
1033 * where the device was mounted?
1034 */
1035 const int default_ont[3][3] = {
1036 { 0, 1, 0 },
1037 { -1, 0, 0 },
1038 { 0, 0, -1 },
1039 };
1040
1041
1042 adev = ACPI_COMPANION(adata->dev);
1043 if (!adev)
1044 return 0;
1045
1046 /* Read _ONT data, which should be a package of 6 integers. */
1047 status = acpi_evaluate_object(adev->handle, "_ONT", NULL, &buffer);
1048 if (status == AE_NOT_FOUND) {
1049 return 0;
1050 } else if (ACPI_FAILURE(status)) {
1051 dev_warn(&indio_dev->dev, "failed to execute _ONT: %d\n",
1052 status);
1053 return status;
1054 }
1055
1056 ont = buffer.pointer;
1057 if (ont->type != ACPI_TYPE_PACKAGE || ont->package.count != 6)
1058 goto out;
1059
1060 /* The first 3 integers provide axis order information.
1061 * e.g. 0 1 2 would indicate normal X,Y,Z ordering.
1062 * e.g. 1 0 2 indicates that data arrives in order Y,X,Z.
1063 */
1064 elements = ont->package.elements;
1065 for (i = 0; i < 3; i++) {
1066 if (elements[i].type != ACPI_TYPE_INTEGER)
1067 goto out;
1068
1069 val = elements[i].integer.value;
1070 if (val > 2)
1071 goto out;
1072
1073 /* Avoiding full matrix multiplication, we simply reorder the
1074 * columns in the default_ont matrix according to the
1075 * ordering provided by _ONT.
1076 */
1077 final_ont[0][i] = default_ont[0][val];
1078 final_ont[1][i] = default_ont[1][val];
1079 final_ont[2][i] = default_ont[2][val];
1080 }
1081
1082 /* The final 3 integers provide sign flip information.
1083 * 0 means no change, 1 means flip.
1084 * e.g. 0 0 1 means that Z data should be sign-flipped.
1085 * This is applied after the axis reordering from above.
1086 */
1087 elements += 3;
1088 for (i = 0; i < 3; i++) {
1089 if (elements[i].type != ACPI_TYPE_INTEGER)
1090 goto out;
1091
1092 val = elements[i].integer.value;
1093 if (val != 0 && val != 1)
1094 goto out;
1095 if (!val)
1096 continue;
1097
1098 /* Flip the values in the indicated column */
1099 final_ont[0][i] *= -1;
1100 final_ont[1][i] *= -1;
1101 final_ont[2][i] *= -1;
1102 }
1103
1104 /* Convert our integer matrix to a string-based iio_mount_matrix */
1105 adata->mount_matrix = devm_kmalloc(&indio_dev->dev,
1106 sizeof(*adata->mount_matrix),
1107 GFP_KERNEL);
1108 if (!adata->mount_matrix) {
1109 ret = -ENOMEM;
1110 goto out;
1111 }
1112
1113 for (i = 0; i < 3; i++) {
1114 for (j = 0; j < 3; j++) {
1115 int matrix_val = final_ont[i][j];
1116 char *str_value;
1117
1118 switch (matrix_val) {
1119 case -1:
1120 str_value = "-1";
1121 break;
1122 case 0:
1123 str_value = "0";
1124 break;
1125 case 1:
1126 str_value = "1";
1127 break;
1128 default:
1129 goto out;
1130 }
1131 adata->mount_matrix->rotation[i * 3 + j] = str_value;
1132 }
1133 }
1134
1135 /* Expose the mount matrix via ext_info */
1136 for (i = 0; i < indio_dev->num_channels; i++)
1137 channels[i].ext_info = mount_matrix_ext_info;
1138
1139 ret = 0;
1140 dev_info(&indio_dev->dev, "computed mount matrix from ACPI\n");
1141
1142 out:
1143 kfree(buffer.pointer);
1144 return ret;
1145 #else /* !CONFIG_ACPI */
1146 return 0;
1147 #endif
1148 }
1149
1150 int st_accel_common_probe(struct iio_dev *indio_dev)
1151 {
1152 struct st_sensor_data *adata = iio_priv(indio_dev);
1153 struct st_sensors_platform_data *pdata =
1154 (struct st_sensors_platform_data *)adata->dev->platform_data;
1155 int irq = adata->get_irq_data_ready(indio_dev);
1156 struct iio_chan_spec *channels;
1157 size_t channels_size;
1158 int err;
1159
1160 indio_dev->modes = INDIO_DIRECT_MODE;
1161 indio_dev->info = &accel_info;
1162 mutex_init(&adata->tb.buf_lock);
1163
1164 err = st_sensors_power_enable(indio_dev);
1165 if (err)
1166 return err;
1167
1168 err = st_sensors_check_device_support(indio_dev,
1169 ARRAY_SIZE(st_accel_sensors_settings),
1170 st_accel_sensors_settings);
1171 if (err < 0)
1172 goto st_accel_power_off;
1173
1174 adata->num_data_channels = ST_ACCEL_NUMBER_DATA_CHANNELS;
1175 adata->multiread_bit = adata->sensor_settings->multi_read_bit;
1176 indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS;
1177
1178 channels_size = indio_dev->num_channels * sizeof(struct iio_chan_spec);
1179 channels = devm_kmemdup(&indio_dev->dev,
1180 adata->sensor_settings->ch,
1181 channels_size, GFP_KERNEL);
1182 if (!channels) {
1183 err = -ENOMEM;
1184 goto st_accel_power_off;
1185 }
1186
1187 if (apply_acpi_orientation(indio_dev, channels))
1188 dev_warn(&indio_dev->dev,
1189 "failed to apply ACPI orientation data: %d\n", err);
1190
1191 indio_dev->channels = channels;
1192 adata->current_fullscale = (struct st_sensor_fullscale_avl *)
1193 &adata->sensor_settings->fs.fs_avl[0];
1194 adata->odr = adata->sensor_settings->odr.odr_avl[0].hz;
1195
1196 if (!pdata)
1197 pdata = (struct st_sensors_platform_data *)&default_accel_pdata;
1198
1199 err = st_sensors_init_sensor(indio_dev, pdata);
1200 if (err < 0)
1201 goto st_accel_power_off;
1202
1203 err = st_accel_allocate_ring(indio_dev);
1204 if (err < 0)
1205 goto st_accel_power_off;
1206
1207 if (irq > 0) {
1208 err = st_sensors_allocate_trigger(indio_dev,
1209 ST_ACCEL_TRIGGER_OPS);
1210 if (err < 0)
1211 goto st_accel_probe_trigger_error;
1212 }
1213
1214 err = iio_device_register(indio_dev);
1215 if (err)
1216 goto st_accel_device_register_error;
1217
1218 dev_info(&indio_dev->dev, "registered accelerometer %s\n",
1219 indio_dev->name);
1220
1221 return 0;
1222
1223 st_accel_device_register_error:
1224 if (irq > 0)
1225 st_sensors_deallocate_trigger(indio_dev);
1226 st_accel_probe_trigger_error:
1227 st_accel_deallocate_ring(indio_dev);
1228 st_accel_power_off:
1229 st_sensors_power_disable(indio_dev);
1230
1231 return err;
1232 }
1233 EXPORT_SYMBOL(st_accel_common_probe);
1234
1235 void st_accel_common_remove(struct iio_dev *indio_dev)
1236 {
1237 struct st_sensor_data *adata = iio_priv(indio_dev);
1238
1239 st_sensors_power_disable(indio_dev);
1240
1241 iio_device_unregister(indio_dev);
1242 if (adata->get_irq_data_ready(indio_dev) > 0)
1243 st_sensors_deallocate_trigger(indio_dev);
1244
1245 st_accel_deallocate_ring(indio_dev);
1246 }
1247 EXPORT_SYMBOL(st_accel_common_remove);
1248
1249 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
1250 MODULE_DESCRIPTION("STMicroelectronics accelerometers driver");
1251 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support