ccs811.c

  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
 67struct ccs811_reading {
 68	__be16 co2;
 69	__be16 voc;
 70	u8 status;
 71	u8 error;
 72	__be16 raw_data;
 73} __attribute__((__packed__));
 74
 75struct 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
 89static 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 */
134static 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
166static 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
178static 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
191static 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
218static 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
252static 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
301static const struct iio_info ccs811_info = {
302	.read_raw = ccs811_read_raw,
303};
304
305static 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
326static const struct iio_trigger_ops ccs811_trigger_ops = {
327	.set_trigger_state = ccs811_set_trigger_state,
328};
329
330static 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
349err:
350	iio_trigger_notify_done(indio_dev->trig);
351
352	return IRQ_HANDLED;
353}
354
355static 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
366static 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
405static 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
525err_buffer_cleanup:
526	iio_triggered_buffer_cleanup(indio_dev);
527err_trigger_unregister:
528	if (data->drdy_trig)
529		iio_trigger_unregister(data->drdy_trig);
530err_poweroff:
531	i2c_smbus_write_byte_data(client, CCS811_MEAS_MODE, CCS811_MODE_IDLE);
532
533	return ret;
534}
535
536static 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
554static const struct i2c_device_id ccs811_id[] = {
555	{ "ccs811" },
556	{	}
557};
558MODULE_DEVICE_TABLE(i2c, ccs811_id);
559
560static const struct of_device_id ccs811_dt_ids[] = {
561	{ .compatible = "ams,ccs811" },
562	{ }
563};
564MODULE_DEVICE_TABLE(of, ccs811_dt_ids);
565
566static 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};
575module_i2c_driver(ccs811_driver);
576
577MODULE_AUTHOR("Narcisa Vasile <narcisaanamaria12@gmail.com>");
578MODULE_DESCRIPTION("CCS811 volatile organic compounds sensor");
579MODULE_LICENSE("GPL v2");