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 * Copyright (c) 2023-2025 Petre Rodan <petre.rodan@subdimension.ro>
7 *
8 * Data sheet:
9 * https://prod-edam.honeywell.com/content/dam/honeywell-edam/sps/siot/en-us/products/sensors/pressure-sensors/board-mount-pressure-sensors/micropressure-mpr-series/documents/sps-siot-mpr-series-datasheet-32332628-ciid-172626.pdf
10 *
11 */
12
13 #include <linux/array_size.h>
14 #include <linux/bitfield.h>
15 #include <linux/bits.h>
16 #include <linux/completion.h>
17 #include <linux/delay.h>
18 #include <linux/errno.h>
19 #include <linux/export.h>
20 #include <linux/interrupt.h>
21 #include <linux/jiffies.h>
22 #include <linux/math64.h>
23 #include <linux/module.h>
24 #include <linux/property.h>
25 #include <linux/string.h>
26 #include <linux/time.h>
27 #include <linux/units.h>
28
29 #include <linux/gpio/consumer.h>
30
31 #include <linux/iio/buffer.h>
32 #include <linux/iio/iio.h>
33 #include <linux/iio/trigger_consumer.h>
34 #include <linux/iio/triggered_buffer.h>
35
36 #include <linux/regulator/consumer.h>
37
38 #include <linux/unaligned.h>
39
40 #include "mprls0025pa.h"
41
42 /* bits in status byte */
43 #define MPR_ST_POWER BIT(6) /* device is powered */
44 #define MPR_ST_BUSY BIT(5) /* device is busy */
45
46 /*
47 * support _RAW sysfs interface:
48 *
49 * Calculation formula from the datasheet:
50 * pressure = (press_cnt - outputmin) * scale + pmin
51 * with:
52 * * pressure - measured pressure in Pascal
53 * * press_cnt - raw value read from sensor
54 * * pmin - minimum pressure range value of sensor (data->pmin)
55 * * pmax - maximum pressure range value of sensor (data->pmax)
56 * * outputmin - minimum numerical range raw value delivered by sensor
57 * (mpr_func_spec.output_min)
58 * * outputmax - maximum numerical range raw value delivered by sensor
59 * (mpr_func_spec.output_max)
60 * * scale - (pmax - pmin) / (outputmax - outputmin)
61 *
62 * formula of the userspace:
63 * pressure = (raw + offset) * scale
64 *
65 * Values given to the userspace in sysfs interface:
66 * * raw - press_cnt
67 * * offset - (-1 * outputmin) + pmin / scale
68 * note: With all sensors from the datasheet pmin = 0
69 * which reduces the offset to (-1 * outputmin)
70 */
71
72 /*
73 * transfer function A: 10% to 90% of 2^24
74 * transfer function B: 2.5% to 22.5% of 2^24
75 * transfer function C: 20% to 80% of 2^24
76 */
77 struct mpr_func_spec {
78 u32 output_min;
79 u32 output_max;
80 };
81
82 static const struct mpr_func_spec mpr_func_spec[] = {
83 [MPR_FUNCTION_A] = { .output_min = 1677722, .output_max = 15099494 },
84 [MPR_FUNCTION_B] = { .output_min = 419430, .output_max = 3774874 },
85 [MPR_FUNCTION_C] = { .output_min = 3355443, .output_max = 13421773 },
86 };
87
88 enum mpr_variants {
89 MPR0001BA = 0x00, MPR01_6BA = 0x01, MPR02_5BA = 0x02, MPR0060MG = 0x03,
90 MPR0100MG = 0x04, MPR0160MG = 0x05, MPR0250MG = 0x06, MPR0400MG = 0x07,
91 MPR0600MG = 0x08, MPR0001BG = 0x09, MPR01_6BG = 0x0a, MPR02_5BG = 0x0b,
92 MPR0100KA = 0x0c, MPR0160KA = 0x0d, MPR0250KA = 0x0e, MPR0006KG = 0x0f,
93 MPR0010KG = 0x10, MPR0016KG = 0x11, MPR0025KG = 0x12, MPR0040KG = 0x13,
94 MPR0060KG = 0x14, MPR0100KG = 0x15, MPR0160KG = 0x16, MPR0250KG = 0x17,
95 MPR0015PA = 0x18, MPR0025PA = 0x19, MPR0030PA = 0x1a, MPR0001PG = 0x1b,
96 MPR0005PG = 0x1c, MPR0015PG = 0x1d, MPR0030PG = 0x1e, MPR0300YG = 0x1f,
97 MPR_VARIANTS_MAX
98 };
99
100 static const char * const mpr_triplet_variants[MPR_VARIANTS_MAX] = {
101 [MPR0001BA] = "0001BA", [MPR01_6BA] = "01.6BA", [MPR02_5BA] = "02.5BA",
102 [MPR0060MG] = "0060MG", [MPR0100MG] = "0100MG", [MPR0160MG] = "0160MG",
103 [MPR0250MG] = "0250MG", [MPR0400MG] = "0400MG", [MPR0600MG] = "0600MG",
104 [MPR0001BG] = "0001BG", [MPR01_6BG] = "01.6BG", [MPR02_5BG] = "02.5BG",
105 [MPR0100KA] = "0100KA", [MPR0160KA] = "0160KA", [MPR0250KA] = "0250KA",
106 [MPR0006KG] = "0006KG", [MPR0010KG] = "0010KG", [MPR0016KG] = "0016KG",
107 [MPR0025KG] = "0025KG", [MPR0040KG] = "0040KG", [MPR0060KG] = "0060KG",
108 [MPR0100KG] = "0100KG", [MPR0160KG] = "0160KG", [MPR0250KG] = "0250KG",
109 [MPR0015PA] = "0015PA", [MPR0025PA] = "0025PA", [MPR0030PA] = "0030PA",
110 [MPR0001PG] = "0001PG", [MPR0005PG] = "0005PG", [MPR0015PG] = "0015PG",
111 [MPR0030PG] = "0030PG", [MPR0300YG] = "0300YG"
112 };
113
114 /**
115 * struct mpr_range_config - list of pressure ranges based on nomenclature
116 * @pmin: lowest pressure that can be measured
117 * @pmax: highest pressure that can be measured
118 */
119 struct mpr_range_config {
120 const s32 pmin;
121 const s32 pmax;
122 };
123
124 /* All min max limits have been converted to pascals */
125 static const struct mpr_range_config mpr_range_config[MPR_VARIANTS_MAX] = {
126 [MPR0001BA] = { .pmin = 0, .pmax = 100000 },
127 [MPR01_6BA] = { .pmin = 0, .pmax = 160000 },
128 [MPR02_5BA] = { .pmin = 0, .pmax = 250000 },
129 [MPR0060MG] = { .pmin = 0, .pmax = 6000 },
130 [MPR0100MG] = { .pmin = 0, .pmax = 10000 },
131 [MPR0160MG] = { .pmin = 0, .pmax = 16000 },
132 [MPR0250MG] = { .pmin = 0, .pmax = 25000 },
133 [MPR0400MG] = { .pmin = 0, .pmax = 40000 },
134 [MPR0600MG] = { .pmin = 0, .pmax = 60000 },
135 [MPR0001BG] = { .pmin = 0, .pmax = 100000 },
136 [MPR01_6BG] = { .pmin = 0, .pmax = 160000 },
137 [MPR02_5BG] = { .pmin = 0, .pmax = 250000 },
138 [MPR0100KA] = { .pmin = 0, .pmax = 100000 },
139 [MPR0160KA] = { .pmin = 0, .pmax = 160000 },
140 [MPR0250KA] = { .pmin = 0, .pmax = 250000 },
141 [MPR0006KG] = { .pmin = 0, .pmax = 6000 },
142 [MPR0010KG] = { .pmin = 0, .pmax = 10000 },
143 [MPR0016KG] = { .pmin = 0, .pmax = 16000 },
144 [MPR0025KG] = { .pmin = 0, .pmax = 25000 },
145 [MPR0040KG] = { .pmin = 0, .pmax = 40000 },
146 [MPR0060KG] = { .pmin = 0, .pmax = 60000 },
147 [MPR0100KG] = { .pmin = 0, .pmax = 100000 },
148 [MPR0160KG] = { .pmin = 0, .pmax = 160000 },
149 [MPR0250KG] = { .pmin = 0, .pmax = 250000 },
150 [MPR0015PA] = { .pmin = 0, .pmax = 103421 },
151 [MPR0025PA] = { .pmin = 0, .pmax = 172369 },
152 [MPR0030PA] = { .pmin = 0, .pmax = 206843 },
153 [MPR0001PG] = { .pmin = 0, .pmax = 6895 },
154 [MPR0005PG] = { .pmin = 0, .pmax = 34474 },
155 [MPR0015PG] = { .pmin = 0, .pmax = 103421 },
156 [MPR0030PG] = { .pmin = 0, .pmax = 206843 },
157 [MPR0300YG] = { .pmin = 0, .pmax = 39997 }
158 };
159
160 static const struct iio_chan_spec mpr_channels[] = {
161 {
162 .type = IIO_PRESSURE,
163 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
164 BIT(IIO_CHAN_INFO_SCALE) |
165 BIT(IIO_CHAN_INFO_OFFSET),
166 .scan_index = 0,
167 .scan_type = {
168 .sign = 'u',
169 .realbits = 24,
170 .storagebits = 32,
171 .endianness = IIO_CPU,
172 },
173 },
174 IIO_CHAN_SOFT_TIMESTAMP(1),
175 };
176
mpr_reset(struct mpr_data * data)177 static void mpr_reset(struct mpr_data *data)
178 {
179 if (data->gpiod_reset) {
180 gpiod_set_value(data->gpiod_reset, 0);
181 udelay(10);
182 gpiod_set_value(data->gpiod_reset, 1);
183 }
184 }
185
186 /**
187 * mpr_read_pressure() - Read pressure value from sensor
188 * @data: Pointer to private data struct.
189 * @press: Output value read from sensor.
190 *
191 * Reading from the sensor by sending and receiving telegrams.
192 *
193 * If there is an end of conversion (EOC) interrupt registered the function
194 * waits for a maximum of one second for the interrupt.
195 *
196 * Context: The function can sleep and data->lock should be held when calling it
197 * Return:
198 * * 0 - OK, the pressure value could be read
199 * * -EBUSY - Sensor does not have a new conversion ready
200 * * -ETIMEDOUT - Timeout while waiting for the EOC interrupt
201 * * -EIO - Invalid status byte received from sensor
202 */
mpr_read_pressure(struct mpr_data * data,s32 * press)203 static int mpr_read_pressure(struct mpr_data *data, s32 *press)
204 {
205 struct device *dev = data->dev;
206 int ret;
207
208 reinit_completion(&data->completion);
209
210 ret = data->ops->write(data, MPR_CMD_SYNC, MPR_PKT_SYNC_LEN);
211 if (ret < 0) {
212 dev_err(dev, "error while writing ret: %d\n", ret);
213 return ret;
214 }
215
216 if (data->irq > 0) {
217 ret = wait_for_completion_timeout(&data->completion, HZ);
218 if (!ret) {
219 dev_err(dev, "timeout while waiting for eoc irq\n");
220 return -ETIMEDOUT;
221 }
222 } else {
223 fsleep(5 * USEC_PER_MSEC);
224 }
225
226 memset(data->rx_buf, 0, sizeof(data->rx_buf));
227 ret = data->ops->read(data, MPR_CMD_NOP, MPR_PKT_NOP_LEN);
228 if (ret < 0)
229 return ret;
230
231 /*
232 * Status byte flags
233 * bit7 SANITY_CHK - must always be 0
234 * bit6 MPR_ST_POWER - 1 if device is powered
235 * bit5 MPR_ST_BUSY - 1 if device has no new conversion ready
236 * bit4 SANITY_CHK - must always be 0
237 * bit3 SANITY_CHK - must always be 0
238 * bit2 MEMORY_ERR - 1 if integrity test has failed
239 * bit1 SANITY_CHK - must always be 0
240 * bit0 MATH_ERR - 1 during internal math saturation error
241 */
242
243 if (data->rx_buf[0] == (MPR_ST_POWER | MPR_ST_BUSY))
244 return -EBUSY;
245
246 if (data->rx_buf[0] != MPR_ST_POWER) {
247 dev_err(data->dev,
248 "unexpected status byte 0x%02x\n", data->rx_buf[0]);
249 return -EIO;
250 }
251
252 *press = get_unaligned_be24(&data->rx_buf[1]);
253
254 dev_dbg(dev, "received: %*ph cnt: %d\n", ret, data->rx_buf, *press);
255
256 return 0;
257 }
258
mpr_eoc_handler(int irq,void * p)259 static irqreturn_t mpr_eoc_handler(int irq, void *p)
260 {
261 struct mpr_data *data = p;
262
263 complete(&data->completion);
264
265 return IRQ_HANDLED;
266 }
267
mpr_trigger_handler(int irq,void * p)268 static irqreturn_t mpr_trigger_handler(int irq, void *p)
269 {
270 int ret;
271 struct iio_poll_func *pf = p;
272 struct iio_dev *indio_dev = pf->indio_dev;
273 struct mpr_data *data = iio_priv(indio_dev);
274
275 mutex_lock(&data->lock);
276 ret = mpr_read_pressure(data, &data->chan.pres);
277 if (ret < 0)
278 goto err;
279
280 iio_push_to_buffers_with_timestamp(indio_dev, &data->chan,
281 iio_get_time_ns(indio_dev));
282
283 err:
284 mutex_unlock(&data->lock);
285 iio_trigger_notify_done(indio_dev->trig);
286
287 return IRQ_HANDLED;
288 }
289
mpr_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)290 static int mpr_read_raw(struct iio_dev *indio_dev,
291 struct iio_chan_spec const *chan, int *val, int *val2, long mask)
292 {
293 int ret;
294 s32 pressure;
295 struct mpr_data *data = iio_priv(indio_dev);
296
297 if (chan->type != IIO_PRESSURE)
298 return -EINVAL;
299
300 switch (mask) {
301 case IIO_CHAN_INFO_RAW:
302 mutex_lock(&data->lock);
303 ret = mpr_read_pressure(data, &pressure);
304 mutex_unlock(&data->lock);
305 if (ret < 0)
306 return ret;
307 *val = pressure;
308 return IIO_VAL_INT;
309 case IIO_CHAN_INFO_SCALE:
310 *val = data->scale;
311 *val2 = data->scale2;
312 return IIO_VAL_INT_PLUS_NANO;
313 case IIO_CHAN_INFO_OFFSET:
314 *val = data->offset;
315 return IIO_VAL_INT;
316 default:
317 return -EINVAL;
318 }
319 }
320
321 static const struct iio_info mpr_info = {
322 .read_raw = &mpr_read_raw,
323 };
324
mpr_common_probe(struct device * dev,const struct mpr_ops * ops,int irq)325 int mpr_common_probe(struct device *dev, const struct mpr_ops *ops, int irq)
326 {
327 int ret;
328 struct mpr_data *data;
329 struct iio_dev *indio_dev;
330 const char *triplet;
331 s64 odelta, pdelta;
332 u32 func;
333 s32 tmp;
334
335 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
336 if (!indio_dev)
337 return -ENOMEM;
338
339 data = iio_priv(indio_dev);
340 data->dev = dev;
341 data->ops = ops;
342 data->irq = irq;
343
344 mutex_init(&data->lock);
345 init_completion(&data->completion);
346
347 indio_dev->name = "mprls0025pa";
348 indio_dev->info = &mpr_info;
349 indio_dev->channels = mpr_channels;
350 indio_dev->num_channels = ARRAY_SIZE(mpr_channels);
351 indio_dev->modes = INDIO_DIRECT_MODE;
352
353 ret = devm_regulator_get_enable(dev, "vdd");
354 if (ret)
355 return dev_err_probe(dev, ret,
356 "can't get and enable vdd supply\n");
357
358 ret = device_property_read_u32(dev,
359 "honeywell,transfer-function", &func);
360 if (ret)
361 return dev_err_probe(dev, ret,
362 "honeywell,transfer-function could not be read\n");
363 data->function = func - 1;
364 if (data->function > MPR_FUNCTION_C)
365 return dev_err_probe(dev, -EINVAL,
366 "honeywell,transfer-function %d invalid\n",
367 data->function);
368
369 ret = device_property_read_string(dev, "honeywell,pressure-triplet",
370 &triplet);
371 if (ret) {
372 ret = device_property_read_u32(dev, "honeywell,pmin-pascal",
373 &data->pmin);
374 if (ret)
375 return dev_err_probe(dev, ret,
376 "honeywell,pmin-pascal could not be read\n");
377
378 ret = device_property_read_u32(dev, "honeywell,pmax-pascal",
379 &data->pmax);
380 if (ret)
381 return dev_err_probe(dev, ret,
382 "honeywell,pmax-pascal could not be read\n");
383 } else {
384 ret = device_property_match_property_string(dev,
385 "honeywell,pressure-triplet",
386 mpr_triplet_variants,
387 MPR_VARIANTS_MAX);
388 if (ret < 0)
389 return dev_err_probe(dev, -EINVAL,
390 "honeywell,pressure-triplet is invalid\n");
391
392 data->pmin = mpr_range_config[ret].pmin;
393 data->pmax = mpr_range_config[ret].pmax;
394 }
395
396 if (data->pmin >= data->pmax)
397 return dev_err_probe(dev, -EINVAL,
398 "pressure limits are invalid\n");
399
400 data->outmin = mpr_func_spec[data->function].output_min;
401 data->outmax = mpr_func_spec[data->function].output_max;
402
403 odelta = data->outmax - data->outmin;
404 pdelta = data->pmax - data->pmin;
405
406 data->scale = div_s64_rem(div_s64(pdelta * NANO, odelta), NANO, &tmp);
407 data->scale2 = tmp;
408
409 data->offset = div_s64(odelta * data->pmin, pdelta) - data->outmin;
410
411 if (data->irq > 0) {
412 ret = devm_request_irq(dev, data->irq, mpr_eoc_handler, 0,
413 dev_name(dev), data);
414 if (ret)
415 return ret;
416 }
417
418 data->gpiod_reset = devm_gpiod_get_optional(dev, "reset",
419 GPIOD_OUT_HIGH);
420 if (IS_ERR(data->gpiod_reset))
421 return dev_err_probe(dev, PTR_ERR(data->gpiod_reset),
422 "request reset-gpio failed\n");
423
424 mpr_reset(data);
425
426 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL,
427 mpr_trigger_handler, NULL);
428 if (ret)
429 return dev_err_probe(dev, ret,
430 "iio triggered buffer setup failed\n");
431
432 ret = devm_iio_device_register(dev, indio_dev);
433 if (ret)
434 return dev_err_probe(dev, ret,
435 "unable to register iio device\n");
436
437 return 0;
438 }
439 EXPORT_SYMBOL_NS(mpr_common_probe, "IIO_HONEYWELL_MPRLS0025PA");
440
441 MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>");
442 MODULE_DESCRIPTION("Honeywell MPR pressure sensor core driver");
443 MODULE_LICENSE("GPL");
444