Commit c55dc91e authored by Lars-Peter Clausen's avatar Lars-Peter Clausen Committed by Guenter Roeck
Browse files

hwmon: (adt7410) Don't re-read non-volatile registers 



Currently each time the temperature register is read the driver also reads the
threshold and hysteresis registers. This increases the amount of I2C traffic and
time needed to read the temperature by a factor of ~5. Neither the threshold nor
the hysteresis change on their own, so once we have read them, we should be able
to just use the cached value of the registers. This patch modifies the code
accordingly and only reads the threshold and hysteresis registers once during
probe.

Signed-off-by: default avatarLars-Peter Clausen <lars@metafoo.de>
Signed-off-by: default avatarGuenter Roeck <linux@roeck-us.net>
parent f40fb63e

drivers/hwmon/adt7410.c

+58 −33
Original line number Original line Diff line number Diff line
@@ -119,45 +119,33 @@ static int adt7410_temp_ready(struct i2c_client *client) 
	return -ETIMEDOUT;

	return -ETIMEDOUT;

}

}





static struct adt7410_data *adt7410_update_device(struct device *dev)

static int adt7410_update_temp(struct device *dev)

{

{

	struct i2c_client *client = to_i2c_client(dev);

	struct i2c_client *client = to_i2c_client(dev);

	struct adt7410_data *data = i2c_get_clientdata(client);

	struct adt7410_data *data = i2c_get_clientdata(client);

	struct adt7410_data *ret = data;

	int ret = 0;



	mutex_lock(&data->update_lock);

	mutex_lock(&data->update_lock);





	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)

	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)

	    || !data->valid) {

	    || !data->valid) {

		int i, status;

		int temp;





		dev_dbg(&client->dev, "Starting update\n");

		dev_dbg(&client->dev, "Starting update\n");





		status = adt7410_temp_ready(client); /* check for new value */

		ret = adt7410_temp_ready(client); /* check for new value */

		if (unlikely(status)) {

		if (ret)

			ret = ERR_PTR(status);

			goto abort;

		}

		for (i = 0; i < ARRAY_SIZE(data->temp); i++) {

			status = i2c_smbus_read_word_swapped(client,

							ADT7410_REG_TEMP[i]);

			if (unlikely(status < 0)) {

				dev_dbg(dev,

					"Failed to read value: reg %d, error %d\n",

					ADT7410_REG_TEMP[i], status);

				ret = ERR_PTR(status);

			goto abort;

			goto abort;

			}



			data->temp[i] = status;

		temp = i2c_smbus_read_word_swapped(client, ADT7410_REG_TEMP[0]);

		}

		if (temp < 0) {

		status = i2c_smbus_read_byte_data(client, ADT7410_T_HYST);

			ret = temp;

		if (unlikely(status < 0)) {

			dev_dbg(dev, "Failed to read value: reg %d, error %d\n",

			dev_dbg(dev,

				ADT7410_REG_TEMP[0], ret);

				"Failed to read value: reg %d, error %d\n",

				ADT7410_T_HYST, status);

			ret = ERR_PTR(status);

			goto abort;

			goto abort;

		}

		}

		data->hyst = status;

		data->temp[0] = temp;



		data->last_updated = jiffies;

		data->last_updated = jiffies;

		data->valid = true;

		data->valid = true;

	}

	}
@@ -167,6 +155,35 @@ abort: 
	return ret;

	return ret;

}

}





static int adt7410_fill_cache(struct i2c_client *client)

{

	struct adt7410_data *data = i2c_get_clientdata(client);

	int ret;

	int i;



	for (i = 1; i < ARRAY_SIZE(ADT7410_REG_TEMP); i++) {

		ret = i2c_smbus_read_word_swapped(client, ADT7410_REG_TEMP[i]);

		if (ret < 0) {

			dev_dbg(&client->dev,

				"Failed to read value: reg %d, error %d\n",

				ADT7410_REG_TEMP[i], ret);

			return ret;

		}

		data->temp[i] = ret;

	}



	ret = i2c_smbus_read_byte_data(client, ADT7410_T_HYST);

	if (ret < 0) {

		dev_dbg(&client->dev,

			"Failed to read value: hyst reg, error %d\n",

			ret);

		return ret;

	}

	data->hyst = ret;



	return 0;

}



static s16 ADT7410_TEMP_TO_REG(long temp)

static s16 ADT7410_TEMP_TO_REG(long temp)

{

{

	return DIV_ROUND_CLOSEST(clamp_val(temp, ADT7410_TEMP_MIN,

	return DIV_ROUND_CLOSEST(clamp_val(temp, ADT7410_TEMP_MIN,
@@ -193,10 +210,16 @@ static ssize_t adt7410_show_temp(struct device *dev, 
				 struct device_attribute *da, char *buf)

				 struct device_attribute *da, char *buf)

{

{

	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);

	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);

	struct adt7410_data *data = adt7410_update_device(dev);

	struct i2c_client *client = to_i2c_client(dev);

	struct adt7410_data *data = i2c_get_clientdata(client);



	if (attr->index == 0) {

		int ret;





	if (IS_ERR(data))

		ret = adt7410_update_temp(dev);

		return PTR_ERR(data);

		if (ret)

			return ret;

	}





	return sprintf(buf, "%d\n", ADT7410_REG_TO_TEMP(data,

	return sprintf(buf, "%d\n", ADT7410_REG_TO_TEMP(data,

		       data->temp[attr->index]));

		       data->temp[attr->index]));
@@ -232,13 +255,11 @@ static ssize_t adt7410_show_t_hyst(struct device *dev, 
				   char *buf)

				   char *buf)

{

{

	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);

	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);

	struct adt7410_data *data;

	struct i2c_client *client = to_i2c_client(dev);

	struct adt7410_data *data = i2c_get_clientdata(client);

	int nr = attr->index;

	int nr = attr->index;

	int hyst;

	int hyst;





	data = adt7410_update_device(dev);

	if (IS_ERR(data))

		return PTR_ERR(data);

	hyst = (data->hyst & ADT7410_T_HYST_MASK) * 1000;

	hyst = (data->hyst & ADT7410_T_HYST_MASK) * 1000;





	/*

	/*
@@ -371,6 +392,10 @@ static int adt7410_probe(struct i2c_client *client, 
	}

	}

	dev_dbg(&client->dev, "Config %02x\n", data->config);

	dev_dbg(&client->dev, "Config %02x\n", data->config);





	ret = adt7410_fill_cache(client);

	if (ret)

		goto exit_restore;



	/* Register sysfs hooks */

	/* Register sysfs hooks */

	ret = sysfs_create_group(&client->dev.kobj, &adt7410_group);

	ret = sysfs_create_group(&client->dev.kobj, &adt7410_group);

	if (ret)

	if (ret)

CRA Git | Maintained and supported by SUSTech CRA and CCSE