st_pressure_core.c 17.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
/*
 * STMicroelectronics pressures driver
 *
 * Copyright 2013 STMicroelectronics Inc.
 *
 * Denis Ciocca <denis.ciocca@st.com>
 *
 * Licensed under the GPL-2.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/mutex.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/irq.h>
#include <linux/delay.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/trigger.h>
#include <linux/iio/buffer.h>
#include <asm/unaligned.h>

#include <linux/iio/common/st_sensors.h>
#include "st_pressure.h"

31 32 33
#define MCELSIUS_PER_CELSIUS			1000

/* Default pressure sensitivity */
34 35 36
#define ST_PRESS_LSB_PER_MBAR			4096UL
#define ST_PRESS_KPASCAL_NANO_SCALE		(100000000UL / \
						 ST_PRESS_LSB_PER_MBAR)
37 38

/* Default temperature sensitivity */
39
#define ST_PRESS_LSB_PER_CELSIUS		480UL
40 41
#define ST_PRESS_MILLI_CELSIUS_OFFSET		42500UL

42 43 44
#define ST_PRESS_NUMBER_DATA_CHANNELS		1

/* FULLSCALE */
45
#define ST_PRESS_FS_AVL_1100MB			1100
46 47
#define ST_PRESS_FS_AVL_1260MB			1260

48 49 50
#define ST_PRESS_1_OUT_XL_ADDR			0x28
#define ST_TEMP_1_OUT_L_ADDR			0x2b

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
/* CUSTOM VALUES FOR LPS331AP SENSOR */
#define ST_PRESS_LPS331AP_WAI_EXP		0xbb
#define ST_PRESS_LPS331AP_ODR_ADDR		0x20
#define ST_PRESS_LPS331AP_ODR_MASK		0x70
#define ST_PRESS_LPS331AP_ODR_AVL_1HZ_VAL	0x01
#define ST_PRESS_LPS331AP_ODR_AVL_7HZ_VAL	0x05
#define ST_PRESS_LPS331AP_ODR_AVL_13HZ_VAL	0x06
#define ST_PRESS_LPS331AP_ODR_AVL_25HZ_VAL	0x07
#define ST_PRESS_LPS331AP_PW_ADDR		0x20
#define ST_PRESS_LPS331AP_PW_MASK		0x80
#define ST_PRESS_LPS331AP_FS_ADDR		0x23
#define ST_PRESS_LPS331AP_FS_MASK		0x30
#define ST_PRESS_LPS331AP_BDU_ADDR		0x20
#define ST_PRESS_LPS331AP_BDU_MASK		0x04
#define ST_PRESS_LPS331AP_DRDY_IRQ_ADDR		0x22
#define ST_PRESS_LPS331AP_DRDY_IRQ_INT1_MASK	0x04
#define ST_PRESS_LPS331AP_DRDY_IRQ_INT2_MASK	0x20
68 69
#define ST_PRESS_LPS331AP_IHL_IRQ_ADDR		0x22
#define ST_PRESS_LPS331AP_IHL_IRQ_MASK		0x80
70 71
#define ST_PRESS_LPS331AP_OD_IRQ_ADDR		0x22
#define ST_PRESS_LPS331AP_OD_IRQ_MASK		0x40
72
#define ST_PRESS_LPS331AP_MULTIREAD_BIT		true
73

74
/* CUSTOM VALUES FOR LPS001WP SENSOR */
75 76 77 78 79 80

/* LPS001WP pressure resolution */
#define ST_PRESS_LPS001WP_LSB_PER_MBAR		16UL
/* LPS001WP temperature resolution */
#define ST_PRESS_LPS001WP_LSB_PER_CELSIUS	64UL

