Skip to contentSkip to conversation

hwmon: (max6639) : Update hwmon init using info

PATCH Superseded Naresh Solanki 3 participants 6 messages May 28, 2024 – May 31, 2024 Hardware monitoring

v2 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 hwmon: (max6639) : Update hwmon init using info

Update hwmon init with info instead of group.
Also added additional attribute for fan i.e.,
fanY_pulse
pwmY_freq

---
 drivers/hwmon/max6639.c | 536 ++++++++++++++++++++++++++--------------
 1 file changed, 357 insertions(+), 179 deletions(-)
drivers/hwmon/max6639.c +357 -179
index cbb595fe47aa..b757a85837e8 100644
@@ -55,13 +55,17 @@ static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
 #define MAX6639_GCONFIG_PWM_FREQ_HI		0x08
 
 #define MAX6639_FAN_CONFIG1_PWM			0x80
-
+#define MAX6639_FAN_CONFIG3_FREQ_MASK		0x03
 #define MAX6639_FAN_CONFIG3_THERM_FULL_SPEED	0x40
 
 #define MAX6639_NUM_CHANNELS			2
 
 static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
 
+/* Supported PWM frequency */
+static const unsigned int freq_table[] = { 20, 33, 50, 100, 5000, 8333, 12500,
+					   25000 };
+
 #define FAN_FROM_REG(val, rpm_range)	((val) == 0 || (val) == 255 ? \
 				0 : (rpm_ranges[rpm_range] * 30) / (val))
 #define TEMP_LIMIT_TO_REG(val)	clamp_val((val) / 1000, 0, 255)
@@ -73,19 +77,16 @@ struct max6639_data {
 	struct regmap *regmap;
 
 	/* Register values initialized only once */
-	u8 ppr;			/* Pulses per rotation 0..3 for 1..4 ppr */
-	u8 rpm_range;		/* Index in above rpm_ranges table */
+	u8 ppr[MAX6639_NUM_CHANNELS];	/* Pulses per rotation 0..3 for 1..4 ppr */
+	u8 rpm_range[MAX6639_NUM_CHANNELS]; /* Index in above rpm_ranges table */
 
 	/* Optional regulator for FAN supply */
 	struct regulator *reg;
 };
 
-static ssize_t temp_input_show(struct device *dev,
-			       struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_input(struct device *dev, int channel, long *temp)
 {
-	long temp;
 	struct max6639_data *data = dev_get_drvdata(dev);
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 	unsigned int val;
 	int res;
 
@@ -93,251 +94,425 @@ static ssize_t temp_input_show(struct device *dev,
 	 * Lock isn't needed as MAX6639_REG_TEMP wpnt change for at least 250ms after reading
 	 * MAX6639_REG_TEMP_EXT
 	 */
-	res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val);
+	res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(channel), &val);
 	if (res < 0)
 		return res;
 
-	temp = val >> 5;
-	res = regmap_read(data->regmap, MAX6639_REG_TEMP(attr->index), &val);
+	*temp = val >> 5;
+	res = regmap_read(data->regmap, MAX6639_REG_TEMP(channel), &val);
 	if (res < 0)
 		return res;
 
-	temp |= val << 3;
-	temp *= 125;
+	*temp |= val << 3;
+	*temp *= 125;
 
-	return sprintf(buf, "%ld\n", temp);
+	return res;
 }
 
-static ssize_t temp_fault_show(struct device *dev,
-			       struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_fault(struct device *dev, int channel, long *fault)
 {
 	struct max6639_data *data = dev_get_drvdata(dev);
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 	unsigned int val;
 	int res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val);
-	if (res < 0)
-		return res;
+	res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(channel), &val);
+	*fault = val & 1;
 
-	return sprintf(buf, "%d\n", val & 1);
+	return res;
 }
 
-static ssize_t temp_max_show(struct device *dev,
-			     struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_max(struct device *dev, int channel, long *max)
 {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 	struct max6639_data *data = dev_get_drvdata(dev);
 	unsigned int val;
 	int res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index), &val);
-	if (res < 0)
-		return res;
+	res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(channel), &val);
+	*max = val * 1000;
 
-	return sprintf(buf, "%d\n", (val * 1000));
+	return res;
 }
 
-static ssize_t temp_max_store(struct device *dev,
-			      struct device_attribute *dev_attr,
-			      const char *buf, size_t count)
+static int max6639_temp_read_crit(struct device *dev, int channel, long *crit)
 {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned long val;
+	unsigned int val;
 	int res;
 
-	res = kstrtoul(buf, 10, &val);
-	if (res)
-		return res;
+	res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), &val);
+	*crit = val * 1000;
 
-	regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index),
-		     TEMP_LIMIT_TO_REG(val));
-	return count;
+	return res;
 }
 
-static ssize_t temp_crit_show(struct device *dev,
-			      struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_emergency(struct device *dev, int channel, long *emerg)
 {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 	struct max6639_data *data = dev_get_drvdata(dev);
 	unsigned int val;
 	int res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index), &val);
-	if (res < 0)
-		return res;
+	res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(channel), &val);
+	*emerg = val * 1000;
 
-	return sprintf(buf, "%d\n", (val * 1000));
+	return res;
 }
 
-static ssize_t temp_crit_store(struct device *dev,
-			       struct device_attribute *dev_attr,
-			       const char *buf, size_t count)
+static int max6639_get_status(struct device *dev, unsigned int *status)
 {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned long val;
+	unsigned int val;
 	int res;
 
-	res = kstrtoul(buf, 10, &val);
-	if (res)
-		return res;
+	res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val);
+	*status = val;
 
-	regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index),
-		     TEMP_LIMIT_TO_REG(val));
-	return count;
+	return res;
 }
 
-static ssize_t temp_emergency_show(struct device *dev,
-				   struct device_attribute *dev_attr,
-				   char *buf)
+static int max6639_temp_set_max(struct max6639_data *data, int channel, unsigned long val)
 {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned int val;
 	int res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), &val);
-	if (res < 0)
-		return res;
-
-	return sprintf(buf, "%d\n", (val * 1000));
+	res = regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(channel),
+			   TEMP_LIMIT_TO_REG(val));
+	return res;
 }
 
-static ssize_t temp_emergency_store(struct device *dev,
-				    struct device_attribute *dev_attr,
-				    const char *buf, size_t count)
+static int max6639_temp_set_crit(struct max6639_data *data, int channel, unsigned long val)
 {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned long val;
 	int res;
 
-	res = kstrtoul(buf, 10, &val);
-	if (res)
-		return res;
+	res = regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
+
+	return res;
+}
+
+static int max6639_temp_set_emergency(struct max6639_data *data, int channel, unsigned long val)
+{
+	int res;
 
-	regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), TEMP_LIMIT_TO_REG(val));
+	res = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
 
-	return count;
+	return res;
 }
 
-static ssize_t pwm_show(struct device *dev, struct device_attribute *dev_attr,
-			char *buf)
+static int max6639_read_fan(struct device *dev, u32 attr, int channel,
+			    long *fan_val)
 {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned int val;
-	int res;
+	unsigned int val, res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(attr->index), &val);
-	if (res < 0)
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	switch (attr) {
+	case hwmon_fan_input:
+		res = regmap_read(data->regmap, MAX6639_REG_FAN_CNT(channel), &val);
+		*fan_val = FAN_FROM_REG(val, data->rpm_range[channel]);
+		return res;
+	case hwmon_fan_fault:
+		res = max6639_get_status(dev, &val);
+		*fan_val = !!(val & (2 >> channel));
 		return res;
+	case hwmon_fan_pulses:
+		*fan_val = data->ppr[channel];
+		return 0;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
 
-	return sprintf(buf, "%d\n", val * 255 / 120);
+static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr)
+{
+	return regmap_write(data->regmap, MAX6639_REG_FAN_PPR(channel), ppr-- << 6);
 }
 
-static ssize_t pwm_store(struct device *dev,
-			 struct device_attribute *dev_attr, const char *buf,
-			 size_t count)
+static int max6639_write_fan(struct device *dev, u32 attr, int channel,
+			     long val)
 {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned long val;
-	int res;
+	int err;
 
-	res = kstrtoul(buf, 10, &val);
-	if (res)
-		return res;
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	switch (attr) {
+	case hwmon_fan_pulses:
+		if (val <= 0 || val > 5) {
+			dev_err(dev, "invalid pulses-per-revolution %ld. Valid range id 1 - 4.",
+				val);
+			return -EINVAL;
+		}
+		/* Set Fan pulse per revolution */
+		err = max6639_set_ppr(data, channel, val);
+		if (err)
+			dev_err(dev, "Failed to set pulses-per-revolution");
+		else
+			data->ppr[channel] = val;
+		return 0;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
 
-	val = clamp_val(val, 0, 255);
+static umode_t max6639_fan_is_visible(const void *_data, u32 attr, int channel)
+{
+	struct max6639_data *data = (struct max6639_data *)_data;
 
-	regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(attr->index), val * 120 / 255);
+	if (IS_ERR(data))
+		return PTR_ERR(data);
 
-	return count;
+	switch (attr) {
+	case hwmon_fan_input:
+	case hwmon_fan_fault:
+		return 0444;
+	case hwmon_fan_pulses:
+		return 0644;
+	default:
+		return 0;
+	}
 }
 
-static ssize_t fan_input_show(struct device *dev,
-			      struct device_attribute *dev_attr, char *buf)
+static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
+			    long *pwm_val)
 {
 	struct max6639_data *data = dev_get_drvdata(dev);
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-	unsigned int val;
-	int res;
-
-	res = regmap_read(data->regmap, MAX6639_REG_FAN_CNT(attr->index), &val);
-	if (res < 0)
+	unsigned int val, res;
+
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	switch (attr) {
+	case hwmon_pwm_input:
+		res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(channel), &val);
+		*pwm_val = val * 255 / 120;
+		return 0;
+	case hwmon_pwm_freq:
+		u8 x;
+
+		res = regmap_read(data->regmap, MAX6639_REG_FAN_CONFIG3(channel), &val);
+		if (res < 0)
+			return res;
+		x = val & MAX6639_FAN_CONFIG3_FREQ_MASK;
+
+		res = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &val);
+		if (res < 0)
+			return res;
+
+		if (val & MAX6639_GCONFIG_PWM_FREQ_HI)
+			x |= 0x4;
+		x &= 0x7;
+		*pwm_val = freq_table[x];
 		return res;
