1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * tmp007.c - Support for TI TMP007 IR thermopile sensor with integrated math engine
4 *
5 * Copyright (c) 2017 Manivannan Sadhasivam <manivannanece23@gmail.com>
6 *
7 * Driver for the Texas Instruments I2C 16-bit IR thermopile sensor
8 *
9 * (7-bit I2C slave address (0x40 - 0x47), changeable via ADR pins)
10 *
11 * Note:
12 * 1. This driver assumes that the sensor has been calibrated beforehand
13 * 2. Limit threshold events are enabled at the start
14 * 3. Operating mode: INT
15 */
16
17 #include <linux/err.h>
18 #include <linux/i2c.h>
19 #include <linux/delay.h>
20 #include <linux/module.h>
21 #include <linux/pm.h>
22 #include <linux/bitops.h>
23 #include <linux/irq.h>
24 #include <linux/interrupt.h>
25
26 #include <linux/iio/iio.h>
27 #include <linux/iio/sysfs.h>
28 #include <linux/iio/events.h>
29
30 #define TMP007_TDIE 0x01
31 #define TMP007_CONFIG 0x02
32 #define TMP007_TOBJECT 0x03
33 #define TMP007_STATUS 0x04
34 #define TMP007_STATUS_MASK 0x05
35 #define TMP007_TOBJ_HIGH_LIMIT 0x06
36 #define TMP007_TOBJ_LOW_LIMIT 0x07
37 #define TMP007_TDIE_HIGH_LIMIT 0x08
38 #define TMP007_TDIE_LOW_LIMIT 0x09
39 #define TMP007_MANUFACTURER_ID 0x1e
40 #define TMP007_DEVICE_ID 0x1f
41
42 #define TMP007_CONFIG_CONV_EN BIT(12)
43 #define TMP007_CONFIG_TC_EN BIT(6)
44 #define TMP007_CONFIG_CR_MASK GENMASK(11, 9)
45 #define TMP007_CONFIG_ALERT_EN BIT(8)
46 #define TMP007_CONFIG_CR_SHIFT 9
47
48 /* Status register flags */
49 #define TMP007_STATUS_ALERT BIT(15)
50 #define TMP007_STATUS_CONV_READY BIT(14)
51 #define TMP007_STATUS_OHF BIT(13)
52 #define TMP007_STATUS_OLF BIT(12)
53 #define TMP007_STATUS_LHF BIT(11)
54 #define TMP007_STATUS_LLF BIT(10)
55 #define TMP007_STATUS_DATA_VALID BIT(9)
56
57 #define TMP007_MANUFACTURER_MAGIC 0x5449
58 #define TMP007_DEVICE_MAGIC 0x0078
59
60 #define TMP007_TEMP_SHIFT 2
61
62 struct tmp007_data {
63 struct i2c_client *client;
64 struct mutex lock;
65 u16 config;
66 u16 status_mask;
67 };
68
69 static const int tmp007_avgs[5][2] = { {4, 0}, {2, 0}, {1, 0},
70 {0, 500000}, {0, 250000} };
71
tmp007_read_temperature(struct tmp007_data * data,u8 reg)72 static int tmp007_read_temperature(struct tmp007_data *data, u8 reg)
73 {
74 s32 ret;
75 int tries = 50;
76
77 while (tries-- > 0) {
78 ret = i2c_smbus_read_word_swapped(data->client,
79 TMP007_STATUS);
80 if (ret < 0)
81 return ret;
82 if ((ret & TMP007_STATUS_CONV_READY) &&
83 !(ret & TMP007_STATUS_DATA_VALID))
84 break;
85 msleep(100);
86 }
87
88 if (tries < 0)
89 return -EIO;
90
91 return i2c_smbus_read_word_swapped(data->client, reg);
92 }
93
tmp007_powerdown(struct tmp007_data * data)94 static int tmp007_powerdown(struct tmp007_data *data)
95 {
96 return i2c_smbus_write_word_swapped(data->client, TMP007_CONFIG,
97 data->config & ~TMP007_CONFIG_CONV_EN);
98 }
99
tmp007_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * channel,int * val,int * val2,long mask)100 static int tmp007_read_raw(struct iio_dev *indio_dev,
101 struct iio_chan_spec const *channel, int *val,
102 int *val2, long mask)
103 {
104 struct tmp007_data *data = iio_priv(indio_dev);
105 s32 ret;
106 int conv_rate;
107
108 switch (mask) {
109 case IIO_CHAN_INFO_RAW:
110 switch (channel->channel2) {
111 case IIO_MOD_TEMP_AMBIENT: /* LSB: 0.03125 degree Celsius */
112 ret = i2c_smbus_read_word_swapped(data->client, TMP007_TDIE);
113 if (ret < 0)
114 return ret;
115 break;
116 case IIO_MOD_TEMP_OBJECT:
117 ret = tmp007_read_temperature(data, TMP007_TOBJECT);
118 if (ret < 0)
119 return ret;
120 break;
121 default:
122 return -EINVAL;
123 }
124
125 *val = sign_extend32(ret, 15) >> TMP007_TEMP_SHIFT;
126
127 return IIO_VAL_INT;
128 case IIO_CHAN_INFO_SCALE:
129 *val = 31;
130 *val2 = 250000;
131
132 return IIO_VAL_INT_PLUS_MICRO;
133 case IIO_CHAN_INFO_SAMP_FREQ:
134 conv_rate = (data->config & TMP007_CONFIG_CR_MASK)
135 >> TMP007_CONFIG_CR_SHIFT;
136 *val = tmp007_avgs[conv_rate][0];
137 *val2 = tmp007_avgs[conv_rate][1];
138
139 return IIO_VAL_INT_PLUS_MICRO;
140 default:
141 return -EINVAL;
142 }
143 }
144
tmp007_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * channel,int val,int val2,long mask)145 static int tmp007_write_raw(struct iio_dev *indio_dev,
146 struct iio_chan_spec const *channel, int val,
147 int val2, long mask)
148 {
149 struct tmp007_data *data = iio_priv(indio_dev);
150 int i;
151 u16 tmp;
152
153 if (mask == IIO_CHAN_INFO_SAMP_FREQ) {
154 for (i = 0; i < ARRAY_SIZE(tmp007_avgs); i++) {
155 if ((val == tmp007_avgs[i][0]) &&
156 (val2 == tmp007_avgs[i][1])) {
157 tmp = data->config & ~TMP007_CONFIG_CR_MASK;
158 tmp |= (i << TMP007_CONFIG_CR_SHIFT);
159
160 return i2c_smbus_write_word_swapped(data->client,
161 TMP007_CONFIG,
162 data->config = tmp);
163 }
164 }
165 }
166
167 return -EINVAL;
168 }
169
tmp007_interrupt_handler(int irq,void * private)170 static irqreturn_t tmp007_interrupt_handler(int irq, void *private)
171 {
172 struct iio_dev *indio_dev = private;
173 struct tmp007_data *data = iio_priv(indio_dev);
174 int ret;
175
176 ret = i2c_smbus_read_word_swapped(data->client, TMP007_STATUS);
177 if ((ret < 0) || !(ret & (TMP007_STATUS_OHF | TMP007_STATUS_OLF |
178 TMP007_STATUS_LHF | TMP007_STATUS_LLF)))
179 return IRQ_NONE;
180
181 if (ret & TMP007_STATUS_OHF)
182 iio_push_event(indio_dev,
183 IIO_MOD_EVENT_CODE(IIO_TEMP, 0,
184 IIO_MOD_TEMP_OBJECT,
185 IIO_EV_TYPE_THRESH,
186 IIO_EV_DIR_RISING),
187 iio_get_time_ns(indio_dev));
188
189 if (ret & TMP007_STATUS_OLF)
190 iio_push_event(indio_dev,
191 IIO_MOD_EVENT_CODE(IIO_TEMP, 0,
192 IIO_MOD_TEMP_OBJECT,
193 IIO_EV_TYPE_THRESH,
194 IIO_EV_DIR_FALLING),
195 iio_get_time_ns(indio_dev));
196
197 if (ret & TMP007_STATUS_LHF)
198 iio_push_event(indio_dev,
199 IIO_MOD_EVENT_CODE(IIO_TEMP, 0,
200 IIO_MOD_TEMP_AMBIENT,
201 IIO_EV_TYPE_THRESH,
202 IIO_EV_DIR_RISING),
203 iio_get_time_ns(indio_dev));
204
205 if (ret & TMP007_STATUS_LLF)
206 iio_push_event(indio_dev,
207 IIO_MOD_EVENT_CODE(IIO_TEMP, 0,
208 IIO_MOD_TEMP_AMBIENT,
209 IIO_EV_TYPE_THRESH,
210 IIO_EV_DIR_FALLING),
211 iio_get_time_ns(indio_dev));
212
213 return IRQ_HANDLED;
214 }
215
tmp007_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,bool state)216 static int tmp007_write_event_config(struct iio_dev *indio_dev,
217 const struct iio_chan_spec *chan, enum iio_event_type type,
218 enum iio_event_direction dir, bool state)
219 {
220 struct tmp007_data *data = iio_priv(indio_dev);
221 unsigned int status_mask;
222 int ret;
223
224 switch (chan->channel2) {
225 case IIO_MOD_TEMP_AMBIENT:
226 if (dir == IIO_EV_DIR_RISING)
227 status_mask = TMP007_STATUS_LHF;
228 else
229 status_mask = TMP007_STATUS_LLF;
230 break;
231 case IIO_MOD_TEMP_OBJECT:
232 if (dir == IIO_EV_DIR_RISING)
233 status_mask = TMP007_STATUS_OHF;
234 else
235 status_mask = TMP007_STATUS_OLF;
236 break;
237 default:
238 return -EINVAL;
239 }
240
241 mutex_lock(&data->lock);
242 ret = i2c_smbus_read_word_swapped(data->client, TMP007_STATUS_MASK);
243 mutex_unlock(&data->lock);
244 if (ret < 0)
245 return ret;
246
247 if (state)
248 ret |= status_mask;
249 else
250 ret &= ~status_mask;
251
252 return i2c_smbus_write_word_swapped(data->client, TMP007_STATUS_MASK,
253 data->status_mask = ret);
254 }
255
tmp007_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)256 static int tmp007_read_event_config(struct iio_dev *indio_dev,
257 const struct iio_chan_spec *chan, enum iio_event_type type,
258 enum iio_event_direction dir)
259 {
260 struct tmp007_data *data = iio_priv(indio_dev);
261 unsigned int mask;
262
263 switch (chan->channel2) {
264 case IIO_MOD_TEMP_AMBIENT:
265 if (dir == IIO_EV_DIR_RISING)
266 mask = TMP007_STATUS_LHF;
267 else
268 mask = TMP007_STATUS_LLF;
269 break;
270 case IIO_MOD_TEMP_OBJECT:
271 if (dir == IIO_EV_DIR_RISING)
272 mask = TMP007_STATUS_OHF;
273 else
274 mask = TMP007_STATUS_OLF;
275 break;
276 default:
277 return -EINVAL;
278 }
279
280 return !!(data->status_mask & mask);
281 }
282
tmp007_read_thresh(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)283 static int tmp007_read_thresh(struct iio_dev *indio_dev,
284 const struct iio_chan_spec *chan, enum iio_event_type type,
285 enum iio_event_direction dir, enum iio_event_info info,
286 int *val, int *val2)
287 {
288 struct tmp007_data *data = iio_priv(indio_dev);
289 int ret;
290 u8 reg;
291
292 switch (chan->channel2) {
293 case IIO_MOD_TEMP_AMBIENT: /* LSB: 0.5 degree Celsius */
294 if (dir == IIO_EV_DIR_RISING)
295 reg = TMP007_TDIE_HIGH_LIMIT;
296 else
297 reg = TMP007_TDIE_LOW_LIMIT;
298 break;
299 case IIO_MOD_TEMP_OBJECT:
300 if (dir == IIO_EV_DIR_RISING)
301 reg = TMP007_TOBJ_HIGH_LIMIT;
302 else
303 reg = TMP007_TOBJ_LOW_LIMIT;
304 break;
305 default:
306 return -EINVAL;
307 }
308
309 ret = i2c_smbus_read_word_swapped(data->client, reg);
310 if (ret < 0)
311 return ret;
312
313 /* Shift length 7 bits = 6(15:6) + 1(0.5 LSB) */
314 *val = sign_extend32(ret, 15) >> 7;
315
316 return IIO_VAL_INT;
317 }
318
tmp007_write_thresh(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)319 static int tmp007_write_thresh(struct iio_dev *indio_dev,
320 const struct iio_chan_spec *chan, enum iio_event_type type,
321 enum iio_event_direction dir, enum iio_event_info info,
322 int val, int val2)
323 {
324 struct tmp007_data *data = iio_priv(indio_dev);
325 u8 reg;
326
327 switch (chan->channel2) {
328 case IIO_MOD_TEMP_AMBIENT:
329 if (dir == IIO_EV_DIR_RISING)
330 reg = TMP007_TDIE_HIGH_LIMIT;
331 else
332 reg = TMP007_TDIE_LOW_LIMIT;
333 break;
334 case IIO_MOD_TEMP_OBJECT:
335 if (dir == IIO_EV_DIR_RISING)
336 reg = TMP007_TOBJ_HIGH_LIMIT;
337 else
338 reg = TMP007_TOBJ_LOW_LIMIT;
339 break;
340 default:
341 return -EINVAL;
342 }
343
344 /* Full scale threshold value is +/- 256 degree Celsius */
345 if (val < -256 || val > 255)
346 return -EINVAL;
347
348 /* Shift length 7 bits = 6(15:6) + 1(0.5 LSB) */
349 return i2c_smbus_write_word_swapped(data->client, reg, (val << 7));
350 }
351
352 static IIO_CONST_ATTR(sampling_frequency_available, "4 2 1 0.5 0.25");
353
354 static struct attribute *tmp007_attributes[] = {
355 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
356 NULL
357 };
358
359 static const struct attribute_group tmp007_attribute_group = {
360 .attrs = tmp007_attributes,
361 };
362
363 static const struct iio_event_spec tmp007_obj_event[] = {
364 {
365 .type = IIO_EV_TYPE_THRESH,
366 .dir = IIO_EV_DIR_RISING,
367 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
368 BIT(IIO_EV_INFO_ENABLE),
369 },
370 {
371 .type = IIO_EV_TYPE_THRESH,
372 .dir = IIO_EV_DIR_FALLING,
373 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
374 BIT(IIO_EV_INFO_ENABLE),
375 },
376 };
377
378 static const struct iio_event_spec tmp007_die_event[] = {
379 {
380 .type = IIO_EV_TYPE_THRESH,
381 .dir = IIO_EV_DIR_RISING,
382 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
383 BIT(IIO_EV_INFO_ENABLE),
384 },
385 {
386 .type = IIO_EV_TYPE_THRESH,
387 .dir = IIO_EV_DIR_FALLING,
388 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
389 BIT(IIO_EV_INFO_ENABLE),
390 },
391 };
392
393 static const struct iio_chan_spec tmp007_channels[] = {
394 {
395 .type = IIO_TEMP,
396 .modified = 1,
397 .channel2 = IIO_MOD_TEMP_AMBIENT,
398 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
399 BIT(IIO_CHAN_INFO_SCALE),
400 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
401 .event_spec = tmp007_die_event,
402 .num_event_specs = ARRAY_SIZE(tmp007_die_event),
403 },
404 {
405 .type = IIO_TEMP,
406 .modified = 1,
407 .channel2 = IIO_MOD_TEMP_OBJECT,
408 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
409 BIT(IIO_CHAN_INFO_SCALE),
410 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
411 .event_spec = tmp007_obj_event,
412 .num_event_specs = ARRAY_SIZE(tmp007_obj_event),
413 }
414 };
415
416 static const struct iio_info tmp007_info = {
417 .read_raw = tmp007_read_raw,
418 .write_raw = tmp007_write_raw,
419 .read_event_config = tmp007_read_event_config,
420 .write_event_config = tmp007_write_event_config,
421 .read_event_value = tmp007_read_thresh,
422 .write_event_value = tmp007_write_thresh,
423 .attrs = &tmp007_attribute_group,
424 };
425
tmp007_identify(struct i2c_client * client)426 static bool tmp007_identify(struct i2c_client *client)
427 {
428 int manf_id, dev_id;
429
430 manf_id = i2c_smbus_read_word_swapped(client, TMP007_MANUFACTURER_ID);
431 if (manf_id < 0)
432 return false;
433
434 dev_id = i2c_smbus_read_word_swapped(client, TMP007_DEVICE_ID);
435 if (dev_id < 0)
436 return false;
437
438 return (manf_id == TMP007_MANUFACTURER_MAGIC && dev_id == TMP007_DEVICE_MAGIC);
439 }
440
tmp007_powerdown_action_cb(void * priv)441 static void tmp007_powerdown_action_cb(void *priv)
442 {
443 struct tmp007_data *data = priv;
444
445 tmp007_powerdown(data);
446 }
447
tmp007_probe(struct i2c_client * client)448 static int tmp007_probe(struct i2c_client *client)
449 {
450 const struct i2c_device_id *tmp007_id = i2c_client_get_device_id(client);
451 struct tmp007_data *data;
452 struct iio_dev *indio_dev;
453 int ret;
454
455 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA))
456 return -EOPNOTSUPP;
457
458 if (!tmp007_identify(client)) {
459 dev_err(&client->dev, "TMP007 not found\n");
460 return -ENODEV;
461 }
462
463 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
464 if (!indio_dev)
465 return -ENOMEM;
466
467 data = iio_priv(indio_dev);
468 i2c_set_clientdata(client, indio_dev);
469 data->client = client;
470 mutex_init(&data->lock);
471
472 indio_dev->name = "tmp007";
473 indio_dev->modes = INDIO_DIRECT_MODE;
474 indio_dev->info = &tmp007_info;
475
476 indio_dev->channels = tmp007_channels;
477 indio_dev->num_channels = ARRAY_SIZE(tmp007_channels);
478
479 /*
480 * Set Configuration register:
481 * 1. Conversion ON
482 * 2. ALERT enable
483 * 3. Transient correction enable
484 */
485
486 ret = i2c_smbus_read_word_swapped(data->client, TMP007_CONFIG);
487 if (ret < 0)
488 return ret;
489
490 data->config = ret;
491 data->config |= (TMP007_CONFIG_CONV_EN | TMP007_CONFIG_ALERT_EN | TMP007_CONFIG_TC_EN);
492
493 ret = i2c_smbus_write_word_swapped(data->client, TMP007_CONFIG,
494 data->config);
495 if (ret < 0)
496 return ret;
497
498 ret = devm_add_action_or_reset(&client->dev, tmp007_powerdown_action_cb, data);
499 if (ret)
500 return ret;
501
502 /*
503 * Only the following flags can activate ALERT pin. Data conversion/validity flags
504 * flags can still be polled for getting temperature data
505 *
506 * Set Status Mask register:
507 * 1. Object temperature high limit enable
508 * 2. Object temperature low limit enable
509 * 3. TDIE temperature high limit enable
510 * 4. TDIE temperature low limit enable
511 */
512
513 ret = i2c_smbus_read_word_swapped(data->client, TMP007_STATUS_MASK);
514 if (ret < 0)
515 return ret;
516
517 data->status_mask = ret;
518 data->status_mask |= (TMP007_STATUS_OHF | TMP007_STATUS_OLF
519 | TMP007_STATUS_LHF | TMP007_STATUS_LLF);
520
521 ret = i2c_smbus_write_word_swapped(data->client, TMP007_STATUS_MASK, data->status_mask);
522 if (ret < 0)
523 return ret;
524
525 if (client->irq) {
526 ret = devm_request_threaded_irq(&client->dev, client->irq,
527 NULL, tmp007_interrupt_handler,
528 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
529 tmp007_id->name, indio_dev);
530 if (ret) {
531 dev_err(&client->dev, "irq request error %d\n", -ret);
532 return ret;
533 }
534 }
535
536 return devm_iio_device_register(&client->dev, indio_dev);
537 }
538
tmp007_suspend(struct device * dev)539 static int tmp007_suspend(struct device *dev)
540 {
541 struct tmp007_data *data = iio_priv(i2c_get_clientdata(
542 to_i2c_client(dev)));
543
544 return tmp007_powerdown(data);
545 }
546
tmp007_resume(struct device * dev)547 static int tmp007_resume(struct device *dev)
548 {
549 struct tmp007_data *data = iio_priv(i2c_get_clientdata(
550 to_i2c_client(dev)));
551
552 return i2c_smbus_write_word_swapped(data->client, TMP007_CONFIG,
553 data->config | TMP007_CONFIG_CONV_EN);
554 }
555
556 static DEFINE_SIMPLE_DEV_PM_OPS(tmp007_pm_ops, tmp007_suspend, tmp007_resume);
557
558 static const struct of_device_id tmp007_of_match[] = {
559 { .compatible = "ti,tmp007", },
560 { }
561 };
562 MODULE_DEVICE_TABLE(of, tmp007_of_match);
563
564 static const struct i2c_device_id tmp007_id[] = {
565 { .name = "tmp007" },
566 { }
567 };
568 MODULE_DEVICE_TABLE(i2c, tmp007_id);
569
570 static struct i2c_driver tmp007_driver = {
571 .driver = {
572 .name = "tmp007",
573 .of_match_table = tmp007_of_match,
574 .pm = pm_sleep_ptr(&tmp007_pm_ops),
575 },
576 .probe = tmp007_probe,
577 .id_table = tmp007_id,
578 };
579 module_i2c_driver(tmp007_driver);
580
581 MODULE_AUTHOR("Manivannan Sadhasivam <manivannanece23@gmail.com>");
582 MODULE_DESCRIPTION("TI TMP007 IR thermopile sensor driver");
583 MODULE_LICENSE("GPL");
584