81 82 83 84 85 86 87 88
#define ST_PRESS_LPS001WP_WAI_EXP		0xba
#define ST_PRESS_LPS001WP_ODR_ADDR		0x20
#define ST_PRESS_LPS001WP_ODR_MASK		0x30
#define ST_PRESS_LPS001WP_ODR_AVL_1HZ_VAL	0x01
#define ST_PRESS_LPS001WP_ODR_AVL_7HZ_VAL	0x02
#define ST_PRESS_LPS001WP_ODR_AVL_13HZ_VAL	0x03
#define ST_PRESS_LPS001WP_PW_ADDR		0x20
#define ST_PRESS_LPS001WP_PW_MASK		0x40
89 90
#define ST_PRESS_LPS001WP_FS_AVL_PRESS_GAIN \
	(100000000UL / ST_PRESS_LPS001WP_LSB_PER_MBAR)
91 92 93 94 95 96
#define ST_PRESS_LPS001WP_BDU_ADDR		0x20
#define ST_PRESS_LPS001WP_BDU_MASK		0x04
#define ST_PRESS_LPS001WP_MULTIREAD_BIT		true
#define ST_PRESS_LPS001WP_OUT_L_ADDR		0x28
#define ST_TEMP_LPS001WP_OUT_L_ADDR		0x2a

97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
/* CUSTOM VALUES FOR LPS25H SENSOR */
#define ST_PRESS_LPS25H_WAI_EXP			0xbd
#define ST_PRESS_LPS25H_ODR_ADDR		0x20
#define ST_PRESS_LPS25H_ODR_MASK		0x70
#define ST_PRESS_LPS25H_ODR_AVL_1HZ_VAL		0x01
#define ST_PRESS_LPS25H_ODR_AVL_7HZ_VAL		0x02
#define ST_PRESS_LPS25H_ODR_AVL_13HZ_VAL	0x03
#define ST_PRESS_LPS25H_ODR_AVL_25HZ_VAL	0x04
#define ST_PRESS_LPS25H_PW_ADDR			0x20
#define ST_PRESS_LPS25H_PW_MASK			0x80
#define ST_PRESS_LPS25H_BDU_ADDR		0x20
#define ST_PRESS_LPS25H_BDU_MASK		0x04
#define ST_PRESS_LPS25H_DRDY_IRQ_ADDR		0x23
#define ST_PRESS_LPS25H_DRDY_IRQ_INT1_MASK	0x01
#define ST_PRESS_LPS25H_DRDY_IRQ_INT2_MASK	0x10
112 113
#define ST_PRESS_LPS25H_IHL_IRQ_ADDR		0x22
#define ST_PRESS_LPS25H_IHL_IRQ_MASK		0x80
114 115
#define ST_PRESS_LPS25H_OD_IRQ_ADDR		0x22
#define ST_PRESS_LPS25H_OD_IRQ_MASK		0x40
116 117 118 119
#define ST_PRESS_LPS25H_MULTIREAD_BIT		true
#define ST_PRESS_LPS25H_OUT_XL_ADDR		0x28
#define ST_TEMP_LPS25H_OUT_L_ADDR		0x2b

120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
/* CUSTOM VALUES FOR LPS22HB SENSOR */
#define ST_PRESS_LPS22HB_WAI_EXP		0xb1
#define ST_PRESS_LPS22HB_ODR_ADDR		0x10
#define ST_PRESS_LPS22HB_ODR_MASK		0x70
#define ST_PRESS_LPS22HB_ODR_AVL_1HZ_VAL	0x01
#define ST_PRESS_LPS22HB_ODR_AVL_10HZ_VAL	0x02
#define ST_PRESS_LPS22HB_ODR_AVL_25HZ_VAL	0x03
#define ST_PRESS_LPS22HB_ODR_AVL_50HZ_VAL	0x04
#define ST_PRESS_LPS22HB_ODR_AVL_75HZ_VAL	0x05
#define ST_PRESS_LPS22HB_PW_ADDR		0x10
#define ST_PRESS_LPS22HB_PW_MASK		0x70
#define ST_PRESS_LPS22HB_BDU_ADDR		0x10
#define ST_PRESS_LPS22HB_BDU_MASK		0x02
#define ST_PRESS_LPS22HB_DRDY_IRQ_ADDR		0x12
#define ST_PRESS_LPS22HB_DRDY_IRQ_INT1_MASK	0x04
#define ST_PRESS_LPS22HB_DRDY_IRQ_INT2_MASK	0x08
#define ST_PRESS_LPS22HB_IHL_IRQ_ADDR		0x12
#define ST_PRESS_LPS22HB_IHL_IRQ_MASK		0x80
#define ST_PRESS_LPS22HB_MULTIREAD_BIT		true

