Lines Matching +full:per +full:- +full:device
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Sensirion SHT3x-DIS humidity and temperature sensor driver.
17 #include <linux/hwmon-sysfs.h>
47 /* delays for single-shot mode i2c commands, both in us */
58 #define SHT3X_MIN_TEMPERATURE -45000
85 /* 0.5 measurements per second */
87 /* 1 measurements per second */
89 /* 2 measurements per second */
91 /* 4 measurements per second */
93 /* 10 measurements per second */
99 /* 0.5 measurements per second */
101 /* 1 measurements per second */
103 /* 2 measurements per second */
105 /* 4 measurements per second */
107 /* 10 measurements per second */
113 /* 0.5 measurements per second */
115 /* 1 measurements per second */
117 /* 2 measurements per second */
119 /* 4 measurements per second */
121 /* 10 measurements per second */
201 return number_of_modes - 1;
211 mutex_lock(&data->i2c_lock);
215 ret = ret < 0 ? ret : -EIO;
224 ret = ret < 0 ? ret : -EIO;
230 mutex_unlock(&data->i2c_lock);
238 * T = -45 + 175 * ST / 2^16
241 return ((21875 * (int)raw) >> 13) - 45000;
254 static struct sht3x_data *sht3x_update_client(struct device *dev)
257 struct i2c_client *client = data->client;
258 u16 interval_ms = mode_to_update_interval[data->mode];
264 mutex_lock(&data->data_lock);
266 * Only update cached readings once per update interval in periodic
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);
280 data->temperature = sht3x_extract_temperature(val);
282 data->humidity = sht3x_extract_humidity(val);
283 data->last_update = jiffies;
287 mutex_unlock(&data->data_lock);
294 static int temp1_input_read(struct device *dev)
301 return data->temperature;
304 static int humidity1_input_read(struct device *dev)
311 return data->humidity;
326 struct i2c_client *client = data->client;
331 commands->read_command, buffer,
340 data->temperature_limits[index] = temperature;
341 data->humidity_limits[index] = humidity;
347 static int temp1_limit_read(struct device *dev, int index)
351 return data->temperature_limits[index];
354 static int humidity1_limit_read(struct device *dev, int index)
358 return data->humidity_limits[index];
364 static size_t limit_write(struct device *dev,
374 struct i2c_client *client = data->client;
379 memcpy(position, commands->write_command, SHT3X_CMD_LENGTH);
393 position - SHT3X_WORD_LEN,
397 mutex_lock(&data->i2c_lock);
399 mutex_unlock(&data->i2c_lock);
402 return ret < 0 ? ret : -EIO;
404 data->temperature_limits[index] = temperature;
405 data->humidity_limits[index] = humidity;
410 static int temp1_limit_write(struct device *dev, int index, int val)
418 mutex_lock(&data->data_lock);
420 data->humidity_limits[index]);
421 mutex_unlock(&data->data_lock);
426 static int humidity1_limit_write(struct device *dev, int index, int val)
433 mutex_lock(&data->data_lock);
434 ret = limit_write(dev, index, data->temperature_limits[index],
436 mutex_unlock(&data->data_lock);
444 * For single-shot mode, only non blocking mode is support,
447 if (data->mode > 0) {
448 data->command = sht3x_cmd_measure_periodic_mode;
449 data->wait_time = 0;
451 if (data->repeatability == high_repeatability) {
452 data->command = sht3x_cmd_measure_single_hpm;
453 data->wait_time = SHT3X_SINGLE_WAIT_TIME_HPM;
454 } else if (data->repeatability == medium_repeatability) {
455 data->command = sht3x_cmd_measure_single_mpm;
456 data->wait_time = SHT3X_SINGLE_WAIT_TIME_MPM;
458 data->command = sht3x_cmd_measure_single_lpm;
459 data->wait_time = SHT3X_SINGLE_WAIT_TIME_LPM;
464 static int status_register_read(struct device *dev,
469 struct i2c_client *client = data->client;
477 static int temp1_alarm_read(struct device *dev)
490 static int humidity1_alarm_read(struct device *dev)
503 static ssize_t heater_enable_show(struct device *dev,
518 static ssize_t heater_enable_store(struct device *dev,
524 struct i2c_client *client = data->client;
532 mutex_lock(&data->i2c_lock);
541 mutex_unlock(&data->i2c_lock);
546 static int update_interval_read(struct device *dev)
550 return mode_to_update_interval[data->mode];
553 static int update_interval_write(struct device *dev, int val)
559 struct i2c_client *client = data->client;
563 mutex_lock(&data->data_lock);
565 if (mode == data->mode) {
566 mutex_unlock(&data->data_lock);
570 mutex_lock(&data->i2c_lock);
577 if (data->mode > 0) {
582 data->mode = 0;
586 if (data->repeatability == high_repeatability)
587 command = periodic_measure_commands_hpm[mode - 1];
588 else if (data->repeatability == medium_repeatability)
589 command = periodic_measure_commands_mpm[mode - 1];
591 command = periodic_measure_commands_lpm[mode - 1];
600 data->mode = mode;
604 mutex_unlock(&data->i2c_lock);
605 mutex_unlock(&data->data_lock);
607 return ret < 0 ? ret : -EIO;
612 static ssize_t repeatability_show(struct device *dev,
618 return sysfs_emit(buf, "%d\n", data->repeatability);
621 static ssize_t repeatability_store(struct device *dev,
636 return -EINVAL;
638 data->repeatability = val;
683 if (chip_data->chip_id == sts3x)
705 static int sht3x_read(struct device *dev, enum hwmon_sensor_types type,
717 return -EOPNOTSUPP;
745 return -EOPNOTSUPP;
773 return -EOPNOTSUPP;
777 return -EOPNOTSUPP;
783 static int sht3x_write(struct device *dev, enum hwmon_sensor_types type,
794 return -EOPNOTSUPP;
811 return -EOPNOTSUPP;
829 return -EOPNOTSUPP;
833 return -EOPNOTSUPP;
841 struct i2c_client *client = data->client;
850 data->serial_number = (buffer[0] << 24) | (buffer[1] << 16) |
853 debugfs_create_u32("serial_number", 0444, client->debugfs, &data->serial_number);
871 struct device *hwmon_dev;
872 struct i2c_adapter *adap = client->adapter;
873 struct device *dev = &client->dev;
876 * we require full i2c support since the sht3x uses multi-byte read and
877 * writes as well as multi-byte commands which are not supported by
881 return -ENODEV;
886 return ret < 0 ? ret : -ENODEV;
890 return -ENOMEM;
892 data->repeatability = high_repeatability;
893 data->mode = 0;
894 data->last_update = jiffies - msecs_to_jiffies(3000);
895 data->client = client;
896 data->chip_id = (uintptr_t)i2c_get_match_data(client);
901 mutex_init(&data->i2c_lock);
902 mutex_init(&data->data_lock);
915 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, data,
925 /* device ID table */