Skip to contentSkip to conversation

hwmon: (max6639) : Update hwmon init using info structure

PATCH Superseded Naresh Solanki 2 participants 8 messages Jun 4, 2024 – Jun 13, 2024 Hardware monitoring

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

PATCH v4 1/2 hwmon: (max6639) : Update hwmon init using info structure

Update hwmon init with info instead of group. The hwmon info structure in more flexible to describe sensor attribute & easy to maintian.

---
Changes in v4:
- Change res type from unsigned to signed

Changes in V3:
- return 0 when 'res' variable is known zero.
- Handle errors first before assigning results
- Use BIT to make it easier to read.
- Remove error message print on user input
- Return err value instead of printing error message & returing zero.
- Remove variable declaration in switch case statement
- Use find_closest instead of for loop
- Remove pointless assignment & check
- Seperate patch for adding additional attributes

---
 drivers/hwmon/max6639.c | 469 +++++++++++++++++++++++++---------------
 1 file changed, 299 insertions(+), 170 deletions(-)
drivers/hwmon/max6639.c +299 -170
index cbb595fe47aa..e2a5210f9f95 100644
@@ -21,6 +21,7 @@
 #include <linux/mutex.h>
 #include <linux/platform_data/max6639.h>
 #include <linux/regmap.h>
+#include <linux/util_macros.h>
 
 /* Addresses to scan */
 static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
@@ -55,13 +56,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 +78,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 +95,378 @@ 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 0;
 }
 
-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);
+	res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(channel), &val);
 	if (res < 0)
 		return res;
 
-	return sprintf(buf, "%d\n", val & 1);
+	*fault = val & 1;
+
+	return 0;
 }
 
-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);
+	res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(channel), &val);
 	if (res < 0)
 		return res;
 
-	return sprintf(buf, "%d\n", (val * 1000));
+	*max = val * 1000;
+
+	return 0;
 }
 
-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)
+	res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), &val);
+	if (res < 0)
 		return res;
 
-	regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index),
-		     TEMP_LIMIT_TO_REG(val));
-	return count;
+	*crit = val * 1000;
+
+	return 0;
 }
 
-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);
+	res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(channel), &val);
 	if (res < 0)
 		return res;
 
-	return sprintf(buf, "%d\n", (val * 1000));
+	*emerg = val * 1000;
+
+	return 0;
 }
 
-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)
+	res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val);
+	if (res < 0)
 		return res;
 
-	regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index),
-		     TEMP_LIMIT_TO_REG(val));
-	return count;
+	*status = val;
+
+	return 0;
 }
 
-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;
-
-	regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), TEMP_LIMIT_TO_REG(val));
+	res = regmap_write(data->regmap, MAX6639_REG_ALERT_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_temp_set_emergency(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_TARGTDUTY(attr->index), &val);
-	if (res < 0)
-		return res;
+	res = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
 
-	return sprintf(buf, "%d\n", val * 255 / 120);
+	return res;
 }
 
-static ssize_t pwm_store(struct device *dev,
-			 struct device_attribute *dev_attr, const char *buf,
-			 size_t count)
+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 long val;
+	unsigned int val;
 	int res;
 
-	res = kstrtoul(buf, 10, &val);
-	if (res)
-		return res;
+	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);
+		if (res < 0)
+			return res;
+		*fan_val = FAN_FROM_REG(val, data->rpm_range[channel]);
+		return 0;
+	case hwmon_fan_fault:
+		res = max6639_get_status(dev, &val);
+		if (res < 0)
+			return res;
+		*fan_val = !!(val & BIT(1 - channel));
+		return 0;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr)
+{
+	/* Decrement the PPR value and shift left by 6 to match the register format */
+	return regmap_write(data->regmap, MAX6639_REG_FAN_PPR(channel), ppr-- << 6);
+}
 
-	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)
-		return res;
+	if (IS_ERR(data))
+		return PTR_ERR(data);
 