140
static const struct iio_chan_spec st_press_1_channels[] = {
141 142 143
	{
		.type = IIO_PRESSURE,
		.channel2 = IIO_NO_MOD,
144
		.address = ST_PRESS_1_OUT_XL_ADDR,
145 146 147 148
		.scan_index = ST_SENSORS_SCAN_X,
		.scan_type = {
			.sign = 'u',
			.realbits = 24,
149
			.storagebits = 32,
150 151 152
			.endianness = IIO_LE,
		},
		.info_mask_separate =
153
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
154 155 156 157 158
		.modified = 0,
	},
	{
		.type = IIO_TEMP,
		.channel2 = IIO_NO_MOD,
159
		.address = ST_TEMP_1_OUT_L_ADDR,
160 161 162 163 164 165 166 167 168 169 170 171 172
		.scan_index = -1,
		.scan_type = {
			.sign = 'u',
			.realbits = 16,
			.storagebits = 16,
			.endianness = IIO_LE,
		},
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) |
			BIT(IIO_CHAN_INFO_SCALE) |
			BIT(IIO_CHAN_INFO_OFFSET),
		.modified = 0,
	},
173 174 175
	IIO_CHAN_SOFT_TIMESTAMP(1)
};

176 177 178 179 180 181 182 183 184 185 186 187
static const struct iio_chan_spec st_press_lps001wp_channels[] = {
	{
		.type = IIO_PRESSURE,
		.channel2 = IIO_NO_MOD,
		.address = ST_PRESS_LPS001WP_OUT_L_ADDR,
		.scan_index = ST_SENSORS_SCAN_X,
		.scan_type = {
			.sign = 'u',
			.realbits = 16,
			.storagebits = 16,
			.endianness = IIO_LE,
		},
188 189 190
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) |
			BIT(IIO_CHAN_INFO_SCALE),
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205
		.modified = 0,
	},
	{
		.type = IIO_TEMP,
		.channel2 = IIO_NO_MOD,
		.address = ST_TEMP_LPS001WP_OUT_L_ADDR,
		.scan_index = -1,
		.scan_type = {
			.sign = 'u',
			.realbits = 16,
			.storagebits = 16,
			.endianness = IIO_LE,
		},
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) |
206
			BIT(IIO_CHAN_INFO_SCALE),
207 208 209 210 211
		.modified = 0,
	},
	IIO_CHAN_SOFT_TIMESTAMP(1)
};

212 213 214 215 216 217 218 219 220
static const struct iio_chan_spec st_press_lps22hb_channels[] = {
	{
		.type = IIO_PRESSURE,
		.channel2 = IIO_NO_MOD,
		.address = ST_PRESS_1_OUT_XL_ADDR,
		.scan_index = 0,
		.scan_type = {
			.sign = 'u',
			.realbits = 24,
221
			.storagebits = 32,
222 223 224 225 226 227 228 229 230 231 232
			.endianness = IIO_LE,
		},
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) |
			BIT(IIO_CHAN_INFO_SCALE),
		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
		.modified = 0,
	},
	IIO_CHAN_SOFT_TIMESTAMP(1)
};