-
-	return sprintf(buf, "%d\n", FAN_FROM_REG(val, data->rpm_range));
+	default:
+		return -EOPNOTSUPP;
+	}
 }
 
-static ssize_t alarm_show(struct device *dev,
-			  struct device_attribute *dev_attr, char *buf)
+static int max6639_write_pwm(struct device *dev, u32 attr, int channel,
+			     long val)
 {
 	struct max6639_data *data = dev_get_drvdata(dev);
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-	unsigned int val;
+	int err;
+
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	switch (attr) {
+	case hwmon_pwm_input:
+		val = clamp_val(val, 0, 255);
+		err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(channel),
+				   val * 120 / 255);
+		return err;
+	case hwmon_pwm_freq:
+		u8 x;
+
+		val = clamp_val(val, 0, 25000);
+		/* Chip supports limited number of frequency */
+		for (x = 0; x < sizeof(freq_table); x++)
+			if (val <= freq_table[x])
+				break;
+
+		err = regmap_update_bits(data->regmap, MAX6639_REG_FAN_CONFIG3(channel),
+					 MAX6639_FAN_CONFIG3_FREQ_MASK, x);
+		if (err < 0)
+			return err;
+
+		if (x >> 2)
+			err = regmap_set_bits(data->regmap, MAX6639_REG_GCONFIG,
+					      MAX6639_GCONFIG_PWM_FREQ_HI);
+		else
+			err = regmap_clear_bits(data->regmap, MAX6639_REG_GCONFIG,
+						MAX6639_GCONFIG_PWM_FREQ_HI);
+		return err;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+static umode_t max6639_pwm_is_visible(const void *_data, u32 attr, int channel)
+{
+	struct max6639_data *data = (struct max6639_data *)_data;
+
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	switch (attr) {
+	case hwmon_pwm_input:
+	case hwmon_pwm_freq:
+		return 0644;
+	default:
+		return 0;
+	}
+}
+
+static int max6639_read_temp(struct device *dev, u32 attr, int channel,
+			     long *val)
+{
+	unsigned int status;
 	int res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val);
-	if (res < 0)
+	switch (attr) {
+	case hwmon_temp_input:
+		res = max6639_temp_read_input(dev, channel, val);
+		return res;
+	case hwmon_temp_fault:
+		res = max6639_temp_read_fault(dev, channel, val);
 		return res;
+	case hwmon_temp_max:
+		res = max6639_temp_read_max(dev, channel, val);
+		return res;
+	case hwmon_temp_crit:
+		res = max6639_temp_read_crit(dev, channel, val);
+		return res;
+	case hwmon_temp_emergency:
+		res = max6639_temp_read_emergency(dev, channel, val);
+		return res;
+	case hwmon_temp_max_alarm:
+		res = max6639_get_status(dev, &status);
+		*val = !!(status & (0x08 >> channel));
+		return res;
+	case hwmon_temp_crit_alarm:
+		res = max6639_get_status(dev, &status);
+		*val = !!(status & (0x80 >> channel));
+		return res;
+	case hwmon_temp_emergency_alarm:
+		res = max6639_get_status(dev, &status);
+		*val = !!(status & (0x20 >> channel));
+		return res;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+static int max6639_write_temp(struct device *dev, u32 attr, int channel,
+			      long val)
+{
+	struct max6639_data *data = dev_get_drvdata(dev);
+
+	switch (attr) {
+	case hwmon_temp_max:
+		return max6639_temp_set_max(data, channel, val);
+	case hwmon_temp_crit:
+		return max6639_temp_set_crit(data, channel, val);
+	case hwmon_temp_emergency:
+		return max6639_temp_set_emergency(data, channel, val);
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+static umode_t max6639_temp_is_visible(const void *_data, u32 attr, int channel)
+{
+	switch (attr) {
+	case hwmon_temp_input:
+	case hwmon_temp_fault:
+	case hwmon_temp_max_alarm:
+	case hwmon_temp_crit_alarm:
+	case hwmon_temp_emergency_alarm:
+		return 0444;
+	case hwmon_temp_max:
+	case hwmon_temp_crit:
+	case hwmon_temp_emergency:
+		return 0644;
+	default:
+		return 0;
+	}
+}
+
+static int max6639_read(struct device *dev, enum hwmon_sensor_types type,
+			u32 attr, int channel, long *val)
+{
+	switch (type) {
+	case hwmon_fan:
+		return max6639_read_fan(dev, attr, channel, val);
+	case hwmon_pwm:
+		return max6639_read_pwm(dev, attr, channel, val);
+	case hwmon_temp:
+		return max6639_read_temp(dev, attr, channel, val);
+	default:
+		return -EOPNOTSUPP;
+	}
+}
 
-	return sprintf(buf, "%d\n", !!(val & (1 << attr->index)));
+static int max6639_write(struct device *dev, enum hwmon_sensor_types type,
+			 u32 attr, int channel, long val)
+{
+	switch (type) {
+	case hwmon_fan:
+		return max6639_write_fan(dev, attr, channel, val);
+	case hwmon_pwm:
+		return max6639_write_pwm(dev, attr, channel, val);
+	case hwmon_temp:
+		return max6639_write_temp(dev, attr, channel, val);
+	default:
+		return -EOPNOTSUPP;
+	}
 }
 
-static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0);
-static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_input, 1);
-static SENSOR_DEVICE_ATTR_RO(temp1_fault, temp_fault, 0);
-static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp_fault, 1);
-static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
-static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
-static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp_crit, 0);
-static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp_crit, 1);
-static SENSOR_DEVICE_ATTR_RW(temp1_emergency, temp_emergency, 0);
-static SENSOR_DEVICE_ATTR_RW(temp2_emergency, temp_emergency, 1);
-static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
-static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
-static SENSOR_DEVICE_ATTR_RO(fan1_input, fan_input, 0);
-static SENSOR_DEVICE_ATTR_RO(fan2_input, fan_input, 1);
-static SENSOR_DEVICE_ATTR_RO(fan1_fault, alarm, 1);
-static SENSOR_DEVICE_ATTR_RO(fan2_fault, alarm, 0);
-static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 3);
-static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, 2);
-static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, alarm, 7);
-static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, 6);
-static SENSOR_DEVICE_ATTR_RO(temp1_emergency_alarm, alarm, 5);
-static SENSOR_DEVICE_ATTR_RO(temp2_emergency_alarm, alarm, 4);
-
-
-static struct attribute *max6639_attrs[] = {
-	&sensor_dev_attr_temp1_input.dev_attr.attr,
-	&sensor_dev_attr_temp2_input.dev_attr.attr,
-	&sensor_dev_attr_temp1_fault.dev_attr.attr,
-	&sensor_dev_attr_temp2_fault.dev_attr.attr,
-	&sensor_dev_attr_temp1_max.dev_attr.attr,
-	&sensor_dev_attr_temp2_max.dev_attr.attr,
-	&sensor_dev_attr_temp1_crit.dev_attr.attr,
-	&sensor_dev_attr_temp2_crit.dev_attr.attr,
-	&sensor_dev_attr_temp1_emergency.dev_attr.attr,
-	&sensor_dev_attr_temp2_emergency.dev_attr.attr,
-	&sensor_dev_attr_pwm1.dev_attr.attr,
-	&sensor_dev_attr_pwm2.dev_attr.attr,
-	&sensor_dev_attr_fan1_input.dev_attr.attr,
-	&sensor_dev_attr_fan2_input.dev_attr.attr,
-	&sensor_dev_attr_fan1_fault.dev_attr.attr,
-	&sensor_dev_attr_fan2_fault.dev_attr.attr,
-	&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
-	&sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
-	&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
-	&sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
-	&sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr,
-	&sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr,
+static umode_t max6639_is_visible(const void *data,
+				  enum hwmon_sensor_types type,
+				  u32 attr, int channel)
+{
+	switch (type) {
+	case hwmon_fan:
+		return max6639_fan_is_visible(data, attr, channel);
+	case hwmon_pwm:
+		return max6639_pwm_is_visible(data, attr, channel);
+	case hwmon_temp:
+		return max6639_temp_is_visible(data, attr, channel);
+	default:
+		return 0;
+	}
+}
+
+static const struct hwmon_channel_info * const max6639_info[] = {
+	HWMON_CHANNEL_INFO(fan,
+			   HWMON_F_INPUT | HWMON_F_FAULT | HWMON_F_PULSES,
+			   HWMON_F_INPUT | HWMON_F_FAULT | HWMON_F_PULSES),
+	HWMON_CHANNEL_INFO(pwm,
+			   HWMON_PWM_INPUT | HWMON_PWM_FREQ,
+			   HWMON_PWM_INPUT | HWMON_PWM_FREQ),
+	HWMON_CHANNEL_INFO(temp,
+			   HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_MAX | HWMON_T_MAX_ALARM |
+			   HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_EMERGENCY |
+			   HWMON_T_EMERGENCY_ALARM,
+			   HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_MAX | HWMON_T_MAX_ALARM |
+			   HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_EMERGENCY |
+			   HWMON_T_EMERGENCY_ALARM),
 	NULL
 };
-ATTRIBUTE_GROUPS(max6639);
+
+static const struct hwmon_ops max6639_hwmon_ops = {
+	.is_visible = max6639_is_visible,
+	.read = max6639_read,
+	.write = max6639_write,
+};
+
+static const struct hwmon_chip_info max6639_chip_info = {
+	.ops = &max6639_hwmon_ops,
+	.info = max6639_info,
+};
 
 /*
  *  returns respective index in rpm_ranges table
@@ -355,11 +530,6 @@ 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)
 {
@@ -380,14 +550,16 @@ static int max6639_init_client(struct i2c_client *client,
 		ppr = max6639_info->ppr;
 	else
 		ppr = 2;
-	ppr -= 1;
+
+	data->ppr[0] = ppr;
+	data->ppr[1] = ppr;
 
 	if (max6639_info)
 		rpm_range = rpm_range_to_reg(max6639_info->rpm_range);
-	data->rpm_range = rpm_range;
+	data->rpm_range[0] = rpm_range;
+	data->rpm_range[1] = rpm_range;
 
 	for (i = 0; i < MAX6639_NUM_CHANNELS; i++) {
-
 		/* Set Fan pulse per revolution */
 		err = max6639_set_ppr(data, i, ppr);
 		if (err)
@@ -395,15 +567,17 @@ static int max6639_init_client(struct i2c_client *client,
 
 		/* Fans config PWM, RPM */
 		err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG1(i),
-				   MAX6639_FAN_CONFIG1_PWM | rpm_range);
+				   MAX6639_FAN_CONFIG1_PWM | data->rpm_range[i]);
 		if (err)
 			return err;
 
 		/* Fans PWM polarity high by default */
