mir/lm-sensors
2
0
Fork 0
mirror of https://github.com/lm-sensors/lm-sensors synced 2025-09-02 07:15:39 +00:00
Code Issues Releases Wiki Activity

New public library function: sensors_get_subfeature(). Applications can

Browse Source 
use it to retrieve a specific subfeature by type. While it is slighly
less efficient than looping over sensors_get_all_subfeatures(), it
often makes the application code much more elegant.


git-svn-id: http://lm-sensors.org/svn/lm-sensors/branches/lm-sensors-3.0.0@4846 7894878c-1315-0410-8ee3-d5d059ff63e0
This commit is contained in:
Jean Delvare
2007-09-23 12:30:28 +00:00
parent c08a168342
commit e01466d993
5 changed files with 210 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
lib/access.c
View File

@@ -393,6 +393,25 @@ sensors_get_all_subfeatures(const sensors_chip_name *name,
return NULL; /* end of subfeature list */ return NULL; /* end of subfeature list */
} }
const sensors_subfeature *
sensors_get_subfeature(const sensors_chip_name *name,
const sensors_feature *feature,
sensors_subfeature_type type)
{
const sensors_chip_features *chip;
int i;
if (!(chip = sensors_lookup_chip(name)))
return NULL; /* No such chip */
for (i = feature->first_subfeature; i < chip->subfeature_count &&
chip->subfeature[i].mapping == feature->number; i++) {
if (chip->subfeature[i].type == type)
return &chip->subfeature[i];
}
return NULL; /* No such subfeature */
}
/* Evaluate an expression */ /* Evaluate an expression */
int sensors_eval_expr(const sensors_chip_features *chip_features, int sensors_eval_expr(const sensors_chip_features *chip_features,
const sensors_expr *expr, const sensors_expr *expr,

8
lib/libsensors.3
View File

@@ -46,6 +46,7 @@ libsensors \- publicly accessible functions provided by the sensors library
\fB*match, int *nr);\fP \fB*match, int *nr);\fP
.B const sensors_feature *sensors_get_features(const sensors_chip_name *name, int *nr);\fP .B const sensors_feature *sensors_get_features(const sensors_chip_name *name, int *nr);\fP
.B const sensors_subfeature *sensors_get_all_subfeatures(const sensors_chip_name *name, const sensors_feature *feature, int *nr);\fP .B const sensors_subfeature *sensors_get_all_subfeatures(const sensors_chip_name *name, const sensors_feature *feature, int *nr);\fP
.B const sensors_subfeature *sensors_get_subfeature(const sensors_chip_name *name, const sensors_feature *feature, sensors_subfeature_type type);\fP
.B const char *libsensors_version; .B const char *libsensors_version;
.fi .fi
.SH DESCRIPTION .SH DESCRIPTION
@@ -140,6 +141,13 @@ more subfeatures are found NULL is returned.
Do not try to change the returned structure; you will corrupt internal Do not try to change the returned structure; you will corrupt internal
data structures. data structures.
\fBconst sensors_subfeature *sensors_get_subfeature(const sensors_chip_name *name, const sensors_feature *feature, sensors_subfeature_type type);\fP
.br
This returns the subfeature of the given type for a given main feature,
if it exists, NULL otherwise.
Do not try to change the returned structure; you will corrupt internal
data structures.
\fBconst char *libsensors_version;\fP \fBconst char *libsensors_version;\fP
.br .br
A string representing the version of libsensors. A string representing the version of libsensors.

9
lib/sensors.h
View File

@@ -221,6 +221,15 @@ const sensors_subfeature *
sensors_get_all_subfeatures(const sensors_chip_name *name, sensors_get_all_subfeatures(const sensors_chip_name *name,
const sensors_feature *feature, int *nr); const sensors_feature *feature, int *nr);
/* This returns the subfeature of the given type for a given main feature,
if it exists, NULL otherwise.
Do not try to change the returned structure; you will corrupt internal
data structures. */
const sensors_subfeature *
sensors_get_subfeature(const sensors_chip_name *name,
const sensors_feature *feature,
sensors_subfeature_type type);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */

138
prog/sensord/chips.c
View File

