1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Sensirion SHT3x-DIS humidity and temperature sensor driver.
3 * The SHT3x comes in many different versions, this driver is for the
4 * I2C version only.
5 *
6 * Copyright (C) 2016 Sensirion AG, Switzerland
7 * Author: David Frey <david.frey@sensirion.com>
8 * Author: Pascal Sachs <pascal.sachs@sensirion.com>
9 */
10
11 #include <asm/page.h>
12 #include <linux/crc8.h>
13 #include <linux/debugfs.h>
14 #include <linux/delay.h>
15 #include <linux/err.h>
16 #include <linux/hwmon.h>
17 #include <linux/hwmon-sysfs.h>
18 #include <linux/i2c.h>
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/jiffies.h>
24
25 /* commands (high repeatability mode) */
26 static const unsigned char sht3x_cmd_measure_single_hpm[] = { 0x24, 0x00 };
27
28 /* commands (medium repeatability mode) */
29 static const unsigned char sht3x_cmd_measure_single_mpm[] = { 0x24, 0x0b };
30
31 /* commands (low repeatability mode) */
32 static const unsigned char sht3x_cmd_measure_single_lpm[] = { 0x24, 0x16 };
33
34 /* commands for periodic mode */
35 static const unsigned char sht3x_cmd_measure_periodic_mode[] = { 0xe0, 0x00 };
36 static const unsigned char sht3x_cmd_break[] = { 0x30, 0x93 };
37
38 /* commands for heater control */
39 static const unsigned char sht3x_cmd_heater_on[] = { 0x30, 0x6d };
40 static const unsigned char sht3x_cmd_heater_off[] = { 0x30, 0x66 };
41
42 /* other commands */
43 static const unsigned char sht3x_cmd_read_status_reg[] = { 0xf3, 0x2d };
44 static const unsigned char sht3x_cmd_clear_status_reg[] = { 0x30, 0x41 };
45 static const unsigned char sht3x_cmd_read_serial_number[] = { 0x37, 0x80 };
46
47 /* delays for single-shot mode i2c commands, both in us */
48 #define SHT3X_SINGLE_WAIT_TIME_HPM 15000
49 #define SHT3X_SINGLE_WAIT_TIME_MPM 6000
50 #define SHT3X_SINGLE_WAIT_TIME_LPM 4000
51
52 #define SHT3X_WORD_LEN 2
53 #define SHT3X_CMD_LENGTH 2
54 #define SHT3X_CRC8_LEN 1
55 #define SHT3X_RESPONSE_LENGTH 6
56 #define SHT3X_CRC8_POLYNOMIAL 0x31
57 #define SHT3X_CRC8_INIT 0xFF
58 #define SHT3X_MIN_TEMPERATURE -45000
59 #define SHT3X_MAX_TEMPERATURE 130000
60 #define SHT3X_MIN_HUMIDITY 0
61 #define SHT3X_MAX_HUMIDITY 100000
62
63 enum sht3x_chips {
64 sht3x,
65 sts3x,
66 };
67
68 enum sht3x_limits {
69 limit_max = 0,
70 limit_max_hyst,
71 limit_min,
72 limit_min_hyst,
73 };
74
75 enum sht3x_repeatability {
76 low_repeatability,
77 medium_repeatability,
78 high_repeatability,
79 };
80
81 DECLARE_CRC8_TABLE(sht3x_crc8_table);
82
83 /* periodic measure commands (high repeatability mode) */
84 static const char periodic_measure_commands_hpm[][SHT3X_CMD_LENGTH] = {
85 /* 0.5 measurements per second */
86 {0x20, 0x32},
87 /* 1 measurements per second */
88 {0x21, 0x30},
89 /* 2 measurements per second */
90 {0x22, 0x36},
91 /* 4 measurements per second */
92 {0x23, 0x34},
93 /* 10 measurements per second */
94 {0x27, 0x37},
95 };
96
97 /* periodic measure commands (medium repeatability) */
98 static const char periodic_measure_commands_mpm[][SHT3X_CMD_LENGTH] = {
99 /* 0.5 measurements per second */
100 {0x20, 0x24},
101 /* 1 measurements per second */
102 {0x21, 0x26},
103 /* 2 measurements per second */
104 {0x22, 0x20},
105 /* 4 measurements per second */
106 {0x23, 0x22},
107 /* 10 measurements per second */
108 {0x27, 0x21},
109 };
110
111 /* periodic measure commands (low repeatability mode) */
112 static const char periodic_measure_commands_lpm[][SHT3X_CMD_LENGTH] = {
113 /* 0.5 measurements per second */
114 {0x20, 0x2f},
115 /* 1 measurements per second */
116 {0x21, 0x2d},
117 /* 2 measurements per second */
118 {0x22, 0x2b},
119 /* 4 measurements per second */
120 {0x23, 0x29},
121 /* 10 measurements per second */
122 {0x27, 0x2a},
123 };
124
125 struct sht3x_limit_commands {
126 const char read_command[SHT3X_CMD_LENGTH];
127 const char write_command[SHT3X_CMD_LENGTH];
128 };
129
130 static const struct sht3x_limit_commands limit_commands[] = {
131 /* temp1_max, humidity1_max */
132 [limit_max] = { {0xe1, 0x1f}, {0x61, 0x1d} },
133 /* temp_1_max_hyst, humidity1_max_hyst */
134 [limit_max_hyst] = { {0xe1, 0x14}, {0x61, 0x16} },
135 /* temp1_min, humidity1_min */
136 [limit_min] = { {0xe1, 0x02}, {0x61, 0x00} },
137 /* temp_1_min_hyst, humidity1_min_hyst */
138 [limit_min_hyst] = { {0xe1, 0x09}, {0x61, 0x0B} },
139 };
140
141 #define SHT3X_NUM_LIMIT_CMD ARRAY_SIZE(limit_commands)
142
143 static const u16 mode_to_update_interval[] = {
144 0,
145 2000,
146 1000,
147 500,
148 250,
149 100,
150 };
151
152 static const struct hwmon_channel_info * const sht3x_channel_info[] = {
153 HWMON_CHANNEL_INFO(chip, HWMON_C_UPDATE_INTERVAL),
154 HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT | HWMON_T_MIN |
155 HWMON_T_MIN_HYST | HWMON_T_MAX |
156 HWMON_T_MAX_HYST | HWMON_T_ALARM),
157 HWMON_CHANNEL_INFO(humidity, HWMON_H_INPUT | HWMON_H_MIN |
158 HWMON_H_MIN_HYST | HWMON_H_MAX |
159 HWMON_H_MAX_HYST | HWMON_H_ALARM),
160 NULL,
161 };
162
163 struct sht3x_data {
164 struct i2c_client *client;
165 enum sht3x_chips chip_id;
166 struct mutex i2c_lock; /* lock for sending i2c commands */
167 struct mutex data_lock; /* lock for updating driver data */
168
169 u8 mode;
170 const unsigned char *command;
171 u32 wait_time; /* in us*/
172 unsigned long last_update; /* last update in periodic mode*/
173 enum sht3x_repeatability repeatability;
174 u32 serial_number;
175
176 /*
177 * cached values for temperature and humidity and limits
178 * the limits arrays have the following order:
179 * max, max_hyst, min, min_hyst
180 */
181 int temperature;
182 int temperature_limits[SHT3X_NUM_LIMIT_CMD];
183 u32 humidity;
184 u32 humidity_limits[SHT3X_NUM_LIMIT_CMD];
185 };
186
get_mode_from_update_interval(u16 value)187 static u8 get_mode_from_update_interval(u16 value)
188 {
189 size_t index;
190 u8 number_of_modes = ARRAY_SIZE(mode_to_update_interval);
191
192 if (value == 0)
193 return 0;
194
195 /* find next faster update interval */
196 for (index = 1; index < number_of_modes; index++) {
197 if (mode_to_update_interval[index] <= value)
198 return index;
199 }
200
201 return number_of_modes - 1;
202 }
203
sht3x_read_from_command(struct i2c_client * client,struct sht3x_data * data,const char * command,char * buf,int length,u32 wait_time)204 static int sht3x_read_from_command(struct i2c_client *client,
205 struct sht3x_data *data,
206 const char *command,
207 char *buf, int length, u32 wait_time)
208 {
209 int ret;
210
211 mutex_lock(&data->i2c_lock);
212 ret = i2c_master_send(client, command, SHT3X_CMD_LENGTH);
213
214 if (ret != SHT3X_CMD_LENGTH) {
215 ret = ret < 0 ? ret : -EIO;
216 goto out;
217 }
218
219 if (wait_time)
220 usleep_range(wait_time, wait_time + 1000);
221
222 ret = i2c_master_recv(client, buf, length);
223 if (ret != length) {
224 ret = ret < 0 ? ret : -EIO;
225 goto out;
226 }
227
228 ret = 0;
229 out:
230 mutex_unlock(&data->i2c_lock);
231 return ret;
232 }
233
sht3x_extract_temperature(u16 raw)234 static int sht3x_extract_temperature(u16 raw)
235 {
236 /*
237 * From datasheet:
238 * T = -45 + 175 * ST / 2^16
239 * Adapted for integer fixed point (3 digit) arithmetic.
240 */
241 return ((21875 * (int)raw) >> 13) - 45000;
242 }
243
sht3x_extract_humidity(u16 raw)244 static u32 sht3x_extract_humidity(u16 raw)
245 {
246 /*
247 * From datasheet:
248 * RH = 100 * SRH / 2^16
249 * Adapted for integer fixed point (3 digit) arithmetic.
250 */
251 return (12500 * (u32)raw) >> 13;
252 }
253
sht3x_update_client(struct device * dev)254 static struct sht3x_data *sht3x_update_client(struct device *dev)
255 {
256 struct sht3x_data *data = dev_get_drvdata(dev);
257 struct i2c_client *client = data->client;
258 u16 interval_ms = mode_to_update_interval[data->mode];
259 unsigned long interval_jiffies = msecs_to_jiffies(interval_ms);
260 unsigned char buf[SHT3X_RESPONSE_LENGTH];
261 u16 val;
262 int ret = 0;
263
264 mutex_lock(&data->data_lock);
265 /*
266 * Only update cached readings once per update interval in periodic
267 * mode. In single shot mode the sensor measures values on demand, so
268 * every time the sysfs interface is called, a measurement is triggered.
269 * In periodic mode however, the measurement process is handled
270 * internally by the sensor and reading out sensor values only makes
271 * sense if a new reading is available.
272 */
273 if (time_after(jiffies, data->last_update + interval_jiffies)) {
274 ret = sht3x_read_from_command(client, data, data->command, buf,
275 sizeof(buf), data->wait_time);
276 if (ret)
277 goto out;
278
279 val = be16_to_cpup((__be16 *)buf);
280 data->temperature = sht3x_extract_temperature(val);
281 val = be16_to_cpup((__be16 *)(buf + 3));
282 data->humidity = sht3x_extract_humidity(val);
283 data->last_update = jiffies;
284 }
285
286 out:
287 mutex_unlock(&data->data_lock);
288 if (ret)
289 return ERR_PTR(ret);
290
291 return data;
292 }
293
temp1_input_read(struct device * dev,long * temp)294 static int temp1_input_read(struct device *dev, long *temp)
295 {
296 struct sht3x_data *data = sht3x_update_client(dev);
297
298 if (IS_ERR(data))
299 return PTR_ERR(data);
300
301 *temp = data->temperature;
302 return 0;
303 }
304
humidity1_input_read(struct device * dev,long * humidity)305 static int humidity1_input_read(struct device *dev, long *humidity)
306 {
307 struct sht3x_data *data = sht3x_update_client(dev);
308
309 if (IS_ERR(data))
310 return PTR_ERR(data);
311
312 *humidity = data->humidity;
313 return 0;
314 }
315
316 /*
317 * limits_update must only be called from probe or with data_lock held
318 */
limits_update(struct sht3x_data * data)319 static int limits_update(struct sht3x_data *data)
320 {
321 int ret;
322 u8 index;
323 int temperature;
324 u32 humidity;
325 u16 raw;
326 char buffer[SHT3X_RESPONSE_LENGTH];
327 const struct sht3x_limit_commands *commands;
328 struct i2c_client *client = data->client;
329
330 for (index = 0; index < SHT3X_NUM_LIMIT_CMD; index++) {
331 commands = &limit_commands[index];
332 ret = sht3x_read_from_command(client, data,
333 commands->read_command, buffer,
334 SHT3X_RESPONSE_LENGTH, 0);
335
336 if (ret)
337 return ret;
338
339 raw = be16_to_cpup((__be16 *)buffer);
340 temperature = sht3x_extract_temperature((raw & 0x01ff) << 7);
341 humidity = sht3x_extract_humidity(raw & 0xfe00);
342 data->temperature_limits[index] = temperature;
343 data->humidity_limits[index] = humidity;
344 }
345
346 return ret;
347 }
348
temp1_limit_read(struct device * dev,int index)349 static int temp1_limit_read(struct device *dev, int index)
350 {
351 struct sht3x_data *data = dev_get_drvdata(dev);
352
353 return data->temperature_limits[index];
354 }
355
humidity1_limit_read(struct device * dev,int index)356 static int humidity1_limit_read(struct device *dev, int index)
357 {
358 struct sht3x_data *data = dev_get_drvdata(dev);
359
360 return data->humidity_limits[index];
361 }
362
363 /*
364 * limit_write must only be called with data_lock held
365 */
limit_write(struct device * dev,u8 index,int temperature,u32 humidity)366 static size_t limit_write(struct device *dev,
367 u8 index,
368 int temperature,
369 u32 humidity)
370 {
371 char buffer[SHT3X_CMD_LENGTH + SHT3X_WORD_LEN + SHT3X_CRC8_LEN];
372 char *position = buffer;
373 int ret;
374 u16 raw;
375 struct sht3x_data *data = dev_get_drvdata(dev);
376 struct i2c_client *client = data->client;
377 const struct sht3x_limit_commands *commands;
378
379 commands = &limit_commands[index];
380
381 memcpy(position, commands->write_command, SHT3X_CMD_LENGTH);
382 position += SHT3X_CMD_LENGTH;
383 /*
384 * ST = (T + 45) / 175 * 2^16
385 * SRH = RH / 100 * 2^16
386 * adapted for fixed point arithmetic and packed the same as
387 * in limit_read()
388 */
389 raw = ((u32)(temperature + 45000) * 24543) >> (16 + 7);
390 raw |= ((humidity * 42950) >> 16) & 0xfe00;
391
392 *((__be16 *)position) = cpu_to_be16(raw);
393 position += SHT3X_WORD_LEN;
394 *position = crc8(sht3x_crc8_table,
395 position - SHT3X_WORD_LEN,
396 SHT3X_WORD_LEN,
397 SHT3X_CRC8_INIT);
398
399 mutex_lock(&data->i2c_lock);
400 ret = i2c_master_send(client, buffer, sizeof(buffer));
401 mutex_unlock(&data->i2c_lock);
402
403 if (ret != sizeof(buffer))
404 return ret < 0 ? ret : -EIO;
405
406 data->temperature_limits[index] = temperature;
407 data->humidity_limits[index] = humidity;
408
409 return 0;
410 }
411
temp1_limit_write(struct device * dev,int index,int val)412 static int temp1_limit_write(struct device *dev, int index, int val)
413 {
414 int temperature;
415 int ret;
416 struct sht3x_data *data = dev_get_drvdata(dev);
417
418 temperature = clamp_val(val, SHT3X_MIN_TEMPERATURE,
419 SHT3X_MAX_TEMPERATURE);
420 mutex_lock(&data->data_lock);
421 ret = limit_write(dev, index, temperature,
422 data->humidity_limits[index]);
423 mutex_unlock(&data->data_lock);
424
425 return ret;
426 }
427
humidity1_limit_write(struct device * dev,int index,int val)428 static int humidity1_limit_write(struct device *dev, int index, int val)
429 {
430 u32 humidity;
431 int ret;
432 struct sht3x_data *data = dev_get_drvdata(dev);
433
434 humidity = clamp_val(val, SHT3X_MIN_HUMIDITY, SHT3X_MAX_HUMIDITY);
435 mutex_lock(&data->data_lock);
436 ret = limit_write(dev, index, data->temperature_limits[index],
437 humidity);
438 mutex_unlock(&data->data_lock);
439
440 return ret;
441 }
442
sht3x_select_command(struct sht3x_data * data)443 static void sht3x_select_command(struct sht3x_data *data)
444 {
445 /*
446 * For single-shot mode, only non blocking mode is support,
447 * we have to wait ourselves for result.
448 */
449 if (data->mode > 0) {
450 data->command = sht3x_cmd_measure_periodic_mode;
451 data->wait_time = 0;
452 } else {
453 if (data->repeatability == high_repeatability) {
454 data->command = sht3x_cmd_measure_single_hpm;
455 data->wait_time = SHT3X_SINGLE_WAIT_TIME_HPM;
456 } else if (data->repeatability == medium_repeatability) {
457 data->command = sht3x_cmd_measure_single_mpm;
458 data->wait_time = SHT3X_SINGLE_WAIT_TIME_MPM;
459 } else {
460 data->command = sht3x_cmd_measure_single_lpm;
461 data->wait_time = SHT3X_SINGLE_WAIT_TIME_LPM;
462 }
463 }
464 }
465
status_register_read(struct device * dev,char * buffer,int length)466 static int status_register_read(struct device *dev,
467 char *buffer, int length)
468 {
469 int ret;
470 struct sht3x_data *data = dev_get_drvdata(dev);
471 struct i2c_client *client = data->client;
472
473 ret = sht3x_read_from_command(client, data, sht3x_cmd_read_status_reg,
474 buffer, length, 0);
475
476 return ret;
477 }
478
temp1_alarm_read(struct device * dev)479 static int temp1_alarm_read(struct device *dev)
480 {
481 char buffer[SHT3X_WORD_LEN + SHT3X_CRC8_LEN];
482 int ret;
483
484 ret = status_register_read(dev, buffer,
485 SHT3X_WORD_LEN + SHT3X_CRC8_LEN);
486 if (ret)
487 return ret;
488
489 return !!(buffer[0] & 0x04);
490 }
491
humidity1_alarm_read(struct device * dev)492 static int humidity1_alarm_read(struct device *dev)
493 {
494 char buffer[SHT3X_WORD_LEN + SHT3X_CRC8_LEN];
495 int ret;
496
497 ret = status_register_read(dev, buffer,
498 SHT3X_WORD_LEN + SHT3X_CRC8_LEN);
499 if (ret)
500 return ret;
501
502 return !!(buffer[0] & 0x08);
503 }
504
heater_enable_show(struct device * dev,struct device_attribute * attr,char * buf)505 static ssize_t heater_enable_show(struct device *dev,
506 struct device_attribute *attr,
507 char *buf)
508 {
509 char buffer[SHT3X_WORD_LEN + SHT3X_CRC8_LEN];
510 int ret;
511
512 ret = status_register_read(dev, buffer,
513 SHT3X_WORD_LEN + SHT3X_CRC8_LEN);
514 if (ret)
515 return ret;
516
517 return sysfs_emit(buf, "%d\n", !!(buffer[0] & 0x20));
518 }
519
heater_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)520 static ssize_t heater_enable_store(struct device *dev,
521 struct device_attribute *attr,
522 const char *buf,
523 size_t count)
524 {
525 struct sht3x_data *data = dev_get_drvdata(dev);
526 struct i2c_client *client = data->client;
527 int ret;
528 bool status;
529
530 ret = kstrtobool(buf, &status);
531 if (ret)
532 return ret;
533
534 mutex_lock(&data->i2c_lock);
535
536 if (status)
537 ret = i2c_master_send(client, (char *)&sht3x_cmd_heater_on,
538 SHT3X_CMD_LENGTH);
539 else
540 ret = i2c_master_send(client, (char *)&sht3x_cmd_heater_off,
541 SHT3X_CMD_LENGTH);
542
543 mutex_unlock(&data->i2c_lock);
544
545 return ret;
546 }
547
update_interval_read(struct device * dev)548 static int update_interval_read(struct device *dev)
549 {
550 struct sht3x_data *data = dev_get_drvdata(dev);
551
552 return mode_to_update_interval[data->mode];
553 }
554
update_interval_write(struct device * dev,int val)555 static int update_interval_write(struct device *dev, int val)
556 {
557 u8 mode;
558 int ret;
559 const char *command;
560 struct sht3x_data *data = dev_get_drvdata(dev);
561 struct i2c_client *client = data->client;
562
563 mode = get_mode_from_update_interval(val);
564
565 mutex_lock(&data->data_lock);
566 /* mode did not change */
567 if (mode == data->mode) {
568 mutex_unlock(&data->data_lock);
569 return 0;
570 }
571
572 mutex_lock(&data->i2c_lock);
573 /*
574 * Abort periodic measure mode.
575 * To do any changes to the configuration while in periodic mode, we
576 * have to send a break command to the sensor, which then falls back
577 * to single shot (mode = 0).
578 */
579 if (data->mode > 0) {
580 ret = i2c_master_send(client, sht3x_cmd_break,
581 SHT3X_CMD_LENGTH);
582 if (ret != SHT3X_CMD_LENGTH)
583 goto out;
584 data->mode = 0;
585 }
586
587 if (mode > 0) {
588 if (data->repeatability == high_repeatability)
589 command = periodic_measure_commands_hpm[mode - 1];
590 else if (data->repeatability == medium_repeatability)
591 command = periodic_measure_commands_mpm[mode - 1];
592 else
593 command = periodic_measure_commands_lpm[mode - 1];
594
595 /* select mode */
596 ret = i2c_master_send(client, command, SHT3X_CMD_LENGTH);
597 if (ret != SHT3X_CMD_LENGTH)
598 goto out;
599 }
600
601 /* select mode and command */
602 data->mode = mode;
603 sht3x_select_command(data);
604
605 out:
606 mutex_unlock(&data->i2c_lock);
607 mutex_unlock(&data->data_lock);
608 if (ret != SHT3X_CMD_LENGTH)
609 return ret < 0 ? ret : -EIO;
610
611 return 0;
612 }
613
repeatability_show(struct device * dev,struct device_attribute * attr,char * buf)614 static ssize_t repeatability_show(struct device *dev,
615 struct device_attribute *attr,
616 char *buf)
617 {
618 struct sht3x_data *data = dev_get_drvdata(dev);
619
620 return sysfs_emit(buf, "%d\n", data->repeatability);
621 }
622
repeatability_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)623 static ssize_t repeatability_store(struct device *dev,
624 struct device_attribute *attr,
625 const char *buf,
626 size_t count)
627 {
628 int ret;
629 u8 val;
630
631 struct sht3x_data *data = dev_get_drvdata(dev);
632
633 ret = kstrtou8(buf, 0, &val);
634 if (ret)
635 return ret;
636
637 if (val > 2)
638 return -EINVAL;
639
640 data->repeatability = val;
641
642 return count;
643 }
644
645 static SENSOR_DEVICE_ATTR_RW(heater_enable, heater_enable, 0);
646 static SENSOR_DEVICE_ATTR_RW(repeatability, repeatability, 0);
647
648 static struct attribute *sht3x_attrs[] = {
649 &sensor_dev_attr_heater_enable.dev_attr.attr,
650 &sensor_dev_attr_repeatability.dev_attr.attr,
651 NULL
652 };
653
654 ATTRIBUTE_GROUPS(sht3x);
655
sht3x_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)656 static umode_t sht3x_is_visible(const void *data, enum hwmon_sensor_types type,
657 u32 attr, int channel)
658 {
659 const struct sht3x_data *chip_data = data;
660
661 switch (type) {
662 case hwmon_chip:
663 switch (attr) {
664 case hwmon_chip_update_interval:
665 return 0644;
666 default:
667 break;
668 }
669 break;
670 case hwmon_temp:
671 switch (attr) {
672 case hwmon_temp_input:
673 case hwmon_temp_alarm:
674 return 0444;
675 case hwmon_temp_max:
676 case hwmon_temp_max_hyst:
677 case hwmon_temp_min:
678 case hwmon_temp_min_hyst:
679 return 0644;
680 default:
681 break;
682 }
683 break;
684 case hwmon_humidity:
685 if (chip_data->chip_id == sts3x)
686 break;
687 switch (attr) {
688 case hwmon_humidity_input:
689 case hwmon_humidity_alarm:
690 return 0444;
691 case hwmon_humidity_max:
692 case hwmon_humidity_max_hyst:
693 case hwmon_humidity_min:
694 case hwmon_humidity_min_hyst:
695 return 0644;
696 default:
697 break;
698 }
699 break;
700 default:
701 break;
702 }
703
704 return 0;
705 }
706
sht3x_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)707 static int sht3x_read(struct device *dev, enum hwmon_sensor_types type,
708 u32 attr, int channel, long *val)
709 {
710 enum sht3x_limits index;
711 int ret;
712
713 switch (type) {
714 case hwmon_chip:
715 switch (attr) {
716 case hwmon_chip_update_interval:
717 *val = update_interval_read(dev);
718 break;
719 default:
720 return -EOPNOTSUPP;
721 }
722 break;
723 case hwmon_temp:
724 switch (attr) {
725 case hwmon_temp_input:
726 return temp1_input_read(dev, val);
727 case hwmon_temp_alarm:
728 ret = temp1_alarm_read(dev);
729 if (ret < 0)
730 return ret;
731 *val = ret;
732 break;
733 case hwmon_temp_max:
734 index = limit_max;
735 *val = temp1_limit_read(dev, index);
736 break;
737 case hwmon_temp_max_hyst:
738 index = limit_max_hyst;
739 *val = temp1_limit_read(dev, index);
740 break;
741 case hwmon_temp_min:
742 index = limit_min;
743 *val = temp1_limit_read(dev, index);
744 break;
745 case hwmon_temp_min_hyst:
746 index = limit_min_hyst;
747 *val = temp1_limit_read(dev, index);
748 break;
749 default:
750 return -EOPNOTSUPP;
751 }
752 break;
753 case hwmon_humidity:
754 switch (attr) {
755 case hwmon_humidity_input:
756 return humidity1_input_read(dev, val);
757 case hwmon_humidity_alarm:
758 ret = humidity1_alarm_read(dev);
759 if (ret < 0)
760 return ret;
761 *val = ret;
762 break;
763 case hwmon_humidity_max:
764 index = limit_max;
765 *val = humidity1_limit_read(dev, index);
766 break;
767 case hwmon_humidity_max_hyst:
768 index = limit_max_hyst;
769 *val = humidity1_limit_read(dev, index);
770 break;
771 case hwmon_humidity_min:
772 index = limit_min;
773 *val = humidity1_limit_read(dev, index);
774 break;
775 case hwmon_humidity_min_hyst:
776 index = limit_min_hyst;
777 *val = humidity1_limit_read(dev, index);
778 break;
779 default:
780 return -EOPNOTSUPP;
781 }
782 break;
783 default:
784 return -EOPNOTSUPP;
785 }
786
787 return 0;
788 }
789
sht3x_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)790 static int sht3x_write(struct device *dev, enum hwmon_sensor_types type,
791 u32 attr, int channel, long val)
792 {
793 enum sht3x_limits index;
794
795 switch (type) {
796 case hwmon_chip:
797 switch (attr) {
798 case hwmon_chip_update_interval:
799 return update_interval_write(dev, val);
800 default:
801 return -EOPNOTSUPP;
802 }
803 case hwmon_temp:
804 switch (attr) {
805 case hwmon_temp_max:
806 index = limit_max;
807 break;
808 case hwmon_temp_max_hyst:
809 index = limit_max_hyst;
810 break;
811 case hwmon_temp_min:
812 index = limit_min;
813 break;
814 case hwmon_temp_min_hyst:
815 index = limit_min_hyst;
816 break;
817 default:
818 return -EOPNOTSUPP;
819 }
820 return temp1_limit_write(dev, index, val);
821 case hwmon_humidity:
822 switch (attr) {
823 case hwmon_humidity_max:
824 index = limit_max;
825 break;
826 case hwmon_humidity_max_hyst:
827 index = limit_max_hyst;
828 break;
829 case hwmon_humidity_min:
830 index = limit_min;
831 break;
832 case hwmon_humidity_min_hyst:
833 index = limit_min_hyst;
834 break;
835 default:
836 return -EOPNOTSUPP;
837 }
838 return humidity1_limit_write(dev, index, val);
839 default:
840 return -EOPNOTSUPP;
841 }
842 }
843
sht3x_serial_number_read(struct sht3x_data * data)844 static void sht3x_serial_number_read(struct sht3x_data *data)
845 {
846 int ret;
847 char buffer[SHT3X_RESPONSE_LENGTH];
848 struct i2c_client *client = data->client;
849
850 ret = sht3x_read_from_command(client, data,
851 sht3x_cmd_read_serial_number,
852 buffer,
853 SHT3X_RESPONSE_LENGTH, 0);
854 if (ret)
855 return;
856
857 data->serial_number = (buffer[0] << 24) | (buffer[1] << 16) |
858 (buffer[3] << 8) | buffer[4];
859
860 debugfs_create_u32("serial_number", 0444, client->debugfs, &data->serial_number);
861 }
862
863 static const struct hwmon_ops sht3x_ops = {
864 .is_visible = sht3x_is_visible,
865 .read = sht3x_read,
866 .write = sht3x_write,
867 };
868
869 static const struct hwmon_chip_info sht3x_chip_info = {
870 .ops = &sht3x_ops,
871 .info = sht3x_channel_info,
872 };
873
sht3x_probe(struct i2c_client * client)874 static int sht3x_probe(struct i2c_client *client)
875 {
876 int ret;
877 struct sht3x_data *data;
878 struct device *hwmon_dev;
879 struct i2c_adapter *adap = client->adapter;
880 struct device *dev = &client->dev;
881
882 /*
883 * we require full i2c support since the sht3x uses multi-byte read and
884 * writes as well as multi-byte commands which are not supported by
885 * the smbus protocol
886 */
887 if (!i2c_check_functionality(adap, I2C_FUNC_I2C))
888 return -ENODEV;
889
890 ret = i2c_master_send(client, sht3x_cmd_clear_status_reg,
891 SHT3X_CMD_LENGTH);
892 if (ret != SHT3X_CMD_LENGTH)
893 return ret < 0 ? ret : -ENODEV;
894
895 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
896 if (!data)
897 return -ENOMEM;
898
899 data->repeatability = high_repeatability;
900 data->mode = 0;
901 data->last_update = jiffies - msecs_to_jiffies(3000);
902 data->client = client;
903 data->chip_id = (uintptr_t)i2c_get_match_data(client);
904 crc8_populate_msb(sht3x_crc8_table, SHT3X_CRC8_POLYNOMIAL);
905
906 sht3x_select_command(data);
907
908 mutex_init(&data->i2c_lock);
909 mutex_init(&data->data_lock);
910
911 /*
912 * An attempt to read limits register too early
913 * causes a NACK response from the chip.
914 * Waiting for an empirical delay of 500 us solves the issue.
915 */
916 usleep_range(500, 600);
917
918 ret = limits_update(data);
919 if (ret)
920 return ret;
921
922 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, data,
923 &sht3x_chip_info, sht3x_groups);
924 if (IS_ERR(hwmon_dev))
925 return PTR_ERR(hwmon_dev);
926
927 sht3x_serial_number_read(data);
928
929 return 0;
930 }
931
932 /* device ID table */
933 static const struct i2c_device_id sht3x_ids[] = {
934 {"sht3x", sht3x},
935 {"sts3x", sts3x},
936 {}
937 };
938
939 MODULE_DEVICE_TABLE(i2c, sht3x_ids);
940
941 static struct i2c_driver sht3x_i2c_driver = {
942 .driver.name = "sht3x",
943 .probe = sht3x_probe,
944 .id_table = sht3x_ids,
945 };
946 module_i2c_driver(sht3x_i2c_driver);
947
948 MODULE_AUTHOR("David Frey <david.frey@sensirion.com>");
949 MODULE_AUTHOR("Pascal Sachs <pascal.sachs@sensirion.com>");
950 MODULE_DESCRIPTION("Sensirion SHT3x humidity and temperature sensor driver");
951 MODULE_LICENSE("GPL");
952