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