-		if (max6639_info && max6639_info->pwm_polarity == 0)
-			err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x00);
-		else
-			err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x02);
+		if (max6639_info) {
+			if (max6639_info->pwm_polarity == 0)
+				err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x00);
+			else
+				err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x02);
+		}
 		if (err)
 			return err;
 
@@ -534,9 +708,13 @@ static int max6639_probe(struct i2c_client *client)
 	if (err < 0)
 		return err;
 
-	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-							   data,
-							   max6639_groups);
+	hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
+							 data, &max6639_chip_info,
+							 NULL);
+
+	if (IS_ERR(hwmon_dev))
+		return dev_err_probe(dev, PTR_ERR(hwmon_dev),
+				     "unable to register hwmon device\n");
 	return PTR_ERR_OR_ZERO(hwmon_dev);
 }
 

base-commit: 5fbf8734fb36cf67339f599f0e51747a6aff690c

Signature · 1 line
2.42.0
#1 lore raw
kernel test robot noticed the following build warnings:

Hi Naresh,

kernel test robot noticed the following build warnings:

[auto build test WARNING on 5fbf8734fb36cf67339f599f0e51747a6aff690c]

url:    https://github.com/intel-lab-lkp/linux/commits/Naresh-Solanki/hwmon-max6639-Update-hwmon-init-using-info/20240528-172245
base:   5fbf8734fb36cf67339f599f0e51747a6aff690c
patch link:    https://lore.kernel.org/r/20240528091808.863702-1-naresh.solanki%409elements.com
patch subject: [PATCH v2] hwmon: (max6639) : Update hwmon init using info
config: i386-buildonly-randconfig-003-20240528 (https://download.01.org/0day-ci/archive/20240528/[email protected]/config)
compiler: clang version 18.1.5 (https://github.com/llvm/llvm-project 617a15a9eac96088ae5e9134248d8236e34b91b1)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240528/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All warnings (new ones prefixed by >>):

>> drivers/hwmon/max6639.c:291:3: warning: label followed by a declaration is a C23 extension [-Wc23-extensions]
     291 |                 u8 x;
         |                 ^
   drivers/hwmon/max6639.c:328:3: warning: label followed by a declaration is a C23 extension [-Wc23-extensions]
     328 |                 u8 x;
         |                 ^

2 warnings generated.

vim +291 drivers/hwmon/max6639.c

275
276 static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
277 long *pwm_val)
278 {
279 struct max6639_data *data = dev_get_drvdata(dev);
280 unsigned int val, res;
281
282 if (IS_ERR(data))
283 return PTR_ERR(data);
284
285 switch (attr) {
286 case hwmon_pwm_input:
287 res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(channel), &val);
288 *pwm_val = val * 255 / 120;
289 return 0;
290 case hwmon_pwm_freq:

 > 291			u8 x;

292
293 res = regmap_read(data->regmap, MAX6639_REG_FAN_CONFIG3(channel), &val);
294 if (res < 0)
295 return res;
296 x = val & MAX6639_FAN_CONFIG3_FREQ_MASK;
297
298 res = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &val);
299 if (res < 0)
300 return res;
301
302 if (val & MAX6639_GCONFIG_PWM_FREQ_HI)
303 x |= 0x4;
304 x &= 0x7;
305 *pwm_val = freq_table[x];
306 return res;
307 default:
308 return -EOPNOTSUPP;
309 }
310 }
311

Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
#2 lore raw
In reply to Naresh Solanki
kernel test robot noticed the following build errors:

Hi Naresh,

kernel test robot noticed the following build errors:

[auto build test ERROR on 5fbf8734fb36cf67339f599f0e51747a6aff690c]

url:    https://github.com/intel-lab-lkp/linux/commits/Naresh-Solanki/hwmon-max6639-Update-hwmon-init-using-info/20240528-172245
base:   5fbf8734fb36cf67339f599f0e51747a6aff690c
patch link:    https://lore.kernel.org/r/20240528091808.863702-1-naresh.solanki%409elements.com
patch subject: [PATCH v2] hwmon: (max6639) : Update hwmon init using info
config: i386-randconfig-015-20240528 (https://download.01.org/0day-ci/archive/20240528/[email protected]/config)
compiler: gcc-10 (Ubuntu 10.5.0-1ubuntu1) 10.5.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240528/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All errors (new ones prefixed by >>):

drivers/hwmon/max6639.c: In function 'max6639_read_pwm':

>> drivers/hwmon/max6639.c:291:3: error: a label can only be part of a statement and a declaration is not a statement
     291 |   u8 x;
         |   ^~
   drivers/hwmon/max6639.c: In function 'max6639_write_pwm':
   drivers/hwmon/max6639.c:328:3: error: a label can only be part of a statement and a declaration is not a statement
     328 |   u8 x;
         |   ^~

vim +291 drivers/hwmon/max6639.c

275
276 static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
277 long *pwm_val)
278 {
279 struct max6639_data *data = dev_get_drvdata(dev);
280 unsigned int val, res;
281
282 if (IS_ERR(data))
283 return PTR_ERR(data);
284
285 switch (attr) {
286 case hwmon_pwm_input:
287 res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(channel), &val);
288 *pwm_val = val * 255 / 120;
289 return 0;
290 case hwmon_pwm_freq:

 > 291			u8 x;

292
293 res = regmap_read(data->regmap, MAX6639_REG_FAN_CONFIG3(channel), &val);
294 if (res < 0)
295 return res;
296 x = val & MAX6639_FAN_CONFIG3_FREQ_MASK;
297
298 res = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &val);
299 if (res < 0)
300 return res;
301
302 if (val & MAX6639_GCONFIG_PWM_FREQ_HI)
303 x |= 0x4;
304 x &= 0x7;
305 *pwm_val = freq_table[x];
306 return res;
307 default:
308 return -EOPNOTSUPP;
309 }
310 }
311

Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
maintainer
#3 lore raw
In reply to Naresh Solanki
Quoted 1 line · Naresh Solanki

Update hwmon init with info instead of group.

A more detailed description which doesn't require insider knowledge would be helpful.

Quoted 3 lines

Also added additional attribute for fan i.e.,
fanY_pulse
pwmY_freq

Separate patches for additional attributes, please.

Quoted 65 lines
---
  drivers/hwmon/max6639.c | 536 ++++++++++++++++++++++++++--------------
  1 file changed, 357 insertions(+), 179 deletions(-)
drivers/hwmon/max6639.c +11 -10
index cbb595fe47aa..b757a85837e8 100644
@@ -55,13 +55,17 @@ static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
  #define MAX6639_GCONFIG_PWM_FREQ_HI		0x08
 
  #define MAX6639_FAN_CONFIG1_PWM			0x80
-
+#define MAX6639_FAN_CONFIG3_FREQ_MASK		0x03
  #define MAX6639_FAN_CONFIG3_THERM_FULL_SPEED	0x40
 
  #define MAX6639_NUM_CHANNELS			2
 
  static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
 
+/* Supported PWM frequency */
+static const unsigned int freq_table[] = { 20, 33, 50, 100, 5000, 8333, 12500,
+					   25000 };
+
  #define FAN_FROM_REG(val, rpm_range)	((val) == 0 || (val) == 255 ? \
  				0 : (rpm_ranges[rpm_range] * 30) / (val))
  #define TEMP_LIMIT_TO_REG(val)	clamp_val((val) / 1000, 0, 255)
@@ -73,19 +77,16 @@ struct max6639_data {
  	struct regmap *regmap;
 
  	/* Register values initialized only once */
-	u8 ppr;			/* Pulses per rotation 0..3 for 1..4 ppr */
-	u8 rpm_range;		/* Index in above rpm_ranges table */
+	u8 ppr[MAX6639_NUM_CHANNELS];	/* Pulses per rotation 0..3 for 1..4 ppr */
+	u8 rpm_range[MAX6639_NUM_CHANNELS]; /* Index in above rpm_ranges table */
 
  	/* Optional regulator for FAN supply */
  	struct regulator *reg;
  };
 
-static ssize_t temp_input_show(struct device *dev,
-			       struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_input(struct device *dev, int channel, long *temp)
  {
-	long temp;
  	struct max6639_data *data = dev_get_drvdata(dev);
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
  	unsigned int val;
  	int res;
 
@@ -93,251 +94,425 @@ static ssize_t temp_input_show(struct device *dev,
  	 * Lock isn't needed as MAX6639_REG_TEMP wpnt change for at least 250ms after reading
  	 * MAX6639_REG_TEMP_EXT
  	 */
-	res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val);
+	res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(channel), &val);
  	if (res < 0)
  		return res;
 
-	temp = val >> 5;
-	res = regmap_read(data->regmap, MAX6639_REG_TEMP(attr->index), &val);
+	*temp = val >> 5;
+	res = regmap_read(data->regmap, MAX6639_REG_TEMP(channel), &val);

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 109

Quoted 10 lines
drivers/hwmon/max6639.c +3 -3
  	if (res < 0)
  		return res;
 
-	temp |= val << 3;
-	temp *= 125;
+	*temp |= val << 3;
+	*temp *= 125;
 
-	return sprintf(buf, "%ld\n", temp);
+	return res;
	return 0;

because res is known to be 0 here.

Quoted 5 lines
drivers/hwmon/max6639.c +1 -2
  }
 
-static ssize_t temp_fault_show(struct device *dev,
-			       struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_fault(struct device *dev, int channel, long *fault)

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 118

Quoted 10 lines
drivers/hwmon/max6639.c +1 -4
  {
  	struct max6639_data *data = dev_get_drvdata(dev);
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
  	unsigned int val;
  	int res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val);
-	if (res < 0)
-		return res;
+	res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(channel), &val);

Please always handle errors first before assigning results, as implemented in max6639_temp_read_input().

	if (res < 0)
		return res;

	*fault = val & 1;

	return 0;
Quoted 153 lines
drivers/hwmon/max6639.c +39 -66
+	*fault = val & 1;
 
-	return sprintf(buf, "%d\n", val & 1);
+	return res;
  }
 
