mirror of
https://github.com/lm-sensors/lm-sensors.git
synced 2026-11-19 19:40:49 +00:00
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
This commit is contained in:
1 parent
e13c11d353
commit
65f1d1f1cd
4 files changed
+234
-232
No files matched your search
+34
-34
@@ -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;
|
||||
|
||||
+53
-53
@@ -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,
|
||||
|
||||
+60
-60
@@ -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:
|
||||
|
||||
+87
-85
@@ -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:
|
||||
|
||||
Reference in new issue
Block a user