233
static const struct st_sensor_settings st_press_sensors_settings[] = {
234
	{
235
		.wai = ST_PRESS_LPS331AP_WAI_EXP,
236
		.wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
237 238 239
		.sensors_supported = {
			[0] = LPS331AP_PRESS_DEV_NAME,
		},
240 241
		.ch = (struct iio_chan_spec *)st_press_1_channels,
		.num_ch = ARRAY_SIZE(st_press_1_channels),
242
		.odr = {
243 244
			.addr = ST_PRESS_LPS331AP_ODR_ADDR,
			.mask = ST_PRESS_LPS331AP_ODR_MASK,
245
			.odr_avl = {
246 247 248 249
				{ 1, ST_PRESS_LPS331AP_ODR_AVL_1HZ_VAL, },
				{ 7, ST_PRESS_LPS331AP_ODR_AVL_7HZ_VAL, },
				{ 13, ST_PRESS_LPS331AP_ODR_AVL_13HZ_VAL, },
				{ 25, ST_PRESS_LPS331AP_ODR_AVL_25HZ_VAL, },
250 251 252
			},
		},
		.pw = {
253 254
			.addr = ST_PRESS_LPS331AP_PW_ADDR,
			.mask = ST_PRESS_LPS331AP_PW_MASK,
255 256 257 258
			.value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
			.value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
		},
		.fs = {
259 260
			.addr = ST_PRESS_LPS331AP_FS_ADDR,
			.mask = ST_PRESS_LPS331AP_FS_MASK,
261
			.fs_avl = {
262 263 264 265
				/*
				 * Pressure and temperature sensitivity values
				 * as defined in table 3 of LPS331AP datasheet.
				 */
266 267
				[0] = {
					.num = ST_PRESS_FS_AVL_1260MB,
268 269
					.gain = ST_PRESS_KPASCAL_NANO_SCALE,
					.gain2 = ST_PRESS_LSB_PER_CELSIUS,
270 271 272 273
				},
			},
		},
		.bdu = {
274 275
			.addr = ST_PRESS_LPS331AP_BDU_ADDR,
			.mask = ST_PRESS_LPS331AP_BDU_MASK,
276 277
		},
		.drdy_irq = {
278 279 280
			.addr = ST_PRESS_LPS331AP_DRDY_IRQ_ADDR,
			.mask_int1 = ST_PRESS_LPS331AP_DRDY_IRQ_INT1_MASK,
			.mask_int2 = ST_PRESS_LPS331AP_DRDY_IRQ_INT2_MASK,
281 282
			.addr_ihl = ST_PRESS_LPS331AP_IHL_IRQ_ADDR,
			.mask_ihl = ST_PRESS_LPS331AP_IHL_IRQ_MASK,
283 284
			.addr_od = ST_PRESS_LPS331AP_OD_IRQ_ADDR,
			.mask_od = ST_PRESS_LPS331AP_OD_IRQ_MASK,
285
			.addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
286
		},
287
		.multi_read_bit = ST_PRESS_LPS331AP_MULTIREAD_BIT,
288 289
		.bootime = 2,
	},
290 291
	{
		.wai = ST_PRESS_LPS001WP_WAI_EXP,
292
		.wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
		.sensors_supported = {
			[0] = LPS001WP_PRESS_DEV_NAME,
		},
		.ch = (struct iio_chan_spec *)st_press_lps001wp_channels,
		.num_ch = ARRAY_SIZE(st_press_lps001wp_channels),
		.odr = {
			.addr = ST_PRESS_LPS001WP_ODR_ADDR,
			.mask = ST_PRESS_LPS001WP_ODR_MASK,
			.odr_avl = {
				{ 1, ST_PRESS_LPS001WP_ODR_AVL_1HZ_VAL, },
				{ 7, ST_PRESS_LPS001WP_ODR_AVL_7HZ_VAL, },
				{ 13, ST_PRESS_LPS001WP_ODR_AVL_13HZ_VAL, },
			},
		},
		.pw = {
			.addr = ST_PRESS_LPS001WP_PW_ADDR,
			.mask = ST_PRESS_LPS001WP_PW_MASK,
			.value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
			.value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
		},
		.fs = {
314 315 316 317 318 319 320 321 322 323 324
			.fs_avl = {
				/*
				 * Pressure and temperature resolution values
				 * as defined in table 3 of LPS001WP datasheet.
				 */
				[0] = {
					.num = ST_PRESS_FS_AVL_1100MB,
					.gain = ST_PRESS_LPS001WP_FS_AVL_PRESS_GAIN,
					.gain2 = ST_PRESS_LPS001WP_LSB_PER_CELSIUS,
				},
			},
325 326 327 328 329 330 331 332 333 334 335
		},
		.bdu = {
			.addr = ST_PRESS_LPS001WP_BDU_ADDR,
			.mask = ST_PRESS_LPS001WP_BDU_MASK,
		},
		.drdy_irq = {
			.addr = 0,
		},
		.multi_read_bit = ST_PRESS_LPS001WP_MULTIREAD_BIT,
		.bootime = 2,
	},
336 337
	{
		.wai = ST_PRESS_LPS25H_WAI_EXP,
338
		.wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
		.sensors_supported = {
			[0] = LPS25H_PRESS_DEV_NAME,
		},
		.ch = (struct iio_chan_spec *)st_press_1_channels,
		.num_ch = ARRAY_SIZE(st_press_1_channels),
		.odr = {
			.addr = ST_PRESS_LPS25H_ODR_ADDR,
			.mask = ST_PRESS_LPS25H_ODR_MASK,
			.odr_avl = {
				{ 1, ST_PRESS_LPS25H_ODR_AVL_1HZ_VAL, },
				{ 7, ST_PRESS_LPS25H_ODR_AVL_7HZ_VAL, },
				{ 13, ST_PRESS_LPS25H_ODR_AVL_13HZ_VAL, },
				{ 25, ST_PRESS_LPS25H_ODR_AVL_25HZ_VAL, },
			},
		},
		.pw = {
			.addr = ST_PRESS_LPS25H_PW_ADDR,
			.mask = ST_PRESS_LPS25H_PW_MASK,
			.value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
			.value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
		},
		.fs = {
			.fs_avl = {
362 363 364 365
				/*
				 * Pressure and temperature sensitivity values
				 * as defined in table 3 of LPS25H datasheet.
				 */
366 367
				[0] = {
					.num = ST_PRESS_FS_AVL_1260MB,
368 369
					.gain = ST_PRESS_KPASCAL_NANO_SCALE,
					.gain2 = ST_PRESS_LSB_PER_CELSIUS,
370 371 372 373 374 375 376 377 378 379 380
				},
			},
		},
		.bdu = {
			.addr = ST_PRESS_LPS25H_BDU_ADDR,
			.mask = ST_PRESS_LPS25H_BDU_MASK,
		},
		.drdy_irq = {
			.addr = ST_PRESS_LPS25H_DRDY_IRQ_ADDR,
			.mask_int1 = ST_PRESS_LPS25H_DRDY_IRQ_INT1_MASK,
			.mask_int2 = ST_PRESS_LPS25H_DRDY_IRQ_INT2_MASK,
381 382
			.addr_ihl = ST_PRESS_LPS25H_IHL_IRQ_ADDR,
			.mask_ihl = ST_PRESS_LPS25H_IHL_IRQ_MASK,
383 384
			.addr_od = ST_PRESS_LPS25H_OD_IRQ_ADDR,
			.mask_od = ST_PRESS_LPS25H_OD_IRQ_MASK,
385
			.addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
386 387 388 389
		},
		.multi_read_bit = ST_PRESS_LPS25H_MULTIREAD_BIT,
		.bootime = 2,
	},
390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
	{
		.wai = ST_PRESS_LPS22HB_WAI_EXP,
		.wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
		.sensors_supported = {
			[0] = LPS22HB_PRESS_DEV_NAME,
		},
		.ch = (struct iio_chan_spec *)st_press_lps22hb_channels,
		.num_ch = ARRAY_SIZE(st_press_lps22hb_channels),
		.odr = {
			.addr = ST_PRESS_LPS22HB_ODR_ADDR,
			.mask = ST_PRESS_LPS22HB_ODR_MASK,
			.odr_avl = {
				{ 1, ST_PRESS_LPS22HB_ODR_AVL_1HZ_VAL, },
				{ 10, ST_PRESS_LPS22HB_ODR_AVL_10HZ_VAL, },
				{ 25, ST_PRESS_LPS22HB_ODR_AVL_25HZ_VAL, },
				{ 50, ST_PRESS_LPS22HB_ODR_AVL_50HZ_VAL, },
				{ 75, ST_PRESS_LPS22HB_ODR_AVL_75HZ_VAL, },
			},
		},
		.pw = {
			.addr = ST_PRESS_LPS22HB_PW_ADDR,
			.mask = ST_PRESS_LPS22HB_PW_MASK,
			.value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
		},
		.fs = {
			.fs_avl = {
				[0] = {
					.num = ST_PRESS_FS_AVL_1260MB,
					.gain = ST_PRESS_KPASCAL_NANO_SCALE,
				},
			},
		},
		.bdu = {
			.addr = ST_PRESS_LPS22HB_BDU_ADDR,
			.mask = ST_PRESS_LPS22HB_BDU_MASK,
		},
		.drdy_irq = {
			.addr = ST_PRESS_LPS22HB_DRDY_IRQ_ADDR,
			.mask_int1 = ST_PRESS_LPS22HB_DRDY_IRQ_INT1_MASK,
			.mask_int2 = ST_PRESS_LPS22HB_DRDY_IRQ_INT2_MASK,
			.addr_ihl = ST_PRESS_LPS22HB_IHL_IRQ_ADDR,
			.mask_ihl = ST_PRESS_LPS22HB_IHL_IRQ_MASK,
		},
		.multi_read_bit = ST_PRESS_LPS22HB_MULTIREAD_BIT,
	},
435 436
};