-static ssize_t temp_max_show(struct device *dev,
-			     struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_max(struct device *dev, int channel, long *max)
  {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
  	struct max6639_data *data = dev_get_drvdata(dev);
  	unsigned int val;
  	int res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index), &val);
-	if (res < 0)
-		return res;
+	res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(channel), &val);
+	*max = val * 1000;
 
-	return sprintf(buf, "%d\n", (val * 1000));
+	return res;
  }
 
-static ssize_t temp_max_store(struct device *dev,
-			      struct device_attribute *dev_attr,
-			      const char *buf, size_t count)
+static int max6639_temp_read_crit(struct device *dev, int channel, long *crit)
  {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
  	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned long val;
+	unsigned int val;
  	int res;
 
-	res = kstrtoul(buf, 10, &val);
-	if (res)
-		return res;
+	res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), &val);
+	*crit = val * 1000;
 
-	regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index),
-		     TEMP_LIMIT_TO_REG(val));
-	return count;
+	return res;
  }
 
-static ssize_t temp_crit_show(struct device *dev,
-			      struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_emergency(struct device *dev, int channel, long *emerg)
  {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
  	struct max6639_data *data = dev_get_drvdata(dev);
  	unsigned int val;
  	int res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index), &val);
-	if (res < 0)
-		return res;
+	res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(channel), &val);
+	*emerg = val * 1000;
 
-	return sprintf(buf, "%d\n", (val * 1000));
+	return res;
  }
 
-static ssize_t temp_crit_store(struct device *dev,
-			       struct device_attribute *dev_attr,
-			       const char *buf, size_t count)
+static int max6639_get_status(struct device *dev, unsigned int *status)
  {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
  	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned long val;
+	unsigned int val;
  	int res;
 
-	res = kstrtoul(buf, 10, &val);
-	if (res)
-		return res;
+	res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val);
+	*status = val;
 
-	regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index),
-		     TEMP_LIMIT_TO_REG(val));
-	return count;
+	return res;
  }
 
-static ssize_t temp_emergency_show(struct device *dev,
-				   struct device_attribute *dev_attr,
-				   char *buf)
+static int max6639_temp_set_max(struct max6639_data *data, int channel, unsigned long val)
  {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned int val;
  	int res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), &val);
-	if (res < 0)
-		return res;
-
-	return sprintf(buf, "%d\n", (val * 1000));
+	res = regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(channel),
+			   TEMP_LIMIT_TO_REG(val));
+	return res;
  }
 
-static ssize_t temp_emergency_store(struct device *dev,
-				    struct device_attribute *dev_attr,
-				    const char *buf, size_t count)
+static int max6639_temp_set_crit(struct max6639_data *data, int channel, unsigned long val)
  {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned long val;
  	int res;
 
-	res = kstrtoul(buf, 10, &val);
-	if (res)
-		return res;
+	res = regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
+
+	return res;
+}
+
+static int max6639_temp_set_emergency(struct max6639_data *data, int channel, unsigned long val)
+{
+	int res;
 
-	regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), TEMP_LIMIT_TO_REG(val));
+	res = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
 
-	return count;
+	return res;
  }
 
-static ssize_t pwm_show(struct device *dev, struct device_attribute *dev_attr,
-			char *buf)
+static int max6639_read_fan(struct device *dev, u32 attr, int channel,
+			    long *fan_val)
  {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
  	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned int val;
-	int res;
+	unsigned int val, res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(attr->index), &val);
-	if (res < 0)
+	if (IS_ERR(data))

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 215

Quoted 10 lines
drivers/hwmon/max6639.c +10 -0
+		return PTR_ERR(data);
+
+	switch (attr) {
+	case hwmon_fan_input:
+		res = regmap_read(data->regmap, MAX6639_REG_FAN_CNT(channel), &val);
+		*fan_val = FAN_FROM_REG(val, data->rpm_range[channel]);
+		return res;
+	case hwmon_fan_fault:
+		res = max6639_get_status(dev, &val);
+		*fan_val = !!(val & (2 >> channel));
				!!BIT(1 - channel)

in these cases might be easier to read than the shifts.

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 227

Quoted 13 lines
drivers/hwmon/max6639.c +10 -1
  		return res;
+	case hwmon_fan_pulses:
+		*fan_val = data->ppr[channel];
+		return 0;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
 
-	return sprintf(buf, "%d\n", val * 255 / 120);
+static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr)
+{
+	return regmap_write(data->regmap, MAX6639_REG_FAN_PPR(channel), ppr-- << 6);

The -- here is confusing. I thoink it would be better to handle it in the calling code.

Quoted 15 lines
drivers/hwmon/max6639.c +3 -7
  }
 
-static ssize_t pwm_store(struct device *dev,
-			 struct device_attribute *dev_attr, const char *buf,
-			 size_t count)
+static int max6639_write_fan(struct device *dev, u32 attr, int channel,
+			     long val)
  {
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
  	struct max6639_data *data = dev_get_drvdata(dev);
-	unsigned long val;
-	int res;
+	int err;
 
-	res = kstrtoul(buf, 10, &val);

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 243

Quoted 10 lines
drivers/hwmon/max6639.c +8 -2
-	if (res)
-		return res;
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	switch (attr) {
+	case hwmon_fan_pulses:
+		if (val <= 0 || val > 5) {
+			dev_err(dev, "invalid pulses-per-revolution %ld. Valid range id 1 - 4.",
+				val);

No such error messages as result to user input, please.

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 249

Quoted 6 lines
drivers/hwmon/max6639.c +6 -0
+			return -EINVAL;
+		}
+		/* Set Fan pulse per revolution */
+		err = max6639_set_ppr(data, channel, val);
+		if (err)
+			dev_err(dev, "Failed to set pulses-per-revolution");

If this is an error, return it.

Quoted 44 lines
drivers/hwmon/max6639.c +26 -11
+		else
+			data->ppr[channel] = val;
+		return 0;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
 
-	val = clamp_val(val, 0, 255);
+static umode_t max6639_fan_is_visible(const void *_data, u32 attr, int channel)
+{
+	struct max6639_data *data = (struct max6639_data *)_data;
 
-	regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(attr->index), val * 120 / 255);
+	if (IS_ERR(data))
+		return PTR_ERR(data);
 
-	return count;
+	switch (attr) {
+	case hwmon_fan_input:
+	case hwmon_fan_fault:
+		return 0444;
+	case hwmon_fan_pulses:
+		return 0644;
+	default:
+		return 0;
+	}
  }
 
-static ssize_t fan_input_show(struct device *dev,
-			      struct device_attribute *dev_attr, char *buf)
+static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
+			    long *pwm_val)
  {
  	struct max6639_data *data = dev_get_drvdata(dev);
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-	unsigned int val;
-	int res;
-
-	res = regmap_read(data->regmap, MAX6639_REG_FAN_CNT(attr->index), &val);
-	if (res < 0)
+	unsigned int val, res;
+
+	if (IS_ERR(data))

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 292

Quoted 10 lines
drivers/hwmon/max6639.c +10 -0
+		return PTR_ERR(data);
+
+	switch (attr) {
+	case hwmon_pwm_input:
+		res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(channel), &val);
+		*pwm_val = val * 255 / 120;
+		return 0;
+	case hwmon_pwm_freq:
+		u8 x;
+

Please avoid.

Quoted 35 lines
drivers/hwmon/max6639.c +24 -6
+		res = regmap_read(data->regmap, MAX6639_REG_FAN_CONFIG3(channel), &val);
+		if (res < 0)
+			return res;
+		x = val & MAX6639_FAN_CONFIG3_FREQ_MASK;
+
+		res = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &val);
+		if (res < 0)
+			return res;
+
+		if (val & MAX6639_GCONFIG_PWM_FREQ_HI)
+			x |= 0x4;
+		x &= 0x7;
+		*pwm_val = freq_table[x];
  		return res;
-
-	return sprintf(buf, "%d\n", FAN_FROM_REG(val, data->rpm_range));
+	default:
+		return -EOPNOTSUPP;
+	}
  }
 
-static ssize_t alarm_show(struct device *dev,
-			  struct device_attribute *dev_attr, char *buf)
+static int max6639_write_pwm(struct device *dev, u32 attr, int channel,
+			     long val)
  {
  	struct max6639_data *data = dev_get_drvdata(dev);
-	struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-	unsigned int val;
+	int err;
+
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	switch (attr) {

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 331

Quoted 10 lines
drivers/hwmon/max6639.c +10 -0
+	case hwmon_pwm_input:
+		val = clamp_val(val, 0, 255);
+		err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(channel),
+				   val * 120 / 255);
+		return err;
+	case hwmon_pwm_freq:
+		u8 x;
+
+		val = clamp_val(val, 0, 25000);
+		/* Chip supports limited number of frequency */

frequencies, but the comment is really not necessary.

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 335

Quoted 4 lines
drivers/hwmon/max6639.c +4 -0
+		for (x = 0; x < sizeof(freq_table); x++)
+			if (val <= freq_table[x])
+				break;
+

Use find_closest()

Quoted 13 lines
drivers/hwmon/max6639.c +13 -0
+		err = regmap_update_bits(data->regmap, MAX6639_REG_FAN_CONFIG3(channel),
+					 MAX6639_FAN_CONFIG3_FREQ_MASK, x);
+		if (err < 0)
+			return err;
+
+		if (x >> 2)
+			err = regmap_set_bits(data->regmap, MAX6639_REG_GCONFIG,
+					      MAX6639_GCONFIG_PWM_FREQ_HI);
+		else
+			err = regmap_clear_bits(data->regmap, MAX6639_REG_GCONFIG,
+						MAX6639_GCONFIG_PWM_FREQ_HI);
+		return err;
+	default:

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 358

Quoted 10 lines
drivers/hwmon/max6639.c +10 -0
+		return -EOPNOTSUPP;
+	}
+}
+
+static umode_t max6639_pwm_is_visible(const void *_data, u32 attr, int channel)
+{
+	struct max6639_data *data = (struct max6639_data *)_data;
+
+	if (IS_ERR(data))
+		return PTR_ERR(data);

Pointless assignment and check. The parameter isn't used.

Quoted 27 lines
drivers/hwmon/max6639.c +22 -2
+
+	switch (attr) {
+	case hwmon_pwm_input:
+	case hwmon_pwm_freq:
+		return 0644;
+	default:
+		return 0;
+	}
+}
+
+static int max6639_read_temp(struct device *dev, u32 attr, int channel,
+			     long *val)
+{
+	unsigned int status;
  	int res;
 
-	res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val);
-	if (res < 0)
+	switch (attr) {
+	case hwmon_temp_input:
+		res = max6639_temp_read_input(dev, channel, val);
+		return res;
+	case hwmon_temp_fault:
+		res = max6639_temp_read_fault(dev, channel, val);
  		return res;
+	case hwmon_temp_max:
+		res = max6639_temp_read_max(dev, channel, val);

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 393

Quoted 10 lines
drivers/hwmon/max6639.c +10 -0
+		return res;
+	case hwmon_temp_crit:
+		res = max6639_temp_read_crit(dev, channel, val);
+		return res;
+	case hwmon_temp_emergency:
+		res = max6639_temp_read_emergency(dev, channel, val);
+		return res;
+	case hwmon_temp_max_alarm:
+		res = max6639_get_status(dev, &status);
+		*val = !!(status & (0x08 >> channel));
					BIT(3 - channel) ?
Quoted 187 lines
drivers/hwmon/max6639.c +117 -54
+		return res;
+	case hwmon_temp_crit_alarm:
+		res = max6639_get_status(dev, &status);
+		*val = !!(status & (0x80 >> channel));
+		return res;
+	case hwmon_temp_emergency_alarm:
+		res = max6639_get_status(dev, &status);
+		*val = !!(status & (0x20 >> channel));
+		return res;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+static int max6639_write_temp(struct device *dev, u32 attr, int channel,
+			      long val)
+{
+	struct max6639_data *data = dev_get_drvdata(dev);
+
+	switch (attr) {
+	case hwmon_temp_max:
+		return max6639_temp_set_max(data, channel, val);
+	case hwmon_temp_crit:
+		return max6639_temp_set_crit(data, channel, val);
+	case hwmon_temp_emergency:
+		return max6639_temp_set_emergency(data, channel, val);
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+static umode_t max6639_temp_is_visible(const void *_data, u32 attr, int channel)
+{
+	switch (attr) {
+	case hwmon_temp_input:
+	case hwmon_temp_fault:
+	case hwmon_temp_max_alarm:
+	case hwmon_temp_crit_alarm:
+	case hwmon_temp_emergency_alarm:
+		return 0444;
+	case hwmon_temp_max:
+	case hwmon_temp_crit:
+	case hwmon_temp_emergency:
+		return 0644;
+	default:
+		return 0;
+	}
+}
+
+static int max6639_read(struct device *dev, enum hwmon_sensor_types type,
+			u32 attr, int channel, long *val)
+{
+	switch (type) {
+	case hwmon_fan:
+		return max6639_read_fan(dev, attr, channel, val);
+	case hwmon_pwm:
+		return max6639_read_pwm(dev, attr, channel, val);
+	case hwmon_temp:
+		return max6639_read_temp(dev, attr, channel, val);
+	default:
+		return -EOPNOTSUPP;
+	}
+}
 
-	return sprintf(buf, "%d\n", !!(val & (1 << attr->index)));
+static int max6639_write(struct device *dev, enum hwmon_sensor_types type,
+			 u32 attr, int channel, long val)
+{
+	switch (type) {
+	case hwmon_fan:
+		return max6639_write_fan(dev, attr, channel, val);
+	case hwmon_pwm:
+		return max6639_write_pwm(dev, attr, channel, val);
+	case hwmon_temp:
+		return max6639_write_temp(dev, attr, channel, val);
+	default:
+		return -EOPNOTSUPP;
+	}
  }
 
-static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0);
-static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_input, 1);
-static SENSOR_DEVICE_ATTR_RO(temp1_fault, temp_fault, 0);
-static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp_fault, 1);
-static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
-static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
-static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp_crit, 0);
-static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp_crit, 1);
-static SENSOR_DEVICE_ATTR_RW(temp1_emergency, temp_emergency, 0);
-static SENSOR_DEVICE_ATTR_RW(temp2_emergency, temp_emergency, 1);
-static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
-static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
-static SENSOR_DEVICE_ATTR_RO(fan1_input, fan_input, 0);
-static SENSOR_DEVICE_ATTR_RO(fan2_input, fan_input, 1);
-static SENSOR_DEVICE_ATTR_RO(fan1_fault, alarm, 1);
-static SENSOR_DEVICE_ATTR_RO(fan2_fault, alarm, 0);
-static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 3);
-static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, 2);
-static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, alarm, 7);
-static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, 6);
-static SENSOR_DEVICE_ATTR_RO(temp1_emergency_alarm, alarm, 5);
-static SENSOR_DEVICE_ATTR_RO(temp2_emergency_alarm, alarm, 4);
-
-
-static struct attribute *max6639_attrs[] = {
-	&sensor_dev_attr_temp1_input.dev_attr.attr,
-	&sensor_dev_attr_temp2_input.dev_attr.attr,
-	&sensor_dev_attr_temp1_fault.dev_attr.attr,
-	&sensor_dev_attr_temp2_fault.dev_attr.attr,
-	&sensor_dev_attr_temp1_max.dev_attr.attr,
-	&sensor_dev_attr_temp2_max.dev_attr.attr,
-	&sensor_dev_attr_temp1_crit.dev_attr.attr,
-	&sensor_dev_attr_temp2_crit.dev_attr.attr,
-	&sensor_dev_attr_temp1_emergency.dev_attr.attr,
-	&sensor_dev_attr_temp2_emergency.dev_attr.attr,
-	&sensor_dev_attr_pwm1.dev_attr.attr,
-	&sensor_dev_attr_pwm2.dev_attr.attr,
-	&sensor_dev_attr_fan1_input.dev_attr.attr,
-	&sensor_dev_attr_fan2_input.dev_attr.attr,
-	&sensor_dev_attr_fan1_fault.dev_attr.attr,
-	&sensor_dev_attr_fan2_fault.dev_attr.attr,
-	&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
-	&sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
-	&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
-	&sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
-	&sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr,
-	&sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr,
+static umode_t max6639_is_visible(const void *data,
+				  enum hwmon_sensor_types type,
+				  u32 attr, int channel)
+{
+	switch (type) {
+	case hwmon_fan:
+		return max6639_fan_is_visible(data, attr, channel);
+	case hwmon_pwm:
+		return max6639_pwm_is_visible(data, attr, channel);
+	case hwmon_temp:
+		return max6639_temp_is_visible(data, attr, channel);
+	default:
+		return 0;
+	}
+}
+
+static const struct hwmon_channel_info * const max6639_info[] = {
+	HWMON_CHANNEL_INFO(fan,
+			   HWMON_F_INPUT | HWMON_F_FAULT | HWMON_F_PULSES,
+			   HWMON_F_INPUT | HWMON_F_FAULT | HWMON_F_PULSES),
+	HWMON_CHANNEL_INFO(pwm,
+			   HWMON_PWM_INPUT | HWMON_PWM_FREQ,
+			   HWMON_PWM_INPUT | HWMON_PWM_FREQ),
+	HWMON_CHANNEL_INFO(temp,
+			   HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_MAX | HWMON_T_MAX_ALARM |
+			   HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_EMERGENCY |
+			   HWMON_T_EMERGENCY_ALARM,
+			   HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_MAX | HWMON_T_MAX_ALARM |
+			   HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_EMERGENCY |
+			   HWMON_T_EMERGENCY_ALARM),
  	NULL
  };
-ATTRIBUTE_GROUPS(max6639);
+
+static const struct hwmon_ops max6639_hwmon_ops = {
+	.is_visible = max6639_is_visible,
+	.read = max6639_read,
+	.write = max6639_write,
+};
+
+static const struct hwmon_chip_info max6639_chip_info = {
+	.ops = &max6639_hwmon_ops,
+	.info = max6639_info,
+};
 
  /*
   *  returns respective index in rpm_ranges table
@@ -355,11 +530,6 @@ 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)
  {

drivers/hwmon/max6639.c static int max6639_init_client(struct i2c_client *client, · line 556

Quoted 8 lines
drivers/hwmon/max6639.c +3 -1
@@ -380,14 +550,16 @@ static int max6639_init_client(struct i2c_client *client,
  		ppr = max6639_info->ppr;
  	else
  		ppr = 2;
-	ppr -= 1;
+
+	data->ppr[0] = ppr;
+	data->ppr[1] = ppr;
 

I think we should drop support for max6639_platform_data entirely. It isn't used anywhere in the kernel and obviously incomplete.

Quoted 38 lines
drivers/hwmon/max6639.c +9 -7
  	if (max6639_info)
  		rpm_range = rpm_range_to_reg(max6639_info->rpm_range);
-	data->rpm_range = rpm_range;
+	data->rpm_range[0] = rpm_range;
+	data->rpm_range[1] = rpm_range;
 
  	for (i = 0; i < MAX6639_NUM_CHANNELS; i++) {
-
  		/* Set Fan pulse per revolution */
  		err = max6639_set_ppr(data, i, ppr);
  		if (err)
@@ -395,15 +567,17 @@ static int max6639_init_client(struct i2c_client *client,
 
  		/* Fans config PWM, RPM */
  		err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG1(i),
-				   MAX6639_FAN_CONFIG1_PWM | rpm_range);
+				   MAX6639_FAN_CONFIG1_PWM | data->rpm_range[i]);
  		if (err)
  			return err;
 
  		/* Fans PWM polarity high by default */
-		if (max6639_info && max6639_info->pwm_polarity == 0)
-			err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x00);
-		else
-			err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x02);
+		if (max6639_info) {
+			if (max6639_info->pwm_polarity == 0)
+				err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x00);
+			else
+				err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x02);
+		}
  		if (err)
  			return err;
 
@@ -534,9 +708,13 @@ static int max6639_probe(struct i2c_client *client)
  	if (err < 0)
  		return err;
 

drivers/hwmon/max6639.c static int max6639_probe(struct i2c_client *client) · line 717

Quoted 10 lines
drivers/hwmon/max6639.c +7 -3
-	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-							   data,
-							   max6639_groups);
+	hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
+							 data, &max6639_chip_info,
+							 NULL);
+
+	if (IS_ERR(hwmon_dev))
+		return dev_err_probe(dev, PTR_ERR(hwmon_dev),
+				     "unable to register hwmon device\n");

This is a functional change unrelated to the conversion, and I am not in favor of it. Please refrain from making such changes.

Thanks,
Guenter

#4 lore raw

Hi Guenter,

