Skip to content

L
linux
Commit 678c2a45 authored by Guenter Roeck's avatar Guenter Roeck
Browse files
Options

hwmon: (max6697) Convert to with_info hwmon API 

Convert to with_info hwmon API to simplify the code and reduce its size.

This patch reduces object file size by approximately 25%.
Reviewed-by: default avatarTzung-Bi Shih <tzungbi@kernel.org>
Signed-off-by: default avatarGuenter Roeck <linux@roeck-us.net>
parent 3a2a8cc3
Hide whitespace changes
Inline Side-by-side
Showing with 171 additions and 289 deletions
drivers/hwmon/max6697.c
View file @ 678c2a45
...@@ -10,7 +10,6 @@ ...@@ -10,7 +10,6 @@
#include <linux/bits.h> #include <linux/bits.h>
#include <linux/err.h> #include <linux/err.h>
#include <linux/hwmon.h> #include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/i2c.h> #include <linux/i2c.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h> #include <linux/module.h>
...@@ -52,7 +51,9 @@ static const u8 MAX6697_REG_CRIT[] = { ...@@ -52,7 +51,9 @@ static const u8 MAX6697_REG_CRIT[] = {
(FIELD_PREP(MAX6697_EXTERNAL_MASK_CHIP, FIELD_GET(MAX6697_EXTERNAL_MASK_DT, reg)) | \ (FIELD_PREP(MAX6697_EXTERNAL_MASK_CHIP, FIELD_GET(MAX6697_EXTERNAL_MASK_DT, reg)) | \
FIELD_PREP(MAX6697_LOCAL_MASK_CHIP, FIELD_GET(MAX6697_LOCAL_MASK_DT, reg))) FIELD_PREP(MAX6697_LOCAL_MASK_CHIP, FIELD_GET(MAX6697_LOCAL_MASK_DT, reg)))
#define MAX6697_REG_STAT(n) (0x44 + (n)) #define MAX6697_REG_STAT_ALARM 0x44
#define MAX6697_REG_STAT_CRIT 0x45
#define MAX6697_REG_STAT_FAULT 0x46
#define MAX6697_REG_CONFIG 0x41 #define MAX6697_REG_CONFIG 0x41
#define MAX6581_CONF_EXTENDED BIT(1) #define MAX6581_CONF_EXTENDED BIT(1)
...@@ -78,7 +79,6 @@ struct max6697_chip_data { ...@@ -78,7 +79,6 @@ struct max6697_chip_data {
u32 have_crit; u32 have_crit;
u32 have_fault; u32 have_fault;
u8 valid_conf; u8 valid_conf;
const u8 *alarm_map;
}; };
struct max6697_data { struct max6697_data {
...@@ -98,11 +98,6 @@ struct max6697_data { ...@@ -98,11 +98,6 @@ struct max6697_data {
u32 alarms; u32 alarms;
}; };
/* Diode fault status bits on MAX6581 are right shifted by one bit */
static const u8 max6581_alarm_map[] = {
0, 0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23 };
static const struct max6697_chip_data max6697_chip_data[] = { static const struct max6697_chip_data max6697_chip_data[] = {
[max6581] = { [max6581] = {
.channels = 8, .channels = 8,
...@@ -110,7 +105,6 @@ static const struct max6697_chip_data max6697_chip_data[] = { ...@@ -110,7 +105,6 @@ static const struct max6697_chip_data max6697_chip_data[] = {
.have_ext = 0x7f, .have_ext = 0x7f,
.have_fault = 0xfe, .have_fault = 0xfe,
.valid_conf = MAX6581_CONF_EXTENDED | MAX6697_CONF_TIMEOUT, .valid_conf = MAX6581_CONF_EXTENDED | MAX6697_CONF_TIMEOUT,
.alarm_map = max6581_alarm_map,
}, },
[max6602] = { [max6602] = {
.channels = 5, .channels = 5,
...@@ -179,313 +173,202 @@ static const struct max6697_chip_data max6697_chip_data[] = { ...@@ -179,313 +173,202 @@ static const struct max6697_chip_data max6697_chip_data[] = {
}, },
}; };
static inline int max6581_offset_to_millic(int val) static int max6697_read(struct device *dev, enum hwmon_sensor_types type,
{ u32 attr, int channel, long *val)
return sign_extend32(val, 7) * 250;
}
static ssize_t temp_input_show(struct device *dev,
struct device_attribute *devattr, char *buf)
{ {
unsigned int offset_regs[2] = { MAX6581_REG_OFFSET_SELECT, MAX6581_REG_OFFSET };
unsigned int temp_regs[2] = { MAX6697_REG_TEMP[channel],
MAX6697_REG_TEMP_EXT[channel] };
struct max6697_data *data = dev_get_drvdata(dev); struct max6697_data *data = dev_get_drvdata(dev);
int index = to_sensor_dev_attr(devattr)->index; struct regmap *regmap = data->regmap;
unsigned int regs[2] = { MAX6697_REG_TEMP[index],
MAX6697_REG_TEMP_EXT[index] };
u8 regdata[2] = { }; u8 regdata[2] = { };
int temp, ret; u32 regval;
ret = regmap_multi_reg_read(data->regmap, regs, regdata,
data->chip->have_ext & BIT(index) ? 2 : 1);
if (ret)
return ret;
temp = ((regdata[0] - data->temp_offset) << 3) | (regdata[1] >> 5);
return sprintf(buf, "%d\n", temp * 125);
}
static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
char *buf)
{
struct max6697_data *data = dev_get_drvdata(dev);
int index = to_sensor_dev_attr_2(devattr)->index;
int nr = to_sensor_dev_attr_2(devattr)->nr;
unsigned int temp;
int reg, ret;
if (index == MAX6697_TEMP_MAX)
reg = MAX6697_REG_MAX[nr];
else
reg = MAX6697_REG_CRIT[nr];
ret = regmap_read(data->regmap, reg, &temp);
if (ret)
return ret;
return sprintf(buf, "%d\n", ((int)temp - data->temp_offset) * 1000);
}
static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct max6697_data *data = dev_get_drvdata(dev);
int index = to_sensor_dev_attr(attr)->index;
unsigned int alarms;
int reg, ret;
if (data->chip->alarm_map)
index = data->chip->alarm_map[index];
reg = MAX6697_REG_STAT(2 - (index / 8));
ret = regmap_read(data->regmap, reg, &alarms);
if (ret)
return ret;
return sprintf(buf, "%u\n", !!(alarms & BIT(index & 7)));
}
static ssize_t temp_store(struct device *dev,
struct device_attribute *devattr, const char *buf,
size_t count)
{
int nr = to_sensor_dev_attr_2(devattr)->nr;
int index = to_sensor_dev_attr_2(devattr)->index;
struct max6697_data *data = dev_get_drvdata(dev);
long temp;
int ret; int ret;
ret = kstrtol(buf, 10, &temp); switch (attr) {
if (ret < 0) case hwmon_temp_input:
return ret; ret = regmap_multi_reg_read(regmap, temp_regs, regdata,
data->chip->have_ext & BIT(channel) ? 2 : 1);
if (ret)
return ret;
*val = (((regdata[0] - data->temp_offset) << 3) | (regdata[1] >> 5)) * 125;
break;
case hwmon_temp_max:
ret = regmap_read(regmap, MAX6697_REG_MAX[channel], &regval);
if (ret)
return ret;
*val = ((int)regval - data->temp_offset) * 1000;
break;
case hwmon_temp_crit:
ret = regmap_read(regmap, MAX6697_REG_CRIT[channel], &regval);
if (ret)
return ret;
*val = ((int)regval - data->temp_offset) * 1000;
break;
case hwmon_temp_offset:
ret = regmap_multi_reg_read(regmap, offset_regs, regdata, 2);
if (ret)
return ret;
temp = clamp_val(temp, -1000000, 1000000); /* prevent underflow */ if (!(regdata[0] & BIT(channel - 1)))
temp = DIV_ROUND_CLOSEST(temp, 1000) + data->temp_offset; regdata[1] = 0;
temp = clamp_val(temp, 0, data->type == max6581 ? 255 : 127);
ret = regmap_write(data->regmap,
index == 2 ? MAX6697_REG_MAX[nr]
: MAX6697_REG_CRIT[nr],
temp);
return ret ? : count; *val = sign_extend32(regdata[1], 7) * 250;
break;
case hwmon_temp_fault:
ret = regmap_read(regmap, MAX6697_REG_STAT_FAULT, &regval);
if (ret)
return ret;
if (data->type == max6581)
*val = !!(regval & BIT(channel - 1));
else
*val = !!(regval & BIT(channel));
break;
case hwmon_temp_crit_alarm:
ret = regmap_read(regmap, MAX6697_REG_STAT_CRIT, &regval);
if (ret)
return ret;
*val = !!(regval & BIT(channel ? channel - 1 : 7));
break;
case hwmon_temp_max_alarm:
ret = regmap_read(regmap, MAX6697_REG_STAT_ALARM, &regval);
if (ret)
return ret;
switch (channel) {
case 0:
*val = !!(regval & BIT(6));
break;
case 7:
*val = !!(regval & BIT(7));
break;
default:
*val = !!(regval & BIT(channel - 1));
break;
}
break;
default:
return -EOPNOTSUPP;
}
return 0;
} }
static ssize_t offset_store(struct device *dev, struct device_attribute *devattr, const char *buf, static int max6697_write(struct device *dev, enum hwmon_sensor_types type,
size_t count) u32 attr, int channel, long val)
{ {
struct max6697_data *data = dev_get_drvdata(dev); struct max6697_data *data = dev_get_drvdata(dev);
int index = to_sensor_dev_attr(devattr)->index;
struct regmap *regmap = data->regmap; struct regmap *regmap = data->regmap;
long temp;
int ret; int ret;
ret = kstrtol(buf, 10, &temp); switch (attr) {
if (ret < 0) case hwmon_temp_max:
return ret; val = clamp_val(val, -1000000, 1000000); /* prevent underflow */
val = DIV_ROUND_CLOSEST(val, 1000) + data->temp_offset;
mutex_lock(&data->update_lock); val = clamp_val(val, 0, data->type == max6581 ? 255 : 127);
temp = clamp_val(temp, MAX6581_OFFSET_MIN, MAX6581_OFFSET_MAX); return regmap_write(regmap, MAX6697_REG_MAX[channel], val);
temp = DIV_ROUND_CLOSEST(temp, 250); case hwmon_temp_crit:
if (!temp) { /* disable this (and only this) channel */ val = clamp_val(val, -1000000, 1000000); /* prevent underflow */
ret = regmap_clear_bits(regmap, MAX6581_REG_OFFSET_SELECT, BIT(index - 1)); val = DIV_ROUND_CLOSEST(val, 1000) + data->temp_offset;
goto unlock; val = clamp_val(val, 0, data->type == max6581 ? 255 : 127);
} return regmap_write(regmap, MAX6697_REG_CRIT[channel], val);
/* enable channel, and update offset */ case hwmon_temp_offset:
ret = regmap_set_bits(regmap, MAX6581_REG_OFFSET_SELECT, BIT(index - 1)); mutex_lock(&data->update_lock);
if (ret) val = clamp_val(val, MAX6581_OFFSET_MIN, MAX6581_OFFSET_MAX);
goto unlock; val = DIV_ROUND_CLOSEST(val, 250);
ret = regmap_write(regmap, MAX6581_REG_OFFSET, temp); if (!val) { /* disable this (and only this) channel */
ret = regmap_clear_bits(regmap, MAX6581_REG_OFFSET_SELECT,
BIT(channel - 1));
} else {
/* enable channel and update offset */
ret = regmap_set_bits(regmap, MAX6581_REG_OFFSET_SELECT,
BIT(channel - 1));
if (ret)
goto unlock;
ret = regmap_write(regmap, MAX6581_REG_OFFSET, val);
}
unlock: unlock:
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return ret ? : count;
}
static ssize_t offset_show(struct device *dev, struct device_attribute *devattr, char *buf)
{
unsigned int regs[2] = { MAX6581_REG_OFFSET_SELECT, MAX6581_REG_OFFSET };
struct max6697_data *data = dev_get_drvdata(dev);
int index = to_sensor_dev_attr(devattr)->index;
u8 regdata[2];
int ret;
ret = regmap_multi_reg_read(data->regmap, regs, regdata, 2);
if (ret)
return ret; return ret;
default:
if (!(regdata[0] & BIT(index - 1))) return -EOPNOTSUPP;
regdata[1] = 0; }
return sprintf(buf, "%d\n", max6581_offset_to_millic(regdata[1]));
} }
static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0); static umode_t max6697_is_visible(const void *_data, enum hwmon_sensor_types type,
static SENSOR_DEVICE_ATTR_2_RW(temp1_max, temp, 0, MAX6697_TEMP_MAX); u32 attr, int channel)
static SENSOR_DEVICE_ATTR_2_RW(temp1_crit, temp, 0, MAX6697_TEMP_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_input, 1);
static SENSOR_DEVICE_ATTR_2_RW(temp2_max, temp, 1, MAX6697_TEMP_MAX);
static SENSOR_DEVICE_ATTR_2_RW(temp2_crit, temp, 1, MAX6697_TEMP_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp3_input, temp_input, 2);
static SENSOR_DEVICE_ATTR_2_RW(temp3_max, temp, 2, MAX6697_TEMP_MAX);
static SENSOR_DEVICE_ATTR_2_RW(temp3_crit, temp, 2, MAX6697_TEMP_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp4_input, temp_input, 3);
static SENSOR_DEVICE_ATTR_2_RW(temp4_max, temp, 3, MAX6697_TEMP_MAX);
static SENSOR_DEVICE_ATTR_2_RW(temp4_crit, temp, 3, MAX6697_TEMP_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp5_input, temp_input, 4);
static SENSOR_DEVICE_ATTR_2_RW(temp5_max, temp, 4, MAX6697_TEMP_MAX);
static SENSOR_DEVICE_ATTR_2_RW(temp5_crit, temp, 4, MAX6697_TEMP_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp6_input, temp_input, 5);
static SENSOR_DEVICE_ATTR_2_RW(temp6_max, temp, 5, MAX6697_TEMP_MAX);
static SENSOR_DEVICE_ATTR_2_RW(temp6_crit, temp, 5, MAX6697_TEMP_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp7_input, temp_input, 6);
static SENSOR_DEVICE_ATTR_2_RW(temp7_max, temp, 6, MAX6697_TEMP_MAX);
static SENSOR_DEVICE_ATTR_2_RW(temp7_crit, temp, 6, MAX6697_TEMP_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp8_input, temp_input, 7);
static SENSOR_DEVICE_ATTR_2_RW(temp8_max, temp, 7, MAX6697_TEMP_MAX);
static SENSOR_DEVICE_ATTR_2_RW(temp8_crit, temp, 7, MAX6697_TEMP_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 22);
static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, 16);
static SENSOR_DEVICE_ATTR_RO(temp3_max_alarm, alarm, 17);
static SENSOR_DEVICE_ATTR_RO(temp4_max_alarm, alarm, 18);
static SENSOR_DEVICE_ATTR_RO(temp5_max_alarm, alarm, 19);
static SENSOR_DEVICE_ATTR_RO(temp6_max_alarm, alarm, 20);
static SENSOR_DEVICE_ATTR_RO(temp7_max_alarm, alarm, 21);
static SENSOR_DEVICE_ATTR_RO(temp8_max_alarm, alarm, 23);
static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, alarm, 15);
static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, 8);
static SENSOR_DEVICE_ATTR_RO(temp3_crit_alarm, alarm, 9);
static SENSOR_DEVICE_ATTR_RO(temp4_crit_alarm, alarm, 10);
static SENSOR_DEVICE_ATTR_RO(temp5_crit_alarm, alarm, 11);
static SENSOR_DEVICE_ATTR_RO(temp6_crit_alarm, alarm, 12);
static SENSOR_DEVICE_ATTR_RO(temp7_crit_alarm, alarm, 13);
static SENSOR_DEVICE_ATTR_RO(temp8_crit_alarm, alarm, 14);
static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 1);
static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 2);
static SENSOR_DEVICE_ATTR_RO(temp4_fault, alarm, 3);
static SENSOR_DEVICE_ATTR_RO(temp5_fault, alarm, 4);
static SENSOR_DEVICE_ATTR_RO(temp6_fault, alarm, 5);
static SENSOR_DEVICE_ATTR_RO(temp7_fault, alarm, 6);
static SENSOR_DEVICE_ATTR_RO(temp8_fault, alarm, 7);
/* There is no offset for local temperature so starting from temp2 */
static SENSOR_DEVICE_ATTR_RW(temp2_offset, offset, 1);
static SENSOR_DEVICE_ATTR_RW(temp3_offset, offset, 2);
static SENSOR_DEVICE_ATTR_RW(temp4_offset, offset, 3);
static SENSOR_DEVICE_ATTR_RW(temp5_offset, offset, 4);
static SENSOR_DEVICE_ATTR_RW(temp6_offset, offset, 5);
static SENSOR_DEVICE_ATTR_RW(temp7_offset, offset, 6);
static SENSOR_DEVICE_ATTR_RW(temp8_offset, offset, 7);
static DEVICE_ATTR(dummy, 0, NULL, NULL);
static umode_t max6697_is_visible(struct kobject *kobj, struct attribute *attr,
int index)
{ {
struct device *dev = kobj_to_dev(kobj); const struct max6697_data *data = _data;
struct max6697_data *data = dev_get_drvdata(dev);
const struct max6697_chip_data *chip = data->chip; const struct max6697_chip_data *chip = data->chip;
int channel = index / 7; /* channel number */
int nr = index % 7; /* attribute index within channel */
if (channel >= chip->channels) if (channel >= chip->channels)
return 0; return 0;
if ((nr == 3 || nr == 4) && !(chip->have_crit & BIT(channel))) switch (attr) {
return 0; case hwmon_temp_max:
if (nr == 5 && !(chip->have_fault & BIT(channel))) return 0644;
return 0; case hwmon_temp_input:
/* offset reg is only supported on max6581 remote channels */ case hwmon_temp_max_alarm:
if (nr == 6) return 0444;
if (data->type != max6581 || channel == 0) case hwmon_temp_crit:
return 0; if (chip->have_crit & BIT(channel))
return 0644;
return attr->mode; break;
case hwmon_temp_crit_alarm:
if (chip->have_crit & BIT(channel))
return 0444;
break;
case hwmon_temp_fault:
if (chip->have_fault & BIT(channel))
return 0444;
break;
case hwmon_temp_offset:
if (data->type == max6581 && channel)
return 0644;
break;
default:
break;
}
return 0;
} }
/* /* Return 0 if detection is successful, -ENODEV otherwise */
* max6697_is_visible uses the index into the following array to determine static const struct hwmon_channel_info * const max6697_info[] = {
* if attributes should be created or not. Any change in order or content HWMON_CHANNEL_INFO(temp,
* must be matched in max6697_is_visible. HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
*/ HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM,
static struct attribute *max6697_attributes[] = { HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
&sensor_dev_attr_temp1_input.dev_attr.attr, HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
&sensor_dev_attr_temp1_max.dev_attr.attr, HWMON_T_FAULT | HWMON_T_OFFSET,
&sensor_dev_attr_temp1_max_alarm.dev_attr.attr, HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
&sensor_dev_attr_temp1_crit.dev_attr.attr, HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, HWMON_T_FAULT | HWMON_T_OFFSET,
&dev_attr_dummy.attr, HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
&dev_attr_dummy.attr, HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
HWMON_T_FAULT | HWMON_T_OFFSET,
&sensor_dev_attr_temp2_input.dev_attr.attr, HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
&sensor_dev_attr_temp2_max.dev_attr.attr, HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
&sensor_dev_attr_temp2_max_alarm.dev_attr.attr, HWMON_T_FAULT | HWMON_T_OFFSET,
&sensor_dev_attr_temp2_crit.dev_attr.attr, HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
&sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
&sensor_dev_attr_temp2_fault.dev_attr.attr, HWMON_T_FAULT | HWMON_T_OFFSET,
&sensor_dev_attr_temp2_offset.dev_attr.attr, HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
&sensor_dev_attr_temp3_input.dev_attr.attr, HWMON_T_FAULT | HWMON_T_OFFSET,
&sensor_dev_attr_temp3_max.dev_attr.attr, HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT |
&sensor_dev_attr_temp3_max_alarm.dev_attr.attr, HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
&sensor_dev_attr_temp3_crit.dev_attr.attr, HWMON_T_FAULT | HWMON_T_OFFSET),
&sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
&sensor_dev_attr_temp3_fault.dev_attr.attr,
&sensor_dev_attr_temp3_offset.dev_attr.attr,
&sensor_dev_attr_temp4_input.dev_attr.attr,
&sensor_dev_attr_temp4_max.dev_attr.attr,
&sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
&sensor_dev_attr_temp4_crit.dev_attr.attr,
&sensor_dev_attr_temp4_crit_alarm.dev_attr.attr,
&sensor_dev_attr_temp4_fault.dev_attr.attr,
&sensor_dev_attr_temp4_offset.dev_attr.attr,
&sensor_dev_attr_temp5_input.dev_attr.attr,
&sensor_dev_attr_temp5_max.dev_attr.attr,
&sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
&sensor_dev_attr_temp5_crit.dev_attr.attr,
&sensor_dev_attr_temp5_crit_alarm.dev_attr.attr,
&sensor_dev_attr_temp5_fault.dev_attr.attr,
&sensor_dev_attr_temp5_offset.dev_attr.attr,
&sensor_dev_attr_temp6_input.dev_attr.attr,
&sensor_dev_attr_temp6_max.dev_attr.attr,
&sensor_dev_attr_temp6_max_alarm.dev_attr.attr,
&sensor_dev_attr_temp6_crit.dev_attr.attr,
&sensor_dev_attr_temp6_crit_alarm.dev_attr.attr,
&sensor_dev_attr_temp6_fault.dev_attr.attr,
&sensor_dev_attr_temp6_offset.dev_attr.attr,
&sensor_dev_attr_temp7_input.dev_attr.attr,
&sensor_dev_attr_temp7_max.dev_attr.attr,
&sensor_dev_attr_temp7_max_alarm.dev_attr.attr,
&sensor_dev_attr_temp7_crit.dev_attr.attr,
&sensor_dev_attr_temp7_crit_alarm.dev_attr.attr,
&sensor_dev_attr_temp7_fault.dev_attr.attr,
&sensor_dev_attr_temp7_offset.dev_attr.attr,
&sensor_dev_attr_temp8_input.dev_attr.attr,
&sensor_dev_attr_temp8_max.dev_attr.attr,
&sensor_dev_attr_temp8_max_alarm.dev_attr.attr,
&sensor_dev_attr_temp8_crit.dev_attr.attr,
&sensor_dev_attr_temp8_crit_alarm.dev_attr.attr,
&sensor_dev_attr_temp8_fault.dev_attr.attr,
&sensor_dev_attr_temp8_offset.dev_attr.attr,
NULL NULL
}; };
static const struct attribute_group max6697_group = { static const struct hwmon_ops max6697_hwmon_ops = {
.attrs = max6697_attributes, .is_visible = max6697_is_visible, .is_visible = max6697_is_visible,
.read = max6697_read,
.write = max6697_write,
};
static const struct hwmon_chip_info max6697_chip_info = {
.ops = &max6697_hwmon_ops,
.info = max6697_info,
}; };
__ATTRIBUTE_GROUPS(max6697);
static int max6697_config_of(struct device_node *node, struct max6697_data *data) static int max6697_config_of(struct device_node *node, struct max6697_data *data)
{ {
...@@ -635,9 +518,8 @@ static int max6697_probe(struct i2c_client *client) ...@@ -635,9 +518,8 @@ static int max6697_probe(struct i2c_client *client)
if (err) if (err)
return err; return err;
hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, data,
data, &max6697_chip_info, NULL);
max6697_groups);
return PTR_ERR_OR_ZERO(hwmon_dev); return PTR_ERR_OR_ZERO(hwmon_dev);
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7