From 65f1d1f1cd28b912168a711d824b49f64ce89035 Mon Sep 17 00:00:00 2001 From: Jean Delvare Date: Sun, 23 Sep 2007 12:12:19 +0000 Subject: [PATCH] Rename subfeature types from *_FEATURE_* to *_SUBFEATURE_*, to better reflect what they represent. git-svn-id: http://lm-sensors.org/svn/lm-sensors/branches/lm-sensors-3.0.0@4837 7894878c-1315-0410-8ee3-d5d059ff63e0 --- lib/sensors.h | 68 ++++++++--------- lib/sysfs.c | 106 +++++++++++++------------- prog/sensord/chips.c | 120 +++++++++++++++--------------- prog/sensors/chips.c | 172 ++++++++++++++++++++++--------------------- 4 files changed, 234 insertions(+), 232 deletions(-) diff --git a/lib/sensors.h b/lib/sensors.h index 23ca3f7d..dc6dfd97 100644 --- a/lib/sensors.h +++ b/lib/sensors.h @@ -128,49 +128,49 @@ const sensors_chip_name *sensors_get_detected_chips(const sensors_chip_name lib/sysfs.c. All the sensor types (in, fan, temp, vid) are a multiple of 0x100 apart, and sensor subfeatures which should not have a compute mapping to the _input subfeature start at 0x?10. */ -typedef enum sensors_feature_type { - SENSORS_FEATURE_IN = 0x000, - SENSORS_FEATURE_IN_MIN, - SENSORS_FEATURE_IN_MAX, - SENSORS_FEATURE_IN_ALARM = 0x010, - SENSORS_FEATURE_IN_MIN_ALARM, - SENSORS_FEATURE_IN_MAX_ALARM, - SENSORS_FEATURE_IN_BEEP, +typedef enum sensors_subfeature_type { + SENSORS_SUBFEATURE_IN_INPUT = 0x000, + SENSORS_SUBFEATURE_IN_MIN, + SENSORS_SUBFEATURE_IN_MAX, + SENSORS_SUBFEATURE_IN_ALARM = 0x010, + SENSORS_SUBFEATURE_IN_MIN_ALARM, + SENSORS_SUBFEATURE_IN_MAX_ALARM, + SENSORS_SUBFEATURE_IN_BEEP, - SENSORS_FEATURE_FAN = 0x100, - SENSORS_FEATURE_FAN_MIN, - SENSORS_FEATURE_FAN_ALARM = 0x110, - SENSORS_FEATURE_FAN_FAULT, - SENSORS_FEATURE_FAN_DIV, - SENSORS_FEATURE_FAN_BEEP, + SENSORS_SUBFEATURE_FAN_INPUT = 0x100, + SENSORS_SUBFEATURE_FAN_MIN, + SENSORS_SUBFEATURE_FAN_ALARM = 0x110, + SENSORS_SUBFEATURE_FAN_FAULT, + SENSORS_SUBFEATURE_FAN_DIV, + SENSORS_SUBFEATURE_FAN_BEEP, - SENSORS_FEATURE_TEMP = 0x200, - SENSORS_FEATURE_TEMP_MAX, - SENSORS_FEATURE_TEMP_MAX_HYST, - SENSORS_FEATURE_TEMP_MIN, - SENSORS_FEATURE_TEMP_CRIT, - SENSORS_FEATURE_TEMP_CRIT_HYST, - SENSORS_FEATURE_TEMP_ALARM = 0x210, - SENSORS_FEATURE_TEMP_MAX_ALARM, - SENSORS_FEATURE_TEMP_MIN_ALARM, - SENSORS_FEATURE_TEMP_CRIT_ALARM, - SENSORS_FEATURE_TEMP_FAULT, - SENSORS_FEATURE_TEMP_TYPE, - SENSORS_FEATURE_TEMP_OFFSET, - SENSORS_FEATURE_TEMP_BEEP, + SENSORS_SUBFEATURE_TEMP_INPUT = 0x200, + SENSORS_SUBFEATURE_TEMP_MAX, + SENSORS_SUBFEATURE_TEMP_MAX_HYST, + SENSORS_SUBFEATURE_TEMP_MIN, + SENSORS_SUBFEATURE_TEMP_CRIT, + SENSORS_SUBFEATURE_TEMP_CRIT_HYST, + SENSORS_SUBFEATURE_TEMP_ALARM = 0x210, + SENSORS_SUBFEATURE_TEMP_MAX_ALARM, + SENSORS_SUBFEATURE_TEMP_MIN_ALARM, + SENSORS_SUBFEATURE_TEMP_CRIT_ALARM, + SENSORS_SUBFEATURE_TEMP_FAULT, + SENSORS_SUBFEATURE_TEMP_TYPE, + SENSORS_SUBFEATURE_TEMP_OFFSET, + SENSORS_SUBFEATURE_TEMP_BEEP, - SENSORS_FEATURE_VID = 0x1000, + SENSORS_SUBFEATURE_VID = 0x1000, - SENSORS_FEATURE_BEEP_ENABLE = 0x1100, + SENSORS_SUBFEATURE_BEEP_ENABLE = 0x1100, - SENSORS_FEATURE_UNKNOWN = INT_MAX, -} sensors_feature_type; + SENSORS_SUBFEATURE_UNKNOWN = INT_MAX, +} sensors_subfeature_type; /* Data about a single chip feature (or category leader) */ struct sensors_feature { char *name; int first_subfeature; - sensors_feature_type type; + sensors_subfeature_type type; }; /* Data about a single chip subfeature: @@ -188,7 +188,7 @@ struct sensors_feature { typedef struct sensors_subfeature { char *name; int number; - sensors_feature_type type; + sensors_subfeature_type type; int mapping; unsigned int flags; } sensors_subfeature; diff --git a/lib/sysfs.c b/lib/sysfs.c index 3d23ed3c..37ad62c9 100644 --- a/lib/sysfs.c +++ b/lib/sysfs.c @@ -49,16 +49,16 @@ static int get_type_scaling(int type) { switch (type & 0xFF10) { - case SENSORS_FEATURE_IN: - case SENSORS_FEATURE_TEMP: + case SENSORS_SUBFEATURE_IN_INPUT: + case SENSORS_SUBFEATURE_TEMP_INPUT: return 1000; - case SENSORS_FEATURE_FAN: + case SENSORS_SUBFEATURE_FAN_INPUT: return 1; } switch (type) { - case SENSORS_FEATURE_VID: - case SENSORS_FEATURE_TEMP_OFFSET: + case SENSORS_SUBFEATURE_VID: + case SENSORS_SUBFEATURE_TEMP_OFFSET: return 1000; default: return 1; @@ -66,56 +66,56 @@ int get_type_scaling(int type) } /* Static mappings for use by sensors_subfeature_get_type() */ -struct feature_subtype_match +struct subfeature_type_match { const char *name; - sensors_feature_type type; + sensors_subfeature_type type; }; struct feature_type_match { const char *name; - const struct feature_subtype_match *submatches; + const struct subfeature_type_match *submatches; }; -static const struct feature_subtype_match temp_matches[] = { - { "input", SENSORS_FEATURE_TEMP }, - { "max", SENSORS_FEATURE_TEMP_MAX }, - { "max_hyst", SENSORS_FEATURE_TEMP_MAX_HYST }, - { "min", SENSORS_FEATURE_TEMP_MIN }, - { "crit", SENSORS_FEATURE_TEMP_CRIT }, - { "crit_hyst", SENSORS_FEATURE_TEMP_CRIT_HYST }, - { "alarm", SENSORS_FEATURE_TEMP_ALARM }, - { "min_alarm", SENSORS_FEATURE_TEMP_MIN_ALARM }, - { "max_alarm", SENSORS_FEATURE_TEMP_MAX_ALARM }, - { "crit_alarm", SENSORS_FEATURE_TEMP_CRIT_ALARM }, - { "fault", SENSORS_FEATURE_TEMP_FAULT }, - { "type", SENSORS_FEATURE_TEMP_TYPE }, - { "offset", SENSORS_FEATURE_TEMP_OFFSET }, +static const struct subfeature_type_match temp_matches[] = { + { "input", SENSORS_SUBFEATURE_TEMP_INPUT }, + { "max", SENSORS_SUBFEATURE_TEMP_MAX }, + { "max_hyst", SENSORS_SUBFEATURE_TEMP_MAX_HYST }, + { "min", SENSORS_SUBFEATURE_TEMP_MIN }, + { "crit", SENSORS_SUBFEATURE_TEMP_CRIT }, + { "crit_hyst", SENSORS_SUBFEATURE_TEMP_CRIT_HYST }, + { "alarm", SENSORS_SUBFEATURE_TEMP_ALARM }, + { "min_alarm", SENSORS_SUBFEATURE_TEMP_MIN_ALARM }, + { "max_alarm", SENSORS_SUBFEATURE_TEMP_MAX_ALARM }, + { "crit_alarm", SENSORS_SUBFEATURE_TEMP_CRIT_ALARM }, + { "fault", SENSORS_SUBFEATURE_TEMP_FAULT }, + { "type", SENSORS_SUBFEATURE_TEMP_TYPE }, + { "offset", SENSORS_SUBFEATURE_TEMP_OFFSET }, { NULL, 0 } }; -static const struct feature_subtype_match in_matches[] = { - { "input", SENSORS_FEATURE_IN }, - { "min", SENSORS_FEATURE_IN_MIN }, - { "max", SENSORS_FEATURE_IN_MAX }, - { "alarm", SENSORS_FEATURE_IN_ALARM }, - { "min_alarm", SENSORS_FEATURE_IN_MIN_ALARM }, - { "max_alarm", SENSORS_FEATURE_IN_MAX_ALARM }, +static const struct subfeature_type_match in_matches[] = { + { "input", SENSORS_SUBFEATURE_IN_INPUT }, + { "min", SENSORS_SUBFEATURE_IN_MIN }, + { "max", SENSORS_SUBFEATURE_IN_MAX }, + { "alarm", SENSORS_SUBFEATURE_IN_ALARM }, + { "min_alarm", SENSORS_SUBFEATURE_IN_MIN_ALARM }, + { "max_alarm", SENSORS_SUBFEATURE_IN_MAX_ALARM }, { NULL, 0 } }; -static const struct feature_subtype_match fan_matches[] = { - { "input", SENSORS_FEATURE_FAN }, - { "min", SENSORS_FEATURE_FAN_MIN }, - { "div", SENSORS_FEATURE_FAN_DIV }, - { "alarm", SENSORS_FEATURE_FAN_ALARM }, - { "fault", SENSORS_FEATURE_FAN_FAULT }, +static const struct subfeature_type_match fan_matches[] = { + { "input", SENSORS_SUBFEATURE_FAN_INPUT }, + { "min", SENSORS_SUBFEATURE_FAN_MIN }, + { "div", SENSORS_SUBFEATURE_FAN_DIV }, + { "alarm", SENSORS_SUBFEATURE_FAN_ALARM }, + { "fault", SENSORS_SUBFEATURE_FAN_FAULT }, { NULL, 0 } }; -static const struct feature_subtype_match cpu_matches[] = { - { "vid", SENSORS_FEATURE_VID }, +static const struct subfeature_type_match cpu_matches[] = { + { "vid", SENSORS_SUBFEATURE_VID }, { NULL, 0 } }; @@ -129,16 +129,16 @@ static struct feature_type_match matches[] = { /* Return the subfeature type and channel number based on the subfeature name */ static -sensors_feature_type sensors_subfeature_get_type(const char *name, int *nr) +sensors_subfeature_type sensors_subfeature_get_type(const char *name, int *nr) { char c; int i, count; - const struct feature_subtype_match *submatches; + const struct subfeature_type_match *submatches; /* Special case */ if (!strcmp(name, "beep_enable")) { *nr = 0; - return SENSORS_FEATURE_BEEP_ENABLE; + return SENSORS_SUBFEATURE_BEEP_ENABLE; } for (i = 0; i < ARRAY_SIZE(matches); i++) @@ -146,7 +146,7 @@ sensors_feature_type sensors_subfeature_get_type(const char *name, int *nr) break; if (i == ARRAY_SIZE(matches) || count != 2 || c != '_') - return SENSORS_FEATURE_UNKNOWN; /* no match */ + return SENSORS_SUBFEATURE_UNKNOWN; /* no match */ submatches = matches[i].submatches; name = strchr(name + 3, '_') + 1; @@ -154,7 +154,7 @@ sensors_feature_type sensors_subfeature_get_type(const char *name, int *nr) if (!strcmp(name, submatches[i].name)) return submatches[i].type; - return SENSORS_FEATURE_UNKNOWN; + return SENSORS_SUBFEATURE_UNKNOWN; } static int sensors_read_dynamic_chip(sensors_chip_features *chip, @@ -185,13 +185,13 @@ static int sensors_read_dynamic_chip(sensors_chip_features *chip, int nr; type = sensors_subfeature_get_type(name, &nr); - if (type == SENSORS_FEATURE_UNKNOWN) + if (type == SENSORS_SUBFEATURE_UNKNOWN) continue; /* Adjust the channel number */ switch (type & 0xFF00) { - case SENSORS_FEATURE_FAN: - case SENSORS_FEATURE_TEMP: + case SENSORS_SUBFEATURE_FAN_INPUT: + case SENSORS_SUBFEATURE_TEMP_INPUT: if (nr) nr--; break; @@ -207,10 +207,10 @@ static int sensors_read_dynamic_chip(sensors_chip_features *chip, /* "calculate" a place to store the subfeature in our sparse, sorted table */ switch (type) { - case SENSORS_FEATURE_VID: + case SENSORS_SUBFEATURE_VID: i = nr + MAX_SENSORS_PER_TYPE * MAX_SUBFEATURES * 6; break; - case SENSORS_FEATURE_BEEP_ENABLE: + case SENSORS_SUBFEATURE_BEEP_ENABLE: i = MAX_SENSORS_PER_TYPE * MAX_SUBFEATURES * 6 + MAX_SENSORS_PER_TYPE; break; @@ -550,9 +550,9 @@ int sensors_read_sysfs_attr(const sensors_chip_name *name, int subfeat_nr, return -SENSORS_ERR_NO_ENTRY; /* REVISIT: this is a ugly hack */ - if (subfeature->type == SENSORS_FEATURE_IN - || subfeature->type == SENSORS_FEATURE_FAN - || subfeature->type == SENSORS_FEATURE_TEMP) + if (subfeature->type == SENSORS_SUBFEATURE_IN_INPUT + || subfeature->type == SENSORS_SUBFEATURE_FAN_INPUT + || subfeature->type == SENSORS_SUBFEATURE_TEMP_INPUT) suffix = "_input"; snprintf(n, NAME_MAX, "%s/%s%s", name->path, subfeature->name, @@ -581,9 +581,9 @@ int sensors_write_sysfs_attr(const sensors_chip_name *name, int subfeat_nr, return -SENSORS_ERR_NO_ENTRY; /* REVISIT: this is a ugly hack */ - if (subfeature->type == SENSORS_FEATURE_IN - || subfeature->type == SENSORS_FEATURE_FAN - || subfeature->type == SENSORS_FEATURE_TEMP) + if (subfeature->type == SENSORS_SUBFEATURE_IN_INPUT + || subfeature->type == SENSORS_SUBFEATURE_FAN_INPUT + || subfeature->type == SENSORS_SUBFEATURE_TEMP_INPUT) suffix = "_input"; snprintf(n, NAME_MAX, "%s/%s%s", name->path, subfeature->name, diff --git a/prog/sensord/chips.c b/prog/sensord/chips.c index 5e9551ec..43b34960 100644 --- a/prog/sensord/chips.c +++ b/prog/sensord/chips.c @@ -162,30 +162,30 @@ static void getAvailableFeatures (const sensors_chip_name *name, } } -#define IN_FEATURE(x) has_features[x - SENSORS_FEATURE_IN] -#define IN_FEATURE_NR(x) feature_nrs[x - SENSORS_FEATURE_IN] +#define IN_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_IN_INPUT] +#define IN_FEATURE_NR(x) feature_nrs[x - SENSORS_SUBFEATURE_IN_INPUT] static void fillChipVoltage (FeatureDescriptor *voltage, const sensors_chip_name *name, const sensors_feature *feature) { - const int size = SENSORS_FEATURE_IN_BEEP - SENSORS_FEATURE_IN + 1; - short has_features[SENSORS_FEATURE_IN_BEEP - SENSORS_FEATURE_IN + 1] = { 0, }; - int feature_nrs[SENSORS_FEATURE_IN_BEEP - SENSORS_FEATURE_IN + 1]; + const int size = SENSORS_SUBFEATURE_IN_BEEP - SENSORS_SUBFEATURE_IN_INPUT + 1; + short has_features[SENSORS_SUBFEATURE_IN_BEEP - SENSORS_SUBFEATURE_IN_INPUT + 1] = { 0, }; + int feature_nrs[SENSORS_SUBFEATURE_IN_BEEP - SENSORS_SUBFEATURE_IN_INPUT + 1]; int pos = 0; voltage->rrd = rrdF2; voltage->type = DataType_voltage; getAvailableFeatures (name, feature, has_features, - feature_nrs, size, SENSORS_FEATURE_IN); + feature_nrs, size, SENSORS_SUBFEATURE_IN_INPUT); - voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_FEATURE_IN); + voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_INPUT); - if (IN_FEATURE(SENSORS_FEATURE_IN_MIN) && - IN_FEATURE(SENSORS_FEATURE_IN_MAX)) { + if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN) && + IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX)) { voltage->format = fmtVolts_2; - voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_FEATURE_IN_MIN); - voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_FEATURE_IN_MAX); + voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MIN); + voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MAX); } else { voltage->format = fmtVolt_2; } @@ -194,52 +194,52 @@ static void fillChipVoltage (FeatureDescriptor *voltage, voltage->dataNumbers[pos] = -1; /* alarm if applicable */ - if (IN_FEATURE(SENSORS_FEATURE_IN_ALARM)) { - voltage->alarmNumber = IN_FEATURE_NR(SENSORS_FEATURE_IN_ALARM); - } else if (IN_FEATURE(SENSORS_FEATURE_IN_MIN_ALARM)) { - voltage->alarmNumber = IN_FEATURE_NR(SENSORS_FEATURE_IN_MIN_ALARM); - } else if (IN_FEATURE(SENSORS_FEATURE_IN_MAX_ALARM)) { - voltage->alarmNumber = IN_FEATURE_NR(SENSORS_FEATURE_IN_MAX_ALARM); + if (IN_FEATURE(SENSORS_SUBFEATURE_IN_ALARM)) { + voltage->alarmNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_ALARM); + } else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN_ALARM)) { + voltage->alarmNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MIN_ALARM); + } else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX_ALARM)) { + voltage->alarmNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MAX_ALARM); } else { voltage->alarmNumber = -1; } /* beep if applicable */ - if (IN_FEATURE(SENSORS_FEATURE_IN_BEEP)) { - voltage->beepNumber = IN_FEATURE_NR(SENSORS_FEATURE_IN_ALARM); + if (IN_FEATURE(SENSORS_SUBFEATURE_IN_BEEP)) { + voltage->beepNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_ALARM); } else { voltage->beepNumber = -1; } } -#define TEMP_FEATURE(x) has_features[x - SENSORS_FEATURE_TEMP] -#define TEMP_FEATURE_NR(x) feature_nrs[x - SENSORS_FEATURE_TEMP] +#define TEMP_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_TEMP_INPUT] +#define TEMP_FEATURE_NR(x) feature_nrs[x - SENSORS_SUBFEATURE_TEMP_INPUT] static void fillChipTemperature (FeatureDescriptor *temperature, const sensors_chip_name *name, const sensors_feature *feature) { - const int size = SENSORS_FEATURE_TEMP_BEEP - SENSORS_FEATURE_TEMP + 1; - short has_features[SENSORS_FEATURE_TEMP_BEEP - SENSORS_FEATURE_TEMP + 1] = { 0, }; - int feature_nrs[SENSORS_FEATURE_TEMP_BEEP - SENSORS_FEATURE_TEMP + 1]; + const int size = SENSORS_SUBFEATURE_TEMP_BEEP - SENSORS_SUBFEATURE_TEMP_INPUT + 1; + short has_features[SENSORS_SUBFEATURE_TEMP_BEEP - SENSORS_SUBFEATURE_TEMP_INPUT + 1] = { 0, }; + int feature_nrs[SENSORS_SUBFEATURE_TEMP_BEEP - SENSORS_SUBFEATURE_TEMP_INPUT + 1]; int pos = 0; temperature->rrd = rrdF1; temperature->type = DataType_temperature; getAvailableFeatures (name, feature, has_features, - feature_nrs, size, SENSORS_FEATURE_TEMP); + feature_nrs, size, SENSORS_SUBFEATURE_TEMP_INPUT); - temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_FEATURE_TEMP); + temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_INPUT); - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN) && - TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX)) { + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MIN) && + TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX)) { temperature->format = fmtTemps_minmax_1; - temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_FEATURE_TEMP_MIN); - temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_FEATURE_TEMP_MAX); - } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX) && - TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_HYST)) { + temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MIN); + temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX); + } else if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX) && + TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_HYST)) { temperature->format = fmtTemps_1; - temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_FEATURE_TEMP_MAX); - temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_FEATURE_TEMP_MAX_HYST); + temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX); + temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX_HYST); } else { temperature->format = fmtTemp_only; } @@ -248,45 +248,45 @@ static void fillChipTemperature (FeatureDescriptor *temperature, temperature->dataNumbers[pos] = -1; /* alarm if applicable */ - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_ALARM)) { - temperature->alarmNumber = TEMP_FEATURE_NR(SENSORS_FEATURE_TEMP_ALARM); - } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_ALARM)) { - temperature->alarmNumber = TEMP_FEATURE_NR(SENSORS_FEATURE_TEMP_MAX_ALARM); + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_ALARM)) { + temperature->alarmNumber = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_ALARM); + } else if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_ALARM)) { + temperature->alarmNumber = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX_ALARM); } else { temperature->alarmNumber = -1; } /* beep if applicable */ - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_BEEP)) { - temperature->beepNumber = TEMP_FEATURE_NR(SENSORS_FEATURE_TEMP_BEEP); + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_BEEP)) { + temperature->beepNumber = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_BEEP); } else { temperature->beepNumber = -1; } } -#define FAN_FEATURE(x) has_features[x - SENSORS_FEATURE_FAN] -#define FAN_FEATURE_NR(x) feature_nrs[x - SENSORS_FEATURE_FAN] +#define FAN_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_FAN_INPUT] +#define FAN_FEATURE_NR(x) feature_nrs[x - SENSORS_SUBFEATURE_FAN_INPUT] static void fillChipFan (FeatureDescriptor *fan, const sensors_chip_name *name, const sensors_feature *feature) { - const int size = SENSORS_FEATURE_FAN_BEEP - SENSORS_FEATURE_FAN + 1; - short has_features[SENSORS_FEATURE_FAN_BEEP - SENSORS_FEATURE_FAN + 1] = { 0, }; - int feature_nrs[SENSORS_FEATURE_FAN_BEEP - SENSORS_FEATURE_FAN + 1]; + const int size = SENSORS_SUBFEATURE_FAN_BEEP - SENSORS_SUBFEATURE_FAN_INPUT + 1; + short has_features[SENSORS_SUBFEATURE_FAN_BEEP - SENSORS_SUBFEATURE_FAN_INPUT + 1] = { 0, }; + int feature_nrs[SENSORS_SUBFEATURE_FAN_BEEP - SENSORS_SUBFEATURE_FAN_INPUT + 1]; int pos = 0; fan->rrd = rrdF0; fan->type = DataType_rpm; getAvailableFeatures (name, feature, has_features, - feature_nrs, size, SENSORS_FEATURE_FAN); + feature_nrs, size, SENSORS_SUBFEATURE_FAN_INPUT); - fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_FEATURE_FAN); + fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_INPUT); - if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN)) { - fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_FEATURE_FAN_MIN); - if (FAN_FEATURE(SENSORS_FEATURE_FAN_DIV)) { + if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_MIN)) { + fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_MIN); + if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_DIV)) { fan->format = fmtFans_0; - fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_FEATURE_FAN_DIV); + fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_DIV); } else { fan->format = fmtFans_nodiv_0; } @@ -298,14 +298,14 @@ static void fillChipFan (FeatureDescriptor *fan, fan->dataNumbers[pos] = -1; /* alarm if applicable */ - if (FAN_FEATURE(SENSORS_FEATURE_FAN_ALARM)) { - fan->alarmNumber = FAN_FEATURE_NR(SENSORS_FEATURE_FAN_ALARM); + if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_ALARM)) { + fan->alarmNumber = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_ALARM); } else { fan->alarmNumber = -1; } /* beep if applicable */ - if (FAN_FEATURE(SENSORS_FEATURE_FAN_BEEP)) { - fan->beepNumber = FAN_FEATURE_NR(SENSORS_FEATURE_FAN_BEEP); + if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_BEEP)) { + fan->beepNumber = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_BEEP); } else { fan->beepNumber = -1; } @@ -373,19 +373,19 @@ FeatureDescriptor * generateChipFeatures (const sensors_chip_name *chip) nr = 0; while ((sensor = sensors_get_features(chip, &nr))) { switch (sensor->type) { - case SENSORS_FEATURE_TEMP: + case SENSORS_SUBFEATURE_TEMP_INPUT: fillChipTemperature(&features[count], chip, sensor); break; - case SENSORS_FEATURE_IN: + case SENSORS_SUBFEATURE_IN_INPUT: fillChipVoltage(&features[count], chip, sensor); break; - case SENSORS_FEATURE_FAN: + case SENSORS_SUBFEATURE_FAN_INPUT: fillChipFan(&features[count], chip, sensor); break; - case SENSORS_FEATURE_VID: + case SENSORS_SUBFEATURE_VID: fillChipVid(&features[count], chip, sensor); break; - case SENSORS_FEATURE_BEEP_ENABLE: + case SENSORS_SUBFEATURE_BEEP_ENABLE: fillChipBeepEnable(&features[count], chip, sensor); break; default: diff --git a/prog/sensors/chips.c b/prog/sensors/chips.c index 1e8cf6f3..b411820e 100644 --- a/prog/sensors/chips.c +++ b/prog/sensors/chips.c @@ -138,8 +138,8 @@ static void print_temp_limits(double limit1, double limit2, printf("ALARM "); } -#define TEMP_FEATURE(x) has_features[x - SENSORS_FEATURE_TEMP] -#define TEMP_FEATURE_VAL(x) feature_vals[x - SENSORS_FEATURE_TEMP] +#define TEMP_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_TEMP_INPUT] +#define TEMP_FEATURE_VAL(x) feature_vals[x - SENSORS_SUBFEATURE_TEMP_INPUT] static void print_chip_temp(const sensors_chip_name *name, const sensors_feature *feature, int label_size) @@ -148,9 +148,9 @@ static void print_chip_temp(const sensors_chip_name *name, const char *s1, *s2; int alarm, crit_displayed = 0; char *label; - const int size = SENSORS_FEATURE_TEMP_TYPE - SENSORS_FEATURE_TEMP + 1; - short has_features[SENSORS_FEATURE_TEMP_TYPE - SENSORS_FEATURE_TEMP + 1] = { 0, }; - double feature_vals[SENSORS_FEATURE_TEMP_TYPE - SENSORS_FEATURE_TEMP + 1] = { 0.0, }; + const int size = SENSORS_SUBFEATURE_TEMP_TYPE - SENSORS_SUBFEATURE_TEMP_INPUT + 1; + short has_features[SENSORS_SUBFEATURE_TEMP_TYPE - SENSORS_SUBFEATURE_TEMP_INPUT + 1] = { 0, }; + double feature_vals[SENSORS_SUBFEATURE_TEMP_TYPE - SENSORS_SUBFEATURE_TEMP_INPUT + 1] = { 0.0, }; if (!(label = sensors_get_label(name, feature))) { printf("ERROR: Can't get temperature label!\n"); @@ -159,38 +159,38 @@ static void print_chip_temp(const sensors_chip_name *name, sensors_get_available_features(name, feature, has_features, feature_vals, size, - SENSORS_FEATURE_TEMP); - val = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP); + SENSORS_SUBFEATURE_TEMP_INPUT); + val = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_INPUT); - alarm = TEMP_FEATURE(SENSORS_FEATURE_TEMP_ALARM) && - TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_ALARM); - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX)) { - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_ALARM) && - TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX_ALARM)) + alarm = TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_ALARM) && + TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_ALARM); + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX)) { + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_ALARM) && + TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX_ALARM)) alarm |= 1; - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN)) { - limit1 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MIN); + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MIN)) { + limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MIN); s1 = "low"; - limit2 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX); + limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX); s2 = "high"; - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN_ALARM) && - TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MIN_ALARM)) + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MIN_ALARM) && + TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MIN_ALARM)) alarm |= 1; } else { - limit1 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX); + limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX); s1 = "high"; - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_HYST)) { - limit2 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX_HYST); + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_HYST)) { + limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX_HYST); s2 = "hyst"; - } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) { - limit2 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT); + } else if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT)) { + limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT); s2 = "crit"; - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) && - TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM)) + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM) && + TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM)) alarm |= 1; crit_displayed = 1; } else { @@ -198,20 +198,20 @@ static void print_chip_temp(const sensors_chip_name *name, s2 = NULL; } } - } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) { - limit1 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT); + } else if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT)) { + limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT); s1 = "crit"; - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_HYST)) { - limit2 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST); + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_HYST)) { + limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_HYST); s2 = "hyst"; } else { limit2 = 0; s2 = NULL; } - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) && - TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM)) + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM) && + TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM)) alarm |= 1; crit_displayed = 1; } else { @@ -222,8 +222,8 @@ static void print_chip_temp(const sensors_chip_name *name, print_label(label, label_size); free(label); - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_FAULT) && - TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_FAULT)) { + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_FAULT) && + TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_FAULT)) { printf(" FAULT "); } else { if (fahrenheit) @@ -232,28 +232,28 @@ static void print_chip_temp(const sensors_chip_name *name, } print_temp_limits(limit1, limit2, s1, s2, alarm); - if (!crit_displayed && TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) { - limit1 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT); + if (!crit_displayed && TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT)) { + limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT); s1 = "crit"; - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_HYST)) { - limit2 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST); + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_HYST)) { + limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_HYST); s2 = "hyst"; } else { limit2 = 0; s2 = NULL; } - alarm = TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) && - TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM); + alarm = TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM) && + TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM); printf("\n%*s", label_size + 10, ""); print_temp_limits(limit1, limit2, s1, s2, alarm); } /* print out temperature sensor info */ - if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_TYPE)) { - int sens = (int)TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_TYPE); + if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_TYPE)) { + int sens = (int)TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_TYPE); /* older kernels / drivers sometimes report a beta value for thermistors */ @@ -271,15 +271,15 @@ static void print_chip_temp(const sensors_chip_name *name, printf("\n"); } -#define IN_FEATURE(x) has_features[x - SENSORS_FEATURE_IN] -#define IN_FEATURE_VAL(x) feature_vals[x - SENSORS_FEATURE_IN] +#define IN_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_IN_INPUT] +#define IN_FEATURE_VAL(x) feature_vals[x - SENSORS_SUBFEATURE_IN_INPUT] static void print_chip_in(const sensors_chip_name *name, const sensors_feature *feature, int label_size) { - const int size = SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN + 1; - short has_features[SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN + 1] = { 0, }; - double feature_vals[SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN + 1] = { 0.0, }; + const int size = SENSORS_SUBFEATURE_IN_MAX_ALARM - SENSORS_SUBFEATURE_IN_INPUT + 1; + short has_features[SENSORS_SUBFEATURE_IN_MAX_ALARM - SENSORS_SUBFEATURE_IN_INPUT + 1] = { 0, }; + double feature_vals[SENSORS_SUBFEATURE_IN_MAX_ALARM - SENSORS_SUBFEATURE_IN_INPUT + 1] = { 0.0, }; double val, alarm_max, alarm_min; char *label; @@ -289,29 +289,30 @@ static void print_chip_in(const sensors_chip_name *name, } sensors_get_available_features(name, feature, has_features, - feature_vals, size, SENSORS_FEATURE_IN); - val = IN_FEATURE_VAL(SENSORS_FEATURE_IN); + feature_vals, size, + SENSORS_SUBFEATURE_IN_INPUT); + val = IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_INPUT); print_label(label, label_size); free(label); printf("%+6.2f V", val); - if (IN_FEATURE(SENSORS_FEATURE_IN_MIN) && - IN_FEATURE(SENSORS_FEATURE_IN_MAX)) + if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN) && + IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX)) printf(" (min = %+6.2f V, max = %+6.2f V)", - IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN), - IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX)); - else if (IN_FEATURE(SENSORS_FEATURE_IN_MIN)) + IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MIN), + IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MAX)); + else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN)) printf(" (min = %+6.2f V)", - IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN)); - else if (IN_FEATURE(SENSORS_FEATURE_IN_MAX)) + IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MIN)); + else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX)) printf(" (max = %+6.2f V)", - IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX)); + IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MAX)); - if (IN_FEATURE(SENSORS_FEATURE_IN_MAX_ALARM) || - IN_FEATURE(SENSORS_FEATURE_IN_MIN_ALARM)) { - alarm_max = IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX_ALARM); - alarm_min = IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN_ALARM); + if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX_ALARM) || + IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN_ALARM)) { + alarm_max = IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MAX_ALARM); + alarm_min = IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MIN_ALARM); if (alarm_min || alarm_max) { printf(" ALARM ("); @@ -323,24 +324,24 @@ static void print_chip_in(const sensors_chip_name *name, printf(")"); } - } else if (IN_FEATURE(SENSORS_FEATURE_IN_ALARM)) { + } else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_ALARM)) { printf(" %s", - IN_FEATURE_VAL(SENSORS_FEATURE_IN_ALARM) ? "ALARM" : ""); + IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_ALARM) ? "ALARM" : ""); } printf("\n"); } -#define FAN_FEATURE(x) has_features[x - SENSORS_FEATURE_FAN] -#define FAN_FEATURE_VAL(x) feature_vals[x - SENSORS_FEATURE_FAN] +#define FAN_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_FAN_INPUT] +#define FAN_FEATURE_VAL(x) feature_vals[x - SENSORS_SUBFEATURE_FAN_INPUT] static void print_chip_fan(const sensors_chip_name *name, const sensors_feature *feature, int label_size) { char *label; - const int size = SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN + 1; - short has_features[SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN + 1] = { 0, }; - double feature_vals[SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN + 1] = { 0.0, }; + const int size = SENSORS_SUBFEATURE_FAN_DIV - SENSORS_SUBFEATURE_FAN_INPUT + 1; + short has_features[SENSORS_SUBFEATURE_FAN_DIV - SENSORS_SUBFEATURE_FAN_INPUT + 1] = { 0, }; + double feature_vals[SENSORS_SUBFEATURE_FAN_DIV - SENSORS_SUBFEATURE_FAN_INPUT + 1] = { 0.0, }; double val; if (!(label = sensors_get_label(name, feature))) { @@ -352,29 +353,30 @@ static void print_chip_fan(const sensors_chip_name *name, free(label); sensors_get_available_features(name, feature, has_features, - feature_vals, size, SENSORS_FEATURE_FAN); - val = FAN_FEATURE_VAL(SENSORS_FEATURE_FAN); + feature_vals, size, + SENSORS_SUBFEATURE_FAN_INPUT); + val = FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_INPUT); - if (FAN_FEATURE(SENSORS_FEATURE_FAN_FAULT) && - FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_FAULT)) + if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_FAULT) && + FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_FAULT)) printf(" FAULT"); else printf("%4.0f RPM", val); - if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN) && - FAN_FEATURE(SENSORS_FEATURE_FAN_DIV)) + if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_MIN) && + FAN_FEATURE(SENSORS_SUBFEATURE_FAN_DIV)) printf(" (min = %4.0f RPM, div = %1.0f)", - FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_MIN), - FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_DIV)); - else if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN)) + FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_MIN), + FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_DIV)); + else if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_MIN)) printf(" (min = %4.0f RPM)", - FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_MIN)); - else if (FAN_FEATURE(SENSORS_FEATURE_FAN_DIV)) + FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_MIN)); + else if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_DIV)) printf(" (div = %1.0f)", - FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_DIV)); + FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_DIV)); - if (FAN_FEATURE(SENSORS_FEATURE_FAN_ALARM) && - FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_ALARM)) { + if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_ALARM) && + FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_ALARM)) { printf(" ALARM"); } @@ -433,19 +435,19 @@ void print_chip(const sensors_chip_name *name) i = 0; while ((feature = sensors_get_features(name, &i))) { switch (feature->type) { - case SENSORS_FEATURE_TEMP: + case SENSORS_SUBFEATURE_TEMP_INPUT: print_chip_temp(name, feature, label_size); break; - case SENSORS_FEATURE_IN: + case SENSORS_SUBFEATURE_IN_INPUT: print_chip_in(name, feature, label_size); break; - case SENSORS_FEATURE_FAN: + case SENSORS_SUBFEATURE_FAN_INPUT: print_chip_fan(name, feature, label_size); break; - case SENSORS_FEATURE_VID: + case SENSORS_SUBFEATURE_VID: print_chip_vid(name, feature, label_size); break; - case SENSORS_FEATURE_BEEP_ENABLE: + case SENSORS_SUBFEATURE_BEEP_ENABLE: print_chip_beep_enable(name, feature, label_size); break; default: