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