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
__ens160_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val)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
ens160_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)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
ens160_set_mode(struct ens160_data * data,u8 mode)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
ens160_set_idle(void * data)165 static void ens160_set_idle(void *data)
166 {
167 ens160_set_mode(data, ENS160_REG_MODE_IDLE);
168 }
169
ens160_chip_init(struct ens160_data * data)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
ens160_suspend(struct device * dev)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
ens160_resume(struct device * dev)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
ens160_trigger_handler(int irq,void * p)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
ens160_set_trigger_state(struct iio_trigger * trig,bool state)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
ens160_setup_trigger(struct iio_dev * indio_dev,int irq)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
devm_ens160_core_probe(struct device * dev,struct regmap * regmap,int irq,const char * name)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