1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * MPRLS0025PA - Honeywell MicroPressure pressure sensor series driver
4 *
5 * Copyright (c) Andreas Klinger <ak@it-klinger.de>
6 *
7 * Data sheet:
8 *  https://prod-edam.honeywell.com/content/dam/honeywell-edam/sps/siot/en-us/
9 *    products/sensors/pressure-sensors/board-mount-pressure-sensors/
10 *    micropressure-mpr-series/documents/
11 *    sps-siot-mpr-series-datasheet-32332628-ciid-172626.pdf
12 *
13 * 7-bit I2C default slave address: 0x18
14 */
15
16#include <linux/delay.h>
17#include <linux/device.h>
18#include <linux/i2c.h>
19#include <linux/math64.h>
20#include <linux/mod_devicetable.h>
21#include <linux/module.h>
22#include <linux/property.h>
23#include <linux/units.h>
24
25#include <linux/gpio/consumer.h>
26
27#include <linux/iio/buffer.h>
28#include <linux/iio/iio.h>
29#include <linux/iio/trigger_consumer.h>
30#include <linux/iio/triggered_buffer.h>
31
32#include <linux/regulator/consumer.h>
33
34#include <asm/unaligned.h>
35
36/* bits in i2c status byte */
37#define MPR_I2C_POWER	BIT(6)	/* device is powered */
38#define MPR_I2C_BUSY	BIT(5)	/* device is busy */
39#define MPR_I2C_MEMORY	BIT(2)	/* integrity test passed */
40#define MPR_I2C_MATH	BIT(0)	/* internal math saturation */
41
42/*
43 * support _RAW sysfs interface:
44 *
45 * Calculation formula from the datasheet:
46 * pressure = (press_cnt - outputmin) * scale + pmin
47 * with:
48 * * pressure	- measured pressure in Pascal
49 * * press_cnt	- raw value read from sensor
50 * * pmin	- minimum pressure range value of sensor (data->pmin)
51 * * pmax	- maximum pressure range value of sensor (data->pmax)
52 * * outputmin	- minimum numerical range raw value delivered by sensor
53 *						(mpr_func_spec.output_min)
54 * * outputmax	- maximum numerical range raw value delivered by sensor
55 *						(mpr_func_spec.output_max)
56 * * scale	- (pmax - pmin) / (outputmax - outputmin)
57 *
58 * formula of the userspace:
59 * pressure = (raw + offset) * scale
60 *
61 * Values given to the userspace in sysfs interface:
62 * * raw	- press_cnt
63 * * offset	- (-1 * outputmin) - pmin / scale
64 *                note: With all sensors from the datasheet pmin = 0
65 *                which reduces the offset to (-1 * outputmin)
66 */
67
68/*
69 * transfer function A: 10%   to 90%   of 2^24
70 * transfer function B:  2.5% to 22.5% of 2^24
71 * transfer function C: 20%   to 80%   of 2^24
72 */
73enum mpr_func_id {
74	MPR_FUNCTION_A,
75	MPR_FUNCTION_B,
76	MPR_FUNCTION_C,
77};
78
79struct mpr_func_spec {
80	u32			output_min;
81	u32			output_max;
82};
83
84static const struct mpr_func_spec mpr_func_spec[] = {
85	[MPR_FUNCTION_A] = {.output_min = 1677722, .output_max = 15099494},
86	[MPR_FUNCTION_B] = {.output_min =  419430, .output_max =  3774874},
87	[MPR_FUNCTION_C] = {.output_min = 3355443, .output_max = 13421773},
88};
89
90struct mpr_chan {
91	s32			pres;		/* pressure value */
92	s64			ts;		/* timestamp */
93};
94
95struct mpr_data {
96	struct i2c_client	*client;
97	struct mutex		lock;		/*
98						 * access to device during read
99						 */
100	u32			pmin;		/* minimal pressure in pascal */
101	u32			pmax;		/* maximal pressure in pascal */
102	enum mpr_func_id	function;	/* transfer function */
103	u32			outmin;		/*
104						 * minimal numerical range raw
105						 * value from sensor
106						 */
107	u32			outmax;		/*
108						 * maximal numerical range raw
109						 * value from sensor
110						 */
111	int                     scale;          /* int part of scale */
112	int                     scale2;         /* nano part of scale */
113	int                     offset;         /* int part of offset */
114	int                     offset2;        /* nano part of offset */
115	struct gpio_desc	*gpiod_reset;	/* reset */
116	int			irq;		/*
117						 * end of conversion irq;
118						 * used to distinguish between
119						 * irq mode and reading in a
120						 * loop until data is ready
121						 */
122	struct completion	completion;	/* handshake from irq to read */
123	struct mpr_chan		chan;		/*
124						 * channel values for buffered
125						 * mode
126						 */
127};
128
129static const struct iio_chan_spec mpr_channels[] = {
130	{
131		.type = IIO_PRESSURE,
132		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
133					BIT(IIO_CHAN_INFO_SCALE) |
134					BIT(IIO_CHAN_INFO_OFFSET),
135		.scan_index = 0,
136		.scan_type = {
137			.sign = 's',
138			.realbits = 32,
139			.storagebits = 32,
140			.endianness = IIO_CPU,
141		},
142	},
143	IIO_CHAN_SOFT_TIMESTAMP(1),
144};
145
146static void mpr_reset(struct mpr_data *data)
147{
148	if (data->gpiod_reset) {
149		gpiod_set_value(data->gpiod_reset, 0);
150		udelay(10);
151		gpiod_set_value(data->gpiod_reset, 1);
152	}
153}
154
155/**
156 * mpr_read_pressure() - Read pressure value from sensor via I2C
157 * @data: Pointer to private data struct.
158 * @press: Output value read from sensor.
159 *
160 * Reading from the sensor by sending and receiving I2C telegrams.
161 *
162 * If there is an end of conversion (EOC) interrupt registered the function
163 * waits for a maximum of one second for the interrupt.
164 *
165 * Context: The function can sleep and data->lock should be held when calling it
166 * Return:
167 * * 0		- OK, the pressure value could be read
168 * * -ETIMEDOUT	- Timeout while waiting for the EOC interrupt or busy flag is
169 *		  still set after nloops attempts of reading
170 */
171static int mpr_read_pressure(struct mpr_data *data, s32 *press)
172{
173	struct device *dev = &data->client->dev;
174	int ret, i;
175	u8 wdata[] = {0xAA, 0x00, 0x00};
176	s32 status;
177	int nloops = 10;
178	u8 buf[4];
179
180	reinit_completion(&data->completion);
181
182	ret = i2c_master_send(data->client, wdata, sizeof(wdata));
183	if (ret < 0) {
184		dev_err(dev, "error while writing ret: %d\n", ret);
185		return ret;
186	}
187	if (ret != sizeof(wdata)) {
188		dev_err(dev, "received size doesn't fit - ret: %d / %u\n", ret,
189							(u32)sizeof(wdata));
190		return -EIO;
191	}
192
193	if (data->irq > 0) {
194		ret = wait_for_completion_timeout(&data->completion, HZ);
195		if (!ret) {
196			dev_err(dev, "timeout while waiting for eoc irq\n");
197			return -ETIMEDOUT;
198		}
199	} else {
200		/* wait until status indicates data is ready */
201		for (i = 0; i < nloops; i++) {
202			/*
203			 * datasheet only says to wait at least 5 ms for the
204			 * data but leave the maximum response time open
205			 * --> let's try it nloops (10) times which seems to be
206			 *     quite long
207			 */
208			usleep_range(5000, 10000);
209			status = i2c_smbus_read_byte(data->client);
210			if (status < 0) {
211				dev_err(dev,
212					"error while reading, status: %d\n",
213					status);
214				return status;
215			}
216			if (!(status & MPR_I2C_BUSY))
217				break;
218		}
219		if (i == nloops) {
220			dev_err(dev, "timeout while reading\n");
221			return -ETIMEDOUT;
222		}
223	}
224
225	ret = i2c_master_recv(data->client, buf, sizeof(buf));
226	if (ret < 0) {
227		dev_err(dev, "error in i2c_master_recv ret: %d\n", ret);
228		return ret;
229	}
230	if (ret != sizeof(buf)) {
231		dev_err(dev, "received size doesn't fit - ret: %d / %u\n", ret,
232							(u32)sizeof(buf));
233		return -EIO;
234	}
235
236	if (buf[0] & MPR_I2C_BUSY) {
237		/*
238		 * it should never be the case that status still indicates
239		 * business
240		 */
241		dev_err(dev, "data still not ready: %08x\n", buf[0]);
242		return -ETIMEDOUT;
243	}
244
245	*press = get_unaligned_be24(&buf[1]);
246
247	dev_dbg(dev, "received: %*ph cnt: %d\n", ret, buf, *press);
248
249	return 0;
250}
251
252static irqreturn_t mpr_eoc_handler(int irq, void *p)
253{
254	struct mpr_data *data = p;
255
256	complete(&data->completion);
257
258	return IRQ_HANDLED;
259}
260
261static irqreturn_t mpr_trigger_handler(int irq, void *p)
262{
263	int ret;
264	struct iio_poll_func *pf = p;
265	struct iio_dev *indio_dev = pf->indio_dev;
266	struct mpr_data *data = iio_priv(indio_dev);
267
268	mutex_lock(&data->lock);
269	ret = mpr_read_pressure(data, &data->chan.pres);
270	if (ret < 0)
271		goto err;
272
273	iio_push_to_buffers_with_timestamp(indio_dev, &data->chan,
274						iio_get_time_ns(indio_dev));
275
276err:
277	mutex_unlock(&data->lock);
278	iio_trigger_notify_done(indio_dev->trig);
279
280	return IRQ_HANDLED;
281}
282
283static int mpr_read_raw(struct iio_dev *indio_dev,
284	struct iio_chan_spec const *chan, int *val, int *val2, long mask)
285{
286	int ret;
287	s32 pressure;
288	struct mpr_data *data = iio_priv(indio_dev);
289
290	if (chan->type != IIO_PRESSURE)
291		return -EINVAL;
292
293	switch (mask) {
294	case IIO_CHAN_INFO_RAW:
295		mutex_lock(&data->lock);
296		ret = mpr_read_pressure(data, &pressure);
297		mutex_unlock(&data->lock);
298		if (ret < 0)
299			return ret;
300		*val = pressure;
301		return IIO_VAL_INT;
302	case IIO_CHAN_INFO_SCALE:
303		*val = data->scale;
304		*val2 = data->scale2;
305		return IIO_VAL_INT_PLUS_NANO;
306	case IIO_CHAN_INFO_OFFSET:
307		*val = data->offset;
308		*val2 = data->offset2;
309		return IIO_VAL_INT_PLUS_NANO;
310	default:
311		return -EINVAL;
312	}
313}
314
315static const struct iio_info mpr_info = {
316	.read_raw = &mpr_read_raw,
317};
318
319static int mpr_probe(struct i2c_client *client)
320{
321	int ret;
322	struct mpr_data *data;
323	struct iio_dev *indio_dev;
324	struct device *dev = &client->dev;
325	s64 scale, offset;
326	u32 func;
327
328	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE))
329		return dev_err_probe(dev, -EOPNOTSUPP,
330					"I2C functionality not supported\n");
331
332	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
333	if (!indio_dev)
334		return dev_err_probe(dev, -ENOMEM, "couldn't get iio_dev\n");
335
336	data = iio_priv(indio_dev);
337	data->client = client;
338	data->irq = client->irq;
339
340	mutex_init(&data->lock);
341	init_completion(&data->completion);
342
343	indio_dev->name = "mprls0025pa";
344	indio_dev->info = &mpr_info;
345	indio_dev->channels = mpr_channels;
346	indio_dev->num_channels = ARRAY_SIZE(mpr_channels);
347	indio_dev->modes = INDIO_DIRECT_MODE;
348
349	ret = devm_regulator_get_enable(dev, "vdd");
350	if (ret)
351		return dev_err_probe(dev, ret,
352				"can't get and enable vdd supply\n");
353
354	if (dev_fwnode(dev)) {
355		ret = device_property_read_u32(dev, "honeywell,pmin-pascal",
356								&data->pmin);
357		if (ret)
358			return dev_err_probe(dev, ret,
359				"honeywell,pmin-pascal could not be read\n");
360		ret = device_property_read_u32(dev, "honeywell,pmax-pascal",
361								&data->pmax);
362		if (ret)
363			return dev_err_probe(dev, ret,
364				"honeywell,pmax-pascal could not be read\n");
365		ret = device_property_read_u32(dev,
366				"honeywell,transfer-function", &func);
367		if (ret)
368			return dev_err_probe(dev, ret,
369				"honeywell,transfer-function could not be read\n");
370		data->function = func - 1;
371		if (data->function > MPR_FUNCTION_C)
372			return dev_err_probe(dev, -EINVAL,
373				"honeywell,transfer-function %d invalid\n",
374								data->function);
375	} else {
376		/* when loaded as i2c device we need to use default values */
377		dev_notice(dev, "firmware node not found; using defaults\n");
378		data->pmin = 0;
379		data->pmax = 172369; /* 25 psi */
380		data->function = MPR_FUNCTION_A;
381	}
382
383	data->outmin = mpr_func_spec[data->function].output_min;
384	data->outmax = mpr_func_spec[data->function].output_max;
385
386	/* use 64 bit calculation for preserving a reasonable precision */
387	scale = div_s64(((s64)(data->pmax - data->pmin)) * NANO,
388						data->outmax - data->outmin);
389	data->scale = div_s64_rem(scale, NANO, &data->scale2);
390	/*
391	 * multiply with NANO before dividing by scale and later divide by NANO
392	 * again.
393	 */
394	offset = ((-1LL) * (s64)data->outmin) * NANO -
395			div_s64(div_s64((s64)data->pmin * NANO, scale), NANO);
396	data->offset = div_s64_rem(offset, NANO, &data->offset2);
397
398	if (data->irq > 0) {
399		ret = devm_request_irq(dev, data->irq, mpr_eoc_handler,
400				IRQF_TRIGGER_RISING, client->name, data);
401		if (ret)
402			return dev_err_probe(dev, ret,
403				"request irq %d failed\n", data->irq);
404	}
405
406	data->gpiod_reset = devm_gpiod_get_optional(dev, "reset",
407							GPIOD_OUT_HIGH);
408	if (IS_ERR(data->gpiod_reset))
409		return dev_err_probe(dev, PTR_ERR(data->gpiod_reset),
410						"request reset-gpio failed\n");
411
412	mpr_reset(data);
413
414	ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL,
415						mpr_trigger_handler, NULL);
416	if (ret)
417		return dev_err_probe(dev, ret,
418					"iio triggered buffer setup failed\n");
419
420	ret = devm_iio_device_register(dev, indio_dev);
421	if (ret)
422		return dev_err_probe(dev, ret,
423					"unable to register iio device\n");
424
425	return 0;
426}
427
428static const struct of_device_id mpr_matches[] = {
429	{ .compatible = "honeywell,mprls0025pa" },
430	{ }
431};
432MODULE_DEVICE_TABLE(of, mpr_matches);
433
434static const struct i2c_device_id mpr_id[] = {
435	{ "mprls0025pa" },
436	{ }
437};
438MODULE_DEVICE_TABLE(i2c, mpr_id);
439
440static struct i2c_driver mpr_driver = {
441	.probe		= mpr_probe,
442	.id_table	= mpr_id,
443	.driver		= {
444		.name		= "mprls0025pa",
445		.of_match_table = mpr_matches,
446	},
447};
448module_i2c_driver(mpr_driver);
449
450MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>");
451MODULE_DESCRIPTION("Honeywell MPRLS0025PA I2C driver");
452MODULE_LICENSE("GPL");
453