Commit | Line | Data |
---|---|---|
505c2549 NSV |
1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | ||
3 | /* | |
4 | * Copyright (c) Linumiz 2021 | |
5 | * | |
6 | * sht4x.c - Linux hwmon driver for SHT4x Temperature and Humidity sensor | |
7 | * | |
8 | * Author: Navin Sankar Velliangiri <navin@linumiz.com> | |
9 | */ | |
10 | ||
11 | #include <linux/crc8.h> | |
12 | #include <linux/delay.h> | |
13 | #include <linux/hwmon.h> | |
14 | #include <linux/i2c.h> | |
15 | #include <linux/jiffies.h> | |
16 | #include <linux/module.h> | |
17 | ||
18 | /* | |
19 | * Poll intervals (in milliseconds) | |
20 | */ | |
21 | #define SHT4X_MIN_POLL_INTERVAL 2000 | |
22 | ||
23 | /* | |
24 | * I2C command delays (in microseconds) | |
25 | */ | |
0e4190d7 | 26 | #define SHT4X_MEAS_DELAY_HPM 8200 /* see t_MEAS,h in datasheet */ |
505c2549 NSV |
27 | #define SHT4X_DELAY_EXTRA 10000 |
28 | ||
29 | /* | |
30 | * Command Bytes | |
31 | */ | |
32 | #define SHT4X_CMD_MEASURE_HPM 0b11111101 | |
33 | #define SHT4X_CMD_RESET 0b10010100 | |
34 | ||
35 | #define SHT4X_CMD_LEN 1 | |
36 | #define SHT4X_CRC8_LEN 1 | |
37 | #define SHT4X_WORD_LEN 2 | |
38 | #define SHT4X_RESPONSE_LENGTH 6 | |
39 | #define SHT4X_CRC8_POLYNOMIAL 0x31 | |
40 | #define SHT4X_CRC8_INIT 0xff | |
41 | #define SHT4X_MIN_TEMPERATURE -45000 | |
42 | #define SHT4X_MAX_TEMPERATURE 125000 | |
43 | #define SHT4X_MIN_HUMIDITY 0 | |
44 | #define SHT4X_MAX_HUMIDITY 100000 | |
45 | ||
46 | DECLARE_CRC8_TABLE(sht4x_crc8_table); | |
47 | ||
48 | /** | |
49 | * struct sht4x_data - All the data required to operate an SHT4X chip | |
50 | * @client: the i2c client associated with the SHT4X | |
51 | * @lock: a mutex that is used to prevent parallel access to the i2c client | |
52 | * @update_interval: the minimum poll interval | |
53 | * @last_updated: the previous time that the SHT4X was polled | |
54 | * @temperature: the latest temperature value received from the SHT4X | |
55 | * @humidity: the latest humidity value received from the SHT4X | |
56 | */ | |
57 | struct sht4x_data { | |
58 | struct i2c_client *client; | |
59 | struct mutex lock; /* atomic read data updates */ | |
60 | bool valid; /* validity of fields below */ | |
61 | long update_interval; /* in milli-seconds */ | |
62 | long last_updated; /* in jiffies */ | |
63 | s32 temperature; | |
64 | s32 humidity; | |
65 | }; | |
66 | ||
67 | /** | |
68 | * sht4x_read_values() - read and parse the raw data from the SHT4X | |
69 | * @sht4x_data: the struct sht4x_data to use for the lock | |
07c6621a | 70 | * Return: 0 if successful, -ERRNO if not |
505c2549 NSV |
71 | */ |
72 | static int sht4x_read_values(struct sht4x_data *data) | |
73 | { | |
74 | int ret = 0; | |
75 | u16 t_ticks, rh_ticks; | |
76 | unsigned long next_update; | |
77 | struct i2c_client *client = data->client; | |
07c6621a JP |
78 | u8 crc; |
79 | u8 cmd[SHT4X_CMD_LEN] = {SHT4X_CMD_MEASURE_HPM}; | |
80 | u8 raw_data[SHT4X_RESPONSE_LENGTH]; | |
505c2549 NSV |
81 | |
82 | mutex_lock(&data->lock); | |
83 | next_update = data->last_updated + | |
84 | msecs_to_jiffies(data->update_interval); | |
07c6621a JP |
85 | |
86 | if (data->valid && time_before_eq(jiffies, next_update)) | |
87 | goto unlock; | |
88 | ||
89 | ret = i2c_master_send(client, cmd, SHT4X_CMD_LEN); | |
90 | if (ret < 0) | |
91 | goto unlock; | |
92 | ||
0e4190d7 | 93 | usleep_range(SHT4X_MEAS_DELAY_HPM, SHT4X_MEAS_DELAY_HPM + SHT4X_DELAY_EXTRA); |
07c6621a JP |
94 | |
95 | ret = i2c_master_recv(client, raw_data, SHT4X_RESPONSE_LENGTH); | |
96 | if (ret != SHT4X_RESPONSE_LENGTH) { | |
97 | if (ret >= 0) | |
98 | ret = -ENODATA; | |
99 | goto unlock; | |
505c2549 NSV |
100 | } |
101 | ||
07c6621a JP |
102 | t_ticks = raw_data[0] << 8 | raw_data[1]; |
103 | rh_ticks = raw_data[3] << 8 | raw_data[4]; | |
104 | ||
105 | crc = crc8(sht4x_crc8_table, &raw_data[0], SHT4X_WORD_LEN, CRC8_INIT_VALUE); | |
106 | if (crc != raw_data[2]) { | |
107 | dev_err(&client->dev, "data integrity check failed\n"); | |
108 | ret = -EIO; | |
109 | goto unlock; | |
110 | } | |
111 | ||
112 | crc = crc8(sht4x_crc8_table, &raw_data[3], SHT4X_WORD_LEN, CRC8_INIT_VALUE); | |
113 | if (crc != raw_data[5]) { | |
114 | dev_err(&client->dev, "data integrity check failed\n"); | |
115 | ret = -EIO; | |
116 | goto unlock; | |
117 | } | |
118 | ||
119 | data->temperature = ((21875 * (int32_t)t_ticks) >> 13) - 45000; | |
120 | data->humidity = ((15625 * (int32_t)rh_ticks) >> 13) - 6000; | |
121 | data->last_updated = jiffies; | |
122 | data->valid = true; | |
123 | ret = 0; | |
124 | ||
505c2549 NSV |
125 | unlock: |
126 | mutex_unlock(&data->lock); | |
127 | return ret; | |
128 | } | |
129 | ||
130 | static ssize_t sht4x_interval_write(struct sht4x_data *data, long val) | |
131 | { | |
f9c0cf8f | 132 | data->update_interval = clamp_val(val, SHT4X_MIN_POLL_INTERVAL, INT_MAX); |
505c2549 NSV |
133 | |
134 | return 0; | |
135 | } | |
136 | ||
07c6621a | 137 | /* sht4x_interval_read() - read the minimum poll interval in milliseconds */ |
505c2549 NSV |
138 | static size_t sht4x_interval_read(struct sht4x_data *data, long *val) |
139 | { | |
140 | *val = data->update_interval; | |
141 | return 0; | |
142 | } | |
143 | ||
07c6621a | 144 | /* sht4x_temperature1_read() - read the temperature in millidegrees */ |
505c2549 NSV |
145 | static int sht4x_temperature1_read(struct sht4x_data *data, long *val) |
146 | { | |
147 | int ret; | |
148 | ||
149 | ret = sht4x_read_values(data); | |
150 | if (ret < 0) | |
151 | return ret; | |
152 | ||
153 | *val = data->temperature; | |
154 | ||
155 | return 0; | |
156 | } | |
157 | ||
07c6621a | 158 | /* sht4x_humidity1_read() - read a relative humidity in millipercent */ |
505c2549 NSV |
159 | static int sht4x_humidity1_read(struct sht4x_data *data, long *val) |
160 | { | |
161 | int ret; | |
162 | ||
163 | ret = sht4x_read_values(data); | |
164 | if (ret < 0) | |
165 | return ret; | |
166 | ||
167 | *val = data->humidity; | |
168 | ||
169 | return 0; | |
170 | } | |
171 | ||
172 | static umode_t sht4x_hwmon_visible(const void *data, | |
173 | enum hwmon_sensor_types type, | |
174 | u32 attr, int channel) | |
175 | { | |
176 | switch (type) { | |
177 | case hwmon_temp: | |
178 | case hwmon_humidity: | |
179 | return 0444; | |
180 | case hwmon_chip: | |
181 | return 0644; | |
182 | default: | |
183 | return 0; | |
184 | } | |
185 | } | |
186 | ||
187 | static int sht4x_hwmon_read(struct device *dev, enum hwmon_sensor_types type, | |
188 | u32 attr, int channel, long *val) | |
189 | { | |
190 | struct sht4x_data *data = dev_get_drvdata(dev); | |
191 | ||
192 | switch (type) { | |
193 | case hwmon_temp: | |
194 | return sht4x_temperature1_read(data, val); | |
195 | case hwmon_humidity: | |
196 | return sht4x_humidity1_read(data, val); | |
197 | case hwmon_chip: | |
198 | return sht4x_interval_read(data, val); | |
199 | default: | |
200 | return -EOPNOTSUPP; | |
201 | } | |
202 | } | |
203 | ||
204 | static int sht4x_hwmon_write(struct device *dev, enum hwmon_sensor_types type, | |
205 | u32 attr, int channel, long val) | |
206 | { | |
207 | struct sht4x_data *data = dev_get_drvdata(dev); | |
208 | ||
209 | switch (type) { | |
210 | case hwmon_chip: | |
211 | return sht4x_interval_write(data, val); | |
212 | default: | |
213 | return -EOPNOTSUPP; | |
214 | } | |
215 | } | |
216 | ||
11c1dff5 | 217 | static const struct hwmon_channel_info * const sht4x_info[] = { |
505c2549 NSV |
218 | HWMON_CHANNEL_INFO(chip, HWMON_C_UPDATE_INTERVAL), |
219 | HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT), | |
220 | HWMON_CHANNEL_INFO(humidity, HWMON_H_INPUT), | |
221 | NULL, | |
222 | }; | |
223 | ||
224 | static const struct hwmon_ops sht4x_hwmon_ops = { | |
225 | .is_visible = sht4x_hwmon_visible, | |
226 | .read = sht4x_hwmon_read, | |
227 | .write = sht4x_hwmon_write, | |
228 | }; | |
229 | ||
230 | static const struct hwmon_chip_info sht4x_chip_info = { | |
231 | .ops = &sht4x_hwmon_ops, | |
232 | .info = sht4x_info, | |
233 | }; | |
234 | ||
deeab9ea | 235 | static int sht4x_probe(struct i2c_client *client) |
505c2549 NSV |
236 | { |
237 | struct device *device = &client->dev; | |
238 | struct device *hwmon_dev; | |
239 | struct sht4x_data *data; | |
240 | u8 cmd[] = {SHT4X_CMD_RESET}; | |
241 | int ret; | |
242 | ||
243 | /* | |
244 | * we require full i2c support since the sht4x uses multi-byte read and | |
245 | * writes as well as multi-byte commands which are not supported by | |
246 | * the smbus protocol | |
247 | */ | |
248 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) | |
249 | return -EOPNOTSUPP; | |
250 | ||
251 | data = devm_kzalloc(device, sizeof(*data), GFP_KERNEL); | |
252 | if (!data) | |
253 | return -ENOMEM; | |
254 | ||
255 | data->update_interval = SHT4X_MIN_POLL_INTERVAL; | |
256 | data->client = client; | |
257 | ||
258 | mutex_init(&data->lock); | |
259 | ||
260 | crc8_populate_msb(sht4x_crc8_table, SHT4X_CRC8_POLYNOMIAL); | |
261 | ||
262 | ret = i2c_master_send(client, cmd, SHT4X_CMD_LEN); | |
263 | if (ret < 0) | |
264 | return ret; | |
265 | if (ret != SHT4X_CMD_LEN) | |
266 | return -EIO; | |
267 | ||
268 | hwmon_dev = devm_hwmon_device_register_with_info(device, | |
269 | client->name, | |
270 | data, | |
271 | &sht4x_chip_info, | |
272 | NULL); | |
273 | ||
274 | return PTR_ERR_OR_ZERO(hwmon_dev); | |
275 | } | |
276 | ||
277 | static const struct i2c_device_id sht4x_id[] = { | |
278 | { "sht4x", 0 }, | |
279 | { }, | |
280 | }; | |
281 | MODULE_DEVICE_TABLE(i2c, sht4x_id); | |
282 | ||
62cfc057 DMT |
283 | static const struct of_device_id sht4x_of_match[] = { |
284 | { .compatible = "sensirion,sht4x" }, | |
285 | { } | |
286 | }; | |
287 | MODULE_DEVICE_TABLE(of, sht4x_of_match); | |
288 | ||
505c2549 NSV |
289 | static struct i2c_driver sht4x_driver = { |
290 | .driver = { | |
291 | .name = "sht4x", | |
62cfc057 | 292 | .of_match_table = sht4x_of_match, |
505c2549 | 293 | }, |
1975d167 | 294 | .probe = sht4x_probe, |
505c2549 NSV |
295 | .id_table = sht4x_id, |
296 | }; | |
297 | ||
298 | module_i2c_driver(sht4x_driver); | |
299 | ||
300 | MODULE_AUTHOR("Navin Sankar Velliangiri <navin@linumiz.com>"); | |
301 | MODULE_DESCRIPTION("Sensirion SHT4x humidity and temperature sensor driver"); | |
302 | MODULE_LICENSE("GPL v2"); |