Quoted 6 lines · Guenter Roeck
Quoted 1 line · Naresh Solanki

Update hwmon init with info instead of group.

A more detailed description which doesn't require insider knowledge would be helpful.

Sure. Will update as:
hwmon: (max6639) : Update hwmon init using info structure

Update hwmon init with info instead of group. The hwmon info structure is more flexible to describe sensor attributes & easy to maintain.

Quoted 6 lines
Quoted 4 lines

Also added additional attribute for fan i.e.,
fanY_pulse
pwmY_freq

Separate patches for additional attributes, please.

Ack.

Quoted 74 lines
Quoted 74 lines
---
  drivers/hwmon/max6639.c | 536 ++++++++++++++++++++++++++--------------
  1 file changed, 357 insertions(+), 179 deletions(-)
drivers/hwmon/max6639.c +13 -12
index cbb595fe47aa..b757a85837e8 100644
@@ -55,13 +55,17 @@ static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
  #define MAX6639_GCONFIG_PWM_FREQ_HI         0x08
 
  #define MAX6639_FAN_CONFIG1_PWM                     0x80
-
+#define MAX6639_FAN_CONFIG3_FREQ_MASK                0x03
  #define MAX6639_FAN_CONFIG3_THERM_FULL_SPEED        0x40
 
  #define MAX6639_NUM_CHANNELS                        2
 
  static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
 
+/* Supported PWM frequency */
+static const unsigned int freq_table[] = { 20, 33, 50, 100, 5000, 8333, 12500,
+                                        25000 };
+
  #define FAN_FROM_REG(val, rpm_range)        ((val) == 0 || (val) == 255 ? \
                              0 : (rpm_ranges[rpm_range] * 30) / (val))
  #define TEMP_LIMIT_TO_REG(val)      clamp_val((val) / 1000, 0, 255)
@@ -73,19 +77,16 @@ struct max6639_data {
      struct regmap *regmap;
 
      /* Register values initialized only once */
-     u8 ppr;                 /* Pulses per rotation 0..3 for 1..4 ppr */
-     u8 rpm_range;           /* Index in above rpm_ranges table */
+     u8 ppr[MAX6639_NUM_CHANNELS];   /* Pulses per rotation 0..3 for 1..4 ppr */
+     u8 rpm_range[MAX6639_NUM_CHANNELS]; /* Index in above rpm_ranges table */
 
      /* Optional regulator for FAN supply */
      struct regulator *reg;
  };
 
-static ssize_t temp_input_show(struct device *dev,
-                            struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_input(struct device *dev, int channel, long *temp)
  {
-     long temp;
      struct max6639_data *data = dev_get_drvdata(dev);
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
      unsigned int val;
      int res;
 
@@ -93,251 +94,425 @@ static ssize_t temp_input_show(struct device *dev,
       * Lock isn't needed as MAX6639_REG_TEMP wpnt change for at least 250ms after reading
       * MAX6639_REG_TEMP_EXT
       */
-     res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val);
+     res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(channel), &val);
      if (res < 0)
              return res;
 
-     temp = val >> 5;
-     res = regmap_read(data->regmap, MAX6639_REG_TEMP(attr->index), &val);
+     *temp = val >> 5;
+     res = regmap_read(data->regmap, MAX6639_REG_TEMP(channel), &val);
      if (res < 0)
              return res;
 
-     temp |= val << 3;
-     temp *= 125;
+     *temp |= val << 3;
+     *temp *= 125;
 
Quoted 6 lines

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 109

Quoted 2 lines
drivers/hwmon/max6639.c +1 -1
-     return sprintf(buf, "%ld\n", temp);
+     return res;
        return 0;

because res is known to be 0 here.

Sure.

Quoted 20 lines
Quoted 6 lines
drivers/hwmon/max6639.c +1 -2
  }
 
-static ssize_t temp_fault_show(struct device *dev,
-                            struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_fault(struct device *dev, int channel, long *fault)

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 118

Quoted 10 lines
drivers/hwmon/max6639.c +1 -4
  {
      struct max6639_data *data = dev_get_drvdata(dev);
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
      unsigned int val;
      int res;
 
-     res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(attr->index), &val);
-     if (res < 0)
-             return res;
+     res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(channel), &val);

Please always handle errors first before assigning results, as implemented in max6639_temp_read_input().

Quoted 7 lines
        if (res < 0)
                return res;

        *fault = val & 1;

        return 0;

Ack

Quoted 166 lines
Quoted 153 lines
drivers/hwmon/max6639.c +39 -66
+     *fault = val & 1;
 
-     return sprintf(buf, "%d\n", val & 1);
+     return res;
  }
 
-static ssize_t temp_max_show(struct device *dev,
-                          struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_max(struct device *dev, int channel, long *max)
  {
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
      struct max6639_data *data = dev_get_drvdata(dev);
      unsigned int val;
      int res;
 
-     res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index), &val);
-     if (res < 0)
-             return res;
+     res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(channel), &val);
+     *max = val * 1000;
 
-     return sprintf(buf, "%d\n", (val * 1000));
+     return res;
  }
 
-static ssize_t temp_max_store(struct device *dev,
-                           struct device_attribute *dev_attr,
-                           const char *buf, size_t count)
+static int max6639_temp_read_crit(struct device *dev, int channel, long *crit)
  {
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
      struct max6639_data *data = dev_get_drvdata(dev);
-     unsigned long val;
+     unsigned int val;
      int res;
 
-     res = kstrtoul(buf, 10, &val);
-     if (res)
-             return res;
+     res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), &val);
+     *crit = val * 1000;
 
-     regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index),
-                  TEMP_LIMIT_TO_REG(val));
-     return count;
+     return res;
  }
 
-static ssize_t temp_crit_show(struct device *dev,
-                           struct device_attribute *dev_attr, char *buf)
+static int max6639_temp_read_emergency(struct device *dev, int channel, long *emerg)
  {
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
      struct max6639_data *data = dev_get_drvdata(dev);
      unsigned int val;
      int res;
 
-     res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index), &val);
-     if (res < 0)
-             return res;
+     res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(channel), &val);
+     *emerg = val * 1000;
 
-     return sprintf(buf, "%d\n", (val * 1000));
+     return res;
  }
 
-static ssize_t temp_crit_store(struct device *dev,
-                            struct device_attribute *dev_attr,
-                            const char *buf, size_t count)
+static int max6639_get_status(struct device *dev, unsigned int *status)
  {
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
      struct max6639_data *data = dev_get_drvdata(dev);
-     unsigned long val;
+     unsigned int val;
      int res;
 
-     res = kstrtoul(buf, 10, &val);
-     if (res)
-             return res;
+     res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val);
+     *status = val;
 
-     regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index),
-                  TEMP_LIMIT_TO_REG(val));
-     return count;
+     return res;
  }
 
-static ssize_t temp_emergency_show(struct device *dev,
-                                struct device_attribute *dev_attr,
-                                char *buf)
+static int max6639_temp_set_max(struct max6639_data *data, int channel, unsigned long val)
  {
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-     struct max6639_data *data = dev_get_drvdata(dev);
-     unsigned int val;
      int res;
 
-     res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), &val);
-     if (res < 0)
-             return res;
-
-     return sprintf(buf, "%d\n", (val * 1000));
+     res = regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(channel),
+                        TEMP_LIMIT_TO_REG(val));
+     return res;
  }
 
-static ssize_t temp_emergency_store(struct device *dev,
-                                 struct device_attribute *dev_attr,
-                                 const char *buf, size_t count)
+static int max6639_temp_set_crit(struct max6639_data *data, int channel, unsigned long val)
  {
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-     struct max6639_data *data = dev_get_drvdata(dev);
-     unsigned long val;
      int res;
 
-     res = kstrtoul(buf, 10, &val);
-     if (res)
-             return res;
+     res = regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
+
+     return res;
+}
+
+static int max6639_temp_set_emergency(struct max6639_data *data, int channel, unsigned long val)
+{
+     int res;
 
-     regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), TEMP_LIMIT_TO_REG(val));
+     res = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
 
-     return count;
+     return res;
  }
 
-static ssize_t pwm_show(struct device *dev, struct device_attribute *dev_attr,
-                     char *buf)
+static int max6639_read_fan(struct device *dev, u32 attr, int channel,
+                         long *fan_val)
  {
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
      struct max6639_data *data = dev_get_drvdata(dev);
-     unsigned int val;
-     int res;
+     unsigned int val, res;
 
-     res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(attr->index), &val);
-     if (res < 0)
+     if (IS_ERR(data))

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 215

Quoted 10 lines
drivers/hwmon/max6639.c +10 -0
+             return PTR_ERR(data);
+
+     switch (attr) {
+     case hwmon_fan_input:
+             res = regmap_read(data->regmap, MAX6639_REG_FAN_CNT(channel), &val);
+             *fan_val = FAN_FROM_REG(val, data->rpm_range[channel]);
+             return res;
+     case hwmon_fan_fault:
+             res = max6639_get_status(dev, &val);
+             *fan_val = !!(val & (2 >> channel));
                                !!BIT(1 - channel)
Quoted 2 lines

in these cases might be easier to read than the shifts.

Ack. Will update all such instance accordingly.

Quoted 9 lines
Quoted 9 lines
drivers/hwmon/max6639.c +7 -0
              return res;
+     case hwmon_fan_pulses:
+             *fan_val = data->ppr[channel];
+             return 0;
+     default:
+             return -EOPNOTSUPP;
+     }
+}
 
Quoted 7 lines

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 227

Quoted 4 lines
drivers/hwmon/max6639.c +3 -1
-     return sprintf(buf, "%d\n", val * 255 / 120);
+static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr)
+{
+     return regmap_write(data->regmap, MAX6639_REG_FAN_PPR(channel), ppr-- << 6);

The -- here is confusing. I thoink it would be better to handle it in the calling code.

I want to avoid caller adjusting value based on hw as far as possible. Is it ok to add a comment here instead like:

/* Decrement the PPR value and shift left by 6 to match the register format */

Please let me know what you feel.

Quoted 14 lines
Quoted 14 lines
drivers/hwmon/max6639.c +3 -6
  }
 
