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