1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * ccs811.c - Support for AMS CCS811 VOC Sensor
4 *
5 * Copyright (C) 2017 Narcisa Vasile <narcisaanamaria12@gmail.com>
6 *
7 * Datasheet: ams.com/content/download/951091/2269479/CCS811_DS000459_3-00.pdf
8 *
9 * IIO driver for AMS CCS811 (I2C address 0x5A/0x5B set by ADDR Low/High)
10 *
11 * TODO:
12 * 1. Make the drive mode selectable form userspace
13 * 2. Add support for interrupts
14 * 3. Adjust time to wait for data to be ready based on selected operation mode
15 * 4. Read error register and put the information in logs
16 */
17
18 #include <linux/cleanup.h>
19 #include <linux/delay.h>
20 #include <linux/gpio/consumer.h>
21 #include <linux/i2c.h>
22 #include <linux/iio/iio.h>
23 #include <linux/iio/buffer.h>
24 #include <linux/iio/trigger.h>
25 #include <linux/iio/triggered_buffer.h>
26 #include <linux/iio/trigger_consumer.h>
27 #include <linux/module.h>
28
29 #define CCS811_STATUS 0x00
30 #define CCS811_MEAS_MODE 0x01
31 #define CCS811_ALG_RESULT_DATA 0x02
32 #define CCS811_RAW_DATA 0x03
33 #define CCS811_HW_ID 0x20
34 #define CCS811_HW_ID_VALUE 0x81
35 #define CCS811_HW_VERSION 0x21
36 #define CCS811_HW_VERSION_VALUE 0x10
37 #define CCS811_HW_VERSION_MASK 0xF0
38 #define CCS811_ERR 0xE0
39 /* Used to transition from boot to application mode */
40 #define CCS811_APP_START 0xF4
41 #define CCS811_SW_RESET 0xFF
42
43 /* Status register flags */
44 #define CCS811_STATUS_ERROR BIT(0)
45 #define CCS811_STATUS_DATA_READY BIT(3)
46 #define CCS811_STATUS_APP_VALID_MASK BIT(4)
47 #define CCS811_STATUS_APP_VALID_LOADED BIT(4)
48 /*
49 * Value of FW_MODE bit of STATUS register describes the sensor's state:
50 * 0: Firmware is in boot mode, this allows new firmware to be loaded
51 * 1: Firmware is in application mode. CCS811 is ready to take ADC measurements
52 */
53 #define CCS811_STATUS_FW_MODE_MASK BIT(7)
54 #define CCS811_STATUS_FW_MODE_APPLICATION BIT(7)
55
56 /* Measurement modes */
57 #define CCS811_MODE_IDLE 0x00
58 #define CCS811_MODE_IAQ_1SEC 0x10
59 #define CCS811_MODE_IAQ_10SEC 0x20
60 #define CCS811_MODE_IAQ_60SEC 0x30
61 #define CCS811_MODE_RAW_DATA 0x40
62
63 #define CCS811_MEAS_MODE_INTERRUPT BIT(3)
64
65 #define CCS811_VOLTAGE_MASK 0x3FF
66
67 struct ccs811_reading {
68 __be16 co2;
69 __be16 voc;
70 u8 status;
71 u8 error;
72 __be16 raw_data;
73 } __attribute__((__packed__));
74
75 struct ccs811_data {
76 struct i2c_client *client;
77 struct mutex lock; /* Protect readings */
78 struct ccs811_reading buffer;
79 struct iio_trigger *drdy_trig;
80 struct gpio_desc *wakeup_gpio;
81 bool drdy_trig_on;
82 /* Ensures correct alignment of timestamp if present */
83 struct {
84 s16 channels[2];
85 aligned_s64 ts;
86 } scan;
87 };
88
89 static const struct iio_chan_spec ccs811_channels[] = {
90 {
91 .type = IIO_CURRENT,
92 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
93 BIT(IIO_CHAN_INFO_SCALE),
94 .scan_index = -1,
95 }, {
96 .type = IIO_VOLTAGE,
97 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
98 BIT(IIO_CHAN_INFO_SCALE),
99 .scan_index = -1,
100 }, {
101 .type = IIO_CONCENTRATION,
102 .channel2 = IIO_MOD_CO2,
103 .modified = 1,
104 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
105 BIT(IIO_CHAN_INFO_SCALE),
106 .scan_index = 0,
107 .scan_type = {
108 .sign = 'u',
109 .realbits = 16,
110 .storagebits = 16,
111 .endianness = IIO_BE,
112 },
113 }, {
114 .type = IIO_CONCENTRATION,
115 .channel2 = IIO_MOD_VOC,
116 .modified = 1,
117 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
118 BIT(IIO_CHAN_INFO_SCALE),
119 .scan_index = 1,
120 .scan_type = {
121 .sign = 'u',
122 .realbits = 16,
123 .storagebits = 16,
124 .endianness = IIO_BE,
125 },
126 },
127 IIO_CHAN_SOFT_TIMESTAMP(2),
128 };
129
130 /*
131 * The CCS811 powers-up in boot mode. A setup write to CCS811_APP_START will
132 * transition the sensor to application mode.
133 */
ccs811_start_sensor_application(struct i2c_client * client)134 static int ccs811_start_sensor_application(struct i2c_client *client)
135 {
136 int ret;
137
138 ret = i2c_smbus_read_byte_data(client, CCS811_STATUS);
139 if (ret < 0)
140 return ret;
141
142 if ((ret & CCS811_STATUS_FW_MODE_APPLICATION))
143 return 0;
144
145 if ((ret & CCS811_STATUS_APP_VALID_MASK) !=
146 CCS811_STATUS_APP_VALID_LOADED)
147 return -EIO;
148
149 ret = i2c_smbus_write_byte(client, CCS811_APP_START);
150 if (ret < 0)
151 return ret;
152
153 ret = i2c_smbus_read_byte_data(client, CCS811_STATUS);
154 if (ret < 0)
155 return ret;
156
157 if ((ret & CCS811_STATUS_FW_MODE_MASK) !=
158 CCS811_STATUS_FW_MODE_APPLICATION) {
159 dev_err(&client->dev, "Application failed to start. Sensor is still in boot mode.\n");
160 return -EIO;
161 }
162
163 return 0;
164 }
165
ccs811_setup(struct i2c_client * client)166 static int ccs811_setup(struct i2c_client *client)
167 {
168 int ret;
169
170 ret = ccs811_start_sensor_application(client);
171 if (ret < 0)
172 return ret;
173
174 return i2c_smbus_write_byte_data(client, CCS811_MEAS_MODE,
175 CCS811_MODE_IAQ_1SEC);
176 }
177
ccs811_set_wakeup(struct ccs811_data * data,bool enable)178 static void ccs811_set_wakeup(struct ccs811_data *data, bool enable)
179 {
180 if (!data->wakeup_gpio)
181 return;
182
183 gpiod_set_value(data->wakeup_gpio, enable);
184
185 if (enable)
186 usleep_range(50, 60);
187 else
188 usleep_range(20, 30);
189 }
190
ccs811_get_measurement(struct ccs811_data * data)191 static int ccs811_get_measurement(struct ccs811_data *data)
192 {
193 int ret, tries = 11;
194
195 ccs811_set_wakeup(data, true);
196
197 /* Maximum waiting time: 1s, as measurements are made every second */
198 while (tries-- > 0) {
199 ret = i2c_smbus_read_byte_data(data->client, CCS811_STATUS);
200 if (ret < 0)
201 return ret;
202
203 if ((ret & CCS811_STATUS_DATA_READY) || tries == 0)
204 break;
205 msleep(100);
206 }
207 if (!(ret & CCS811_STATUS_DATA_READY))
208 return -EIO;
209
210 ret = i2c_smbus_read_i2c_block_data(data->client,
211 CCS811_ALG_RESULT_DATA, 8,
212 (char *)&data->buffer);
213 ccs811_set_wakeup(data, false);
214
215 return ret;
216 }
217
ccs811_read_info_raw(struct ccs811_data * data,struct iio_chan_spec const * chan,int * val,int mask)218 static int ccs811_read_info_raw(struct ccs811_data *data,
219 struct iio_chan_spec const *chan,
220 int *val, int mask)
221 {
222 int ret;
223
224 guard(mutex)(&data->lock);
225 ret = ccs811_get_measurement(data);
226 if (ret < 0)
227 return ret;
228
229 switch (chan->type) {
230 case IIO_VOLTAGE:
231 *val = be16_to_cpu(data->buffer.raw_data) & CCS811_VOLTAGE_MASK;
232 return IIO_VAL_INT;
233 case IIO_CURRENT:
234 *val = be16_to_cpu(data->buffer.raw_data) >> 10;
235 return IIO_VAL_INT;
236 case IIO_CONCENTRATION:
237 switch (chan->channel2) {
238 case IIO_MOD_CO2:
239 *val = be16_to_cpu(data->buffer.co2);
240 return IIO_VAL_INT;
241 case IIO_MOD_VOC:
242 *val = be16_to_cpu(data->buffer.voc);
243 return IIO_VAL_INT;
244 default:
245 return -EINVAL;
246 }
247 default:
248 return -EINVAL;
249 }
250 }
251
ccs811_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)252 static int ccs811_read_raw(struct iio_dev *indio_dev,
253 struct iio_chan_spec const *chan,
254 int *val, int *val2, long mask)
255 {
256 struct ccs811_data *data = iio_priv(indio_dev);
257 int ret;
258
259 switch (mask) {
260 case IIO_CHAN_INFO_RAW:
261 if (!iio_device_claim_direct(indio_dev))
262 return -EBUSY;
263
264 ret = ccs811_read_info_raw(data, chan, val, mask);
265
266 iio_device_release_direct(indio_dev);
267
268 return ret;
269
270 case IIO_CHAN_INFO_SCALE:
271 switch (chan->type) {
272 case IIO_VOLTAGE:
273 *val = 1;
274 *val2 = 612903;
275 return IIO_VAL_INT_PLUS_MICRO;
276 case IIO_CURRENT:
277 *val = 0;
278 *val2 = 1000;
279 return IIO_VAL_INT_PLUS_MICRO;
280 case IIO_CONCENTRATION:
281 switch (chan->channel2) {
282 case IIO_MOD_CO2:
283 *val = 0;
284 *val2 = 100;
285 return IIO_VAL_INT_PLUS_MICRO;
286 case IIO_MOD_VOC:
287 *val = 0;
288 *val2 = 100;
289 return IIO_VAL_INT_PLUS_NANO;
290 default:
291 return -EINVAL;
292 }
293 default:
294 return -EINVAL;
295 }
296 default:
297 return -EINVAL;
298 }
299 }
300
301 static const struct iio_info ccs811_info = {
302 .read_raw = ccs811_read_raw,
303 };
304
ccs811_set_trigger_state(struct iio_trigger * trig,bool state)305 static int ccs811_set_trigger_state(struct iio_trigger *trig,
306 bool state)
307 {
308 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
309 struct ccs811_data *data = iio_priv(indio_dev);
310 int ret;
311
312 ret = i2c_smbus_read_byte_data(data->client, CCS811_MEAS_MODE);
313 if (ret < 0)
314 return ret;
315
316 if (state)
317 ret |= CCS811_MEAS_MODE_INTERRUPT;
318 else
319 ret &= ~CCS811_MEAS_MODE_INTERRUPT;
320
321 data->drdy_trig_on = state;
322
323 return i2c_smbus_write_byte_data(data->client, CCS811_MEAS_MODE, ret);
324 }
325
326 static const struct iio_trigger_ops ccs811_trigger_ops = {
327 .set_trigger_state = ccs811_set_trigger_state,
328 };
329
ccs811_trigger_handler(int irq,void * p)330 static irqreturn_t ccs811_trigger_handler(int irq, void *p)
331 {
332 struct iio_poll_func *pf = p;
333 struct iio_dev *indio_dev = pf->indio_dev;
334 struct ccs811_data *data = iio_priv(indio_dev);
335 struct i2c_client *client = data->client;
336 int ret;
337
338 ret = i2c_smbus_read_i2c_block_data(client, CCS811_ALG_RESULT_DATA,
339 sizeof(data->scan.channels),
340 (u8 *)data->scan.channels);
341 if (ret != 4) {
342 dev_err(&client->dev, "cannot read sensor data\n");
343 goto err;
344 }
345
346 iio_push_to_buffers_with_ts(indio_dev, &data->scan, sizeof(data->scan),
347 iio_get_time_ns(indio_dev));
348
349 err:
350 iio_trigger_notify_done(indio_dev->trig);
351
352 return IRQ_HANDLED;
353 }
354
ccs811_data_rdy_trigger_poll(int irq,void * private)355 static irqreturn_t ccs811_data_rdy_trigger_poll(int irq, void *private)
356 {
357 struct iio_dev *indio_dev = private;
358 struct ccs811_data *data = iio_priv(indio_dev);
359
360 if (data->drdy_trig_on)
361 iio_trigger_poll(data->drdy_trig);
362
363 return IRQ_HANDLED;
364 }
365
ccs811_reset(struct i2c_client * client)366 static int ccs811_reset(struct i2c_client *client)
367 {
368 struct gpio_desc *reset_gpio;
369 int ret;
370
371 reset_gpio = devm_gpiod_get_optional(&client->dev, "reset",
372 GPIOD_OUT_LOW);
373 if (IS_ERR(reset_gpio))
374 return PTR_ERR(reset_gpio);
375
376 /* Try to reset using nRESET pin if available else do SW reset */
377 if (reset_gpio) {
378 gpiod_set_value(reset_gpio, 1);
379 usleep_range(20, 30);
380 gpiod_set_value(reset_gpio, 0);
381 } else {
382 /*
383 * As per the datasheet, this sequence of values needs to be
384 * written to the SW_RESET register for triggering the soft
385 * reset in the device and placing it in boot mode.
386 */
387 static const u8 reset_seq[] = {
388 0x11, 0xE5, 0x72, 0x8A,
389 };
390
391 ret = i2c_smbus_write_i2c_block_data(client, CCS811_SW_RESET,
392 sizeof(reset_seq), reset_seq);
393 if (ret < 0) {
394 dev_err(&client->dev, "Failed to reset sensor\n");
395 return ret;
396 }
397 }
398
399 /* tSTART delay required after reset */
400 usleep_range(1000, 2000);
401
402 return 0;
403 }
404
ccs811_probe(struct i2c_client * client)405 static int ccs811_probe(struct i2c_client *client)
406 {
407 const struct i2c_device_id *id = i2c_client_get_device_id(client);
408 struct iio_dev *indio_dev;
409 struct ccs811_data *data;
410 int ret;
411
412 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
413 | I2C_FUNC_SMBUS_BYTE_DATA
414 | I2C_FUNC_SMBUS_READ_I2C_BLOCK))
415 return -EOPNOTSUPP;
416
417 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
418 if (!indio_dev)
419 return -ENOMEM;
420
421 data = iio_priv(indio_dev);
422 i2c_set_clientdata(client, indio_dev);
423 data->client = client;
424
425 data->wakeup_gpio = devm_gpiod_get_optional(&client->dev, "wakeup",
426 GPIOD_OUT_HIGH);
427 if (IS_ERR(data->wakeup_gpio))
428 return PTR_ERR(data->wakeup_gpio);
429
430 ccs811_set_wakeup(data, true);
431
432 ret = ccs811_reset(client);
433 if (ret) {
434 ccs811_set_wakeup(data, false);
435 return ret;
436 }
437
438 /* Check hardware id (should be 0x81 for this family of devices) */
439 ret = i2c_smbus_read_byte_data(client, CCS811_HW_ID);
440 if (ret < 0) {
441 ccs811_set_wakeup(data, false);
442 return ret;
443 }
444
445 if (ret != CCS811_HW_ID_VALUE) {
446 dev_err(&client->dev, "hardware id doesn't match CCS81x\n");
447 ccs811_set_wakeup(data, false);
448 return -ENODEV;
449 }
450
451 ret = i2c_smbus_read_byte_data(client, CCS811_HW_VERSION);
452 if (ret < 0) {
453 ccs811_set_wakeup(data, false);
454 return ret;
455 }
456
457 if ((ret & CCS811_HW_VERSION_MASK) != CCS811_HW_VERSION_VALUE) {
458 dev_err(&client->dev, "no CCS811 sensor\n");
459 ccs811_set_wakeup(data, false);
460 return -ENODEV;
461 }
462
463 ret = ccs811_setup(client);
464 if (ret < 0) {
465 ccs811_set_wakeup(data, false);
466 return ret;
467 }
468
469 ccs811_set_wakeup(data, false);
470
471 mutex_init(&data->lock);
472
473 indio_dev->name = id->name;
474 indio_dev->info = &ccs811_info;
475 indio_dev->modes = INDIO_DIRECT_MODE;
476
477 indio_dev->channels = ccs811_channels;
478 indio_dev->num_channels = ARRAY_SIZE(ccs811_channels);
479
480 if (client->irq > 0) {
481 ret = devm_request_threaded_irq(&client->dev, client->irq,
482 ccs811_data_rdy_trigger_poll,
483 NULL,
484 IRQF_TRIGGER_FALLING |
485 IRQF_ONESHOT,
486 "ccs811_irq", indio_dev);
487 if (ret) {
488 dev_err(&client->dev, "irq request error %d\n", -ret);
489 goto err_poweroff;
490 }
491
492 data->drdy_trig = devm_iio_trigger_alloc(&client->dev,
493 "%s-dev%d",
494 indio_dev->name,
495 iio_device_id(indio_dev));
496 if (!data->drdy_trig) {
497 ret = -ENOMEM;
498 goto err_poweroff;
499 }
500
501 data->drdy_trig->ops = &ccs811_trigger_ops;
502 iio_trigger_set_drvdata(data->drdy_trig, indio_dev);
503 ret = iio_trigger_register(data->drdy_trig);
504 if (ret)
505 goto err_poweroff;
506
507 indio_dev->trig = iio_trigger_get(data->drdy_trig);
508 }
509
510 ret = iio_triggered_buffer_setup(indio_dev, NULL,
511 ccs811_trigger_handler, NULL);
512
513 if (ret < 0) {
514 dev_err(&client->dev, "triggered buffer setup failed\n");
515 goto err_trigger_unregister;
516 }
517
518 ret = iio_device_register(indio_dev);
519 if (ret < 0) {
520 dev_err(&client->dev, "unable to register iio device\n");
521 goto err_buffer_cleanup;
522 }
523 return 0;
524
525 err_buffer_cleanup:
526 iio_triggered_buffer_cleanup(indio_dev);
527 err_trigger_unregister:
528 if (data->drdy_trig)
529 iio_trigger_unregister(data->drdy_trig);
530 err_poweroff:
531 i2c_smbus_write_byte_data(client, CCS811_MEAS_MODE, CCS811_MODE_IDLE);
532
533 return ret;
534 }
535
ccs811_remove(struct i2c_client * client)536 static void ccs811_remove(struct i2c_client *client)
537 {
538 struct iio_dev *indio_dev = i2c_get_clientdata(client);
539 struct ccs811_data *data = iio_priv(indio_dev);
540 int ret;
541
542 iio_device_unregister(indio_dev);
543 iio_triggered_buffer_cleanup(indio_dev);
544 if (data->drdy_trig)
545 iio_trigger_unregister(data->drdy_trig);
546
547 ret = i2c_smbus_write_byte_data(client, CCS811_MEAS_MODE,
548 CCS811_MODE_IDLE);
549 if (ret)
550 dev_warn(&client->dev, "Failed to power down device (%pe)\n",
551 ERR_PTR(ret));
552 }
553
554 static const struct i2c_device_id ccs811_id[] = {
555 { "ccs811" },
556 { }
557 };
558 MODULE_DEVICE_TABLE(i2c, ccs811_id);
559
560 static const struct of_device_id ccs811_dt_ids[] = {
561 { .compatible = "ams,ccs811" },
562 { }
563 };
564 MODULE_DEVICE_TABLE(of, ccs811_dt_ids);
565
566 static struct i2c_driver ccs811_driver = {
567 .driver = {
568 .name = "ccs811",
569 .of_match_table = ccs811_dt_ids,
570 },
571 .probe = ccs811_probe,
572 .remove = ccs811_remove,
573 .id_table = ccs811_id,
574 };
575 module_i2c_driver(ccs811_driver);
576
577 MODULE_AUTHOR("Narcisa Vasile <narcisaanamaria12@gmail.com>");
578 MODULE_DESCRIPTION("CCS811 volatile organic compounds sensor");
579 MODULE_LICENSE("GPL v2");
580