-static ssize_t pwm_store(struct device *dev,
-                      struct device_attribute *dev_attr, const char *buf,
-                      size_t count)
+static int max6639_write_fan(struct device *dev, u32 attr, int channel,
+                          long val)
  {
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
      struct max6639_data *data = dev_get_drvdata(dev);
-     unsigned long val;
-     int res;
+     int err;
 
Quoted 14 lines

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 243

Quoted 11 lines
drivers/hwmon/max6639.c +8 -3
-     res = kstrtoul(buf, 10, &val);
-     if (res)
-             return res;
+     if (IS_ERR(data))
+             return PTR_ERR(data);
+
+     switch (attr) {
+     case hwmon_fan_pulses:
+             if (val <= 0 || val > 5) {
+                     dev_err(dev, "invalid pulses-per-revolution %ld. Valid range id 1 - 4.",
+                             val);

No such error messages as result to user input, please.

Ack

Quoted 9 lines

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 249

Quoted 6 lines
drivers/hwmon/max6639.c +6 -0
+                     return -EINVAL;
+             }
+             /* Set Fan pulse per revolution */
+             err = max6639_set_ppr(data, channel, val);
+             if (err)
+                     dev_err(dev, "Failed to set pulses-per-revolution");

If this is an error, return it.

Ack

Quoted 48 lines
Quoted 48 lines
drivers/hwmon/max6639.c +30 -11
+             else
+                     data->ppr[channel] = val;
+             return 0;
+     default:
+             return -EOPNOTSUPP;
+     }
+}
 
-     val = clamp_val(val, 0, 255);
+static umode_t max6639_fan_is_visible(const void *_data, u32 attr, int channel)
+{
+     struct max6639_data *data = (struct max6639_data *)_data;
 
-     regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(attr->index), val * 120 / 255);
+     if (IS_ERR(data))
+             return PTR_ERR(data);
 
-     return count;
+     switch (attr) {
+     case hwmon_fan_input:
+     case hwmon_fan_fault:
+             return 0444;
+     case hwmon_fan_pulses:
+             return 0644;
+     default:
+             return 0;
+     }
  }
 
-static ssize_t fan_input_show(struct device *dev,
-                           struct device_attribute *dev_attr, char *buf)
+static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
+                         long *pwm_val)
  {
      struct max6639_data *data = dev_get_drvdata(dev);
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-     unsigned int val;
-     int res;
-
-     res = regmap_read(data->regmap, MAX6639_REG_FAN_CNT(attr->index), &val);
-     if (res < 0)
+     unsigned int val, res;
+
+     if (IS_ERR(data))
+             return PTR_ERR(data);
+
+     switch (attr) {
+     case hwmon_pwm_input:
Quoted 9 lines

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 292

Quoted 6 lines
drivers/hwmon/max6639.c +6 -0
+             res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(channel), &val);
+             *pwm_val = val * 255 / 120;
+             return 0;
+     case hwmon_pwm_freq:
+             u8 x;
+

Please avoid.

Ack

Quoted 48 lines
Quoted 35 lines
drivers/hwmon/max6639.c +24 -6
+             res = regmap_read(data->regmap, MAX6639_REG_FAN_CONFIG3(channel), &val);
+             if (res < 0)
+                     return res;
+             x = val & MAX6639_FAN_CONFIG3_FREQ_MASK;
+
+             res = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &val);
+             if (res < 0)
+                     return res;
+
+             if (val & MAX6639_GCONFIG_PWM_FREQ_HI)
+                     x |= 0x4;
+             x &= 0x7;
+             *pwm_val = freq_table[x];
              return res;
-
-     return sprintf(buf, "%d\n", FAN_FROM_REG(val, data->rpm_range));
+     default:
+             return -EOPNOTSUPP;
+     }
  }
 
-static ssize_t alarm_show(struct device *dev,
-                       struct device_attribute *dev_attr, char *buf)
+static int max6639_write_pwm(struct device *dev, u32 attr, int channel,
+                          long val)
  {
      struct max6639_data *data = dev_get_drvdata(dev);
-     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
-     unsigned int val;
+     int err;
+
+     if (IS_ERR(data))
+             return PTR_ERR(data);
+
+     switch (attr) {

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 331

Quoted 10 lines
drivers/hwmon/max6639.c +10 -0
+     case hwmon_pwm_input:
+             val = clamp_val(val, 0, 255);
+             err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(channel),
+                                val * 120 / 255);
+             return err;
+     case hwmon_pwm_freq:
+             u8 x;
+
+             val = clamp_val(val, 0, 25000);
+             /* Chip supports limited number of frequency */

frequencies, but the comment is really not necessary.

Quoted 7 lines

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 335

Quoted 4 lines
drivers/hwmon/max6639.c +4 -0
+             for (x = 0; x < sizeof(freq_table); x++)
+                     if (val <= freq_table[x])
+                             break;
+

Use find_closest()

Ack. Will update as:

                i = find_closest(val, freq_table, ARRAY_SIZE(freq_table));
Quoted 17 lines
Quoted 17 lines
drivers/hwmon/max6639.c +17 -0
+             err = regmap_update_bits(data->regmap, MAX6639_REG_FAN_CONFIG3(channel),
+                                      MAX6639_FAN_CONFIG3_FREQ_MASK, x);
+             if (err < 0)
+                     return err;
+
+             if (x >> 2)
+                     err = regmap_set_bits(data->regmap, MAX6639_REG_GCONFIG,
+                                           MAX6639_GCONFIG_PWM_FREQ_HI);
+             else
+                     err = regmap_clear_bits(data->regmap, MAX6639_REG_GCONFIG,
+                                             MAX6639_GCONFIG_PWM_FREQ_HI);
+             return err;
+     default:
+             return -EOPNOTSUPP;
+     }
+}
+
Quoted 9 lines

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 358

Quoted 6 lines
drivers/hwmon/max6639.c +6 -0
+static umode_t max6639_pwm_is_visible(const void *_data, u32 attr, int channel)
+{
+     struct max6639_data *data = (struct max6639_data *)_data;
+
+     if (IS_ERR(data))
+             return PTR_ERR(data);

Pointless assignment and check. The parameter isn't used.

Ack. Will be removed.

Quoted 31 lines
Quoted 31 lines
drivers/hwmon/max6639.c +26 -2
+
+     switch (attr) {
+     case hwmon_pwm_input:
+     case hwmon_pwm_freq:
+             return 0644;
+     default:
+             return 0;
+     }
+}
+
+static int max6639_read_temp(struct device *dev, u32 attr, int channel,
+                          long *val)
+{
+     unsigned int status;
      int res;
 
-     res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val);
-     if (res < 0)
+     switch (attr) {
+     case hwmon_temp_input:
+             res = max6639_temp_read_input(dev, channel, val);
+             return res;
+     case hwmon_temp_fault:
+             res = max6639_temp_read_fault(dev, channel, val);
              return res;
+     case hwmon_temp_max:
+             res = max6639_temp_read_max(dev, channel, val);
+             return res;
+     case hwmon_temp_crit:
+             res = max6639_temp_read_crit(dev, channel, val);
+             return res;
Quoted 9 lines

drivers/hwmon/max6639.c static ssize_t temp_input_show(struct device *dev, · line 393

Quoted 6 lines
drivers/hwmon/max6639.c +6 -0
+     case hwmon_temp_emergency:
+             res = max6639_temp_read_emergency(dev, channel, val);
+             return res;
+     case hwmon_temp_max_alarm:
+             res = max6639_get_status(dev, &status);
+             *val = !!(status & (0x08 >> channel));
                                        BIT(3 - channel) ?

Ack

Quoted 190 lines
Quoted 190 lines
drivers/hwmon/max6639.c +117 -54
+             return res;
+     case hwmon_temp_crit_alarm:
+             res = max6639_get_status(dev, &status);
+             *val = !!(status & (0x80 >> channel));
+             return res;
+     case hwmon_temp_emergency_alarm:
+             res = max6639_get_status(dev, &status);
+             *val = !!(status & (0x20 >> channel));
+             return res;
+     default:
+             return -EOPNOTSUPP;
+     }
+}
+
+static int max6639_write_temp(struct device *dev, u32 attr, int channel,
+                           long val)
+{
+     struct max6639_data *data = dev_get_drvdata(dev);
+
+     switch (attr) {
+     case hwmon_temp_max:
+             return max6639_temp_set_max(data, channel, val);
+     case hwmon_temp_crit:
+             return max6639_temp_set_crit(data, channel, val);
+     case hwmon_temp_emergency:
+             return max6639_temp_set_emergency(data, channel, val);
+     default:
+             return -EOPNOTSUPP;
+     }
+}
+
+static umode_t max6639_temp_is_visible(const void *_data, u32 attr, int channel)
+{
+     switch (attr) {
+     case hwmon_temp_input:
+     case hwmon_temp_fault:
+     case hwmon_temp_max_alarm:
+     case hwmon_temp_crit_alarm:
+     case hwmon_temp_emergency_alarm:
+             return 0444;
+     case hwmon_temp_max:
+     case hwmon_temp_crit:
+     case hwmon_temp_emergency:
+             return 0644;
+     default:
+             return 0;
+     }
+}
+
+static int max6639_read(struct device *dev, enum hwmon_sensor_types type,
+                     u32 attr, int channel, long *val)
+{
+     switch (type) {
+     case hwmon_fan:
+             return max6639_read_fan(dev, attr, channel, val);
+     case hwmon_pwm:
+             return max6639_read_pwm(dev, attr, channel, val);
+     case hwmon_temp:
+             return max6639_read_temp(dev, attr, channel, val);
+     default:
+             return -EOPNOTSUPP;
+     }
+}
 
-     return sprintf(buf, "%d\n", !!(val & (1 << attr->index)));
+static int max6639_write(struct device *dev, enum hwmon_sensor_types type,
+                      u32 attr, int channel, long val)
+{
+     switch (type) {
+     case hwmon_fan:
+             return max6639_write_fan(dev, attr, channel, val);
+     case hwmon_pwm:
+             return max6639_write_pwm(dev, attr, channel, val);
+     case hwmon_temp:
+             return max6639_write_temp(dev, attr, channel, val);
+     default:
+             return -EOPNOTSUPP;
+     }
  }
 
