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