1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * STMicroelectronics pressures driver
4 *
5 * Copyright 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/errno.h>
14 #include <linux/types.h>
15 #include <linux/interrupt.h>
16 #include <linux/i2c.h>
17 #include <linux/gpio.h>
18 #include <linux/irq.h>
19 #include <linux/delay.h>
20 #include <linux/iio/iio.h>
21 #include <linux/iio/sysfs.h>
22 #include <linux/iio/trigger.h>
23 #include <linux/iio/buffer.h>
24 #include <asm/unaligned.h>
25
26 #include <linux/iio/common/st_sensors.h>
27 #include "st_pressure.h"
28
29 /*
30 * About determining pressure scaling factors
31 * ------------------------------------------
32 *
33 * Datasheets specify typical pressure sensitivity so that pressure is computed
34 * according to the following equation :
35 * pressure[mBar] = raw / sensitivity
36 * where :
37 * raw the 24 bits long raw sampled pressure
38 * sensitivity a scaling factor specified by the datasheet in LSB/mBar
39 *
40 * IIO ABI expects pressure to be expressed as kPascal, hence pressure should be
41 * computed according to :
42 * pressure[kPascal] = pressure[mBar] / 10
43 * = raw / (sensitivity * 10) (1)
44 *
45 * Finally, st_press_read_raw() returns pressure scaling factor as an
46 * IIO_VAL_INT_PLUS_NANO with a zero integral part and "gain" as decimal part.
47 * Therefore, from (1), "gain" becomes :
48 * gain = 10^9 / (sensitivity * 10)
49 * = 10^8 / sensitivity
50 *
51 * About determining temperature scaling factors and offsets
52 * ---------------------------------------------------------
53 *
54 * Datasheets specify typical temperature sensitivity and offset so that
55 * temperature is computed according to the following equation :
56 * temp[Celsius] = offset[Celsius] + (raw / sensitivity)
57 * where :
58 * raw the 16 bits long raw sampled temperature
59 * offset a constant specified by the datasheet in degree Celsius
60 * (sometimes zero)
61 * sensitivity a scaling factor specified by the datasheet in LSB/Celsius
62 *
63 * IIO ABI expects temperature to be expressed as milli degree Celsius such as
64 * user space should compute temperature according to :
65 * temp[mCelsius] = temp[Celsius] * 10^3
66 * = (offset[Celsius] + (raw / sensitivity)) * 10^3
67 * = ((offset[Celsius] * sensitivity) + raw) *
68 * (10^3 / sensitivity) (2)
69 *
70 * IIO ABI expects user space to apply offset and scaling factors to raw samples
71 * according to :
72 * temp[mCelsius] = (OFFSET + raw) * SCALE
73 * where :
74 * OFFSET an arbitrary constant exposed by device
75 * SCALE an arbitrary scaling factor exposed by device
76 *
77 * Matching OFFSET and SCALE with members of (2) gives :
78 * OFFSET = offset[Celsius] * sensitivity (3)
79 * SCALE = 10^3 / sensitivity (4)
80 *
81 * st_press_read_raw() returns temperature scaling factor as an
82 * IIO_VAL_FRACTIONAL with a 10^3 numerator and "gain2" as denominator.
83 * Therefore, from (3), "gain2" becomes :
84 * gain2 = sensitivity
85 *
86 * When declared within channel, i.e. for a non zero specified offset,
87 * st_press_read_raw() will return the latter as an IIO_VAL_FRACTIONAL such as :
88 * numerator = OFFSET * 10^3
89 * denominator = 10^3
90 * giving from (4):
91 * numerator = offset[Celsius] * 10^3 * sensitivity
92 * = offset[mCelsius] * gain2
93 */
94
95 #define MCELSIUS_PER_CELSIUS 1000
96
97 /* Default pressure sensitivity */
98 #define ST_PRESS_LSB_PER_MBAR 4096UL
99 #define ST_PRESS_KPASCAL_NANO_SCALE (100000000UL / \
100 ST_PRESS_LSB_PER_MBAR)
101
102 /* Default temperature sensitivity */
103 #define ST_PRESS_LSB_PER_CELSIUS 480UL
104 #define ST_PRESS_MILLI_CELSIUS_OFFSET 42500UL
105
106 /* FULLSCALE */
107 #define ST_PRESS_FS_AVL_1100MB 1100
108 #define ST_PRESS_FS_AVL_1260MB 1260
109
110 #define ST_PRESS_1_OUT_XL_ADDR 0x28
111 #define ST_TEMP_1_OUT_L_ADDR 0x2b
112
113 /* LPS001WP pressure resolution */
114 #define ST_PRESS_LPS001WP_LSB_PER_MBAR 16UL
115 /* LPS001WP temperature resolution */
116 #define ST_PRESS_LPS001WP_LSB_PER_CELSIUS 64UL
117 /* LPS001WP pressure gain */
118 #define ST_PRESS_LPS001WP_FS_AVL_PRESS_GAIN \
119 (100000000UL / ST_PRESS_LPS001WP_LSB_PER_MBAR)
120 /* LPS001WP pressure and temp L addresses */
121 #define ST_PRESS_LPS001WP_OUT_L_ADDR 0x28
122 #define ST_TEMP_LPS001WP_OUT_L_ADDR 0x2a
123
124 /* LPS25H pressure and temp L addresses */
125 #define ST_PRESS_LPS25H_OUT_XL_ADDR 0x28
126 #define ST_TEMP_LPS25H_OUT_L_ADDR 0x2b
127
128 /* LPS22HB temperature sensitivity */
129 #define ST_PRESS_LPS22HB_LSB_PER_CELSIUS 100UL
130
131 static const struct iio_chan_spec st_press_1_channels[] = {
132 {
133 .type = IIO_PRESSURE,
134 .address = ST_PRESS_1_OUT_XL_ADDR,
135 .scan_index = 0,
136 .scan_type = {
137 .sign = 's',
138 .realbits = 24,
139 .storagebits = 32,
140 .endianness = IIO_LE,
141 },
142 .info_mask_separate =
143 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
144 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
145 },
146 {
147 .type = IIO_TEMP,
148 .address = ST_TEMP_1_OUT_L_ADDR,
149 .scan_index = 1,
150 .scan_type = {
151 .sign = 's',
152 .realbits = 16,
153 .storagebits = 16,
154 .endianness = IIO_LE,
155 },
156 .info_mask_separate =
157 BIT(IIO_CHAN_INFO_RAW) |
158 BIT(IIO_CHAN_INFO_SCALE) |
159 BIT(IIO_CHAN_INFO_OFFSET),
160 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
161 },
162 IIO_CHAN_SOFT_TIMESTAMP(2)
163 };
164
165 static const struct iio_chan_spec st_press_lps001wp_channels[] = {
166 {
167 .type = IIO_PRESSURE,
168 .address = ST_PRESS_LPS001WP_OUT_L_ADDR,
169 .scan_index = 0,
170 .scan_type = {
171 .sign = 's',
172 .realbits = 16,
173 .storagebits = 16,
174 .endianness = IIO_LE,
175 },
176 .info_mask_separate =
177 BIT(IIO_CHAN_INFO_RAW) |
178 BIT(IIO_CHAN_INFO_SCALE),
179 },
180 {
181 .type = IIO_TEMP,
182 .address = ST_TEMP_LPS001WP_OUT_L_ADDR,
183 .scan_index = 1,
184 .scan_type = {
185 .sign = 's',
186 .realbits = 16,
187 .storagebits = 16,
188 .endianness = IIO_LE,
189 },
190 .info_mask_separate =
191 BIT(IIO_CHAN_INFO_RAW) |
192 BIT(IIO_CHAN_INFO_SCALE),
193 },
194 IIO_CHAN_SOFT_TIMESTAMP(2)
195 };
196
197 static const struct iio_chan_spec st_press_lps22hb_channels[] = {
198 {
199 .type = IIO_PRESSURE,
200 .address = ST_PRESS_1_OUT_XL_ADDR,
201 .scan_index = 0,
202 .scan_type = {
203 .sign = 's',
204 .realbits = 24,
205 .storagebits = 32,
206 .endianness = IIO_LE,
207 },
208 .info_mask_separate =
209 BIT(IIO_CHAN_INFO_RAW) |
210 BIT(IIO_CHAN_INFO_SCALE),
211 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
212 },
213 {
214 .type = IIO_TEMP,
215 .address = ST_TEMP_1_OUT_L_ADDR,
216 .scan_index = 1,
217 .scan_type = {
218 .sign = 's',
219 .realbits = 16,
220 .storagebits = 16,
221 .endianness = IIO_LE,
222 },
223 .info_mask_separate =
224 BIT(IIO_CHAN_INFO_RAW) |
225 BIT(IIO_CHAN_INFO_SCALE),
226 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
227 },
228 IIO_CHAN_SOFT_TIMESTAMP(2)
229 };
230
231 static const struct st_sensor_settings st_press_sensors_settings[] = {
232 {
233 /*
234 * CUSTOM VALUES FOR LPS331AP SENSOR
235 * See LPS331AP datasheet:
236 * http://www2.st.com/resource/en/datasheet/lps331ap.pdf
237 */
238 .wai = 0xbb,
239 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
240 .sensors_supported = {
241 [0] = LPS331AP_PRESS_DEV_NAME,
242 },
243 .ch = (struct iio_chan_spec *)st_press_1_channels,
244 .num_ch = ARRAY_SIZE(st_press_1_channels),
245 .odr = {
246 .addr = 0x20,
247 .mask = 0x70,
248 .odr_avl = {
249 { .hz = 1, .value = 0x01 },
250 { .hz = 7, .value = 0x05 },
251 { .hz = 13, .value = 0x06 },
252 { .hz = 25, .value = 0x07 },
253 },
254 },
255 .pw = {
256 .addr = 0x20,
257 .mask = 0x80,
258 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
259 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
260 },
261 .fs = {
262 .addr = 0x23,
263 .mask = 0x30,
264 .fs_avl = {
265 /*
266 * Pressure and temperature sensitivity values
267 * as defined in table 3 of LPS331AP datasheet.
268 */
269 [0] = {
270 .num = ST_PRESS_FS_AVL_1260MB,
271 .gain = ST_PRESS_KPASCAL_NANO_SCALE,
272 .gain2 = ST_PRESS_LSB_PER_CELSIUS,
273 },
274 },
275 },
276 .bdu = {
277 .addr = 0x20,
278 .mask = 0x04,
279 },
280 .drdy_irq = {
281 .int1 = {
282 .addr = 0x22,
283 .mask = 0x04,
284 .addr_od = 0x22,
285 .mask_od = 0x40,
286 },
287 .int2 = {
288 .addr = 0x22,
289 .mask = 0x20,
290 .addr_od = 0x22,
291 .mask_od = 0x40,
292 },
293 .addr_ihl = 0x22,
294 .mask_ihl = 0x80,
295 .stat_drdy = {
296 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
297 .mask = 0x03,
298 },
299 },
300 .sim = {
301 .addr = 0x20,
302 .value = BIT(0),
303 },
304 .multi_read_bit = true,
305 .bootime = 2,
306 },
307 {
308 /*
309 * CUSTOM VALUES FOR LPS001WP SENSOR
310 */
311 .wai = 0xba,
312 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
313 .sensors_supported = {
314 [0] = LPS001WP_PRESS_DEV_NAME,
315 },
316 .ch = (struct iio_chan_spec *)st_press_lps001wp_channels,
317 .num_ch = ARRAY_SIZE(st_press_lps001wp_channels),
318 .odr = {
319 .addr = 0x20,
320 .mask = 0x30,
321 .odr_avl = {
322 { .hz = 1, .value = 0x01 },
323 { .hz = 7, .value = 0x02 },
324 { .hz = 13, .value = 0x03 },
325 },
326 },
327 .pw = {
328 .addr = 0x20,
329 .mask = 0x40,
330 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
331 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
332 },
333 .fs = {
334 .fs_avl = {
335 /*
336 * Pressure and temperature resolution values
337 * as defined in table 3 of LPS001WP datasheet.
338 */
339 [0] = {
340 .num = ST_PRESS_FS_AVL_1100MB,
341 .gain = ST_PRESS_LPS001WP_FS_AVL_PRESS_GAIN,
342 .gain2 = ST_PRESS_LPS001WP_LSB_PER_CELSIUS,
343 },
344 },
345 },
346 .bdu = {
347 .addr = 0x20,
348 .mask = 0x04,
349 },
350 .sim = {
351 .addr = 0x20,
352 .value = BIT(0),
353 },
354 .multi_read_bit = true,
355 .bootime = 2,
356 },
357 {
358 /*
359 * CUSTOM VALUES FOR LPS25H SENSOR
360 * See LPS25H datasheet:
361 * http://www2.st.com/resource/en/datasheet/lps25h.pdf
362 */
363 .wai = 0xbd,
364 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
365 .sensors_supported = {
366 [0] = LPS25H_PRESS_DEV_NAME,
367 },
368 .ch = (struct iio_chan_spec *)st_press_1_channels,
369 .num_ch = ARRAY_SIZE(st_press_1_channels),
370 .odr = {
371 .addr = 0x20,
372 .mask = 0x70,
373 .odr_avl = {
374 { .hz = 1, .value = 0x01 },
375 { .hz = 7, .value = 0x02 },
376 { .hz = 13, .value = 0x03 },
377 { .hz = 25, .value = 0x04 },
378 },
379 },
380 .pw = {
381 .addr = 0x20,
382 .mask = 0x80,
383 .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
384 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
385 },
386 .fs = {
387 .fs_avl = {
388 /*
389 * Pressure and temperature sensitivity values
390 * as defined in table 3 of LPS25H datasheet.
391 */
392 [0] = {
393 .num = ST_PRESS_FS_AVL_1260MB,
394 .gain = ST_PRESS_KPASCAL_NANO_SCALE,
395 .gain2 = ST_PRESS_LSB_PER_CELSIUS,
396 },
397 },
398 },
399 .bdu = {
400 .addr = 0x20,
401 .mask = 0x04,
402 },
403 .drdy_irq = {
404 .int1 = {
405 .addr = 0x23,
406 .mask = 0x01,
407 .addr_od = 0x22,
408 .mask_od = 0x40,
409 },
410 .addr_ihl = 0x22,
411 .mask_ihl = 0x80,
412 .stat_drdy = {
413 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
414 .mask = 0x03,
415 },
416 },
417 .sim = {
418 .addr = 0x20,
419 .value = BIT(0),
420 },
421 .multi_read_bit = true,
422 .bootime = 2,
423 },
424 {
425 /*
426 * CUSTOM VALUES FOR LPS22HB SENSOR
427 * See LPS22HB datasheet:
428 * http://www2.st.com/resource/en/datasheet/lps22hb.pdf
429 */
430 .wai = 0xb1,
431 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
432 .sensors_supported = {
433 [0] = LPS22HB_PRESS_DEV_NAME,
434 [1] = LPS33HW_PRESS_DEV_NAME,
435 [2] = LPS35HW_PRESS_DEV_NAME,
436 },
437 .ch = (struct iio_chan_spec *)st_press_lps22hb_channels,
438 .num_ch = ARRAY_SIZE(st_press_lps22hb_channels),
439 .odr = {
440 .addr = 0x10,
441 .mask = 0x70,
442 .odr_avl = {
443 { .hz = 1, .value = 0x01 },
444 { .hz = 10, .value = 0x02 },
445 { .hz = 25, .value = 0x03 },
446 { .hz = 50, .value = 0x04 },
447 { .hz = 75, .value = 0x05 },
448 },
449 },
450 .pw = {
451 .addr = 0x10,
452 .mask = 0x70,
453 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
454 },
455 .fs = {
456 .fs_avl = {
457 /*
458 * Pressure and temperature sensitivity values
459 * as defined in table 3 of LPS22HB datasheet.
460 */
461 [0] = {
462 .num = ST_PRESS_FS_AVL_1260MB,
463 .gain = ST_PRESS_KPASCAL_NANO_SCALE,
464 .gain2 = ST_PRESS_LPS22HB_LSB_PER_CELSIUS,
465 },
466 },
467 },
468 .bdu = {
469 .addr = 0x10,
470 .mask = 0x02,
471 },
472 .drdy_irq = {
473 .int1 = {
474 .addr = 0x12,
475 .mask = 0x04,
476 .addr_od = 0x12,
477 .mask_od = 0x40,
478 },
479 .addr_ihl = 0x12,
480 .mask_ihl = 0x80,
481 .stat_drdy = {
482 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
483 .mask = 0x03,
484 },
485 },
486 .sim = {
487 .addr = 0x10,
488 .value = BIT(0),
489 },
490 .multi_read_bit = false,
491 .bootime = 2,
492 },
493 {
494 /*
495 * CUSTOM VALUES FOR LPS22HH SENSOR
496 * See LPS22HH datasheet:
497 * http://www2.st.com/resource/en/datasheet/lps22hh.pdf
498 */
499 .wai = 0xb3,
500 .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
501 .sensors_supported = {
502 [0] = LPS22HH_PRESS_DEV_NAME,
503 },
504 .ch = (struct iio_chan_spec *)st_press_lps22hb_channels,
505 .num_ch = ARRAY_SIZE(st_press_lps22hb_channels),
506 .odr = {
507 .addr = 0x10,
508 .mask = 0x70,
509 .odr_avl = {
510 { .hz = 1, .value = 0x01 },
511 { .hz = 10, .value = 0x02 },
512 { .hz = 25, .value = 0x03 },
513 { .hz = 50, .value = 0x04 },
514 { .hz = 75, .value = 0x05 },
515 { .hz = 100, .value = 0x06 },
516 { .hz = 200, .value = 0x07 },
517 },
518 },
519 .pw = {
520 .addr = 0x10,
521 .mask = 0x70,
522 .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
523 },
524 .fs = {
525 .fs_avl = {
526 /*
527 * Pressure and temperature sensitivity values
528 * as defined in table 3 of LPS22HH datasheet.
529 */
530 [0] = {
531 .num = ST_PRESS_FS_AVL_1260MB,
532 .gain = ST_PRESS_KPASCAL_NANO_SCALE,
533 .gain2 = ST_PRESS_LPS22HB_LSB_PER_CELSIUS,
534 },
535 },
536 },
537 .bdu = {
538 .addr = 0x10,
539 .mask = BIT(1),
540 },
541 .drdy_irq = {
542 .int1 = {
543 .addr = 0x12,
544 .mask = BIT(2),
545 .addr_od = 0x11,
546 .mask_od = BIT(5),
547 },
548 .addr_ihl = 0x11,
549 .mask_ihl = BIT(6),
550 .stat_drdy = {
551 .addr = ST_SENSORS_DEFAULT_STAT_ADDR,
552 .mask = 0x03,
553 },
554 },
555 .sim = {
556 .addr = 0x10,
557 .value = BIT(0),
558 },
559 .multi_read_bit = false,
560 .bootime = 2,
561 },
562 };
563
564 static int st_press_write_raw(struct iio_dev *indio_dev,
565 struct iio_chan_spec const *ch,
566 int val,
567 int val2,
568 long mask)
569 {
570 int err;
571
572 switch (mask) {
573 case IIO_CHAN_INFO_SAMP_FREQ:
574 if (val2)
575 return -EINVAL;
576 mutex_lock(&indio_dev->mlock);
577 err = st_sensors_set_odr(indio_dev, val);
578 mutex_unlock(&indio_dev->mlock);
579 return err;
580 default:
581 return -EINVAL;
582 }
583 }
584
585 static int st_press_read_raw(struct iio_dev *indio_dev,
586 struct iio_chan_spec const *ch, int *val,
587 int *val2, long mask)
588 {
589 int err;
590 struct st_sensor_data *press_data = iio_priv(indio_dev);
591
592 switch (mask) {
593 case IIO_CHAN_INFO_RAW:
594 err = st_sensors_read_info_raw(indio_dev, ch, val);
595 if (err < 0)
596 goto read_error;
597
598 return IIO_VAL_INT;
599 case IIO_CHAN_INFO_SCALE:
600 switch (ch->type) {
601 case IIO_PRESSURE:
602 *val = 0;
603 *val2 = press_data->current_fullscale->gain;
604 return IIO_VAL_INT_PLUS_NANO;
605 case IIO_TEMP:
606 *val = MCELSIUS_PER_CELSIUS;
607 *val2 = press_data->current_fullscale->gain2;
608 return IIO_VAL_FRACTIONAL;
609 default:
610 err = -EINVAL;
611 goto read_error;
612 }
613
614 case IIO_CHAN_INFO_OFFSET:
615 switch (ch->type) {
616 case IIO_TEMP:
617 *val = ST_PRESS_MILLI_CELSIUS_OFFSET *
618 press_data->current_fullscale->gain2;
619 *val2 = MCELSIUS_PER_CELSIUS;
620 break;
621 default:
622 err = -EINVAL;
623 goto read_error;
624 }
625
626 return IIO_VAL_FRACTIONAL;
627 case IIO_CHAN_INFO_SAMP_FREQ:
628 *val = press_data->odr;
629 return IIO_VAL_INT;
630 default:
631 return -EINVAL;
632 }
633
634 read_error:
635 return err;
636 }
637
638 static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();
639
640 static struct attribute *st_press_attributes[] = {
641 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
642 NULL,
643 };
644
645 static const struct attribute_group st_press_attribute_group = {
646 .attrs = st_press_attributes,
647 };
648
649 static const struct iio_info press_info = {
650 .attrs = &st_press_attribute_group,
651 .read_raw = &st_press_read_raw,
652 .write_raw = &st_press_write_raw,
653 .debugfs_reg_access = &st_sensors_debugfs_reg_access,
654 };
655
656 #ifdef CONFIG_IIO_TRIGGER
657 static const struct iio_trigger_ops st_press_trigger_ops = {
658 .set_trigger_state = ST_PRESS_TRIGGER_SET_STATE,
659 .validate_device = st_sensors_validate_device,
660 };
661 #define ST_PRESS_TRIGGER_OPS (&st_press_trigger_ops)
662 #else
663 #define ST_PRESS_TRIGGER_OPS NULL
664 #endif
665
666 /*
667 * st_press_get_settings() - get sensor settings from device name
668 * @name: device name buffer reference.
669 *
670 * Return: valid reference on success, NULL otherwise.
671 */
672 const struct st_sensor_settings *st_press_get_settings(const char *name)
673 {
674 int index = st_sensors_get_settings_index(name,
675 st_press_sensors_settings,
676 ARRAY_SIZE(st_press_sensors_settings));
677 if (index < 0)
678 return NULL;
679
680 return &st_press_sensors_settings[index];
681 }
682 EXPORT_SYMBOL(st_press_get_settings);
683
684 int st_press_common_probe(struct iio_dev *indio_dev)
685 {
686 struct st_sensor_data *press_data = iio_priv(indio_dev);
687 struct st_sensors_platform_data *pdata =
688 (struct st_sensors_platform_data *)press_data->dev->platform_data;
689 int err;
690
691 indio_dev->modes = INDIO_DIRECT_MODE;
692 indio_dev->info = &press_info;
693
694 err = st_sensors_power_enable(indio_dev);
695 if (err)
696 return err;
697
698 err = st_sensors_verify_id(indio_dev);
699 if (err < 0)
700 goto st_press_power_off;
701
702 /*
703 * Skip timestamping channel while declaring available channels to
704 * common st_sensor layer. Look at st_sensors_get_buffer_element() to
705 * see how timestamps are explicitly pushed as last samples block
706 * element.
707 */
708 press_data->num_data_channels = press_data->sensor_settings->num_ch - 1;
709 indio_dev->channels = press_data->sensor_settings->ch;
710 indio_dev->num_channels = press_data->sensor_settings->num_ch;
711
712 press_data->current_fullscale =
713 (struct st_sensor_fullscale_avl *)
714 &press_data->sensor_settings->fs.fs_avl[0];
715
716 press_data->odr = press_data->sensor_settings->odr.odr_avl[0].hz;
717
718 /* Some devices don't support a data ready pin. */
719 if (!pdata && (press_data->sensor_settings->drdy_irq.int1.addr ||
720 press_data->sensor_settings->drdy_irq.int2.addr))
721 pdata = (struct st_sensors_platform_data *)&default_press_pdata;
722
723 err = st_sensors_init_sensor(indio_dev, pdata);
724 if (err < 0)
725 goto st_press_power_off;
726
727 err = st_press_allocate_ring(indio_dev);
728 if (err < 0)
729 goto st_press_power_off;
730
731 if (press_data->irq > 0) {
732 err = st_sensors_allocate_trigger(indio_dev,
733 ST_PRESS_TRIGGER_OPS);
734 if (err < 0)
735 goto st_press_probe_trigger_error;
736 }
737
738 err = iio_device_register(indio_dev);
739 if (err)
740 goto st_press_device_register_error;
741
742 dev_info(&indio_dev->dev, "registered pressure sensor %s\n",
743 indio_dev->name);
744
745 return err;
746
747 st_press_device_register_error:
748 if (press_data->irq > 0)
749 st_sensors_deallocate_trigger(indio_dev);
750 st_press_probe_trigger_error:
751 st_press_deallocate_ring(indio_dev);
752 st_press_power_off:
753 st_sensors_power_disable(indio_dev);
754
755 return err;
756 }
757 EXPORT_SYMBOL(st_press_common_probe);
758
759 void st_press_common_remove(struct iio_dev *indio_dev)
760 {
761 struct st_sensor_data *press_data = iio_priv(indio_dev);
762
763 st_sensors_power_disable(indio_dev);
764
765 iio_device_unregister(indio_dev);
766 if (press_data->irq > 0)
767 st_sensors_deallocate_trigger(indio_dev);
768
769 st_press_deallocate_ring(indio_dev);
770 }
771 EXPORT_SYMBOL(st_press_common_remove);
772
773 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
774 MODULE_DESCRIPTION("STMicroelectronics pressures driver");
775 MODULE_LICENSE("GPL v2");