-static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0);
-static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_input, 1);
-static SENSOR_DEVICE_ATTR_RO(temp1_fault, temp_fault, 0);
-static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp_fault, 1);
-static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
-static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
-static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp_crit, 0);
-static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp_crit, 1);
-static SENSOR_DEVICE_ATTR_RW(temp1_emergency, temp_emergency, 0);
-static SENSOR_DEVICE_ATTR_RW(temp2_emergency, temp_emergency, 1);
-static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
-static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
-static SENSOR_DEVICE_ATTR_RO(fan1_input, fan_input, 0);
-static SENSOR_DEVICE_ATTR_RO(fan2_input, fan_input, 1);
-static SENSOR_DEVICE_ATTR_RO(fan1_fault, alarm, 1);
-static SENSOR_DEVICE_ATTR_RO(fan2_fault, alarm, 0);
-static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 3);
-static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, 2);
-static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, alarm, 7);
-static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, 6);
-static SENSOR_DEVICE_ATTR_RO(temp1_emergency_alarm, alarm, 5);
-static SENSOR_DEVICE_ATTR_RO(temp2_emergency_alarm, alarm, 4);
-
-
-static struct attribute *max6639_attrs[] = {
-     &sensor_dev_attr_temp1_input.dev_attr.attr,
-     &sensor_dev_attr_temp2_input.dev_attr.attr,
-     &sensor_dev_attr_temp1_fault.dev_attr.attr,
-     &sensor_dev_attr_temp2_fault.dev_attr.attr,
-     &sensor_dev_attr_temp1_max.dev_attr.attr,
-     &sensor_dev_attr_temp2_max.dev_attr.attr,
-     &sensor_dev_attr_temp1_crit.dev_attr.attr,
-     &sensor_dev_attr_temp2_crit.dev_attr.attr,
-     &sensor_dev_attr_temp1_emergency.dev_attr.attr,
-     &sensor_dev_attr_temp2_emergency.dev_attr.attr,
-     &sensor_dev_attr_pwm1.dev_attr.attr,
-     &sensor_dev_attr_pwm2.dev_attr.attr,
-     &sensor_dev_attr_fan1_input.dev_attr.attr,
-     &sensor_dev_attr_fan2_input.dev_attr.attr,
-     &sensor_dev_attr_fan1_fault.dev_attr.attr,
-     &sensor_dev_attr_fan2_fault.dev_attr.attr,
-     &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
-     &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
-     &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
-     &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
-     &sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr,
-     &sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr,
+static umode_t max6639_is_visible(const void *data,
+                               enum hwmon_sensor_types type,
+                               u32 attr, int channel)
+{
+     switch (type) {
+     case hwmon_fan:
+             return max6639_fan_is_visible(data, attr, channel);
+     case hwmon_pwm:
+             return max6639_pwm_is_visible(data, attr, channel);
+     case hwmon_temp:
+             return max6639_temp_is_visible(data, attr, channel);
+     default:
+             return 0;
+     }
+}
+
+static const struct hwmon_channel_info * const max6639_info[] = {
+     HWMON_CHANNEL_INFO(fan,
+                        HWMON_F_INPUT | HWMON_F_FAULT | HWMON_F_PULSES,
+                        HWMON_F_INPUT | HWMON_F_FAULT | HWMON_F_PULSES),
+     HWMON_CHANNEL_INFO(pwm,
+                        HWMON_PWM_INPUT | HWMON_PWM_FREQ,
+                        HWMON_PWM_INPUT | HWMON_PWM_FREQ),
+     HWMON_CHANNEL_INFO(temp,
+                        HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_MAX | HWMON_T_MAX_ALARM |
+                        HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_EMERGENCY |
+                        HWMON_T_EMERGENCY_ALARM,
+                        HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_MAX | HWMON_T_MAX_ALARM |
+                        HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_EMERGENCY |
+                        HWMON_T_EMERGENCY_ALARM),
      NULL
  };
-ATTRIBUTE_GROUPS(max6639);
+
+static const struct hwmon_ops max6639_hwmon_ops = {
+     .is_visible = max6639_is_visible,
+     .read = max6639_read,
+     .write = max6639_write,
+};
+
+static const struct hwmon_chip_info max6639_chip_info = {
+     .ops = &max6639_hwmon_ops,
+     .info = max6639_info,
+};
 
  /*
   *  returns respective index in rpm_ranges table
@@ -355,11 +530,6 @@ 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)
  {
@@ -380,14 +550,16 @@ static int max6639_init_client(struct i2c_client *client,
              ppr = max6639_info->ppr;
      else
              ppr = 2;
Quoted 9 lines

drivers/hwmon/max6639.c static int max6639_init_client(struct i2c_client *client, · line 556

Quoted 5 lines
drivers/hwmon/max6639.c +3 -1
-     ppr -= 1;
+
+     data->ppr[0] = ppr;
+     data->ppr[1] = ppr;
 

I think we should drop support for max6639_platform_data entirely. It isn't used anywhere in the kernel and obviously incomplete.

Ack. I'll work on it and submit patch next week after testing.

Quoted 38 lines
Quoted 38 lines
drivers/hwmon/max6639.c +9 -7
      if (max6639_info)
              rpm_range = rpm_range_to_reg(max6639_info->rpm_range);
-     data->rpm_range = rpm_range;
+     data->rpm_range[0] = rpm_range;
+     data->rpm_range[1] = rpm_range;
 
      for (i = 0; i < MAX6639_NUM_CHANNELS; i++) {
-
              /* Set Fan pulse per revolution */
              err = max6639_set_ppr(data, i, ppr);
              if (err)
@@ -395,15 +567,17 @@ static int max6639_init_client(struct i2c_client *client,
 
              /* Fans config PWM, RPM */
              err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG1(i),
-                                MAX6639_FAN_CONFIG1_PWM | rpm_range);
+                                MAX6639_FAN_CONFIG1_PWM | data->rpm_range[i]);
              if (err)
                      return err;
 
              /* Fans PWM polarity high by default */
-             if (max6639_info && max6639_info->pwm_polarity == 0)
-                     err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x00);
-             else
-                     err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x02);
+             if (max6639_info) {
+                     if (max6639_info->pwm_polarity == 0)
+                             err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x00);
+                     else
+                             err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x02);
+             }
              if (err)
                      return err;
 
@@ -534,9 +708,13 @@ static int max6639_probe(struct i2c_client *client)
      if (err < 0)
              return err;
 
Quoted 13 lines

drivers/hwmon/max6639.c static int max6639_probe(struct i2c_client *client) · line 717

Quoted 10 lines
drivers/hwmon/max6639.c +7 -3
-     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
-                                                        data,
-                                                        max6639_groups);
+     hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
+                                                      data, &max6639_chip_info,
+                                                      NULL);
+
+     if (IS_ERR(hwmon_dev))
+             return dev_err_probe(dev, PTR_ERR(hwmon_dev),
+                                  "unable to register hwmon device\n");

This is a functional change unrelated to the conversion, and I am not in favor of it. Please refrain from making such changes.

Ack.

Regards,
Naresh

Quoted 4 lines

Thanks,
Guenter

#5 lore raw
In reply to Naresh Solanki
kernel test robot noticed the following build errors:

Hi Naresh,

kernel test robot noticed the following build errors:

[auto build test ERROR on 5fbf8734fb36cf67339f599f0e51747a6aff690c]

url:    https://github.com/intel-lab-lkp/linux/commits/Naresh-Solanki/hwmon-max6639-Update-hwmon-init-using-info/20240528-172245
base:   5fbf8734fb36cf67339f599f0e51747a6aff690c
patch link:    https://lore.kernel.org/r/20240528091808.863702-1-naresh.solanki%409elements.com
patch subject: [PATCH v2] hwmon: (max6639) : Update hwmon init using info
config: arm64-randconfig-002-20240528 (https://download.01.org/0day-ci/archive/20240528/[email protected]/config)
compiler: clang version 15.0.7 (https://github.com/llvm/llvm-project 8dfdcc7b7bf66834a761bd8de445840ef68e4d1a)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240528/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All errors (new ones prefixed by >>):

>> drivers/hwmon/max6639.c:291:3: error: expected expression
                   u8 x;
                   ^
>> drivers/hwmon/max6639.c:296:3: error: use of undeclared identifier 'x'
                   x = val & MAX6639_FAN_CONFIG3_FREQ_MASK;
                   ^
   drivers/hwmon/max6639.c:303:4: error: use of undeclared identifier 'x'
                           x |= 0x4;
                           ^
   drivers/hwmon/max6639.c:304:3: error: use of undeclared identifier 'x'
                   x &= 0x7;
                   ^
   drivers/hwmon/max6639.c:305:25: error: use of undeclared identifier 'x'
                   *pwm_val = freq_table[x];
                                         ^
   drivers/hwmon/max6639.c:328:3: error: expected expression
                   u8 x;
                   ^
   drivers/hwmon/max6639.c:332:8: error: use of undeclared identifier 'x'
                   for (x = 0; x < sizeof(freq_table); x++)
                        ^
   drivers/hwmon/max6639.c:332:15: error: use of undeclared identifier 'x'
                   for (x = 0; x < sizeof(freq_table); x++)
                               ^
   drivers/hwmon/max6639.c:332:39: error: use of undeclared identifier 'x'
                   for (x = 0; x < sizeof(freq_table); x++)
                                                       ^
   drivers/hwmon/max6639.c:333:26: error: use of undeclared identifier 'x'
                           if (val <= freq_table[x])
                                                 ^
   drivers/hwmon/max6639.c:337:38: error: use of undeclared identifier 'x'
                                            MAX6639_FAN_CONFIG3_FREQ_MASK, x);
                                                                           ^
   drivers/hwmon/max6639.c:341:7: error: use of undeclared identifier 'x'
                   if (x >> 2)
                       ^

12 errors generated.

vim +291 drivers/hwmon/max6639.c

275
276 static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
277 long *pwm_val)
278 {
279 struct max6639_data *data = dev_get_drvdata(dev);
280 unsigned int val, res;
281
282 if (IS_ERR(data))
283 return PTR_ERR(data);
284
285 switch (attr) {
286 case hwmon_pwm_input:
287 res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(channel), &val);
288 *pwm_val = val * 255 / 120;
289 return 0;
290 case hwmon_pwm_freq:

 > 291			u8 x;
   292	
   293			res = regmap_read(data->regmap, MAX6639_REG_FAN_CONFIG3(channel), &val);
   294			if (res < 0)
   295				return res;
 > 296			x = val & MAX6639_FAN_CONFIG3_FREQ_MASK;

297
298 res = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &val);
299 if (res < 0)
300 return res;
301
302 if (val & MAX6639_GCONFIG_PWM_FREQ_HI)
303 x |= 0x4;
304 x &= 0x7;
305 *pwm_val = freq_table[x];
306 return res;
307 default:
308 return -EOPNOTSUPP;
309 }
310 }
311

Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki