1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Copyright (c) 2010 Christoph Mair <christoph.mair@gmail.com>
4	* Copyright (c) 2012 Bosch Sensortec GmbH
5	* Copyright (c) 2012 Unixphere AB
6	* Copyright (c) 2014 Intel Corporation
7	* Copyright (c) 2016 Linus Walleij <linus.walleij@linaro.org>
8	*
9	* Driver for Bosch Sensortec BMP180 and BMP280 digital pressure sensor.
10	*
11	* Datasheet:
12	* https://cdn-shop.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf
13	* https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf
14	* https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bme280-ds002.pdf
15	* https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp388-ds001.pdf
16	* https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp390-ds002.pdf
17	* https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp581-ds004.pdf
18	*
19	* Sensor API:
20	* https://github.com/boschsensortec/BME280_SensorAPI
21	* https://github.com/boschsensortec/BMP3_SensorAPI
22	* https://github.com/boschsensortec/BMP5_SensorAPI
23	*
24	* Notice:
25	* The link to the bmp180 datasheet points to an outdated version missing these changes:
26	* - Changed document referral from ANP015 to BST-MPS-AN004-00 on page 26
27	* - Updated equation for B3 param on section 3.5 to ((((long)AC1 * 4 + X3) << oss) + 2) / 4
28	* - Updated RoHS directive to 2011/65/EU effective 8 June 2011 on page 26
29	*/
30
31	#define pr_fmt(fmt) "bmp280: " fmt
32
33	#include <linux/bitops.h>
34	#include <linux/bitfield.h>
35	#include <linux/cleanup.h>
36	#include <linux/completion.h>
37	#include <linux/delay.h>
38	#include <linux/device.h>
39	#include <linux/gpio/consumer.h>
40	#include <linux/interrupt.h>
41	#include <linux/irq.h> /* For irq_get_irq_data() */
42	#include <linux/module.h>
43	#include <linux/nvmem-provider.h>
44	#include <linux/pm_runtime.h>
45	#include <linux/property.h>
46	#include <linux/random.h>
47	#include <linux/regmap.h>
48	#include <linux/regulator/consumer.h>
49	#include <linux/types.h>
50
51	#include <linux/iio/buffer.h>
52	#include <linux/iio/iio.h>
53	#include <linux/iio/trigger.h>
54	#include <linux/iio/trigger_consumer.h>
55	#include <linux/iio/triggered_buffer.h>
56
57	#include <linux/unaligned.h>
58
59	#include "bmp280.h"
60
61	/*
62	* These enums are used for indexing into the array of calibration
63	* coefficients for BMP180.
64	*/
65	enum { AC1, AC2, AC3, AC4, AC5, AC6, B1, B2, MB, MC, MD };
66
67	enum bmp380_odr {
68	BMP380_ODR_200HZ,
69	BMP380_ODR_100HZ,
70	BMP380_ODR_50HZ,
71	BMP380_ODR_25HZ,
72	BMP380_ODR_12_5HZ,
73	BMP380_ODR_6_25HZ,
74	BMP380_ODR_3_125HZ,
75	BMP380_ODR_1_5625HZ,
76	BMP380_ODR_0_78HZ,
77	BMP380_ODR_0_39HZ,
78	BMP380_ODR_0_2HZ,
79	BMP380_ODR_0_1HZ,
80	BMP380_ODR_0_05HZ,
81	BMP380_ODR_0_02HZ,
82	BMP380_ODR_0_01HZ,
83	BMP380_ODR_0_006HZ,
84	BMP380_ODR_0_003HZ,
85	BMP380_ODR_0_0015HZ,
86	};
87
88	enum bmp580_odr {
89	BMP580_ODR_240HZ,
90	BMP580_ODR_218HZ,
91	BMP580_ODR_199HZ,
92	BMP580_ODR_179HZ,
93	BMP580_ODR_160HZ,
94	BMP580_ODR_149HZ,
95	BMP580_ODR_140HZ,
96	BMP580_ODR_129HZ,
97	BMP580_ODR_120HZ,
98	BMP580_ODR_110HZ,
99	BMP580_ODR_100HZ,
100	BMP580_ODR_89HZ,
101	BMP580_ODR_80HZ,
102	BMP580_ODR_70HZ,
103	BMP580_ODR_60HZ,
104	BMP580_ODR_50HZ,
105	BMP580_ODR_45HZ,
106	BMP580_ODR_40HZ,
107	BMP580_ODR_35HZ,
108	BMP580_ODR_30HZ,
109	BMP580_ODR_25HZ,
110	BMP580_ODR_20HZ,
111	BMP580_ODR_15HZ,
112	BMP580_ODR_10HZ,
113	BMP580_ODR_5HZ,
114	BMP580_ODR_4HZ,
115	BMP580_ODR_3HZ,
116	BMP580_ODR_2HZ,
117	BMP580_ODR_1HZ,
118	BMP580_ODR_0_5HZ,
119	BMP580_ODR_0_25HZ,
120	BMP580_ODR_0_125HZ,
121	};
122
123	/*
124	* These enums are used for indexing into the array of compensation
125	* parameters for BMP280.
126	*/
127	enum { T1, T2, T3, P1, P2, P3, P4, P5, P6, P7, P8, P9 };
128
129	enum {
130	/* Temperature calib indexes */
131	BMP380_T1 = 0,
132	BMP380_T2 = 2,
133	BMP380_T3 = 4,
134	/* Pressure calib indexes */
135	BMP380_P1 = 5,
136	BMP380_P2 = 7,
137	BMP380_P3 = 9,
138	BMP380_P4 = 10,
139	BMP380_P5 = 11,
140	BMP380_P6 = 13,
141	BMP380_P7 = 15,
142	BMP380_P8 = 16,
143	BMP380_P9 = 17,
144	BMP380_P10 = 19,
145	BMP380_P11 = 20,
146	};
147
148	enum bmp280_scan {
149	BMP280_PRESS,
150	BMP280_TEMP,
151	BME280_HUMID,
152	};
153
154	static const struct iio_chan_spec bmp280_channels[] = {
155	{
156	.type = IIO_PRESSURE,
157	/* PROCESSED maintained for ABI backwards compatibility */
158	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
159	BIT(IIO_CHAN_INFO_RAW) |
160	BIT(IIO_CHAN_INFO_SCALE) |
161	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
162	.scan_index = 0,
163	.scan_type = {
164	.sign = 'u',
165	.realbits = 32,
166	.storagebits = 32,
167	.endianness = IIO_CPU,
168	},
169	},
170	{
171	.type = IIO_TEMP,
172	/* PROCESSED maintained for ABI backwards compatibility */
173	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
174	BIT(IIO_CHAN_INFO_RAW) |
175	BIT(IIO_CHAN_INFO_SCALE) |
176	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
177	.scan_index = 1,
178	.scan_type = {
179	.sign = 's',
180	.realbits = 32,
181	.storagebits = 32,
182	.endianness = IIO_CPU,
183	},
184	},
185	IIO_CHAN_SOFT_TIMESTAMP(2),
186	};
187
188	static const struct iio_chan_spec bme280_channels[] = {
189	{
190	.type = IIO_PRESSURE,
191	/* PROCESSED maintained for ABI backwards compatibility */
192	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
193	BIT(IIO_CHAN_INFO_RAW) |
194	BIT(IIO_CHAN_INFO_SCALE) |
195	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
196	.scan_index = 0,
197	.scan_type = {
198	.sign = 'u',
199	.realbits = 32,
200	.storagebits = 32,
201	.endianness = IIO_CPU,
202	},
203	},
204	{
205	.type = IIO_TEMP,
206	/* PROCESSED maintained for ABI backwards compatibility */
207	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
208	BIT(IIO_CHAN_INFO_RAW) |
209	BIT(IIO_CHAN_INFO_SCALE) |
210	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
211	.scan_index = 1,
212	.scan_type = {
213	.sign = 's',
214	.realbits = 32,
215	.storagebits = 32,
216	.endianness = IIO_CPU,
217	},
218	},
219	{
220	.type = IIO_HUMIDITYRELATIVE,
221	/* PROCESSED maintained for ABI backwards compatibility */
222	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
223	BIT(IIO_CHAN_INFO_RAW) |
224	BIT(IIO_CHAN_INFO_SCALE) |
225	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
226	.scan_index = 2,
227	.scan_type = {
228	.sign = 'u',
229	.realbits = 32,
230	.storagebits = 32,
231	.endianness = IIO_CPU,
232	},
233	},
234	IIO_CHAN_SOFT_TIMESTAMP(3),
235	};
236
237	static const struct iio_chan_spec bmp380_channels[] = {
238	{
239	.type = IIO_PRESSURE,
240	/* PROCESSED maintained for ABI backwards compatibility */
241	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
242	BIT(IIO_CHAN_INFO_RAW) |
243	BIT(IIO_CHAN_INFO_SCALE) |
244	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
245	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) |
246	BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),
247	.scan_index = 0,
248	.scan_type = {
249	.sign = 'u',
250	.realbits = 32,
251	.storagebits = 32,
252	.endianness = IIO_CPU,
253	},
254	},
255	{
256	.type = IIO_TEMP,
257	/* PROCESSED maintained for ABI backwards compatibility */
258	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
259	BIT(IIO_CHAN_INFO_RAW) |
260	BIT(IIO_CHAN_INFO_SCALE) |
261	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
262	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) |
263	BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),
264	.scan_index = 1,
265	.scan_type = {
266	.sign = 's',
267	.realbits = 32,
268	.storagebits = 32,
269	.endianness = IIO_CPU,
270	},
271	},
272	IIO_CHAN_SOFT_TIMESTAMP(2),
273	};
274
275	static const struct iio_chan_spec bmp580_channels[] = {
276	{
277	.type = IIO_PRESSURE,
278	/* PROCESSED maintained for ABI backwards compatibility */
279	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
280	BIT(IIO_CHAN_INFO_RAW) |
281	BIT(IIO_CHAN_INFO_SCALE) |
282	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
283	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) |
284	BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),
285	.scan_index = 0,
286	.scan_type = {
287	.sign = 'u',
288	.realbits = 24,
289	.storagebits = 32,
290	.endianness = IIO_LE,
291	},
292	},
293	{
294	.type = IIO_TEMP,
295	/* PROCESSED maintained for ABI backwards compatibility */
296	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
297	BIT(IIO_CHAN_INFO_RAW) |
298	BIT(IIO_CHAN_INFO_SCALE) |
299	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
300	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) |
301	BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),
302	.scan_index = 1,
303	.scan_type = {
304	.sign = 's',
305	.realbits = 24,
306	.storagebits = 32,
307	.endianness = IIO_LE,
308	},
309	},
310	IIO_CHAN_SOFT_TIMESTAMP(2),
311	};
312
313	static int bmp280_read_calib(struct bmp280_data *data)
314	{
315	struct bmp280_calib *calib = &data->calib.bmp280;
316	int ret;
317
318	/* Read temperature and pressure calibration values. */
319	ret = regmap_bulk_read(map: data->regmap, BMP280_REG_COMP_TEMP_START,
320	val: data->bmp280_cal_buf,
321	val_count: sizeof(data->bmp280_cal_buf));
322	if (ret) {
323	dev_err(data->dev,
324	"failed to read calibration parameters\n");
325	return ret;
326	}
327
328	/* Toss calibration data into the entropy pool */
329	add_device_randomness(buf: data->bmp280_cal_buf,
330	len: sizeof(data->bmp280_cal_buf));
331
332	/* Parse temperature calibration values. */
333	calib->T1 = le16_to_cpu(data->bmp280_cal_buf[T1]);
334	calib->T2 = le16_to_cpu(data->bmp280_cal_buf[T2]);
335	calib->T3 = le16_to_cpu(data->bmp280_cal_buf[T3]);
336
337	/* Parse pressure calibration values. */
338	calib->P1 = le16_to_cpu(data->bmp280_cal_buf[P1]);
339	calib->P2 = le16_to_cpu(data->bmp280_cal_buf[P2]);
340	calib->P3 = le16_to_cpu(data->bmp280_cal_buf[P3]);
341	calib->P4 = le16_to_cpu(data->bmp280_cal_buf[P4]);
342	calib->P5 = le16_to_cpu(data->bmp280_cal_buf[P5]);
343	calib->P6 = le16_to_cpu(data->bmp280_cal_buf[P6]);
344	calib->P7 = le16_to_cpu(data->bmp280_cal_buf[P7]);
345	calib->P8 = le16_to_cpu(data->bmp280_cal_buf[P8]);
346	calib->P9 = le16_to_cpu(data->bmp280_cal_buf[P9]);
347
348	return 0;
349	}
350
351	/*
352	* These enums are used for indexing into the array of humidity parameters
353	* for BME280. Due to some weird indexing, unaligned BE/LE accesses co-exist in
354	* order to prepare the FIELD_{GET/PREP}() fields. Table 16 in Section 4.2.2 of
355	* the datasheet.
356	*/
357	enum { H2 = 0, H3 = 2, H4 = 3, H5 = 4, H6 = 6 };
358
359	static int bme280_read_calib(struct bmp280_data *data)
360	{
361	struct bmp280_calib *calib = &data->calib.bmp280;
362	struct device *dev = data->dev;
363	s16 h4_upper, h4_lower, tmp_1, tmp_2, tmp_3;
364	unsigned int tmp;
365	int ret;
366
367	/* Load shared calibration params with bmp280 first */
368	ret = bmp280_read_calib(data);
369	if (ret)
370	return ret;
371
372	ret = regmap_read(map: data->regmap, BME280_REG_COMP_H1, val: &tmp);
373	if (ret) {
374	dev_err(dev, "failed to read H1 comp value\n");
375	return ret;
376	}
377	calib->H1 = tmp;
378
379	ret = regmap_bulk_read(map: data->regmap, BME280_REG_COMP_H2,
380	val: data->bme280_humid_cal_buf,
381	val_count: sizeof(data->bme280_humid_cal_buf));
382	if (ret) {
383	dev_err(dev, "failed to read humidity calibration values\n");
384	return ret;
385	}
386
387	calib->H2 = get_unaligned_le16(p: &data->bme280_humid_cal_buf[H2]);
388	calib->H3 = data->bme280_humid_cal_buf[H3];
389	tmp_1 = get_unaligned_be16(p: &data->bme280_humid_cal_buf[H4]);
390	tmp_2 = FIELD_GET(BME280_COMP_H4_GET_MASK_UP, tmp_1);
391	h4_upper = FIELD_PREP(BME280_COMP_H4_PREP_MASK_UP, tmp_2);
392	h4_lower = FIELD_GET(BME280_COMP_H4_MASK_LOW, tmp_1);
393	calib->H4 = sign_extend32(value: h4_upper | h4_lower, index: 11);
394	tmp_3 = get_unaligned_le16(p: &data->bme280_humid_cal_buf[H5]);
395	calib->H5 = sign_extend32(FIELD_GET(BME280_COMP_H5_MASK, tmp_3), index: 11);
396	calib->H6 = data->bme280_humid_cal_buf[H6];
397
398	return 0;
399	}
400
401	static int bme280_read_humid_adc(struct bmp280_data *data, u16 *adc_humidity)
402	{
403	u16 value_humidity;
404	int ret;
405
406	ret = regmap_bulk_read(map: data->regmap, BME280_REG_HUMIDITY_MSB,
407	val: &data->be16, BME280_NUM_HUMIDITY_BYTES);
408	if (ret) {
409	dev_err(data->dev, "failed to read humidity\n");
410	return ret;
411	}
412
413	value_humidity = be16_to_cpu(data->be16);
414	if (value_humidity == BMP280_HUMIDITY_SKIPPED) {
415	dev_err(data->dev, "reading humidity skipped\n");
416	return -EIO;
417	}
418	*adc_humidity = value_humidity;
419
420	return 0;
421	}
422
423	/*
424	* Returns humidity in percent, resolution is 0.01 percent. Output value of
425	* "47445" represents 47445/1024 = 46.333 %RH.
426	*
427	* Taken from BME280 datasheet, Section 4.2.3, "Compensation formula".
428	*/
429	static u32 bme280_compensate_humidity(struct bmp280_data *data,
430	u16 adc_humidity, s32 t_fine)
431	{
432	struct bmp280_calib *calib = &data->calib.bmp280;
433	s32 var;
434
435	var = t_fine - (s32)76800;
436	var = (((((s32)adc_humidity << 14) - (calib->H4 << 20) - (calib->H5 * var))
437	+ (s32)16384) >> 15) * (((((((var * calib->H6) >> 10)
438	* (((var * (s32)calib->H3) >> 11) + (s32)32768)) >> 10)
439	+ (s32)2097152) * calib->H2 + 8192) >> 14);
440	var -= ((((var >> 15) * (var >> 15)) >> 7) * (s32)calib->H1) >> 4;
441
442	var = clamp_val(var, 0, 419430400);
443
444	return var >> 12;
445	}
446
447	static int bmp280_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
448	{
449	u32 value_temp;
450	int ret;
451
452	ret = regmap_bulk_read(map: data->regmap, BMP280_REG_TEMP_MSB,
453	val: data->buf, BMP280_NUM_TEMP_BYTES);
454	if (ret) {
455	dev_err(data->dev, "failed to read temperature\n");
456	return ret;
457	}
458
459	value_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(data->buf));
460	if (value_temp == BMP280_TEMP_SKIPPED) {
461	dev_err(data->dev, "reading temperature skipped\n");
462	return -EIO;
463	}
464	*adc_temp = value_temp;
465
466	return 0;
467	}
468
469	/*
470	* Returns temperature in DegC, resolution is 0.01 DegC. Output value of
471	* "5123" equals 51.23 DegC. t_fine carries fine temperature as global
472	* value.
473	*
474	* Taken from datasheet, Section 3.11.3, "Compensation formula".
475	*/
476	static s32 bmp280_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
477	{
478	struct bmp280_calib *calib = &data->calib.bmp280;
479	s32 var1, var2;
480
481	var1 = (((((s32)adc_temp) >> 3) - ((s32)calib->T1 << 1)) *
482	((s32)calib->T2)) >> 11;
483	var2 = (((((((s32)adc_temp) >> 4) - ((s32)calib->T1)) *
484	((((s32)adc_temp >> 4) - ((s32)calib->T1))) >> 12) *
485	((s32)calib->T3))) >> 14;
486	return var1 + var2; /* t_fine = var1 + var2 */
487	}
488
489	static int bmp280_get_t_fine(struct bmp280_data *data, s32 *t_fine)
490	{
491	u32 adc_temp;
492	int ret;
493
494	ret = bmp280_read_temp_adc(data, adc_temp: &adc_temp);
495	if (ret)
496	return ret;
497
498	*t_fine = bmp280_calc_t_fine(data, adc_temp);
499
500	return 0;
501	}
502
503	static s32 bmp280_compensate_temp(struct bmp280_data *data, u32 adc_temp)
504	{
505	return (bmp280_calc_t_fine(data, adc_temp) * 5 + 128) / 256;
506	}
507
508	static int bmp280_read_press_adc(struct bmp280_data *data, u32 *adc_press)
509	{
510	u32 value_press;
511	int ret;
512
513	ret = regmap_bulk_read(map: data->regmap, BMP280_REG_PRESS_MSB,
514	val: data->buf, BMP280_NUM_PRESS_BYTES);
515	if (ret) {
516	dev_err(data->dev, "failed to read pressure\n");
517	return ret;
518	}
519
520	value_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(data->buf));
521	if (value_press == BMP280_PRESS_SKIPPED) {
522	dev_err(data->dev, "reading pressure skipped\n");
523	return -EIO;
524	}
525	*adc_press = value_press;
526
527	return 0;
528	}
529
530	/*
531	* Returns pressure in Pa as unsigned 32 bit integer in Q24.8 format (24
532	* integer bits and 8 fractional bits). Output value of "24674867"
533	* represents 24674867/256 = 96386.2 Pa = 963.862 hPa
534	*
535	* Taken from datasheet, Section 3.11.3, "Compensation formula".
536	*/
537	static u32 bmp280_compensate_press(struct bmp280_data *data,
538	u32 adc_press, s32 t_fine)
539	{
540	struct bmp280_calib *calib = &data->calib.bmp280;
541	s64 var1, var2, p;
542
543	var1 = ((s64)t_fine) - 128000;
544	var2 = var1 * var1 * (s64)calib->P6;
545	var2 += (var1 * (s64)calib->P5) << 17;
546	var2 += ((s64)calib->P4) << 35;
547	var1 = ((var1 * var1 * (s64)calib->P3) >> 8) +
548	((var1 * (s64)calib->P2) << 12);
549	var1 = ((((s64)1) << 47) + var1) * ((s64)calib->P1) >> 33;
550
551	if (var1 == 0)
552	return 0;
553
554	p = ((((s64)1048576 - (s32)adc_press) << 31) - var2) * 3125;
555	p = div64_s64(dividend: p, divisor: var1);
556	var1 = (((s64)calib->P9) * (p >> 13) * (p >> 13)) >> 25;
557	var2 = ((s64)(calib->P8) * p) >> 19;
558	p = ((p + var1 + var2) >> 8) + (((s64)calib->P7) << 4);
559
560	return (u32)p;
561	}
562
563	static int bmp280_read_temp(struct bmp280_data *data, s32 *comp_temp)
564	{
565	u32 adc_temp;
566	int ret;
567
568	ret = bmp280_read_temp_adc(data, adc_temp: &adc_temp);
569	if (ret)
570	return ret;
571
572	*comp_temp = bmp280_compensate_temp(data, adc_temp);
573
574	return 0;
575	}
576
577	static int bmp280_read_press(struct bmp280_data *data, u32 *comp_press)
578	{
579	u32 adc_press;
580	s32 t_fine;
581	int ret;
582
583	ret = bmp280_get_t_fine(data, t_fine: &t_fine);
584	if (ret)
585	return ret;
586
587	ret = bmp280_read_press_adc(data, adc_press: &adc_press);
588	if (ret)
589	return ret;
590
591	*comp_press = bmp280_compensate_press(data, adc_press, t_fine);
592
593	return 0;
594	}
595
596	static int bme280_read_humid(struct bmp280_data *data, u32 *comp_humidity)
597	{
598	u16 adc_humidity;
599	s32 t_fine;
600	int ret;
601
602	ret = bmp280_get_t_fine(data, t_fine: &t_fine);
603	if (ret)
604	return ret;
605
606	ret = bme280_read_humid_adc(data, adc_humidity: &adc_humidity);
607	if (ret)
608	return ret;
609
610	*comp_humidity = bme280_compensate_humidity(data, adc_humidity, t_fine);
611
612	return 0;
613	}
614
615	static int bmp280_read_raw_impl(struct iio_dev *indio_dev,
616	struct iio_chan_spec const *chan,
617	int *val, int *val2, long mask)
618	{
619	struct bmp280_data *data = iio_priv(indio_dev);
620	int chan_value;
621	int ret;
622
623	guard(mutex)(T: &data->lock);
624
625	switch (mask) {
626	case IIO_CHAN_INFO_PROCESSED:
627	ret = data->chip_info->set_mode(data, BMP280_FORCED);
628	if (ret)
629	return ret;
630
631	ret = data->chip_info->wait_conv(data);
632	if (ret)
633	return ret;
634
635	switch (chan->type) {
636	case IIO_HUMIDITYRELATIVE:
637	ret = data->chip_info->read_humid(data, &chan_value);
638	if (ret)
639	return ret;
640
641	*val = data->chip_info->humid_coeffs[0] * chan_value;
642	*val2 = data->chip_info->humid_coeffs[1];
643	return data->chip_info->humid_coeffs_type;
644	case IIO_PRESSURE:
645	ret = data->chip_info->read_press(data, &chan_value);
646	if (ret)
647	return ret;
648
649	*val = data->chip_info->press_coeffs[0] * chan_value;
650	*val2 = data->chip_info->press_coeffs[1];
651	return data->chip_info->press_coeffs_type;
652	case IIO_TEMP:
653	ret = data->chip_info->read_temp(data, &chan_value);
654	if (ret)
655	return ret;
656
657	*val = data->chip_info->temp_coeffs[0] * chan_value;
658	*val2 = data->chip_info->temp_coeffs[1];
659	return data->chip_info->temp_coeffs_type;
660	default:
661	return -EINVAL;
662	}
663	case IIO_CHAN_INFO_RAW:
664	ret = data->chip_info->set_mode(data, BMP280_FORCED);
665	if (ret)
666	return ret;
667
668	ret = data->chip_info->wait_conv(data);
669	if (ret)
670	return ret;
671
672	switch (chan->type) {
673	case IIO_HUMIDITYRELATIVE:
674	ret = data->chip_info->read_humid(data, &chan_value);
675	if (ret)
676	return ret;
677
678	*val = chan_value;
679	return IIO_VAL_INT;
680	case IIO_PRESSURE:
681	ret = data->chip_info->read_press(data, &chan_value);
682	if (ret)
683	return ret;
684
685	*val = chan_value;
686	return IIO_VAL_INT;
687	case IIO_TEMP:
688	ret = data->chip_info->read_temp(data, &chan_value);
689	if (ret)
690	return ret;
691
692	*val = chan_value;
693	return IIO_VAL_INT;
694	default:
695	return -EINVAL;
696	}
697	case IIO_CHAN_INFO_SCALE:
698	switch (chan->type) {
699	case IIO_HUMIDITYRELATIVE:
700	*val = data->chip_info->humid_coeffs[0];
701	*val2 = data->chip_info->humid_coeffs[1];
702	return data->chip_info->humid_coeffs_type;
703	case IIO_PRESSURE:
704	*val = data->chip_info->press_coeffs[0];
705	*val2 = data->chip_info->press_coeffs[1];
706	return data->chip_info->press_coeffs_type;
707	case IIO_TEMP:
708	*val = data->chip_info->temp_coeffs[0];
709	*val2 = data->chip_info->temp_coeffs[1];
710	return data->chip_info->temp_coeffs_type;
711	default:
712	return -EINVAL;
713	}
714	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
715	switch (chan->type) {
716	case IIO_HUMIDITYRELATIVE:
717	*val = 1 << data->oversampling_humid;
718	return IIO_VAL_INT;
719	case IIO_PRESSURE:
720	*val = 1 << data->oversampling_press;
721	return IIO_VAL_INT;
722	case IIO_TEMP:
723	*val = 1 << data->oversampling_temp;
724	return IIO_VAL_INT;
725	default:
726	return -EINVAL;
727	}
728	case IIO_CHAN_INFO_SAMP_FREQ:
729	if (!data->chip_info->sampling_freq_avail)
730	return -EINVAL;
731
732	*val = data->chip_info->sampling_freq_avail[data->sampling_freq][0];
733	*val2 = data->chip_info->sampling_freq_avail[data->sampling_freq][1];
734	return IIO_VAL_INT_PLUS_MICRO;
735	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
736	if (!data->chip_info->iir_filter_coeffs_avail)
737	return -EINVAL;
738
739	*val = (1 << data->iir_filter_coeff) - 1;
740	return IIO_VAL_INT;
741	default:
742	return -EINVAL;
743	}
744	}
745
746	static int bmp280_read_raw(struct iio_dev *indio_dev,
747	struct iio_chan_spec const *chan,
748	int *val, int *val2, long mask)
749	{
750	struct bmp280_data *data = iio_priv(indio_dev);
751	int ret;
752
753	pm_runtime_get_sync(dev: data->dev);
754	ret = bmp280_read_raw_impl(indio_dev, chan, val, val2, mask);
755	pm_runtime_mark_last_busy(dev: data->dev);
756	pm_runtime_put_autosuspend(dev: data->dev);
757
758	return ret;
759	}
760
761	static int bme280_write_oversampling_ratio_humid(struct bmp280_data *data,
762	int val)
763	{
764	const int *avail = data->chip_info->oversampling_humid_avail;
765	const int n = data->chip_info->num_oversampling_humid_avail;
766	int ret, prev;
767	int i;
768
769	for (i = 0; i < n; i++) {
770	if (avail[i] == val) {
771	prev = data->oversampling_humid;
772	data->oversampling_humid = ilog2(val);
773
774	ret = data->chip_info->chip_config(data);
775	if (ret) {
776	data->oversampling_humid = prev;
777	data->chip_info->chip_config(data);
778	return ret;
779	}
780	return 0;
781	}
782	}
783	return -EINVAL;
784	}
785
786	static int bmp280_write_oversampling_ratio_temp(struct bmp280_data *data,
787	int val)
788	{
789	const int *avail = data->chip_info->oversampling_temp_avail;
790	const int n = data->chip_info->num_oversampling_temp_avail;
791	int ret, prev;
792	int i;
793
794	for (i = 0; i < n; i++) {
795	if (avail[i] == val) {
796	prev = data->oversampling_temp;
797	data->oversampling_temp = ilog2(val);
798
799	ret = data->chip_info->chip_config(data);
800	if (ret) {
801	data->oversampling_temp = prev;
802	data->chip_info->chip_config(data);
803	return ret;
804	}
805	return 0;
806	}
807	}
808	return -EINVAL;
809	}
810
811	static int bmp280_write_oversampling_ratio_press(struct bmp280_data *data,
812	int val)
813	{
814	const int *avail = data->chip_info->oversampling_press_avail;
815	const int n = data->chip_info->num_oversampling_press_avail;
816	int ret, prev;
817	int i;
818
819	for (i = 0; i < n; i++) {
820	if (avail[i] == val) {
821	prev = data->oversampling_press;
822	data->oversampling_press = ilog2(val);
823
824	ret = data->chip_info->chip_config(data);
825	if (ret) {
826	data->oversampling_press = prev;
827	data->chip_info->chip_config(data);
828	return ret;
829	}
830	return 0;
831	}
832	}
833	return -EINVAL;
834	}
835
836	static int bmp280_write_sampling_frequency(struct bmp280_data *data,
837	int val, int val2)
838	{
839	const int (*avail)[2] = data->chip_info->sampling_freq_avail;
840	const int n = data->chip_info->num_sampling_freq_avail;
841	int ret, prev;
842	int i;
843
844	for (i = 0; i < n; i++) {
845	if (avail[i][0] == val && avail[i][1] == val2) {
846	prev = data->sampling_freq;
847	data->sampling_freq = i;
848
849	ret = data->chip_info->chip_config(data);
850	if (ret) {
851	data->sampling_freq = prev;
852	data->chip_info->chip_config(data);
853	return ret;
854	}
855	return 0;
856	}
857	}
858	return -EINVAL;
859	}
860
861	static int bmp280_write_iir_filter_coeffs(struct bmp280_data *data, int val)
862	{
863	const int *avail = data->chip_info->iir_filter_coeffs_avail;
864	const int n = data->chip_info->num_iir_filter_coeffs_avail;
865	int ret, prev;
866	int i;
867
868	for (i = 0; i < n; i++) {
869	if (avail[i] - 1 == val) {
870	prev = data->iir_filter_coeff;
871	data->iir_filter_coeff = i;
872
873	ret = data->chip_info->chip_config(data);
874	if (ret) {
875	data->iir_filter_coeff = prev;
876	data->chip_info->chip_config(data);
877	return ret;
878
879	}
880	return 0;
881	}
882	}
883	return -EINVAL;
884	}
885
886	static int bmp280_write_raw_impl(struct iio_dev *indio_dev,
887	struct iio_chan_spec const *chan,
888	int val, int val2, long mask)
889	{
890	struct bmp280_data *data = iio_priv(indio_dev);
891
892	guard(mutex)(T: &data->lock);
893
894	/*
895	* Helper functions to update sensor running configuration.
896	* If an error happens applying new settings, will try restore
897	* previous parameters to ensure the sensor is left in a known
898	* working configuration.
899	*/
900	switch (mask) {
901	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
902	switch (chan->type) {
903	case IIO_HUMIDITYRELATIVE:
904	return bme280_write_oversampling_ratio_humid(data, val);
905	case IIO_PRESSURE:
906	return bmp280_write_oversampling_ratio_press(data, val);
907	case IIO_TEMP:
908	return bmp280_write_oversampling_ratio_temp(data, val);
909	default:
910	return -EINVAL;
911	}
912	case IIO_CHAN_INFO_SAMP_FREQ:
913	return bmp280_write_sampling_frequency(data, val, val2);
914	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
915	return bmp280_write_iir_filter_coeffs(data, val);
916	default:
917	return -EINVAL;
918	}
919	}
920
921	static int bmp280_write_raw(struct iio_dev *indio_dev,
922	struct iio_chan_spec const *chan,
923	int val, int val2, long mask)
924	{
925	struct bmp280_data *data = iio_priv(indio_dev);
926	int ret;
927
928	pm_runtime_get_sync(dev: data->dev);
929	ret = bmp280_write_raw_impl(indio_dev, chan, val, val2, mask);
930	pm_runtime_mark_last_busy(dev: data->dev);
931	pm_runtime_put_autosuspend(dev: data->dev);
932
933	return ret;
934	}
935
936	static int bmp280_read_avail(struct iio_dev *indio_dev,
937	struct iio_chan_spec const *chan,
938	const int **vals, int *type, int *length,
939	long mask)
940	{
941	struct bmp280_data *data = iio_priv(indio_dev);
942
943	switch (mask) {
944	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
945	switch (chan->type) {
946	case IIO_PRESSURE:
947	*vals = data->chip_info->oversampling_press_avail;
948	*length = data->chip_info->num_oversampling_press_avail;
949	break;
950	case IIO_TEMP:
951	*vals = data->chip_info->oversampling_temp_avail;
952	*length = data->chip_info->num_oversampling_temp_avail;
953	break;
954	default:
955	return -EINVAL;
956	}
957	*type = IIO_VAL_INT;
958	return IIO_AVAIL_LIST;
959	case IIO_CHAN_INFO_SAMP_FREQ:
960	*vals = (const int *)data->chip_info->sampling_freq_avail;
961	*type = IIO_VAL_INT_PLUS_MICRO;
962	/* Values are stored in a 2D matrix */
963	*length = data->chip_info->num_sampling_freq_avail;
964	return IIO_AVAIL_LIST;
965	case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
966	*vals = data->chip_info->iir_filter_coeffs_avail;
967	*type = IIO_VAL_INT;
968	*length = data->chip_info->num_iir_filter_coeffs_avail;
969	return IIO_AVAIL_LIST;
970	default:
971	return -EINVAL;
972	}
973	}
974
975	static const struct iio_info bmp280_info = {
976	.read_raw = &bmp280_read_raw,
977	.read_avail = &bmp280_read_avail,
978	.write_raw = &bmp280_write_raw,
979	};
980
981	static const unsigned long bmp280_avail_scan_masks[] = {
982	BIT(BMP280_TEMP) | BIT(BMP280_PRESS),
983	0
984	};
985
986	static const unsigned long bme280_avail_scan_masks[] = {
987	BIT(BME280_HUMID) | BIT(BMP280_TEMP) | BIT(BMP280_PRESS),
988	0
989	};
990
991	static int bmp280_preinit(struct bmp280_data *data)
992	{
993	struct device *dev = data->dev;
994	unsigned int reg;
995	int ret;
996
997	ret = regmap_write(map: data->regmap, BMP280_REG_RESET, BMP280_RST_SOFT_CMD);
998	if (ret)
999	return dev_err_probe(dev, err: ret, fmt: "Failed to reset device.\n");
1000
1001	/*
1002	* According to the datasheet in Chapter 1: Specification, Table 2,
1003	* after resetting, the device uses the complete power-on sequence so
1004	* it needs to wait for the defined start-up time.
1005	*/
1006	fsleep(usecs: data->start_up_time_us);
1007
1008	ret = regmap_read(map: data->regmap, BMP280_REG_STATUS, val: &reg);
1009	if (ret)
1010	return dev_err_probe(dev, err: ret, fmt: "Failed to read status register.\n");
1011
1012	if (reg & BMP280_REG_STATUS_IM_UPDATE)
1013	return dev_err_probe(dev, err: -EIO, fmt: "Failed to copy NVM contents.\n");
1014
1015	return 0;
1016	}
1017
1018	static const u8 bmp280_operation_mode[] = {
1019	[BMP280_SLEEP] = BMP280_MODE_SLEEP,
1020	[BMP280_FORCED] = BMP280_MODE_FORCED,
1021	[BMP280_NORMAL] = BMP280_MODE_NORMAL,
1022	};
1023
1024	static int bmp280_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
1025	{
1026	int ret;
1027
1028	ret = regmap_write_bits(map: data->regmap, BMP280_REG_CTRL_MEAS,
1029	BMP280_MODE_MASK, val: bmp280_operation_mode[mode]);
1030	if (ret) {
1031	dev_err(data->dev, "failed to write ctrl_meas register.\n");
1032	return ret;
1033	}
1034
1035	data->op_mode = mode;
1036
1037	return 0;
1038	}
1039
1040	static int bmp280_wait_conv(struct bmp280_data *data)
1041	{
1042	unsigned int reg, meas_time_us;
1043	int ret;
1044
1045	/* Check if we are using a BME280 device */
1046	if (data->oversampling_humid)
1047	meas_time_us = BMP280_PRESS_HUMID_MEAS_OFFSET +
1048	BIT(data->oversampling_humid) * BMP280_MEAS_DUR;
1049
1050	else
1051	meas_time_us = 0;
1052
1053	/* Pressure measurement time */
1054	meas_time_us += BMP280_PRESS_HUMID_MEAS_OFFSET +
1055	BIT(data->oversampling_press) * BMP280_MEAS_DUR;
1056
1057	/* Temperature measurement time */
1058	meas_time_us += BIT(data->oversampling_temp) * BMP280_MEAS_DUR;
1059
1060	/* Waiting time according to the BM(P/E)2 Sensor API */
1061	fsleep(usecs: meas_time_us);
1062
1063	ret = regmap_read(map: data->regmap, BMP280_REG_STATUS, val: &reg);
1064	if (ret) {
1065	dev_err(data->dev, "failed to read status register.\n");
1066	return ret;
1067	}
1068
1069	if (reg & BMP280_REG_STATUS_MEAS_BIT) {
1070	dev_err(data->dev, "Measurement cycle didn't complete.\n");
1071	return -EBUSY;
1072	}
1073
1074	return 0;
1075	}
1076
1077	static int bmp280_chip_config(struct bmp280_data *data)
1078	{
1079	u8 osrs = FIELD_PREP(BMP280_OSRS_TEMP_MASK, data->oversampling_temp + 1) |
1080	FIELD_PREP(BMP280_OSRS_PRESS_MASK, data->oversampling_press + 1);
1081	int ret;
1082
1083	ret = regmap_write_bits(map: data->regmap, BMP280_REG_CTRL_MEAS,
1084	BMP280_OSRS_TEMP_MASK |
1085	BMP280_OSRS_PRESS_MASK |
1086	BMP280_MODE_MASK,
1087	val: osrs | BMP280_MODE_SLEEP);
1088	if (ret) {
1089	dev_err(data->dev, "failed to write ctrl_meas register\n");
1090	return ret;
1091	}
1092
1093	ret = regmap_update_bits(map: data->regmap, BMP280_REG_CONFIG,
1094	BMP280_FILTER_MASK,
1095	BMP280_FILTER_4X);
1096	if (ret) {
1097	dev_err(data->dev, "failed to write config register\n");
1098	return ret;
1099	}
1100
1101	return ret;
1102	}
1103
1104	static irqreturn_t bmp280_trigger_handler(int irq, void *p)
1105	{
1106	struct iio_poll_func *pf = p;
1107	struct iio_dev *indio_dev = pf->indio_dev;
1108	struct bmp280_data *data = iio_priv(indio_dev);
1109	u32 adc_temp, adc_press;
1110	s32 t_fine;
1111	struct {
1112	u32 comp_press;
1113	s32 comp_temp;
1114	aligned_s64 timestamp;
1115	} buffer;
1116	int ret;
1117
1118	guard(mutex)(T: &data->lock);
1119
1120	/* Burst read data registers */
1121	ret = regmap_bulk_read(map: data->regmap, BMP280_REG_PRESS_MSB,
1122	val: data->buf, BMP280_BURST_READ_BYTES);
1123	if (ret) {
1124	dev_err(data->dev, "failed to burst read sensor data\n");
1125	goto out;
1126	}
1127
1128	/* Temperature calculations */
1129	adc_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[3]));
1130	if (adc_temp == BMP280_TEMP_SKIPPED) {
1131	dev_err(data->dev, "reading temperature skipped\n");
1132	goto out;
1133	}
1134
1135	buffer.comp_temp = bmp280_compensate_temp(data, adc_temp);
1136
1137	/* Pressure calculations */
1138	adc_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[0]));
1139	if (adc_press == BMP280_PRESS_SKIPPED) {
1140	dev_err(data->dev, "reading pressure skipped\n");
1141	goto out;
1142	}
1143
1144	t_fine = bmp280_calc_t_fine(data, adc_temp);
1145	buffer.comp_press = bmp280_compensate_press(data, adc_press, t_fine);
1146
1147	iio_push_to_buffers_with_ts(indio_dev, data: &buffer, data_total_len: sizeof(buffer),
1148	timestamp: iio_get_time_ns(indio_dev));
1149
1150	out:
1151	iio_trigger_notify_done(trig: indio_dev->trig);
1152
1153	return IRQ_HANDLED;
1154	}
1155
1156	static const int bmp280_oversampling_avail[] = { 1, 2, 4, 8, 16 };
1157	static const u8 bmp280_chip_ids[] = { BMP280_CHIP_ID };
1158	static const int bmp280_temp_coeffs[] = { 10, 1 };
1159	static const int bmp280_press_coeffs[] = { 1, 256000 };
1160
1161	const struct bmp280_chip_info bmp280_chip_info = {
1162	.id_reg = BMP280_REG_ID,
1163	.chip_id = bmp280_chip_ids,
1164	.num_chip_id = ARRAY_SIZE(bmp280_chip_ids),
1165	.regmap_config = &bmp280_regmap_config,
1166	.start_up_time_us = 2000,
1167	.channels = bmp280_channels,
1168	.num_channels = ARRAY_SIZE(bmp280_channels),
1169	.avail_scan_masks = bmp280_avail_scan_masks,
1170
1171	.oversampling_temp_avail = bmp280_oversampling_avail,
1172	.num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1173	/*
1174	* Oversampling config values on BMx280 have one additional setting
1175	* that other generations of the family don't:
1176	* The value 0 means the measurement is bypassed instead of
1177	* oversampling set to x1.
1178	*
1179	* To account for this difference, and preserve the same common
1180	* config logic, this is handled later on chip_config callback
1181	* incrementing one unit the oversampling setting.
1182	*/
1183	.oversampling_temp_default = BMP280_OSRS_TEMP_2X - 1,
1184
1185	.oversampling_press_avail = bmp280_oversampling_avail,
1186	.num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1187	.oversampling_press_default = BMP280_OSRS_PRESS_16X - 1,
1188
1189	.temp_coeffs = bmp280_temp_coeffs,
1190	.temp_coeffs_type = IIO_VAL_FRACTIONAL,
1191	.press_coeffs = bmp280_press_coeffs,
1192	.press_coeffs_type = IIO_VAL_FRACTIONAL,
1193
1194	.chip_config = bmp280_chip_config,
1195	.read_temp = bmp280_read_temp,
1196	.read_press = bmp280_read_press,
1197	.read_calib = bmp280_read_calib,
1198	.set_mode = bmp280_set_mode,
1199	.wait_conv = bmp280_wait_conv,
1200	.preinit = bmp280_preinit,
1201
1202	.trigger_handler = bmp280_trigger_handler,
1203	};
1204	EXPORT_SYMBOL_NS(bmp280_chip_info, "IIO_BMP280");
1205
1206	static int bme280_chip_config(struct bmp280_data *data)
1207	{
1208	u8 osrs = FIELD_PREP(BME280_OSRS_HUMIDITY_MASK, data->oversampling_humid + 1);
1209	int ret;
1210
1211	/*
1212	* Oversampling of humidity must be set before oversampling of
1213	* temperature/pressure is set to become effective.
1214	*/
1215	ret = regmap_update_bits(map: data->regmap, BME280_REG_CTRL_HUMIDITY,
1216	BME280_OSRS_HUMIDITY_MASK, val: osrs);
1217	if (ret) {
1218	dev_err(data->dev, "failed to set humidity oversampling");
1219	return ret;
1220	}
1221
1222	return bmp280_chip_config(data);
1223	}
1224
1225	static irqreturn_t bme280_trigger_handler(int irq, void *p)
1226	{
1227	struct iio_poll_func *pf = p;
1228	struct iio_dev *indio_dev = pf->indio_dev;
1229	struct bmp280_data *data = iio_priv(indio_dev);
1230	u32 adc_temp, adc_press, adc_humidity;
1231	s32 t_fine;
1232	struct {
1233	u32 comp_press;
1234	s32 comp_temp;
1235	u32 comp_humidity;
1236	aligned_s64 timestamp;
1237	} buffer;
1238	int ret;
1239
1240	/* Don't leak uninitialized stack to userspace. */
1241	memset(&buffer, 0, sizeof(buffer));
1242
1243	guard(mutex)(T: &data->lock);
1244
1245	/* Burst read data registers */
1246	ret = regmap_bulk_read(map: data->regmap, BMP280_REG_PRESS_MSB,
1247	val: data->buf, BME280_BURST_READ_BYTES);
1248	if (ret) {
1249	dev_err(data->dev, "failed to burst read sensor data\n");
1250	goto out;
1251	}
1252
1253	/* Temperature calculations */
1254	adc_temp = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[3]));
1255	if (adc_temp == BMP280_TEMP_SKIPPED) {
1256	dev_err(data->dev, "reading temperature skipped\n");
1257	goto out;
1258	}
1259
1260	buffer.comp_temp = bmp280_compensate_temp(data, adc_temp);
1261
1262	/* Pressure calculations */
1263	adc_press = FIELD_GET(BMP280_MEAS_TRIM_MASK, get_unaligned_be24(&data->buf[0]));
1264	if (adc_press == BMP280_PRESS_SKIPPED) {
1265	dev_err(data->dev, "reading pressure skipped\n");
1266	goto out;
1267	}
1268
1269	t_fine = bmp280_calc_t_fine(data, adc_temp);
1270	buffer.comp_press = bmp280_compensate_press(data, adc_press, t_fine);
1271
1272	/* Humidity calculations */
1273	adc_humidity = get_unaligned_be16(p: &data->buf[6]);
1274
1275	if (adc_humidity == BMP280_HUMIDITY_SKIPPED) {
1276	dev_err(data->dev, "reading humidity skipped\n");
1277	goto out;
1278	}
1279
1280	buffer.comp_humidity = bme280_compensate_humidity(data, adc_humidity,
1281	t_fine);
1282
1283	iio_push_to_buffers_with_ts(indio_dev, data: &buffer, data_total_len: sizeof(buffer),
1284	timestamp: iio_get_time_ns(indio_dev));
1285
1286	out:
1287	iio_trigger_notify_done(trig: indio_dev->trig);
1288
1289	return IRQ_HANDLED;
1290	}
1291
1292	static int __bmp280_trigger_probe(struct iio_dev *indio_dev,
1293	const struct iio_trigger_ops *trigger_ops,
1294	int (*int_pin_config)(struct bmp280_data *data),
1295	irq_handler_t irq_thread_handler)
1296	{
1297	struct bmp280_data *data = iio_priv(indio_dev);
1298	struct device *dev = data->dev;
1299	u32 irq_type;
1300	int ret, irq;
1301
1302	irq = fwnode_irq_get(dev_fwnode(dev), index: 0);
1303	if (irq < 0)
1304	return dev_err_probe(dev, err: irq, fmt: "No interrupt found.\n");
1305
1306	irq_type = irq_get_trigger_type(irq);
1307	switch (irq_type) {
1308	case IRQF_TRIGGER_RISING:
1309	data->trig_active_high = true;
1310	break;
1311	case IRQF_TRIGGER_FALLING:
1312	data->trig_active_high = false;
1313	break;
1314	default:
1315	return dev_err_probe(dev, err: -EINVAL, fmt: "Invalid interrupt type specified.\n");
1316	}
1317
1318	data->trig_open_drain =
1319	fwnode_property_read_bool(dev_fwnode(dev), propname: "int-open-drain");
1320
1321	ret = int_pin_config(data);
1322	if (ret)
1323	return ret;
1324
1325	data->trig = devm_iio_trigger_alloc(data->dev, "%s-dev%d",
1326	indio_dev->name,
1327	iio_device_id(indio_dev));
1328	if (!data->trig)
1329	return -ENOMEM;
1330
1331	data->trig->ops = trigger_ops;
1332	iio_trigger_set_drvdata(trig: data->trig, data);
1333
1334	ret = devm_request_threaded_irq(dev: data->dev, irq, NULL,
1335	thread_fn: irq_thread_handler, IRQF_ONESHOT,
1336	devname: indio_dev->name, dev_id: indio_dev);
1337	if (ret)
1338	return dev_err_probe(dev, err: ret, fmt: "request IRQ failed.\n");
1339
1340	ret = devm_iio_trigger_register(dev: data->dev, trig_info: data->trig);
1341	if (ret)
1342	return dev_err_probe(dev, err: ret, fmt: "iio trigger register failed.\n");
1343
1344	indio_dev->trig = iio_trigger_get(trig: data->trig);
1345
1346	return 0;
1347	}
1348
1349	static const u8 bme280_chip_ids[] = { BME280_CHIP_ID };
1350	static const int bme280_humid_coeffs[] = { 1000, 1024 };
1351
1352	const struct bmp280_chip_info bme280_chip_info = {
1353	.id_reg = BMP280_REG_ID,
1354	.chip_id = bme280_chip_ids,
1355	.num_chip_id = ARRAY_SIZE(bme280_chip_ids),
1356	.regmap_config = &bme280_regmap_config,
1357	.start_up_time_us = 2000,
1358	.channels = bme280_channels,
1359	.num_channels = ARRAY_SIZE(bme280_channels),
1360	.avail_scan_masks = bme280_avail_scan_masks,
1361
1362	.oversampling_temp_avail = bmp280_oversampling_avail,
1363	.num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1364	.oversampling_temp_default = BMP280_OSRS_TEMP_2X - 1,
1365
1366	.oversampling_press_avail = bmp280_oversampling_avail,
1367	.num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1368	.oversampling_press_default = BMP280_OSRS_PRESS_16X - 1,
1369
1370	.oversampling_humid_avail = bmp280_oversampling_avail,
1371	.num_oversampling_humid_avail = ARRAY_SIZE(bmp280_oversampling_avail),
1372	.oversampling_humid_default = BME280_OSRS_HUMIDITY_16X - 1,
1373
1374	.temp_coeffs = bmp280_temp_coeffs,
1375	.temp_coeffs_type = IIO_VAL_FRACTIONAL,
1376	.press_coeffs = bmp280_press_coeffs,
1377	.press_coeffs_type = IIO_VAL_FRACTIONAL,
1378	.humid_coeffs = bme280_humid_coeffs,
1379	.humid_coeffs_type = IIO_VAL_FRACTIONAL,
1380
1381	.chip_config = bme280_chip_config,
1382	.read_temp = bmp280_read_temp,
1383	.read_press = bmp280_read_press,
1384	.read_humid = bme280_read_humid,
1385	.read_calib = bme280_read_calib,
1386	.set_mode = bmp280_set_mode,
1387	.wait_conv = bmp280_wait_conv,
1388	.preinit = bmp280_preinit,
1389
1390	.trigger_handler = bme280_trigger_handler,
1391	};
1392	EXPORT_SYMBOL_NS(bme280_chip_info, "IIO_BMP280");
1393
1394	/*
1395	* Helper function to send a command to BMP3XX sensors.
1396	*
1397	* Sensor processes commands written to the CMD register and signals
1398	* execution result through "cmd_rdy" and "cmd_error" flags available on
1399	* STATUS and ERROR registers.
1400	*/
1401	static int bmp380_cmd(struct bmp280_data *data, u8 cmd)
1402	{
1403	unsigned int reg;
1404	int ret;
1405
1406	/* Check if device is ready to process a command */
1407	ret = regmap_read(map: data->regmap, BMP380_REG_STATUS, val: &reg);
1408	if (ret) {
1409	dev_err(data->dev, "failed to read error register\n");
1410	return ret;
1411	}
1412	if (!(reg & BMP380_STATUS_CMD_RDY_MASK)) {
1413	dev_err(data->dev, "device is not ready to accept commands\n");
1414	return -EBUSY;
1415	}
1416
1417	/* Send command to process */
1418	ret = regmap_write(map: data->regmap, BMP380_REG_CMD, val: cmd);
1419	if (ret) {
1420	dev_err(data->dev, "failed to send command to device\n");
1421	return ret;
1422	}
1423	/* Wait for 2ms for command to be processed */
1424	fsleep(usecs: data->start_up_time_us);
1425	/* Check for command processing error */
1426	ret = regmap_read(map: data->regmap, BMP380_REG_ERROR, val: &reg);
1427	if (ret) {
1428	dev_err(data->dev, "error reading ERROR reg\n");
1429	return ret;
1430	}
1431	if (reg & BMP380_ERR_CMD_MASK) {
1432	dev_err(data->dev, "error processing command 0x%X\n", cmd);
1433	return -EINVAL;
1434	}
1435
1436	return 0;
1437	}
1438
1439	static int bmp380_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
1440	{
1441	u32 value_temp;
1442	int ret;
1443
1444	ret = regmap_bulk_read(map: data->regmap, BMP380_REG_TEMP_XLSB,
1445	val: data->buf, BMP280_NUM_TEMP_BYTES);
1446	if (ret) {
1447	dev_err(data->dev, "failed to read temperature\n");
1448	return ret;
1449	}
1450
1451	value_temp = get_unaligned_le24(p: data->buf);
1452	if (value_temp == BMP380_TEMP_SKIPPED) {
1453	dev_err(data->dev, "reading temperature skipped\n");
1454	return -EIO;
1455	}
1456	*adc_temp = value_temp;
1457
1458	return 0;
1459	}
1460
1461	/*
1462	* Returns temperature in Celsius degrees, resolution is 0.01º C. Output value
1463	* of "5123" equals 51.2º C. t_fine carries fine temperature as global value.
1464	*
1465	* Taken from datasheet, Section Appendix 9, "Compensation formula" and repo
1466	* https://github.com/BoschSensortec/BMP3-Sensor-API.
1467	*/
1468	static s32 bmp380_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
1469	{
1470	s64 var1, var2, var3, var4, var5, var6;
1471	struct bmp380_calib *calib = &data->calib.bmp380;
1472
1473	var1 = ((s64) adc_temp) - (((s64) calib->T1) << 8);
1474	var2 = var1 * ((s64) calib->T2);
1475	var3 = var1 * var1;
1476	var4 = var3 * ((s64) calib->T3);
1477	var5 = (var2 << 18) + var4;
1478	var6 = var5 >> 32;
1479	return (s32)var6; /* t_fine = var6 */
1480	}
1481
1482	static int bmp380_get_t_fine(struct bmp280_data *data, s32 *t_fine)
1483	{
1484	s32 adc_temp;
1485	int ret;
1486
1487	ret = bmp380_read_temp_adc(data, adc_temp: &adc_temp);
1488	if (ret)
1489	return ret;
1490
1491	*t_fine = bmp380_calc_t_fine(data, adc_temp);
1492
1493	return 0;
1494	}
1495
1496	static int bmp380_compensate_temp(struct bmp280_data *data, u32 adc_temp)
1497	{
1498	s64 comp_temp;
1499	s32 var6;
1500
1501	var6 = bmp380_calc_t_fine(data, adc_temp);
1502	comp_temp = (var6 * 25) >> 14;
1503
1504	comp_temp = clamp_val(comp_temp, BMP380_MIN_TEMP, BMP380_MAX_TEMP);
1505	return (s32) comp_temp;
1506	}
1507
1508	static int bmp380_read_press_adc(struct bmp280_data *data, u32 *adc_press)
1509	{
1510	u32 value_press;
1511	int ret;
1512
1513	ret = regmap_bulk_read(map: data->regmap, BMP380_REG_PRESS_XLSB,
1514	val: data->buf, BMP280_NUM_PRESS_BYTES);
1515	if (ret) {
1516	dev_err(data->dev, "failed to read pressure\n");
1517	return ret;
1518	}
1519
1520	value_press = get_unaligned_le24(p: data->buf);
1521	if (value_press == BMP380_PRESS_SKIPPED) {
1522	dev_err(data->dev, "reading pressure skipped\n");
1523	return -EIO;
1524	}
1525	*adc_press = value_press;
1526
1527	return 0;
1528	}
1529
1530	/*
1531	* Returns pressure in Pa as an unsigned 32 bit integer in fractional Pascal.
1532	* Output value of "9528709" represents 9528709/100 = 95287.09 Pa = 952.8709 hPa.
1533	*
1534	* Taken from datasheet, Section 9.3. "Pressure compensation" and repository
1535	* https://github.com/BoschSensortec/BMP3-Sensor-API.
1536	*/
1537	static u32 bmp380_compensate_press(struct bmp280_data *data,
1538	u32 adc_press, s32 t_fine)
1539	{
1540	s64 var1, var2, var3, var4, var5, var6, offset, sensitivity;
1541	struct bmp380_calib *calib = &data->calib.bmp380;
1542	u32 comp_press;
1543
1544	var1 = (s64)t_fine * (s64)t_fine;
1545	var2 = var1 >> 6;
1546	var3 = (var2 * ((s64)t_fine)) >> 8;
1547	var4 = ((s64)calib->P8 * var3) >> 5;
1548	var5 = ((s64)calib->P7 * var1) << 4;
1549	var6 = ((s64)calib->P6 * (s64)t_fine) << 22;
1550	offset = ((s64)calib->P5 << 47) + var4 + var5 + var6;
1551	var2 = ((s64)calib->P4 * var3) >> 5;
1552	var4 = ((s64)calib->P3 * var1) << 2;
1553	var5 = ((s64)calib->P2 - ((s64)1 << 14)) *
1554	((s64)t_fine << 21);
1555	sensitivity = (((s64) calib->P1 - ((s64) 1 << 14)) << 46) +
1556	var2 + var4 + var5;
1557	var1 = (sensitivity >> 24) * (s64)adc_press;
1558	var2 = (s64)calib->P10 * (s64)t_fine;
1559	var3 = var2 + ((s64)calib->P9 << 16);
1560	var4 = (var3 * (s64)adc_press) >> 13;
1561
1562	/*
1563	* Dividing by 10 followed by multiplying by 10 to avoid
1564	* possible overflow caused by (uncomp_data->pressure * partial_data4).
1565	*/
1566	var5 = ((s64)adc_press * div_s64(dividend: var4, divisor: 10)) >> 9;
1567	var5 *= 10;
1568	var6 = (s64)adc_press * (s64)adc_press;
1569	var2 = ((s64)calib->P11 * var6) >> 16;
1570	var3 = (var2 * (s64)adc_press) >> 7;
1571	var4 = (offset >> 2) + var1 + var5 + var3;
1572	comp_press = ((u64)var4 * 25) >> 40;
1573
1574	comp_press = clamp_val(comp_press, BMP380_MIN_PRES, BMP380_MAX_PRES);
1575	return comp_press;
1576	}
1577
1578	static int bmp380_read_temp(struct bmp280_data *data, s32 *comp_temp)
1579	{
1580	u32 adc_temp;
1581	int ret;
1582
1583	ret = bmp380_read_temp_adc(data, adc_temp: &adc_temp);
1584	if (ret)
1585	return ret;
1586
1587	*comp_temp = bmp380_compensate_temp(data, adc_temp);
1588
1589	return 0;
1590	}
1591
1592	static int bmp380_read_press(struct bmp280_data *data, u32 *comp_press)
1593	{
1594	u32 adc_press, t_fine;
1595	int ret;
1596
1597	ret = bmp380_get_t_fine(data, t_fine: &t_fine);
1598	if (ret)
1599	return ret;
1600
1601	ret = bmp380_read_press_adc(data, adc_press: &adc_press);
1602	if (ret)
1603	return ret;
1604
1605	*comp_press = bmp380_compensate_press(data, adc_press, t_fine);
1606
1607	return 0;
1608	}
1609
1610	static int bmp380_read_calib(struct bmp280_data *data)
1611	{
1612	struct bmp380_calib *calib = &data->calib.bmp380;
1613	int ret;
1614
1615	/* Read temperature and pressure calibration data */
1616	ret = regmap_bulk_read(map: data->regmap, BMP380_REG_CALIB_TEMP_START,
1617	val: data->bmp380_cal_buf,
1618	val_count: sizeof(data->bmp380_cal_buf));
1619	if (ret) {
1620	dev_err(data->dev,
1621	"failed to read calibration parameters\n");
1622	return ret;
1623	}
1624
1625	/* Toss the temperature calibration data into the entropy pool */
1626	add_device_randomness(buf: data->bmp380_cal_buf,
1627	len: sizeof(data->bmp380_cal_buf));
1628
1629	/* Parse calibration values */
1630	calib->T1 = get_unaligned_le16(p: &data->bmp380_cal_buf[BMP380_T1]);
1631	calib->T2 = get_unaligned_le16(p: &data->bmp380_cal_buf[BMP380_T2]);
1632	calib->T3 = data->bmp380_cal_buf[BMP380_T3];
1633	calib->P1 = get_unaligned_le16(p: &data->bmp380_cal_buf[BMP380_P1]);
1634	calib->P2 = get_unaligned_le16(p: &data->bmp380_cal_buf[BMP380_P2]);
1635	calib->P3 = data->bmp380_cal_buf[BMP380_P3];
1636	calib->P4 = data->bmp380_cal_buf[BMP380_P4];
1637	calib->P5 = get_unaligned_le16(p: &data->bmp380_cal_buf[BMP380_P5]);
1638	calib->P6 = get_unaligned_le16(p: &data->bmp380_cal_buf[BMP380_P6]);
1639	calib->P7 = data->bmp380_cal_buf[BMP380_P7];
1640	calib->P8 = data->bmp380_cal_buf[BMP380_P8];
1641	calib->P9 = get_unaligned_le16(p: &data->bmp380_cal_buf[BMP380_P9]);
1642	calib->P10 = data->bmp380_cal_buf[BMP380_P10];
1643	calib->P11 = data->bmp380_cal_buf[BMP380_P11];
1644
1645	return 0;
1646	}
1647
1648	static const int bmp380_odr_table[][2] = {
1649	[BMP380_ODR_200HZ] = {200, 0},
1650	[BMP380_ODR_100HZ] = {100, 0},
1651	[BMP380_ODR_50HZ] = {50, 0},
1652	[BMP380_ODR_25HZ] = {25, 0},
1653	[BMP380_ODR_12_5HZ] = {12, 500000},
1654	[BMP380_ODR_6_25HZ] = {6, 250000},
1655	[BMP380_ODR_3_125HZ] = {3, 125000},
1656	[BMP380_ODR_1_5625HZ] = {1, 562500},
1657	[BMP380_ODR_0_78HZ] = {0, 781250},
1658	[BMP380_ODR_0_39HZ] = {0, 390625},
1659	[BMP380_ODR_0_2HZ] = {0, 195313},
1660	[BMP380_ODR_0_1HZ] = {0, 97656},
1661	[BMP380_ODR_0_05HZ] = {0, 48828},
1662	[BMP380_ODR_0_02HZ] = {0, 24414},
1663	[BMP380_ODR_0_01HZ] = {0, 12207},
1664	[BMP380_ODR_0_006HZ] = {0, 6104},
1665	[BMP380_ODR_0_003HZ] = {0, 3052},
1666	[BMP380_ODR_0_0015HZ] = {0, 1526},
1667	};
1668
1669	static int bmp380_preinit(struct bmp280_data *data)
1670	{
1671	/* BMP3xx requires soft-reset as part of initialization */
1672	return bmp380_cmd(data, BMP380_CMD_SOFT_RESET);
1673	}
1674
1675	static const u8 bmp380_operation_mode[] = {
1676	[BMP280_SLEEP] = BMP380_MODE_SLEEP,
1677	[BMP280_FORCED] = BMP380_MODE_FORCED,
1678	[BMP280_NORMAL] = BMP380_MODE_NORMAL,
1679	};
1680
1681	static int bmp380_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
1682	{
1683	int ret;
1684
1685	ret = regmap_write_bits(map: data->regmap, BMP380_REG_POWER_CONTROL,
1686	BMP380_MODE_MASK,
1687	FIELD_PREP(BMP380_MODE_MASK,
1688	bmp380_operation_mode[mode]));
1689	if (ret) {
1690	dev_err(data->dev, "failed to write power control register.\n");
1691	return ret;
1692	}
1693
1694	data->op_mode = mode;
1695
1696	return 0;
1697	}
1698
1699	static int bmp380_wait_conv(struct bmp280_data *data)
1700	{
1701	unsigned int reg;
1702	int ret, meas_time_us;
1703
1704	/* Offset measurement time */
1705	meas_time_us = BMP380_MEAS_OFFSET;
1706
1707	/* Pressure measurement time */
1708	meas_time_us += BMP380_PRESS_MEAS_OFFSET +
1709	BIT(data->oversampling_press) * BMP380_MEAS_DUR;
1710
1711	/* Temperature measurement time */
1712	meas_time_us += BMP380_TEMP_MEAS_OFFSET +
1713	BIT(data->oversampling_temp) * BMP380_MEAS_DUR;
1714
1715	/* Measurement time defined in Datasheet Section 3.9.2 */
1716	fsleep(usecs: meas_time_us);
1717
1718	ret = regmap_read(map: data->regmap, BMP380_REG_STATUS, val: &reg);
1719	if (ret) {
1720	dev_err(data->dev, "failed to read status register.\n");
1721	return ret;
1722	}
1723
1724	if (!((reg & BMP380_STATUS_DRDY_PRESS_MASK) &&
1725	(reg & BMP380_STATUS_DRDY_TEMP_MASK))) {
1726	dev_err(data->dev, "Measurement cycle didn't complete.\n");
1727	return -EBUSY;
1728	}
1729
1730	return 0;
1731	}
1732
1733	static int bmp380_chip_config(struct bmp280_data *data)
1734	{
1735	bool change = false, aux;
1736	unsigned int tmp;
1737	u8 osrs;
1738	int ret;
1739
1740	/* Configure power control register */
1741	ret = regmap_update_bits(map: data->regmap, BMP380_REG_POWER_CONTROL,
1742	BMP380_CTRL_SENSORS_MASK,
1743	BMP380_CTRL_SENSORS_PRESS_EN |
1744	BMP380_CTRL_SENSORS_TEMP_EN);
1745	if (ret) {
1746	dev_err(data->dev,
1747	"failed to write operation control register\n");
1748	return ret;
1749	}
1750
1751	/* Configure oversampling */
1752	osrs = FIELD_PREP(BMP380_OSRS_TEMP_MASK, data->oversampling_temp) |
1753	FIELD_PREP(BMP380_OSRS_PRESS_MASK, data->oversampling_press);
1754
1755	ret = regmap_update_bits_check(map: data->regmap, BMP380_REG_OSR,
1756	BMP380_OSRS_TEMP_MASK |
1757	BMP380_OSRS_PRESS_MASK,
1758	val: osrs, change: &aux);
1759	if (ret) {
1760	dev_err(data->dev, "failed to write oversampling register\n");
1761	return ret;
1762	}
1763	change = change || aux;
1764
1765	/* Configure output data rate */
1766	ret = regmap_update_bits_check(map: data->regmap, BMP380_REG_ODR,
1767	BMP380_ODRS_MASK, val: data->sampling_freq,
1768	change: &aux);
1769	if (ret) {
1770	dev_err(data->dev, "failed to write ODR selection register\n");
1771	return ret;
1772	}
1773	change = change || aux;
1774
1775	/* Set filter data */
1776	ret = regmap_update_bits(map: data->regmap, BMP380_REG_CONFIG, BMP380_FILTER_MASK,
1777	FIELD_PREP(BMP380_FILTER_MASK, data->iir_filter_coeff));
1778	if (ret) {
1779	dev_err(data->dev, "failed to write config register\n");
1780	return ret;
1781	}
1782
1783	if (change) {
1784	/*
1785	* The configurations errors are detected on the fly during a
1786	* measurement cycle. If the sampling frequency is too low, it's
1787	* faster to reset the measurement loop than wait until the next
1788	* measurement is due.
1789	*
1790	* Resets sensor measurement loop toggling between sleep and
1791	* normal operating modes.
1792	*/
1793	ret = bmp380_set_mode(data, mode: BMP280_SLEEP);
1794	if (ret) {
1795	dev_err(data->dev, "failed to set sleep mode\n");
1796	return ret;
1797	}
1798
1799	/*
1800	* According to the BMP3 Sensor API, the sensor needs 5ms
1801	* in order to go to the sleep mode.
1802	*/
1803	fsleep(usecs: 5 * USEC_PER_MSEC);
1804
1805	ret = bmp380_set_mode(data, mode: BMP280_NORMAL);
1806	if (ret) {
1807	dev_err(data->dev, "failed to set normal mode\n");
1808	return ret;
1809	}
1810	/*
1811	* Waits for measurement before checking configuration error
1812	* flag. Selected longest measurement time, calculated from
1813	* formula in datasheet section 3.9.2 with an offset of ~+15%
1814	* as it seen as well in table 3.9.1.
1815	*/
1816	fsleep(usecs: 150 * USEC_PER_MSEC);
1817
1818	/* Check config error flag */
1819	ret = regmap_read(map: data->regmap, BMP380_REG_ERROR, val: &tmp);
1820	if (ret) {
1821	dev_err(data->dev, "failed to read error register\n");
1822	return ret;
1823	}
1824	if (tmp & BMP380_ERR_CONF_MASK) {
1825	dev_warn(data->dev,
1826	"sensor flagged configuration as incompatible\n");
1827	return -EINVAL;
1828	}
1829	}
1830
1831	/* Dummy read to empty data registers. */
1832	ret = bmp380_read_press(data, comp_press: &tmp);
1833	if (ret)
1834	return ret;
1835
1836	ret = bmp380_set_mode(data, mode: BMP280_SLEEP);
1837	if (ret)
1838	dev_err(data->dev, "failed to set sleep mode.\n");
1839
1840	return ret;
1841	}
1842
1843	static int bmp380_data_rdy_trigger_set_state(struct iio_trigger *trig,
1844	bool state)
1845	{
1846	struct bmp280_data *data = iio_trigger_get_drvdata(trig);
1847	int ret;
1848
1849	guard(mutex)(T: &data->lock);
1850
1851	ret = regmap_update_bits(map: data->regmap, BMP380_REG_INT_CONTROL,
1852	BMP380_INT_CTRL_DRDY_EN,
1853	FIELD_PREP(BMP380_INT_CTRL_DRDY_EN, !!state));
1854	if (ret)
1855	dev_err(data->dev,
1856	"Could not %s interrupt.\n", str_enable_disable(state));
1857	return ret;
1858	}
1859
1860	static const struct iio_trigger_ops bmp380_trigger_ops = {
1861	.set_trigger_state = &bmp380_data_rdy_trigger_set_state,
1862	};
1863
1864	static int bmp380_int_pin_config(struct bmp280_data *data)
1865	{
1866	int pin_drive_cfg = FIELD_PREP(BMP380_INT_CTRL_OPEN_DRAIN,
1867	data->trig_open_drain);
1868	int pin_level_cfg = FIELD_PREP(BMP380_INT_CTRL_LEVEL,
1869	data->trig_active_high);
1870	int ret, int_pin_cfg = pin_drive_cfg | pin_level_cfg;
1871
1872	ret = regmap_update_bits(map: data->regmap, BMP380_REG_INT_CONTROL,
1873	BMP380_INT_CTRL_SETTINGS_MASK, val: int_pin_cfg);
1874	if (ret)
1875	dev_err(data->dev, "Could not set interrupt settings.\n");
1876
1877	return ret;
1878	}
1879
1880	static irqreturn_t bmp380_irq_thread_handler(int irq, void *p)
1881	{
1882	struct iio_dev *indio_dev = p;
1883	struct bmp280_data *data = iio_priv(indio_dev);
1884	unsigned int int_ctrl;
1885	int ret;
1886
1887	ret = regmap_read(map: data->regmap, BMP380_REG_INT_STATUS, val: &int_ctrl);
1888	if (ret)
1889	return IRQ_NONE;
1890
1891	if (FIELD_GET(BMP380_INT_STATUS_DRDY, int_ctrl))
1892	iio_trigger_poll_nested(trig: data->trig);
1893
1894	return IRQ_HANDLED;
1895	}
1896
1897	static int bmp380_trigger_probe(struct iio_dev *indio_dev)
1898	{
1899	return __bmp280_trigger_probe(indio_dev, trigger_ops: &bmp380_trigger_ops,
1900	int_pin_config: bmp380_int_pin_config,
1901	irq_thread_handler: bmp380_irq_thread_handler);
1902	}
1903
1904	static irqreturn_t bmp380_trigger_handler(int irq, void *p)
1905	{
1906	struct iio_poll_func *pf = p;
1907	struct iio_dev *indio_dev = pf->indio_dev;
1908	struct bmp280_data *data = iio_priv(indio_dev);
1909	u32 adc_temp, adc_press;
1910	s32 t_fine;
1911	struct {
1912	u32 comp_press;
1913	s32 comp_temp;
1914	aligned_s64 timestamp;
1915	} buffer;
1916	int ret;
1917
1918	guard(mutex)(T: &data->lock);
1919
1920	/* Burst read data registers */
1921	ret = regmap_bulk_read(map: data->regmap, BMP380_REG_PRESS_XLSB,
1922	val: data->buf, BMP280_BURST_READ_BYTES);
1923	if (ret) {
1924	dev_err(data->dev, "failed to burst read sensor data\n");
1925	goto out;
1926	}
1927
1928	/* Temperature calculations */
1929	adc_temp = get_unaligned_le24(p: &data->buf[3]);
1930	if (adc_temp == BMP380_TEMP_SKIPPED) {
1931	dev_err(data->dev, "reading temperature skipped\n");
1932	goto out;
1933	}
1934
1935	buffer.comp_temp = bmp380_compensate_temp(data, adc_temp);
1936
1937	/* Pressure calculations */
1938	adc_press = get_unaligned_le24(p: &data->buf[0]);
1939	if (adc_press == BMP380_PRESS_SKIPPED) {
1940	dev_err(data->dev, "reading pressure skipped\n");
1941	goto out;
1942	}
1943
1944	t_fine = bmp380_calc_t_fine(data, adc_temp);
1945	buffer.comp_press = bmp380_compensate_press(data, adc_press, t_fine);
1946
1947	iio_push_to_buffers_with_ts(indio_dev, data: &buffer, data_total_len: sizeof(buffer),
1948	timestamp: iio_get_time_ns(indio_dev));
1949
1950	out:
1951	iio_trigger_notify_done(trig: indio_dev->trig);
1952
1953	return IRQ_HANDLED;
1954	}
1955
1956	static const int bmp380_oversampling_avail[] = { 1, 2, 4, 8, 16, 32 };
1957	static const int bmp380_iir_filter_coeffs_avail[] = { 1, 2, 4, 8, 16, 32, 64, 128};
1958	static const u8 bmp380_chip_ids[] = { BMP380_CHIP_ID, BMP390_CHIP_ID };
1959	static const int bmp380_temp_coeffs[] = { 10, 1 };
1960	static const int bmp380_press_coeffs[] = { 1, 100000 };
1961
1962	const struct bmp280_chip_info bmp380_chip_info = {
1963	.id_reg = BMP380_REG_ID,
1964	.chip_id = bmp380_chip_ids,
1965	.num_chip_id = ARRAY_SIZE(bmp380_chip_ids),
1966	.regmap_config = &bmp380_regmap_config,
1967	.spi_read_extra_byte = true,
1968	.start_up_time_us = 2000,
1969	.channels = bmp380_channels,
1970	.num_channels = ARRAY_SIZE(bmp380_channels),
1971	.avail_scan_masks = bmp280_avail_scan_masks,
1972
1973	.oversampling_temp_avail = bmp380_oversampling_avail,
1974	.num_oversampling_temp_avail = ARRAY_SIZE(bmp380_oversampling_avail),
1975	.oversampling_temp_default = ilog2(1),
1976
1977	.oversampling_press_avail = bmp380_oversampling_avail,
1978	.num_oversampling_press_avail = ARRAY_SIZE(bmp380_oversampling_avail),
1979	.oversampling_press_default = ilog2(4),
1980
1981	.sampling_freq_avail = bmp380_odr_table,
1982	.num_sampling_freq_avail = ARRAY_SIZE(bmp380_odr_table) * 2,
1983	.sampling_freq_default = BMP380_ODR_50HZ,
1984
1985	.iir_filter_coeffs_avail = bmp380_iir_filter_coeffs_avail,
1986	.num_iir_filter_coeffs_avail = ARRAY_SIZE(bmp380_iir_filter_coeffs_avail),
1987	.iir_filter_coeff_default = 2,
1988
1989	.temp_coeffs = bmp380_temp_coeffs,
1990	.temp_coeffs_type = IIO_VAL_FRACTIONAL,
1991	.press_coeffs = bmp380_press_coeffs,
1992	.press_coeffs_type = IIO_VAL_FRACTIONAL,
1993
1994	.chip_config = bmp380_chip_config,
1995	.read_temp = bmp380_read_temp,
1996	.read_press = bmp380_read_press,
1997	.read_calib = bmp380_read_calib,
1998	.set_mode = bmp380_set_mode,
1999	.wait_conv = bmp380_wait_conv,
2000	.preinit = bmp380_preinit,
2001
2002	.trigger_probe = bmp380_trigger_probe,
2003	.trigger_handler = bmp380_trigger_handler,
2004	};
2005	EXPORT_SYMBOL_NS(bmp380_chip_info, "IIO_BMP280");
2006
2007	static int bmp580_soft_reset(struct bmp280_data *data)
2008	{
2009	unsigned int reg;
2010	int ret;
2011
2012	ret = regmap_write(map: data->regmap, BMP580_REG_CMD, BMP580_CMD_SOFT_RESET);
2013	if (ret) {
2014	dev_err(data->dev, "failed to send reset command to device\n");
2015	return ret;
2016	}
2017	/* From datasheet's table 4: electrical characteristics */
2018	fsleep(usecs: 2000);
2019
2020	/* Dummy read of chip_id */
2021	ret = regmap_read(map: data->regmap, BMP580_REG_CHIP_ID, val: &reg);
2022	if (ret) {
2023	dev_err(data->dev, "failed to reestablish comms after reset\n");
2024	return ret;
2025	}
2026
2027	ret = regmap_read(map: data->regmap, BMP580_REG_INT_STATUS, val: &reg);
2028	if (ret) {
2029	dev_err(data->dev, "error reading interrupt status register\n");
2030	return ret;
2031	}
2032	if (!(reg & BMP580_INT_STATUS_POR_MASK)) {
2033	dev_err(data->dev, "error resetting sensor\n");
2034	return -EINVAL;
2035	}
2036
2037	return 0;
2038	}
2039
2040	/**
2041	* bmp580_nvm_operation() - Helper function to commit NVM memory operations
2042	* @data: sensor data struct
2043	* @is_write: flag to signal write operation
2044	*/
2045	static int bmp580_nvm_operation(struct bmp280_data *data, bool is_write)
2046	{
2047	unsigned long timeout, poll;
2048	unsigned int reg;
2049	int ret;
2050
2051	/* Check NVM ready flag */
2052	ret = regmap_read(map: data->regmap, BMP580_REG_STATUS, val: &reg);
2053	if (ret) {
2054	dev_err(data->dev, "failed to check nvm status\n");
2055	return ret;
2056	}
2057	if (!(reg & BMP580_STATUS_NVM_RDY_MASK)) {
2058	dev_err(data->dev, "sensor's nvm is not ready\n");
2059	return -EIO;
2060	}
2061
2062	/* Start NVM operation sequence */
2063	ret = regmap_write(map: data->regmap, BMP580_REG_CMD,
2064	BMP580_CMD_NVM_OP_SEQ_0);
2065	if (ret) {
2066	dev_err(data->dev,
2067	"failed to send nvm operation's first sequence\n");
2068	return ret;
2069	}
2070	if (is_write) {
2071	/* Send NVM write sequence */
2072	ret = regmap_write(map: data->regmap, BMP580_REG_CMD,
2073	BMP580_CMD_NVM_WRITE_SEQ_1);
2074	if (ret) {
2075	dev_err(data->dev,
2076	"failed to send nvm write sequence\n");
2077	return ret;
2078	}
2079	/* Datasheet says on 4.8.1.2 it takes approximately 10ms */
2080	poll = 2000;
2081	timeout = 12000;
2082	} else {
2083	/* Send NVM read sequence */
2084	ret = regmap_write(map: data->regmap, BMP580_REG_CMD,
2085	BMP580_CMD_NVM_READ_SEQ_1);
2086	if (ret) {
2087	dev_err(data->dev,
2088	"failed to send nvm read sequence\n");
2089	return ret;
2090	}
2091	/* Datasheet says on 4.8.1.1 it takes approximately 200us */
2092	poll = 50;
2093	timeout = 400;
2094	}
2095
2096	/* Wait until NVM is ready again */
2097	ret = regmap_read_poll_timeout(data->regmap, BMP580_REG_STATUS, reg,
2098	(reg & BMP580_STATUS_NVM_RDY_MASK),
2099	poll, timeout);
2100	if (ret) {
2101	dev_err(data->dev, "error checking nvm operation status\n");
2102	return ret;
2103	}
2104
2105	/* Check NVM error flags */
2106	if ((reg & BMP580_STATUS_NVM_ERR_MASK) || (reg & BMP580_STATUS_NVM_CMD_ERR_MASK)) {
2107	dev_err(data->dev, "error processing nvm operation\n");
2108	return -EIO;
2109	}
2110
2111	return 0;
2112	}
2113
2114	/*
2115	* Contrary to previous sensors families, compensation algorithm is builtin.
2116	* We are only required to read the register raw data and adapt the ranges
2117	* for what is expected on IIO ABI.
2118	*/
2119
2120	static int bmp580_read_temp(struct bmp280_data *data, s32 *raw_temp)
2121	{
2122	s32 value_temp;
2123	int ret;
2124
2125	ret = regmap_bulk_read(map: data->regmap, BMP580_REG_TEMP_XLSB,
2126	val: data->buf, BMP280_NUM_TEMP_BYTES);
2127	if (ret) {
2128	dev_err(data->dev, "failed to read temperature\n");
2129	return ret;
2130	}
2131
2132	value_temp = get_unaligned_le24(p: data->buf);
2133	if (value_temp == BMP580_TEMP_SKIPPED) {
2134	dev_err(data->dev, "reading temperature skipped\n");
2135	return -EIO;
2136	}
2137	*raw_temp = sign_extend32(value: value_temp, index: 23);
2138
2139	return 0;
2140	}
2141
2142	static int bmp580_read_press(struct bmp280_data *data, u32 *raw_press)
2143	{
2144	u32 value_press;
2145	int ret;
2146
2147	ret = regmap_bulk_read(map: data->regmap, BMP580_REG_PRESS_XLSB,
2148	val: data->buf, BMP280_NUM_PRESS_BYTES);
2149	if (ret) {
2150	dev_err(data->dev, "failed to read pressure\n");
2151	return ret;
2152	}
2153
2154	value_press = get_unaligned_le24(p: data->buf);
2155	if (value_press == BMP580_PRESS_SKIPPED) {
2156	dev_err(data->dev, "reading pressure skipped\n");
2157	return -EIO;
2158	}
2159	*raw_press = value_press;
2160
2161	return 0;
2162	}
2163
2164	static const int bmp580_odr_table[][2] = {
2165	[BMP580_ODR_240HZ] = {240, 0},
2166	[BMP580_ODR_218HZ] = {218, 0},
2167	[BMP580_ODR_199HZ] = {199, 0},
2168	[BMP580_ODR_179HZ] = {179, 0},
2169	[BMP580_ODR_160HZ] = {160, 0},
2170	[BMP580_ODR_149HZ] = {149, 0},
2171	[BMP580_ODR_140HZ] = {140, 0},
2172	[BMP580_ODR_129HZ] = {129, 0},
2173	[BMP580_ODR_120HZ] = {120, 0},
2174	[BMP580_ODR_110HZ] = {110, 0},
2175	[BMP580_ODR_100HZ] = {100, 0},
2176	[BMP580_ODR_89HZ] = {89, 0},
2177	[BMP580_ODR_80HZ] = {80, 0},
2178	[BMP580_ODR_70HZ] = {70, 0},
2179	[BMP580_ODR_60HZ] = {60, 0},
2180	[BMP580_ODR_50HZ] = {50, 0},
2181	[BMP580_ODR_45HZ] = {45, 0},
2182	[BMP580_ODR_40HZ] = {40, 0},
2183	[BMP580_ODR_35HZ] = {35, 0},
2184	[BMP580_ODR_30HZ] = {30, 0},
2185	[BMP580_ODR_25HZ] = {25, 0},
2186	[BMP580_ODR_20HZ] = {20, 0},
2187	[BMP580_ODR_15HZ] = {15, 0},
2188	[BMP580_ODR_10HZ] = {10, 0},
2189	[BMP580_ODR_5HZ] = {5, 0},
2190	[BMP580_ODR_4HZ] = {4, 0},
2191	[BMP580_ODR_3HZ] = {3, 0},
2192	[BMP580_ODR_2HZ] = {2, 0},
2193	[BMP580_ODR_1HZ] = {1, 0},
2194	[BMP580_ODR_0_5HZ] = {0, 500000},
2195	[BMP580_ODR_0_25HZ] = {0, 250000},
2196	[BMP580_ODR_0_125HZ] = {0, 125000},
2197	};
2198
2199	static const int bmp580_nvmem_addrs[] = { 0x20, 0x21, 0x22 };
2200
2201	static int bmp580_nvmem_read_impl(void *priv, unsigned int offset, void *val,
2202	size_t bytes)
2203	{
2204	struct bmp280_data *data = priv;
2205	u16 *dst = val;
2206	int ret, addr;
2207
2208	guard(mutex)(T: &data->lock);
2209
2210	/* Set sensor in standby mode */
2211	ret = regmap_update_bits(map: data->regmap, BMP580_REG_ODR_CONFIG,
2212	BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS,
2213	BMP580_ODR_DEEPSLEEP_DIS |
2214	FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP));
2215	if (ret) {
2216	dev_err(data->dev, "failed to change sensor to standby mode\n");
2217	goto exit;
2218	}
2219	/* Wait standby transition time */
2220	fsleep(usecs: 2500);
2221
2222	while (bytes >= sizeof(*dst)) {
2223	addr = bmp580_nvmem_addrs[offset / sizeof(*dst)];
2224
2225	ret = regmap_write(map: data->regmap, BMP580_REG_NVM_ADDR,
2226	FIELD_PREP(BMP580_NVM_ROW_ADDR_MASK, addr));
2227	if (ret) {
2228	dev_err(data->dev, "error writing nvm address\n");
2229	goto exit;
2230	}
2231
2232	ret = bmp580_nvm_operation(data, is_write: false);
2233	if (ret)
2234	goto exit;
2235
2236	ret = regmap_bulk_read(map: data->regmap, BMP580_REG_NVM_DATA_LSB,
2237	val: &data->le16, val_count: sizeof(data->le16));
2238	if (ret) {
2239	dev_err(data->dev, "error reading nvm data regs\n");
2240	goto exit;
2241	}
2242
2243	*dst++ = le16_to_cpu(data->le16);
2244	bytes -= sizeof(*dst);
2245	offset += sizeof(*dst);
2246	}
2247	exit:
2248	/* Restore chip config */
2249	data->chip_info->chip_config(data);
2250	return ret;
2251	}
2252
2253	static int bmp580_nvmem_read(void *priv, unsigned int offset, void *val,
2254	size_t bytes)
2255	{
2256	struct bmp280_data *data = priv;
2257	int ret;
2258
2259	pm_runtime_get_sync(dev: data->dev);
2260	ret = bmp580_nvmem_read_impl(priv, offset, val, bytes);
2261	pm_runtime_mark_last_busy(dev: data->dev);
2262	pm_runtime_put_autosuspend(dev: data->dev);
2263
2264	return ret;
2265	}
2266
2267	static int bmp580_nvmem_write_impl(void *priv, unsigned int offset, void *val,
2268	size_t bytes)
2269	{
2270	struct bmp280_data *data = priv;
2271	u16 *buf = val;
2272	int ret, addr;
2273
2274	guard(mutex)(T: &data->lock);
2275
2276	/* Set sensor in standby mode */
2277	ret = regmap_update_bits(map: data->regmap, BMP580_REG_ODR_CONFIG,
2278	BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS,
2279	BMP580_ODR_DEEPSLEEP_DIS |
2280	FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP));
2281	if (ret) {
2282	dev_err(data->dev, "failed to change sensor to standby mode\n");
2283	goto exit;
2284	}
2285	/* Wait standby transition time */
2286	fsleep(usecs: 2500);
2287
2288	while (bytes >= sizeof(*buf)) {
2289	addr = bmp580_nvmem_addrs[offset / sizeof(*buf)];
2290
2291	ret = regmap_write(map: data->regmap, BMP580_REG_NVM_ADDR,
2292	BMP580_NVM_PROG_EN |
2293	FIELD_PREP(BMP580_NVM_ROW_ADDR_MASK, addr));
2294	if (ret) {
2295	dev_err(data->dev, "error writing nvm address\n");
2296	goto exit;
2297	}
2298	data->le16 = cpu_to_le16(*buf++);
2299
2300	ret = regmap_bulk_write(map: data->regmap, BMP580_REG_NVM_DATA_LSB,
2301	val: &data->le16, val_count: sizeof(data->le16));
2302	if (ret) {
2303	dev_err(data->dev, "error writing LSB NVM data regs\n");
2304	goto exit;
2305	}
2306
2307	ret = bmp580_nvm_operation(data, is_write: true);
2308	if (ret)
2309	goto exit;
2310
2311	/* Disable programming mode bit */
2312	ret = regmap_clear_bits(map: data->regmap, BMP580_REG_NVM_ADDR,
2313	BMP580_NVM_PROG_EN);
2314	if (ret) {
2315	dev_err(data->dev, "error resetting nvm write\n");
2316	goto exit;
2317	}
2318
2319	bytes -= sizeof(*buf);
2320	offset += sizeof(*buf);
2321	}
2322	exit:
2323	/* Restore chip config */
2324	data->chip_info->chip_config(data);
2325	return ret;
2326	}
2327
2328	static int bmp580_nvmem_write(void *priv, unsigned int offset, void *val,
2329	size_t bytes)
2330	{
2331	struct bmp280_data *data = priv;
2332	int ret;
2333
2334	pm_runtime_get_sync(dev: data->dev);
2335	ret = bmp580_nvmem_write_impl(priv, offset, val, bytes);
2336	pm_runtime_mark_last_busy(dev: data->dev);
2337	pm_runtime_put_autosuspend(dev: data->dev);
2338
2339	return ret;
2340	}
2341
2342	static int bmp580_preinit(struct bmp280_data *data)
2343	{
2344	struct nvmem_config config = {
2345	.dev = data->dev,
2346	.priv = data,
2347	.name = "bmp580_nvmem",
2348	.word_size = sizeof(u16),
2349	.stride = sizeof(u16),
2350	.size = 3 * sizeof(u16),
2351	.reg_read = bmp580_nvmem_read,
2352	.reg_write = bmp580_nvmem_write,
2353	};
2354	unsigned int reg;
2355	int ret;
2356
2357	/* Issue soft-reset command */
2358	ret = bmp580_soft_reset(data);
2359	if (ret)
2360	return ret;
2361
2362	/* Post powerup sequence */
2363	ret = regmap_read(map: data->regmap, BMP580_REG_CHIP_ID, val: &reg);
2364	if (ret) {
2365	dev_err(data->dev, "failed to establish comms with the chip\n");
2366	return ret;
2367	}
2368
2369	/* Print warn message if we don't know the chip id */
2370	if (reg != BMP580_CHIP_ID && reg != BMP580_CHIP_ID_ALT)
2371	dev_warn(data->dev, "unexpected chip_id\n");
2372
2373	ret = regmap_read(map: data->regmap, BMP580_REG_STATUS, val: &reg);
2374	if (ret) {
2375	dev_err(data->dev, "failed to read nvm status\n");
2376	return ret;
2377	}
2378
2379	/* Check nvm status */
2380	if (!(reg & BMP580_STATUS_NVM_RDY_MASK) || (reg & BMP580_STATUS_NVM_ERR_MASK)) {
2381	dev_err(data->dev, "nvm error on powerup sequence\n");
2382	return -EIO;
2383	}
2384
2385	/* Register nvmem device */
2386	return PTR_ERR_OR_ZERO(ptr: devm_nvmem_register(dev: config.dev, cfg: &config));
2387	}
2388
2389	static const u8 bmp580_operation_mode[] = {
2390	[BMP280_SLEEP] = BMP580_MODE_SLEEP,
2391	[BMP280_FORCED] = BMP580_MODE_FORCED,
2392	[BMP280_NORMAL] = BMP580_MODE_NORMAL,
2393	};
2394
2395	static int bmp580_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
2396	{
2397	struct device *dev = data->dev;
2398	int ret;
2399
2400	if (mode == BMP280_FORCED) {
2401	ret = regmap_set_bits(map: data->regmap, BMP580_REG_DSP_CONFIG,
2402	BMP580_DSP_IIR_FORCED_FLUSH);
2403	if (ret) {
2404	dev_err(dev, "Could not flush IIR filter constants.\n");
2405	return ret;
2406	}
2407	}
2408
2409	ret = regmap_write_bits(map: data->regmap, BMP580_REG_ODR_CONFIG,
2410	BMP580_MODE_MASK,
2411	FIELD_PREP(BMP580_MODE_MASK,
2412	bmp580_operation_mode[mode]));
2413	if (ret) {
2414	dev_err(dev, "failed to write power control register.\n");
2415	return ret;
2416	}
2417
2418	data->op_mode = mode;
2419
2420	return 0;
2421	}
2422
2423	static int bmp580_wait_conv(struct bmp280_data *data)
2424	{
2425	/*
2426	* Taken from datasheet, Section 2 "Specification, Table 3 "Electrical
2427	* characteristics.
2428	*/
2429	static const int time_conv_press[] = {
2430	0, 1050, 1785, 3045, 5670, 10920, 21420, 42420,
2431	84420,
2432	};
2433	static const int time_conv_temp[] = {
2434	0, 1050, 1105, 1575, 2205, 3465, 6090, 11340,
2435	21840,
2436	};
2437	int meas_time_us;
2438
2439	meas_time_us = 4 * USEC_PER_MSEC +
2440	time_conv_temp[data->oversampling_temp] +
2441	time_conv_press[data->oversampling_press];
2442
2443	/*
2444	* Measurement time mentioned in Chapter 2, Table 4 of the datasheet.
2445	* The extra 4ms is the required mode change to start of measurement
2446	* time.
2447	*/
2448	fsleep(usecs: meas_time_us);
2449
2450	return 0;
2451	}
2452
2453	static int bmp580_chip_config(struct bmp280_data *data)
2454	{
2455	bool change = false, aux;
2456	unsigned int tmp;
2457	u8 reg_val;
2458	int ret;
2459
2460	/* Sets sensor in standby mode */
2461	ret = regmap_update_bits(map: data->regmap, BMP580_REG_ODR_CONFIG,
2462	BMP580_MODE_MASK | BMP580_ODR_DEEPSLEEP_DIS,
2463	BMP580_ODR_DEEPSLEEP_DIS |
2464	FIELD_PREP(BMP580_MODE_MASK, BMP580_MODE_SLEEP));
2465	if (ret) {
2466	dev_err(data->dev, "failed to change sensor to standby mode\n");
2467	return ret;
2468	}
2469	/* From datasheet's table 4: electrical characteristics */
2470	fsleep(usecs: 2500);
2471
2472	/* Set default DSP mode settings */
2473	reg_val = FIELD_PREP(BMP580_DSP_COMP_MASK, BMP580_DSP_PRESS_TEMP_COMP_EN) |
2474	BMP580_DSP_SHDW_IIR_TEMP_EN | BMP580_DSP_SHDW_IIR_PRESS_EN;
2475
2476	ret = regmap_update_bits(map: data->regmap, BMP580_REG_DSP_CONFIG,
2477	BMP580_DSP_COMP_MASK |
2478	BMP580_DSP_SHDW_IIR_TEMP_EN |
2479	BMP580_DSP_SHDW_IIR_PRESS_EN, val: reg_val);
2480	if (ret) {
2481	dev_err(data->dev, "failed to change DSP mode settings\n");
2482	return ret;
2483	}
2484
2485	/* Configure oversampling */
2486	reg_val = FIELD_PREP(BMP580_OSR_TEMP_MASK, data->oversampling_temp) |
2487	FIELD_PREP(BMP580_OSR_PRESS_MASK, data->oversampling_press) |
2488	BMP580_OSR_PRESS_EN;
2489
2490	ret = regmap_update_bits_check(map: data->regmap, BMP580_REG_OSR_CONFIG,
2491	BMP580_OSR_TEMP_MASK |
2492	BMP580_OSR_PRESS_MASK |
2493	BMP580_OSR_PRESS_EN,
2494	val: reg_val, change: &aux);
2495	if (ret) {
2496	dev_err(data->dev, "failed to write oversampling register\n");
2497	return ret;
2498	}
2499	change = change || aux;
2500
2501	/* Configure output data rate */
2502	ret = regmap_update_bits_check(map: data->regmap, BMP580_REG_ODR_CONFIG, BMP580_ODR_MASK,
2503	FIELD_PREP(BMP580_ODR_MASK, data->sampling_freq),
2504	change: &aux);
2505	if (ret) {
2506	dev_err(data->dev, "failed to write ODR configuration register\n");
2507	return ret;
2508	}
2509	change = change || aux;
2510
2511	/* Set filter data */
2512	reg_val = FIELD_PREP(BMP580_DSP_IIR_PRESS_MASK, data->iir_filter_coeff) |
2513	FIELD_PREP(BMP580_DSP_IIR_TEMP_MASK, data->iir_filter_coeff);
2514
2515	ret = regmap_update_bits(map: data->regmap, BMP580_REG_DSP_IIR,
2516	BMP580_DSP_IIR_PRESS_MASK | BMP580_DSP_IIR_TEMP_MASK,
2517	val: reg_val);
2518	if (ret) {
2519	dev_err(data->dev, "failed to write config register\n");
2520	return ret;
2521	}
2522
2523	if (change) {
2524	/*
2525	* Check if ODR and OSR settings are valid or we are
2526	* operating in a degraded mode.
2527	*/
2528	ret = regmap_read(map: data->regmap, BMP580_REG_EFF_OSR, val: &tmp);
2529	if (ret) {
2530	dev_err(data->dev,
2531	"error reading effective OSR register\n");
2532	return ret;
2533	}
2534	if (!(tmp & BMP580_EFF_OSR_VALID_ODR)) {
2535	dev_warn(data->dev, "OSR and ODR incompatible settings detected\n");
2536	/* Set current OSR settings from data on effective OSR */
2537	data->oversampling_temp = FIELD_GET(BMP580_EFF_OSR_TEMP_MASK, tmp);
2538	data->oversampling_press = FIELD_GET(BMP580_EFF_OSR_PRESS_MASK, tmp);
2539	return -EINVAL;
2540	}
2541	}
2542
2543	return 0;
2544	}
2545
2546	static int bmp580_data_rdy_trigger_set_state(struct iio_trigger *trig,
2547	bool state)
2548	{
2549	struct bmp280_data *data = iio_trigger_get_drvdata(trig);
2550	int ret;
2551
2552	guard(mutex)(T: &data->lock);
2553
2554	ret = regmap_update_bits(map: data->regmap, BMP580_REG_INT_CONFIG,
2555	BMP580_INT_CONFIG_INT_EN,
2556	FIELD_PREP(BMP580_INT_CONFIG_INT_EN, !!state));
2557	if (ret)
2558	dev_err(data->dev,
2559	"Could not %s interrupt.\n", str_enable_disable(state));
2560	return ret;
2561	}
2562
2563	static const struct iio_trigger_ops bmp580_trigger_ops = {
2564	.set_trigger_state = &bmp580_data_rdy_trigger_set_state,
2565	};
2566
2567	static int bmp580_int_pin_config(struct bmp280_data *data)
2568	{
2569	int pin_drive_cfg = FIELD_PREP(BMP580_INT_CONFIG_OPEN_DRAIN,
2570	data->trig_open_drain);
2571	int pin_level_cfg = FIELD_PREP(BMP580_INT_CONFIG_LEVEL,
2572	data->trig_active_high);
2573	int ret, int_pin_cfg = pin_drive_cfg | pin_level_cfg;
2574
2575	ret = regmap_update_bits(map: data->regmap, BMP580_REG_INT_CONFIG,
2576	BMP580_INT_CONFIG_MASK, val: int_pin_cfg);
2577	if (ret) {
2578	dev_err(data->dev, "Could not set interrupt settings.\n");
2579	return ret;
2580	}
2581
2582	ret = regmap_set_bits(map: data->regmap, BMP580_REG_INT_SOURCE,
2583	BMP580_INT_SOURCE_DRDY);
2584	if (ret)
2585	dev_err(data->dev, "Could not set interrupt source.\n");
2586
2587	return ret;
2588	}
2589
2590	static irqreturn_t bmp580_irq_thread_handler(int irq, void *p)
2591	{
2592	struct iio_dev *indio_dev = p;
2593	struct bmp280_data *data = iio_priv(indio_dev);
2594	unsigned int int_ctrl;
2595	int ret;
2596
2597	ret = regmap_read(map: data->regmap, BMP580_REG_INT_STATUS, val: &int_ctrl);
2598	if (ret)
2599	return IRQ_NONE;
2600
2601	if (FIELD_GET(BMP580_INT_STATUS_DRDY_MASK, int_ctrl))
2602	iio_trigger_poll_nested(trig: data->trig);
2603
2604	return IRQ_HANDLED;
2605	}
2606
2607	static int bmp580_trigger_probe(struct iio_dev *indio_dev)
2608	{
2609	return __bmp280_trigger_probe(indio_dev, trigger_ops: &bmp580_trigger_ops,
2610	int_pin_config: bmp580_int_pin_config,
2611	irq_thread_handler: bmp580_irq_thread_handler);
2612	}
2613
2614	static irqreturn_t bmp580_trigger_handler(int irq, void *p)
2615	{
2616	struct iio_poll_func *pf = p;
2617	struct iio_dev *indio_dev = pf->indio_dev;
2618	struct bmp280_data *data = iio_priv(indio_dev);
2619	struct {
2620	__le32 comp_temp;
2621	__le32 comp_press;
2622	aligned_s64 timestamp;
2623	} buffer;
2624	int ret;
2625
2626	guard(mutex)(T: &data->lock);
2627
2628	/* Burst read data registers */
2629	ret = regmap_bulk_read(map: data->regmap, BMP580_REG_TEMP_XLSB,
2630	val: data->buf, BMP280_BURST_READ_BYTES);
2631	if (ret) {
2632	dev_err(data->dev, "failed to burst read sensor data\n");
2633	goto out;
2634	}
2635
2636	/* Pressure calculations */
2637	memcpy(&buffer.comp_press, &data->buf[3], 3);
2638
2639	/* Temperature calculations */
2640	memcpy(&buffer.comp_temp, &data->buf[0], 3);
2641
2642	iio_push_to_buffers_with_ts(indio_dev, data: &buffer, data_total_len: sizeof(buffer),
2643	timestamp: iio_get_time_ns(indio_dev));
2644
2645	out:
2646	iio_trigger_notify_done(trig: indio_dev->trig);
2647
2648	return IRQ_HANDLED;
2649	}
2650
2651	static const int bmp580_oversampling_avail[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
2652	static const u8 bmp580_chip_ids[] = { BMP580_CHIP_ID, BMP580_CHIP_ID_ALT };
2653	/* Instead of { 1000, 16 } we do this, to avoid overflow issues */
2654	static const int bmp580_temp_coeffs[] = { 125, 13 };
2655	static const int bmp580_press_coeffs[] = { 1, 64000};
2656
2657	const struct bmp280_chip_info bmp580_chip_info = {
2658	.id_reg = BMP580_REG_CHIP_ID,
2659	.chip_id = bmp580_chip_ids,
2660	.num_chip_id = ARRAY_SIZE(bmp580_chip_ids),
2661	.regmap_config = &bmp580_regmap_config,
2662	.start_up_time_us = 2000,
2663	.channels = bmp580_channels,
2664	.num_channels = ARRAY_SIZE(bmp580_channels),
2665	.avail_scan_masks = bmp280_avail_scan_masks,
2666
2667	.oversampling_temp_avail = bmp580_oversampling_avail,
2668	.num_oversampling_temp_avail = ARRAY_SIZE(bmp580_oversampling_avail),
2669	.oversampling_temp_default = ilog2(1),
2670
2671	.oversampling_press_avail = bmp580_oversampling_avail,
2672	.num_oversampling_press_avail = ARRAY_SIZE(bmp580_oversampling_avail),
2673	.oversampling_press_default = ilog2(4),
2674
2675	.sampling_freq_avail = bmp580_odr_table,
2676	.num_sampling_freq_avail = ARRAY_SIZE(bmp580_odr_table) * 2,
2677	.sampling_freq_default = BMP580_ODR_50HZ,
2678
2679	.iir_filter_coeffs_avail = bmp380_iir_filter_coeffs_avail,
2680	.num_iir_filter_coeffs_avail = ARRAY_SIZE(bmp380_iir_filter_coeffs_avail),
2681	.iir_filter_coeff_default = 2,
2682
2683	.temp_coeffs = bmp580_temp_coeffs,
2684	.temp_coeffs_type = IIO_VAL_FRACTIONAL_LOG2,
2685	.press_coeffs = bmp580_press_coeffs,
2686	.press_coeffs_type = IIO_VAL_FRACTIONAL,
2687
2688	.chip_config = bmp580_chip_config,
2689	.read_temp = bmp580_read_temp,
2690	.read_press = bmp580_read_press,
2691	.set_mode = bmp580_set_mode,
2692	.wait_conv = bmp580_wait_conv,
2693	.preinit = bmp580_preinit,
2694
2695	.trigger_probe = bmp580_trigger_probe,
2696	.trigger_handler = bmp580_trigger_handler,
2697	};
2698	EXPORT_SYMBOL_NS(bmp580_chip_info, "IIO_BMP280");
2699
2700	static int bmp180_wait_for_eoc(struct bmp280_data *data, u8 ctrl_meas)
2701	{
2702	static const int conversion_time_max[] = { 4500, 7500, 13500, 25500 };
2703	unsigned int delay_us;
2704	unsigned int ctrl;
2705	int ret;
2706
2707	if (data->use_eoc)
2708	reinit_completion(x: &data->done);
2709
2710	ret = regmap_write(map: data->regmap, BMP280_REG_CTRL_MEAS, val: ctrl_meas);
2711	if (ret) {
2712	dev_err(data->dev, "failed to write crtl_meas register\n");
2713	return ret;
2714	}
2715
2716	if (data->use_eoc) {
2717	/*
2718	* If we have a completion interrupt, use it, wait up to
2719	* 100ms. The longest conversion time listed is 76.5 ms for
2720	* advanced resolution mode.
2721	*/
2722	ret = wait_for_completion_timeout(x: &data->done,
2723	timeout: 1 + msecs_to_jiffies(m: 100));
2724	if (!ret)
2725	dev_err(data->dev, "timeout waiting for completion\n");
2726	} else {
2727	if (FIELD_GET(BMP180_MEAS_CTRL_MASK, ctrl_meas) == BMP180_MEAS_TEMP)
2728	delay_us = 4500;
2729	else
2730	delay_us =
2731	conversion_time_max[data->oversampling_press];
2732
2733	fsleep(usecs: delay_us);
2734	}
2735
2736	ret = regmap_read(map: data->regmap, BMP280_REG_CTRL_MEAS, val: &ctrl);
2737	if (ret) {
2738	dev_err(data->dev, "failed to read ctrl_meas register\n");
2739	return ret;
2740	}
2741
2742	/* The value of this bit reset to "0" after conversion is complete */
2743	if (ctrl & BMP180_MEAS_SCO) {
2744	dev_err(data->dev, "conversion didn't complete\n");
2745	return -EIO;
2746	}
2747
2748	return 0;
2749	}
2750
2751	static int bmp180_read_temp_adc(struct bmp280_data *data, u32 *adc_temp)
2752	{
2753	int ret;
2754
2755	ret = bmp180_wait_for_eoc(data,
2756	FIELD_PREP(BMP180_MEAS_CTRL_MASK, BMP180_MEAS_TEMP) |
2757	BMP180_MEAS_SCO);
2758	if (ret)
2759	return ret;
2760
2761	ret = regmap_bulk_read(map: data->regmap, BMP180_REG_OUT_MSB,
2762	val: &data->be16, val_count: sizeof(data->be16));
2763	if (ret) {
2764	dev_err(data->dev, "failed to read temperature\n");
2765	return ret;
2766	}
2767
2768	*adc_temp = be16_to_cpu(data->be16);
2769
2770	return 0;
2771	}
2772
2773	static int bmp180_read_calib(struct bmp280_data *data)
2774	{
2775	struct bmp180_calib *calib = &data->calib.bmp180;
2776	int ret;
2777	int i;
2778
2779	ret = regmap_bulk_read(map: data->regmap, BMP180_REG_CALIB_START,
2780	val: data->bmp180_cal_buf, val_count: sizeof(data->bmp180_cal_buf));
2781	if (ret) {
2782	dev_err(data->dev, "failed to read calibration parameters\n");
2783	return ret;
2784	}
2785
2786	/* None of the words has the value 0 or 0xFFFF */
2787	for (i = 0; i < ARRAY_SIZE(data->bmp180_cal_buf); i++) {
2788	if (data->bmp180_cal_buf[i] == cpu_to_be16(0) ||
2789	data->bmp180_cal_buf[i] == cpu_to_be16(0xffff))
2790	return -EIO;
2791	}
2792
2793	/* Toss the calibration data into the entropy pool */
2794	add_device_randomness(buf: data->bmp180_cal_buf,
2795	len: sizeof(data->bmp180_cal_buf));
2796
2797	calib->AC1 = be16_to_cpu(data->bmp180_cal_buf[AC1]);
2798	calib->AC2 = be16_to_cpu(data->bmp180_cal_buf[AC2]);
2799	calib->AC3 = be16_to_cpu(data->bmp180_cal_buf[AC3]);
2800	calib->AC4 = be16_to_cpu(data->bmp180_cal_buf[AC4]);
2801	calib->AC5 = be16_to_cpu(data->bmp180_cal_buf[AC5]);
2802	calib->AC6 = be16_to_cpu(data->bmp180_cal_buf[AC6]);
2803	calib->B1 = be16_to_cpu(data->bmp180_cal_buf[B1]);
2804	calib->B2 = be16_to_cpu(data->bmp180_cal_buf[B2]);
2805	calib->MB = be16_to_cpu(data->bmp180_cal_buf[MB]);
2806	calib->MC = be16_to_cpu(data->bmp180_cal_buf[MC]);
2807	calib->MD = be16_to_cpu(data->bmp180_cal_buf[MD]);
2808
2809	return 0;
2810	}
2811
2812	/*
2813	* Returns temperature in DegC, resolution is 0.1 DegC.
2814	* t_fine carries fine temperature as global value.
2815	*
2816	* Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
2817	*/
2818
2819	static s32 bmp180_calc_t_fine(struct bmp280_data *data, u32 adc_temp)
2820	{
2821	struct bmp180_calib *calib = &data->calib.bmp180;
2822	s32 x1, x2;
2823
2824	x1 = ((((s32)adc_temp) - calib->AC6) * calib->AC5) >> 15;
2825	x2 = (calib->MC << 11) / (x1 + calib->MD);
2826	return x1 + x2; /* t_fine = x1 + x2; */
2827	}
2828
2829	static int bmp180_get_t_fine(struct bmp280_data *data, s32 *t_fine)
2830	{
2831	s32 adc_temp;
2832	int ret;
2833
2834	ret = bmp180_read_temp_adc(data, adc_temp: &adc_temp);
2835	if (ret)
2836	return ret;
2837
2838	*t_fine = bmp180_calc_t_fine(data, adc_temp);
2839
2840	return 0;
2841	}
2842
2843	static s32 bmp180_compensate_temp(struct bmp280_data *data, u32 adc_temp)
2844	{
2845	return (bmp180_calc_t_fine(data, adc_temp) + 8) / 16;
2846	}
2847
2848	static int bmp180_read_temp(struct bmp280_data *data, s32 *comp_temp)
2849	{
2850	u32 adc_temp;
2851	int ret;
2852
2853	ret = bmp180_read_temp_adc(data, adc_temp: &adc_temp);
2854	if (ret)
2855	return ret;
2856
2857	*comp_temp = bmp180_compensate_temp(data, adc_temp);
2858
2859	return 0;
2860	}
2861
2862	static int bmp180_read_press_adc(struct bmp280_data *data, u32 *adc_press)
2863	{
2864	u8 oss = data->oversampling_press;
2865	int ret;
2866
2867	ret = bmp180_wait_for_eoc(data,
2868	FIELD_PREP(BMP180_MEAS_CTRL_MASK, BMP180_MEAS_PRESS) |
2869	FIELD_PREP(BMP180_OSRS_PRESS_MASK, oss) |
2870	BMP180_MEAS_SCO);
2871	if (ret)
2872	return ret;
2873
2874	ret = regmap_bulk_read(map: data->regmap, BMP180_REG_OUT_MSB,
2875	val: data->buf, BMP280_NUM_PRESS_BYTES);
2876	if (ret) {
2877	dev_err(data->dev, "failed to read pressure\n");
2878	return ret;
2879	}
2880
2881	*adc_press = get_unaligned_be24(p: data->buf) >> (8 - oss);
2882
2883	return 0;
2884	}
2885
2886	/*
2887	* Returns pressure in Pa, resolution is 1 Pa.
2888	*
2889	* Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
2890	*/
2891	static u32 bmp180_compensate_press(struct bmp280_data *data, u32 adc_press,
2892	s32 t_fine)
2893	{
2894	struct bmp180_calib *calib = &data->calib.bmp180;
2895	s32 oss = data->oversampling_press;
2896	s32 x1, x2, x3, p;
2897	s32 b3, b6;
2898	u32 b4, b7;
2899
2900	b6 = t_fine - 4000;
2901	x1 = (calib->B2 * (b6 * b6 >> 12)) >> 11;
2902	x2 = calib->AC2 * b6 >> 11;
2903	x3 = x1 + x2;
2904	b3 = ((((s32)calib->AC1 * 4 + x3) << oss) + 2) / 4;
2905	x1 = calib->AC3 * b6 >> 13;
2906	x2 = (calib->B1 * ((b6 * b6) >> 12)) >> 16;
2907	x3 = (x1 + x2 + 2) >> 2;
2908	b4 = calib->AC4 * (u32)(x3 + 32768) >> 15;
2909	b7 = (adc_press - b3) * (50000 >> oss);
2910	if (b7 < 0x80000000)
2911	p = (b7 * 2) / b4;
2912	else
2913	p = (b7 / b4) * 2;
2914
2915	x1 = (p >> 8) * (p >> 8);
2916	x1 = (x1 * 3038) >> 16;
2917	x2 = (-7357 * p) >> 16;
2918
2919	return p + ((x1 + x2 + 3791) >> 4);
2920	}
2921
2922	static int bmp180_read_press(struct bmp280_data *data, u32 *comp_press)
2923	{
2924	u32 adc_press;
2925	s32 t_fine;
2926	int ret;
2927
2928	ret = bmp180_get_t_fine(data, t_fine: &t_fine);
2929	if (ret)
2930	return ret;
2931
2932	ret = bmp180_read_press_adc(data, adc_press: &adc_press);
2933	if (ret)
2934	return ret;
2935
2936	*comp_press = bmp180_compensate_press(data, adc_press, t_fine);
2937
2938	return 0;
2939	}
2940
2941	/* Keep compatibility with newer generations of the sensor */
2942	static int bmp180_set_mode(struct bmp280_data *data, enum bmp280_op_mode mode)
2943	{
2944	return 0;
2945	}
2946
2947	/* Keep compatibility with newer generations of the sensor */
2948	static int bmp180_wait_conv(struct bmp280_data *data)
2949	{
2950	return 0;
2951	}
2952
2953	/* Keep compatibility with newer generations of the sensor */
2954	static int bmp180_chip_config(struct bmp280_data *data)
2955	{
2956	return 0;
2957	}
2958
2959	static irqreturn_t bmp180_trigger_handler(int irq, void *p)
2960	{
2961	struct iio_poll_func *pf = p;
2962	struct iio_dev *indio_dev = pf->indio_dev;
2963	struct bmp280_data *data = iio_priv(indio_dev);
2964	struct {
2965	u32 comp_press;
2966	s32 comp_temp;
2967	aligned_s64 timestamp;
2968	} buffer;
2969	int ret;
2970
2971	guard(mutex)(T: &data->lock);
2972
2973	ret = bmp180_read_temp(data, comp_temp: &buffer.comp_temp);
2974	if (ret)
2975	goto out;
2976
2977
2978	ret = bmp180_read_press(data, comp_press: &buffer.comp_press);
2979	if (ret)
2980	goto out;
2981
2982	iio_push_to_buffers_with_ts(indio_dev, data: &buffer, data_total_len: sizeof(buffer),
2983	timestamp: iio_get_time_ns(indio_dev));
2984
2985	out:
2986	iio_trigger_notify_done(trig: indio_dev->trig);
2987
2988	return IRQ_HANDLED;
2989	}
2990
2991	static const int bmp180_oversampling_temp_avail[] = { 1 };
2992	static const int bmp180_oversampling_press_avail[] = { 1, 2, 4, 8 };
2993	static const u8 bmp180_chip_ids[] = { BMP180_CHIP_ID };
2994	static const int bmp180_temp_coeffs[] = { 100, 1 };
2995	static const int bmp180_press_coeffs[] = { 1, 1000 };
2996
2997	const struct bmp280_chip_info bmp180_chip_info = {
2998	.id_reg = BMP280_REG_ID,
2999	.chip_id = bmp180_chip_ids,
3000	.num_chip_id = ARRAY_SIZE(bmp180_chip_ids),
3001	.regmap_config = &bmp180_regmap_config,
3002	.start_up_time_us = 2000,
3003	.channels = bmp280_channels,
3004	.num_channels = ARRAY_SIZE(bmp280_channels),
3005	.avail_scan_masks = bmp280_avail_scan_masks,
3006
3007	.oversampling_temp_avail = bmp180_oversampling_temp_avail,
3008	.num_oversampling_temp_avail =
3009	ARRAY_SIZE(bmp180_oversampling_temp_avail),
3010	.oversampling_temp_default = 0,
3011
3012	.oversampling_press_avail = bmp180_oversampling_press_avail,
3013	.num_oversampling_press_avail =
3014	ARRAY_SIZE(bmp180_oversampling_press_avail),
3015	.oversampling_press_default = BMP180_MEAS_PRESS_8X,
3016
3017	.temp_coeffs = bmp180_temp_coeffs,
3018	.temp_coeffs_type = IIO_VAL_FRACTIONAL,
3019	.press_coeffs = bmp180_press_coeffs,
3020	.press_coeffs_type = IIO_VAL_FRACTIONAL,
3021
3022	.chip_config = bmp180_chip_config,
3023	.read_temp = bmp180_read_temp,
3024	.read_press = bmp180_read_press,
3025	.read_calib = bmp180_read_calib,
3026	.set_mode = bmp180_set_mode,
3027	.wait_conv = bmp180_wait_conv,
3028
3029	.trigger_handler = bmp180_trigger_handler,
3030	};
3031	EXPORT_SYMBOL_NS(bmp180_chip_info, "IIO_BMP280");
3032
3033	static irqreturn_t bmp085_eoc_irq(int irq, void *d)
3034	{
3035	struct bmp280_data *data = d;
3036
3037	complete(&data->done);
3038
3039	return IRQ_HANDLED;
3040	}
3041
3042	static int bmp085_trigger_probe(struct iio_dev *indio_dev)
3043	{
3044	struct bmp280_data *data = iio_priv(indio_dev);
3045	struct device *dev = data->dev;
3046	unsigned long irq_trig;
3047	int ret, irq;
3048
3049	irq = fwnode_irq_get(dev_fwnode(dev), index: 0);
3050	if (irq < 0)
3051	return dev_err_probe(dev, err: irq, fmt: "No interrupt found.\n");
3052
3053	irq_trig = irq_get_trigger_type(irq);
3054	if (irq_trig != IRQF_TRIGGER_RISING) {
3055	dev_err(dev, "non-rising trigger given for EOC interrupt, trying to enforce it\n");
3056	irq_trig = IRQF_TRIGGER_RISING;
3057	}
3058
3059	init_completion(x: &data->done);
3060
3061	ret = devm_request_irq(dev, irq, handler: bmp085_eoc_irq, irqflags: irq_trig,
3062	devname: indio_dev->name, dev_id: data);
3063	if (ret) {
3064	/* Bail out without IRQ but keep the driver in place */
3065	dev_err(dev, "unable to request DRDY IRQ\n");
3066	return 0;
3067	}
3068
3069	data->use_eoc = true;
3070
3071	return 0;
3072	}
3073
3074	/* Identical to bmp180_chip_info + bmp085_trigger_probe */
3075	const struct bmp280_chip_info bmp085_chip_info = {
3076	.id_reg = BMP280_REG_ID,
3077	.chip_id = bmp180_chip_ids,
3078	.num_chip_id = ARRAY_SIZE(bmp180_chip_ids),
3079	.regmap_config = &bmp180_regmap_config,
3080	.start_up_time_us = 2000,
3081	.channels = bmp280_channels,
3082	.num_channels = ARRAY_SIZE(bmp280_channels),
3083	.avail_scan_masks = bmp280_avail_scan_masks,
3084
3085	.oversampling_temp_avail = bmp180_oversampling_temp_avail,
3086	.num_oversampling_temp_avail =
3087	ARRAY_SIZE(bmp180_oversampling_temp_avail),
3088	.oversampling_temp_default = 0,
3089
3090	.oversampling_press_avail = bmp180_oversampling_press_avail,
3091	.num_oversampling_press_avail =
3092	ARRAY_SIZE(bmp180_oversampling_press_avail),
3093	.oversampling_press_default = BMP180_MEAS_PRESS_8X,
3094
3095	.temp_coeffs = bmp180_temp_coeffs,
3096	.temp_coeffs_type = IIO_VAL_FRACTIONAL,
3097	.press_coeffs = bmp180_press_coeffs,
3098	.press_coeffs_type = IIO_VAL_FRACTIONAL,
3099
3100	.chip_config = bmp180_chip_config,
3101	.read_temp = bmp180_read_temp,
3102	.read_press = bmp180_read_press,
3103	.read_calib = bmp180_read_calib,
3104	.set_mode = bmp180_set_mode,
3105	.wait_conv = bmp180_wait_conv,
3106
3107	.trigger_probe = bmp085_trigger_probe,
3108	.trigger_handler = bmp180_trigger_handler,
3109	};
3110	EXPORT_SYMBOL_NS(bmp085_chip_info, "IIO_BMP280");
3111
3112	static int bmp280_buffer_preenable(struct iio_dev *indio_dev)
3113	{
3114	struct bmp280_data *data = iio_priv(indio_dev);
3115
3116	pm_runtime_get_sync(dev: data->dev);
3117	data->chip_info->set_mode(data, BMP280_NORMAL);
3118
3119	return 0;
3120	}
3121
3122	static int bmp280_buffer_postdisable(struct iio_dev *indio_dev)
3123	{
3124	struct bmp280_data *data = iio_priv(indio_dev);
3125
3126	pm_runtime_mark_last_busy(dev: data->dev);
3127	pm_runtime_put_autosuspend(dev: data->dev);
3128
3129	return 0;
3130	}
3131
3132	static const struct iio_buffer_setup_ops bmp280_buffer_setup_ops = {
3133	.preenable = bmp280_buffer_preenable,
3134	.postdisable = bmp280_buffer_postdisable,
3135	};
3136
3137	static void bmp280_pm_disable(void *data)
3138	{
3139	struct device *dev = data;
3140
3141	pm_runtime_get_sync(dev);
3142	pm_runtime_put_noidle(dev);
3143	pm_runtime_disable(dev);
3144	}
3145
3146	static void bmp280_regulators_disable(void *data)
3147	{
3148	struct regulator_bulk_data *supplies = data;
3149
3150	regulator_bulk_disable(BMP280_NUM_SUPPLIES, consumers: supplies);
3151	}
3152
3153	int bmp280_common_probe(struct device *dev,
3154	struct regmap *regmap,
3155	const struct bmp280_chip_info *chip_info,
3156	const char *name,
3157	int irq)
3158	{
3159	struct iio_dev *indio_dev;
3160	struct bmp280_data *data;
3161	struct gpio_desc *gpiod;
3162	unsigned int chip_id;
3163	unsigned int i;
3164	int ret;
3165
3166	indio_dev = devm_iio_device_alloc(parent: dev, sizeof_priv: sizeof(*data));
3167	if (!indio_dev)
3168	return -ENOMEM;
3169
3170	data = iio_priv(indio_dev);
3171	mutex_init(&data->lock);
3172	data->dev = dev;
3173
3174	indio_dev->name = name;
3175	indio_dev->info = &bmp280_info;
3176	indio_dev->modes = INDIO_DIRECT_MODE;
3177
3178	data->chip_info = chip_info;
3179
3180	/* Apply initial values from chip info structure */
3181	indio_dev->channels = chip_info->channels;
3182	indio_dev->num_channels = chip_info->num_channels;
3183	indio_dev->available_scan_masks = chip_info->avail_scan_masks;
3184	data->oversampling_press = chip_info->oversampling_press_default;
3185	data->oversampling_humid = chip_info->oversampling_humid_default;
3186	data->oversampling_temp = chip_info->oversampling_temp_default;
3187	data->iir_filter_coeff = chip_info->iir_filter_coeff_default;
3188	data->sampling_freq = chip_info->sampling_freq_default;
3189	data->start_up_time_us = chip_info->start_up_time_us;
3190
3191	/* Bring up regulators */
3192	regulator_bulk_set_supply_names(consumers: data->supplies,
3193	supply_names: bmp280_supply_names,
3194	BMP280_NUM_SUPPLIES);
3195
3196	ret = devm_regulator_bulk_get(dev,
3197	BMP280_NUM_SUPPLIES, consumers: data->supplies);
3198	if (ret) {
3199	dev_err(dev, "failed to get regulators\n");
3200	return ret;
3201	}
3202
3203	ret = regulator_bulk_enable(BMP280_NUM_SUPPLIES, consumers: data->supplies);
3204	if (ret) {
3205	dev_err(dev, "failed to enable regulators\n");
3206	return ret;
3207	}
3208
3209	ret = devm_add_action_or_reset(dev, bmp280_regulators_disable,
3210	data->supplies);
3211	if (ret)
3212	return ret;
3213
3214	/* Wait to make sure we started up properly */
3215	fsleep(usecs: data->start_up_time_us);
3216
3217	/* Bring chip out of reset if there is an assigned GPIO line */
3218	gpiod = devm_gpiod_get_optional(dev, con_id: "reset", flags: GPIOD_OUT_HIGH);
3219	/* Deassert the signal */
3220	if (gpiod) {
3221	dev_info(dev, "release reset\n");
3222	gpiod_set_value(desc: gpiod, value: 0);
3223	}
3224
3225	data->regmap = regmap;
3226
3227	ret = regmap_read(map: regmap, reg: data->chip_info->id_reg, val: &chip_id);
3228	if (ret) {
3229	dev_err(data->dev, "failed to read chip id\n");
3230	return ret;
3231	}
3232
3233	for (i = 0; i < data->chip_info->num_chip_id; i++) {
3234	if (chip_id == data->chip_info->chip_id[i]) {
3235	dev_info(dev, "0x%x is a known chip id for %s\n", chip_id, name);
3236	break;
3237	}
3238	}
3239
3240	if (i == data->chip_info->num_chip_id)
3241	dev_warn(dev, "bad chip id: 0x%x is not a known chip id\n", chip_id);
3242
3243	if (data->chip_info->preinit) {
3244	ret = data->chip_info->preinit(data);
3245	if (ret)
3246	return dev_err_probe(dev: data->dev, err: ret,
3247	fmt: "error running preinit tasks\n");
3248	}
3249
3250	ret = data->chip_info->chip_config(data);
3251	if (ret)
3252	return ret;
3253
3254	dev_set_drvdata(dev, data: indio_dev);
3255
3256	/*
3257	* Some chips have calibration parameters "programmed into the devices'
3258	* non-volatile memory during production". Let's read them out at probe
3259	* time once. They will not change.
3260	*/
3261
3262	if (data->chip_info->read_calib) {
3263	ret = data->chip_info->read_calib(data);
3264	if (ret)
3265	return dev_err_probe(dev: data->dev, err: ret,
3266	fmt: "failed to read calibration coefficients\n");
3267	}
3268
3269	ret = devm_iio_triggered_buffer_setup(data->dev, indio_dev,
3270	iio_pollfunc_store_time,
3271	data->chip_info->trigger_handler,
3272	&bmp280_buffer_setup_ops);
3273	if (ret)
3274	return dev_err_probe(dev: data->dev, err: ret,
3275	fmt: "iio triggered buffer setup failed\n");
3276
3277	/*
3278	* Attempt to grab an optional EOC IRQ - only the BMP085 has this
3279	* however as it happens, the BMP085 shares the chip ID of BMP180
3280	* so we look for an IRQ if we have that.
3281	*/
3282	if (irq > 0) {
3283	if (data->chip_info->trigger_probe)
3284	ret = data->chip_info->trigger_probe(indio_dev);
3285	if (ret)
3286	return ret;
3287	}
3288
3289	ret = data->chip_info->set_mode(data, BMP280_SLEEP);
3290	if (ret)
3291	return dev_err_probe(dev, err: ret, fmt: "Failed to set sleep mode\n");
3292
3293	/* Enable runtime PM */
3294	pm_runtime_get_noresume(dev);
3295	pm_runtime_set_active(dev);
3296	pm_runtime_enable(dev);
3297	/*
3298	* Set autosuspend to two orders of magnitude larger than the
3299	* start-up time.
3300	*/
3301	pm_runtime_set_autosuspend_delay(dev, delay: data->start_up_time_us / 10);
3302	pm_runtime_use_autosuspend(dev);
3303	pm_runtime_put(dev);
3304
3305	ret = devm_add_action_or_reset(dev, bmp280_pm_disable, dev);
3306	if (ret)
3307	return ret;
3308
3309	return devm_iio_device_register(dev, indio_dev);
3310	}
3311	EXPORT_SYMBOL_NS(bmp280_common_probe, "IIO_BMP280");
3312
3313	static int bmp280_runtime_suspend(struct device *dev)
3314	{
3315	struct iio_dev *indio_dev = dev_get_drvdata(dev);
3316	struct bmp280_data *data = iio_priv(indio_dev);
3317
3318	data->chip_info->set_mode(data, BMP280_SLEEP);
3319
3320	fsleep(usecs: data->start_up_time_us);
3321	return regulator_bulk_disable(BMP280_NUM_SUPPLIES, consumers: data->supplies);
3322	}
3323
3324	static int bmp280_runtime_resume(struct device *dev)
3325	{
3326	struct iio_dev *indio_dev = dev_get_drvdata(dev);
3327	struct bmp280_data *data = iio_priv(indio_dev);
3328	int ret;
3329
3330	ret = regulator_bulk_enable(BMP280_NUM_SUPPLIES, consumers: data->supplies);
3331	if (ret)
3332	return ret;
3333
3334	fsleep(usecs: data->start_up_time_us);
3335
3336	ret = data->chip_info->chip_config(data);
3337	if (ret)
3338	return ret;
3339
3340	return data->chip_info->set_mode(data, data->op_mode);
3341	}
3342
3343	EXPORT_RUNTIME_DEV_PM_OPS(bmp280_dev_pm_ops, bmp280_runtime_suspend,
3344	bmp280_runtime_resume, NULL);
3345
3346	MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
3347	MODULE_DESCRIPTION("Driver for Bosch Sensortec BMP180/BMP280 pressure and temperature sensor");
3348	MODULE_LICENSE("GPL v2");
3349