[linux-2.6-block.git] / drivers / iio / pressure / ms5611_core.c

/*
 * MS5611 pressure and temperature sensor driver
 *
 * Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Data sheet:
 *  http://www.meas-spec.com/downloads/MS5611-01BA03.pdf
 *  http://www.meas-spec.com/downloads/MS5607-02BA03.pdf
 *
 */

#include <linux/module.h>
#include <linux/iio/iio.h>
#include <linux/delay.h>
#include <linux/regulator/consumer.h>

#include <linux/iio/sysfs.h>
#include <linux/iio/buffer.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/iio/trigger_consumer.h>
#include "ms5611.h"

#define MS5611_INIT_OSR(_cmd, _conv_usec, _rate) \
	{ .cmd = _cmd, .conv_usec = _conv_usec, .rate = _rate }

static const struct ms5611_osr ms5611_avail_pressure_osr[] = {
	MS5611_INIT_OSR(0x40, 600,  256),
	MS5611_INIT_OSR(0x42, 1170, 512),
	MS5611_INIT_OSR(0x44, 2280, 1024),
	MS5611_INIT_OSR(0x46, 4540, 2048),
	MS5611_INIT_OSR(0x48, 9040, 4096)
};

static const struct ms5611_osr ms5611_avail_temp_osr[] = {
	MS5611_INIT_OSR(0x50, 600,  256),
	MS5611_INIT_OSR(0x52, 1170, 512),
	MS5611_INIT_OSR(0x54, 2280, 1024),
	MS5611_INIT_OSR(0x56, 4540, 2048),
	MS5611_INIT_OSR(0x58, 9040, 4096)
};

static const char ms5611_show_osr[] = "256 512 1024 2048 4096";

static IIO_CONST_ATTR(oversampling_ratio_available, ms5611_show_osr);

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

static const struct attribute_group ms5611_attribute_group = {
	.attrs = ms5611_attributes,
};

static bool ms5611_prom_is_valid(u16 *prom, size_t len)
{
	int i, j;
	uint16_t crc = 0, crc_orig = prom[7] & 0x000F;

	prom[7] &= 0xFF00;

	for (i = 0; i < len * 2; i++) {
		if (i % 2 == 1)
			crc ^= prom[i >> 1] & 0x00FF;
		else
			crc ^= prom[i >> 1] >> 8;

		for (j = 0; j < 8; j++) {
			if (crc & 0x8000)
				crc = (crc << 1) ^ 0x3000;
			else
				crc <<= 1;
		}
	}

	crc = (crc >> 12) & 0x000F;

	return crc_orig != 0x0000 && crc == crc_orig;
}

static int ms5611_read_prom(struct iio_dev *indio_dev)
{
	int ret, i;
	struct ms5611_state *st = iio_priv(indio_dev);

	for (i = 0; i < MS5611_PROM_WORDS_NB; i++) {
		ret = st->read_prom_word(&indio_dev->dev,
					 i, &st->chip_info->prom[i]);
		if (ret < 0) {
			dev_err(&indio_dev->dev,
				"failed to read prom at %d\n", i);
			return ret;
		}
	}

	if (!ms5611_prom_is_valid(st->chip_info->prom, MS5611_PROM_WORDS_NB)) {
		dev_err(&indio_dev->dev, "PROM integrity check failed\n");
		return -ENODEV;
	}

	return 0;
}

static int ms5611_read_temp_and_pressure(struct iio_dev *indio_dev,
					 s32 *temp, s32 *pressure)
{
	int ret;
	struct ms5611_state *st = iio_priv(indio_dev);

	ret = st->read_adc_temp_and_pressure(&indio_dev->dev, temp, pressure);
	if (ret < 0) {
		dev_err(&indio_dev->dev,
			"failed to read temperature and pressure\n");
		return ret;
	}

	return st->chip_info->temp_and_pressure_compensate(st->chip_info,
							   temp, pressure);
}

static int ms5611_temp_and_pressure_compensate(struct ms5611_chip_info *chip_info,
					       s32 *temp, s32 *pressure)
{
	s32 t = *temp, p = *pressure;
	s64 off, sens, dt;

	dt = t - (chip_info->prom[5] << 8);
	off = ((s64)chip_info->prom[2] << 16) + ((chip_info->prom[4] * dt) >> 7);
	sens = ((s64)chip_info->prom[1] << 15) + ((chip_info->prom[3] * dt) >> 8);

	t = 2000 + ((chip_info->prom[6] * dt) >> 23);
	if (t < 2000) {
		s64 off2, sens2, t2;

		t2 = (dt * dt) >> 31;
		off2 = (5 * (t - 2000) * (t - 2000)) >> 1;
		sens2 = off2 >> 1;

		if (t < -1500) {
			s64 tmp = (t + 1500) * (t + 1500);

			off2 += 7 * tmp;
			sens2 += (11 * tmp) >> 1;
		}

		t -= t2;
		off -= off2;
		sens -= sens2;
	}

	*temp = t;
	*pressure = (((p * sens) >> 21) - off) >> 15;

	return 0;
}

static int ms5607_temp_and_pressure_compensate(struct ms5611_chip_info *chip_info,
					       s32 *temp, s32 *pressure)
{
	s32 t = *temp, p = *pressure;
	s64 off, sens, dt;

	dt = t - (chip_info->prom[5] << 8);
	off = ((s64)chip_info->prom[2] << 17) + ((chip_info->prom[4] * dt) >> 6);
	sens = ((s64)chip_info->prom[1] << 16) + ((chip_info->prom[3] * dt) >> 7);

	t = 2000 + ((chip_info->prom[6] * dt) >> 23);
	if (t < 2000) {
		s64 off2, sens2, t2, tmp;

		t2 = (dt * dt) >> 31;
		tmp = (t - 2000) * (t - 2000);
		off2 = (61 * tmp) >> 4;
		sens2 = tmp << 1;

		if (t < -1500) {
			tmp = (t + 1500) * (t + 1500);
			off2 += 15 * tmp;
			sens2 += 8 * tmp;
		}

		t -= t2;
		off -= off2;
		sens -= sens2;
	}

	*temp = t;
	*pressure = (((p * sens) >> 21) - off) >> 15;

	return 0;
}

static int ms5611_reset(struct iio_dev *indio_dev)
{
	int ret;
	struct ms5611_state *st = iio_priv(indio_dev);

	ret = st->reset(&indio_dev->dev);
	if (ret < 0) {
		dev_err(&indio_dev->dev, "failed to reset device\n");
		return ret;
	}

	usleep_range(3000, 4000);

	return 0;
}

static irqreturn_t ms5611_trigger_handler(int irq, void *p)
{
	struct iio_poll_func *pf = p;
	struct iio_dev *indio_dev = pf->indio_dev;
	struct ms5611_state *st = iio_priv(indio_dev);
	s32 buf[4]; /* s32 (pressure) + s32 (temp) + 2 * s32 (timestamp) */
	int ret;

	mutex_lock(&st->lock);
	ret = ms5611_read_temp_and_pressure(indio_dev, &buf[1], &buf[0]);
	mutex_unlock(&st->lock);
	if (ret < 0)
		goto err;

	iio_push_to_buffers_with_timestamp(indio_dev, buf,
					   iio_get_time_ns(indio_dev));

err:
	iio_trigger_notify_done(indio_dev->trig);

	return IRQ_HANDLED;
}

static int ms5611_read_raw(struct iio_dev *indio_dev,
			   struct iio_chan_spec const *chan,
			   int *val, int *val2, long mask)
{
	int ret;
	s32 temp, pressure;
	struct ms5611_state *st = iio_priv(indio_dev);

	switch (mask) {
	case IIO_CHAN_INFO_PROCESSED:
		mutex_lock(&st->lock);
		ret = ms5611_read_temp_and_pressure(indio_dev,
						    &temp, &pressure);
		mutex_unlock(&st->lock);
		if (ret < 0)
			return ret;

		switch (chan->type) {
		case IIO_TEMP:
			*val = temp * 10;
			return IIO_VAL_INT;
		case IIO_PRESSURE:
			*val = pressure / 1000;
			*val2 = (pressure % 1000) * 1000;
			return IIO_VAL_INT_PLUS_MICRO;
		default:
			return -EINVAL;
		}
	case IIO_CHAN_INFO_SCALE:
		switch (chan->type) {
		case IIO_TEMP:
			*val = 10;
			return IIO_VAL_INT;
		case IIO_PRESSURE:
			*val = 0;
			*val2 = 1000;
			return IIO_VAL_INT_PLUS_MICRO;
		default:
			return -EINVAL;
		}
	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
		if (chan->type != IIO_TEMP && chan->type != IIO_PRESSURE)
			break;
		mutex_lock(&st->lock);
		if (chan->type == IIO_TEMP)
			*val = (int)st->temp_osr->rate;
		else
			*val = (int)st->pressure_osr->rate;
		mutex_unlock(&st->lock);
		return IIO_VAL_INT;
	}

	return -EINVAL;
}

