Changeset 4846
- Timestamp:
- 09/23/07 14:30:28 (1 year ago)
- Files:
-
- lm-sensors/branches/lm-sensors-3.0.0/lib/access.c (modified) (1 diff)
- lm-sensors/branches/lm-sensors-3.0.0/lib/libsensors.3 (modified) (2 diffs)
- lm-sensors/branches/lm-sensors-3.0.0/lib/sensors.h (modified) (1 diff)
- lm-sensors/branches/lm-sensors-3.0.0/prog/sensord/chips.c (modified) (11 diffs)
- lm-sensors/branches/lm-sensors-3.0.0/prog/sensors/chips.c (modified) (16 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
lm-sensors/branches/lm-sensors-3.0.0/lib/access.c
r4845 r4846 392 392 return subfeature; 393 393 return NULL; /* end of subfeature list */ 394 } 395 396 const sensors_subfeature * 397 sensors_get_subfeature(const sensors_chip_name *name, 398 const sensors_feature *feature, 399 sensors_subfeature_type type) 400 { 401 const sensors_chip_features *chip; 402 int i; 403 404 if (!(chip = sensors_lookup_chip(name))) 405 return NULL; /* No such chip */ 406 407 for (i = feature->first_subfeature; i < chip->subfeature_count && 408 chip->subfeature[i].mapping == feature->number; i++) { 409 if (chip->subfeature[i].type == type) 410 return &chip->subfeature[i]; 411 } 412 return NULL; /* No such subfeature */ 394 413 } 395 414 lm-sensors/branches/lm-sensors-3.0.0/lib/libsensors.3
r4838 r4846 47 47 .B const sensors_feature *sensors_get_features(const sensors_chip_name *name, int *nr);\fP 48 48 .B const sensors_subfeature *sensors_get_all_subfeatures(const sensors_chip_name *name, const sensors_feature *feature, int *nr);\fP 49 .B const sensors_subfeature *sensors_get_subfeature(const sensors_chip_name *name, const sensors_feature *feature, sensors_subfeature_type type);\fP 49 50 .B const char *libsensors_version; 50 51 .fi … … 141 142 data structures. 142 143 144 \fBconst sensors_subfeature *sensors_get_subfeature(const sensors_chip_name *name, const sensors_feature *feature, sensors_subfeature_type type);\fP 145 .br 146 This returns the subfeature of the given type for a given main feature, 147 if it exists, NULL otherwise. 148 Do not try to change the returned structure; you will corrupt internal 149 data structures. 150 143 151 \fBconst char *libsensors_version;\fP 144 152 .br lm-sensors/branches/lm-sensors-3.0.0/lib/sensors.h
r4838 r4846 222 222 const sensors_feature *feature, int *nr); 223 223 224 /* This returns the subfeature of the given type for a given main feature, 225 if it exists, NULL otherwise. 226 Do not try to change the returned structure; you will corrupt internal 227 data structures. */ 228 const sensors_subfeature * 229 sensors_get_subfeature(const sensors_chip_name *name, 230 const sensors_feature *feature, 231 sensors_subfeature_type type); 232 224 233 #ifdef __cplusplus 225 234 } lm-sensors/branches/lm-sensors-3.0.0/prog/sensord/chips.c
r4838 r4846 141 141 } 142 142 143 static void getAvailableFeatures (const sensors_chip_name *name,144 const sensors_feature *feature,145 short *has_features,146 int *feature_nrs, int size,147 int first_val)148 {149 const sensors_subfeature *iter;150 int i = 0;151 152 while ((iter = sensors_get_all_subfeatures(name, feature, &i))) {153 int index0;154 155 index0 = iter->type - first_val;156 if (index0 < 0 || index0 >= size)157 /* New feature in libsensors? Ignore. */158 continue;159 160 has_features[index0] = 1;161 feature_nrs[index0] = iter->number;162 }163 }164 165 #define IN_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_IN_INPUT]166 #define IN_FEATURE_NR(x) feature_nrs[x - SENSORS_SUBFEATURE_IN_INPUT]167 143 static void fillChipVoltage (FeatureDescriptor *voltage, 168 144 const sensors_chip_name *name, 169 145 const sensors_feature *feature) 170 146 { 171 const int size = SENSORS_SUBFEATURE_IN_BEEP - SENSORS_SUBFEATURE_IN_INPUT + 1; 172 short has_features[SENSORS_SUBFEATURE_IN_BEEP - SENSORS_SUBFEATURE_IN_INPUT + 1] = { 0, }; 173 int feature_nrs[SENSORS_SUBFEATURE_IN_BEEP - SENSORS_SUBFEATURE_IN_INPUT + 1]; 147 const sensors_subfeature *sf, *sfmin, *sfmax; 174 148 int pos = 0; 175 149 … … 177 151 voltage->type = DataType_voltage; 178 152 179 getAvailableFeatures (name, feature, has_features,180 feature_nrs, size, SENSORS_SUBFEATURE_IN_INPUT);181 182 voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_INPUT); 183 184 if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN) &&185 IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX)) {153 sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_INPUT); 154 if (sf) 155 voltage->dataNumbers[pos++] = sf->number; 156 157 sfmin = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_MIN); 158 sfmax = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_MAX); 159 if (sfmin && sfmax) { 186 160 voltage->format = fmtVolts_2; 187 voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MIN);188 voltage->dataNumbers[pos++] = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MAX);161 voltage->dataNumbers[pos++] = sfmin->number; 162 voltage->dataNumbers[pos++] = sfmax->number; 189 163 } else { 190 164 voltage->format = fmtVolt_2; … … 195 169 196 170 /* alarm if applicable */ 197 if (IN_FEATURE(SENSORS_SUBFEATURE_IN_ALARM)) { 198 voltage->alarmNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_ALARM); 199 } else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN_ALARM)) { 200 voltage->alarmNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MIN_ALARM); 201 } else if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX_ALARM)) { 202 voltage->alarmNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_MAX_ALARM); 171 if ((sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_ALARM)) || 172 (sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_MIN_ALARM)) || 173 (sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_MAX_ALARM))) { 174 voltage->alarmNumber = sf->number; 203 175 } else { 204 176 voltage->alarmNumber = -1; 205 177 } 206 178 /* beep if applicable */ 207 if ( IN_FEATURE(SENSORS_SUBFEATURE_IN_BEEP)) {208 voltage->beepNumber = IN_FEATURE_NR(SENSORS_SUBFEATURE_IN_ALARM);179 if ((sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_IN_BEEP))) { 180 voltage->beepNumber = sf->number; 209 181 } else { 210 182 voltage->beepNumber = -1; … … 212 184 } 213 185 214 #define TEMP_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_TEMP_INPUT]215 #define TEMP_FEATURE_NR(x) feature_nrs[x - SENSORS_SUBFEATURE_TEMP_INPUT]216 186 static void fillChipTemperature (FeatureDescriptor *temperature, 217 187 const sensors_chip_name *name, 218 188 const sensors_feature *feature) 219 189 { 220 const int size = SENSORS_SUBFEATURE_TEMP_BEEP - SENSORS_SUBFEATURE_TEMP_INPUT + 1; 221 short has_features[SENSORS_SUBFEATURE_TEMP_BEEP - SENSORS_SUBFEATURE_TEMP_INPUT + 1] = { 0, }; 222 int feature_nrs[SENSORS_SUBFEATURE_TEMP_BEEP - SENSORS_SUBFEATURE_TEMP_INPUT + 1]; 190 const sensors_subfeature *sf, *sfmin, *sfmax, *sfhyst; 223 191 int pos = 0; 224 192 … … 226 194 temperature->type = DataType_temperature; 227 195 228 getAvailableFeatures (name, feature, has_features, 229 feature_nrs, size, SENSORS_SUBFEATURE_TEMP_INPUT); 230 231 temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_INPUT); 232 233 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MIN) && 234 TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX)) { 196 sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_INPUT); 197 if (sf) 198 temperature->dataNumbers[pos++] = sf->number; 199 200 sfmin = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_MIN); 201 sfmax = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_MAX); 202 sfhyst = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_MAX_HYST); 203 if (sfmin && sfmax) { 235 204 temperature->format = fmtTemps_minmax_1; 236 temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MIN); 237 temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX); 238 } else if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX) && 239 TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_HYST)) { 205 temperature->dataNumbers[pos++] = sfmin->number; 206 temperature->dataNumbers[pos++] = sfmax->number; 207 } else if (sfmax && sfhyst) { 240 208 temperature->format = fmtTemps_1; 241 temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX);242 temperature->dataNumbers[pos++] = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX_HYST);209 temperature->dataNumbers[pos++] = sfmax->number; 210 temperature->dataNumbers[pos++] = sfhyst->number; 243 211 } else { 244 212 temperature->format = fmtTemp_only; … … 249 217 250 218 /* alarm if applicable */ 251 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_ALARM)) { 252 temperature->alarmNumber = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_ALARM); 253 } else if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_ALARM)) { 254 temperature->alarmNumber = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_MAX_ALARM); 219 if ((sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_ALARM)) || 220 (sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_MAX_ALARM))) { 221 temperature->alarmNumber = sf->number; 255 222 } else { 256 223 temperature->alarmNumber = -1; 257 224 } 258 225 /* beep if applicable */ 259 if ( TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_BEEP)) {260 temperature->beepNumber = TEMP_FEATURE_NR(SENSORS_SUBFEATURE_TEMP_BEEP);226 if ((sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_TEMP_BEEP))) { 227 temperature->beepNumber = sf->number; 261 228 } else { 262 229 temperature->beepNumber = -1; … … 264 231 } 265 232 266 #define FAN_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_FAN_INPUT]267 #define FAN_FEATURE_NR(x) feature_nrs[x - SENSORS_SUBFEATURE_FAN_INPUT]268 233 static void fillChipFan (FeatureDescriptor *fan, 269 234 const sensors_chip_name *name, 270 235 const sensors_feature *feature) 271 236 { 272 const int size = SENSORS_SUBFEATURE_FAN_BEEP - SENSORS_SUBFEATURE_FAN_INPUT + 1; 273 short has_features[SENSORS_SUBFEATURE_FAN_BEEP - SENSORS_SUBFEATURE_FAN_INPUT + 1] = { 0, }; 274 int feature_nrs[SENSORS_SUBFEATURE_FAN_BEEP - SENSORS_SUBFEATURE_FAN_INPUT + 1]; 237 const sensors_subfeature *sf, *sfmin, *sfdiv; 275 238 int pos = 0; 276 239 … … 278 241 fan->type = DataType_rpm; 279 242 280 getAvailableFeatures (name, feature, has_features, 281 feature_nrs, size, SENSORS_SUBFEATURE_FAN_INPUT); 282 283 fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_INPUT); 284 285 if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_MIN)) { 286 fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_MIN); 287 if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_DIV)) { 243 sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_FAN_INPUT); 244 if (sf) 245 fan->dataNumbers[pos++] = sf->number; 246 247 sfmin = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_FAN_MIN); 248 if (sfmin) { 249 fan->dataNumbers[pos++] = sfmin->number; 250 sfdiv = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_FAN_DIV); 251 if (sfdiv) { 288 252 fan->format = fmtFans_0; 289 fan->dataNumbers[pos++] = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_DIV);253 fan->dataNumbers[pos++] = sfdiv->number; 290 254 } else { 291 255 fan->format = fmtFans_nodiv_0; … … 299 263 300 264 /* alarm if applicable */ 301 if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_ALARM)) { 302 fan->alarmNumber = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_ALARM); 265 sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_FAN_ALARM); 266 if (sf) { 267 fan->alarmNumber = sf->number; 303 268 } else { 304 269 fan->alarmNumber = -1; 305 270 } 306 271 /* beep if applicable */ 307 if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_BEEP)) { 308 fan->beepNumber = FAN_FEATURE_NR(SENSORS_SUBFEATURE_FAN_BEEP); 272 sf = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_FAN_BEEP); 273 if (sf) { 274 fan->beepNumber = sf->number; 309 275 } else { 310 276 fan->beepNumber = -1; … … 316 282 const sensors_feature *feature) 317 283 { 318 int i = 0;319 284 const sensors_subfeature *sub; 320 285 321 sub = sensors_get_ all_subfeatures(name, feature, &i);286 sub = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_VID); 322 287 if (!sub) 323 288 return; … … 336 301 const sensors_feature *feature) 337 302 { 338 int i = 0;339 303 const sensors_subfeature *sub; 340 304 341 sub = sensors_get_ all_subfeatures(name, feature, &i);305 sub = sensors_get_subfeature(name, feature, SENSORS_SUBFEATURE_BEEP_ENABLE); 342 306 if (!sub) 343 307 return; lm-sensors/branches/lm-sensors-3.0.0/prog/sensors/chips.c
r4838 r4846 71 71 } 72 72 73 static void sensors_get_available_features(const sensors_chip_name *name, 74 const sensors_feature *feature, 75 short *has_features, 76 double *feature_vals, int size, 77 int first_val) 78 { 79 const sensors_subfeature *iter; 80 int i = 0; 81 82 while ((iter = sensors_get_all_subfeatures(name, feature, &i))) { 83 int indx, err; 84 85 indx = iter->type - first_val; 86 if (indx < 0 || indx >= size) 87 /* New feature in libsensors? Ignore. */ 88 continue; 89 90 err = sensors_get_value(name, iter->number, &feature_vals[indx]); 91 if (err) { 92 printf("ERROR: Can't get %s data: %s\n", iter->name, 93 sensors_strerror(err)); 94 continue; 95 } 96 97 has_features[indx] = 1; 98 } 73 static double get_value(const sensors_chip_name *name, int subfeat_nr) 74 { 75 double val; 76 int err; 77 78 err = sensors_get_value(name, subfeat_nr, &val); 79 if (err) { 80 printf("ERROR: Can't get value of subfeature %d: %s\n", 81 subfeat_nr, sensors_strerror(err)); 82 val = 0; 83 } 84 return val; 99 85 } 100 86 … … 139 125 } 140 126 141 #define TEMP_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_TEMP_INPUT]142 #define TEMP_FEATURE_VAL(x) feature_vals[x - SENSORS_SUBFEATURE_TEMP_INPUT]143 127 static void print_chip_temp(const sensors_chip_name *name, 144 128 const sensors_feature *feature, 145 129 int label_size) 146 130 { 131 const sensors_subfeature *sf, *sfmin, *sfmax, *sfcrit, *sfhyst; 147 132 double val, limit1, limit2; 148 133 const char *s1, *s2; 149 134 int alarm, crit_displayed = 0; 150 135 char *label; 151 const int size = SENSORS_SUBFEATURE_TEMP_TYPE - SENSORS_SUBFEATURE_TEMP_INPUT + 1;152 short has_features[SENSORS_SUBFEATURE_TEMP_TYPE - SENSORS_SUBFEATURE_TEMP_INPUT + 1] = { 0, };153 double feature_vals[SENSORS_SUBFEATURE_TEMP_TYPE - SENSORS_SUBFEATURE_TEMP_INPUT + 1] = { 0.0, };154 136 155 137 if (!(label = sensors_get_label(name, feature))) { … … 157 139 return; 158 140 } 159 160 sensors_get_available_features(name, feature, has_features, 161 feature_vals, size, 162 SENSORS_SUBFEATURE_TEMP_INPUT); 163 val = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_INPUT); 164 165 alarm = TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_ALARM) && 166 TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_ALARM); 167 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX)) { 168 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_ALARM) && 169 TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX_ALARM)) 141 print_label(label, label_size); 142 free(label); 143 144 sf = sensors_get_subfeature(name, feature, 145 SENSORS_SUBFEATURE_TEMP_INPUT); 146 val = sf ? get_value(name, sf->number) : 0; 147 148 sf = sensors_get_subfeature(name, feature, 149 SENSORS_SUBFEATURE_TEMP_ALARM); 150 alarm = sf && get_value(name, sf->number); 151 152 sfmin = sensors_get_subfeature(name, feature, 153 SENSORS_SUBFEATURE_TEMP_MIN); 154 sfmax = sensors_get_subfeature(name, feature, 155 SENSORS_SUBFEATURE_TEMP_MAX); 156 sfcrit = sensors_get_subfeature(name, feature, 157 SENSORS_SUBFEATURE_TEMP_CRIT); 158 if (sfmax) { 159 sf = sensors_get_subfeature(name, feature, 160 SENSORS_SUBFEATURE_TEMP_MAX_ALARM); 161 if (sf && get_value(name, sf->number)) 170 162 alarm |= 1; 171 163 172 if ( TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MIN)) {173 limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MIN);164 if (sfmin) { 165 limit1 = get_value(name, sfmin->number); 174 166 s1 = "low"; 175 limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX);167 limit2 = get_value(name, sfmax->number); 176 168 s2 = "high"; 177 169 178 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MIN_ALARM) && 179 TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MIN_ALARM)) 170 sf = sensors_get_subfeature(name, feature, 171 SENSORS_SUBFEATURE_TEMP_MIN_ALARM); 172 if (sf && get_value(name, sf->number)) 180 173 alarm |= 1; 181 174 } else { 182 limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX);175 limit1 = get_value(name, sfmax->number); 183 176 s1 = "high"; 184 177 185 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_MAX_HYST)) { 186 limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_MAX_HYST); 178 sfhyst = sensors_get_subfeature(name, feature, 179 SENSORS_SUBFEATURE_TEMP_MAX_HYST); 180 if (sfhyst) { 181 limit2 = get_value(name, sfhyst->number); 187 182 s2 = "hyst"; 188 } else if ( TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT)) {189 limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT);183 } else if (sfcrit) { 184 limit2 = get_value(name, sfcrit->number); 190 185 s2 = "crit"; 191 186 192 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM) && 193 TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM)) 187 sf = sensors_get_subfeature(name, feature, 188 SENSORS_SUBFEATURE_TEMP_CRIT_ALARM); 189 if (sf && get_value(name, sf->number)) 194 190 alarm |= 1; 195 191 crit_displayed = 1; … … 199 195 } 200 196 } 201 } else if ( TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT)) {202 limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT);197 } else if (sfcrit) { 198 limit1 = get_value(name, sfcrit->number); 203 199 s1 = "crit"; 204 200 205 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_HYST)) { 206 limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_HYST); 201 sfhyst = sensors_get_subfeature(name, feature, 202 SENSORS_SUBFEATURE_TEMP_CRIT_HYST); 203 if (sfhyst) { 204 limit2 = get_value(name, sfhyst->number); 207 205 s2 = "hyst"; 208 206 } else { … … 211 209 } 212 210 213 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM) && 214 TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM)) 211 sf = sensors_get_subfeature(name, feature, 212 SENSORS_SUBFEATURE_TEMP_CRIT_ALARM); 213 if (sf && get_value(name, sf->number)) 215 214 alarm |= 1; 216 215 crit_displayed = 1; … … 220 219 } 221 220 222 print_label(label, label_size); 223 free(label); 224 225 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_FAULT) && 226 TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_FAULT)) { 221 222 sf = sensors_get_subfeature(name, feature, 223 SENSORS_SUBFEATURE_TEMP_FAULT); 224 if (sf && get_value(name, sf->number)) { 227 225 printf(" FAULT "); 228 226 } else { … … 233 231 print_temp_limits(limit1, limit2, s1, s2, alarm); 234 232 235 if (!crit_displayed && TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT)) {236 limit1 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT);233 if (!crit_displayed && sfcrit) { 234 limit1 = get_value(name, sfcrit->number); 237 235 s1 = "crit"; 238 236 239 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_HYST)) { 240 limit2 = TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_HYST); 237 sfhyst = sensors_get_subfeature(name, feature, 238 SENSORS_SUBFEATURE_TEMP_CRIT_HYST); 239 if (sfhyst) { 240 limit2 = get_value(name, sfhyst->number); 241 241 s2 = "hyst"; 242 242 } else { … … 245 245 } 246 246 247 alarm = TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM) && 248 TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_CRIT_ALARM); 247 sf = sensors_get_subfeature(name, feature, 248 SENSORS_SUBFEATURE_TEMP_CRIT_ALARM); 249 if (sf && get_value(name, sf->number)) 250 alarm |= 1; 249 251 250 252 printf("\n%*s", label_size + 10, ""); … … 253 255 254 256 /* print out temperature sensor info */ 255 if (TEMP_FEATURE(SENSORS_SUBFEATURE_TEMP_TYPE)) { 256 int sens = (int)TEMP_FEATURE_VAL(SENSORS_SUBFEATURE_TEMP_TYPE); 257 sf = sensors_get_subfeature(name, feature, 258 SENSORS_SUBFEATURE_TEMP_TYPE); 259 if (sf) { 260 int sens = (int)get_value(name, sf->number); 257 261 258 262 /* older kernels / drivers sometimes report a beta value for … … 272 276 } 273 277 274 #define IN_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_IN_INPUT]275 #define IN_FEATURE_VAL(x) feature_vals[x - SENSORS_SUBFEATURE_IN_INPUT]276 278 static void print_chip_in(const sensors_chip_name *name, 277 279 const sensors_feature *feature, 278 280 int label_size) 279 281 { 280 const int size = SENSORS_SUBFEATURE_IN_MAX_ALARM - SENSORS_SUBFEATURE_IN_INPUT + 1; 281 short has_features[SENSORS_SUBFEATURE_IN_MAX_ALARM - SENSORS_SUBFEATURE_IN_INPUT + 1] = { 0, }; 282 double feature_vals[SENSORS_SUBFEATURE_IN_MAX_ALARM - SENSORS_SUBFEATURE_IN_INPUT + 1] = { 0.0, }; 282 const sensors_subfeature *sf, *sfmin, *sfmax; 283 283 double val, alarm_max, alarm_min; 284 284 char *label; … … 288 288 return; 289 289 } 290 291 sensors_get_available_features(name, feature, has_features,292 feature_vals, size,293 SENSORS_SUBFEATURE_IN_INPUT);294 val = IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_INPUT);295 296 290 print_label(label, label_size); 297 291 free(label); 292 293 sf = sensors_get_subfeature(name, feature, 294 SENSORS_SUBFEATURE_IN_INPUT); 295 val = sf ? get_value(name, sf->number) : 0; 298 296 printf("%+6.2f V", val); 299 297 300 if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN) && 301 IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX)) 298 sfmin = sensors_get_subfeature(name, feature, 299 SENSORS_SUBFEATURE_IN_MIN); 300 sfmax = sensors_get_subfeature(name, feature, 301 SENSORS_SUBFEATURE_IN_MAX); 302 if (sfmin && sfmax) 302 303 printf(" (min = %+6.2f V, max = %+6.2f V)", 303 IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MIN),304 IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MAX));305 else if ( IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN))304 get_value(name, sfmin->number), 305 get_value(name, sfmax->number)); 306 else if (sfmin) 306 307 printf(" (min = %+6.2f V)", 307 IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MIN));308 else if ( IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX))308 get_value(name, sfmin->number)); 309 else if (sfmax) 309 310 printf(" (max = %+6.2f V)", 310 IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MAX)); 311 312 if (IN_FEATURE(SENSORS_SUBFEATURE_IN_MAX_ALARM) || 313 IN_FEATURE(SENSORS_SUBFEATURE_IN_MIN_ALARM)) { 314 alarm_max = IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MAX_ALARM); 315 alarm_min = IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_MIN_ALARM); 311 get_value(name, sfmax->number)); 312 313 sf = sensors_get_subfeature(name, feature, 314 SENSORS_SUBFEATURE_IN_ALARM); 315 sfmin = sensors_get_subfeature(name, feature, 316 SENSORS_SUBFEATURE_IN_MIN_ALARM); 317 sfmax = sensors_get_subfeature(name, feature, 318 SENSORS_SUBFEATURE_IN_MAX_ALARM); 319 if (sfmin || sfmax) { 320 alarm_max = sfmax ? get_value(name, sfmax->number) : 0; 321 alarm_min = sfmin ? get_value(name, sfmin->number) : 0; 316 322 317 323 if (alarm_min || alarm_max) { … … 325 331 printf(")"); 326 332 } 327 } else if ( IN_FEATURE(SENSORS_SUBFEATURE_IN_ALARM)) {333 } else if (sf) { 328 334 printf(" %s", 329 IN_FEATURE_VAL(SENSORS_SUBFEATURE_IN_ALARM) ? "ALARM" : "");335 get_value(name, sf->number) ? "ALARM" : ""); 330 336 } 331 337 … … 333 339 } 334 340 335 #define FAN_FEATURE(x) has_features[x - SENSORS_SUBFEATURE_FAN_INPUT]336 #define FAN_FEATURE_VAL(x) feature_vals[x - SENSORS_SUBFEATURE_FAN_INPUT]337 341 static void print_chip_fan(const sensors_chip_name *name, 338 342 const sensors_feature *feature, 339 343 int label_size) 340 344 { 341 char *label; 342 const int size = SENSORS_SUBFEATURE_FAN_DIV - SENSORS_SUBFEATURE_FAN_INPUT + 1; 343 short has_features[SENSORS_SUBFEATURE_FAN_DIV - SENSORS_SUBFEATURE_FAN_INPUT + 1] = { 0, }; 344 double feature_vals[SENSORS_SUBFEATURE_FAN_DIV - SENSORS_SUBFEATURE_FAN_INPUT + 1] = { 0.0, }; 345 const sensors_subfeature *sf, *sfmin, *sfdiv; 346 char *label; 345 347 double val; 346 348 … … 349 351 return; 350 352 } 351 352 353 print_label(label, label_size); 353 354 free(label); 354 355 355 sensors_get_available_features(name, feature, has_features, 356 feature_vals, size, 357 SENSORS_SUBFEATURE_FAN_INPUT); 358 val = FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_INPUT); 359 360 if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_FAULT) && 361 FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_FAULT)) 356 sf = sensors_get_subfeature(name, feature, 357 SENSORS_SUBFEATURE_FAN_INPUT); 358 val = sf ? get_value(name, sf->number) : 0; 359 sf = sensors_get_subfeature(name, feature, 360 SENSORS_SUBFEATURE_FAN_FAULT); 361 if (sf && get_value(name, sf->number)) 362 362 printf(" FAULT"); 363 363 else 364 364 printf("%4.0f RPM", val); 365 365 366 if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_MIN) && 367 FAN_FEATURE(SENSORS_SUBFEATURE_FAN_DIV)) 366 sfmin = sensors_get_subfeature(name, feature, 367 SENSORS_SUBFEATURE_FAN_MIN); 368 sfdiv = sensors_get_subfeature(name, feature, 369 SENSORS_SUBFEATURE_FAN_DIV); 370 if (sfmin && sfdiv) 368 371 printf(" (min = %4.0f RPM, div = %1.0f)", 369 FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_MIN),370 FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_DIV));371 else if ( FAN_FEATURE(SENSORS_SUBFEATURE_FAN_MIN))372 get_value(name, sfmin->number), 373 get_value(name, sfdiv->number)); 374 else if (sfmin) 372 375 printf(" (min = %4.0f RPM)", 373 FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_MIN));374 else if ( FAN_FEATURE(SENSORS_SUBFEATURE_FAN_DIV))376 get_value(name, sfmin->number)); 377 else if (sfdiv) 375 378 printf(" (div = %1.0f)", 376 FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_DIV)); 377 378 if (FAN_FEATURE(SENSORS_SUBFEATURE_FAN_ALARM) && 379 FAN_FEATURE_VAL(SENSORS_SUBFEATURE_FAN_ALARM)) { 379 get_value(name, sfdiv->number)); 380 381 sf = sensors_get_subfeature(name, feature, 382 SENSORS_SUBFEATURE_FAN_ALARM); 383 if (sf && get_value(name, sf->number)) { 380 384 printf(" ALARM"); 381 385 } … … 391 395 const sensors_subfeature *subfeature; 392 396 double vid; 393 int i = 0; 394 395 subfeature = sensors_get_all_subfeatures(name, feature, &i);397 398 subfeature = sensors_get_subfeature(name, feature, 399 SENSORS_SUBFEATURE_VID); 396 400 if (!subfeature) 397 401 return; … … 412 416 const sensors_subfeature *subfeature; 413 417 double beep_enable; 414 int i = 0; 415 416 subfeature = sensors_get_all_subfeatures(name, feature, &i);418 419 subfeature = sensors_get_subfeature(name, feature, 420 SENSORS_SUBFEATURE_BEEP_ENABLE); 417 421 if (!subfeature) 418 422 return;