437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457
static int st_press_write_raw(struct iio_dev *indio_dev,
			      struct iio_chan_spec const *ch,
			      int val,
			      int val2,
			      long mask)
{
	int err;

	switch (mask) {
	case IIO_CHAN_INFO_SAMP_FREQ:
		if (val2)
			return -EINVAL;
		mutex_lock(&indio_dev->mlock);
		err = st_sensors_set_odr(indio_dev, val);
		mutex_unlock(&indio_dev->mlock);
		return err;
	default:
		return -EINVAL;
	}
}

458 459 460 461 462
static int st_press_read_raw(struct iio_dev *indio_dev,
			struct iio_chan_spec const *ch, int *val,
							int *val2, long mask)
{
	int err;
463
	struct st_sensor_data *press_data = iio_priv(indio_dev);
464 465 466 467 468 469 470 471 472 473 474

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		err = st_sensors_read_info_raw(indio_dev, ch, val);
		if (err < 0)
			goto read_error;

		return IIO_VAL_INT;
	case IIO_CHAN_INFO_SCALE:
		switch (ch->type) {
		case IIO_PRESSURE:
475
			*val = 0;
476
			*val2 = press_data->current_fullscale->gain;
477
			return IIO_VAL_INT_PLUS_NANO;
478
		case IIO_TEMP:
479
			*val = MCELSIUS_PER_CELSIUS;
480
			*val2 = press_data->current_fullscale->gain2;
481
			return IIO_VAL_FRACTIONAL;
482 483 484 485 486 487 488 489
		default:
			err = -EINVAL;
			goto read_error;
		}

	case IIO_CHAN_INFO_OFFSET:
		switch (ch->type) {
		case IIO_TEMP:
490 491 492
			*val = ST_PRESS_MILLI_CELSIUS_OFFSET *
			       press_data->current_fullscale->gain2;
			*val2 = MCELSIUS_PER_CELSIUS;
493 494 495 496 497 498 499
			break;
		default:
			err = -EINVAL;
			goto read_error;
		}

		return IIO_VAL_FRACTIONAL;
500
	case IIO_CHAN_INFO_SAMP_FREQ:
501
		*val = press_data->odr;
502
		return IIO_VAL_INT;
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
	default:
		return -EINVAL;
	}