static const struct ms5611_osr *ms5611_find_osr(int rate,
						const struct ms5611_osr *osr,
						size_t count)
{
	unsigned int r;

	for (r = 0; r < count; r++)
		if ((unsigned short)rate == osr[r].rate)
			break;
	if (r >= count)
		return NULL;
	return &osr[r];
}

static int ms5611_write_raw(struct iio_dev *indio_dev,
			    struct iio_chan_spec const *chan,
			    int val, int val2, long mask)
{
	struct ms5611_state *st = iio_priv(indio_dev);
	const struct ms5611_osr *osr = NULL;

	if (mask != IIO_CHAN_INFO_OVERSAMPLING_RATIO)
		return -EINVAL;

	if (chan->type == IIO_TEMP)
		osr = ms5611_find_osr(val, ms5611_avail_temp_osr,
				      ARRAY_SIZE(ms5611_avail_temp_osr));
	else if (chan->type == IIO_PRESSURE)
		osr = ms5611_find_osr(val, ms5611_avail_pressure_osr,
				      ARRAY_SIZE(ms5611_avail_pressure_osr));
	if (!osr)
		return -EINVAL;

	mutex_lock(&st->lock);

	if (iio_buffer_enabled(indio_dev)) {
		mutex_unlock(&st->lock);
		return -EBUSY;
	}

	if (chan->type == IIO_TEMP)
		st->temp_osr = osr;
	else
		st->pressure_osr = osr;

	mutex_unlock(&st->lock);
	return 0;
}

static const unsigned long ms5611_scan_masks[] = {0x3, 0};

static struct ms5611_chip_info chip_info_tbl[] = {
	[MS5611] = {
		.temp_and_pressure_compensate = ms5611_temp_and_pressure_compensate,
	},
	[MS5607] = {
		.temp_and_pressure_compensate = ms5607_temp_and_pressure_compensate,
	}
};

static const struct iio_chan_spec ms5611_channels[] = {
	{
		.type = IIO_PRESSURE,
		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
			BIT(IIO_CHAN_INFO_SCALE) |
			BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
		.scan_index = 0,
		.scan_type = {
			.sign = 's',
			.realbits = 32,
			.storagebits = 32,
			.endianness = IIO_CPU,
		},
	},
	{
		.type = IIO_TEMP,
		.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
			BIT(IIO_CHAN_INFO_SCALE) |
			BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
		.scan_index = 1,
		.scan_type = {
			.sign = 's',
			.realbits = 32,
			.storagebits = 32,
			.endianness = IIO_CPU,
		},
	},
	IIO_CHAN_SOFT_TIMESTAMP(2),
};

static const struct iio_info ms5611_info = {
	.read_raw = &ms5611_read_raw,
	.write_raw = &ms5611_write_raw,
	.attrs = &ms5611_attribute_group,
	.driver_module = THIS_MODULE,
};

static int ms5611_init(struct iio_dev *indio_dev)
{
	int ret;
	struct ms5611_state *st = iio_priv(indio_dev);

	/* Enable attached regulator if any. */
	st->vdd = devm_regulator_get(indio_dev->dev.parent, "vdd");
	if (!IS_ERR(st->vdd)) {
		ret = regulator_enable(st->vdd);
		if (ret) {
			dev_err(indio_dev->dev.parent,
				"failed to enable Vdd supply: %d\n", ret);
			return ret;
		}
	} else {
		ret = PTR_ERR(st->vdd);
		if (ret != -ENODEV)
			return ret;
	}

	ret = ms5611_reset(indio_dev);
	if (ret < 0)
		goto err_regulator_disable;

	ret = ms5611_read_prom(indio_dev);
	if (ret < 0)
		goto err_regulator_disable;

	return 0;

err_regulator_disable:
	if (!IS_ERR_OR_NULL(st->vdd))
		regulator_disable(st->vdd);
	return ret;
}

static void ms5611_fini(const struct iio_dev *indio_dev)
{
	const struct ms5611_state *st = iio_priv(indio_dev);

	if (!IS_ERR_OR_NULL(st->vdd))
		regulator_disable(st->vdd);
}

