| Message ID | 20240430210539.935040-1-naresh.solanki@9elements.com (mailing list archive) |
|---|---|
| State | Changes Requested |
| Headers | show |
| Series | [v2] hwmon (max6639): Use regmap | expand |
On 4/30/24 14:05, Naresh Solanki wrote: > Add regmap support & remove local caching. > > Signed-off-by: Naresh Solanki <naresh.solanki@9elements.com> I assume the first post was superseded due to the missing version ? Either case, please provide change logs with your patches. Thanks, Guenter
On Wed, May 01, 2024 at 02:35:38AM +0530, Naresh Solanki wrote: > Add regmap support & remove local caching. > > Signed-off-by: Naresh Solanki <naresh.solanki@9elements.com> > --- > drivers/hwmon/Kconfig | 1 + > drivers/hwmon/max6639.c | 310 ++++++++++++++++++++-------------------- > 2 files changed, 154 insertions(+), 157 deletions(-) > > > base-commit: 8b3aa2c488653fa1e127cf6e11499a8cbbaccad0 > > diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig > index bafc0058c728..e14ae18a973b 100644 > --- a/drivers/hwmon/Kconfig > +++ b/drivers/hwmon/Kconfig > @@ -1233,6 +1233,7 @@ config SENSORS_MAX6621 > config SENSORS_MAX6639 > tristate "Maxim MAX6639 sensor chip" > depends on I2C > + select REGMAP_I2C > help > If you say yes here you get support for the MAX6639 > sensor chips. > diff --git a/drivers/hwmon/max6639.c b/drivers/hwmon/max6639.c > index 5dd0349e8bd0..b12d2098e259 100644 > --- a/drivers/hwmon/max6639.c > +++ b/drivers/hwmon/max6639.c > @@ -20,6 +20,7 @@ > #include <linux/err.h> > #include <linux/mutex.h> > #include <linux/platform_data/max6639.h> > +#include <linux/regmap.h> > > /* Addresses to scan */ > static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END }; > @@ -57,6 +58,8 @@ static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END }; > > #define MAX6639_FAN_CONFIG3_THERM_FULL_SPEED 0x40 > > +#define MAX6639_NDEV 2 > + > static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 }; > > #define FAN_FROM_REG(val, rpm_range) ((val) == 0 || (val) == 255 ? \ > @@ -67,22 +70,11 @@ static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 }; > * Client data (each client gets its own) > */ > struct max6639_data { > - struct i2c_client *client; > + struct regmap *regmap; > struct mutex update_lock; I think that lock can be dropped entirely. > - bool valid; /* true if following fields are valid */ > - unsigned long last_updated; /* In jiffies */ > - > - /* Register values sampled regularly */ > - u16 temp[2]; /* Temperature, in 1/8 C, 0..255 C */ > - bool temp_fault[2]; /* Detected temperature diode failure */ > - u8 fan[2]; /* Register value: TACH count for fans >=30 */ > - u8 status; /* Detected channel alarms and fan failures */ > > /* Register values only written to */ > - u8 pwm[2]; /* Register value: Duty cycle 0..120 */ > - u8 temp_therm[2]; /* THERM Temperature, 0..255 C (->_max) */ > - u8 temp_alert[2]; /* ALERT Temperature, 0..255 C (->_crit) */ > - u8 temp_ot[2]; /* OT Temperature, 0..255 C (->_emergency) */ > + u8 pwm[MAX6639_NDEV]; /* Register value: Duty cycle 0..120 */ pwm caching needs to be dropped as well. It is no longer initialized in max6639_init_client(), but updated and later used in pwm_store() and pwm_show(). Looking at the datasheet, the pwm registers are volatile and should not be cached in the first place. > > /* Register values initialized only once */ > u8 ppr; /* Pulses per rotation 0..3 for 1..4 ppr */ > @@ -92,90 +84,58 @@ struct max6639_data { > struct regulator *reg; > }; > > -static struct max6639_data *max6639_update_device(struct device *dev) > -{ > - struct max6639_data *data = dev_get_drvdata(dev); > - struct i2c_client *client = data->client; > - struct max6639_data *ret = data; > - int i; > - int status_reg; > - > - mutex_lock(&data->update_lock); > - > - if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) { > - int res; > - > - dev_dbg(&client->dev, "Starting max6639 update\n"); > - > - status_reg = i2c_smbus_read_byte_data(client, > - MAX6639_REG_STATUS); > - if (status_reg < 0) { > - ret = ERR_PTR(status_reg); > - goto abort; > - } > - > - data->status = status_reg; > - > - for (i = 0; i < 2; i++) { > - res = i2c_smbus_read_byte_data(client, > - MAX6639_REG_FAN_CNT(i)); > - if (res < 0) { > - ret = ERR_PTR(res); > - goto abort; > - } > - data->fan[i] = res; > - > - res = i2c_smbus_read_byte_data(client, > - MAX6639_REG_TEMP_EXT(i)); > - if (res < 0) { > - ret = ERR_PTR(res); > - goto abort; > - } > - data->temp[i] = res >> 5; > - data->temp_fault[i] = res & 0x01; > - > - res = i2c_smbus_read_byte_data(client, > - MAX6639_REG_TEMP(i)); > - if (res < 0) { > - ret = ERR_PTR(res); > - goto abort; > - } > - data->temp[i] |= res << 3; > - } > - > - data->last_updated = jiffies; > - data->valid = true; > - } > -abort: > - mutex_unlock(&data->update_lock); > - > - return ret; > -} > - > static ssize_t temp_input_show(struct device *dev, > struct device_attribute *dev_attr, char *buf) > { > long temp; > - struct max6639_data *data = max6639_update_device(dev); > + struct max6639_data *data = dev_get_drvdata(dev); > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > + unsigned int val; > + int res; > > if (IS_ERR(data)) > return PTR_ERR(data); Drop > > - temp = data->temp[attr->index] * 125; > + mutex_lock(&data->update_lock); > + res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val); > + if (res < 0) > + goto exit; > + > + temp = val >> 5; > + res = regmap_read(data->regmap, MAX6639_REG_TEMP(attr->index), &val); > + if (res < 0) > + goto exit; > + > + temp |= val << 3; > + temp *= 125; > + > +exit: > + mutex_unlock(&data->update_lock); Given that updates to MAX6639_REG_TEMP are blocked for up to 250ms after reading MAX6639_REG_TEMP_EXT, I think this lock is unnecessary. > + if (res < 0) > + return res; > + > return sprintf(buf, "%ld\n", temp); > } > > static ssize_t temp_fault_show(struct device *dev, > struct device_attribute *dev_attr, char *buf) > { > - struct max6639_data *data = max6639_update_device(dev); > + struct max6639_data *data = dev_get_drvdata(dev); > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > + unsigned int val; > + int res; > > if (IS_ERR(data)) > return PTR_ERR(data); Drop > > - return sprintf(buf, "%d\n", data->temp_fault[attr->index]); > + mutex_lock(&data->update_lock); > + res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val); > + mutex_unlock(&data->update_lock); Updates are blocked for 250ms after the extended temperature is read. I don't think there is a good reason to hold the lock while reading the register; worst case the value will be read here and by another thread from temp_input_show() at the same time, but that should not make a practical difference. > + > + if (res < 0) > + return res; > + > + return sprintf(buf, "%d\n", val & 1); > } > > static ssize_t temp_max_show(struct device *dev, > @@ -183,8 +143,17 @@ static ssize_t temp_max_show(struct device *dev, > { > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > struct max6639_data *data = dev_get_drvdata(dev); > + unsigned int val; > + int res; > > - return sprintf(buf, "%d\n", (data->temp_therm[attr->index] * 1000)); > + mutex_lock(&data->update_lock); > + res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index), &val); > + mutex_unlock(&data->update_lock); Unnecessary lock. In general there is really hardly ever a good reason to hold a local lock during single register regmap accesses. Regmap serializes those accesses internally anyway. > + > + if (res < 0) > + return res; > + > + return sprintf(buf, "%d\n", (val * 1000)); > } > > static ssize_t temp_max_store(struct device *dev, > @@ -193,7 +162,6 @@ static ssize_t temp_max_store(struct device *dev, > { > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > struct max6639_data *data = dev_get_drvdata(dev); > - struct i2c_client *client = data->client; > unsigned long val; > int res; > > @@ -202,10 +170,8 @@ static ssize_t temp_max_store(struct device *dev, > return res; > > mutex_lock(&data->update_lock); > - data->temp_therm[attr->index] = TEMP_LIMIT_TO_REG(val); > - i2c_smbus_write_byte_data(client, > - MAX6639_REG_THERM_LIMIT(attr->index), > - data->temp_therm[attr->index]); > + regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index), > + TEMP_LIMIT_TO_REG(val)); > mutex_unlock(&data->update_lock); Now unnecessary lock (it was necessary previously to ensure that data->temp_therm[] and the register value are in sync). > return count; > } > @@ -215,8 +181,17 @@ static ssize_t temp_crit_show(struct device *dev, > { > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > struct max6639_data *data = dev_get_drvdata(dev); > + unsigned int val; > + int res; > + > + mutex_lock(&data->update_lock); > + res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index), &val); > + mutex_unlock(&data->update_lock); Unnecessary lock > > - return sprintf(buf, "%d\n", (data->temp_alert[attr->index] * 1000)); > + if (res < 0) > + return res; > + > + return sprintf(buf, "%d\n", (val * 1000)); > } > > static ssize_t temp_crit_store(struct device *dev, > @@ -225,7 +200,6 @@ static ssize_t temp_crit_store(struct device *dev, > { > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > struct max6639_data *data = dev_get_drvdata(dev); > - struct i2c_client *client = data->client; > unsigned long val; > int res; > > @@ -234,10 +208,8 @@ static ssize_t temp_crit_store(struct device *dev, > return res; > > mutex_lock(&data->update_lock); > - data->temp_alert[attr->index] = TEMP_LIMIT_TO_REG(val); > - i2c_smbus_write_byte_data(client, > - MAX6639_REG_ALERT_LIMIT(attr->index), > - data->temp_alert[attr->index]); > + regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index), > + TEMP_LIMIT_TO_REG(val)); Now unnecessary lock > mutex_unlock(&data->update_lock); > return count; > } > @@ -248,8 +220,17 @@ static ssize_t temp_emergency_show(struct device *dev, > { > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > struct max6639_data *data = dev_get_drvdata(dev); > + unsigned int val; > + int res; > > - return sprintf(buf, "%d\n", (data->temp_ot[attr->index] * 1000)); > + mutex_lock(&data->update_lock); > + res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), &val); > + mutex_unlock(&data->update_lock); Unnecessary lock > + > + if (res < 0) > + return res; > + > + return sprintf(buf, "%d\n", (val * 1000)); > } > > static ssize_t temp_emergency_store(struct device *dev, > @@ -258,7 +239,6 @@ static ssize_t temp_emergency_store(struct device *dev, > { > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > struct max6639_data *data = dev_get_drvdata(dev); > - struct i2c_client *client = data->client; > unsigned long val; > int res; > > @@ -267,10 +247,7 @@ static ssize_t temp_emergency_store(struct device *dev, > return res; > > mutex_lock(&data->update_lock); > - data->temp_ot[attr->index] = TEMP_LIMIT_TO_REG(val); > - i2c_smbus_write_byte_data(client, > - MAX6639_REG_OT_LIMIT(attr->index), > - data->temp_ot[attr->index]); > + regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), TEMP_LIMIT_TO_REG(val)); Unnecessary lock > mutex_unlock(&data->update_lock); > return count; > } > @@ -290,7 +267,6 @@ static ssize_t pwm_store(struct device *dev, > { > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > struct max6639_data *data = dev_get_drvdata(dev); > - struct i2c_client *client = data->client; > unsigned long val; > int res; > > @@ -299,12 +275,9 @@ static ssize_t pwm_store(struct device *dev, > return res; > > val = clamp_val(val, 0, 255); > - > - mutex_lock(&data->update_lock); > data->pwm[attr->index] = (u8)(val * 120 / 255); > - i2c_smbus_write_byte_data(client, > - MAX6639_REG_TARGTDUTY(attr->index), > - data->pwm[attr->index]); > + mutex_lock(&data->update_lock); > + regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(attr->index), data->pwm[attr->index]); > mutex_unlock(&data->update_lock); Now unnecessary lock (after data->pwm is removed) > return count; > } > @@ -312,26 +285,35 @@ static ssize_t pwm_store(struct device *dev, > static ssize_t fan_input_show(struct device *dev, > struct device_attribute *dev_attr, char *buf) > { > - struct max6639_data *data = max6639_update_device(dev); > + struct max6639_data *data = dev_get_drvdata(dev); > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > + unsigned int val; > + int res; > > if (IS_ERR(data)) > return PTR_ERR(data); > > - return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index], > - data->rpm_range)); > + res = regmap_read(data->regmap, MAX6639_REG_FAN_CNT(attr->index), &val); > + if (res < 0) > + return res; > + > + return sprintf(buf, "%d\n", FAN_FROM_REG(val, data->rpm_range)); > } > > static ssize_t alarm_show(struct device *dev, > struct device_attribute *dev_attr, char *buf) > { > - struct max6639_data *data = max6639_update_device(dev); > + struct max6639_data *data = dev_get_drvdata(dev); > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > + unsigned int val; > + int res; > > if (IS_ERR(data)) > return PTR_ERR(data); > > - return sprintf(buf, "%d\n", !!(data->status & (1 << attr->index))); > + res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val); > + > + return sprintf(buf, "%d\n", !!(val & (1 << attr->index))); > } > > static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0); > @@ -401,6 +383,11 @@ static int rpm_range_to_reg(int range) > return 1; /* default: 4000 RPM */ > } > > +static int max6639_set_ppr(struct max6639_data *data, u8 channel, u8 ppr) > +{ > + return regmap_write(data->regmap, MAX6639_REG_FAN_PPR(channel), ppr << 6); > +} > + > static int max6639_init_client(struct i2c_client *client, > struct max6639_data *data) > { > @@ -408,49 +395,43 @@ static int max6639_init_client(struct i2c_client *client, > dev_get_platdata(&client->dev); > int i; > int rpm_range = 1; /* default: 4000 RPM */ > - int err; > + int err, ppr; > > /* Reset chip to default values, see below for GCONFIG setup */ > - err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG, > - MAX6639_GCONFIG_POR); > + err = regmap_write(data->regmap, MAX6639_REG_GCONFIG, MAX6639_GCONFIG_POR); > if (err) > goto exit; > > /* Fans pulse per revolution is 2 by default */ > if (max6639_info && max6639_info->ppr > 0 && > max6639_info->ppr < 5) > - data->ppr = max6639_info->ppr; > + ppr = max6639_info->ppr; > else > - data->ppr = 2; > - data->ppr -= 1; > + ppr = 2; > + ppr -= 1; > > if (max6639_info) > rpm_range = rpm_range_to_reg(max6639_info->rpm_range); > data->rpm_range = rpm_range; > > - for (i = 0; i < 2; i++) { > + for (i = 0; i < MAX6639_NDEV; i++) { > > /* Set Fan pulse per revolution */ > - err = i2c_smbus_write_byte_data(client, > - MAX6639_REG_FAN_PPR(i), > - data->ppr << 6); > + err = max6639_set_ppr(data, i, ppr); > if (err) > goto exit; > > /* Fans config PWM, RPM */ > - err = i2c_smbus_write_byte_data(client, > - MAX6639_REG_FAN_CONFIG1(i), > - MAX6639_FAN_CONFIG1_PWM | rpm_range); > + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG1(i), > + MAX6639_FAN_CONFIG1_PWM | rpm_range); > if (err) > goto exit; > > /* Fans PWM polarity high by default */ > if (max6639_info && max6639_info->pwm_polarity == 0) > - err = i2c_smbus_write_byte_data(client, > - MAX6639_REG_FAN_CONFIG2a(i), 0x00); > + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x00); > else > - err = i2c_smbus_write_byte_data(client, > - MAX6639_REG_FAN_CONFIG2a(i), 0x02); > + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x02); > if (err) > goto exit; > > @@ -458,42 +439,31 @@ static int max6639_init_client(struct i2c_client *client, > * /THERM full speed enable, > * PWM frequency 25kHz, see also GCONFIG below > */ > - err = i2c_smbus_write_byte_data(client, > - MAX6639_REG_FAN_CONFIG3(i), > - MAX6639_FAN_CONFIG3_THERM_FULL_SPEED | 0x03); > + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG3(i), > + MAX6639_FAN_CONFIG3_THERM_FULL_SPEED | 0x03); > if (err) > goto exit; > > /* Max. temp. 80C/90C/100C */ > - data->temp_therm[i] = 80; > - data->temp_alert[i] = 90; > - data->temp_ot[i] = 100; > - err = i2c_smbus_write_byte_data(client, > - MAX6639_REG_THERM_LIMIT(i), > - data->temp_therm[i]); > + err = regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(i), 80); > if (err) > goto exit; > - err = i2c_smbus_write_byte_data(client, > - MAX6639_REG_ALERT_LIMIT(i), > - data->temp_alert[i]); > + err = regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(i), 90); > if (err) > goto exit; > - err = i2c_smbus_write_byte_data(client, > - MAX6639_REG_OT_LIMIT(i), data->temp_ot[i]); > + err = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(i), 100); > if (err) > goto exit; > > /* PWM 120/120 (i.e. 100%) */ > - data->pwm[i] = 120; > - err = i2c_smbus_write_byte_data(client, > - MAX6639_REG_TARGTDUTY(i), data->pwm[i]); > + err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(i), 120); > if (err) > goto exit; > } > /* Start monitoring */ > - err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG, > - MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL | > - MAX6639_GCONFIG_PWM_FREQ_HI); > + err = regmap_write(data->regmap, MAX6639_REG_GCONFIG, > + MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL | > + MAX6639_GCONFIG_PWM_FREQ_HI); > exit: > return err; > } > @@ -524,6 +494,30 @@ static void max6639_regulator_disable(void *data) > regulator_disable(data); > } > > +static bool max6639_regmap_is_volatile(struct device *dev, unsigned int reg) > +{ > + switch (reg) { > + case MAX6639_REG_TEMP(0): > + case MAX6639_REG_TEMP_EXT(0): > + case MAX6639_REG_TEMP(1): > + case MAX6639_REG_TEMP_EXT(1): > + case MAX6639_REG_STATUS: > + case MAX6639_REG_FAN_CNT(0): > + case MAX6639_REG_FAN_CNT(1): pwm registers are also volatile. > + return true; > + default: > + return false; > + } > +} > + > +static const struct regmap_config max6639_regmap_config = { > + .reg_bits = 8, > + .val_bits = 8, > + .max_register = MAX6639_REG_DEVREV, > + .cache_type = REGCACHE_MAPLE, > + .volatile_reg = max6639_regmap_is_volatile, > +}; > + > static int max6639_probe(struct i2c_client *client) > { > struct device *dev = &client->dev; > @@ -535,7 +529,11 @@ static int max6639_probe(struct i2c_client *client) > if (!data) > return -ENOMEM; > > - data->client = client; > + data->regmap = devm_regmap_init_i2c(client, &max6639_regmap_config); > + if (IS_ERR(data->regmap)) > + return dev_err_probe(dev, > + PTR_ERR(data->regmap), > + "regmap initialization failed\n"); > > data->reg = devm_regulator_get_optional(dev, "fan"); > if (IS_ERR(data->reg)) { > @@ -573,25 +571,24 @@ static int max6639_probe(struct i2c_client *client) > > static int max6639_suspend(struct device *dev) > { > - struct i2c_client *client = to_i2c_client(dev); > struct max6639_data *data = dev_get_drvdata(dev); > - int ret = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG); > + int ret, err; > > - if (ret < 0) > - return ret; > + err = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &ret); > + Unnecessary empty line. > + if (err < 0) > + return err; > > if (data->reg) > regulator_disable(data->reg); > > - return i2c_smbus_write_byte_data(client, > - MAX6639_REG_GCONFIG, ret | MAX6639_GCONFIG_STANDBY); > + return regmap_write(data->regmap, MAX6639_REG_GCONFIG, ret | MAX6639_GCONFIG_STANDBY); > } > > static int max6639_resume(struct device *dev) > { > - struct i2c_client *client = to_i2c_client(dev); > struct max6639_data *data = dev_get_drvdata(dev); > - int ret; > + int ret, err; > > if (data->reg) { > ret = regulator_enable(data->reg); > @@ -601,12 +598,11 @@ static int max6639_resume(struct device *dev) > } > } > > - ret = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG); > - if (ret < 0) > - return ret; > + err = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &ret); > + if (err < 0) > + return err; > > - return i2c_smbus_write_byte_data(client, > - MAX6639_REG_GCONFIG, ret & ~MAX6639_GCONFIG_STANDBY); > + return regmap_write(data->regmap, MAX6639_REG_GCONFIG, ret & ~MAX6639_GCONFIG_STANDBY); > } > > static const struct i2c_device_id max6639_id[] = {
Hi Guenter On Wed, 1 May 2024 at 05:24, Guenter Roeck <linux@roeck-us.net> wrote: > > On 4/30/24 14:05, Naresh Solanki wrote: > > Add regmap support & remove local caching. > > > > Signed-off-by: Naresh Solanki <naresh.solanki@9elements.com> > > I assume the first post was superseded due to the missing version ? Yes. Apology I pushed the first post without updating version. > > Either case, please provide change logs with your patches. Yes, I missed this as well. Will do that in v3. v3 will include fixes you have suggested in v2. Regards, Naresh > > Thanks, > Guenter >
Hi Guenter, On Wed, 1 May 2024 at 19:27, Guenter Roeck <linux@roeck-us.net> wrote: > > On Wed, May 01, 2024 at 02:35:38AM +0530, Naresh Solanki wrote: > > Add regmap support & remove local caching. > > > > Signed-off-by: Naresh Solanki <naresh.solanki@9elements.com> > > --- > > drivers/hwmon/Kconfig | 1 + > > drivers/hwmon/max6639.c | 310 ++++++++++++++++++++-------------------- > > 2 files changed, 154 insertions(+), 157 deletions(-) > > > > > > base-commit: 8b3aa2c488653fa1e127cf6e11499a8cbbaccad0 > > > > diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig > > index bafc0058c728..e14ae18a973b 100644 > > --- a/drivers/hwmon/Kconfig > > +++ b/drivers/hwmon/Kconfig > > @@ -1233,6 +1233,7 @@ config SENSORS_MAX6621 > > config SENSORS_MAX6639 > > tristate "Maxim MAX6639 sensor chip" > > depends on I2C > > + select REGMAP_I2C > > help > > If you say yes here you get support for the MAX6639 > > sensor chips. > > diff --git a/drivers/hwmon/max6639.c b/drivers/hwmon/max6639.c > > index 5dd0349e8bd0..b12d2098e259 100644 > > --- a/drivers/hwmon/max6639.c > > +++ b/drivers/hwmon/max6639.c > > @@ -20,6 +20,7 @@ > > #include <linux/err.h> > > #include <linux/mutex.h> > > #include <linux/platform_data/max6639.h> > > +#include <linux/regmap.h> > > > > /* Addresses to scan */ > > static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END }; > > @@ -57,6 +58,8 @@ static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END }; > > > > #define MAX6639_FAN_CONFIG3_THERM_FULL_SPEED 0x40 > > > > +#define MAX6639_NDEV 2 > > + > > static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 }; > > > > #define FAN_FROM_REG(val, rpm_range) ((val) == 0 || (val) == 255 ? \ > > @@ -67,22 +70,11 @@ static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 }; > > * Client data (each client gets its own) > > */ > > struct max6639_data { > > - struct i2c_client *client; > > + struct regmap *regmap; > > struct mutex update_lock; > > I think that lock can be dropped entirely. Sure. > > > - bool valid; /* true if following fields are valid */ > > - unsigned long last_updated; /* In jiffies */ > > - > > - /* Register values sampled regularly */ > > - u16 temp[2]; /* Temperature, in 1/8 C, 0..255 C */ > > - bool temp_fault[2]; /* Detected temperature diode failure */ > > - u8 fan[2]; /* Register value: TACH count for fans >=30 */ > > - u8 status; /* Detected channel alarms and fan failures */ > > > > /* Register values only written to */ > > - u8 pwm[2]; /* Register value: Duty cycle 0..120 */ > > - u8 temp_therm[2]; /* THERM Temperature, 0..255 C (->_max) */ > > - u8 temp_alert[2]; /* ALERT Temperature, 0..255 C (->_crit) */ > > - u8 temp_ot[2]; /* OT Temperature, 0..255 C (->_emergency) */ > > + u8 pwm[MAX6639_NDEV]; /* Register value: Duty cycle 0..120 */ > > pwm caching needs to be dropped as well. It is no longer initialized in > max6639_init_client(), but updated and later used in pwm_store() and > pwm_show(). Looking at the datasheet, the pwm registers are volatile > and should not be cached in the first place. Yes. I did that but found that the register is write only. i.e., > > > > > > /* Register values initialized only once */ > > u8 ppr; /* Pulses per rotation 0..3 for 1..4 ppr */ > > @@ -92,90 +84,58 @@ struct max6639_data { > > struct regulator *reg; > > }; > > > > -static struct max6639_data *max6639_update_device(struct device *dev) > > -{ > > - struct max6639_data *data = dev_get_drvdata(dev); > > - struct i2c_client *client = data->client; > > - struct max6639_data *ret = data; > > - int i; > > - int status_reg; > > - > > - mutex_lock(&data->update_lock); > > - > > - if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) { > > - int res; > > - > > - dev_dbg(&client->dev, "Starting max6639 update\n"); > > - > > - status_reg = i2c_smbus_read_byte_data(client, > > - MAX6639_REG_STATUS); > > - if (status_reg < 0) { > > - ret = ERR_PTR(status_reg); > > - goto abort; > > - } > > - > > - data->status = status_reg; > > - > > - for (i = 0; i < 2; i++) { > > - res = i2c_smbus_read_byte_data(client, > > - MAX6639_REG_FAN_CNT(i)); > > - if (res < 0) { > > - ret = ERR_PTR(res); > > - goto abort; > > - } > > - data->fan[i] = res; > > - > > - res = i2c_smbus_read_byte_data(client, > > - MAX6639_REG_TEMP_EXT(i)); > > - if (res < 0) { > > - ret = ERR_PTR(res); > > - goto abort; > > - } > > - data->temp[i] = res >> 5; > > - data->temp_fault[i] = res & 0x01; > > - > > - res = i2c_smbus_read_byte_data(client, > > - MAX6639_REG_TEMP(i)); > > - if (res < 0) { > > - ret = ERR_PTR(res); > > - goto abort; > > - } > > - data->temp[i] |= res << 3; > > - } > > - > > - data->last_updated = jiffies; > > - data->valid = true; > > - } > > -abort: > > - mutex_unlock(&data->update_lock); > > - > > - return ret; > > -} > > - > > static ssize_t temp_input_show(struct device *dev, > > struct device_attribute *dev_attr, char *buf) > > { > > long temp; > > - struct max6639_data *data = max6639_update_device(dev); > > + struct max6639_data *data = dev_get_drvdata(dev); > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > + unsigned int val; > > + int res; > > > > if (IS_ERR(data)) > > return PTR_ERR(data); > > Drop Sure > > > > > - temp = data->temp[attr->index] * 125; > > + mutex_lock(&data->update_lock); > > + res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val); > > + if (res < 0) > > + goto exit; > > + > > + temp = val >> 5; > > + res = regmap_read(data->regmap, MAX6639_REG_TEMP(attr->index), &val); > > + if (res < 0) > > + goto exit; > > + > > + temp |= val << 3; > > + temp *= 125; > > + > > +exit: > > + mutex_unlock(&data->update_lock); Sure > > Given that updates to MAX6639_REG_TEMP are blocked for up to 250ms > after reading MAX6639_REG_TEMP_EXT, I think this lock is unnecessary. > > > + if (res < 0) > > + return res; > > + > > return sprintf(buf, "%ld\n", temp); > > } > > > > static ssize_t temp_fault_show(struct device *dev, > > struct device_attribute *dev_attr, char *buf) > > { > > - struct max6639_data *data = max6639_update_device(dev); > > + struct max6639_data *data = dev_get_drvdata(dev); > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > + unsigned int val; > > + int res; > > > > if (IS_ERR(data)) > > return PTR_ERR(data); > > Drop Ack > > > > > - return sprintf(buf, "%d\n", data->temp_fault[attr->index]); > > + mutex_lock(&data->update_lock); > > + res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val); > > + mutex_unlock(&data->update_lock); > > Updates are blocked for 250ms after the extended temperature is read. > I don't think there is a good reason to hold the lock while reading > the register; worst case the value will be read here and by another thread > from temp_input_show() at the same time, but that should not make a > practical difference. Ack > > > + > > + if (res < 0) > > + return res; > > + > > + return sprintf(buf, "%d\n", val & 1); > > } > > > > static ssize_t temp_max_show(struct device *dev, > > @@ -183,8 +143,17 @@ static ssize_t temp_max_show(struct device *dev, > > { > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > struct max6639_data *data = dev_get_drvdata(dev); > > + unsigned int val; > > + int res; > > > > - return sprintf(buf, "%d\n", (data->temp_therm[attr->index] * 1000)); > > + mutex_lock(&data->update_lock); > > + res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index), &val); > > + mutex_unlock(&data->update_lock); > > Unnecessary lock. In general there is really hardly ever a good reason > to hold a local lock during single register regmap accesses. Regmap > serializes those accesses internally anyway. Ack > > > + > > + if (res < 0) > > + return res; > > + > > + return sprintf(buf, "%d\n", (val * 1000)); > > } > > > > static ssize_t temp_max_store(struct device *dev, > > @@ -193,7 +162,6 @@ static ssize_t temp_max_store(struct device *dev, > > { > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > struct max6639_data *data = dev_get_drvdata(dev); > > - struct i2c_client *client = data->client; > > unsigned long val; > > int res; > > > > @@ -202,10 +170,8 @@ static ssize_t temp_max_store(struct device *dev, > > return res; > > > > mutex_lock(&data->update_lock); > > - data->temp_therm[attr->index] = TEMP_LIMIT_TO_REG(val); > > - i2c_smbus_write_byte_data(client, > > - MAX6639_REG_THERM_LIMIT(attr->index), > > - data->temp_therm[attr->index]); > > + regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index), > > + TEMP_LIMIT_TO_REG(val)); > > mutex_unlock(&data->update_lock); > > Now unnecessary lock (it was necessary previously to ensure that > data->temp_therm[] and the register value are in sync). Ack > > > return count; > > } > > @@ -215,8 +181,17 @@ static ssize_t temp_crit_show(struct device *dev, > > { > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > struct max6639_data *data = dev_get_drvdata(dev); > > + unsigned int val; > > + int res; > > + > > + mutex_lock(&data->update_lock); > > + res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index), &val); > > + mutex_unlock(&data->update_lock); > > Unnecessary lock Ack > > > > > - return sprintf(buf, "%d\n", (data->temp_alert[attr->index] * 1000)); > > + if (res < 0) > > + return res; > > + > > + return sprintf(buf, "%d\n", (val * 1000)); > > } > > > > static ssize_t temp_crit_store(struct device *dev, > > @@ -225,7 +200,6 @@ static ssize_t temp_crit_store(struct device *dev, > > { > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > struct max6639_data *data = dev_get_drvdata(dev); > > - struct i2c_client *client = data->client; > > unsigned long val; > > int res; > > > > @@ -234,10 +208,8 @@ static ssize_t temp_crit_store(struct device *dev, > > return res; > > > > mutex_lock(&data->update_lock); > > - data->temp_alert[attr->index] = TEMP_LIMIT_TO_REG(val); > > - i2c_smbus_write_byte_data(client, > > - MAX6639_REG_ALERT_LIMIT(attr->index), > > - data->temp_alert[attr->index]); > > + regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index), > > + TEMP_LIMIT_TO_REG(val)); > > Now unnecessary lock Ack > > > mutex_unlock(&data->update_lock); > > return count; > > } > > @@ -248,8 +220,17 @@ static ssize_t temp_emergency_show(struct device *dev, > > { > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > struct max6639_data *data = dev_get_drvdata(dev); > > + unsigned int val; > > + int res; > > > > - return sprintf(buf, "%d\n", (data->temp_ot[attr->index] * 1000)); > > + mutex_lock(&data->update_lock); > > + res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), &val); > > + mutex_unlock(&data->update_lock); > > Unnecessary lock Ack > > > + > > + if (res < 0) > > + return res; > > + > > + return sprintf(buf, "%d\n", (val * 1000)); > > } > > > > static ssize_t temp_emergency_store(struct device *dev, > > @@ -258,7 +239,6 @@ static ssize_t temp_emergency_store(struct device *dev, > > { > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > struct max6639_data *data = dev_get_drvdata(dev); > > - struct i2c_client *client = data->client; > > unsigned long val; > > int res; > > > > @@ -267,10 +247,7 @@ static ssize_t temp_emergency_store(struct device *dev, > > return res; > > > > mutex_lock(&data->update_lock); > > - data->temp_ot[attr->index] = TEMP_LIMIT_TO_REG(val); > > - i2c_smbus_write_byte_data(client, > > - MAX6639_REG_OT_LIMIT(attr->index), > > - data->temp_ot[attr->index]); > > + regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), TEMP_LIMIT_TO_REG(val)); > > Unnecessary lock Ack > > > mutex_unlock(&data->update_lock); > > return count; > > } > > @@ -290,7 +267,6 @@ static ssize_t pwm_store(struct device *dev, > > { > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > struct max6639_data *data = dev_get_drvdata(dev); > > - struct i2c_client *client = data->client; > > unsigned long val; > > int res; > > > > @@ -299,12 +275,9 @@ static ssize_t pwm_store(struct device *dev, > > return res; > > > > val = clamp_val(val, 0, 255); > > - > > - mutex_lock(&data->update_lock); > > data->pwm[attr->index] = (u8)(val * 120 / 255); > > - i2c_smbus_write_byte_data(client, > > - MAX6639_REG_TARGTDUTY(attr->index), > > - data->pwm[attr->index]); > > + mutex_lock(&data->update_lock); > > + regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(attr->index), data->pwm[attr->index]); > > mutex_unlock(&data->update_lock); > > Now unnecessary lock (after data->pwm is removed) Ack > > > return count; > > } > > @@ -312,26 +285,35 @@ static ssize_t pwm_store(struct device *dev, > > static ssize_t fan_input_show(struct device *dev, > > struct device_attribute *dev_attr, char *buf) > > { > > - struct max6639_data *data = max6639_update_device(dev); > > + struct max6639_data *data = dev_get_drvdata(dev); > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > + unsigned int val; > > + int res; > > > > if (IS_ERR(data)) > > return PTR_ERR(data); > > > > - return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index], > > - data->rpm_range)); > > + res = regmap_read(data->regmap, MAX6639_REG_FAN_CNT(attr->index), &val); > > + if (res < 0) > > + return res; > > + > > + return sprintf(buf, "%d\n", FAN_FROM_REG(val, data->rpm_range)); > > } > > > > static ssize_t alarm_show(struct device *dev, > > struct device_attribute *dev_attr, char *buf) > > { > > - struct max6639_data *data = max6639_update_device(dev); > > + struct max6639_data *data = dev_get_drvdata(dev); > > struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); > > + unsigned int val; > > + int res; > > > > if (IS_ERR(data)) > > return PTR_ERR(data); > > > > - return sprintf(buf, "%d\n", !!(data->status & (1 << attr->index))); > > + res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val); > > + > > + return sprintf(buf, "%d\n", !!(val & (1 << attr->index))); > > } > > > > static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0); > > @@ -401,6 +383,11 @@ static int rpm_range_to_reg(int range) > > return 1; /* default: 4000 RPM */ > > } > > > > +static int max6639_set_ppr(struct max6639_data *data, u8 channel, u8 ppr) > > +{ > > + return regmap_write(data->regmap, MAX6639_REG_FAN_PPR(channel), ppr << 6); > > +} > > + > > static int max6639_init_client(struct i2c_client *client, > > struct max6639_data *data) > > { > > @@ -408,49 +395,43 @@ static int max6639_init_client(struct i2c_client *client, > > dev_get_platdata(&client->dev); > > int i; > > int rpm_range = 1; /* default: 4000 RPM */ > > - int err; > > + int err, ppr; > > > > /* Reset chip to default values, see below for GCONFIG setup */ > > - err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG, > > - MAX6639_GCONFIG_POR); > > + err = regmap_write(data->regmap, MAX6639_REG_GCONFIG, MAX6639_GCONFIG_POR); > > if (err) > > goto exit; > > > > /* Fans pulse per revolution is 2 by default */ > > if (max6639_info && max6639_info->ppr > 0 && > > max6639_info->ppr < 5) > > - data->ppr = max6639_info->ppr; > > + ppr = max6639_info->ppr; > > else > > - data->ppr = 2; > > - data->ppr -= 1; > > + ppr = 2; > > + ppr -= 1; > > > > if (max6639_info) > > rpm_range = rpm_range_to_reg(max6639_info->rpm_range); > > data->rpm_range = rpm_range; > > > > - for (i = 0; i < 2; i++) { > > + for (i = 0; i < MAX6639_NDEV; i++) { > > > > /* Set Fan pulse per revolution */ > > - err = i2c_smbus_write_byte_data(client, > > - MAX6639_REG_FAN_PPR(i), > > - data->ppr << 6); > > + err = max6639_set_ppr(data, i, ppr); > > if (err) > > goto exit; > > > > /* Fans config PWM, RPM */ > > - err = i2c_smbus_write_byte_data(client, > > - MAX6639_REG_FAN_CONFIG1(i), > > - MAX6639_FAN_CONFIG1_PWM | rpm_range); > > + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG1(i), > > + MAX6639_FAN_CONFIG1_PWM | rpm_range); > > if (err) > > goto exit; > > > > /* Fans PWM polarity high by default */ > > if (max6639_info && max6639_info->pwm_polarity == 0) > > - err = i2c_smbus_write_byte_data(client, > > - MAX6639_REG_FAN_CONFIG2a(i), 0x00); > > + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x00); > > else > > - err = i2c_smbus_write_byte_data(client, > > - MAX6639_REG_FAN_CONFIG2a(i), 0x02); > > + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x02); > > if (err) > > goto exit; > > > > @@ -458,42 +439,31 @@ static int max6639_init_client(struct i2c_client *client, > > * /THERM full speed enable, > > * PWM frequency 25kHz, see also GCONFIG below > > */ > > - err = i2c_smbus_write_byte_data(client, > > - MAX6639_REG_FAN_CONFIG3(i), > > - MAX6639_FAN_CONFIG3_THERM_FULL_SPEED | 0x03); > > + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG3(i), > > + MAX6639_FAN_CONFIG3_THERM_FULL_SPEED | 0x03); > > if (err) > > goto exit; > > > > /* Max. temp. 80C/90C/100C */ > > - data->temp_therm[i] = 80; > > - data->temp_alert[i] = 90; > > - data->temp_ot[i] = 100; > > - err = i2c_smbus_write_byte_data(client, > > - MAX6639_REG_THERM_LIMIT(i), > > - data->temp_therm[i]); > > + err = regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(i), 80); > > if (err) > > goto exit; > > - err = i2c_smbus_write_byte_data(client, > > - MAX6639_REG_ALERT_LIMIT(i), > > - data->temp_alert[i]); > > + err = regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(i), 90); > > if (err) > > goto exit; > > - err = i2c_smbus_write_byte_data(client, > > - MAX6639_REG_OT_LIMIT(i), data->temp_ot[i]); > > + err = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(i), 100); > > if (err) > > goto exit; > > > > /* PWM 120/120 (i.e. 100%) */ > > - data->pwm[i] = 120; > > - err = i2c_smbus_write_byte_data(client, > > - MAX6639_REG_TARGTDUTY(i), data->pwm[i]); > > + err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(i), 120); > > if (err) > > goto exit; > > } > > /* Start monitoring */ > > - err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG, > > - MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL | > > - MAX6639_GCONFIG_PWM_FREQ_HI); > > + err = regmap_write(data->regmap, MAX6639_REG_GCONFIG, > > + MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL | > > + MAX6639_GCONFIG_PWM_FREQ_HI); > > exit: > > return err; > > } > > @@ -524,6 +494,30 @@ static void max6639_regulator_disable(void *data) > > regulator_disable(data); > > } > > > > +static bool max6639_regmap_is_volatile(struct device *dev, unsigned int reg) > > +{ > > + switch (reg) { > > + case MAX6639_REG_TEMP(0): > > + case MAX6639_REG_TEMP_EXT(0): > > + case MAX6639_REG_TEMP(1): > > + case MAX6639_REG_TEMP_EXT(1): > > + case MAX6639_REG_STATUS: > > + case MAX6639_REG_FAN_CNT(0): > > + case MAX6639_REG_FAN_CNT(1): > > pwm registers are also volatile. > > > + return true; > > + default: > > + return false; > > + } > > +} > > + > > +static const struct regmap_config max6639_regmap_config = { > > + .reg_bits = 8, > > + .val_bits = 8, > > + .max_register = MAX6639_REG_DEVREV, > > + .cache_type = REGCACHE_MAPLE, > > + .volatile_reg = max6639_regmap_is_volatile, > > +}; > > + > > static int max6639_probe(struct i2c_client *client) > > { > > struct device *dev = &client->dev; > > @@ -535,7 +529,11 @@ static int max6639_probe(struct i2c_client *client) > > if (!data) > > return -ENOMEM; > > > > - data->client = client; > > + data->regmap = devm_regmap_init_i2c(client, &max6639_regmap_config); > > + if (IS_ERR(data->regmap)) > > + return dev_err_probe(dev, > > + PTR_ERR(data->regmap), > > + "regmap initialization failed\n"); > > > > data->reg = devm_regulator_get_optional(dev, "fan"); > > if (IS_ERR(data->reg)) { > > @@ -573,25 +571,24 @@ static int max6639_probe(struct i2c_client *client) > > > > static int max6639_suspend(struct device *dev) > > { > > - struct i2c_client *client = to_i2c_client(dev); > > struct max6639_data *data = dev_get_drvdata(dev); > > - int ret = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG); > > + int ret, err; > > > > - if (ret < 0) > > - return ret; > > + err = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &ret); > > + > > Unnecessary empty line. Ack > > > + if (err < 0) > > + return err; > > > > if (data->reg) > > regulator_disable(data->reg); > > > > - return i2c_smbus_write_byte_data(client, > > - MAX6639_REG_GCONFIG, ret | MAX6639_GCONFIG_STANDBY); > > + return regmap_write(data->regmap, MAX6639_REG_GCONFIG, ret | MAX6639_GCONFIG_STANDBY); > > } > > > > static int max6639_resume(struct device *dev) > > { > > - struct i2c_client *client = to_i2c_client(dev); > > struct max6639_data *data = dev_get_drvdata(dev); > > - int ret; > > + int ret, err; > > > > if (data->reg) { > > ret = regulator_enable(data->reg); > > @@ -601,12 +598,11 @@ static int max6639_resume(struct device *dev) > > } > > } > > > > - ret = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG); > > - if (ret < 0) > > - return ret; > > + err = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &ret); > > + if (err < 0) > > + return err; > > > > - return i2c_smbus_write_byte_data(client, > > - MAX6639_REG_GCONFIG, ret & ~MAX6639_GCONFIG_STANDBY); > > + return regmap_write(data->regmap, MAX6639_REG_GCONFIG, ret & ~MAX6639_GCONFIG_STANDBY); > > } > > > > static const struct i2c_device_id max6639_id[] = { Regards, Naresh
On 5/2/24 10:25, Naresh Solanki wrote: [ ... ] >>> + u8 pwm[MAX6639_NDEV]; /* Register value: Duty cycle 0..120 */ >> >> pwm caching needs to be dropped as well. It is no longer initialized in >> max6639_init_client(), but updated and later used in pwm_store() and >> pwm_show(). Looking at the datasheet, the pwm registers are volatile >> and should not be cached in the first place. > Yes. I did that but found that the register is write only. i.e., Odd. The datasheet says that it is r/w or, rather, that reading it returns the _current_ pwm value and writing it sets the target pwm value in pwm mode. What happens when the register is read ? Thanks, Guenter
Hi Guenter, On Thu, 2 May 2024 at 23:52, Guenter Roeck <linux@roeck-us.net> wrote: > > On 5/2/24 10:25, Naresh Solanki wrote: > [ ... ] > > >>> + u8 pwm[MAX6639_NDEV]; /* Register value: Duty cycle 0..120 */ > >> > >> pwm caching needs to be dropped as well. It is no longer initialized in > >> max6639_init_client(), but updated and later used in pwm_store() and > >> pwm_show(). Looking at the datasheet, the pwm registers are volatile > >> and should not be cached in the first place. > > Yes. I did that but found that the register is write only. i.e., > > Odd. The datasheet says that it is r/w or, rather, that reading it returns > the _current_ pwm value and writing it sets the target pwm value in pwm mode. > > What happens when the register is read ? Upon revisiting the datasheet and conducting further testing, it appears that my previous response was inaccurate. After testing, it's clear that it reads what is being written & hence it's perfectly fine to remove variable pwm[] from local caching. Verified using below command: ---- i2cset -f -y 130 0x2e 0x26 0x10; i2cget -f -y 130 0x2e 0x26 0x10 ---- Regards, Naresh > > Thanks, > Guenter >
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index bafc0058c728..e14ae18a973b 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -1233,6 +1233,7 @@ config SENSORS_MAX6621 config SENSORS_MAX6639 tristate "Maxim MAX6639 sensor chip" depends on I2C + select REGMAP_I2C help If you say yes here you get support for the MAX6639 sensor chips. diff --git a/drivers/hwmon/max6639.c b/drivers/hwmon/max6639.c index 5dd0349e8bd0..b12d2098e259 100644 --- a/drivers/hwmon/max6639.c +++ b/drivers/hwmon/max6639.c @@ -20,6 +20,7 @@ #include <linux/err.h> #include <linux/mutex.h> #include <linux/platform_data/max6639.h> +#include <linux/regmap.h> /* Addresses to scan */ static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END }; @@ -57,6 +58,8 @@ static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END }; #define MAX6639_FAN_CONFIG3_THERM_FULL_SPEED 0x40 +#define MAX6639_NDEV 2 + static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 }; #define FAN_FROM_REG(val, rpm_range) ((val) == 0 || (val) == 255 ? \ @@ -67,22 +70,11 @@ static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 }; * Client data (each client gets its own) */ struct max6639_data { - struct i2c_client *client; + struct regmap *regmap; struct mutex update_lock; - bool valid; /* true if following fields are valid */ - unsigned long last_updated; /* In jiffies */ - - /* Register values sampled regularly */ - u16 temp[2]; /* Temperature, in 1/8 C, 0..255 C */ - bool temp_fault[2]; /* Detected temperature diode failure */ - u8 fan[2]; /* Register value: TACH count for fans >=30 */ - u8 status; /* Detected channel alarms and fan failures */ /* Register values only written to */ - u8 pwm[2]; /* Register value: Duty cycle 0..120 */ - u8 temp_therm[2]; /* THERM Temperature, 0..255 C (->_max) */ - u8 temp_alert[2]; /* ALERT Temperature, 0..255 C (->_crit) */ - u8 temp_ot[2]; /* OT Temperature, 0..255 C (->_emergency) */ + u8 pwm[MAX6639_NDEV]; /* Register value: Duty cycle 0..120 */ /* Register values initialized only once */ u8 ppr; /* Pulses per rotation 0..3 for 1..4 ppr */ @@ -92,90 +84,58 @@ struct max6639_data { struct regulator *reg; }; -static struct max6639_data *max6639_update_device(struct device *dev) -{ - struct max6639_data *data = dev_get_drvdata(dev); - struct i2c_client *client = data->client; - struct max6639_data *ret = data; - int i; - int status_reg; - - mutex_lock(&data->update_lock); - - if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) { - int res; - - dev_dbg(&client->dev, "Starting max6639 update\n"); - - status_reg = i2c_smbus_read_byte_data(client, - MAX6639_REG_STATUS); - if (status_reg < 0) { - ret = ERR_PTR(status_reg); - goto abort; - } - - data->status = status_reg; - - for (i = 0; i < 2; i++) { - res = i2c_smbus_read_byte_data(client, - MAX6639_REG_FAN_CNT(i)); - if (res < 0) { - ret = ERR_PTR(res); - goto abort; - } - data->fan[i] = res; - - res = i2c_smbus_read_byte_data(client, - MAX6639_REG_TEMP_EXT(i)); - if (res < 0) { - ret = ERR_PTR(res); - goto abort; - } - data->temp[i] = res >> 5; - data->temp_fault[i] = res & 0x01; - - res = i2c_smbus_read_byte_data(client, - MAX6639_REG_TEMP(i)); - if (res < 0) { - ret = ERR_PTR(res); - goto abort; - } - data->temp[i] |= res << 3; - } - - data->last_updated = jiffies; - data->valid = true; - } -abort: - mutex_unlock(&data->update_lock); - - return ret; -} - static ssize_t temp_input_show(struct device *dev, struct device_attribute *dev_attr, char *buf) { long temp; - struct max6639_data *data = max6639_update_device(dev); + struct max6639_data *data = dev_get_drvdata(dev); struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); + unsigned int val; + int res; if (IS_ERR(data)) return PTR_ERR(data); - temp = data->temp[attr->index] * 125; + mutex_lock(&data->update_lock); + res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val); + if (res < 0) + goto exit; + + temp = val >> 5; + res = regmap_read(data->regmap, MAX6639_REG_TEMP(attr->index), &val); + if (res < 0) + goto exit; + + temp |= val << 3; + temp *= 125; + +exit: + mutex_unlock(&data->update_lock); + if (res < 0) + return res; + return sprintf(buf, "%ld\n", temp); } static ssize_t temp_fault_show(struct device *dev, struct device_attribute *dev_attr, char *buf) { - struct max6639_data *data = max6639_update_device(dev); + struct max6639_data *data = dev_get_drvdata(dev); struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); + unsigned int val; + int res; if (IS_ERR(data)) return PTR_ERR(data); - return sprintf(buf, "%d\n", data->temp_fault[attr->index]); + mutex_lock(&data->update_lock); + res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val); + mutex_unlock(&data->update_lock); + + if (res < 0) + return res; + + return sprintf(buf, "%d\n", val & 1); } static ssize_t temp_max_show(struct device *dev, @@ -183,8 +143,17 @@ static ssize_t temp_max_show(struct device *dev, { struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); struct max6639_data *data = dev_get_drvdata(dev); + unsigned int val; + int res; - return sprintf(buf, "%d\n", (data->temp_therm[attr->index] * 1000)); + mutex_lock(&data->update_lock); + res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index), &val); + mutex_unlock(&data->update_lock); + + if (res < 0) + return res; + + return sprintf(buf, "%d\n", (val * 1000)); } static ssize_t temp_max_store(struct device *dev, @@ -193,7 +162,6 @@ static ssize_t temp_max_store(struct device *dev, { struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); struct max6639_data *data = dev_get_drvdata(dev); - struct i2c_client *client = data->client; unsigned long val; int res; @@ -202,10 +170,8 @@ static ssize_t temp_max_store(struct device *dev, return res; mutex_lock(&data->update_lock); - data->temp_therm[attr->index] = TEMP_LIMIT_TO_REG(val); - i2c_smbus_write_byte_data(client, - MAX6639_REG_THERM_LIMIT(attr->index), - data->temp_therm[attr->index]); + regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index), + TEMP_LIMIT_TO_REG(val)); mutex_unlock(&data->update_lock); return count; } @@ -215,8 +181,17 @@ static ssize_t temp_crit_show(struct device *dev, { struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); struct max6639_data *data = dev_get_drvdata(dev); + unsigned int val; + int res; + + mutex_lock(&data->update_lock); + res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index), &val); + mutex_unlock(&data->update_lock); - return sprintf(buf, "%d\n", (data->temp_alert[attr->index] * 1000)); + if (res < 0) + return res; + + return sprintf(buf, "%d\n", (val * 1000)); } static ssize_t temp_crit_store(struct device *dev, @@ -225,7 +200,6 @@ static ssize_t temp_crit_store(struct device *dev, { struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); struct max6639_data *data = dev_get_drvdata(dev); - struct i2c_client *client = data->client; unsigned long val; int res; @@ -234,10 +208,8 @@ static ssize_t temp_crit_store(struct device *dev, return res; mutex_lock(&data->update_lock); - data->temp_alert[attr->index] = TEMP_LIMIT_TO_REG(val); - i2c_smbus_write_byte_data(client, - MAX6639_REG_ALERT_LIMIT(attr->index), - data->temp_alert[attr->index]); + regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index), + TEMP_LIMIT_TO_REG(val)); mutex_unlock(&data->update_lock); return count; } @@ -248,8 +220,17 @@ static ssize_t temp_emergency_show(struct device *dev, { struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); struct max6639_data *data = dev_get_drvdata(dev); + unsigned int val; + int res; - return sprintf(buf, "%d\n", (data->temp_ot[attr->index] * 1000)); + mutex_lock(&data->update_lock); + res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), &val); + mutex_unlock(&data->update_lock); + + if (res < 0) + return res; + + return sprintf(buf, "%d\n", (val * 1000)); } static ssize_t temp_emergency_store(struct device *dev, @@ -258,7 +239,6 @@ static ssize_t temp_emergency_store(struct device *dev, { struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); struct max6639_data *data = dev_get_drvdata(dev); - struct i2c_client *client = data->client; unsigned long val; int res; @@ -267,10 +247,7 @@ static ssize_t temp_emergency_store(struct device *dev, return res; mutex_lock(&data->update_lock); - data->temp_ot[attr->index] = TEMP_LIMIT_TO_REG(val); - i2c_smbus_write_byte_data(client, - MAX6639_REG_OT_LIMIT(attr->index), - data->temp_ot[attr->index]); + regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), TEMP_LIMIT_TO_REG(val)); mutex_unlock(&data->update_lock); return count; } @@ -290,7 +267,6 @@ static ssize_t pwm_store(struct device *dev, { struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); struct max6639_data *data = dev_get_drvdata(dev); - struct i2c_client *client = data->client; unsigned long val; int res; @@ -299,12 +275,9 @@ static ssize_t pwm_store(struct device *dev, return res; val = clamp_val(val, 0, 255); - - mutex_lock(&data->update_lock); data->pwm[attr->index] = (u8)(val * 120 / 255); - i2c_smbus_write_byte_data(client, - MAX6639_REG_TARGTDUTY(attr->index), - data->pwm[attr->index]); + mutex_lock(&data->update_lock); + regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(attr->index), data->pwm[attr->index]); mutex_unlock(&data->update_lock); return count; } @@ -312,26 +285,35 @@ static ssize_t pwm_store(struct device *dev, static ssize_t fan_input_show(struct device *dev, struct device_attribute *dev_attr, char *buf) { - struct max6639_data *data = max6639_update_device(dev); + struct max6639_data *data = dev_get_drvdata(dev); struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); + unsigned int val; + int res; if (IS_ERR(data)) return PTR_ERR(data); - return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index], - data->rpm_range)); + res = regmap_read(data->regmap, MAX6639_REG_FAN_CNT(attr->index), &val); + if (res < 0) + return res; + + return sprintf(buf, "%d\n", FAN_FROM_REG(val, data->rpm_range)); } static ssize_t alarm_show(struct device *dev, struct device_attribute *dev_attr, char *buf) { - struct max6639_data *data = max6639_update_device(dev); + struct max6639_data *data = dev_get_drvdata(dev); struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr); + unsigned int val; + int res; if (IS_ERR(data)) return PTR_ERR(data); - return sprintf(buf, "%d\n", !!(data->status & (1 << attr->index))); + res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val); + + return sprintf(buf, "%d\n", !!(val & (1 << attr->index))); } static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0); @@ -401,6 +383,11 @@ static int rpm_range_to_reg(int range) return 1; /* default: 4000 RPM */ } +static int max6639_set_ppr(struct max6639_data *data, u8 channel, u8 ppr) +{ + return regmap_write(data->regmap, MAX6639_REG_FAN_PPR(channel), ppr << 6); +} + static int max6639_init_client(struct i2c_client *client, struct max6639_data *data) { @@ -408,49 +395,43 @@ static int max6639_init_client(struct i2c_client *client, dev_get_platdata(&client->dev); int i; int rpm_range = 1; /* default: 4000 RPM */ - int err; + int err, ppr; /* Reset chip to default values, see below for GCONFIG setup */ - err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG, - MAX6639_GCONFIG_POR); + err = regmap_write(data->regmap, MAX6639_REG_GCONFIG, MAX6639_GCONFIG_POR); if (err) goto exit; /* Fans pulse per revolution is 2 by default */ if (max6639_info && max6639_info->ppr > 0 && max6639_info->ppr < 5) - data->ppr = max6639_info->ppr; + ppr = max6639_info->ppr; else - data->ppr = 2; - data->ppr -= 1; + ppr = 2; + ppr -= 1; if (max6639_info) rpm_range = rpm_range_to_reg(max6639_info->rpm_range); data->rpm_range = rpm_range; - for (i = 0; i < 2; i++) { + for (i = 0; i < MAX6639_NDEV; i++) { /* Set Fan pulse per revolution */ - err = i2c_smbus_write_byte_data(client, - MAX6639_REG_FAN_PPR(i), - data->ppr << 6); + err = max6639_set_ppr(data, i, ppr); if (err) goto exit; /* Fans config PWM, RPM */ - err = i2c_smbus_write_byte_data(client, - MAX6639_REG_FAN_CONFIG1(i), - MAX6639_FAN_CONFIG1_PWM | rpm_range); + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG1(i), + MAX6639_FAN_CONFIG1_PWM | rpm_range); if (err) goto exit; /* Fans PWM polarity high by default */ if (max6639_info && max6639_info->pwm_polarity == 0) - err = i2c_smbus_write_byte_data(client, - MAX6639_REG_FAN_CONFIG2a(i), 0x00); + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x00); else - err = i2c_smbus_write_byte_data(client, - MAX6639_REG_FAN_CONFIG2a(i), 0x02); + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x02); if (err) goto exit; @@ -458,42 +439,31 @@ static int max6639_init_client(struct i2c_client *client, * /THERM full speed enable, * PWM frequency 25kHz, see also GCONFIG below */ - err = i2c_smbus_write_byte_data(client, - MAX6639_REG_FAN_CONFIG3(i), - MAX6639_FAN_CONFIG3_THERM_FULL_SPEED | 0x03); + err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG3(i), + MAX6639_FAN_CONFIG3_THERM_FULL_SPEED | 0x03); if (err) goto exit; /* Max. temp. 80C/90C/100C */ - data->temp_therm[i] = 80; - data->temp_alert[i] = 90; - data->temp_ot[i] = 100; - err = i2c_smbus_write_byte_data(client, - MAX6639_REG_THERM_LIMIT(i), - data->temp_therm[i]); + err = regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(i), 80); if (err) goto exit; - err = i2c_smbus_write_byte_data(client, - MAX6639_REG_ALERT_LIMIT(i), - data->temp_alert[i]); + err = regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(i), 90); if (err) goto exit; - err = i2c_smbus_write_byte_data(client, - MAX6639_REG_OT_LIMIT(i), data->temp_ot[i]); + err = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(i), 100); if (err) goto exit; /* PWM 120/120 (i.e. 100%) */ - data->pwm[i] = 120; - err = i2c_smbus_write_byte_data(client, - MAX6639_REG_TARGTDUTY(i), data->pwm[i]); + err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(i), 120); if (err) goto exit; } /* Start monitoring */ - err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG, - MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL | - MAX6639_GCONFIG_PWM_FREQ_HI); + err = regmap_write(data->regmap, MAX6639_REG_GCONFIG, + MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL | + MAX6639_GCONFIG_PWM_FREQ_HI); exit: return err; } @@ -524,6 +494,30 @@ static void max6639_regulator_disable(void *data) regulator_disable(data); } +static bool max6639_regmap_is_volatile(struct device *dev, unsigned int reg) +{ + switch (reg) { + case MAX6639_REG_TEMP(0): + case MAX6639_REG_TEMP_EXT(0): + case MAX6639_REG_TEMP(1): + case MAX6639_REG_TEMP_EXT(1): + case MAX6639_REG_STATUS: + case MAX6639_REG_FAN_CNT(0): + case MAX6639_REG_FAN_CNT(1): + return true; + default: + return false; + } +} + +static const struct regmap_config max6639_regmap_config = { + .reg_bits = 8, + .val_bits = 8, + .max_register = MAX6639_REG_DEVREV, + .cache_type = REGCACHE_MAPLE, + .volatile_reg = max6639_regmap_is_volatile, +}; + static int max6639_probe(struct i2c_client *client) { struct device *dev = &client->dev; @@ -535,7 +529,11 @@ static int max6639_probe(struct i2c_client *client) if (!data) return -ENOMEM; - data->client = client; + data->regmap = devm_regmap_init_i2c(client, &max6639_regmap_config); + if (IS_ERR(data->regmap)) + return dev_err_probe(dev, + PTR_ERR(data->regmap), + "regmap initialization failed\n"); data->reg = devm_regulator_get_optional(dev, "fan"); if (IS_ERR(data->reg)) { @@ -573,25 +571,24 @@ static int max6639_probe(struct i2c_client *client) static int max6639_suspend(struct device *dev) { - struct i2c_client *client = to_i2c_client(dev); struct max6639_data *data = dev_get_drvdata(dev); - int ret = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG); + int ret, err; - if (ret < 0) - return ret; + err = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &ret); + + if (err < 0) + return err; if (data->reg) regulator_disable(data->reg); - return i2c_smbus_write_byte_data(client, - MAX6639_REG_GCONFIG, ret | MAX6639_GCONFIG_STANDBY); + return regmap_write(data->regmap, MAX6639_REG_GCONFIG, ret | MAX6639_GCONFIG_STANDBY); } static int max6639_resume(struct device *dev) { - struct i2c_client *client = to_i2c_client(dev); struct max6639_data *data = dev_get_drvdata(dev); - int ret; + int ret, err; if (data->reg) { ret = regulator_enable(data->reg); @@ -601,12 +598,11 @@ static int max6639_resume(struct device *dev) } } - ret = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG); - if (ret < 0) - return ret; + err = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &ret); + if (err < 0) + return err; - return i2c_smbus_write_byte_data(client, - MAX6639_REG_GCONFIG, ret & ~MAX6639_GCONFIG_STANDBY); + return regmap_write(data->regmap, MAX6639_REG_GCONFIG, ret & ~MAX6639_GCONFIG_STANDBY); } static const struct i2c_device_id max6639_id[] = {
Add regmap support & remove local caching. Signed-off-by: Naresh Solanki <naresh.solanki@9elements.com> --- drivers/hwmon/Kconfig | 1 + drivers/hwmon/max6639.c | 310 ++++++++++++++++++++-------------------- 2 files changed, 154 insertions(+), 157 deletions(-) base-commit: 8b3aa2c488653fa1e127cf6e11499a8cbbaccad0