1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * sgp40.c - Support for Sensirion SGP40 Gas Sensor 4 * 5 * Copyright (C) 2021 Andreas Klinger <ak@it-klinger.de> 6 * 7 * I2C slave address: 0x59 8 * 9 * Datasheet can be found here: 10 * https://www.sensirion.com/file/datasheet_sgp40 11 * 12 * There are two functionalities supported: 13 * 14 * 1) read raw logarithmic resistance value from sensor 15 * --> useful to pass it to the algorithm of the sensor vendor for 16 * measuring deteriorations and improvements of air quality. 17 * It can be read from the attribute in_resistance_raw. 18 * 19 * 2) calculate an estimated absolute voc index (in_concentration_input) 20 * with 0 - 500 index points) for measuring the air quality. 21 * For this purpose the value of the resistance for which the voc index 22 * will be 250 can be set up using in_resistance_calibbias (default 30000). 23 * 24 * The voc index is calculated as: 25 * x = (in_resistance_raw - in_resistance_calibbias) * 0.65 26 * in_concentration_input = 500 / (1 + e^x) 27 * 28 * Compensation values of relative humidity and temperature can be set up 29 * by writing to the out values of temp and humidityrelative. 30 */ 31 32 #include <linux/delay.h> 33 #include <linux/crc8.h> 34 #include <linux/module.h> 35 #include <linux/mutex.h> 36 #include <linux/i2c.h> 37 #include <linux/iio/iio.h> 38 39 /* 40 * floating point calculation of voc is done as integer 41 * where numbers are multiplied by 1 << SGP40_CALC_POWER 42 */ 43 #define SGP40_CALC_POWER 14 44 45 #define SGP40_CRC8_POLYNOMIAL 0x31 46 #define SGP40_CRC8_INIT 0xff 47 48 DECLARE_CRC8_TABLE(sgp40_crc8_table); 49 50 struct sgp40_data { 51 struct device *dev; 52 struct i2c_client *client; 53 int rht; 54 int temp; 55 int res_calibbias; 56 /* Prevent concurrent access to rht, tmp, calibbias */ 57 struct mutex lock; 58 }; 59 60 struct sgp40_tg_measure { 61 u8 command[2]; 62 __be16 rht_ticks; 63 u8 rht_crc; 64 __be16 temp_ticks; 65 u8 temp_crc; 66 } __packed; 67 68 struct sgp40_tg_result { 69 __be16 res_ticks; 70 u8 res_crc; 71 } __packed; 72 73 static const struct iio_chan_spec sgp40_channels[] = { 74 { 75 .type = IIO_CONCENTRATION, 76 .channel2 = IIO_MOD_VOC, 77 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), 78 }, 79 { 80 .type = IIO_RESISTANCE, 81 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 82 BIT(IIO_CHAN_INFO_CALIBBIAS), 83 }, 84 { 85 .type = IIO_TEMP, 86 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 87 .output = 1, 88 }, 89 { 90 .type = IIO_HUMIDITYRELATIVE, 91 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 92 .output = 1, 93 }, 94 }; 95 96 /* 97 * taylor approximation of e^x: 98 * y = 1 + x + x^2 / 2 + x^3 / 6 + x^4 / 24 + ... + x^n / n! 99 * 100 * Because we are calculating x real value multiplied by 2^power we get 101 * an additional 2^power^n to divide for every element. For a reasonable 102 * precision this would overflow after a few iterations. Therefore we 103 * divide the x^n part whenever its about to overflow (xmax). 104 */ 105 106 static u32 sgp40_exp(int exp, u32 power, u32 rounds) 107 { 108 u32 x, y, xp; 109 u32 factorial, divider, xmax; 110 int sign = 1; 111 int i; 112 113 if (exp == 0) 114 return 1 << power; 115 else if (exp < 0) { 116 sign = -1; 117 exp *= -1; 118 } 119 120 xmax = 0x7FFFFFFF / exp; 121 x = exp; 122 xp = 1; 123 factorial = 1; 124 y = 1 << power; 125 divider = 0; 126 127 for (i = 1; i <= rounds; i++) { 128 xp *= x; 129 factorial *= i; 130 y += (xp >> divider) / factorial; 131 divider += power; 132 /* divide when next multiplication would overflow */ 133 if (xp >= xmax) { 134 xp >>= power; 135 divider -= power; 136 } 137 } 138 139 if (sign == -1) 140 return (1 << (power * 2)) / y; 141 else 142 return y; 143 } 144 145 static int sgp40_calc_voc(struct sgp40_data *data, u16 resistance_raw, int *voc) 146 { 147 int x; 148 u32 exp = 0; 149 150 /* we calculate as a multiple of 16384 (2^14) */ 151 mutex_lock(&data->lock); 152 x = ((int)resistance_raw - data->res_calibbias) * 106; 153 mutex_unlock(&data->lock); 154 155 /* voc = 500 / (1 + e^x) */ 156 exp = sgp40_exp(x, SGP40_CALC_POWER, 18); 157 *voc = 500 * ((1 << (SGP40_CALC_POWER * 2)) / ((1<<SGP40_CALC_POWER) + exp)); 158 159 dev_dbg(data->dev, "raw: %d res_calibbias: %d x: %d exp: %d voc: %d\n", 160 resistance_raw, data->res_calibbias, x, exp, *voc); 161 162 return 0; 163 } 164 165 static int sgp40_measure_resistance_raw(struct sgp40_data *data, u16 *resistance_raw) 166 { 167 int ret; 168 struct i2c_client *client = data->client; 169 u32 ticks; 170 u16 ticks16; 171 u8 crc; 172 struct sgp40_tg_measure tg = {.command = {0x26, 0x0F}}; 173 struct sgp40_tg_result tgres; 174 175 mutex_lock(&data->lock); 176 177 ticks = (data->rht / 10) * 65535 / 10000; 178 ticks16 = (u16)clamp(ticks, 0u, 65535u); /* clamp between 0 .. 100 %rH */ 179 tg.rht_ticks = cpu_to_be16(ticks16); 180 tg.rht_crc = crc8(sgp40_crc8_table, (u8 *)&tg.rht_ticks, 2, SGP40_CRC8_INIT); 181 182 ticks = ((data->temp + 45000) / 10 ) * 65535 / 17500; 183 ticks16 = (u16)clamp(ticks, 0u, 65535u); /* clamp between -45 .. +130 °C */ 184 tg.temp_ticks = cpu_to_be16(ticks16); 185 tg.temp_crc = crc8(sgp40_crc8_table, (u8 *)&tg.temp_ticks, 2, SGP40_CRC8_INIT); 186 187 mutex_unlock(&data->lock); 188 189 ret = i2c_master_send(client, (const char *)&tg, sizeof(tg)); 190 if (ret != sizeof(tg)) { 191 dev_warn(data->dev, "i2c_master_send ret: %d sizeof: %zu\n", ret, sizeof(tg)); 192 return -EIO; 193 } 194 msleep(30); 195 196 ret = i2c_master_recv(client, (u8 *)&tgres, sizeof(tgres)); 197 if (ret < 0) 198 return ret; 199 if (ret != sizeof(tgres)) { 200 dev_warn(data->dev, "i2c_master_recv ret: %d sizeof: %zu\n", ret, sizeof(tgres)); 201 return -EIO; 202 } 203 204 crc = crc8(sgp40_crc8_table, (u8 *)&tgres.res_ticks, 2, SGP40_CRC8_INIT); 205 if (crc != tgres.res_crc) { 206 dev_err(data->dev, "CRC error while measure-raw\n"); 207 return -EIO; 208 } 209 210 *resistance_raw = be16_to_cpu(tgres.res_ticks); 211 212 return 0; 213 } 214 215 static int sgp40_read_raw(struct iio_dev *indio_dev, 216 struct iio_chan_spec const *chan, int *val, 217 int *val2, long mask) 218 { 219 struct sgp40_data *data = iio_priv(indio_dev); 220 int ret, voc; 221 u16 resistance_raw; 222 223 switch (mask) { 224 case IIO_CHAN_INFO_RAW: 225 switch (chan->type) { 226 case IIO_RESISTANCE: 227 ret = sgp40_measure_resistance_raw(data, &resistance_raw); 228 if (ret) 229 return ret; 230 231 *val = resistance_raw; 232 return IIO_VAL_INT; 233 case IIO_TEMP: 234 mutex_lock(&data->lock); 235 *val = data->temp; 236 mutex_unlock(&data->lock); 237 return IIO_VAL_INT; 238 case IIO_HUMIDITYRELATIVE: 239 mutex_lock(&data->lock); 240 *val = data->rht; 241 mutex_unlock(&data->lock); 242 return IIO_VAL_INT; 243 default: 244 return -EINVAL; 245 } 246 case IIO_CHAN_INFO_PROCESSED: 247 ret = sgp40_measure_resistance_raw(data, &resistance_raw); 248 if (ret) 249 return ret; 250 251 ret = sgp40_calc_voc(data, resistance_raw, &voc); 252 if (ret) 253 return ret; 254 255 *val = voc / (1 << SGP40_CALC_POWER); 256 /* 257 * calculation should fit into integer, where: 258 * voc <= (500 * 2^SGP40_CALC_POWER) = 8192000 259 * (with SGP40_CALC_POWER = 14) 260 */ 261 *val2 = ((voc % (1 << SGP40_CALC_POWER)) * 244) / (1 << (SGP40_CALC_POWER - 12)); 262 dev_dbg(data->dev, "voc: %d val: %d.%06d\n", voc, *val, *val2); 263 return IIO_VAL_INT_PLUS_MICRO; 264 case IIO_CHAN_INFO_CALIBBIAS: 265 mutex_lock(&data->lock); 266 *val = data->res_calibbias; 267 mutex_unlock(&data->lock); 268 return IIO_VAL_INT; 269 default: 270 return -EINVAL; 271 } 272 } 273 274 static int sgp40_write_raw(struct iio_dev *indio_dev, 275 struct iio_chan_spec const *chan, int val, 276 int val2, long mask) 277 { 278 struct sgp40_data *data = iio_priv(indio_dev); 279 280 switch (mask) { 281 case IIO_CHAN_INFO_RAW: 282 switch (chan->type) { 283 case IIO_TEMP: 284 if ((val < -45000) || (val > 130000)) 285 return -EINVAL; 286 287 mutex_lock(&data->lock); 288 data->temp = val; 289 mutex_unlock(&data->lock); 290 return 0; 291 case IIO_HUMIDITYRELATIVE: 292 if ((val < 0) || (val > 100000)) 293 return -EINVAL; 294 295 mutex_lock(&data->lock); 296 data->rht = val; 297 mutex_unlock(&data->lock); 298 return 0; 299 default: 300 return -EINVAL; 301 } 302 case IIO_CHAN_INFO_CALIBBIAS: 303 if ((val < 20000) || (val > 52768)) 304 return -EINVAL; 305 306 mutex_lock(&data->lock); 307 data->res_calibbias = val; 308 mutex_unlock(&data->lock); 309 return 0; 310 } 311 return -EINVAL; 312 } 313 314 static const struct iio_info sgp40_info = { 315 .read_raw = sgp40_read_raw, 316 .write_raw = sgp40_write_raw, 317 }; 318 319 static int sgp40_probe(struct i2c_client *client) 320 { 321 const struct i2c_device_id *id = i2c_client_get_device_id(client); 322 struct device *dev = &client->dev; 323 struct iio_dev *indio_dev; 324 struct sgp40_data *data; 325 int ret; 326 327 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 328 if (!indio_dev) 329 return -ENOMEM; 330 331 data = iio_priv(indio_dev); 332 data->client = client; 333 data->dev = dev; 334 335 crc8_populate_msb(sgp40_crc8_table, SGP40_CRC8_POLYNOMIAL); 336 337 mutex_init(&data->lock); 338 339 /* set default values */ 340 data->rht = 50000; /* 50 % */ 341 data->temp = 25000; /* 25 °C */ 342 data->res_calibbias = 30000; /* resistance raw value for voc index of 250 */ 343 344 indio_dev->info = &sgp40_info; 345 indio_dev->name = id->name; 346 indio_dev->modes = INDIO_DIRECT_MODE; 347 indio_dev->channels = sgp40_channels; 348 indio_dev->num_channels = ARRAY_SIZE(sgp40_channels); 349 350 ret = devm_iio_device_register(dev, indio_dev); 351 if (ret) 352 dev_err(dev, "failed to register iio device\n"); 353 354 return ret; 355 } 356 357 static const struct i2c_device_id sgp40_id[] = { 358 { "sgp40" }, 359 { } 360 }; 361 362 MODULE_DEVICE_TABLE(i2c, sgp40_id); 363 364 static const struct of_device_id sgp40_dt_ids[] = { 365 { .compatible = "sensirion,sgp40" }, 366 { } 367 }; 368 369 MODULE_DEVICE_TABLE(of, sgp40_dt_ids); 370 371 static struct i2c_driver sgp40_driver = { 372 .driver = { 373 .name = "sgp40", 374 .of_match_table = sgp40_dt_ids, 375 }, 376 .probe = sgp40_probe, 377 .id_table = sgp40_id, 378 }; 379 module_i2c_driver(sgp40_driver); 380 381 MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>"); 382 MODULE_DESCRIPTION("Sensirion SGP40 gas sensor"); 383 MODULE_LICENSE("GPL v2"); 384