int ms5611_probe(struct iio_dev *indio_dev, struct device *dev,
		 const char *name, int type)
{
	int ret;
	struct ms5611_state *st = iio_priv(indio_dev);

	mutex_init(&st->lock);
	st->chip_info = &chip_info_tbl[type];
	st->temp_osr =
		&ms5611_avail_temp_osr[ARRAY_SIZE(ms5611_avail_temp_osr) - 1];
	st->pressure_osr =
		&ms5611_avail_pressure_osr[ARRAY_SIZE(ms5611_avail_pressure_osr)
					   - 1];
	indio_dev->dev.parent = dev;
	indio_dev->name = name;
	indio_dev->info = &ms5611_info;
	indio_dev->channels = ms5611_channels;
	indio_dev->num_channels = ARRAY_SIZE(ms5611_channels);
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->available_scan_masks = ms5611_scan_masks;

	ret = ms5611_init(indio_dev);
	if (ret < 0)
		return ret;

	ret = iio_triggered_buffer_setup(indio_dev, NULL,
					 ms5611_trigger_handler, NULL);
	if (ret < 0) {
		dev_err(dev, "iio triggered buffer setup failed\n");
		goto err_fini;
	}

	ret = iio_device_register(indio_dev);
	if (ret < 0) {
		dev_err(dev, "unable to register iio device\n");
		goto err_buffer_cleanup;
	}

	return 0;

err_buffer_cleanup:
	iio_triggered_buffer_cleanup(indio_dev);
err_fini:
	ms5611_fini(indio_dev);
	return ret;
}
EXPORT_SYMBOL(ms5611_probe);

int ms5611_remove(struct iio_dev *indio_dev)
{
	iio_device_unregister(indio_dev);
	iio_triggered_buffer_cleanup(indio_dev);
	ms5611_fini(indio_dev);

	return 0;
}
EXPORT_SYMBOL(ms5611_remove);

MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
MODULE_DESCRIPTION("MS5611 core driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
c0644160 TD	1	/*
	2	* MS5611 pressure and temperature sensor driver
	3	*
	4	* Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*
	10	* Data sheet:
	11	* http://www.meas-spec.com/downloads/MS5611-01BA03.pdf
9690d81a	12	* http://www.meas-spec.com/downloads/MS5607-02BA03.pdf
c0644160 TD	13	*
	14	*/
	15
	16	#include <linux/module.h>
	17	#include <linux/iio/iio.h>
	18	#include <linux/delay.h>
3145229f	19	#include <linux/regulator/consumer.h>
c0644160	20
033691a9	21	#include <linux/iio/sysfs.h>
713bbb4e DB	22	#include <linux/iio/buffer.h>
	23	#include <linux/iio/triggered_buffer.h>
	24	#include <linux/iio/trigger_consumer.h>
c0644160 TD	25	#include "ms5611.h"
c0644160 TD	26
033691a9 GB	27	#define MS5611_INIT_OSR(_cmd, _conv_usec, _rate) \
	28	{ .cmd = _cmd, .conv_usec = _conv_usec, .rate = _rate }
	29
	30	static const struct ms5611_osr ms5611_avail_pressure_osr[] = {
	31	MS5611_INIT_OSR(0x40, 600, 256),
	32	MS5611_INIT_OSR(0x42, 1170, 512),
	33	MS5611_INIT_OSR(0x44, 2280, 1024),
	34	MS5611_INIT_OSR(0x46, 4540, 2048),
	35	MS5611_INIT_OSR(0x48, 9040, 4096)
	36	};
	37
	38	static const struct ms5611_osr ms5611_avail_temp_osr[] = {
	39	MS5611_INIT_OSR(0x50, 600, 256),
	40	MS5611_INIT_OSR(0x52, 1170, 512),
	41	MS5611_INIT_OSR(0x54, 2280, 1024),
	42	MS5611_INIT_OSR(0x56, 4540, 2048),
	43	MS5611_INIT_OSR(0x58, 9040, 4096)
	44	};
	45
	46	static const char ms5611_show_osr[] = "256 512 1024 2048 4096";
	47
	48	static IIO_CONST_ATTR(oversampling_ratio_available, ms5611_show_osr);
	49
	50	static struct attribute *ms5611_attributes[] = {
	51	&iio_const_attr_oversampling_ratio_available.dev_attr.attr,
	52	NULL,
	53	};
	54
	55	static const struct attribute_group ms5611_attribute_group = {
	56	.attrs = ms5611_attributes,
	57	};
	58
c0644160 TD	59	static bool ms5611_prom_is_valid(u16 *prom, size_t len)
	60	{
	61	int i, j;
	62	uint16_t crc = 0, crc_orig = prom[7] & 0x000F;
	63
	64	prom[7] &= 0xFF00;
	65
	66	for (i = 0; i < len * 2; i++) {
	67	if (i % 2 == 1)
	68	crc ^= prom[i >> 1] & 0x00FF;
	69	else
	70	crc ^= prom[i >> 1] >> 8;
	71
	72	for (j = 0; j < 8; j++) {
	73	if (crc & 0x8000)
	74	crc = (crc << 1) ^ 0x3000;
	75	else
	76	crc <<= 1;
	77	}
	78	}
	79
	80	crc = (crc >> 12) & 0x000F;
	81
	82	return crc_orig != 0x0000 && crc == crc_orig;
	83	}
	84
	85	static int ms5611_read_prom(struct iio_dev *indio_dev)
	86	{
	87	int ret, i;
	88	struct ms5611_state *st = iio_priv(indio_dev);
	89
	90	for (i = 0; i < MS5611_PROM_WORDS_NB; i++) {
9690d81a TD	91	ret = st->read_prom_word(&indio_dev->dev,
9690d81a TD	92	i, &st->chip_info->prom[i]);
c0644160 TD	93	if (ret < 0) {
	94	dev_err(&indio_dev->dev,
	95	"failed to read prom at %d\n", i);
	96	return ret;
	97	}
	98	}
	99
9690d81a	100	if (!ms5611_prom_is_valid(st->chip_info->prom, MS5611_PROM_WORDS_NB)) {
c0644160 TD	101	dev_err(&indio_dev->dev, "PROM integrity check failed\n");
	102	return -ENODEV;
	103	}
	104
	105	return 0;
	106	}
	107
	108	static int ms5611_read_temp_and_pressure(struct iio_dev *indio_dev,
	109	s32 temp, s32 pressure)
	110	{
	111	int ret;
c0644160 TD	112	struct ms5611_state *st = iio_priv(indio_dev);
c0644160 TD	113
9690d81a	114	ret = st->read_adc_temp_and_pressure(&indio_dev->dev, temp, pressure);
c0644160 TD	115	if (ret < 0) {
	116	dev_err(&indio_dev->dev,
	117	"failed to read temperature and pressure\n");
	118	return ret;
	119	}
	120
9690d81a TD	121	return st->chip_info->temp_and_pressure_compensate(st->chip_info,
	122	temp, pressure);
	123	}
	124
	125	static int ms5611_temp_and_pressure_compensate(struct ms5611_chip_info *chip_info,
	126	s32 temp, s32 pressure)
	127	{
	128	s32 t = temp, p = pressure;
	129	s64 off, sens, dt;
c0644160	130
9690d81a TD	131	dt = t - (chip_info->prom[5] << 8);
	132	off = ((s64)chip_info->prom[2] << 16) + ((chip_info->prom[4] * dt) >> 7);
	133	sens = ((s64)chip_info->prom[1] << 15) + ((chip_info->prom[3] * dt) >> 8);
	134
	135	t = 2000 + ((chip_info->prom[6] * dt) >> 23);
c0644160 TD	136	if (t < 2000) {
	137	s64 off2, sens2, t2;
	138
	139	t2 = (dt * dt) >> 31;
	140	off2 = (5 * (t - 2000) * (t - 2000)) >> 1;
	141	sens2 = off2 >> 1;
	142
	143	if (t < -1500) {
	144	s64 tmp = (t + 1500) * (t + 1500);
	145
	146	off2 += 7 * tmp;
	147	sens2 += (11 * tmp) >> 1;
	148	}
	149
	150	t -= t2;
	151	off -= off2;
	152	sens -= sens2;
	153	}
	154
	155	*temp = t;
	156	pressure = (((p sens) >> 21) - off) >> 15;
	157
	158	return 0;
	159	}
	160
9690d81a TD	161	static int ms5607_temp_and_pressure_compensate(struct ms5611_chip_info *chip_info,
	162	s32 temp, s32 pressure)
	163	{
	164	s32 t = temp, p = pressure;
	165	s64 off, sens, dt;
	166
	167	dt = t - (chip_info->prom[5] << 8);
	168	off = ((s64)chip_info->prom[2] << 17) + ((chip_info->prom[4] * dt) >> 6);
	169	sens = ((s64)chip_info->prom[1] << 16) + ((chip_info->prom[3] * dt) >> 7);
	170
	171	t = 2000 + ((chip_info->prom[6] * dt) >> 23);
	172	if (t < 2000) {
ce5b8fc1	173	s64 off2, sens2, t2, tmp;
9690d81a TD	174
9690d81a TD	175	t2 = (dt * dt) >> 31;
ce5b8fc1 GB	176	tmp = (t - 2000) * (t - 2000);
	177	off2 = (61 * tmp) >> 4;
	178	sens2 = tmp << 1;
9690d81a TD	179
9690d81a TD	180	if (t < -1500) {
ce5b8fc1	181	tmp = (t + 1500) * (t + 1500);
9690d81a	182	off2 += 15 * tmp;
ce5b8fc1	183	sens2 += 8 * tmp;
9690d81a TD	184	}
	185
	186	t -= t2;
	187	off -= off2;
	188	sens -= sens2;
	189	}
	190
	191	*temp = t;
	192	pressure = (((p sens) >> 21) - off) >> 15;
	193
	194	return 0;
	195	}
	196
c0644160 TD	197	static int ms5611_reset(struct iio_dev *indio_dev)
	198	{
	199	int ret;
	200	struct ms5611_state *st = iio_priv(indio_dev);
	201
	202	ret = st->reset(&indio_dev->dev);
	203	if (ret < 0) {
	204	dev_err(&indio_dev->dev, "failed to reset device\n");
	205	return ret;
	206	}
	207
	208	usleep_range(3000, 4000);
	209
	210	return 0;
	211	}
	212
713bbb4e DB	213	static irqreturn_t ms5611_trigger_handler(int irq, void *p)
	214	{
	215	struct iio_poll_func *pf = p;
	216	struct iio_dev *indio_dev = pf->indio_dev;
	217	struct ms5611_state *st = iio_priv(indio_dev);
	218	s32 buf[4]; /* s32 (pressure) + s32 (temp) + 2 * s32 (timestamp) */
	219	int ret;
	220
	221	mutex_lock(&st->lock);
	222	ret = ms5611_read_temp_and_pressure(indio_dev, &buf[1], &buf[0]);
	223	mutex_unlock(&st->lock);
	224	if (ret < 0)
	225	goto err;
	226
bc2b7dab GB	227	iio_push_to_buffers_with_timestamp(indio_dev, buf,
bc2b7dab GB	228	iio_get_time_ns(indio_dev));
713bbb4e DB	229
	230	err:
	231	iio_trigger_notify_done(indio_dev->trig);
	232
	233	return IRQ_HANDLED;
	234	}
	235
c0644160 TD	236	static int ms5611_read_raw(struct iio_dev *indio_dev,
	237	struct iio_chan_spec const *chan,
	238	int val, int val2, long mask)
	239	{
	240	int ret;
	241	s32 temp, pressure;
	242	struct ms5611_state *st = iio_priv(indio_dev);
	243
	244	switch (mask) {
	245	case IIO_CHAN_INFO_PROCESSED:
	246	mutex_lock(&st->lock);
	247	ret = ms5611_read_temp_and_pressure(indio_dev,
	248	&temp, &pressure);
	249	mutex_unlock(&st->lock);
	250	if (ret < 0)
	251	return ret;
	252
	253	switch (chan->type) {
	254	case IIO_TEMP:
	255	val = temp 10;
	256	return IIO_VAL_INT;
	257	case IIO_PRESSURE:
	258	*val = pressure / 1000;
	259	val2 = (pressure % 1000) 1000;
	260	return IIO_VAL_INT_PLUS_MICRO;
	261	default:
	262	return -EINVAL;
	263	}
1ad1ce9b DB	264	case IIO_CHAN_INFO_SCALE:
	265	switch (chan->type) {
	266	case IIO_TEMP:
	267	*val = 10;
	268	return IIO_VAL_INT;
	269	case IIO_PRESSURE:
	270	*val = 0;
	271	*val2 = 1000;
	272	return IIO_VAL_INT_PLUS_MICRO;
	273	default:
	274	return -EINVAL;
	275	}
033691a9 GB	276	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
	277	if (chan->type != IIO_TEMP && chan->type != IIO_PRESSURE)
	278	break;
	279	mutex_lock(&st->lock);
	280	if (chan->type == IIO_TEMP)
	281	*val = (int)st->temp_osr->rate;
	282	else
	283	*val = (int)st->pressure_osr->rate;
	284	mutex_unlock(&st->lock);
	285	return IIO_VAL_INT;
c0644160 TD	286	}
	287
	288	return -EINVAL;
	289	}
	290
033691a9 GB	291	static const struct ms5611_osr *ms5611_find_osr(int rate,
	292	const struct ms5611_osr *osr,
	293	size_t count)
	294	{
	295	unsigned int r;
	296
	297	for (r = 0; r < count; r++)
	298	if ((unsigned short)rate == osr[r].rate)
	299	break;
	300	if (r >= count)
	301	return NULL;
	302	return &osr[r];
	303	}
	304
	305	static int ms5611_write_raw(struct iio_dev *indio_dev,
	306	struct iio_chan_spec const *chan,
	307	int val, int val2, long mask)
	308	{
	309	struct ms5611_state *st = iio_priv(indio_dev);
	310	const struct ms5611_osr *osr = NULL;
	311
	312	if (mask != IIO_CHAN_INFO_OVERSAMPLING_RATIO)
	313	return -EINVAL;
	314
	315	if (chan->type == IIO_TEMP)
	316	osr = ms5611_find_osr(val, ms5611_avail_temp_osr,
	317	ARRAY_SIZE(ms5611_avail_temp_osr));
	318	else if (chan->type == IIO_PRESSURE)
	319	osr = ms5611_find_osr(val, ms5611_avail_pressure_osr,
	320	ARRAY_SIZE(ms5611_avail_pressure_osr));
	321	if (!osr)
	322	return -EINVAL;
	323
	324	mutex_lock(&st->lock);
	325
	326	if (iio_buffer_enabled(indio_dev)) {
	327	mutex_unlock(&st->lock);
	328	return -EBUSY;
	329	}
	330
	331	if (chan->type == IIO_TEMP)
	332	st->temp_osr = osr;
	333	else
	334	st->pressure_osr = osr;
	335
	336	mutex_unlock(&st->lock);
	337	return 0;
	338	}
	339
713bbb4e DB	340	static const unsigned long ms5611_scan_masks[] = {0x3, 0};
713bbb4e DB	341
9690d81a TD	342	static struct ms5611_chip_info chip_info_tbl[] = {
	343	[MS5611] = {
	344	.temp_and_pressure_compensate = ms5611_temp_and_pressure_compensate,
	345	},
	346	[MS5607] = {
	347	.temp_and_pressure_compensate = ms5607_temp_and_pressure_compensate,
	348	}
	349	};
	350
c0644160 TD	351	static const struct iio_chan_spec ms5611_channels[] = {
	352	{
	353	.type = IIO_PRESSURE,
1ad1ce9b	354	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) \|
033691a9 GB	355	BIT(IIO_CHAN_INFO_SCALE) \|
033691a9 GB	356	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
713bbb4e DB	357	.scan_index = 0,
	358	.scan_type = {
	359	.sign = 's',
	360	.realbits = 32,
	361	.storagebits = 32,
	362	.endianness = IIO_CPU,
	363	},
c0644160 TD	364	},
	365	{
	366	.type = IIO_TEMP,
1ad1ce9b	367	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) \|
033691a9 GB	368	BIT(IIO_CHAN_INFO_SCALE) \|
033691a9 GB	369	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
713bbb4e DB	370	.scan_index = 1,
	371	.scan_type = {
	372	.sign = 's',
	373	.realbits = 32,
	374	.storagebits = 32,
	375	.endianness = IIO_CPU,
	376	},
	377	},
	378	IIO_CHAN_SOFT_TIMESTAMP(2),