read_error:
	return err;
}

static ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL();

static struct attribute *st_press_attributes[] = {
	&iio_dev_attr_sampling_frequency_available.dev_attr.attr,
	NULL,
};

static const struct attribute_group st_press_attribute_group = {
	.attrs = st_press_attributes,
};

static const struct iio_info press_info = {
	.driver_module = THIS_MODULE,
	.attrs = &st_press_attribute_group,
	.read_raw = &st_press_read_raw,
526
	.write_raw = &st_press_write_raw,
527
	.debugfs_reg_access = &st_sensors_debugfs_reg_access,
528 529 530 531 532 533
};

#ifdef CONFIG_IIO_TRIGGER
static const struct iio_trigger_ops st_press_trigger_ops = {
	.owner = THIS_MODULE,
	.set_trigger_state = ST_PRESS_TRIGGER_SET_STATE,
534
	.validate_device = st_sensors_validate_device,
535 536 537 538 539 540
};
#define ST_PRESS_TRIGGER_OPS (&st_press_trigger_ops)
#else
#define ST_PRESS_TRIGGER_OPS NULL
#endif

541
int st_press_common_probe(struct iio_dev *indio_dev)
542
{
543 544
	struct st_sensor_data *press_data = iio_priv(indio_dev);
	int irq = press_data->get_irq_data_ready(indio_dev);
545
	int err;
546 547 548

	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->info = &press_info;
549
	mutex_init(&press_data->tb.buf_lock);
550

551 552 553
	err = st_sensors_power_enable(indio_dev);
	if (err)
		return err;
554

555
	err = st_sensors_check_device_support(indio_dev,
556 557
					ARRAY_SIZE(st_press_sensors_settings),
					st_press_sensors_settings);
558
	if (err < 0)
559
		goto st_press_power_off;
560

561 562 563 564
	press_data->num_data_channels = ST_PRESS_NUMBER_DATA_CHANNELS;
	press_data->multiread_bit = press_data->sensor_settings->multi_read_bit;
	indio_dev->channels = press_data->sensor_settings->ch;
	indio_dev->num_channels = press_data->sensor_settings->num_ch;
565

566 567 568
	press_data->current_fullscale =
		(struct st_sensor_fullscale_avl *)
			&press_data->sensor_settings->fs.fs_avl[0];
569

570
	press_data->odr = press_data->sensor_settings->odr.odr_avl[0].hz;
571

572
	/* Some devices don't support a data ready pin. */
573 574 575
	if (!press_data->dev->platform_data &&
				press_data->sensor_settings->drdy_irq.addr)
		press_data->dev->platform_data =
576 577
			(struct st_sensors_platform_data *)&default_press_pdata;

578
	err = st_sensors_init_sensor(indio_dev, press_data->dev->platform_data);
579
	if (err < 0)
580
		goto st_press_power_off;
581

582 583
	err = st_press_allocate_ring(indio_dev);
	if (err < 0)
584
		goto st_press_power_off;
585

586
	if (irq > 0) {
587
		err = st_sensors_allocate_trigger(indio_dev,
588
						  ST_PRESS_TRIGGER_OPS);
589 590 591 592 593 594 595 596
		if (err < 0)
			goto st_press_probe_trigger_error;
	}

	err = iio_device_register(indio_dev);
	if (err)
		goto st_press_device_register_error;

597 598 599
	dev_info(&indio_dev->dev, "registered pressure sensor %s\n",
		 indio_dev->name);

600 601 602
	return err;

st_press_device_register_error:
603
	if (irq > 0)
604 605
		st_sensors_deallocate_trigger(indio_dev);
st_press_probe_trigger_error:
606
	st_press_deallocate_ring(indio_dev);
607 608
st_press_power_off:
	st_sensors_power_disable(indio_dev);
609

610 611 612 613 614 615
	return err;
}
EXPORT_SYMBOL(st_press_common_probe);

void st_press_common_remove(struct iio_dev *indio_dev)
{
616
	struct st_sensor_data *press_data = iio_priv(indio_dev);
617

618
	st_sensors_power_disable(indio_dev);
619

620
	iio_device_unregister(indio_dev);
621
	if (press_data->get_irq_data_ready(indio_dev) > 0)
622
		st_sensors_deallocate_trigger(indio_dev);
623 624

	st_press_deallocate_ring(indio_dev);
625 626 627 628 629 630
}
EXPORT_SYMBOL(st_press_common_remove);

MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
MODULE_DESCRIPTION("STMicroelectronics pressures driver");
MODULE_LICENSE("GPL v2");