@@ -140,52 +140,26 @@ rrdF3
return buff; return buff;
} }
static void getAvailableFeatures (const sensors_chip_name *name,
const sensors_feature *feature,
short *has_features,
int *feature_nrs, int size,
int first_val)
{
const sensors_subfeature *iter;
int i = 0;
while ((iter = sensors_get_all_subfeatures(name, feature, &i))) {
int index0;
index0 = iter->type - first_val;
if (index0 < 0 || index0 >= size)
/* New feature in libsensors? Ignore. */
continue;
has_features[index0] = 1;
feature_nrs[index0] = iter->number;
}
}
#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, static void fillChipVoltage (FeatureDescriptor *voltage,
const sensors_chip_name *name, const sensors_chip_name *name,
const sensors_feature *feature) const sensors_feature *feature)
{ {
const int size = SENSORS_SUBFEATURE_IN_BEEP - SENSORS_SUBFEATURE_IN_INPUT + 1; const sensors_subfeature *sf, *sfmin, *sfmax;
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; int pos = 0;
voltage->rrd = rrdF2; voltage->rrd = rrdF2;
voltage->type = DataType_voltage; voltage->type = DataType_voltage;
getAvailableFeatures (name, feature, has_features, sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_INPUT);
feature_nrs, size, SENSORS_SUBFEATURE_IN_INPUT); if (sf)
voltage->dataNumbers[pos++] = sf->number;
voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_INPUT); sfmin = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_MIN);
sfmax = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_MAX);
if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN) && if (sfmin && sfmax) {
IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX)) {
voltage->format = fmtVolts_2; voltage->format = fmtVolts_2;
voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MIN); voltage->dataNumbers[pos++] = sfmin->number;
voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MAX); voltage->dataNumbers[pos++] = sfmax->number;
} else { } else {
voltage->format = fmtVolt_2; voltage->format = fmtVolt_2;
} }
@@ -194,52 +168,46 @@ static void fillChipVoltage (FeatureDescriptor *voltage,
voltage->dataNumbers[pos] = -1; voltage->dataNumbers[pos] = -1;
/* alarm if applicable */ /* alarm if applicable */
if (IN_FEATURE(SENSORS_SUBFEATURE_IN_ALARM)) { if ((sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_ALARM)) ||
voltage->alarmNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_ALARM); (sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_MIN_ALARM)) ||
} else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN_ALARM)) { (sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_MAX_ALARM))) {
voltage->alarmNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MIN_ALARM); voltage->alarmNumber = sf->number;
} else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX_ALARM)) {
voltage->alarmNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MAX_ALARM);
} else { } else {
voltage->alarmNumber = -1; voltage->alarmNumber = -1;
} }
/* beep if applicable */ /* beep if applicable */
if (IN_FEATURE(SENSORS_SUBFEATURE_IN_BEEP)) { if ((sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_BEEP))) {
voltage->beepNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_ALARM); voltage->beepNumber = sf->number;
} else { } else {
voltage->beepNumber = -1; voltage->beepNumber = -1;
} }
} }
#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, static void fillChipTemperature (FeatureDescriptor *temperature,
const sensors_chip_name *name, const sensors_chip_name *name,
const sensors_feature *feature) const sensors_feature *feature)
{ {
const int size = SENSORS_SUBFEATURE_TEMP_BEEP - SENSORS_SUBFEATURE_TEMP_INPUT + 1; const sensors_subfeature *sf, *sfmin, *sfmax, *sfhyst;
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; int pos = 0;
temperature->rrd = rrdF1; temperature->rrd = rrdF1;
temperature->type = DataType_temperature; temperature->type = DataType_temperature;
getAvailableFeatures (name, feature, has_features, sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_INPUT);
feature_nrs, size, SENSORS_SUBFEATURE_TEMP_INPUT); if (sf)
temperature->dataNumbers[pos++] = sf->number;
temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_INPUT); sfmin = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_MIN);
sfmax = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_MAX);
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MIN) && sfhyst = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_MAX_HYST);
TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX)) { if (sfmin && sfmax) {
temperature->format = fmtTemps_minmax_1; temperature->format = fmtTemps_minmax_1;
temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MIN); temperature->dataNumbers[pos++] = sfmin->number;
temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX); temperature->dataNumbers[pos++] = sfmax->number;
} else if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX) && } else if (sfmax && sfhyst) {
TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_HYST)) {
temperature->format = fmtTemps_1; temperature->format = fmtTemps_1;
temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX); temperature->dataNumbers[pos++] = sfmax->number;
temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX_HYST); temperature->dataNumbers[pos++] = sfhyst->number;
} else { } else {
temperature->format = fmtTemp_only; temperature->format = fmtTemp_only;
} }
@@ -248,45 +216,41 @@ static void fillChipTemperature (FeatureDescriptor *temperature,
temperature->dataNumbers[pos] = -1; temperature->dataNumbers[pos] = -1;
/* alarm if applicable */ /* alarm if applicable */
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_ALARM)) { if ((sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_ALARM)) ||
temperature->alarmNumber = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_ALARM); (sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_MAX_ALARM))) {
} else if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_ALARM)) { temperature->alarmNumber = sf->number;
temperature->alarmNumber = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX_ALARM);
} else { } else {
temperature->alarmNumber = -1; temperature->alarmNumber = -1;
} }
/* beep if applicable */ /* beep if applicable */
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_BEEP)) { if ((sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_BEEP))) {
temperature->beepNumber = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_BEEP); temperature->beepNumber = sf->number;
} else { } else {
temperature->beepNumber = -1; temperature->beepNumber = -1;
} }
} }
#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, static void fillChipFan (FeatureDescriptor *fan,
const sensors_chip_name *name, const sensors_chip_name *name,
const sensors_feature *feature) const sensors_feature *feature)
{ {
const int size = SENSORS_SUBFEATURE_FAN_BEEP - SENSORS_SUBFEATURE_FAN_INPUT + 1; const sensors_subfeature *sf, *sfmin, *sfdiv;
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; int pos = 0;
fan->rrd = rrdF0; fan->rrd = rrdF0;
fan->type = DataType_rpm; fan->type = DataType_rpm;
getAvailableFeatures (name, feature, has_features, sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_FAN_INPUT);
feature_nrs, size, SENSORS_SUBFEATURE_FAN_INPUT); if (sf)
fan->dataNumbers[pos++] = sf->number;
fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_INPUT); sfmin = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_FAN_MIN);
if (sfmin) {
if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_MIN)) { fan->dataNumbers[pos++] = sfmin->number;
fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_MIN); sfdiv = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_FAN_DIV);
if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_DIV)) { if (sfdiv) {
fan->format = fmtFans_0; fan->format = fmtFans_0;
fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_DIV); fan->dataNumbers[pos++] = sfdiv->number;
} else { } else {
fan->format = fmtFans_nodiv_0; fan->format = fmtFans_nodiv_0;
} }
@@ -298,14 +262,16 @@ static void fillChipFan (FeatureDescriptor *fan,
fan->dataNumbers[pos] = -1; fan->dataNumbers[pos] = -1;
/* alarm if applicable */ /* alarm if applicable */
if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_ALARM)) { sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_FAN_ALARM);
fan->alarmNumber = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_ALARM); if (sf) {
fan->alarmNumber = sf->number;
} else { } else {
fan->alarmNumber = -1; fan->alarmNumber = -1;
} }
/* beep if applicable */ /* beep if applicable */
if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_BEEP)) { sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_FAN_BEEP);
fan->beepNumber = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_BEEP); if (sf) {
fan->beepNumber = sf->number;
} else { } else {
fan->beepNumber = -1; fan->beepNumber = -1;
} }
@@ -315,10 +281,9 @@ static void fillChipVid (FeatureDescriptor *vid,
const sensors_chip_name *name, const sensors_chip_name *name,
const sensors_feature *feature) const sensors_feature *feature)
{ {
int i = 0;
const sensors_subfeature *sub; const sensors_subfeature *sub;
sub = sensors_get_all_subfeatures(name, feature, &i); sub = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_VID);
if (!sub) if (!sub)
return; return;
@@ -335,10 +300,9 @@ static void fillChipBeepEnable (FeatureDescriptor *beepen,
const sensors_chip_name *name, const sensors_chip_name *name,
const sensors_feature *feature) const sensors_feature *feature)
{ {
int i = 0;
const sensors_subfeature *sub; const sensors_subfeature *sub;
sub = sensors_get_all_subfeatures(name, feature, &i); sub = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_BEEP_ENABLE);
if (!sub) if (!sub)
return; return;

236
prog/sensors/chips.c
View File

@@ -70,32 +70,18 @@ static void print_label(const char *label, int space)
printf("%s:%*s", label, space - len, ""); printf("%s:%*s", label, space - len, "");
} }
static void sensors_get_available_features(const sensors_chip_name *name, static double get_value(const sensors_chip_name *name, int subfeat_nr)
const sensors_feature *feature,
short *has_features,
double *feature_vals, int size,
int first_val)
{ {
const sensors_subfeature *iter; double val;
int i = 0; int err;
while ((iter = sensors_get_all_subfeatures(name, feature, &i))) { err = sensors_get_value(name, subfeat_nr, &val);
int indx, err;
indx = iter->type - first_val;
if (indx < 0 || indx >= size)
/* New feature in libsensors? Ignore. */
continue;
err = sensors_get_value(name, iter->number, &feature_vals[indx]);
if (err) { if (err) {
printf("ERROR: Can't get %s data: %s\n", iter->name, printf("ERROR: Can't get value of subfeature %d: %s\n",
sensors_strerror(err)); subfeat_nr, sensors_strerror(err));
continue; val = 0;
}
has_features[indx] = 1;
} }
return val;
} }
static int sensors_get_label_size(const sensors_chip_name *name) static int sensors_get_label_size(const sensors_chip_name *name)
@@ -138,59 +124,69 @@ static void print_temp_limits(double limit1, double limit2,
printf("ALARM "); printf("ALARM ");
} }
#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, static void print_chip_temp(const sensors_chip_name *name,
const sensors_feature *feature, const sensors_feature *feature,
int label_size) int label_size)
{ {
const sensors_subfeature *sf, *sfmin, *sfmax, *sfcrit, *sfhyst;
double val, limit1, limit2; double val, limit1, limit2;
const char *s1, *s2; const char *s1, *s2;
int alarm, crit_displayed = 0; int alarm, crit_displayed = 0;
char *label; char *label;
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))) { if (!(label = sensors_get_label(name, feature))) {
printf("ERROR: Can't get temperature label!\n"); printf("ERROR: Can't get temperature label!\n");
return; return;
} }
print_label(label, label_size);
free(label);
sensors_get_available_features(name, feature, has_features, sf = sensors_get_subfeature(name, feature,
feature_vals, size,
SENSORS_SUBFEATURE_TEMP_INPUT); SENSORS_SUBFEATURE_TEMP_INPUT);
val = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_INPUT); val = sf ? get_value(name, sf->number) : 0;
alarm = TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_ALARM) && sf = sensors_get_subfeature(name, feature,
TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_ALARM); SENSORS_SUBFEATURE_TEMP_ALARM);
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX)) { alarm = sf && get_value(name, sf->number);
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_ALARM) &&
TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX_ALARM)) sfmin = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_MIN);
sfmax = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_MAX);
sfcrit = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_CRIT);
if (sfmax) {
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_MAX_ALARM);
if (sf && get_value(name, sf->number))
alarm |= 1; alarm |= 1;
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MIN)) { if (sfmin) {
limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MIN); limit1 = get_value(name, sfmin->number);
s1 = "low"; s1 = "low";
limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX); limit2 = get_value(name, sfmax->number);
s2 = "high"; s2 = "high";
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MIN_ALARM) && sf = sensors_get_subfeature(name, feature,
TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MIN_ALARM)) SENSORS_SUBFEATURE_TEMP_MIN_ALARM);
if (sf && get_value(name, sf->number))
alarm |= 1; alarm |= 1;
} else { } else {
limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX); limit1 = get_value(name, sfmax->number);
s1 = "high"; s1 = "high";
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_HYST)) { sfhyst = sensors_get_subfeature(name, feature,
limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX_HYST); SENSORS_SUBFEATURE_TEMP_MAX_HYST);
if (sfhyst) {
limit2 = get_value(name, sfhyst->number);
s2 = "hyst"; s2 = "hyst";
} else if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT)) { } else if (sfcrit) {
limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT); limit2 = get_value(name, sfcrit->number);
s2 = "crit"; s2 = "crit";
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM) && sf = sensors_get_subfeature(name, feature,
TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM)) SENSORS_SUBFEATURE_TEMP_CRIT_ALARM);
if (sf && get_value(name, sf->number))
alarm |= 1; alarm |= 1;
crit_displayed = 1; crit_displayed = 1;
} else { } else {
@@ -198,20 +194,23 @@ static void print_chip_temp(const sensors_chip_name *name,
s2 = NULL; s2 = NULL;
} }
} }
} else if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT)) { } else if (sfcrit) {
limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT); limit1 = get_value(name, sfcrit->number);
s1 = "crit"; s1 = "crit";
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_HYST)) { sfhyst = sensors_get_subfeature(name, feature,
limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_HYST); SENSORS_SUBFEATURE_TEMP_CRIT_HYST);
if (sfhyst) {
limit2 = get_value(name, sfhyst->number);
s2 = "hyst"; s2 = "hyst";
} else { } else {
limit2 = 0; limit2 = 0;
s2 = NULL; s2 = NULL;
} }
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM) && sf = sensors_get_subfeature(name, feature,
TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM)) SENSORS_SUBFEATURE_TEMP_CRIT_ALARM);
if (sf && get_value(name, sf->number))
alarm |= 1; alarm |= 1;
crit_displayed = 1; crit_displayed = 1;
} else { } else {
@@ -219,11 +218,10 @@ static void print_chip_temp(const sensors_chip_name *name,
s1 = s2 = NULL; s1 = s2 = NULL;
} }
print_label(label, label_size);
free(label);
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_FAULT) && sf = sensors_get_subfeature(name, feature,
TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_FAULT)) { SENSORS_SUBFEATURE_TEMP_FAULT);
if (sf && get_value(name, sf->number)) {
printf(" FAULT "); printf(" FAULT ");
} else { } else {
if (fahrenheit) if (fahrenheit)
@@ -232,28 +230,34 @@ static void print_chip_temp(const sensors_chip_name *name,
} }
print_temp_limits(limit1, limit2, s1, s2, alarm); print_temp_limits(limit1, limit2, s1, s2, alarm);
if (!crit_displayed && TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT)) { if (!crit_displayed && sfcrit) {
limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT); limit1 = get_value(name, sfcrit->number);
s1 = "crit"; s1 = "crit";
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_HYST)) { sfhyst = sensors_get_subfeature(name, feature,
limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_HYST); SENSORS_SUBFEATURE_TEMP_CRIT_HYST);
if (sfhyst) {
limit2 = get_value(name, sfhyst->number);
s2 = "hyst"; s2 = "hyst";
} else { } else {
limit2 = 0; limit2 = 0;
s2 = NULL; s2 = NULL;
} }
alarm = TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM) && sf = sensors_get_subfeature(name, feature,
TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM); SENSORS_SUBFEATURE_TEMP_CRIT_ALARM);
if (sf && get_value(name, sf->number))
alarm |= 1;
printf("\n%*s", label_size + 10, ""); printf("\n%*s", label_size + 10, "");
print_temp_limits(limit1, limit2, s1, s2, alarm); print_temp_limits(limit1, limit2, s1, s2, alarm);
} }
/* print out temperature sensor info */ /* print out temperature sensor info */
if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_TYPE)) { sf = sensors_get_subfeature(name, feature,
int sens = (int)TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_TYPE); SENSORS_SUBFEATURE_TEMP_TYPE);
if (sf) {
int sens = (int)get_value(name, sf->number);
/* older kernels / drivers sometimes report a beta value for /* older kernels / drivers sometimes report a beta value for
thermistors */ thermistors */
@@ -271,15 +275,11 @@ static void print_chip_temp(const sensors_chip_name *name,
printf("\n"); printf("\n");
} }
#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, static void print_chip_in(const sensors_chip_name *name,
const sensors_feature *feature, const sensors_feature *feature,
int label_size) int label_size)
{ {
const int size = SENSORS_SUBFEATURE_IN_MAX_ALARM - SENSORS_SUBFEATURE_IN_INPUT + 1; const sensors_subfeature *sf, *sfmin, *sfmax;
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; double val, alarm_max, alarm_min;
char *label; char *label;
@@ -287,32 +287,38 @@ static void print_chip_in(const sensors_chip_name *name,
printf("ERROR: Can't get in label!\n"); printf("ERROR: Can't get in label!\n");
return; return;
} }
sensors_get_available_features(name, feature, has_features,
feature_vals, size,
SENSORS_SUBFEATURE_IN_INPUT);
val = IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_INPUT);
print_label(label, label_size); print_label(label, label_size);
free(label); free(label);
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_IN_INPUT);
val = sf ? get_value(name, sf->number) : 0;
printf("%+6.2f V", val); printf("%+6.2f V", val);
if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN) && sfmin = sensors_get_subfeature(name, feature,
IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX)) SENSORS_SUBFEATURE_IN_MIN);
sfmax = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_IN_MAX);
if (sfmin && sfmax)
printf(" (min = %+6.2f V, max = %+6.2f V)", printf(" (min = %+6.2f V, max = %+6.2f V)",
IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MIN), get_value(name, sfmin->number),
IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MAX)); get_value(name, sfmax->number));
else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN)) else if (sfmin)
printf(" (min = %+6.2f V)", printf(" (min = %+6.2f V)",
IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MIN)); get_value(name, sfmin->number));
else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX)) else if (sfmax)
printf(" (max = %+6.2f V)", printf(" (max = %+6.2f V)",
IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MAX)); get_value(name, sfmax->number));
if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX_ALARM) || sf = sensors_get_subfeature(name, feature,
IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN_ALARM)) { SENSORS_SUBFEATURE_IN_ALARM);
alarm_max = IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MAX_ALARM); sfmin = sensors_get_subfeature(name, feature,
alarm_min = IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MIN_ALARM); SENSORS_SUBFEATURE_IN_MIN_ALARM);
sfmax = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_IN_MAX_ALARM);
if (sfmin || sfmax) {
alarm_max = sfmax ? get_value(name, sfmax->number) : 0;
alarm_min = sfmin ? get_value(name, sfmin->number) : 0;
if (alarm_min || alarm_max) { if (alarm_min || alarm_max) {
printf(" ALARM ("); printf(" ALARM (");
@@ -324,59 +330,57 @@ static void print_chip_in(const sensors_chip_name *name,
printf(")"); printf(")");
} }
} else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_ALARM)) { } else if (sf) {
printf(" %s", printf(" %s",
IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_ALARM) ? "ALARM" : ""); get_value(name, sf->number) ? "ALARM" : "");
} }
printf("\n"); printf("\n");
} }
#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, static void print_chip_fan(const sensors_chip_name *name,
const sensors_feature *feature, const sensors_feature *feature,
int label_size) int label_size)
{ {
const sensors_subfeature *sf, *sfmin, *sfdiv;
char *label; char *label;
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; double val;
if (!(label = sensors_get_label(name, feature))) { if (!(label = sensors_get_label(name, feature))) {
printf("ERROR: Can't get fan label!\n"); printf("ERROR: Can't get fan label!\n");
return; return;
} }
print_label(label, label_size); print_label(label, label_size);
free(label); free(label);
sensors_get_available_features(name, feature, has_features, sf = sensors_get_subfeature(name, feature,
feature_vals, size,
SENSORS_SUBFEATURE_FAN_INPUT); SENSORS_SUBFEATURE_FAN_INPUT);
val = FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_INPUT); val = sf ? get_value(name, sf->number) : 0;
sf = sensors_get_subfeature(name, feature,
if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_FAULT) && SENSORS_SUBFEATURE_FAN_FAULT);
FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_FAULT)) if (sf && get_value(name, sf->number))
printf(" FAULT"); printf(" FAULT");
else else
printf("%4.0f RPM", val); printf("%4.0f RPM", val);
if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_MIN) && sfmin = sensors_get_subfeature(name, feature,
FAN_FEATURE(SENSORS_SUBFEATURE_FAN_DIV)) SENSORS_SUBFEATURE_FAN_MIN);
sfdiv = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_DIV);
if (sfmin && sfdiv)
printf(" (min = %4.0f RPM, div = %1.0f)", printf(" (min = %4.0f RPM, div = %1.0f)",
FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_MIN), get_value(name, sfmin->number),
FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_DIV)); get_value(name, sfdiv->number));
else if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_MIN)) else if (sfmin)
printf(" (min = %4.0f RPM)", printf(" (min = %4.0f RPM)",
FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_MIN)); get_value(name, sfmin->number));
else if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_DIV)) else if (sfdiv)
printf(" (div = %1.0f)", printf(" (div = %1.0f)",
FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_DIV)); get_value(name, sfdiv->number));
if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_ALARM) && sf = sensors_get_subfeature(name, feature,
FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_ALARM)) { SENSORS_SUBFEATURE_FAN_ALARM);
if (sf && get_value(name, sf->number)) {
printf(" ALARM"); printf(" ALARM");
} }
@@ -390,9 +394,9 @@ static void print_chip_vid(const sensors_chip_name *name,
char *label; char *label;
const sensors_subfeature *subfeature; const sensors_subfeature *subfeature;
double vid; double vid;
int i = 0;
subfeature = sensors_get_all_subfeatures(name, feature, &i); subfeature = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_VID);
if (!subfeature) if (!subfeature)
return; return;
@@ -411,9 +415,9 @@ static void print_chip_beep_enable(const sensors_chip_name *name,
char *label; char *label;
const sensors_subfeature *subfeature; const sensors_subfeature *subfeature;
double beep_enable; double beep_enable;
int i = 0;
subfeature = sensors_get_all_subfeatures(name, feature, &i); subfeature = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_BEEP_ENABLE);
if (!subfeature) if (!subfeature)
return; return;