1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * hdc100x.c - Support for the TI HDC100x temperature + humidity sensors |
4 | * |
5 | * Copyright (C) 2015, 2018 |
6 | * Author: Matt Ranostay <matt.ranostay@konsulko.com> |
7 | * |
8 | * Datasheets: |
9 | * https://www.ti.com/product/HDC1000/datasheet |
10 | * https://www.ti.com/product/HDC1008/datasheet |
11 | * https://www.ti.com/product/HDC1010/datasheet |
12 | * https://www.ti.com/product/HDC1050/datasheet |
13 | * https://www.ti.com/product/HDC1080/datasheet |
14 | */ |
15 | |
16 | #include <linux/delay.h> |
17 | #include <linux/module.h> |
18 | #include <linux/mod_devicetable.h> |
19 | #include <linux/init.h> |
20 | #include <linux/i2c.h> |
21 | |
22 | #include <linux/iio/iio.h> |
23 | #include <linux/iio/sysfs.h> |
24 | #include <linux/iio/buffer.h> |
25 | #include <linux/iio/trigger_consumer.h> |
26 | #include <linux/iio/triggered_buffer.h> |
27 | |
28 | #include <linux/time.h> |
29 | |
30 | #define HDC100X_REG_TEMP 0x00 |
31 | #define HDC100X_REG_HUMIDITY 0x01 |
32 | |
33 | #define HDC100X_REG_CONFIG 0x02 |
34 | #define HDC100X_REG_CONFIG_ACQ_MODE BIT(12) |
35 | #define HDC100X_REG_CONFIG_HEATER_EN BIT(13) |
36 | |
37 | struct hdc100x_data { |
38 | struct i2c_client *client; |
39 | struct mutex lock; |
40 | u16 config; |
41 | |
42 | /* integration time of the sensor */ |
43 | int adc_int_us[2]; |
44 | /* Ensure natural alignment of timestamp */ |
45 | struct { |
46 | __be16 channels[2]; |
47 | s64 ts __aligned(8); |
48 | } scan; |
49 | }; |
50 | |
51 | /* integration time in us */ |
52 | static const int hdc100x_int_time[][3] = { |
53 | { 6350, 3650, 0 }, /* IIO_TEMP channel*/ |
54 | { 6500, 3850, 2500 }, /* IIO_HUMIDITYRELATIVE channel */ |
55 | }; |
56 | |
57 | /* HDC100X_REG_CONFIG shift and mask values */ |
58 | static const struct { |
59 | int shift; |
60 | int mask; |
61 | } hdc100x_resolution_shift[2] = { |
62 | { /* IIO_TEMP channel */ |
63 | .shift = 10, |
64 | .mask = 1 |
65 | }, |
66 | { /* IIO_HUMIDITYRELATIVE channel */ |
67 | .shift = 8, |
68 | .mask = 3, |
69 | }, |
70 | }; |
71 | |
72 | static IIO_CONST_ATTR(temp_integration_time_available, |
73 | "0.00365 0.00635" ); |
74 | |
75 | static IIO_CONST_ATTR(humidityrelative_integration_time_available, |
76 | "0.0025 0.00385 0.0065" ); |
77 | |
78 | static IIO_CONST_ATTR(out_current_heater_raw_available, |
79 | "0 1" ); |
80 | |
81 | static struct attribute *hdc100x_attributes[] = { |
82 | &iio_const_attr_temp_integration_time_available.dev_attr.attr, |
83 | &iio_const_attr_humidityrelative_integration_time_available.dev_attr.attr, |
84 | &iio_const_attr_out_current_heater_raw_available.dev_attr.attr, |
85 | NULL |
86 | }; |
87 | |
88 | static const struct attribute_group hdc100x_attribute_group = { |
89 | .attrs = hdc100x_attributes, |
90 | }; |
91 | |
92 | static const struct iio_chan_spec hdc100x_channels[] = { |
93 | { |
94 | .type = IIO_TEMP, |
95 | .address = HDC100X_REG_TEMP, |
96 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | |
97 | BIT(IIO_CHAN_INFO_SCALE) | |
98 | BIT(IIO_CHAN_INFO_INT_TIME) | |
99 | BIT(IIO_CHAN_INFO_OFFSET), |
100 | .scan_index = 0, |
101 | .scan_type = { |
102 | .sign = 's', |
103 | .realbits = 16, |
104 | .storagebits = 16, |
105 | .endianness = IIO_BE, |
106 | }, |
107 | }, |
108 | { |
109 | .type = IIO_HUMIDITYRELATIVE, |
110 | .address = HDC100X_REG_HUMIDITY, |
111 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | |
112 | BIT(IIO_CHAN_INFO_SCALE) | |
113 | BIT(IIO_CHAN_INFO_INT_TIME), |
114 | .scan_index = 1, |
115 | .scan_type = { |
116 | .sign = 'u', |
117 | .realbits = 16, |
118 | .storagebits = 16, |
119 | .endianness = IIO_BE, |
120 | }, |
121 | }, |
122 | { |
123 | .type = IIO_CURRENT, |
124 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
125 | .extend_name = "heater" , |
126 | .output = 1, |
127 | .scan_index = -1, |
128 | }, |
129 | IIO_CHAN_SOFT_TIMESTAMP(2), |
130 | }; |
131 | |
132 | static const unsigned long hdc100x_scan_masks[] = {0x3, 0}; |
133 | |
134 | static int hdc100x_update_config(struct hdc100x_data *data, int mask, int val) |
135 | { |
136 | int tmp = (~mask & data->config) | val; |
137 | int ret; |
138 | |
139 | ret = i2c_smbus_write_word_swapped(client: data->client, |
140 | HDC100X_REG_CONFIG, value: tmp); |
141 | if (!ret) |
142 | data->config = tmp; |
143 | |
144 | return ret; |
145 | } |
146 | |
147 | static int hdc100x_set_it_time(struct hdc100x_data *data, int chan, int val2) |
148 | { |
149 | int shift = hdc100x_resolution_shift[chan].shift; |
150 | int ret = -EINVAL; |
151 | int i; |
152 | |
153 | for (i = 0; i < ARRAY_SIZE(hdc100x_int_time[chan]); i++) { |
154 | if (val2 && val2 == hdc100x_int_time[chan][i]) { |
155 | ret = hdc100x_update_config(data, |
156 | mask: hdc100x_resolution_shift[chan].mask << shift, |
157 | val: i << shift); |
158 | if (!ret) |
159 | data->adc_int_us[chan] = val2; |
160 | break; |
161 | } |
162 | } |
163 | |
164 | return ret; |
165 | } |
166 | |
167 | static int hdc100x_get_measurement(struct hdc100x_data *data, |
168 | struct iio_chan_spec const *chan) |
169 | { |
170 | struct i2c_client *client = data->client; |
171 | int delay = data->adc_int_us[chan->address] + 1*USEC_PER_MSEC; |
172 | int ret; |
173 | __be16 val; |
174 | |
175 | /* start measurement */ |
176 | ret = i2c_smbus_write_byte(client, value: chan->address); |
177 | if (ret < 0) { |
178 | dev_err(&client->dev, "cannot start measurement" ); |
179 | return ret; |
180 | } |
181 | |
182 | /* wait for integration time to pass */ |
183 | usleep_range(min: delay, max: delay + 1000); |
184 | |
185 | /* read measurement */ |
186 | ret = i2c_master_recv(client: data->client, buf: (char *)&val, count: sizeof(val)); |
187 | if (ret < 0) { |
188 | dev_err(&client->dev, "cannot read sensor data\n" ); |
189 | return ret; |
190 | } |
191 | return be16_to_cpu(val); |
192 | } |
193 | |
194 | static int hdc100x_get_heater_status(struct hdc100x_data *data) |
195 | { |
196 | return !!(data->config & HDC100X_REG_CONFIG_HEATER_EN); |
197 | } |
198 | |
199 | static int hdc100x_read_raw(struct iio_dev *indio_dev, |
200 | struct iio_chan_spec const *chan, int *val, |
201 | int *val2, long mask) |
202 | { |
203 | struct hdc100x_data *data = iio_priv(indio_dev); |
204 | |
205 | switch (mask) { |
206 | case IIO_CHAN_INFO_RAW: { |
207 | int ret; |
208 | |
209 | mutex_lock(&data->lock); |
210 | if (chan->type == IIO_CURRENT) { |
211 | *val = hdc100x_get_heater_status(data); |
212 | ret = IIO_VAL_INT; |
213 | } else { |
214 | ret = iio_device_claim_direct_mode(indio_dev); |
215 | if (ret) { |
216 | mutex_unlock(lock: &data->lock); |
217 | return ret; |
218 | } |
219 | |
220 | ret = hdc100x_get_measurement(data, chan); |
221 | iio_device_release_direct_mode(indio_dev); |
222 | if (ret >= 0) { |
223 | *val = ret; |
224 | ret = IIO_VAL_INT; |
225 | } |
226 | } |
227 | mutex_unlock(lock: &data->lock); |
228 | return ret; |
229 | } |
230 | case IIO_CHAN_INFO_INT_TIME: |
231 | *val = 0; |
232 | *val2 = data->adc_int_us[chan->address]; |
233 | return IIO_VAL_INT_PLUS_MICRO; |
234 | case IIO_CHAN_INFO_SCALE: |
235 | if (chan->type == IIO_TEMP) { |
236 | *val = 165000; |
237 | *val2 = 65536; |
238 | return IIO_VAL_FRACTIONAL; |
239 | } else { |
240 | *val = 100000; |
241 | *val2 = 65536; |
242 | return IIO_VAL_FRACTIONAL; |
243 | } |
244 | break; |
245 | case IIO_CHAN_INFO_OFFSET: |
246 | *val = -15887; |
247 | *val2 = 515151; |
248 | return IIO_VAL_INT_PLUS_MICRO; |
249 | default: |
250 | return -EINVAL; |
251 | } |
252 | } |
253 | |
254 | static int hdc100x_write_raw(struct iio_dev *indio_dev, |
255 | struct iio_chan_spec const *chan, |
256 | int val, int val2, long mask) |
257 | { |
258 | struct hdc100x_data *data = iio_priv(indio_dev); |
259 | int ret = -EINVAL; |
260 | |
261 | switch (mask) { |
262 | case IIO_CHAN_INFO_INT_TIME: |
263 | if (val != 0) |
264 | return -EINVAL; |
265 | |
266 | mutex_lock(&data->lock); |
267 | ret = hdc100x_set_it_time(data, chan: chan->address, val2); |
268 | mutex_unlock(lock: &data->lock); |
269 | return ret; |
270 | case IIO_CHAN_INFO_RAW: |
271 | if (chan->type != IIO_CURRENT || val2 != 0) |
272 | return -EINVAL; |
273 | |
274 | mutex_lock(&data->lock); |
275 | ret = hdc100x_update_config(data, HDC100X_REG_CONFIG_HEATER_EN, |
276 | val: val ? HDC100X_REG_CONFIG_HEATER_EN : 0); |
277 | mutex_unlock(lock: &data->lock); |
278 | return ret; |
279 | default: |
280 | return -EINVAL; |
281 | } |
282 | } |
283 | |
284 | static int hdc100x_buffer_postenable(struct iio_dev *indio_dev) |
285 | { |
286 | struct hdc100x_data *data = iio_priv(indio_dev); |
287 | int ret; |
288 | |
289 | /* Buffer is enabled. First set ACQ Mode, then attach poll func */ |
290 | mutex_lock(&data->lock); |
291 | ret = hdc100x_update_config(data, HDC100X_REG_CONFIG_ACQ_MODE, |
292 | HDC100X_REG_CONFIG_ACQ_MODE); |
293 | mutex_unlock(lock: &data->lock); |
294 | |
295 | return ret; |
296 | } |
297 | |
298 | static int hdc100x_buffer_predisable(struct iio_dev *indio_dev) |
299 | { |
300 | struct hdc100x_data *data = iio_priv(indio_dev); |
301 | int ret; |
302 | |
303 | mutex_lock(&data->lock); |
304 | ret = hdc100x_update_config(data, HDC100X_REG_CONFIG_ACQ_MODE, val: 0); |
305 | mutex_unlock(lock: &data->lock); |
306 | |
307 | return ret; |
308 | } |
309 | |
310 | static const struct iio_buffer_setup_ops hdc_buffer_setup_ops = { |
311 | .postenable = hdc100x_buffer_postenable, |
312 | .predisable = hdc100x_buffer_predisable, |
313 | }; |
314 | |
315 | static irqreturn_t hdc100x_trigger_handler(int irq, void *p) |
316 | { |
317 | struct iio_poll_func *pf = p; |
318 | struct iio_dev *indio_dev = pf->indio_dev; |
319 | struct hdc100x_data *data = iio_priv(indio_dev); |
320 | struct i2c_client *client = data->client; |
321 | int delay = data->adc_int_us[0] + data->adc_int_us[1] + 2*USEC_PER_MSEC; |
322 | int ret; |
323 | |
324 | /* dual read starts at temp register */ |
325 | mutex_lock(&data->lock); |
326 | ret = i2c_smbus_write_byte(client, HDC100X_REG_TEMP); |
327 | if (ret < 0) { |
328 | dev_err(&client->dev, "cannot start measurement\n" ); |
329 | goto err; |
330 | } |
331 | usleep_range(min: delay, max: delay + 1000); |
332 | |
333 | ret = i2c_master_recv(client, buf: (u8 *)data->scan.channels, count: 4); |
334 | if (ret < 0) { |
335 | dev_err(&client->dev, "cannot read sensor data\n" ); |
336 | goto err; |
337 | } |
338 | |
339 | iio_push_to_buffers_with_timestamp(indio_dev, data: &data->scan, |
340 | timestamp: iio_get_time_ns(indio_dev)); |
341 | err: |
342 | mutex_unlock(lock: &data->lock); |
343 | iio_trigger_notify_done(trig: indio_dev->trig); |
344 | |
345 | return IRQ_HANDLED; |
346 | } |
347 | |
348 | static const struct iio_info hdc100x_info = { |
349 | .read_raw = hdc100x_read_raw, |
350 | .write_raw = hdc100x_write_raw, |
351 | .attrs = &hdc100x_attribute_group, |
352 | }; |
353 | |
354 | static int hdc100x_probe(struct i2c_client *client) |
355 | { |
356 | struct iio_dev *indio_dev; |
357 | struct hdc100x_data *data; |
358 | int ret; |
359 | |
360 | if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_SMBUS_WORD_DATA | |
361 | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_I2C)) |
362 | return -EOPNOTSUPP; |
363 | |
364 | indio_dev = devm_iio_device_alloc(parent: &client->dev, sizeof_priv: sizeof(*data)); |
365 | if (!indio_dev) |
366 | return -ENOMEM; |
367 | |
368 | data = iio_priv(indio_dev); |
369 | i2c_set_clientdata(client, data: indio_dev); |
370 | data->client = client; |
371 | mutex_init(&data->lock); |
372 | |
373 | indio_dev->name = dev_name(dev: &client->dev); |
374 | indio_dev->modes = INDIO_DIRECT_MODE; |
375 | indio_dev->info = &hdc100x_info; |
376 | |
377 | indio_dev->channels = hdc100x_channels; |
378 | indio_dev->num_channels = ARRAY_SIZE(hdc100x_channels); |
379 | indio_dev->available_scan_masks = hdc100x_scan_masks; |
380 | |
381 | /* be sure we are in a known state */ |
382 | hdc100x_set_it_time(data, chan: 0, val2: hdc100x_int_time[0][0]); |
383 | hdc100x_set_it_time(data, chan: 1, val2: hdc100x_int_time[1][0]); |
384 | hdc100x_update_config(data, HDC100X_REG_CONFIG_ACQ_MODE, val: 0); |
385 | |
386 | ret = devm_iio_triggered_buffer_setup(&client->dev, |
387 | indio_dev, NULL, |
388 | hdc100x_trigger_handler, |
389 | &hdc_buffer_setup_ops); |
390 | if (ret < 0) { |
391 | dev_err(&client->dev, "iio triggered buffer setup failed\n" ); |
392 | return ret; |
393 | } |
394 | |
395 | return devm_iio_device_register(&client->dev, indio_dev); |
396 | } |
397 | |
398 | static const struct i2c_device_id hdc100x_id[] = { |
399 | { "hdc100x" , 0 }, |
400 | { "hdc1000" , 0 }, |
401 | { "hdc1008" , 0 }, |
402 | { "hdc1010" , 0 }, |
403 | { "hdc1050" , 0 }, |
404 | { "hdc1080" , 0 }, |
405 | { } |
406 | }; |
407 | MODULE_DEVICE_TABLE(i2c, hdc100x_id); |
408 | |
409 | static const struct of_device_id hdc100x_dt_ids[] = { |
410 | { .compatible = "ti,hdc1000" }, |
411 | { .compatible = "ti,hdc1008" }, |
412 | { .compatible = "ti,hdc1010" }, |
413 | { .compatible = "ti,hdc1050" }, |
414 | { .compatible = "ti,hdc1080" }, |
415 | { } |
416 | }; |
417 | MODULE_DEVICE_TABLE(of, hdc100x_dt_ids); |
418 | |
419 | static const struct acpi_device_id hdc100x_acpi_match[] = { |
420 | { "TXNW1010" }, |
421 | { } |
422 | }; |
423 | MODULE_DEVICE_TABLE(acpi, hdc100x_acpi_match); |
424 | |
425 | static struct i2c_driver hdc100x_driver = { |
426 | .driver = { |
427 | .name = "hdc100x" , |
428 | .of_match_table = hdc100x_dt_ids, |
429 | .acpi_match_table = hdc100x_acpi_match, |
430 | }, |
431 | .probe = hdc100x_probe, |
432 | .id_table = hdc100x_id, |
433 | }; |
434 | module_i2c_driver(hdc100x_driver); |
435 | |
436 | MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>" ); |
437 | MODULE_DESCRIPTION("TI HDC100x humidity and temperature sensor driver" ); |
438 | MODULE_LICENSE("GPL" ); |
439 | |