-	return sprintf(buf, "%d\n", FAN_FROM_REG(val, data->rpm_range));
+	switch (attr) {
+	case hwmon_pwm_input:
+		res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(channel), &val);
+		if (res < 0)
+			return res;
+		*pwm_val = val * 255 / 120;
+		return 0;
+	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;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+static umode_t max6639_pwm_is_visible(const void *_data, u32 attr, int channel)
+{
+	switch (attr) {
+	case hwmon_pwm_input:
+		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);
+		if (res < 0)
+			return res;
+		*val = !!(status & BIT(3 - channel));
+		return 0;
+	case hwmon_temp_crit_alarm:
+		res = max6639_get_status(dev, &status);
+		if (res < 0)
+			return res;
+		*val = !!(status & BIT(7 - channel));
+		return 0;
+	case hwmon_temp_emergency_alarm:
+		res = max6639_get_status(dev, &status);
+		if (res < 0)
+			return res;
+		*val = !!(status & BIT(5 - channel));
+		return 0;
+	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_pwm:
+		return max6639_write_pwm(dev, attr, channel, val);
+	case hwmon_temp:
+		return max6639_write_temp(dev, attr, channel, val);
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+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 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 const struct hwmon_channel_info * const max6639_info[] = {
+	HWMON_CHANNEL_INFO(fan,
+			   HWMON_F_INPUT | HWMON_F_FAULT,
+			   HWMON_F_INPUT | HWMON_F_FAULT),
+	HWMON_CHANNEL_INFO(pwm,
+			   HWMON_PWM_INPUT,
+			   HWMON_PWM_INPUT),
+	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 +484,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,30 +504,34 @@ 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);
+		err = max6639_set_ppr(data, i, data->ppr[i]);
 		if (err)
 			return err;
 
 		/* 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 +662,10 @@ 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);
+
 	return PTR_ERR_OR_ZERO(hwmon_dev);
 }
 

base-commit: 5124d9acf3af50bcc6d0958db4fecb3c2f13f8ed

Signature · 1 line
2.42.0
#1 lore raw

PATCH v4 2/2 hwmon: (max6639) : Add hwmon attributes for fan and pwm

Add attribute for fan & pwm i.e.,
fanY_pulse
pwmY_freq

---
 drivers/hwmon/max6639.c | 74 ++++++++++++++++++++++++++++++++++++++---
 1 file changed, 70 insertions(+), 4 deletions(-)
drivers/hwmon/max6639.c +70 -4
index e2a5210f9f95..6c7eaeeb2a80 100644
@@ -235,6 +235,9 @@ static int max6639_read_fan(struct device *dev, u32 attr, int channel,
 			return res;
 		*fan_val = !!(val & BIT(1 - channel));
 		return 0;
+	case hwmon_fan_pulses:
+		*fan_val = data->ppr[channel];
+		return 0;
 	default:
 		return -EOPNOTSUPP;
 	}
@@ -246,6 +249,32 @@ 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 int max6639_write_fan(struct device *dev, u32 attr, int channel,
+			     long val)
+{
+	struct max6639_data *data = dev_get_drvdata(dev);
+	int err;
+
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	switch (attr) {
+	case hwmon_fan_pulses:
+		if (val <= 0 || val > 5)
+			return -EINVAL;
+
+		/* Set Fan pulse per revolution */
+		err = max6639_set_ppr(data, channel, val);
+		if (err < 0)
+			return err;
+
+		data->ppr[channel] = val;
+		return 0;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
 static umode_t max6639_fan_is_visible(const void *_data, u32 attr, int channel)
 {
 	struct max6639_data *data = (struct max6639_data *)_data;
@@ -270,6 +299,7 @@ static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
 	struct max6639_data *data = dev_get_drvdata(dev);
 	unsigned int val;
 	int res;
+	u8 i;
 
 	if (IS_ERR(data))
 		return PTR_ERR(data);
@@ -281,6 +311,21 @@ static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
 			return res;
 		*pwm_val = val * 255 / 120;
 		return 0;
+	case hwmon_pwm_freq:
+		res = regmap_read(data->regmap, MAX6639_REG_FAN_CONFIG3(channel), &val);
+		if (res < 0)
+			return res;
+		i = 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)
+			i |= 0x4;
+		i &= 0x7;
+		*pwm_val = freq_table[i];
+		return 0;
 	default:
 		return -EOPNOTSUPP;
 	}
@@ -291,6 +336,7 @@ static int max6639_write_pwm(struct device *dev, u32 attr, int channel,
 {
 	struct max6639_data *data = dev_get_drvdata(dev);
 	int err;
+	u8 i;
 
 	if (IS_ERR(data))
 		return PTR_ERR(data);
@@ -301,6 +347,23 @@ static int max6639_write_pwm(struct device *dev, u32 attr, int channel,
 		err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(channel),
 				   val * 120 / 255);
 		return err;
+	case hwmon_pwm_freq:
+		val = clamp_val(val, 0, 25000);
+
+		i = find_closest(val, freq_table, ARRAY_SIZE(freq_table));
+
+		err = regmap_update_bits(data->regmap, MAX6639_REG_FAN_CONFIG3(channel),
+					 MAX6639_FAN_CONFIG3_FREQ_MASK, i);
+		if (err < 0)
+			return err;
+
+		if (i >> 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;
 	}
@@ -310,6 +373,7 @@ static umode_t max6639_pwm_is_visible(const void *_data, u32 attr, int channel)
 {
 	switch (attr) {
 	case hwmon_pwm_input:
+	case hwmon_pwm_freq:
 		return 0644;
 	default:
 		return 0;
@@ -415,6 +479,8 @@ 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:
@@ -442,11 +508,11 @@ static umode_t max6639_is_visible(const void *data,
 
 static const struct hwmon_channel_info * const max6639_info[] = {
 	HWMON_CHANNEL_INFO(fan,
-			   HWMON_F_INPUT | HWMON_F_FAULT,
-			   HWMON_F_INPUT | HWMON_F_FAULT),
+			   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_INPUT),
+			   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 |
Signature · 1 line
2.42.0
maintainer
#2 lore raw

Re: [PATCH v4 2/2] hwmon: (max6639) : Add hwmon attributes for fan and pwm

Quoted 26 lines · Naresh Solanki

Add attribute for fan & pwm i.e.,
fanY_pulse
pwmY_freq

---
  drivers/hwmon/max6639.c | 74 ++++++++++++++++++++++++++++++++++++++---
  1 file changed, 70 insertions(+), 4 deletions(-)
drivers/hwmon/max6639.c +3 -0
index e2a5210f9f95..6c7eaeeb2a80 100644
@@ -235,6 +235,9 @@ static int max6639_read_fan(struct device *dev, u32 attr, int channel,
  			return res;
  		*fan_val = !!(val & BIT(1 - channel));
  		return 0;
+	case hwmon_fan_pulses:
+		*fan_val = data->ppr[channel];
+		return 0;
  	default:
  		return -EOPNOTSUPP;
  	}
@@ -246,6 +249,32 @@ 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);
  }

drivers/hwmon/max6639.c static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr) · line 260

Quoted 10 lines
drivers/hwmon/max6639.c +9 -0
 
+static int max6639_write_fan(struct device *dev, u32 attr, int channel,
+			     long val)
+{
+	struct max6639_data *data = dev_get_drvdata(dev);
+	int err;
+
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+

Unnecessary check.

drivers/hwmon/max6639.c static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr) · line 271

Quoted 11 lines
drivers/hwmon/max6639.c +11 -0
+	switch (attr) {
+	case hwmon_fan_pulses:
+		if (val <= 0 || val > 5)
+			return -EINVAL;
+
+		/* Set Fan pulse per revolution */
+		err = max6639_set_ppr(data, channel, val);
+		if (err < 0)
+			return err;
+
+		data->ppr[channel] = val;

Needs mutex protection to avoid inconsistencies due to concurrent writes.

Quoted 23 lines
drivers/hwmon/max6639.c +9 -0
+		return 0;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
  static umode_t max6639_fan_is_visible(const void *_data, u32 attr, int channel)
  {
  	struct max6639_data *data = (struct max6639_data *)_data;
@@ -270,6 +299,7 @@ static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
  	struct max6639_data *data = dev_get_drvdata(dev);
  	unsigned int val;
  	int res;
+	u8 i;
 
  	if (IS_ERR(data))
  		return PTR_ERR(data);
@@ -281,6 +311,21 @@ static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
  			return res;
  		*pwm_val = val * 255 / 120;
  		return 0;
+	case hwmon_pwm_freq:
+		res = regmap_read(data->regmap, MAX6639_REG_FAN_CONFIG3(channel), &val);

drivers/hwmon/max6639.c static int max6639_read_pwm(struct device *dev, u32 attr, int channel, · line 325

Quoted 10 lines
drivers/hwmon/max6639.c +10 -0
+		if (res < 0)
+			return res;
+		i = 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)
+			i |= 0x4;

This sequence will need to be mutex protected to avoid consistency errors if a write happens at the same time.

Quoted 24 lines
drivers/hwmon/max6639.c +10 -0
+		i &= 0x7;
+		*pwm_val = freq_table[i];
+		return 0;
  	default:
  		return -EOPNOTSUPP;
  	}
@@ -291,6 +336,7 @@ static int max6639_write_pwm(struct device *dev, u32 attr, int channel,
  {
  	struct max6639_data *data = dev_get_drvdata(dev);
  	int err;
+	u8 i;
 
  	if (IS_ERR(data))
  		return PTR_ERR(data);
@@ -301,6 +347,23 @@ static int max6639_write_pwm(struct device *dev, u32 attr, int channel,
  		err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(channel),
  				   val * 120 / 255);
  		return err;
+	case hwmon_pwm_freq:
+		val = clamp_val(val, 0, 25000);
+
+		i = find_closest(val, freq_table, ARRAY_SIZE(freq_table));
+
+		err = regmap_update_bits(data->regmap, MAX6639_REG_FAN_CONFIG3(channel),

drivers/hwmon/max6639.c static int max6639_write_pwm(struct device *dev, u32 attr, int channel, · line 365

Quoted 10 lines
drivers/hwmon/max6639.c +10 -0
+					 MAX6639_FAN_CONFIG3_FREQ_MASK, i);
+		if (err < 0)
+			return err;
+
+		if (i >> 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);

Same as above. In general, every operation with more than a single element needs to be mutex protected.

Quoted 37 lines
drivers/hwmon/max6639.c +8 -4
+		return err;
  	default:
  		return -EOPNOTSUPP;
  	}
@@ -310,6 +373,7 @@ static umode_t max6639_pwm_is_visible(const void *_data, u32 attr, int channel)
  {
  	switch (attr) {
  	case hwmon_pwm_input:
+	case hwmon_pwm_freq:
  		return 0644;
  	default:
  		return 0;
@@ -415,6 +479,8 @@ 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:
@@ -442,11 +508,11 @@ static umode_t max6639_is_visible(const void *data,
 
  static const struct hwmon_channel_info * const max6639_info[] = {
  	HWMON_CHANNEL_INFO(fan,
-			   HWMON_F_INPUT | HWMON_F_FAULT,
-			   HWMON_F_INPUT | HWMON_F_FAULT),
+			   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_INPUT),
+			   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 |
#3 lore raw

Re: [PATCH v4 2/2] hwmon: (max6639) : Add hwmon attributes for fan and pwm

Hi Guenter,

Quoted 29 lines · Guenter Roeck
Quoted 27 lines · Naresh Solanki

Add attribute for fan & pwm i.e.,
fanY_pulse
pwmY_freq

---
  drivers/hwmon/max6639.c | 74 ++++++++++++++++++++++++++++++++++++++---
  1 file changed, 70 insertions(+), 4 deletions(-)
drivers/hwmon/max6639.c +3 -0
index e2a5210f9f95..6c7eaeeb2a80 100644
@@ -235,6 +235,9 @@ static int max6639_read_fan(struct device *dev, u32 attr, int channel,
                      return res;
              *fan_val = !!(val & BIT(1 - channel));
              return 0;
+     case hwmon_fan_pulses:
+             *fan_val = data->ppr[channel];
+             return 0;
      default:
              return -EOPNOTSUPP;
      }
@@ -246,6 +249,32 @@ 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);
  }
 
Quoted 11 lines

drivers/hwmon/max6639.c static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr) · line 260

Quoted 9 lines
drivers/hwmon/max6639.c +9 -0
+static int max6639_write_fan(struct device *dev, u32 attr, int channel,
+                          long val)
+{
+     struct max6639_data *data = dev_get_drvdata(dev);
+     int err;
+
+     if (IS_ERR(data))
+             return PTR_ERR(data);
+

Unnecessary check.

Ack.

Quoted 14 lines

drivers/hwmon/max6639.c static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr) · line 271

Quoted 12 lines
drivers/hwmon/max6639.c +11 -0
+     switch (attr) {
+     case hwmon_fan_pulses:
+             if (val <= 0 || val > 5)
+                     return -EINVAL;
+
+             /* Set Fan pulse per revolution */
+             err = max6639_set_ppr(data, channel, val);
+             if (err < 0)
+                     return err;
+
+             data->ppr[channel] = val;

Needs mutex protection to avoid inconsistencies due to concurrent writes.

This is single i2c access. Still we need mutex protection here ?

Quoted 29 lines
Quoted 29 lines
drivers/hwmon/max6639.c +14 -0
+             return 0;
+     default:
+             return -EOPNOTSUPP;
+     }
+}
+
  static umode_t max6639_fan_is_visible(const void *_data, u32 attr, int channel)
  {
      struct max6639_data *data = (struct max6639_data *)_data;
@@ -270,6 +299,7 @@ static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
      struct max6639_data *data = dev_get_drvdata(dev);
      unsigned int val;
      int res;
+     u8 i;
 
      if (IS_ERR(data))
              return PTR_ERR(data);
@@ -281,6 +311,21 @@ static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
                      return res;
              *pwm_val = val * 255 / 120;
              return 0;
+     case hwmon_pwm_freq:
+             res = regmap_read(data->regmap, MAX6639_REG_FAN_CONFIG3(channel), &val);
+             if (res < 0)
+                     return res;
+             i = val & MAX6639_FAN_CONFIG3_FREQ_MASK;
+
+             res = regmap_read(data->regmap, MAX6639_REG_GCONFIG, &val);
Quoted 8 lines

drivers/hwmon/max6639.c static int max6639_read_pwm(struct device *dev, u32 attr, int channel, · line 325

Quoted 5 lines
drivers/hwmon/max6639.c +5 -0
+             if (res < 0)
+                     return res;
+
+             if (val & MAX6639_GCONFIG_PWM_FREQ_HI)
+                     i |= 0x4;

This sequence will need to be mutex protected to avoid consistency errors if a write happens at the same time.

Ack. Yes, there is multiple access to the device. Will update accordingly.

Quoted 31 lines
Quoted 31 lines
drivers/hwmon/max6639.c +15 -0
+             i &= 0x7;
+             *pwm_val = freq_table[i];
+             return 0;
      default:
              return -EOPNOTSUPP;
      }
@@ -291,6 +336,7 @@ static int max6639_write_pwm(struct device *dev, u32 attr, int channel,
  {
      struct max6639_data *data = dev_get_drvdata(dev);
      int err;
+     u8 i;
 
      if (IS_ERR(data))
              return PTR_ERR(data);
@@ -301,6 +347,23 @@ static int max6639_write_pwm(struct device *dev, u32 attr, int channel,
              err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(channel),
                                 val * 120 / 255);
              return err;
+     case hwmon_pwm_freq:
+             val = clamp_val(val, 0, 25000);
+
+             i = find_closest(val, freq_table, ARRAY_SIZE(freq_table));
+
+             err = regmap_update_bits(data->regmap, MAX6639_REG_FAN_CONFIG3(channel),
+                                      MAX6639_FAN_CONFIG3_FREQ_MASK, i);
+             if (err < 0)
+                     return err;
+
+             if (i >> 2)
Quoted 8 lines

drivers/hwmon/max6639.c static int max6639_write_pwm(struct device *dev, u32 attr, int channel, · line 365

Quoted 5 lines
drivers/hwmon/max6639.c +5 -0
+                     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);

Same as above. In general, every operation with more than a single element needs to be mutex protected.

Ack.

Regards,
Naresh

Quoted 39 lines
Quoted 38 lines
drivers/hwmon/max6639.c +8 -4
+             return err;
      default:
              return -EOPNOTSUPP;
      }
@@ -310,6 +373,7 @@ static umode_t max6639_pwm_is_visible(const void *_data, u32 attr, int channel)
  {
      switch (attr) {
      case hwmon_pwm_input:
+     case hwmon_pwm_freq:
              return 0644;
      default:
              return 0;
@@ -415,6 +479,8 @@ 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:
@@ -442,11 +508,11 @@ static umode_t max6639_is_visible(const void *data,
 
  static const struct hwmon_channel_info * const max6639_info[] = {
      HWMON_CHANNEL_INFO(fan,
-                        HWMON_F_INPUT | HWMON_F_FAULT,
-                        HWMON_F_INPUT | HWMON_F_FAULT),
+                        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_INPUT),
+                        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 |
maintainer
#4 lore raw

Re: [PATCH v4 2/2] hwmon: (max6639) : Add hwmon attributes for fan and pwm

On 6/13/24 02:51, Naresh Solanki wrote:
...

Quoted 14 lines
Quoted 14 lines

drivers/hwmon/max6639.c static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr) · line 271

Quoted 12 lines
drivers/hwmon/max6639.c +11 -0
+     switch (attr) {
+     case hwmon_fan_pulses:
+             if (val <= 0 || val > 5)
+                     return -EINVAL;
+
+             /* Set Fan pulse per revolution */
+             err = max6639_set_ppr(data, channel, val);
+             if (err < 0)
+                     return err;
+
+             data->ppr[channel] = val;

Needs mutex protection to avoid inconsistencies due to concurrent writes.

Quoted 1 line

This is single i2c access. Still we need mutex protection here ?

In this case, the mutex doesn't protect the i2c access, it protects the consistency between the chip configuration and the information stored in data->ppr[].

CPU1 CPU2
[val==1] [val!=1]

max6639_set_ppr();
			max6639_set_ppr();
			data->ppr[channel] = val;

data->ppr[channel] = val;

The alternative would be to not cache ppr and read it from the regmap cache when needed.

Guenter

maintainer
#5 lore raw
In reply to Naresh Solanki

Hi Naresh,

Quoted 5 lines · Naresh Solanki

Update hwmon init with info instead of group. The hwmon info structure in more flexible to describe sensor attribute & easy to maintian.

---

After applying your patch, I get the following errors in my module tests.

Testing max6639 ...
temp1_crit: Suspected underflow: [min=0, read 255000, written -2147483648]
temp1_emergency: Suspected underflow: [min=0, read 255000, written -2147483648]
temp1_max: Suspected underflow: [min=0, read 255000, written -2147483648]
temp2_crit: Suspected underflow: [min=0, read 255000, written -2147483648]
temp2_emergency: Suspected underflow: [min=0, read 255000, written -2147483648]
temp2_max: Suspected underflow: [min=0, read 255000, written -2147483648]

That was not seen before. Problem is that your set functions pass 'unsigned long' as parameter, converting negative values into large positive ones.

Guenter

Quoted 669 lines

Changes in v4:
- Change res type from unsigned to signed

Changes in V3:
- return 0 when 'res' variable is known zero.
- Handle errors first before assigning results
- Use BIT to make it easier to read.
- Remove error message print on user input
- Return err value instead of printing error message & returing zero.
- Remove variable declaration in switch case statement
- Use find_closest instead of for loop
- Remove pointless assignment & check
- Seperate patch for adding additional attributes

---
 drivers/hwmon/max6639.c | 469 +++++++++++++++++++++++++---------------
 1 file changed, 299 insertions(+), 170 deletions(-)

base-commit: 5124d9acf3af50bcc6d0958db4fecb3c2f13f8ed

drivers/hwmon/max6639.c +299 -170
index cbb595fe47aa..e2a5210f9f95 100644
@@ -21,6 +21,7 @@
 #include <linux/mutex.h>
 #include <linux/platform_data/max6639.h>
 #include <linux/regmap.h>
+#include <linux/util_macros.h>
 
 /* Addresses to scan */
 static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
@@ -55,13 +56,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 +78,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 +95,378 @@ 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 0;
 }
 
-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);
+	res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(channel), &val);
 	if (res < 0)
 		return res;
 
-	return sprintf(buf, "%d\n", val & 1);
+	*fault = val & 1;
+
+	return 0;
 }
 
-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);
+	res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(channel), &val);
 	if (res < 0)
 		return res;
 
-	return sprintf(buf, "%d\n", (val * 1000));
+	*max = val * 1000;
+
+	return 0;
 }
 
-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)
+	res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), &val);
+	if (res < 0)
 		return res;
 
-	regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index),
-		     TEMP_LIMIT_TO_REG(val));
-	return count;
+	*crit = val * 1000;
+
+	return 0;
 }
 
-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);
+	res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(channel), &val);
 	if (res < 0)
 		return res;
 
-	return sprintf(buf, "%d\n", (val * 1000));
+	*emerg = val * 1000;
+
+	return 0;
 }
 
-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)
+	res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val);
+	if (res < 0)
 		return res;
 
-	regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index),
-		     TEMP_LIMIT_TO_REG(val));
-	return count;
+	*status = val;
+
+	return 0;
 }
 
-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;
-
-	regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), TEMP_LIMIT_TO_REG(val));
+	res = regmap_write(data->regmap, MAX6639_REG_ALERT_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_temp_set_emergency(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_TARGTDUTY(attr->index), &val);
-	if (res < 0)
-		return res;
+	res = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
 
-	return sprintf(buf, "%d\n", val * 255 / 120);
+	return res;
 }
 
-static ssize_t pwm_store(struct device *dev,
-			 struct device_attribute *dev_attr, const char *buf,
-			 size_t count)
+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 long val;
+	unsigned int val;
 	int res;
 
-	res = kstrtoul(buf, 10, &val);
-	if (res)
-		return res;
+	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);
+		if (res < 0)
+			return res;
+		*fan_val = FAN_FROM_REG(val, data->rpm_range[channel]);
+		return 0;
+	case hwmon_fan_fault:
+		res = max6639_get_status(dev, &val);
+		if (res < 0)
+			return res;
+		*fan_val = !!(val & BIT(1 - channel));
+		return 0;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr)
+{
+	/* Decrement the PPR value and shift left by 6 to match the register format */
+	return regmap_write(data->regmap, MAX6639_REG_FAN_PPR(channel), ppr-- << 6);
+}
 
-	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)
-		return res;
+	if (IS_ERR(data))
+		return PTR_ERR(data);
 
-	return sprintf(buf, "%d\n", FAN_FROM_REG(val, data->rpm_range));
+	switch (attr) {
+	case hwmon_pwm_input:
+		res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(channel), &val);
+		if (res < 0)
+			return res;
+		*pwm_val = val * 255 / 120;
+		return 0;
+	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;
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+static umode_t max6639_pwm_is_visible(const void *_data, u32 attr, int channel)
+{
+	switch (attr) {
+	case hwmon_pwm_input:
+		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);
+		if (res < 0)
+			return res;
+		*val = !!(status & BIT(3 - channel));
+		return 0;
+	case hwmon_temp_crit_alarm:
+		res = max6639_get_status(dev, &status);
+		if (res < 0)
+			return res;
+		*val = !!(status & BIT(7 - channel));
+		return 0;
+	case hwmon_temp_emergency_alarm:
+		res = max6639_get_status(dev, &status);
+		if (res < 0)
+			return res;
+		*val = !!(status & BIT(5 - channel));
+		return 0;
+	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_pwm:
+		return max6639_write_pwm(dev, attr, channel, val);
+	case hwmon_temp:
+		return max6639_write_temp(dev, attr, channel, val);
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
+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 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 const struct hwmon_channel_info * const max6639_info[] = {
+	HWMON_CHANNEL_INFO(fan,
+			   HWMON_F_INPUT | HWMON_F_FAULT,
+			   HWMON_F_INPUT | HWMON_F_FAULT),
+	HWMON_CHANNEL_INFO(pwm,
+			   HWMON_PWM_INPUT,
+			   HWMON_PWM_INPUT),
+	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 +484,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,30 +504,34 @@ 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);
+		err = max6639_set_ppr(data, i, data->ppr[i]);
 		if (err)
 			return err;
 
 		/* 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 +662,10 @@ 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);
+
 	return PTR_ERR_OR_ZERO(hwmon_dev);
 }
 
#6 lore raw

Hi Guenter,

Quoted 20 lines · Guenter Roeck

Hi Naresh,

Quoted 5 lines · Naresh Solanki

Update hwmon init with info instead of group. The hwmon info structure in more flexible to describe sensor attribute & easy to maintian.

---

After applying your patch, I get the following errors in my module tests.

Testing max6639 ...
temp1_crit: Suspected underflow: [min=0, read 255000, written -2147483648]
temp1_emergency: Suspected underflow: [min=0, read 255000, written -2147483648]
temp1_max: Suspected underflow: [min=0, read 255000, written -2147483648]
temp2_crit: Suspected underflow: [min=0, read 255000, written -2147483648]
temp2_emergency: Suspected underflow: [min=0, read 255000, written -2147483648]
temp2_max: Suspected underflow: [min=0, read 255000, written -2147483648]

Quoted 2 lines

That was not seen before. Problem is that your set functions pass 'unsigned long' as parameter, converting negative values into large positive ones.

Agree. Will update v5 with below changes:
For set functions, I'll change 'unsigned long' to long. For get functions, will do typecast as below:

        *crit = (long)val * 1000;

Please let me know if you have any other suggestions.

Thanks
Naresh.

Quoted 673 lines

Guenter

Quoted 669 lines

Changes in v4:
- Change res type from unsigned to signed

Changes in V3:
- return 0 when 'res' variable is known zero.
- Handle errors first before assigning results
- Use BIT to make it easier to read.
- Remove error message print on user input
- Return err value instead of printing error message & returing zero.
- Remove variable declaration in switch case statement
- Use find_closest instead of for loop
- Remove pointless assignment & check
- Seperate patch for adding additional attributes

---
 drivers/hwmon/max6639.c | 469 +++++++++++++++++++++++++---------------
 1 file changed, 299 insertions(+), 170 deletions(-)

base-commit: 5124d9acf3af50bcc6d0958db4fecb3c2f13f8ed

drivers/hwmon/max6639.c +299 -170
index cbb595fe47aa..e2a5210f9f95 100644
@@ -21,6 +21,7 @@
 #include <linux/mutex.h>
 #include <linux/platform_data/max6639.h>
 #include <linux/regmap.h>
+#include <linux/util_macros.h>
 
 /* Addresses to scan */
 static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
@@ -55,13 +56,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 +78,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 +95,378 @@ 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 0;
 }
 
-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);
+     res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(channel), &val);
      if (res < 0)
              return res;
 
-     return sprintf(buf, "%d\n", val & 1);
+     *fault = val & 1;
+
+     return 0;
 }
 
-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);
+     res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(channel), &val);
      if (res < 0)
              return res;
 
-     return sprintf(buf, "%d\n", (val * 1000));
+     *max = val * 1000;
+
+     return 0;
 }
 
-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)
+     res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), &val);
+     if (res < 0)
              return res;
 
-     regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(attr->index),
-                  TEMP_LIMIT_TO_REG(val));
-     return count;
+     *crit = val * 1000;
+
+     return 0;
 }
 
-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);
+     res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(channel), &val);
      if (res < 0)
              return res;
 
-     return sprintf(buf, "%d\n", (val * 1000));
+     *emerg = val * 1000;
+
+     return 0;
 }
 
-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)
+     res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val);
+     if (res < 0)
              return res;
 
-     regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(attr->index),
-                  TEMP_LIMIT_TO_REG(val));
-     return count;
+     *status = val;
+
+     return 0;
 }
 
-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;
-
-     regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(attr->index), TEMP_LIMIT_TO_REG(val));
+     res = regmap_write(data->regmap, MAX6639_REG_ALERT_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_temp_set_emergency(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_TARGTDUTY(attr->index), &val);
-     if (res < 0)
-             return res;
+     res = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
 
-     return sprintf(buf, "%d\n", val * 255 / 120);
+     return res;
 }
 
-static ssize_t pwm_store(struct device *dev,
-                      struct device_attribute *dev_attr, const char *buf,
-                      size_t count)
+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 long val;
+     unsigned int val;
      int res;
 
-     res = kstrtoul(buf, 10, &val);
-     if (res)
-             return res;
+     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);
+             if (res < 0)
+                     return res;
+             *fan_val = FAN_FROM_REG(val, data->rpm_range[channel]);
+             return 0;
+     case hwmon_fan_fault:
+             res = max6639_get_status(dev, &val);
+             if (res < 0)
+                     return res;
+             *fan_val = !!(val & BIT(1 - channel));
+             return 0;
+     default:
+             return -EOPNOTSUPP;
+     }
+}
+
+static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr)
+{
+     /* Decrement the PPR value and shift left by 6 to match the register format */
+     return regmap_write(data->regmap, MAX6639_REG_FAN_PPR(channel), ppr-- << 6);
+}
 
-     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)
-             return res;
+     if (IS_ERR(data))
+             return PTR_ERR(data);
 
-     return sprintf(buf, "%d\n", FAN_FROM_REG(val, data->rpm_range));
+     switch (attr) {
+     case hwmon_pwm_input:
+             res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(channel), &val);
+             if (res < 0)
+                     return res;
+             *pwm_val = val * 255 / 120;
+             return 0;
+     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;
+     default:
+             return -EOPNOTSUPP;
+     }
+}
+
+static umode_t max6639_pwm_is_visible(const void *_data, u32 attr, int channel)
+{
+     switch (attr) {
+     case hwmon_pwm_input:
+             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);
+             if (res < 0)
+                     return res;
+             *val = !!(status & BIT(3 - channel));
+             return 0;
+     case hwmon_temp_crit_alarm:
+             res = max6639_get_status(dev, &status);
+             if (res < 0)
+                     return res;
+             *val = !!(status & BIT(7 - channel));
+             return 0;
+     case hwmon_temp_emergency_alarm:
+             res = max6639_get_status(dev, &status);
+             if (res < 0)
+                     return res;
+             *val = !!(status & BIT(5 - channel));
+             return 0;
+     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_pwm:
+             return max6639_write_pwm(dev, attr, channel, val);
+     case hwmon_temp:
+             return max6639_write_temp(dev, attr, channel, val);
+     default:
+             return -EOPNOTSUPP;
+     }
+}
+
+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 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 const struct hwmon_channel_info * const max6639_info[] = {
+     HWMON_CHANNEL_INFO(fan,
+                        HWMON_F_INPUT | HWMON_F_FAULT,
+                        HWMON_F_INPUT | HWMON_F_FAULT),
+     HWMON_CHANNEL_INFO(pwm,
+                        HWMON_PWM_INPUT,
+                        HWMON_PWM_INPUT),
+     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 +484,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,30 +504,34 @@ 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);
+             err = max6639_set_ppr(data, i, data->ppr[i]);
              if (err)
                      return err;
 
              /* 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 +662,10 @@ 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);
+
      return PTR_ERR_OR_ZERO(hwmon_dev);
 }
 
maintainer
#7 lore raw
Quoted 24 lines · Naresh Solanki

Hi Guenter,

Quoted 20 lines · Guenter Roeck

Hi Naresh,

Quoted 5 lines · Naresh Solanki

Update hwmon init with info instead of group. The hwmon info structure in more flexible to describe sensor attribute & easy to maintian.

---

After applying your patch, I get the following errors in my module tests.

Testing max6639 ...
temp1_crit: Suspected underflow: [min=0, read 255000, written -2147483648]
temp1_emergency: Suspected underflow: [min=0, read 255000, written -2147483648]
temp1_max: Suspected underflow: [min=0, read 255000, written -2147483648]
temp2_crit: Suspected underflow: [min=0, read 255000, written -2147483648]
temp2_emergency: Suspected underflow: [min=0, read 255000, written -2147483648]
temp2_max: Suspected underflow: [min=0, read 255000, written -2147483648]

Quoted 9 lines
Quoted 2 lines

That was not seen before. Problem is that your set functions pass 'unsigned long' as parameter, converting negative values into large positive ones.

Agree. Will update v5 with below changes:
For set functions, I'll change 'unsigned long' to long. For get functions, will do typecast as below:

         *crit = (long)val * 1000;

Please let me know if you have any other suggestions.

No. Running your patch through my module tests was the last step of applying it, so you were almost there.

Thanks,
Guenter