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
tmp006_read_measurement(struct tmp006_data * data,u8 reg)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
tmp006_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * channel,int * val,int * val2,long mask)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
tmp006_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)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
tmp006_check_identification(struct i2c_client * client)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
tmp006_power(struct device * dev,bool up)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
tmp006_powerdown_cleanup(void * dev)244 static void tmp006_powerdown_cleanup(void *dev)
245 {
246 tmp006_power(dev, false);
247 }
248
tmp006_trigger_handler(int irq,void * p)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
tmp006_set_trigger_state(struct iio_trigger * trig,bool state)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
tmp006_probe(struct i2c_client * client)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
tmp006_suspend(struct device * dev)379 static int tmp006_suspend(struct device *dev)
380 {
381 return tmp006_power(dev, false);
382 }
383
tmp006_resume(struct device * dev)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