1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * tmp006.c - Support for TI TMP006 IR thermopile sensor
4  *
5  * Copyright (c) 2013 Peter Meerwald <pmeerw@pmeerw.net>
6  *
7  * Driver for the Texas Instruments I2C 16-bit IR thermopile sensor
8  *
9  * (7-bit I2C slave address 0x40, changeable via ADR pins)
10  */
11 
12 #include <linux/err.h>
13 #include <linux/i2c.h>
14 #include <linux/delay.h>
15 #include <linux/module.h>
16 #include <linux/mod_devicetable.h>
17 #include <linux/pm.h>
18 #include <linux/bitops.h>
19 
20 #include <linux/iio/iio.h>
21 #include <linux/iio/sysfs.h>
22 #include <linux/iio/trigger.h>
23 #include <linux/iio/triggered_buffer.h>
24 #include <linux/iio/trigger_consumer.h>
25 
26 #define TMP006_VOBJECT 0x00
27 #define TMP006_TAMBIENT 0x01
28 #define TMP006_CONFIG 0x02
29 #define TMP006_MANUFACTURER_ID 0xfe
30 #define TMP006_DEVICE_ID 0xff
31 
32 #define TMP006_TAMBIENT_SHIFT 2
33 
34 #define TMP006_CONFIG_RESET BIT(15)
35 #define TMP006_CONFIG_DRDY_EN BIT(8)
36 #define TMP006_CONFIG_DRDY BIT(7)
37 
38 #define TMP006_CONFIG_MOD_MASK GENMASK(14, 12)
39 
40 #define TMP006_CONFIG_CR_MASK GENMASK(11, 9)
41 #define TMP006_CONFIG_CR_SHIFT 9
42 
43 #define TMP006_MANUFACTURER_MAGIC 0x5449
44 #define TMP006_DEVICE_MAGIC 0x0067
45 
46 struct tmp006_data {
47 	struct i2c_client *client;
48 	u16 config;
49 	struct iio_trigger *drdy_trig;
50 };
51 
52 static int tmp006_read_measurement(struct tmp006_data *data, u8 reg)
53 {
54 	s32 ret;
55 	int tries = 50;
56 
57 	while (tries-- > 0) {
58 		ret = i2c_smbus_read_word_swapped(data->client,
59 			TMP006_CONFIG);
60 		if (ret < 0)
61 			return ret;
62 		if (ret & TMP006_CONFIG_DRDY)
63 			break;
64 		msleep(100);
65 	}
66 
67 	if (tries < 0)
68 		return -EIO;
69 
70 	return i2c_smbus_read_word_swapped(data->client, reg);
71 }
72 
73 static const int tmp006_freqs[5][2] = { {4, 0}, {2, 0}, {1, 0},
74 					{0, 500000}, {0, 250000} };
75 
76 static int tmp006_read_raw(struct iio_dev *indio_dev,
77 			    struct iio_chan_spec const *channel, int *val,
78 			    int *val2, long mask)
79 {
80 	struct tmp006_data *data = iio_priv(indio_dev);
81 	s32 ret;
82 	int cr;
83 
84 	switch (mask) {
85 	case IIO_CHAN_INFO_RAW:
86 		if (channel->type == IIO_VOLTAGE) {
87 			/* LSB is 156.25 nV */
88 			if (!iio_device_claim_direct(indio_dev))
89 				return -EBUSY;
90 
91 			ret = tmp006_read_measurement(data, TMP006_VOBJECT);
92 			iio_device_release_direct(indio_dev);
93 			if (ret < 0)
94 				return ret;
95 
96 			*val = sign_extend32(ret, 15);
97 		} else if (channel->type == IIO_TEMP) {
98 			/* LSB is 0.03125 degrees Celsius */
99 			if (!iio_device_claim_direct(indio_dev))
100 				return -EBUSY;
101 
102 			ret = tmp006_read_measurement(data, TMP006_TAMBIENT);
103 			iio_device_release_direct(indio_dev);
104 			if (ret < 0)
105 				return ret;
106 
107 			*val = sign_extend32(ret, 15) >> TMP006_TAMBIENT_SHIFT;
108 		} else {
109 			break;
110 		}
111 		return IIO_VAL_INT;
112 	case IIO_CHAN_INFO_SCALE:
113 		if (channel->type == IIO_VOLTAGE) {
114 			*val = 0;
115 			*val2 = 156250;
116 		} else if (channel->type == IIO_TEMP) {
117 			*val = 31;
118 			*val2 = 250000;
119 		} else {
120 			break;
121 		}
122 		return IIO_VAL_INT_PLUS_MICRO;
123 	case IIO_CHAN_INFO_SAMP_FREQ:
124 		cr = (data->config & TMP006_CONFIG_CR_MASK)
125 			>> TMP006_CONFIG_CR_SHIFT;
126 		*val = tmp006_freqs[cr][0];
127 		*val2 = tmp006_freqs[cr][1];
128 		return IIO_VAL_INT_PLUS_MICRO;
129 	default:
130 		break;
131 	}
132 
133 	return -EINVAL;
134 }
135 
136 static int tmp006_write_raw(struct iio_dev *indio_dev,
137 			    struct iio_chan_spec const *chan,
138 			    int val,
139 			    int val2,
140 			    long mask)
141 {
142 	struct tmp006_data *data = iio_priv(indio_dev);
143 	int ret, i;
144 
145 	if (mask != IIO_CHAN_INFO_SAMP_FREQ)
146 		return -EINVAL;
147 
148 	for (i = 0; i < ARRAY_SIZE(tmp006_freqs); i++)
149 		if ((val == tmp006_freqs[i][0]) &&
150 		    (val2 == tmp006_freqs[i][1])) {
151 			if (!iio_device_claim_direct(indio_dev))
152 				return -EBUSY;
153 
154 			data->config &= ~TMP006_CONFIG_CR_MASK;
155 			data->config |= i << TMP006_CONFIG_CR_SHIFT;
156 
157 			ret = i2c_smbus_write_word_swapped(data->client,
158 							   TMP006_CONFIG,
159 							   data->config);
160 
161 			iio_device_release_direct(indio_dev);
162 			return ret;
163 		}
164 	return -EINVAL;
165 }
166 
167 static IIO_CONST_ATTR(sampling_frequency_available, "4 2 1 0.5 0.25");
168 
169 static struct attribute *tmp006_attributes[] = {
170 	&iio_const_attr_sampling_frequency_available.dev_attr.attr,
171 	NULL
172 };
173 
174 static const struct attribute_group tmp006_attribute_group = {
175 	.attrs = tmp006_attributes,
176 };
177 
178 static const struct iio_chan_spec tmp006_channels[] = {
179 	{
180 		.type = IIO_VOLTAGE,
181 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
182 			BIT(IIO_CHAN_INFO_SCALE),
183 		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
184 		.scan_index = 0,
185 		.scan_type = {
186 			.sign = 's',
187 			.realbits = 16,
188 			.storagebits = 16,
189 			.endianness = IIO_BE,
190 		}
191 	},
192 	{
193 		.type = IIO_TEMP,
194 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
195 			BIT(IIO_CHAN_INFO_SCALE),
196 		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
197 		.scan_index = 1,
198 		.scan_type = {
199 			.sign = 's',
200 			.realbits = 14,
201 			.storagebits = 16,
202 			.shift = TMP006_TAMBIENT_SHIFT,
203 			.endianness = IIO_BE,
204 		}
205 	},
206 	IIO_CHAN_SOFT_TIMESTAMP(2),
207 };
208 
209 static const struct iio_info tmp006_info = {
210 	.read_raw = tmp006_read_raw,
211 	.write_raw = tmp006_write_raw,
212 	.attrs = &tmp006_attribute_group,
213 };
214 
215 static bool tmp006_check_identification(struct i2c_client *client)
216 {
217 	int mid, did;
218 
219 	mid = i2c_smbus_read_word_swapped(client, TMP006_MANUFACTURER_ID);
220 	if (mid < 0)
221 		return false;
222 
223 	did = i2c_smbus_read_word_swapped(client, TMP006_DEVICE_ID);
224 	if (did < 0)
225 		return false;
226 
227 	return mid == TMP006_MANUFACTURER_MAGIC && did == TMP006_DEVICE_MAGIC;
228 }
229 
230 static int tmp006_power(struct device *dev, bool up)
231 {
232 	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
233 	struct tmp006_data *data = iio_priv(indio_dev);
234 
235 	if (up)
236 		data->config |= TMP006_CONFIG_MOD_MASK;
237 	else
238 		data->config &= ~TMP006_CONFIG_MOD_MASK;
239 
240 	return i2c_smbus_write_word_swapped(data->client, TMP006_CONFIG,
241 		data->config);
242 }
243 
244 static void tmp006_powerdown_cleanup(void *dev)
245 {
246 	tmp006_power(dev, false);
247 }
248 
249 static irqreturn_t tmp006_trigger_handler(int irq, void *p)
250 {
251 	struct iio_poll_func *pf = p;
252 	struct iio_dev *indio_dev = pf->indio_dev;
253 	struct tmp006_data *data = iio_priv(indio_dev);
254 	struct {
255 		s16 channels[2];
256 		aligned_s64 ts;
257 	} scan;
258 	s32 ret;
259 
260 	memset(&scan, 0, sizeof(scan));
261 
262 	ret = i2c_smbus_read_word_data(data->client, TMP006_VOBJECT);
263 	if (ret < 0)
264 		goto err;
265 	scan.channels[0] = ret;
266 
267 	ret = i2c_smbus_read_word_data(data->client, TMP006_TAMBIENT);
268 	if (ret < 0)
269 		goto err;
270 	scan.channels[1] = ret;
271 
272 	iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan),
273 				    iio_get_time_ns(indio_dev));
274 err:
275 	iio_trigger_notify_done(indio_dev->trig);
276 	return IRQ_HANDLED;
277 }
278 
279 static int tmp006_set_trigger_state(struct iio_trigger *trig, bool state)
280 {
281 	struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
282 	struct tmp006_data *data = iio_priv(indio_dev);
283 
284 	if (state)
285 		data->config |= TMP006_CONFIG_DRDY_EN;
286 	else
287 		data->config &= ~TMP006_CONFIG_DRDY_EN;
288 
289 	return i2c_smbus_write_word_swapped(data->client, TMP006_CONFIG,
290 					    data->config);
291 }
292 
293 static const struct iio_trigger_ops tmp006_trigger_ops = {
294 	.set_trigger_state = tmp006_set_trigger_state,
295 };
296 
297 static const unsigned long tmp006_scan_masks[] = { 0x3, 0 };
298 
299 static int tmp006_probe(struct i2c_client *client)
300 {
301 	struct iio_dev *indio_dev;
302 	struct tmp006_data *data;
303 	int ret;
304 
305 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA))
306 		return -EOPNOTSUPP;
307 
308 	if (!tmp006_check_identification(client)) {
309 		dev_err(&client->dev, "no TMP006 sensor\n");
310 		return -ENODEV;
311 	}
312 
313 	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
314 	if (!indio_dev)
315 		return -ENOMEM;
316 
317 	data = iio_priv(indio_dev);
318 	i2c_set_clientdata(client, indio_dev);
319 	data->client = client;
320 
321 	indio_dev->name = dev_name(&client->dev);
322 	indio_dev->modes = INDIO_DIRECT_MODE;
323 	indio_dev->info = &tmp006_info;
324 
325 	indio_dev->channels = tmp006_channels;
326 	indio_dev->num_channels = ARRAY_SIZE(tmp006_channels);
327 	indio_dev->available_scan_masks = tmp006_scan_masks;
328 
329 	ret = i2c_smbus_read_word_swapped(data->client, TMP006_CONFIG);
330 	if (ret < 0)
331 		return ret;
332 	data->config = ret;
333 
334 	if ((ret & TMP006_CONFIG_MOD_MASK) != TMP006_CONFIG_MOD_MASK) {
335 		ret = tmp006_power(&client->dev, true);
336 		if (ret < 0)
337 			return ret;
338 	}
339 
340 	ret = devm_add_action_or_reset(&client->dev, tmp006_powerdown_cleanup,
341 				       &client->dev);
342 	if (ret < 0)
343 		return ret;
344 
345 	if (client->irq > 0) {
346 		data->drdy_trig = devm_iio_trigger_alloc(&client->dev,
347 							 "%s-dev%d",
348 							 indio_dev->name,
349 							 iio_device_id(indio_dev));
350 		if (!data->drdy_trig)
351 			return -ENOMEM;
352 
353 		data->drdy_trig->ops = &tmp006_trigger_ops;
354 		iio_trigger_set_drvdata(data->drdy_trig, indio_dev);
355 		ret = iio_trigger_register(data->drdy_trig);
356 		if (ret)
357 			return ret;
358 
359 		indio_dev->trig = iio_trigger_get(data->drdy_trig);
360 
361 		ret = devm_request_threaded_irq(&client->dev, client->irq,
362 						iio_trigger_generic_data_rdy_poll,
363 						NULL,
364 						IRQF_ONESHOT,
365 						"tmp006_irq",
366 						data->drdy_trig);
367 		if (ret < 0)
368 			return ret;
369 	}
370 
371 	ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
372 					      tmp006_trigger_handler, NULL);
373 	if (ret < 0)
374 		return ret;
375 
376 	return devm_iio_device_register(&client->dev, indio_dev);
377 }
378 
379 static int tmp006_suspend(struct device *dev)
380 {
381 	return tmp006_power(dev, false);
382 }
383 
384 static int tmp006_resume(struct device *dev)
385 {
386 	return tmp006_power(dev, true);
387 }
388 
389 static DEFINE_SIMPLE_DEV_PM_OPS(tmp006_pm_ops, tmp006_suspend, tmp006_resume);
390 
391 static const struct of_device_id tmp006_of_match[] = {
392 	{ .compatible = "ti,tmp006" },
393 	{ }
394 };
395 MODULE_DEVICE_TABLE(of, tmp006_of_match);
396 
397 static const struct i2c_device_id tmp006_id[] = {
398 	{ "tmp006" },
399 	{ }
400 };
401 MODULE_DEVICE_TABLE(i2c, tmp006_id);
402 
403 static struct i2c_driver tmp006_driver = {
404 	.driver = {
405 		.name	= "tmp006",
406 		.of_match_table = tmp006_of_match,
407 		.pm	= pm_sleep_ptr(&tmp006_pm_ops),
408 	},
409 	.probe = tmp006_probe,
410 	.id_table = tmp006_id,
411 };
412 module_i2c_driver(tmp006_driver);
413 
414 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
415 MODULE_DESCRIPTION("TI TMP006 IR thermopile sensor driver");
416 MODULE_LICENSE("GPL");
417