1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * ScioSense ENS160 multi-gas sensor driver 4 * 5 * Copyright (c) 2024 Gustavo Silva <gustavograzs@gmail.com> 6 * 7 * Datasheet: 8 * https://www.sciosense.com/wp-content/uploads/2023/12/ENS160-Datasheet.pdf 9 */ 10 11 #include <linux/bitfield.h> 12 #include <linux/iio/iio.h> 13 #include <linux/iio/trigger.h> 14 #include <linux/iio/trigger_consumer.h> 15 #include <linux/iio/triggered_buffer.h> 16 #include <linux/module.h> 17 #include <linux/regmap.h> 18 19 #include "ens160.h" 20 21 #define ENS160_PART_ID 0x160 22 23 #define ENS160_BOOTING_TIME_MS 10U 24 25 #define ENS160_REG_PART_ID 0x00 26 27 #define ENS160_REG_OPMODE 0x10 28 29 #define ENS160_REG_CONFIG 0x11 30 #define ENS160_REG_CONFIG_INTEN BIT(0) 31 #define ENS160_REG_CONFIG_INTDAT BIT(1) 32 #define ENS160_REG_CONFIG_INT_CFG BIT(5) 33 34 #define ENS160_REG_MODE_DEEP_SLEEP 0x00 35 #define ENS160_REG_MODE_IDLE 0x01 36 #define ENS160_REG_MODE_STANDARD 0x02 37 #define ENS160_REG_MODE_RESET 0xF0 38 39 #define ENS160_REG_COMMAND 0x12 40 #define ENS160_REG_COMMAND_GET_APPVER 0x0E 41 #define ENS160_REG_COMMAND_CLRGPR 0xCC 42 43 #define ENS160_REG_TEMP_IN 0x13 44 #define ENS160_REG_RH_IN 0x15 45 #define ENS160_REG_DEVICE_STATUS 0x20 46 #define ENS160_REG_DATA_AQI 0x21 47 #define ENS160_REG_DATA_TVOC 0x22 48 #define ENS160_REG_DATA_ECO2 0x24 49 #define ENS160_REG_DATA_T 0x30 50 #define ENS160_REG_DATA_RH 0x32 51 #define ENS160_REG_GPR_READ4 0x4C 52 53 #define ENS160_STATUS_VALIDITY_FLAG GENMASK(3, 2) 54 55 #define ENS160_STATUS_NORMAL 0x00 56 57 struct ens160_data { 58 struct regmap *regmap; 59 /* Protect reads from the sensor */ 60 struct mutex mutex; 61 struct { 62 __le16 chans[2]; 63 aligned_s64 timestamp; 64 } scan __aligned(IIO_DMA_MINALIGN); 65 u8 fw_version[3]; 66 __le16 buf; 67 }; 68 69 static const struct iio_chan_spec ens160_channels[] = { 70 { 71 .type = IIO_CONCENTRATION, 72 .channel2 = IIO_MOD_VOC, 73 .modified = 1, 74 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 75 BIT(IIO_CHAN_INFO_SCALE), 76 .address = ENS160_REG_DATA_TVOC, 77 .scan_index = 0, 78 .scan_type = { 79 .sign = 'u', 80 .realbits = 16, 81 .storagebits = 16, 82 .endianness = IIO_LE, 83 }, 84 }, 85 { 86 .type = IIO_CONCENTRATION, 87 .channel2 = IIO_MOD_CO2, 88 .modified = 1, 89 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 90 BIT(IIO_CHAN_INFO_SCALE), 91 .address = ENS160_REG_DATA_ECO2, 92 .scan_index = 1, 93 .scan_type = { 94 .sign = 'u', 95 .realbits = 16, 96 .storagebits = 16, 97 .endianness = IIO_LE, 98 }, 99 }, 100 IIO_CHAN_SOFT_TIMESTAMP(2), 101 }; 102 103 static int __ens160_read_raw(struct iio_dev *indio_dev, 104 struct iio_chan_spec const *chan, 105 int *val) 106 { 107 struct ens160_data *data = iio_priv(indio_dev); 108 int ret; 109 110 guard(mutex)(&data->mutex); 111 ret = regmap_bulk_read(data->regmap, chan->address, 112 &data->buf, sizeof(data->buf)); 113 if (ret) 114 return ret; 115 *val = le16_to_cpu(data->buf); 116 return IIO_VAL_INT; 117 } 118 119 static int ens160_read_raw(struct iio_dev *indio_dev, 120 struct iio_chan_spec const *chan, 121 int *val, int *val2, long mask) 122 { 123 int ret; 124 125 switch (mask) { 126 case IIO_CHAN_INFO_RAW: 127 if (!iio_device_claim_direct(indio_dev)) 128 return -EBUSY; 129 ret = __ens160_read_raw(indio_dev, chan, val); 130 iio_device_release_direct(indio_dev); 131 return ret; 132 case IIO_CHAN_INFO_SCALE: 133 switch (chan->channel2) { 134 case IIO_MOD_CO2: 135 /* The sensor reads CO2 data as ppm */ 136 *val = 0; 137 *val2 = 100; 138 return IIO_VAL_INT_PLUS_MICRO; 139 case IIO_MOD_VOC: 140 /* The sensor reads VOC data as ppb */ 141 *val = 0; 142 *val2 = 100; 143 return IIO_VAL_INT_PLUS_NANO; 144 default: 145 return -EINVAL; 146 } 147 default: 148 return -EINVAL; 149 } 150 } 151 152 static int ens160_set_mode(struct ens160_data *data, u8 mode) 153 { 154 int ret; 155 156 ret = regmap_write(data->regmap, ENS160_REG_OPMODE, mode); 157 if (ret) 158 return ret; 159 160 msleep(ENS160_BOOTING_TIME_MS); 161 162 return 0; 163 } 164 165 static void ens160_set_idle(void *data) 166 { 167 ens160_set_mode(data, ENS160_REG_MODE_IDLE); 168 } 169 170 static int ens160_chip_init(struct ens160_data *data) 171 { 172 struct device *dev = regmap_get_device(data->regmap); 173 unsigned int status; 174 int ret; 175 176 ret = ens160_set_mode(data, ENS160_REG_MODE_RESET); 177 if (ret) 178 return ret; 179 180 ret = regmap_bulk_read(data->regmap, ENS160_REG_PART_ID, &data->buf, 181 sizeof(data->buf)); 182 if (ret) 183 return ret; 184 185 if (le16_to_cpu(data->buf) != ENS160_PART_ID) 186 return -ENODEV; 187 188 ret = ens160_set_mode(data, ENS160_REG_MODE_IDLE); 189 if (ret) 190 return ret; 191 192 ret = regmap_write(data->regmap, ENS160_REG_COMMAND, 193 ENS160_REG_COMMAND_CLRGPR); 194 if (ret) 195 return ret; 196 197 ret = regmap_write(data->regmap, ENS160_REG_COMMAND, 198 ENS160_REG_COMMAND_GET_APPVER); 199 if (ret) 200 return ret; 201 202 ret = regmap_bulk_read(data->regmap, ENS160_REG_GPR_READ4, 203 data->fw_version, sizeof(data->fw_version)); 204 if (ret) 205 return ret; 206 207 dev_info(dev, "firmware version: %u.%u.%u\n", data->fw_version[2], 208 data->fw_version[1], data->fw_version[0]); 209 210 ret = ens160_set_mode(data, ENS160_REG_MODE_STANDARD); 211 if (ret) 212 return ret; 213 214 ret = devm_add_action_or_reset(dev, ens160_set_idle, data); 215 if (ret) 216 return ret; 217 218 ret = regmap_read(data->regmap, ENS160_REG_DEVICE_STATUS, &status); 219 if (ret) 220 return ret; 221 222 if (FIELD_GET(ENS160_STATUS_VALIDITY_FLAG, status) 223 != ENS160_STATUS_NORMAL) 224 return -EINVAL; 225 226 return 0; 227 } 228 229 static const struct iio_info ens160_info = { 230 .read_raw = ens160_read_raw, 231 }; 232 233 static int ens160_suspend(struct device *dev) 234 { 235 struct iio_dev *indio_dev = dev_get_drvdata(dev); 236 struct ens160_data *data = iio_priv(indio_dev); 237 238 return ens160_set_mode(data, ENS160_REG_MODE_DEEP_SLEEP); 239 } 240 241 static int ens160_resume(struct device *dev) 242 { 243 struct iio_dev *indio_dev = dev_get_drvdata(dev); 244 struct ens160_data *data = iio_priv(indio_dev); 245 int ret; 246 247 ret = ens160_set_mode(data, ENS160_REG_MODE_IDLE); 248 if (ret) 249 return ret; 250 251 return ens160_set_mode(data, ENS160_REG_MODE_STANDARD); 252 } 253 EXPORT_NS_SIMPLE_DEV_PM_OPS(ens160_pm_ops, ens160_suspend, ens160_resume, 254 IIO_ENS160); 255 256 static irqreturn_t ens160_trigger_handler(int irq, void *p) 257 { 258 struct iio_poll_func *pf = p; 259 struct iio_dev *indio_dev = pf->indio_dev; 260 struct ens160_data *data = iio_priv(indio_dev); 261 int ret; 262 263 guard(mutex)(&data->mutex); 264 265 ret = regmap_bulk_read(data->regmap, ENS160_REG_DATA_TVOC, 266 data->scan.chans, sizeof(data->scan.chans)); 267 if (ret) 268 goto err; 269 270 iio_push_to_buffers_with_ts(indio_dev, &data->scan, sizeof(data->scan), 271 pf->timestamp); 272 err: 273 iio_trigger_notify_done(indio_dev->trig); 274 275 return IRQ_HANDLED; 276 } 277 278 static int ens160_set_trigger_state(struct iio_trigger *trig, bool state) 279 { 280 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 281 struct ens160_data *data = iio_priv(indio_dev); 282 unsigned int int_bits = ENS160_REG_CONFIG_INTEN | 283 ENS160_REG_CONFIG_INTDAT | 284 ENS160_REG_CONFIG_INT_CFG; 285 286 if (state) 287 return regmap_set_bits(data->regmap, ENS160_REG_CONFIG, 288 int_bits); 289 else 290 return regmap_clear_bits(data->regmap, ENS160_REG_CONFIG, 291 int_bits); 292 } 293 294 static const struct iio_trigger_ops ens160_trigger_ops = { 295 .set_trigger_state = ens160_set_trigger_state, 296 .validate_device = iio_trigger_validate_own_device, 297 }; 298 299 static int ens160_setup_trigger(struct iio_dev *indio_dev, int irq) 300 { 301 struct device *dev = indio_dev->dev.parent; 302 struct iio_trigger *trig; 303 int ret; 304 305 trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name, 306 iio_device_id(indio_dev)); 307 if (!trig) 308 return dev_err_probe(dev, -ENOMEM, 309 "failed to allocate trigger\n"); 310 311 trig->ops = &ens160_trigger_ops; 312 iio_trigger_set_drvdata(trig, indio_dev); 313 314 ret = devm_iio_trigger_register(dev, trig); 315 if (ret) 316 return ret; 317 318 indio_dev->trig = iio_trigger_get(trig); 319 320 ret = devm_request_threaded_irq(dev, irq, 321 iio_trigger_generic_data_rdy_poll, 322 NULL, 323 IRQF_ONESHOT, 324 indio_dev->name, 325 indio_dev->trig); 326 if (ret) 327 return dev_err_probe(dev, ret, "failed to request irq\n"); 328 329 return 0; 330 } 331 332 int devm_ens160_core_probe(struct device *dev, struct regmap *regmap, int irq, 333 const char *name) 334 { 335 struct ens160_data *data; 336 struct iio_dev *indio_dev; 337 int ret; 338 339 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 340 if (!indio_dev) 341 return -ENOMEM; 342 343 data = iio_priv(indio_dev); 344 data->regmap = regmap; 345 346 indio_dev->name = name; 347 indio_dev->info = &ens160_info; 348 indio_dev->modes = INDIO_DIRECT_MODE; 349 indio_dev->channels = ens160_channels; 350 indio_dev->num_channels = ARRAY_SIZE(ens160_channels); 351 352 if (irq > 0) { 353 ret = ens160_setup_trigger(indio_dev, irq); 354 if (ret) 355 return dev_err_probe(dev, ret, 356 "failed to setup trigger\n"); 357 } 358 359 ret = ens160_chip_init(data); 360 if (ret) 361 return dev_err_probe(dev, ret, "chip initialization failed\n"); 362 363 mutex_init(&data->mutex); 364 365 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, 366 iio_pollfunc_store_time, 367 ens160_trigger_handler, NULL); 368 if (ret) 369 return ret; 370 371 return devm_iio_device_register(dev, indio_dev); 372 } 373 EXPORT_SYMBOL_NS(devm_ens160_core_probe, "IIO_ENS160"); 374 375 MODULE_AUTHOR("Gustavo Silva <gustavograzs@gmail.com>"); 376 MODULE_DESCRIPTION("ScioSense ENS160 driver"); 377 MODULE_LICENSE("GPL v2"); 378