c0644160 TD	379	};
	380
	381	static const struct iio_info ms5611_info = {
	382	.read_raw = &ms5611_read_raw,
033691a9 GB	383	.write_raw = &ms5611_write_raw,
033691a9 GB	384	.attrs = &ms5611_attribute_group,
c0644160 TD	385	.driver_module = THIS_MODULE,
	386	};
	387
	388	static int ms5611_init(struct iio_dev *indio_dev)
	389	{
	390	int ret;
334ecdd0	391	struct ms5611_state *st = iio_priv(indio_dev);
3145229f GB	392
3145229f GB	393	/* Enable attached regulator if any. */
334ecdd0 GB	394	st->vdd = devm_regulator_get(indio_dev->dev.parent, "vdd");
	395	if (!IS_ERR(st->vdd)) {
	396	ret = regulator_enable(st->vdd);
3145229f GB	397	if (ret) {
3145229f GB	398	dev_err(indio_dev->dev.parent,
334ecdd0	399	"failed to enable Vdd supply: %d\n", ret);
3145229f GB	400	return ret;
3145229f GB	401	}
334ecdd0 GB	402	} else {
	403	ret = PTR_ERR(st->vdd);
	404	if (ret != -ENODEV)
	405	return ret;
3145229f	406	}
c0644160 TD	407
	408	ret = ms5611_reset(indio_dev);
	409	if (ret < 0)
334ecdd0 GB	410	goto err_regulator_disable;
	411
	412	ret = ms5611_read_prom(indio_dev);
	413	if (ret < 0)
	414	goto err_regulator_disable;
	415
	416	return 0;
c0644160	417
334ecdd0 GB	418	err_regulator_disable:
	419	if (!IS_ERR_OR_NULL(st->vdd))
	420	regulator_disable(st->vdd);
	421	return ret;
	422	}
	423
	424	static void ms5611_fini(const struct iio_dev *indio_dev)
	425	{
	426	const struct ms5611_state *st = iio_priv(indio_dev);
	427
	428	if (!IS_ERR_OR_NULL(st->vdd))
	429	regulator_disable(st->vdd);
c0644160 TD	430	}
c0644160 TD	431
eac635eb	432	int ms5611_probe(struct iio_dev indio_dev, struct device dev,
964d97bd	433	const char *name, int type)
c0644160 TD	434	{
	435	int ret;
	436	struct ms5611_state *st = iio_priv(indio_dev);
	437
	438	mutex_init(&st->lock);
9690d81a	439	st->chip_info = &chip_info_tbl[type];
033691a9 GB	440	st->temp_osr =
	441	&ms5611_avail_temp_osr[ARRAY_SIZE(ms5611_avail_temp_osr) - 1];
	442	st->pressure_osr =
	443	&ms5611_avail_pressure_osr[ARRAY_SIZE(ms5611_avail_pressure_osr)
	444	- 1];
c0644160	445	indio_dev->dev.parent = dev;
eac635eb	446	indio_dev->name = name;
c0644160 TD	447	indio_dev->info = &ms5611_info;
	448	indio_dev->channels = ms5611_channels;
	449	indio_dev->num_channels = ARRAY_SIZE(ms5611_channels);
	450	indio_dev->modes = INDIO_DIRECT_MODE;
713bbb4e	451	indio_dev->available_scan_masks = ms5611_scan_masks;
c0644160 TD	452
	453	ret = ms5611_init(indio_dev);
	454	if (ret < 0)
	455	return ret;
	456
713bbb4e DB	457	ret = iio_triggered_buffer_setup(indio_dev, NULL,
	458	ms5611_trigger_handler, NULL);
	459	if (ret < 0) {
	460	dev_err(dev, "iio triggered buffer setup failed\n");
334ecdd0	461	goto err_fini;
713bbb4e DB	462	}
	463
	464	ret = iio_device_register(indio_dev);
	465	if (ret < 0) {
	466	dev_err(dev, "unable to register iio device\n");
	467	goto err_buffer_cleanup;
	468	}
	469
	470	return 0;
	471
	472	err_buffer_cleanup:
	473	iio_triggered_buffer_cleanup(indio_dev);
334ecdd0 GB	474	err_fini:
334ecdd0 GB	475	ms5611_fini(indio_dev);
713bbb4e	476	return ret;
c0644160 TD	477	}
	478	EXPORT_SYMBOL(ms5611_probe);
	479
713bbb4e DB	480	int ms5611_remove(struct iio_dev *indio_dev)
	481	{
	482	iio_device_unregister(indio_dev);
	483	iio_triggered_buffer_cleanup(indio_dev);
334ecdd0	484	ms5611_fini(indio_dev);
713bbb4e DB	485
	486	return 0;
	487	}
	488	EXPORT_SYMBOL(ms5611_remove);
	489
c0644160 TD	490	MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
	491	MODULE_DESCRIPTION("MS5611 core driver");
	492	MODULE_LICENSE("GPL v2");