1 /* 2 * ccs811.c - Support for AMS CCS811 VOC Sensor 3 * 4 * Copyright (C) 2017 Narcisa Vasile <narcisaanamaria12@gmail.com> 5 * 6 * Datasheet: ams.com/content/download/951091/2269479/CCS811_DS000459_3-00.pdf 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 * IIO driver for AMS CCS811 (I2C address 0x5A/0x5B set by ADDR Low/High) 13 * 14 * TODO: 15 * 1. Make the drive mode selectable form userspace 16 * 2. Add support for interrupts 17 * 3. Adjust time to wait for data to be ready based on selected operation mode 18 * 4. Read error register and put the information in logs 19 */ 20 21 #include <linux/delay.h> 22 #include <linux/i2c.h> 23 #include <linux/iio/iio.h> 24 #include <linux/iio/buffer.h> 25 #include <linux/iio/trigger.h> 26 #include <linux/iio/triggered_buffer.h> 27 #include <linux/iio/trigger_consumer.h> 28 #include <linux/module.h> 29 30 #define CCS811_STATUS 0x00 31 #define CCS811_MEAS_MODE 0x01 32 #define CCS811_ALG_RESULT_DATA 0x02 33 #define CCS811_RAW_DATA 0x03 34 #define CCS811_HW_ID 0x20 35 #define CCS881_HW_ID_VALUE 0x81 36 #define CCS811_HW_VERSION 0x21 37 #define CCS811_HW_VERSION_VALUE 0x10 38 #define CCS811_HW_VERSION_MASK 0xF0 39 #define CCS811_ERR 0xE0 40 /* Used to transition from boot to application mode */ 41 #define CCS811_APP_START 0xF4 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 resistance; 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 bool drdy_trig_on; 81 }; 82 83 static const struct iio_chan_spec ccs811_channels[] = { 84 { 85 .type = IIO_CURRENT, 86 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 87 BIT(IIO_CHAN_INFO_SCALE), 88 .scan_index = -1, 89 }, { 90 .type = IIO_VOLTAGE, 91 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 92 BIT(IIO_CHAN_INFO_SCALE), 93 .scan_index = -1, 94 }, { 95 .type = IIO_CONCENTRATION, 96 .channel2 = IIO_MOD_CO2, 97 .modified = 1, 98 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 99 BIT(IIO_CHAN_INFO_OFFSET) | 100 BIT(IIO_CHAN_INFO_SCALE), 101 .scan_index = 0, 102 .scan_type = { 103 .sign = 'u', 104 .realbits = 16, 105 .storagebits = 16, 106 .endianness = IIO_BE, 107 }, 108 }, { 109 .type = IIO_CONCENTRATION, 110 .channel2 = IIO_MOD_VOC, 111 .modified = 1, 112 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 113 BIT(IIO_CHAN_INFO_SCALE), 114 .scan_index = 1, 115 .scan_type = { 116 .sign = 'u', 117 .realbits = 16, 118 .storagebits = 16, 119 .endianness = IIO_BE, 120 }, 121 }, 122 IIO_CHAN_SOFT_TIMESTAMP(2), 123 }; 124 125 /* 126 * The CCS811 powers-up in boot mode. A setup write to CCS811_APP_START will 127 * transition the sensor to application mode. 128 */ 129 static int ccs811_start_sensor_application(struct i2c_client *client) 130 { 131 int ret; 132 133 ret = i2c_smbus_read_byte_data(client, CCS811_STATUS); 134 if (ret < 0) 135 return ret; 136 137 if ((ret & CCS811_STATUS_APP_VALID_MASK) != 138 CCS811_STATUS_APP_VALID_LOADED) 139 return -EIO; 140 141 ret = i2c_smbus_write_byte(client, CCS811_APP_START); 142 if (ret < 0) 143 return ret; 144 145 ret = i2c_smbus_read_byte_data(client, CCS811_STATUS); 146 if (ret < 0) 147 return ret; 148 149 if ((ret & CCS811_STATUS_FW_MODE_MASK) != 150 CCS811_STATUS_FW_MODE_APPLICATION) { 151 dev_err(&client->dev, "Application failed to start. Sensor is still in boot mode.\n"); 152 return -EIO; 153 } 154 155 return 0; 156 } 157 158 static int ccs811_setup(struct i2c_client *client) 159 { 160 int ret; 161 162 ret = ccs811_start_sensor_application(client); 163 if (ret < 0) 164 return ret; 165 166 return i2c_smbus_write_byte_data(client, CCS811_MEAS_MODE, 167 CCS811_MODE_IAQ_1SEC); 168 } 169 170 static int ccs811_get_measurement(struct ccs811_data *data) 171 { 172 int ret, tries = 11; 173 174 /* Maximum waiting time: 1s, as measurements are made every second */ 175 while (tries-- > 0) { 176 ret = i2c_smbus_read_byte_data(data->client, CCS811_STATUS); 177 if (ret < 0) 178 return ret; 179 180 if ((ret & CCS811_STATUS_DATA_READY) || tries == 0) 181 break; 182 msleep(100); 183 } 184 if (!(ret & CCS811_STATUS_DATA_READY)) 185 return -EIO; 186 187 return i2c_smbus_read_i2c_block_data(data->client, 188 CCS811_ALG_RESULT_DATA, 8, 189 (char *)&data->buffer); 190 } 191 192 static int ccs811_read_raw(struct iio_dev *indio_dev, 193 struct iio_chan_spec const *chan, 194 int *val, int *val2, long mask) 195 { 196 struct ccs811_data *data = iio_priv(indio_dev); 197 int ret; 198 199 switch (mask) { 200 case IIO_CHAN_INFO_RAW: 201 ret = iio_device_claim_direct_mode(indio_dev); 202 if (ret) 203 return ret; 204 mutex_lock(&data->lock); 205 ret = ccs811_get_measurement(data); 206 if (ret < 0) { 207 mutex_unlock(&data->lock); 208 iio_device_release_direct_mode(indio_dev); 209 return ret; 210 } 211 212 switch (chan->type) { 213 case IIO_VOLTAGE: 214 *val = be16_to_cpu(data->buffer.resistance) & 215 CCS811_VOLTAGE_MASK; 216 ret = IIO_VAL_INT; 217 break; 218 case IIO_CURRENT: 219 *val = be16_to_cpu(data->buffer.resistance) >> 10; 220 ret = IIO_VAL_INT; 221 break; 222 case IIO_CONCENTRATION: 223 switch (chan->channel2) { 224 case IIO_MOD_CO2: 225 *val = be16_to_cpu(data->buffer.co2); 226 ret = IIO_VAL_INT; 227 break; 228 case IIO_MOD_VOC: 229 *val = be16_to_cpu(data->buffer.voc); 230 ret = IIO_VAL_INT; 231 break; 232 default: 233 ret = -EINVAL; 234 } 235 break; 236 default: 237 ret = -EINVAL; 238 } 239 mutex_unlock(&data->lock); 240 iio_device_release_direct_mode(indio_dev); 241 242 return ret; 243 244 case IIO_CHAN_INFO_SCALE: 245 switch (chan->type) { 246 case IIO_VOLTAGE: 247 *val = 1; 248 *val2 = 612903; 249 return IIO_VAL_INT_PLUS_MICRO; 250 case IIO_CURRENT: 251 *val = 0; 252 *val2 = 1000; 253 return IIO_VAL_INT_PLUS_MICRO; 254 case IIO_CONCENTRATION: 255 switch (chan->channel2) { 256 case IIO_MOD_CO2: 257 *val = 0; 258 *val2 = 12834; 259 return IIO_VAL_INT_PLUS_MICRO; 260 case IIO_MOD_VOC: 261 *val = 0; 262 *val2 = 84246; 263 return IIO_VAL_INT_PLUS_MICRO; 264 default: 265 return -EINVAL; 266 } 267 default: 268 return -EINVAL; 269 } 270 case IIO_CHAN_INFO_OFFSET: 271 if (!(chan->type == IIO_CONCENTRATION && 272 chan->channel2 == IIO_MOD_CO2)) 273 return -EINVAL; 274 *val = -400; 275 return IIO_VAL_INT; 276 default: 277 return -EINVAL; 278 } 279 } 280 281 static const struct iio_info ccs811_info = { 282 .read_raw = ccs811_read_raw, 283 }; 284 285 static int ccs811_set_trigger_state(struct iio_trigger *trig, 286 bool state) 287 { 288 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 289 struct ccs811_data *data = iio_priv(indio_dev); 290 int ret; 291 292 ret = i2c_smbus_read_byte_data(data->client, CCS811_MEAS_MODE); 293 if (ret < 0) 294 return ret; 295 296 if (state) 297 ret |= CCS811_MEAS_MODE_INTERRUPT; 298 else 299 ret &= ~CCS811_MEAS_MODE_INTERRUPT; 300 301 data->drdy_trig_on = state; 302 303 return i2c_smbus_write_byte_data(data->client, CCS811_MEAS_MODE, ret); 304 } 305 306 static const struct iio_trigger_ops ccs811_trigger_ops = { 307 .set_trigger_state = ccs811_set_trigger_state, 308 }; 309 310 static irqreturn_t ccs811_trigger_handler(int irq, void *p) 311 { 312 struct iio_poll_func *pf = p; 313 struct iio_dev *indio_dev = pf->indio_dev; 314 struct ccs811_data *data = iio_priv(indio_dev); 315 struct i2c_client *client = data->client; 316 s16 buf[8]; /* s16 eCO2 + s16 TVOC + padding + 8 byte timestamp */ 317 int ret; 318 319 ret = i2c_smbus_read_i2c_block_data(client, CCS811_ALG_RESULT_DATA, 4, 320 (u8 *)&buf); 321 if (ret != 4) { 322 dev_err(&client->dev, "cannot read sensor data\n"); 323 goto err; 324 } 325 326 iio_push_to_buffers_with_timestamp(indio_dev, buf, 327 iio_get_time_ns(indio_dev)); 328 329 err: 330 iio_trigger_notify_done(indio_dev->trig); 331 332 return IRQ_HANDLED; 333 } 334 335 static irqreturn_t ccs811_data_rdy_trigger_poll(int irq, void *private) 336 { 337 struct iio_dev *indio_dev = private; 338 struct ccs811_data *data = iio_priv(indio_dev); 339 340 if (data->drdy_trig_on) 341 iio_trigger_poll(data->drdy_trig); 342 343 return IRQ_HANDLED; 344 } 345 346 static int ccs811_probe(struct i2c_client *client, 347 const struct i2c_device_id *id) 348 { 349 struct iio_dev *indio_dev; 350 struct ccs811_data *data; 351 int ret; 352 353 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE 354 | I2C_FUNC_SMBUS_BYTE_DATA 355 | I2C_FUNC_SMBUS_READ_I2C_BLOCK)) 356 return -EOPNOTSUPP; 357 358 /* Check hardware id (should be 0x81 for this family of devices) */ 359 ret = i2c_smbus_read_byte_data(client, CCS811_HW_ID); 360 if (ret < 0) 361 return ret; 362 363 if (ret != CCS881_HW_ID_VALUE) { 364 dev_err(&client->dev, "hardware id doesn't match CCS81x\n"); 365 return -ENODEV; 366 } 367 368 ret = i2c_smbus_read_byte_data(client, CCS811_HW_VERSION); 369 if (ret < 0) 370 return ret; 371 372 if ((ret & CCS811_HW_VERSION_MASK) != CCS811_HW_VERSION_VALUE) { 373 dev_err(&client->dev, "no CCS811 sensor\n"); 374 return -ENODEV; 375 } 376 377 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 378 if (!indio_dev) 379 return -ENOMEM; 380 381 ret = ccs811_setup(client); 382 if (ret < 0) 383 return ret; 384 385 data = iio_priv(indio_dev); 386 i2c_set_clientdata(client, indio_dev); 387 data->client = client; 388 389 mutex_init(&data->lock); 390 391 indio_dev->dev.parent = &client->dev; 392 indio_dev->name = id->name; 393 indio_dev->info = &ccs811_info; 394 indio_dev->modes = INDIO_DIRECT_MODE; 395 396 indio_dev->channels = ccs811_channels; 397 indio_dev->num_channels = ARRAY_SIZE(ccs811_channels); 398 399 if (client->irq > 0) { 400 ret = devm_request_threaded_irq(&client->dev, client->irq, 401 ccs811_data_rdy_trigger_poll, 402 NULL, 403 IRQF_TRIGGER_FALLING | 404 IRQF_ONESHOT, 405 "ccs811_irq", indio_dev); 406 if (ret) { 407 dev_err(&client->dev, "irq request error %d\n", -ret); 408 goto err_poweroff; 409 } 410 411 data->drdy_trig = devm_iio_trigger_alloc(&client->dev, 412 "%s-dev%d", 413 indio_dev->name, 414 indio_dev->id); 415 if (!data->drdy_trig) { 416 ret = -ENOMEM; 417 goto err_poweroff; 418 } 419 420 data->drdy_trig->dev.parent = &client->dev; 421 data->drdy_trig->ops = &ccs811_trigger_ops; 422 iio_trigger_set_drvdata(data->drdy_trig, indio_dev); 423 indio_dev->trig = data->drdy_trig; 424 iio_trigger_get(indio_dev->trig); 425 ret = iio_trigger_register(data->drdy_trig); 426 if (ret) 427 goto err_poweroff; 428 } 429 430 ret = iio_triggered_buffer_setup(indio_dev, NULL, 431 ccs811_trigger_handler, NULL); 432 433 if (ret < 0) { 434 dev_err(&client->dev, "triggered buffer setup failed\n"); 435 goto err_trigger_unregister; 436 } 437 438 ret = iio_device_register(indio_dev); 439 if (ret < 0) { 440 dev_err(&client->dev, "unable to register iio device\n"); 441 goto err_buffer_cleanup; 442 } 443 return 0; 444 445 err_buffer_cleanup: 446 iio_triggered_buffer_cleanup(indio_dev); 447 err_trigger_unregister: 448 if (data->drdy_trig) 449 iio_trigger_unregister(data->drdy_trig); 450 err_poweroff: 451 i2c_smbus_write_byte_data(client, CCS811_MEAS_MODE, CCS811_MODE_IDLE); 452 453 return ret; 454 } 455 456 static int ccs811_remove(struct i2c_client *client) 457 { 458 struct iio_dev *indio_dev = i2c_get_clientdata(client); 459 struct ccs811_data *data = iio_priv(indio_dev); 460 461 iio_device_unregister(indio_dev); 462 iio_triggered_buffer_cleanup(indio_dev); 463 if (data->drdy_trig) 464 iio_trigger_unregister(data->drdy_trig); 465 466 return i2c_smbus_write_byte_data(client, CCS811_MEAS_MODE, 467 CCS811_MODE_IDLE); 468 } 469 470 static const struct i2c_device_id ccs811_id[] = { 471 {"ccs811", 0}, 472 { } 473 }; 474 MODULE_DEVICE_TABLE(i2c, ccs811_id); 475 476 static struct i2c_driver ccs811_driver = { 477 .driver = { 478 .name = "ccs811", 479 }, 480 .probe = ccs811_probe, 481 .remove = ccs811_remove, 482 .id_table = ccs811_id, 483 }; 484 module_i2c_driver(ccs811_driver); 485 486 MODULE_AUTHOR("Narcisa Vasile <narcisaanamaria12@gmail.com>"); 487 MODULE_DESCRIPTION("CCS811 volatile organic compounds sensor"); 488 MODULE_LICENSE("GPL v2"); 489