drivers/iio/temperature/tmp006.c

   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 <[email protected]>
   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  * TODO: data ready irq
  12  */
  13
  14 #include <linux/err.h>
  15 #include <linux/i2c.h>
  16 #include <linux/delay.h>
  17 #include <linux/module.h>
  18 #include <linux/pm.h>
  19 #include <linux/bitops.h>
  20
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/sysfs.h>
  23
  24 #define TMP006_VOBJECT 0x00
  25 #define TMP006_TAMBIENT 0x01
  26 #define TMP006_CONFIG 0x02
  27 #define TMP006_MANUFACTURER_ID 0xfe
  28 #define TMP006_DEVICE_ID 0xff
  29
  30 #define TMP006_TAMBIENT_SHIFT 2
  31
  32 #define TMP006_CONFIG_RESET BIT(15)
  33 #define TMP006_CONFIG_DRDY_EN BIT(8)
  34 #define TMP006_CONFIG_DRDY BIT(7)
  35
  36 #define TMP006_CONFIG_MOD_MASK GENMASK(14, 12)
  37
  38 #define TMP006_CONFIG_CR_MASK GENMASK(11, 9)
  39 #define TMP006_CONFIG_CR_SHIFT 9
  40
  41 #define TMP006_MANUFACTURER_MAGIC 0x5449
  42 #define TMP006_DEVICE_MAGIC 0x0067
  43
  44 struct tmp006_data {
  45         struct i2c_client *client;
  46         u16 config;
  47 };
  48
  49 static int tmp006_read_measurement(struct tmp006_data *data, u8 reg)
  50 {
  51         s32 ret;
  52         int tries = 50;
  53
  54         while (tries-- > 0) {
  55                 ret = i2c_smbus_read_word_swapped(data->client,
  56                         TMP006_CONFIG);
  57                 if (ret < 0)
  58                         return ret;
  59                 if (ret & TMP006_CONFIG_DRDY)
  60                         break;
  61                 msleep(100);
  62         }
  63
  64         if (tries < 0)
  65                 return -EIO;
  66
  67         return i2c_smbus_read_word_swapped(data->client, reg);
  68 }
  69
  70 static const int tmp006_freqs[5][2] = { {4, 0}, {2, 0}, {1, 0},
  71                                         {0, 500000}, {0, 250000} };
  72
  73 static int tmp006_read_raw(struct iio_dev *indio_dev,
  74                             struct iio_chan_spec const *channel, int *val,
  75                             int *val2, long mask)
  76 {
  77         struct tmp006_data *data = iio_priv(indio_dev);
  78         s32 ret;
  79         int cr;
  80
  81         switch (mask) {
  82         case IIO_CHAN_INFO_RAW:
  83                 if (channel->type == IIO_VOLTAGE) {
  84                         /* LSB is 156.25 nV */
  85                         ret = tmp006_read_measurement(data, TMP006_VOBJECT);
  86                         if (ret < 0)
  87                                 return ret;
  88                         *val = sign_extend32(ret, 15);
  89                 } else if (channel->type == IIO_TEMP) {
  90                         /* LSB is 0.03125 degrees Celsius */
  91                         ret = tmp006_read_measurement(data, TMP006_TAMBIENT);
  92                         if (ret < 0)
  93                                 return ret;
  94                         *val = sign_extend32(ret, 15) >> TMP006_TAMBIENT_SHIFT;
  95                 } else {
  96                         break;
  97                 }
  98                 return IIO_VAL_INT;
  99         case IIO_CHAN_INFO_SCALE:
 100                 if (channel->type == IIO_VOLTAGE) {
 101                         *val = 0;
 102                         *val2 = 156250;
 103                 } else if (channel->type == IIO_TEMP) {
 104                         *val = 31;
 105                         *val2 = 250000;
 106                 } else {
 107                         break;
 108                 }
 109                 return IIO_VAL_INT_PLUS_MICRO;
 110         case IIO_CHAN_INFO_SAMP_FREQ:
 111                 cr = (data->config & TMP006_CONFIG_CR_MASK)
 112                         >> TMP006_CONFIG_CR_SHIFT;
 113                 *val = tmp006_freqs[cr][0];
 114                 *val2 = tmp006_freqs[cr][1];
 115                 return IIO_VAL_INT_PLUS_MICRO;
 116         default:
 117                 break;
 118         }
 119
 120         return -EINVAL;
 121 }
 122
 123 static int tmp006_write_raw(struct iio_dev *indio_dev,
 124                             struct iio_chan_spec const *chan,
 125                             int val,
 126                             int val2,
 127                             long mask)
 128 {
 129         struct tmp006_data *data = iio_priv(indio_dev);
 130         int i;
 131
 132         if (mask != IIO_CHAN_INFO_SAMP_FREQ)
 133                 return -EINVAL;
 134
 135         for (i = 0; i < ARRAY_SIZE(tmp006_freqs); i++)
 136                 if ((val == tmp006_freqs[i][0]) &&
 137                     (val2 == tmp006_freqs[i][1])) {
 138                         data->config &= ~TMP006_CONFIG_CR_MASK;
 139                         data->config |= i << TMP006_CONFIG_CR_SHIFT;
 140
 141                         return i2c_smbus_write_word_swapped(data->client,
 142                                                             TMP006_CONFIG,
 143                                                             data->config);
 144
 145                 }
 146         return -EINVAL;
 147 }
 148
 149 static IIO_CONST_ATTR(sampling_frequency_available, "4 2 1 0.5 0.25");
 150
 151 static struct attribute *tmp006_attributes[] = {
 152         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 153         NULL
 154 };
 155
 156 static const struct attribute_group tmp006_attribute_group = {
 157         .attrs = tmp006_attributes,
 158 };
 159
 160 static const struct iio_chan_spec tmp006_channels[] = {
 161         {
 162                 .type = IIO_VOLTAGE,
 163                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 164                         BIT(IIO_CHAN_INFO_SCALE),
 165                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 166         },
 167         {
 168                 .type = IIO_TEMP,
 169                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 170                         BIT(IIO_CHAN_INFO_SCALE),
 171                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 172         }
 173 };
 174
 175 static const struct iio_info tmp006_info = {
 176         .read_raw = tmp006_read_raw,
 177         .write_raw = tmp006_write_raw,
 178         .attrs = &tmp006_attribute_group,
 179 };
 180
 181 static bool tmp006_check_identification(struct i2c_client *client)
 182 {
 183         int mid, did;
 184
 185         mid = i2c_smbus_read_word_swapped(client, TMP006_MANUFACTURER_ID);
 186         if (mid < 0)
 187                 return false;
 188
 189         did = i2c_smbus_read_word_swapped(client, TMP006_DEVICE_ID);
 190         if (did < 0)
 191                 return false;
 192
 193         return mid == TMP006_MANUFACTURER_MAGIC && did == TMP006_DEVICE_MAGIC;
 194 }
 195
 196 static int tmp006_probe(struct i2c_client *client,
 197                          const struct i2c_device_id *id)
 198 {
 199         struct iio_dev *indio_dev;
 200         struct tmp006_data *data;
 201         int ret;
 202
 203         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA))
 204                 return -EOPNOTSUPP;
 205
 206         if (!tmp006_check_identification(client)) {
 207                 dev_err(&client->dev, "no TMP006 sensor\n");
 208                 return -ENODEV;
 209         }
 210
 211         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 212         if (!indio_dev)
 213                 return -ENOMEM;
 214
 215         data = iio_priv(indio_dev);
 216         i2c_set_clientdata(client, indio_dev);
 217         data->client = client;
 218
 219         indio_dev->dev.parent = &client->dev;
 220         indio_dev->name = dev_name(&client->dev);
 221         indio_dev->modes = INDIO_DIRECT_MODE;
 222         indio_dev->info = &tmp006_info;
 223
 224         indio_dev->channels = tmp006_channels;
 225         indio_dev->num_channels = ARRAY_SIZE(tmp006_channels);
 226
 227         ret = i2c_smbus_read_word_swapped(data->client, TMP006_CONFIG);
 228         if (ret < 0)
 229                 return ret;
 230         data->config = ret;
 231
 232         return iio_device_register(indio_dev);
 233 }
 234
 235 static int tmp006_powerdown(struct tmp006_data *data)
 236 {
 237         return i2c_smbus_write_word_swapped(data->client, TMP006_CONFIG,
 238                 data->config & ~TMP006_CONFIG_MOD_MASK);
 239 }
 240
 241 static int tmp006_remove(struct i2c_client *client)
 242 {
 243         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 244
 245         iio_device_unregister(indio_dev);
 246         tmp006_powerdown(iio_priv(indio_dev));
 247
 248         return 0;
 249 }
 250
 251 #ifdef CONFIG_PM_SLEEP
 252 static int tmp006_suspend(struct device *dev)
 253 {
 254         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 255         return tmp006_powerdown(iio_priv(indio_dev));
 256 }
 257
 258 static int tmp006_resume(struct device *dev)
 259 {
 260         struct tmp006_data *data = iio_priv(i2c_get_clientdata(
 261                 to_i2c_client(dev)));
 262         return i2c_smbus_write_word_swapped(data->client, TMP006_CONFIG,
 263                 data->config | TMP006_CONFIG_MOD_MASK);
 264 }
 265 #endif
 266
 267 static SIMPLE_DEV_PM_OPS(tmp006_pm_ops, tmp006_suspend, tmp006_resume);
 268
 269 static const struct i2c_device_id tmp006_id[] = {
 270         { "tmp006", 0 },
 271         { }
 272 };
 273 MODULE_DEVICE_TABLE(i2c, tmp006_id);
 274
 275 static struct i2c_driver tmp006_driver = {
 276         .driver = {
 277                 .name   = "tmp006",
 278                 .pm     = &tmp006_pm_ops,
 279         },
 280         .probe = tmp006_probe,
 281         .remove = tmp006_remove,
 282         .id_table = tmp006_id,
 283 };
 284 module_i2c_driver(tmp006_driver);
 285
 286 MODULE_AUTHOR("Peter Meerwald <[email protected]>");
 287 MODULE_DESCRIPTION("TI TMP006 IR thermopile sensor driver");
 288 MODULE_LICENSE("GPL");