1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2016 Marek Vasut <marex@denx.de>
4 *
5 * Driver for Hope RF HP03 digital temperature and pressure sensor.
6 */
7
8#define pr_fmt(fmt) "hp03: " fmt
9
10#include <linux/module.h>
11#include <linux/delay.h>
12#include <linux/gpio/consumer.h>
13#include <linux/i2c.h>
14#include <linux/regmap.h>
15#include <linux/iio/iio.h>
16#include <linux/iio/sysfs.h>
17
18/*
19 * The HP03 sensor occupies two fixed I2C addresses:
20 *  0x50 ... read-only EEPROM with calibration data
21 *  0x77 ... read-write ADC for pressure and temperature
22 */
23#define HP03_EEPROM_ADDR		0x50
24#define HP03_ADC_ADDR			0x77
25
26#define HP03_EEPROM_CX_OFFSET		0x10
27#define HP03_EEPROM_AB_OFFSET		0x1e
28#define HP03_EEPROM_CD_OFFSET		0x20
29
30#define HP03_ADC_WRITE_REG		0xff
31#define HP03_ADC_READ_REG		0xfd
32#define HP03_ADC_READ_PRESSURE		0xf0	/* D1 in datasheet */
33#define HP03_ADC_READ_TEMP		0xe8	/* D2 in datasheet */
34
35struct hp03_priv {
36	struct i2c_client	*client;
37	struct mutex		lock;
38	struct gpio_desc	*xclr_gpio;
39
40	struct i2c_client	*eeprom_client;
41	struct regmap		*eeprom_regmap;
42
43	s32			pressure;	/* kPa */
44	s32			temp;		/* Deg. C */
45};
46
47static const struct iio_chan_spec hp03_channels[] = {
48	{
49		.type = IIO_PRESSURE,
50		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
51		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
52	},
53	{
54		.type = IIO_TEMP,
55		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
56		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
57	},
58};
59
60static bool hp03_is_writeable_reg(struct device *dev, unsigned int reg)
61{
62	return false;
63}
64
65static bool hp03_is_volatile_reg(struct device *dev, unsigned int reg)
66{
67	return false;
68}
69
70static const struct regmap_config hp03_regmap_config = {
71	.reg_bits	= 8,
72	.val_bits	= 8,
73
74	.max_register	= HP03_EEPROM_CD_OFFSET + 1,
75	.cache_type	= REGCACHE_RBTREE,
76
77	.writeable_reg	= hp03_is_writeable_reg,
78	.volatile_reg	= hp03_is_volatile_reg,
79};
80
81static int hp03_get_temp_pressure(struct hp03_priv *priv, const u8 reg)
82{
83	int ret;
84
85	ret = i2c_smbus_write_byte_data(priv->client, HP03_ADC_WRITE_REG, reg);
86	if (ret < 0)
87		return ret;
88
89	msleep(50);	/* Wait for conversion to finish */
90
91	return i2c_smbus_read_word_data(priv->client, HP03_ADC_READ_REG);
92}
93
94static int hp03_update_temp_pressure(struct hp03_priv *priv)
95{
96	struct device *dev = &priv->client->dev;
97	u8 coefs[18];
98	u16 cx_val[7];
99	int ab_val, d1_val, d2_val, diff_val, dut, off, sens, x;
100	int i, ret;
101
102	/* Sample coefficients from EEPROM */
103	ret = regmap_bulk_read(priv->eeprom_regmap, HP03_EEPROM_CX_OFFSET,
104			       coefs, sizeof(coefs));
105	if (ret < 0) {
106		dev_err(dev, "Failed to read EEPROM (reg=%02x)\n",
107			HP03_EEPROM_CX_OFFSET);
108		return ret;
109	}
110
111	/* Sample Temperature and Pressure */
112	gpiod_set_value_cansleep(priv->xclr_gpio, 1);
113
114	ret = hp03_get_temp_pressure(priv, HP03_ADC_READ_PRESSURE);
115	if (ret < 0) {
116		dev_err(dev, "Failed to read pressure\n");
117		goto err_adc;
118	}
119	d1_val = ret;
120
121	ret = hp03_get_temp_pressure(priv, HP03_ADC_READ_TEMP);
122	if (ret < 0) {
123		dev_err(dev, "Failed to read temperature\n");
124		goto err_adc;
125	}
126	d2_val = ret;
127
128	gpiod_set_value_cansleep(priv->xclr_gpio, 0);
129
130	/* The Cx coefficients and Temp/Pressure values are MSB first. */
131	for (i = 0; i < 7; i++)
132		cx_val[i] = (coefs[2 * i] << 8) | (coefs[(2 * i) + 1] << 0);
133	d1_val = ((d1_val >> 8) & 0xff) | ((d1_val & 0xff) << 8);
134	d2_val = ((d2_val >> 8) & 0xff) | ((d2_val & 0xff) << 8);
135
136	/* Coefficient voodoo from the HP03 datasheet. */
137	if (d2_val >= cx_val[4])
138		ab_val = coefs[14];	/* A-value */
139	else
140		ab_val = coefs[15];	/* B-value */
141
142	diff_val = d2_val - cx_val[4];
143	dut = (ab_val * (diff_val >> 7) * (diff_val >> 7)) >> coefs[16];
144	dut = diff_val - dut;
145
146	off = (cx_val[1] + (((cx_val[3] - 1024) * dut) >> 14)) * 4;
147	sens = cx_val[0] + ((cx_val[2] * dut) >> 10);
148	x = ((sens * (d1_val - 7168)) >> 14) - off;
149
150	priv->pressure = ((x * 100) >> 5) + (cx_val[6] * 10);
151	priv->temp = 250 + ((dut * cx_val[5]) >> 16) - (dut >> coefs[17]);
152
153	return 0;
154
155err_adc:
156	gpiod_set_value_cansleep(priv->xclr_gpio, 0);
157	return ret;
158}
159
160static int hp03_read_raw(struct iio_dev *indio_dev,
161			 struct iio_chan_spec const *chan,
162			 int *val, int *val2, long mask)
163{
164	struct hp03_priv *priv = iio_priv(indio_dev);
165	int ret;
166
167	mutex_lock(&priv->lock);
168	ret = hp03_update_temp_pressure(priv);
169	mutex_unlock(&priv->lock);
170
171	if (ret)
172		return ret;
173
174	switch (mask) {
175	case IIO_CHAN_INFO_RAW:
176		switch (chan->type) {
177		case IIO_PRESSURE:
178			*val = priv->pressure;
179			return IIO_VAL_INT;
180		case IIO_TEMP:
181			*val = priv->temp;
182			return IIO_VAL_INT;
183		default:
184			return -EINVAL;
185		}
186		break;
187	case IIO_CHAN_INFO_SCALE:
188		switch (chan->type) {
189		case IIO_PRESSURE:
190			*val = 0;
191			*val2 = 1000;
192			return IIO_VAL_INT_PLUS_MICRO;
193		case IIO_TEMP:
194			*val = 10;
195			return IIO_VAL_INT;
196		default:
197			return -EINVAL;
198		}
199		break;
200	default:
201		return -EINVAL;
202	}
203
204	return -EINVAL;
205}
206
207static const struct iio_info hp03_info = {
208	.read_raw	= &hp03_read_raw,
209};
210
211static int hp03_probe(struct i2c_client *client)
212{
213	const struct i2c_device_id *id = i2c_client_get_device_id(client);
214	struct device *dev = &client->dev;
215	struct iio_dev *indio_dev;
216	struct hp03_priv *priv;
217	int ret;
218
219	indio_dev = devm_iio_device_alloc(dev, sizeof(*priv));
220	if (!indio_dev)
221		return -ENOMEM;
222
223	priv = iio_priv(indio_dev);
224	priv->client = client;
225	mutex_init(&priv->lock);
226
227	indio_dev->name = id->name;
228	indio_dev->channels = hp03_channels;
229	indio_dev->num_channels = ARRAY_SIZE(hp03_channels);
230	indio_dev->info = &hp03_info;
231	indio_dev->modes = INDIO_DIRECT_MODE;
232
233	priv->xclr_gpio = devm_gpiod_get_index(dev, "xclr", 0, GPIOD_OUT_HIGH);
234	if (IS_ERR(priv->xclr_gpio)) {
235		dev_err(dev, "Failed to claim XCLR GPIO\n");
236		ret = PTR_ERR(priv->xclr_gpio);
237		return ret;
238	}
239
240	/*
241	 * Allocate another device for the on-sensor EEPROM,
242	 * which has it's dedicated I2C address and contains
243	 * the calibration constants for the sensor.
244	 */
245	priv->eeprom_client = devm_i2c_new_dummy_device(dev, client->adapter,
246							HP03_EEPROM_ADDR);
247	if (IS_ERR(priv->eeprom_client)) {
248		dev_err(dev, "New EEPROM I2C device failed\n");
249		return PTR_ERR(priv->eeprom_client);
250	}
251
252	priv->eeprom_regmap = devm_regmap_init_i2c(priv->eeprom_client,
253						   &hp03_regmap_config);
254	if (IS_ERR(priv->eeprom_regmap)) {
255		dev_err(dev, "Failed to allocate EEPROM regmap\n");
256		return PTR_ERR(priv->eeprom_regmap);
257	}
258
259	ret = devm_iio_device_register(dev, indio_dev);
260	if (ret) {
261		dev_err(dev, "Failed to register IIO device\n");
262		return ret;
263	}
264
265	return 0;
266}
267
268static const struct i2c_device_id hp03_id[] = {
269	{ "hp03", 0 },
270	{ },
271};
272MODULE_DEVICE_TABLE(i2c, hp03_id);
273
274static const struct of_device_id hp03_of_match[] = {
275	{ .compatible = "hoperf,hp03" },
276	{ },
277};
278MODULE_DEVICE_TABLE(of, hp03_of_match);
279
280static struct i2c_driver hp03_driver = {
281	.driver = {
282		.name	= "hp03",
283		.of_match_table = hp03_of_match,
284	},
285	.probe		= hp03_probe,
286	.id_table	= hp03_id,
287};
288module_i2c_driver(hp03_driver);
289
290MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
291MODULE_DESCRIPTION("Driver for Hope RF HP03 pressure and temperature sensor");
292MODULE_LICENSE("GPL v2");
293