Changeset 5943

Show
Ignore:
Timestamp:
03/16/11 18:23:33 (14 months ago)
Author:
groeck
Message:

sensors: Added support for additional sensor attributes

Location:
lm-sensors/trunk
Files:
3 modified

Legend:

Unmodified
Added
Removed

  • lm-sensors/trunk/CHANGES

    r5942 r5943  
    1717           If an attribute value is 0, display the value with its base unit, 
    1818           not with the minumum supported unit 
     19           Added support for additional sensor attributes 
    1920  sensors-detect: Improve LM90 and W83L771 detection 
    2021                  Fix error seen if I2C bus numbers are not sequential 

  • lm-sensors/trunk/prog/sensors/chips.c

    r5942 r5943  
    3030#include "lib/sensors.h" 
    3131#include "lib/error.h" 
     32 
     33#define ARRAY_SIZE(arr) (int)(sizeof(arr) / sizeof((arr)[0])) 
    3234 
    3335void print_chip_raw(const sensors_chip_name *name) 
    … …  
    127129} 
    128130 
    129 static void print_temp_limits(double limit1, double limit2, 
    130                               const char *name1, const char *name2, int alarm) 
    131 { 
    132         if (fahrenheit) { 
    133                 limit1 = deg_ctof(limit1); 
    134                 limit2 = deg_ctof(limit2); 
    135         } 
    136  
    137         if (name2) { 
    138                 printf("(%-4s = %+5.1f%s, %-4s = %+5.1f%s)  ", 
    139                        name1, limit1, degstr, 
    140                        name2, limit2, degstr); 
    141         } else if (name1) { 
    142                 printf("(%-4s = %+5.1f%s)                  ", 
    143                        name1, limit1, degstr); 
    144         } else { 
    145                 printf("                                  "); 
    146         } 
    147  
    148         if (alarm) 
    149                 printf("ALARM  "); 
    150 } 
     131static void print_alarms(struct sensor_subfeature_data *alarms, int alarm_count, 
     132                         int leading_spaces) 
     133{ 
     134        int i, printed; 
     135 
     136        printf("%*s", leading_spaces + 7, "ALARM"); 
     137        if (alarm_count > 1 || alarms[0].name) { 
     138                printf(" ("); 
     139                for (i = printed = 0; i < alarm_count; i++) { 
     140                        if (alarms[i].name) { 
     141                                if (printed) 
     142                                        printf(", "); 
     143                                printf("%s", alarms[i].name); 
     144                                printed = 1; 
     145                        } 
     146                } 
     147                printf(")"); 
     148        } 
     149} 
     150 
     151static void print_limits(struct sensor_subfeature_data *limits, 
     152                         int limit_count, 
     153                         struct sensor_subfeature_data *alarms, 
     154                         int alarm_count, int label_size, 
     155                         const char *fmt) 
     156{ 
     157        int i; 
     158        int alarms_printed = 0; 
     159 
     160        for (i = 0; i < limit_count; i++) { 
     161                if (!(i & 1)) { 
     162                        if (i) 
     163                                printf("\n%*s", label_size + 10, ""); 
     164                        printf("("); 
     165                } else { 
     166                        printf(", "); 
     167                } 
     168                printf(fmt, limits[i].name, limits[i].value, 
     169                             limits[i].unit); 
     170                if ((i & 1) || i == limit_count - 1) { 
     171                        printf(")"); 
     172                        if (alarm_count && !alarms_printed) { 
     173                                print_alarms(alarms, alarm_count, 
     174                                             (i & 1) ? 0 : 16); 
     175                                alarms_printed = 1; 
     176                        } 
     177                } 
     178        } 
     179        if (alarm_count && !alarms_printed) 
     180                print_alarms(alarms, alarm_count, 32); 
     181} 
     182 
     183/* 
     184 * Get sensor limit information. 
     185 * *num_limits and *num_alarms must be initialized by the caller. 
     186 */ 
     187static void get_sensor_limit_data(const sensors_chip_name *name, 
     188                                  const sensors_feature *feature, 
     189                                  const struct sensor_subfeature_list *sfl, 
     190                                  struct sensor_subfeature_data *limits, 
     191                                  int max_limits, 
     192                                  int *num_limits, 
     193                                  struct sensor_subfeature_data *alarms, 
     194                                  int max_alarms, 
     195                                  int *num_alarms) 
     196{ 
     197        const sensors_subfeature *sf; 
     198 
     199        for (; sfl->subfeature >= 0; sfl++) { 
     200                sf = sensors_get_subfeature(name, feature, sfl->subfeature); 
     201                if (sf) { 
     202                        if (sfl->alarm) { 
     203                                /* 
     204                                 * Only queue alarm subfeatures if the alarm 
     205                                 * is active, and don't store the alarm value 
     206                                 * (it is implied to be active if queued). 
     207                                 */ 
     208                                if (get_value(name, sf)) { 
     209                                        if (*num_alarms >= max_alarms) { 
     210                                                fprintf(stderr, 
     211                                                        "Not enough %s buffers (%d)\n", 
     212                                                        "alarm", max_alarms); 
     213                                        } else { 
     214                                                alarms[*num_alarms].name = sfl->name; 
     215                                                (*num_alarms)++; 
     216                                        } 
     217                                } 
     218                        } else { 
     219                                /* 
     220                                 * Always queue limit subfeatures with their value. 
     221                                 */ 
     222                                if (*num_limits >= max_limits) { 
     223                                        fprintf(stderr, 
     224                                                "Not enough %s buffers (%d)\n", 
     225                                                "limit", max_limits); 
     226                                } else { 
     227                                        limits[*num_limits].value = get_value(name, sf); 
     228                                        limits[*num_limits].name = sfl->name; 
     229                                        (*num_limits)++; 
     230                                } 
     231                        } 
     232                        if (sfl->exists) { 
     233                                get_sensor_limit_data(name, feature, sfl->exists, 
     234                                                      limits, max_limits, num_limits, 
     235                                                      alarms, max_alarms, num_alarms); 
     236                        } 
     237                } 
     238        } 
     239} 
     240 
     241static const struct sensor_subfeature_list temp_max_sensors[] = { 
     242        { SENSORS_SUBFEATURE_TEMP_MAX_HYST, NULL, 0, "hyst" }, 
     243        { -1, NULL, 0, NULL } 
     244}; 
     245 
     246static const struct sensor_subfeature_list temp_crit_sensors[] = { 
     247        { SENSORS_SUBFEATURE_TEMP_CRIT_HYST, NULL, 0, "crit hyst" }, 
     248        { -1, NULL, 0, NULL } 
     249}; 
     250 
     251static const struct sensor_subfeature_list temp_emergency_sensors[] = { 
     252        { SENSORS_SUBFEATURE_TEMP_EMERGENCY_HYST, NULL, 0, 
     253            "emerg hyst" }, 
     254        { -1, NULL, 0, NULL } 
     255}; 
     256 
     257static const struct sensor_subfeature_list temp_sensors[] = { 
     258        { SENSORS_SUBFEATURE_TEMP_ALARM, NULL, 1, NULL }, 
     259        { SENSORS_SUBFEATURE_TEMP_LCRIT_ALARM, NULL, 1, "LCRIT" }, 
     260        { SENSORS_SUBFEATURE_TEMP_MIN_ALARM, NULL, 1, "LOW" }, 
     261        { SENSORS_SUBFEATURE_TEMP_MAX_ALARM, NULL, 1, "HIGH" }, 
     262        { SENSORS_SUBFEATURE_TEMP_CRIT_ALARM, NULL, 1, "CRIT" }, 
     263        { SENSORS_SUBFEATURE_TEMP_EMERGENCY_ALARM, NULL, 1, "EMERGENCY" }, 
     264        { SENSORS_SUBFEATURE_TEMP_MIN, NULL, 0, "low" }, 
     265        { SENSORS_SUBFEATURE_TEMP_MAX, temp_max_sensors, 0, "high" }, 
     266        { SENSORS_SUBFEATURE_TEMP_LCRIT, NULL, 0, "crit low" }, 
     267        { SENSORS_SUBFEATURE_TEMP_CRIT, temp_crit_sensors, 0, "crit" }, 
     268        { SENSORS_SUBFEATURE_TEMP_EMERGENCY, temp_emergency_sensors, 0, 
     269            "emerg" }, 
     270        { -1, NULL, 0, NULL } 
     271}; 
    151272 
    152273static void print_chip_temp(const sensors_chip_name *name, 
    … …  
    154275                            int label_size) 
    155276{ 
    156         const sensors_subfeature *sf, *sfmin, *sfmax, *sfcrit, *sfhyst; 
    157         double val, limit1, limit2; 
    158         const char *s1, *s2; 
    159         int alarm, crit_displayed = 0; 
    160         char *label; 
     277        struct sensor_subfeature_data sensors[8]; 
     278        struct sensor_subfeature_data alarms[5]; 
     279        int sensor_count, alarm_count; 
     280        const sensors_subfeature *sf; 
     281        double val; 
     282        char *label; 
     283        int i; 
    161284 
    162285        if (!(label = sensors_get_label(name, feature))) { 
    … …  
    167290        print_label(label, label_size); 
    168291        free(label); 
    169  
    170         sf = sensors_get_subfeature(name, feature, 
    171                                     SENSORS_SUBFEATURE_TEMP_ALARM); 
    172         alarm = sf && get_value(name, sf); 
    173  
    174         sfmin = sensors_get_subfeature(name, feature, 
    175                                        SENSORS_SUBFEATURE_TEMP_MIN); 
    176         sfmax = sensors_get_subfeature(name, feature, 
    177                                        SENSORS_SUBFEATURE_TEMP_MAX); 
    178         sfcrit = sensors_get_subfeature(name, feature, 
    179                                         SENSORS_SUBFEATURE_TEMP_CRIT); 
    180         if (sfmax) { 
    181                 sf = sensors_get_subfeature(name, feature, 
    182                                         SENSORS_SUBFEATURE_TEMP_MAX_ALARM); 
    183                 if (sf && get_value(name, sf)) 
    184                         alarm |= 1; 
    185  
    186                 if (sfmin) { 
    187                         limit1 = get_value(name, sfmin); 
    188                         s1 = "low"; 
    189                         limit2 = get_value(name, sfmax); 
    190                         s2 = "high"; 
    191  
    192                         sf = sensors_get_subfeature(name, feature, 
    193                                         SENSORS_SUBFEATURE_TEMP_MIN_ALARM); 
    194                         if (sf && get_value(name, sf)) 
    195                                 alarm |= 1; 
    196                 } else { 
    197                         limit1 = get_value(name, sfmax); 
    198                         s1 = "high"; 
    199  
    200                         sfhyst = sensors_get_subfeature(name, feature, 
    201                                         SENSORS_SUBFEATURE_TEMP_MAX_HYST); 
    202                         if (sfhyst) { 
    203                                 limit2 = get_value(name, sfhyst); 
    204                                 s2 = "hyst"; 
    205                         } else if (sfcrit) { 
    206                                 limit2 = get_value(name, sfcrit); 
    207                                 s2 = "crit"; 
    208  
    209                                 sf = sensors_get_subfeature(name, feature, 
    210                                         SENSORS_SUBFEATURE_TEMP_CRIT_ALARM); 
    211                                 if (sf && get_value(name, sf)) 
    212                                         alarm |= 1; 
    213                                 crit_displayed = 1; 
    214                         } else { 
    215                                 limit2 = 0; 
    216                                 s2 = NULL; 
    217                         } 
    218                 } 
    219         } else if (sfcrit) { 
    220                 limit1 = get_value(name, sfcrit); 
    221                 s1 = "crit"; 
    222  
    223                 sfhyst = sensors_get_subfeature(name, feature, 
    224                                         SENSORS_SUBFEATURE_TEMP_CRIT_HYST); 
    225                 if (sfhyst) { 
    226                         limit2 = get_value(name, sfhyst); 
    227                         s2 = "hyst"; 
    228                 } else { 
    229                         limit2 = 0; 
    230                         s2 = NULL; 
    231                 } 
    232  
    233                 sf = sensors_get_subfeature(name, feature, 
    234                                         SENSORS_SUBFEATURE_TEMP_CRIT_ALARM); 
    235                 if (sf && get_value(name, sf)) 
    236                         alarm |= 1; 
    237                 crit_displayed = 1; 
    238         } else { 
    239                 limit1 = limit2 = 0; 
    240                 s1 = s2 = NULL; 
    241         } 
    242  
    243292 
    244293        sf = sensors_get_subfeature(name, feature, 
    … …  
    257306                        printf("     N/A  "); 
    258307        } 
    259         print_temp_limits(limit1, limit2, s1, s2, alarm); 
    260  
    261         if (!crit_displayed && sfcrit) { 
    262                 limit1 = get_value(name, sfcrit); 
    263                 s1 = "crit"; 
    264  
    265                 sfhyst = sensors_get_subfeature(name, feature, 
    266                                         SENSORS_SUBFEATURE_TEMP_CRIT_HYST); 
    267                 if (sfhyst) { 
    268                         limit2 = get_value(name, sfhyst); 
    269                         s2 = "hyst"; 
    270                 } else { 
    271                         limit2 = 0; 
    272                         s2 = NULL; 
    273                 } 
    274  
    275                 sf = sensors_get_subfeature(name, feature, 
    276                                         SENSORS_SUBFEATURE_TEMP_CRIT_ALARM); 
    277                 alarm = sf && get_value(name, sf); 
    278  
    279                 printf("\n%*s", label_size + 10, ""); 
    280                 print_temp_limits(limit1, limit2, s1, s2, alarm); 
    281         } 
     308 
     309        sensor_count = alarm_count = 0; 
     310        get_sensor_limit_data(name, feature, temp_sensors, 
     311                              sensors, ARRAY_SIZE(sensors), &sensor_count, 
     312                              alarms, ARRAY_SIZE(alarms), &alarm_count); 
     313 
     314        for (i = 0; i < sensor_count; i++) { 
     315                if (fahrenheit) 
     316                        sensors[i].value = deg_ctof(sensors[i].value); 
     317                sensors[i].unit = degstr; 
     318        } 
     319 
     320        print_limits(sensors, sensor_count, alarms, alarm_count, label_size, 
     321                     "%-4s = %+5.1f%s"); 
    282322 
    283323        /* print out temperature sensor info */ 
    … …  
    292332                        sens = 4; 
    293333 
    294                 printf("sensor = %s", sens == 0 ? "disabled" : 
     334                printf("  sensor = %s", sens == 0 ? "disabled" : 
    295335                       sens == 1 ? "diode" : 
    296336                       sens == 2 ? "transistor" : 
    … …  
    303343} 
    304344 
     345static const struct sensor_subfeature_list voltage_sensors[] = { 
     346        { SENSORS_SUBFEATURE_IN_ALARM, NULL, 1, NULL }, 
     347        { SENSORS_SUBFEATURE_IN_LCRIT_ALARM, NULL, 1, "LCRIT" }, 
     348        { SENSORS_SUBFEATURE_IN_MIN_ALARM, NULL, 1, "MIN" }, 
     349        { SENSORS_SUBFEATURE_IN_MAX_ALARM, NULL, 1, "MAX" }, 
     350        { SENSORS_SUBFEATURE_IN_CRIT_ALARM, NULL, 1, "CRIT" }, 
     351        { SENSORS_SUBFEATURE_IN_LCRIT, NULL, 0, "crit min" }, 
     352        { SENSORS_SUBFEATURE_IN_MIN, NULL, 0, "min" }, 
     353        { SENSORS_SUBFEATURE_IN_MAX, NULL, 0, "max" }, 
     354        { SENSORS_SUBFEATURE_IN_CRIT, NULL, 0, "crit max" }, 
     355        { -1, NULL, 0, NULL } 
     356}; 
     357 
    305358static void print_chip_in(const sensors_chip_name *name, 
    306359                          const sensors_feature *feature, 
    307360                          int label_size) 
    308361{ 
    309         const sensors_subfeature *sf, *sfmin, *sfmax; 
    310         double val, alarm_max, alarm_min; 
    311         char *label; 
     362        const sensors_subfeature *sf; 
     363        char *label; 
     364        struct sensor_subfeature_data sensors[4]; 
     365        struct sensor_subfeature_data alarms[4]; 
     366        int sensor_count, alarm_count; 
     367        double val; 
    312368 
    313369        if (!(label = sensors_get_label(name, feature))) { 
    … …  
    322378                                    SENSORS_SUBFEATURE_IN_INPUT); 
    323379        if (sf && get_input_value(name, sf, &val) == 0) 
    324                 printf("%+6.2f V", val); 
     380                printf("%+6.2f V  ", val); 
    325381        else 
    326                 printf("     N/A"); 
    327  
    328         sfmin = sensors_get_subfeature(name, feature, 
    329                                        SENSORS_SUBFEATURE_IN_MIN); 
    330         sfmax = sensors_get_subfeature(name, feature, 
    331                                        SENSORS_SUBFEATURE_IN_MAX); 
    332         if (sfmin && sfmax) 
    333                 printf("  (min = %+6.2f V, max = %+6.2f V)", 
    334                        get_value(name, sfmin), 
    335                        get_value(name, sfmax)); 
    336         else if (sfmin) 
    337                 printf("  (min = %+6.2f V)", 
    338                        get_value(name, sfmin)); 
    339         else if (sfmax) 
    340                 printf("  (max = %+6.2f V)", 
    341                        get_value(name, sfmax)); 
    342  
    343         sf = sensors_get_subfeature(name, feature, 
    344                                     SENSORS_SUBFEATURE_IN_ALARM); 
    345         sfmin = sensors_get_subfeature(name, feature, 
    346                                        SENSORS_SUBFEATURE_IN_MIN_ALARM); 
    347         sfmax = sensors_get_subfeature(name, feature, 
    348                                        SENSORS_SUBFEATURE_IN_MAX_ALARM); 
    349         if (sfmin || sfmax) { 
    350                 alarm_max = sfmax ? get_value(name, sfmax) : 0; 
    351                 alarm_min = sfmin ? get_value(name, sfmin) : 0; 
    352  
    353                 if (alarm_min || alarm_max) { 
    354                         printf(" ALARM ("); 
    355  
    356                         if (alarm_min) 
    357                                 printf("MIN"); 
    358                         if (alarm_max) 
    359                                 printf("%sMAX", (alarm_min) ? ", " : ""); 
    360  
    361                         printf(")"); 
    362                 } 
    363         } else if (sf) { 
    364                 printf("   %s", 
    365                        get_value(name, sf) ? "ALARM" : ""); 
    366         } 
     382                printf("     N/A  "); 
     383 
     384        sensor_count = alarm_count = 0; 
     385        get_sensor_limit_data(name, feature, voltage_sensors, 
     386                              sensors, ARRAY_SIZE(sensors), &sensor_count, 
     387                              alarms, ARRAY_SIZE(alarms), &alarm_count); 
     388 
     389        print_limits(sensors, sensor_count, alarms, alarm_count, label_size, 
     390                     "%s = %+6.2f V"); 
    367391 
    368392        printf("\n"); 
    … …  
    456480} 
    457481 
     482static const struct sensor_subfeature_list power_common_sensors[] = { 
     483        { SENSORS_SUBFEATURE_POWER_ALARM, NULL, 1, NULL }, 
     484        { SENSORS_SUBFEATURE_POWER_MAX_ALARM, NULL, 1, "MAX" }, 
     485        { SENSORS_SUBFEATURE_POWER_CRIT_ALARM, NULL, 1, "CRIT" }, 
     486        { SENSORS_SUBFEATURE_POWER_CAP_ALARM, NULL, 1, "CAP" }, 
     487        { SENSORS_SUBFEATURE_POWER_MAX, NULL, 0, "max" }, 
     488        { SENSORS_SUBFEATURE_POWER_CRIT, NULL, 0, "crit" }, 
     489        { SENSORS_SUBFEATURE_POWER_CAP, NULL, 0, "cap" }, 
     490        { -1, NULL, 0, NULL } 
     491}; 
     492 
     493static const struct sensor_subfeature_list power_inst_sensors[] = { 
     494        { SENSORS_SUBFEATURE_POWER_INPUT_LOWEST, NULL, 0, "lowest" }, 
     495        { SENSORS_SUBFEATURE_POWER_INPUT_HIGHEST, NULL, 0, "highest" }, 
     496        { -1, NULL, 0, NULL } 
     497}; 
     498 
     499static const struct sensor_subfeature_list power_avg_sensors[] = { 
     500        { SENSORS_SUBFEATURE_POWER_AVERAGE_LOWEST, NULL, 0, "lowest" }, 
     501        { SENSORS_SUBFEATURE_POWER_AVERAGE_HIGHEST, NULL, 0, "highest" }, 
     502        { SENSORS_SUBFEATURE_POWER_AVERAGE_INTERVAL, NULL, 0, 
     503                "interval" }, 
     504        { -1, NULL, 0, NULL } 
     505}; 
     506 
    458507static void print_chip_power(const sensors_chip_name *name, 
    459508                             const sensors_feature *feature, 
    … …  
    461510{ 
    462511        double val; 
    463         int need_space = 0; 
    464         const sensors_subfeature *sf, *sfmin, *sfmax, *sfint; 
     512        const sensors_subfeature *sf; 
     513        struct sensor_subfeature_data sensors[6]; 
     514        struct sensor_subfeature_data alarms[3]; 
     515        int sensor_count, alarm_count; 
    465516        char *label; 
    466517        const char *unit; 
     518        int i; 
    467519 
    468520        if (!(label = sensors_get_label(name, feature))) { 
    … …  
    473525        print_label(label, label_size); 
    474526        free(label); 
     527 
     528        sensor_count = alarm_count = 0; 
    475529 
    476530        /* Power sensors come in 2 flavors: instantaneous and averaged. 
    … …  
    479533        sf = sensors_get_subfeature(name, feature, 
    480534                                    SENSORS_SUBFEATURE_POWER_INPUT); 
    481         if (sf) { 
    482                 sfmin = sensors_get_subfeature(name, feature, 
    483                                                SENSORS_SUBFEATURE_POWER_INPUT_HIGHEST); 
    484                 sfmax = sensors_get_subfeature(name, feature, 
    485                                                SENSORS_SUBFEATURE_POWER_INPUT_LOWEST); 
    486                 sfint = NULL; 
    487         } else { 
     535        get_sensor_limit_data(name, feature, 
     536                              sf ? power_inst_sensors : power_avg_sensors, 
     537                              sensors, ARRAY_SIZE(sensors), &sensor_count, 
     538                              alarms, ARRAY_SIZE(alarms), &alarm_count); 
     539        /* Add sensors common to both flavors. */ 
     540        get_sensor_limit_data(name, feature, 
     541                              power_common_sensors, 
     542                              sensors, ARRAY_SIZE(sensors), &sensor_count, 
     543                              alarms, ARRAY_SIZE(alarms), &alarm_count); 
     544        if (!sf) 
    488545                sf = sensors_get_subfeature(name, feature, 
    489546                                            SENSORS_SUBFEATURE_POWER_AVERAGE); 
    490                 sfmin = sensors_get_subfeature(name, feature, 
    491                                                SENSORS_SUBFEATURE_POWER_AVERAGE_HIGHEST); 
    492                 sfmax = sensors_get_subfeature(name, feature, 
    493                                                SENSORS_SUBFEATURE_POWER_AVERAGE_LOWEST); 
    494                 sfint = sensors_get_subfeature(name, feature, 
    495                                                SENSORS_SUBFEATURE_POWER_AVERAGE_INTERVAL); 
    496         } 
    497547 
    498548        if (sf && get_input_value(name, sf, &val) == 0) { 
    499549                scale_value(&val, &unit); 
    500                 printf("%6.2f %sW", val, unit); 
     550                printf("%6.2f %sW  ", val, unit); 
    501551        } else 
    502                 printf("     N/A"); 
    503  
    504         if (sfmin || sfmax || sfint) { 
    505                 printf("  ("); 
    506  
    507                 if (sfmin) { 
    508                         val = get_value(name, sfmin); 
    509                         scale_value(&val, &unit); 
    510                         printf("min = %6.2f %sW", val, unit); 
    511                         need_space = 1; 
    512                 } 
    513  
    514                 if (sfmax) { 
    515                         val = get_value(name, sfmax); 
    516                         scale_value(&val, &unit); 
    517                         printf("%smax = %6.2f %sW", (need_space ? ", " : ""), 
    518                                val, unit); 
    519                         need_space = 1; 
    520                 } 
    521  
    522                 if (sfint) { 
    523                         printf("%sinterval = %6.2f s", (need_space ? ", " : ""), 
    524                                get_value(name, sfint)); 
    525                         need_space = 1; 
    526                 } 
    527                 printf(")"); 
    528         } 
     552                printf("     N/A  "); 
     553 
     554        for (i = 0; i < sensor_count; i++) 
     555                scale_value(&sensors[i].value, &sensors[i].unit); 
     556 
     557        print_limits(sensors, sensor_count, alarms, alarm_count, 
     558                     label_size, "%s = %6.2f %sW"); 
    529559 
    530560        printf("\n"); 
    … …  
    601631} 
    602632 
     633static const struct sensor_subfeature_list current_sensors[] = { 
     634        { SENSORS_SUBFEATURE_CURR_ALARM, NULL, 1, NULL }, 
     635        { SENSORS_SUBFEATURE_CURR_LCRIT_ALARM, NULL, 1, "LCRIT" }, 
     636        { SENSORS_SUBFEATURE_CURR_MIN_ALARM, NULL, 1, "MIN" }, 
     637        { SENSORS_SUBFEATURE_CURR_MAX_ALARM, NULL, 1, "MAX" }, 
     638        { SENSORS_SUBFEATURE_CURR_CRIT_ALARM, NULL, 1, "CRIT" }, 
     639        { SENSORS_SUBFEATURE_CURR_LCRIT, NULL, 0, "crit min" }, 
     640        { SENSORS_SUBFEATURE_CURR_MIN, NULL, 0, "min" }, 
     641        { SENSORS_SUBFEATURE_CURR_MAX, NULL, 0, "max" }, 
     642        { SENSORS_SUBFEATURE_CURR_CRIT, NULL, 0, "crit max" }, 
     643        { -1, NULL, 0, NULL } 
     644}; 
     645 
    603646static void print_chip_curr(const sensors_chip_name *name, 
    604647                            const sensors_feature *feature, 
    605648                            int label_size) 
    606649{ 
    607         const sensors_subfeature *sf, *sfmin, *sfmax; 
    608         double alarm_max, alarm_min, val; 
    609         char *label; 
     650        const sensors_subfeature *sf; 
     651        double val; 
     652        char *label; 
     653        struct sensor_subfeature_data sensors[4]; 
     654        struct sensor_subfeature_data alarms[4]; 
     655        int sensor_count, alarm_count; 
    610656 
    611657        if (!(label = sensors_get_label(name, feature))) { 
    … …  
    620666                                    SENSORS_SUBFEATURE_CURR_INPUT); 
    621667        if (sf && get_input_value(name, sf, &val) == 0) 
    622                 printf("%+6.2f A", val); 
     668                printf("%+6.2f A  ", val); 
    623669        else 
    624                 printf("     N/A"); 
    625  
    626         sfmin = sensors_get_subfeature(name, feature, 
    627                                        SENSORS_SUBFEATURE_CURR_MIN); 
    628         sfmax = sensors_get_subfeature(name, feature, 
    629                                        SENSORS_SUBFEATURE_CURR_MAX); 
    630         if (sfmin && sfmax) 
    631                 printf("  (min = %+6.2f A, max = %+6.2f A)", 
    632                        get_value(name, sfmin), 
    633                        get_value(name, sfmax)); 
    634         else if (sfmin) 
    635                 printf("  (min = %+6.2f A)", 
    636                        get_value(name, sfmin)); 
    637         else if (sfmax) 
    638                 printf("  (max = %+6.2f A)", 
    639                        get_value(name, sfmax)); 
    640  
    641         sf = sensors_get_subfeature(name, feature, 
    642                                     SENSORS_SUBFEATURE_CURR_ALARM); 
    643         sfmin = sensors_get_subfeature(name, feature, 
    644                                        SENSORS_SUBFEATURE_CURR_MIN_ALARM); 
    645         sfmax = sensors_get_subfeature(name, feature, 
    646                                        SENSORS_SUBFEATURE_CURR_MAX_ALARM); 
    647         if (sfmin || sfmax) { 
    648                 alarm_max = sfmax ? get_value(name, sfmax) : 0; 
    649                 alarm_min = sfmin ? get_value(name, sfmin) : 0; 
    650  
    651                 if (alarm_min || alarm_max) { 
    652                         printf(" ALARM ("); 
    653  
    654                         if (alarm_min) 
    655                                 printf("MIN"); 
    656                         if (alarm_max) 
    657                                 printf("%sMAX", (alarm_min) ? ", " : ""); 
    658  
    659                         printf(")"); 
    660                 } 
    661         } else if (sf) { 
    662                 printf("   %s", 
    663                        get_value(name, sf) ? "ALARM" : ""); 
    664         } 
     670                printf("     N/A  "); 
     671 
     672        sensor_count = alarm_count = 0; 
     673        get_sensor_limit_data(name, feature, current_sensors, 
     674                              sensors, ARRAY_SIZE(sensors), &sensor_count, 
     675                              alarms, ARRAY_SIZE(alarms), &alarm_count); 
     676 
     677        print_limits(sensors, sensor_count, alarms, alarm_count, label_size, 
     678                     "%s = %+6.2f A"); 
    665679 
    666680        printf("\n"); 

  • lm-sensors/trunk/prog/sensors/chips.h

    r5163 r5943  
    2525#include "lib/sensors.h" 
    2626 
     27/* 
     28 * Retrieved subfeatures 
     29 */ 
     30struct sensor_subfeature_data { 
     31        double value;           /* Subfeature value. Not used for alarms. */ 
     32        const char *name;       /* Subfeature name */ 
     33        const char *unit;       /* Unit to be displayed for this subfeature. 
     34                                   This field is optional. */ 
     35}; 
     36 
     37/* 
     38 * Subfeature data structure. Used to create a table of implemented subfeatures 
     39 * for a given feature. 
     40 */ 
     41struct sensor_subfeature_list { 
     42        int subfeature; 
     43        const struct sensor_subfeature_list *exists; 
     44                                /* Complementary subfeatures to be displayed 
     45                                   if subfeature exists */ 
     46        int alarm;              /* true if this is an alarm */ 
     47        const char *name;       /* subfeature name to be printed */ 
     48}; 
     49 
    2750void print_chip_raw(const sensors_chip_name *name); 
    2851void print_chip(const sensors_chip_name *name);