GNU Linux-libre 4.9.282-gnu1
[releases.git] / drivers / iio / chemical / vz89x.c
1 /*
2  * vz89x.c - Support for SGX Sensortech MiCS VZ89X VOC sensors
3  *
4  * Copyright (C) 2015 Matt Ranostay <mranostay@gmail.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  */
17
18 #include <linux/module.h>
19 #include <linux/mutex.h>
20 #include <linux/init.h>
21 #include <linux/i2c.h>
22 #include <linux/of.h>
23 #include <linux/of_device.h>
24
25 #include <linux/iio/iio.h>
26 #include <linux/iio/sysfs.h>
27
28 #define VZ89X_REG_MEASUREMENT           0x09
29 #define VZ89X_REG_MEASUREMENT_RD_SIZE   6
30 #define VZ89X_REG_MEASUREMENT_WR_SIZE   3
31
32 #define VZ89X_VOC_CO2_IDX               0
33 #define VZ89X_VOC_SHORT_IDX             1
34 #define VZ89X_VOC_TVOC_IDX              2
35 #define VZ89X_VOC_RESISTANCE_IDX        3
36
37 #define VZ89TE_REG_MEASUREMENT          0x0c
38 #define VZ89TE_REG_MEASUREMENT_RD_SIZE  7
39 #define VZ89TE_REG_MEASUREMENT_WR_SIZE  6
40
41 #define VZ89TE_VOC_TVOC_IDX             0
42 #define VZ89TE_VOC_CO2_IDX              1
43 #define VZ89TE_VOC_RESISTANCE_IDX       2
44
45 enum {
46         VZ89X,
47         VZ89TE,
48 };
49
50 struct vz89x_chip_data;
51
52 struct vz89x_data {
53         struct i2c_client *client;
54         const struct vz89x_chip_data *chip;
55         struct mutex lock;
56         int (*xfer)(struct vz89x_data *data, u8 cmd);
57
58         bool is_valid;
59         unsigned long last_update;
60         u8 buffer[VZ89TE_REG_MEASUREMENT_RD_SIZE];
61 };
62
63 struct vz89x_chip_data {
64         bool (*valid)(struct vz89x_data *data);
65         const struct iio_chan_spec *channels;
66         u8 num_channels;
67
68         u8 cmd;
69         u8 read_size;
70         u8 write_size;
71 };
72
73 static const struct iio_chan_spec vz89x_channels[] = {
74         {
75                 .type = IIO_CONCENTRATION,
76                 .channel2 = IIO_MOD_CO2,
77                 .modified = 1,
78                 .info_mask_separate =
79                         BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_RAW),
80                 .address = VZ89X_VOC_CO2_IDX,
81         },
82         {
83                 .type = IIO_CONCENTRATION,
84                 .channel2 = IIO_MOD_VOC,
85                 .modified = 1,
86                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
87                 .address = VZ89X_VOC_SHORT_IDX,
88                 .extend_name = "short",
89         },
90         {
91                 .type = IIO_CONCENTRATION,
92                 .channel2 = IIO_MOD_VOC,
93                 .modified = 1,
94                 .info_mask_separate =
95                         BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_RAW),
96                 .address = VZ89X_VOC_TVOC_IDX,
97         },
98         {
99                 .type = IIO_RESISTANCE,
100                 .info_mask_separate =
101                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
102                 .address = VZ89X_VOC_RESISTANCE_IDX,
103                 .scan_index = -1,
104                 .scan_type = {
105                         .endianness = IIO_LE,
106                 },
107         },
108 };
109
110 static const struct iio_chan_spec vz89te_channels[] = {
111         {
112                 .type = IIO_CONCENTRATION,
113                 .channel2 = IIO_MOD_VOC,
114                 .modified = 1,
115                 .info_mask_separate =
116                         BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_RAW),
117                 .address = VZ89TE_VOC_TVOC_IDX,
118         },
119
120         {
121                 .type = IIO_CONCENTRATION,
122                 .channel2 = IIO_MOD_CO2,
123                 .modified = 1,
124                 .info_mask_separate =
125                         BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_RAW),
126                 .address = VZ89TE_VOC_CO2_IDX,
127         },
128         {
129                 .type = IIO_RESISTANCE,
130                 .info_mask_separate =
131                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
132                 .address = VZ89TE_VOC_RESISTANCE_IDX,
133                 .scan_index = -1,
134                 .scan_type = {
135                         .endianness = IIO_BE,
136                 },
137         },
138 };
139
140 static IIO_CONST_ATTR(in_concentration_co2_scale, "0.00000698689");
141 static IIO_CONST_ATTR(in_concentration_voc_scale, "0.00000000436681223");
142
143 static struct attribute *vz89x_attributes[] = {
144         &iio_const_attr_in_concentration_co2_scale.dev_attr.attr,
145         &iio_const_attr_in_concentration_voc_scale.dev_attr.attr,
146         NULL,
147 };
148
149 static const struct attribute_group vz89x_attrs_group = {
150         .attrs = vz89x_attributes,
151 };
152
153 /*
154  * Chipset sometime updates in the middle of a reading causing it to reset the
155  * data pointer, and causing invalid reading of previous data.
156  * We can check for this by reading MSB of the resistance reading that is
157  * always zero, and by also confirming the VOC_short isn't zero.
158  */
159
160 static bool vz89x_measurement_is_valid(struct vz89x_data *data)
161 {
162         if (data->buffer[VZ89X_VOC_SHORT_IDX] == 0)
163                 return true;
164
165         return !!(data->buffer[data->chip->read_size - 1] > 0);
166 }
167
168 /* VZ89TE device has a modified CRC-8 two complement check */
169 static bool vz89te_measurement_is_valid(struct vz89x_data *data)
170 {
171         u8 crc = 0;
172         int i, sum = 0;
173
174         for (i = 0; i < (data->chip->read_size - 1); i++) {
175                 sum = crc + data->buffer[i];
176                 crc = sum;
177                 crc += sum / 256;
178         }
179
180         return !((0xff - crc) == data->buffer[data->chip->read_size - 1]);
181 }
182
183 static int vz89x_i2c_xfer(struct vz89x_data *data, u8 cmd)
184 {
185         const struct vz89x_chip_data *chip = data->chip;
186         struct i2c_client *client = data->client;
187         struct i2c_msg msg[2];
188         int ret;
189         u8 buf[6] = { cmd, 0, 0, 0, 0, 0xf3 };
190
191         msg[0].addr = client->addr;
192         msg[0].flags = client->flags;
193         msg[0].len = chip->write_size;
194         msg[0].buf  = (char *) &buf;
195
196         msg[1].addr = client->addr;
197         msg[1].flags = client->flags | I2C_M_RD;
198         msg[1].len = chip->read_size;
199         msg[1].buf = (char *) &data->buffer;
200
201         ret = i2c_transfer(client->adapter, msg, 2);
202
203         return (ret == 2) ? 0 : ret;
204 }
205
206 static int vz89x_smbus_xfer(struct vz89x_data *data, u8 cmd)
207 {
208         struct i2c_client *client = data->client;
209         int ret;
210         int i;
211
212         ret = i2c_smbus_write_word_data(client, cmd, 0);
213         if (ret < 0)
214                 return ret;
215
216         for (i = 0; i < data->chip->read_size; i++) {
217                 ret = i2c_smbus_read_byte(client);
218                 if (ret < 0)
219                         return ret;
220                 data->buffer[i] = ret;
221         }
222
223         return 0;
224 }
225
226 static int vz89x_get_measurement(struct vz89x_data *data)
227 {
228         const struct vz89x_chip_data *chip = data->chip;
229         int ret;
230
231         /* sensor can only be polled once a second max per datasheet */
232         if (!time_after(jiffies, data->last_update + HZ))
233                 return data->is_valid ? 0 : -EAGAIN;
234
235         data->is_valid = false;
236         data->last_update = jiffies;
237
238         ret = data->xfer(data, chip->cmd);
239         if (ret < 0)
240                 return ret;
241
242         ret = chip->valid(data);
243         if (ret)
244                 return -EAGAIN;
245
246         data->is_valid = true;
247
248         return 0;
249 }
250
251 static int vz89x_get_resistance_reading(struct vz89x_data *data,
252                                         struct iio_chan_spec const *chan,
253                                         int *val)
254 {
255         u8 *tmp = (u8 *) &data->buffer[chan->address];
256
257         switch (chan->scan_type.endianness) {
258         case IIO_LE:
259                 *val = le32_to_cpup((__le32 *) tmp) & GENMASK(23, 0);
260                 break;
261         case IIO_BE:
262                 *val = be32_to_cpup((__be32 *) tmp) >> 8;
263                 break;
264         default:
265                 return -EINVAL;
266         }
267
268         return 0;
269 }
270
271 static int vz89x_read_raw(struct iio_dev *indio_dev,
272                           struct iio_chan_spec const *chan, int *val,
273                           int *val2, long mask)
274 {
275         struct vz89x_data *data = iio_priv(indio_dev);
276         int ret = -EINVAL;
277
278         switch (mask) {
279         case IIO_CHAN_INFO_RAW:
280                 mutex_lock(&data->lock);
281                 ret = vz89x_get_measurement(data);
282                 mutex_unlock(&data->lock);
283
284                 if (ret)
285                         return ret;
286
287                 switch (chan->type) {
288                 case IIO_CONCENTRATION:
289                         *val = data->buffer[chan->address];
290                         return IIO_VAL_INT;
291                 case IIO_RESISTANCE:
292                         ret = vz89x_get_resistance_reading(data, chan, val);
293                         if (!ret)
294                                 return IIO_VAL_INT;
295                         break;
296                 default:
297                         return -EINVAL;
298                 }
299                 break;
300         case IIO_CHAN_INFO_SCALE:
301                 switch (chan->type) {
302                 case IIO_RESISTANCE:
303                         *val = 10;
304                         return IIO_VAL_INT;
305                 default:
306                         return -EINVAL;
307                 }
308                 break;
309         case IIO_CHAN_INFO_OFFSET:
310                 switch (chan->channel2) {
311                 case IIO_MOD_CO2:
312                         *val = 44;
313                         *val2 = 250000;
314                         return IIO_VAL_INT_PLUS_MICRO;
315                 case IIO_MOD_VOC:
316                         *val = -13;
317                         return IIO_VAL_INT;
318                 default:
319                         return -EINVAL;
320                 }
321         }
322
323         return ret;
324 }
325
326 static const struct iio_info vz89x_info = {
327         .attrs          = &vz89x_attrs_group,
328         .read_raw       = vz89x_read_raw,
329         .driver_module  = THIS_MODULE,
330 };
331
332 static const struct vz89x_chip_data vz89x_chips[] = {
333         {
334                 .valid = vz89x_measurement_is_valid,
335
336                 .cmd = VZ89X_REG_MEASUREMENT,
337                 .read_size = VZ89X_REG_MEASUREMENT_RD_SIZE,
338                 .write_size = VZ89X_REG_MEASUREMENT_WR_SIZE,
339
340                 .channels = vz89x_channels,
341                 .num_channels = ARRAY_SIZE(vz89x_channels),
342         },
343         {
344                 .valid = vz89te_measurement_is_valid,
345
346                 .cmd = VZ89TE_REG_MEASUREMENT,
347                 .read_size = VZ89TE_REG_MEASUREMENT_RD_SIZE,
348                 .write_size = VZ89TE_REG_MEASUREMENT_WR_SIZE,
349
350                 .channels = vz89te_channels,
351                 .num_channels = ARRAY_SIZE(vz89te_channels),
352         },
353 };
354
355 static const struct of_device_id vz89x_dt_ids[] = {
356         { .compatible = "sgx,vz89x", .data = (void *) VZ89X },
357         { .compatible = "sgx,vz89te", .data = (void *) VZ89TE },
358         { }
359 };
360 MODULE_DEVICE_TABLE(of, vz89x_dt_ids);
361
362 static int vz89x_probe(struct i2c_client *client,
363                        const struct i2c_device_id *id)
364 {
365         struct iio_dev *indio_dev;
366         struct vz89x_data *data;
367         const struct of_device_id *of_id;
368         int chip_id;
369
370         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
371         if (!indio_dev)
372                 return -ENOMEM;
373         data = iio_priv(indio_dev);
374
375         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
376                 data->xfer = vz89x_i2c_xfer;
377         else if (i2c_check_functionality(client->adapter,
378                                 I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BYTE))
379                 data->xfer = vz89x_smbus_xfer;
380         else
381                 return -EOPNOTSUPP;
382
383         of_id = of_match_device(vz89x_dt_ids, &client->dev);
384         if (!of_id)
385                 chip_id = id->driver_data;
386         else
387                 chip_id = (unsigned long)of_id->data;
388
389         i2c_set_clientdata(client, indio_dev);
390         data->client = client;
391         data->chip = &vz89x_chips[chip_id];
392         data->last_update = jiffies - HZ;
393         mutex_init(&data->lock);
394
395         indio_dev->dev.parent = &client->dev;
396         indio_dev->info = &vz89x_info,
397         indio_dev->name = dev_name(&client->dev);
398         indio_dev->modes = INDIO_DIRECT_MODE;
399
400         indio_dev->channels = data->chip->channels;
401         indio_dev->num_channels = data->chip->num_channels;
402
403         return devm_iio_device_register(&client->dev, indio_dev);
404 }
405
406 static const struct i2c_device_id vz89x_id[] = {
407         { "vz89x", VZ89X },
408         { "vz89te", VZ89TE },
409         { }
410 };
411 MODULE_DEVICE_TABLE(i2c, vz89x_id);
412
413 static struct i2c_driver vz89x_driver = {
414         .driver = {
415                 .name   = "vz89x",
416                 .of_match_table = of_match_ptr(vz89x_dt_ids),
417         },
418         .probe = vz89x_probe,
419         .id_table = vz89x_id,
420 };
421 module_i2c_driver(vz89x_driver);
422
423 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
424 MODULE_DESCRIPTION("SGX Sensortech MiCS VZ89X VOC sensors");
425 MODULE_LICENSE("GPL v2");