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 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 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 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 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 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 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 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 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 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 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 441 static void tmp007_powerdown_action_cb(void *priv) 442 { 443 struct tmp007_data *data = priv; 444 445 tmp007_powerdown(data); 446 } 447 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 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 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