Show
Ignore:
Timestamp:
08/26/07 12:57:16 (6 years ago)
Author:
khali
Message:

Mass reindent and coding style cleanups.

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • lm-sensors/branches/lm-sensors-3.0.0/prog/sensors/chips_generic.c

    r4695 r4708  
    2727#include "chips.h" 
    2828 
    29 static int get_feature_value(const sensors_chip_name *name,  
    30                              const sensors_feature_data *feature,  
    31                              double *val) 
    32 { 
    33   return sensors_get_value(name, feature->number, val); 
    34 } 
    35  
    36 static void sensors_get_available_features(const sensors_chip_name *name,  
    37                                            const sensors_feature_data *feature,  
    38                                            int i, 
    39                                            short *has_features,  
    40                                            double *feature_vals,  
    41                                            int size,  
    42                                            int first_val) 
    43 { 
    44   const sensors_feature_data *iter; 
    45    
    46   while((iter = sensors_get_all_features(name, &i)) && 
    47       iter->mapping == feature->number) { 
    48     int indx; 
    49      
    50     indx = iter->type - first_val - 1; 
    51     if (indx < 0 || indx >= size) { 
    52       printf("ERROR: Bug in sensors: index out of bound"); 
    53       return; 
    54     } 
    55      
    56     if (get_feature_value(name, iter, &feature_vals[indx])) 
    57       printf("ERROR: Can't get %s data!\n", iter->name); 
    58      
    59     has_features[indx] = 1; 
    60   } 
     29static int get_feature_value(const sensors_chip_name *name, 
     30                             const sensors_feature_data *feature, 
     31                             double *val) 
     32{ 
     33        return sensors_get_value(name, feature->number, val); 
     34} 
     35 
     36static void sensors_get_available_features(const sensors_chip_name *name, 
     37                                           const sensors_feature_data *feature, 
     38                                           int i, short *has_features, 
     39                                           double *feature_vals, int size, 
     40                                           int first_val) 
     41{ 
     42        const sensors_feature_data *iter; 
     43 
     44        while ((iter = sensors_get_all_features(name, &i)) && 
     45               iter->mapping == feature->number) { 
     46                int indx; 
     47 
     48                indx = iter->type - first_val - 1; 
     49                if (indx < 0 || indx >= size) { 
     50                        printf("ERROR: Bug in sensors: index out of bound"); 
     51                        return; 
     52                } 
     53 
     54                if (get_feature_value(name, iter, &feature_vals[indx])) 
     55                        printf("ERROR: Can't get %s data!\n", iter->name); 
     56 
     57                has_features[indx] = 1; 
     58        } 
    6159} 
    6260 
    6361static int sensors_get_label_size(const sensors_chip_name *name) 
    6462{ 
    65   int i; 
    66   const sensors_feature_data *iter; 
    67   char *label; 
    68   unsigned int max_size = 11; /* Initialised to 11 as minumum label-width */ 
    69  
    70   i = 0; 
    71   while((iter = sensors_get_all_features(name, &i))) { 
    72     if ((label = sensors_get_label(name, iter->number)) && 
    73         strlen(label) > max_size) 
    74       max_size = strlen(label); 
    75     free(label); 
    76   } 
    77   return max_size + 1; 
     63        int i; 
     64        const sensors_feature_data *iter; 
     65        char *label; 
     66        unsigned int max_size = 11;     /* 11 as minumum label width */ 
     67 
     68        i = 0; 
     69        while ((iter = sensors_get_all_features(name, &i))) { 
     70                if ((label = sensors_get_label(name, iter->number)) && 
     71                    strlen(label) > max_size) 
     72                        max_size = strlen(label); 
     73                free(label); 
     74        } 
     75        return max_size + 1; 
    7876} 
    7977 
    … …  
    8381static inline float deg_ctof(float cel) 
    8482{ 
    85    return ( cel * ( 9.0F / 5.0F ) + 32.0F ); 
    86 } 
    87  
    88 #define TEMP_FEATURE(x) has_features[x - SENSORS_FEATURE_TEMP - 1] 
    89 #define TEMP_FEATURE_VAL(x) feature_vals[x - SENSORS_FEATURE_TEMP - 1] 
    90 static void print_generic_chip_temp(const sensors_chip_name *name,  
    91                                     const sensors_feature_data *feature, 
    92                                     int i, int label_size) 
    93 { 
    94   double val, max, min; 
    95   char *label; 
    96   int type; 
    97   const int size = SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP; 
    98   short has_features[SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP] = {0, }; 
    99   double feature_vals[SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP] = {0.0, }; 
    100    
    101   if (!(label = sensors_get_label(name, feature->number))) { 
    102     printf("ERROR: Can't get temperature label!\n"); 
    103     return; 
    104   } 
    105    
    106   if (get_feature_value(name, feature, &val)) { 
    107     printf("ERROR: Can't get %s data!\n", label); 
    108     free(label); 
    109     return; 
    110   } 
    111    
    112   sensors_get_available_features(name, feature, i, has_features, 
    113       feature_vals, size, SENSORS_FEATURE_TEMP); 
    114    
    115   if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX)) { 
    116     max = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX); 
    117      
    118     if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN)) { 
    119       min = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MIN); 
    120       type = MINMAX; 
    121     } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_HYST)) { 
    122       min = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX_HYST); 
    123       type = HYST; 
    124     } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) { 
    125       min = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT); 
    126       type = CRIT; 
    127     } else { 
    128       min = 0; 
    129       type = MAXONLY; 
    130     } 
    131   } else { 
    132     min = max = 0; 
    133     type = SINGLE; 
    134   } 
    135    
    136   if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_FAULT) && 
    137       TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_FAULT)) 
    138     val = HUGE_VAL; 
    139    
    140   print_label(label, label_size); 
    141   free(label); 
    142    
    143   print_temp_info(val, max, min, type, 1, 1); 
    144    
    145   /* ALARM features */ 
    146   if ((TEMP_FEATURE(SENSORS_FEATURE_TEMP_ALARM) &&  
    147        TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_ALARM) > 0.5) 
    148    || (type == MINMAX && 
    149        TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN_ALARM) &&  
    150        TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MIN_ALARM) > 0.5) 
    151    || (type == MINMAX && 
    152        TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_ALARM) &&  
    153        TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX_ALARM) > 0.5) 
    154    || (type == CRIT && 
    155        TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) &&  
    156        TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM) > 0.5)) { 
    157     printf("ALARM  "); 
    158   } 
    159    
    160   if (type != CRIT && TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) { 
    161     if (fahrenheit) { 
    162       TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT) = deg_ctof( 
    163         TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT)); 
    164       TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST) = deg_ctof( 
    165         TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST)); 
    166     } 
    167      
    168     if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_HYST)) 
    169       printf("\n%*s(crit = %+5.1f%s, hyst = %+5.1f%s)  ", label_size + 10, "",  
    170         TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT), degstr, 
    171         TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST), degstr); 
    172     else 
    173       printf("\n%*s(crit = %+5.1f%s)  ", label_size + 10, "",  
    174         TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT), degstr); 
    175  
    176     if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) && 
    177         TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM)) { 
    178       printf("ALARM  "); 
    179     } 
    180   }        
    181  
    182   /* print out temperature sensor info */ 
    183   if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_SENS)) { 
    184     int sens = (int)TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_SENS); 
    185      
    186     /* older kernels / drivers sometimes report a beta value for thermistors */ 
    187     if (sens > 1000)  
    188       sens = 4; 
    189      
    190     printf("sensor = %s", sens == 0 ? "disabled" : 
    191                           sens == 1 ? "diode" : 
    192                           sens == 2 ? "transistor" : 
    193                           sens == 3 ? "thermal diode" : 
    194                           sens == 4 ? "thermistor" : 
    195                           sens == 5 ? "AMD AMDSI" : 
    196                           sens == 6 ? "Intel PECI" : 
    197                           "unknown"); 
    198   } 
    199   printf("\n"); 
    200 } 
    201  
    202 #define IN_FEATURE(x) has_features[x - SENSORS_FEATURE_IN - 1] 
    203 #define IN_FEATURE_VAL(x) feature_vals[x - SENSORS_FEATURE_IN - 1] 
    204 static void print_generic_chip_in(const sensors_chip_name *name,  
    205                                   const sensors_feature_data *feature, 
    206                                   int i, int label_size) 
    207 { 
    208   const int size = SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN; 
    209   short has_features[SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN] = {0, }; 
    210   double feature_vals[SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN] = {0.0, }; 
    211   double val, alarm_max, alarm_min; 
    212   char *label; 
    213    
    214   if (!(label = sensors_get_label(name, feature->number))) { 
    215     printf("ERROR: Can't get in label!\n"); 
    216     return; 
    217   } 
    218    
    219   if (get_feature_value(name, feature, &val)) { 
    220     printf("ERROR: Can't get %s data!\n", label); 
    221     free(label); 
    222     return; 
    223   } 
    224    
    225   sensors_get_available_features(name, feature, i, has_features, feature_vals, 
    226       size, SENSORS_FEATURE_IN); 
    227    
    228   print_label(label, label_size); 
    229   free(label); 
    230   printf("%+6.2f V", val); 
    231    
    232   if (IN_FEATURE(SENSORS_FEATURE_IN_MIN) && IN_FEATURE(SENSORS_FEATURE_IN_MAX)) 
    233     printf("  (min = %+6.2f V, max = %+6.2f V)", 
    234       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN), 
    235       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX)); 
    236   else if (IN_FEATURE(SENSORS_FEATURE_IN_MIN)) 
    237     printf("  (min = %+6.2f V)", IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN)); 
    238   else if (IN_FEATURE(SENSORS_FEATURE_IN_MAX)) 
    239     printf("  (max = %+6.2f V)", IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX)); 
    240    
    241   if (IN_FEATURE(SENSORS_FEATURE_IN_MAX_ALARM) || 
    242       IN_FEATURE(SENSORS_FEATURE_IN_MIN_ALARM)) { 
    243     alarm_max = IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX_ALARM); 
    244     alarm_min = IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN_ALARM); 
    245      
    246     if (alarm_min || alarm_max) { 
    247       printf(" ALARM ("); 
    248        
    249       if (alarm_min) 
    250         printf("MIN"); 
    251       if (alarm_max) 
    252         printf("%sMAX", (alarm_min) ? ", " : ""); 
    253        
    254       printf(")"); 
    255     } 
    256   } else if (IN_FEATURE(SENSORS_FEATURE_IN_ALARM)) { 
    257     printf("   %s",  
    258     IN_FEATURE_VAL(SENSORS_FEATURE_IN_ALARM) ? "ALARM" : ""); 
    259   } 
    260    
    261   printf("\n"); 
    262 } 
    263  
    264 #define FAN_FEATURE(x) has_features[x - SENSORS_FEATURE_FAN - 1] 
    265 #define FAN_FEATURE_VAL(x) feature_vals[x - SENSORS_FEATURE_FAN - 1] 
    266 static void print_generic_chip_fan(const sensors_chip_name *name,  
    267                                    const sensors_feature_data *feature, 
    268                                    int i, int label_size) 
    269 { 
    270   char *label; 
    271   const int size = SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN; 
    272   short has_features[SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN] = {0, }; 
    273   double feature_vals[SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN] = {0.0, }; 
    274   double val; 
    275    
    276   if (!(label = sensors_get_label(name, feature->number))) { 
    277     printf("ERROR: Can't get fan label!\n"); 
    278     return; 
    279   } 
    280    
    281   if (get_feature_value(name, feature, &val)) 
    282   { 
    283     printf("ERROR: Can't get %s data!\n", label); 
    284     free(label); 
    285     return; 
    286   } 
    287    
    288   print_label(label, label_size); 
    289   free(label); 
    290  
    291   if (FAN_FEATURE(SENSORS_FEATURE_FAN_FAULT) && 
    292       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_FAULT)) 
    293     printf("   FAULT"); 
    294   else 
    295     printf("%4.0f RPM", val); 
    296    
    297   sensors_get_available_features(name, feature, i, has_features, feature_vals, 
    298       size, SENSORS_FEATURE_FAN); 
    299    
    300   if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN) && 
    301       FAN_FEATURE(SENSORS_FEATURE_FAN_DIV)) 
    302     printf("  (min = %4.0f RPM, div = %1.0f)", 
    303       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_MIN), 
    304       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_DIV)); 
    305   else if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN)) 
    306     printf("  (min = %4.0f RPM)", FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_MIN)); 
    307   else if (FAN_FEATURE(SENSORS_FEATURE_FAN_DIV)) 
    308     printf("  (div = %1.0f)", FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_DIV)); 
    309    
    310   if (FAN_FEATURE(SENSORS_FEATURE_FAN_ALARM) &&  
    311       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_ALARM)) { 
    312     printf("  ALARM"); 
    313   }        
    314    
    315   printf("\n"); 
     83        return cel * (9.0F / 5.0F) + 32.0F; 
     84} 
     85 
     86#define TEMP_FEATURE(x)         has_features[x - SENSORS_FEATURE_TEMP - 1] 
     87#define TEMP_FEATURE_VAL(x)     feature_vals[x - SENSORS_FEATURE_TEMP - 1] 
     88static void print_generic_chip_temp(const sensors_chip_name *name, 
     89                                    const sensors_feature_data *feature, 
     90                                    int i, int label_size) 
     91{ 
     92        double val, max, min; 
     93        char *label; 
     94        int type; 
     95        const int size = SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP; 
     96        short has_features[SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP] = { 0, }; 
     97        double feature_vals[SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP] = { 0.0, }; 
     98 
     99        if (!(label = sensors_get_label(name, feature->number))) { 
     100                printf("ERROR: Can't get temperature label!\n"); 
     101                return; 
     102        } 
     103 
     104        if (get_feature_value(name, feature, &val)) { 
     105                printf("ERROR: Can't get %s data!\n", label); 
     106                free(label); 
     107                return; 
     108        } 
     109 
     110        sensors_get_available_features(name, feature, i, has_features, 
     111                                       feature_vals, size, 
     112                                       SENSORS_FEATURE_TEMP); 
     113 
     114        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX)) { 
     115                max = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX); 
     116 
     117                if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN)) { 
     118                        min = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MIN); 
     119                        type = MINMAX; 
     120                } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_HYST)) { 
     121                        min = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX_HYST); 
     122                        type = HYST; 
     123                } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) { 
     124                        min = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT); 
     125                        type = CRIT; 
     126                } else { 
     127                        min = 0; 
     128                        type = MAXONLY; 
     129                } 
     130        } else { 
     131                min = max = 0; 
     132                type = SINGLE; 
     133        } 
     134 
     135        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_FAULT) && 
     136            TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_FAULT)) 
     137                val = HUGE_VAL; 
     138 
     139        print_label(label, label_size); 
     140        free(label); 
     141 
     142        print_temp_info(val, max, min, type, 1, 1); 
     143 
     144        /* ALARM features */ 
     145        if ((TEMP_FEATURE(SENSORS_FEATURE_TEMP_ALARM) && 
     146             TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_ALARM) > 0.5) 
     147         || (type == MINMAX && 
     148             TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN_ALARM) && 
     149             TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MIN_ALARM) > 0.5) 
     150         || (type == MINMAX && 
     151             TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_ALARM) && 
     152             TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX_ALARM) > 0.5) 
     153         || (type == CRIT && 
     154             TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) && 
     155             TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM) > 0.5)) { 
     156                printf("ALARM  "); 
     157        } 
     158 
     159        if (type != CRIT && TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) { 
     160                if (fahrenheit) { 
     161                        TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT) = deg_ctof( 
     162                                TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT)); 
     163                        TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST) = deg_ctof( 
     164                                TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST)); 
     165                } 
     166 
     167                if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_HYST)) 
     168                        printf("\n%*s(crit = %+5.1f%s, hyst = %+5.1f%s)  ", 
     169                               label_size + 10, "", 
     170                               TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT), 
     171                               degstr, 
     172                               TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST), 
     173                               degstr); 
     174                else 
     175                        printf("\n%*s(crit = %+5.1f%s)  ", 
     176                               label_size + 10, "", 
     177                               TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT), 
     178                               degstr); 
     179 
     180                if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) && 
     181                    TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM)) { 
     182                        printf("ALARM  "); 
     183                } 
     184        } 
     185 
     186        /* print out temperature sensor info */ 
     187        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_SENS)) { 
     188                int sens = (int)TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_SENS); 
     189 
     190                /* older kernels / drivers sometimes report a beta value for 
     191                   thermistors */ 
     192                if (sens > 1000) 
     193                        sens = 4; 
     194 
     195                printf("sensor = %s", sens == 0 ? "disabled" : 
     196                       sens == 1 ? "diode" : 
     197                       sens == 2 ? "transistor" : 
     198                       sens == 3 ? "thermal diode" : 
     199                       sens == 4 ? "thermistor" : 
     200                       sens == 5 ? "AMD AMDSI" : 
     201                       sens == 6 ? "Intel PECI" : "unknown"); 
     202        } 
     203        printf("\n"); 
     204} 
     205 
     206#define IN_FEATURE(x)           has_features[x - SENSORS_FEATURE_IN - 1] 
     207#define IN_FEATURE_VAL(x)       feature_vals[x - SENSORS_FEATURE_IN - 1] 
     208static void print_generic_chip_in(const sensors_chip_name *name, 
     209                                  const sensors_feature_data *feature, 
     210                                  int i, int label_size) 
     211{ 
     212        const int size = SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN; 
     213        short has_features[SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN] = { 0, }; 
     214        double feature_vals[SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN] = { 0.0, }; 
     215        double val, alarm_max, alarm_min; 
     216        char *label; 
     217 
     218        if (!(label = sensors_get_label(name, feature->number))) { 
     219                printf("ERROR: Can't get in label!\n"); 
     220                return; 
     221        } 
     222 
     223        if (get_feature_value(name, feature, &val)) { 
     224                printf("ERROR: Can't get %s data!\n", label); 
     225                free(label); 
     226                return; 
     227        } 
     228 
     229        sensors_get_available_features(name, feature, i, has_features, 
     230                                       feature_vals, size, SENSORS_FEATURE_IN); 
     231 
     232        print_label(label, label_size); 
     233        free(label); 
     234        printf("%+6.2f V", val); 
     235 
     236        if (IN_FEATURE(SENSORS_FEATURE_IN_MIN) && 
     237            IN_FEATURE(SENSORS_FEATURE_IN_MAX)) 
     238                printf("  (min = %+6.2f V, max = %+6.2f V)", 
     239                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN), 
     240                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX)); 
     241        else if (IN_FEATURE(SENSORS_FEATURE_IN_MIN)) 
     242                printf("  (min = %+6.2f V)", 
     243                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN)); 
     244        else if (IN_FEATURE(SENSORS_FEATURE_IN_MAX)) 
     245                printf("  (max = %+6.2f V)", 
     246                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX)); 
     247 
     248        if (IN_FEATURE(SENSORS_FEATURE_IN_MAX_ALARM) || 
     249            IN_FEATURE(SENSORS_FEATURE_IN_MIN_ALARM)) { 
     250                alarm_max = IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX_ALARM); 
     251                alarm_min = IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN_ALARM); 
     252 
     253                if (alarm_min || alarm_max) { 
     254                        printf(" ALARM ("); 
     255 
     256                        if (alarm_min) 
     257                                printf("MIN"); 
     258                        if (alarm_max) 
     259                                printf("%sMAX", (alarm_min) ? ", " : ""); 
     260 
     261                        printf(")"); 
     262                } 
     263        } else if (IN_FEATURE(SENSORS_FEATURE_IN_ALARM)) { 
     264                printf("   %s", 
     265                IN_FEATURE_VAL(SENSORS_FEATURE_IN_ALARM) ? "ALARM" : ""); 
     266        } 
     267 
     268        printf("\n"); 
     269} 
     270 
     271#define FAN_FEATURE(x)          has_features[x - SENSORS_FEATURE_FAN - 1] 
     272#define FAN_FEATURE_VAL(x)      feature_vals[x - SENSORS_FEATURE_FAN - 1] 
     273static void print_generic_chip_fan(const sensors_chip_name *name, 
     274                                   const sensors_feature_data *feature, 
     275                                   int i, int label_size) 
     276{ 
     277        char *label; 
     278        const int size = SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN; 
     279        short has_features[SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN] = { 0, }; 
     280        double feature_vals[SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN] = { 0.0, }; 
     281        double val; 
     282 
     283        if (!(label = sensors_get_label(name, feature->number))) { 
     284                printf("ERROR: Can't get fan label!\n"); 
     285                return; 
     286        } 
     287 
     288        if (get_feature_value(name, feature, &val)) { 
     289                printf("ERROR: Can't get %s data!\n", label); 
     290                free(label); 
     291                return; 
     292        } 
     293 
     294        print_label(label, label_size); 
     295        free(label); 
     296 
     297        if (FAN_FEATURE(SENSORS_FEATURE_FAN_FAULT) && 
     298            FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_FAULT)) 
     299                printf("   FAULT"); 
     300        else 
     301                printf("%4.0f RPM", val); 
     302 
     303        sensors_get_available_features(name, feature, i, has_features, 
     304                                       feature_vals, size, SENSORS_FEATURE_FAN); 
     305 
     306        if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN) && 
     307            FAN_FEATURE(SENSORS_FEATURE_FAN_DIV)) 
     308                printf("  (min = %4.0f RPM, div = %1.0f)", 
     309                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_MIN), 
     310                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_DIV)); 
     311        else if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN)) 
     312                printf("  (min = %4.0f RPM)", 
     313                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_MIN)); 
     314        else if (FAN_FEATURE(SENSORS_FEATURE_FAN_DIV)) 
     315                printf("  (div = %1.0f)", 
     316                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_DIV)); 
     317 
     318        if (FAN_FEATURE(SENSORS_FEATURE_FAN_ALARM) && 
     319            FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_ALARM)) { 
     320                printf("  ALARM"); 
     321        } 
     322 
     323        printf("\n"); 
    316324} 
    317325 
    318326void print_generic_chip(const sensors_chip_name *name) 
    319327{ 
    320   const sensors_feature_data *feature; 
    321   int i, label_size; 
    322    
    323   label_size = sensors_get_label_size(name); 
    324    
    325   i = 0; 
    326   while((feature = sensors_get_all_features(name, &i))) { 
    327     if (feature->mapping != SENSORS_NO_MAPPING) 
    328       continue; 
    329      
    330     switch (feature->type) { 
    331       case SENSORS_FEATURE_TEMP: 
    332         print_generic_chip_temp(name, feature, i, label_size); break; 
    333       case SENSORS_FEATURE_IN: 
    334         print_generic_chip_in(name, feature, i, label_size); break; 
    335       case SENSORS_FEATURE_FAN: 
    336         print_generic_chip_fan(name, feature, i, label_size); break; 
    337       case SENSORS_FEATURE_VID: 
    338         print_vid_info(name, feature->number, label_size); break; 
    339       default: continue; 
    340     } 
    341   } 
    342 } 
     328        const sensors_feature_data *feature; 
     329        int i, label_size; 
     330 
     331        label_size = sensors_get_label_size(name); 
     332 
     333        i = 0; 
     334        while ((feature = sensors_get_all_features(name, &i))) { 
     335                if (feature->mapping != SENSORS_NO_MAPPING) 
     336                        continue; 
     337 
     338                switch (feature->type) { 
     339                case SENSORS_FEATURE_TEMP: 
     340                        print_generic_chip_temp(name, feature, i, label_size); 
     341                        break; 
     342                case SENSORS_FEATURE_IN: 
     343                        print_generic_chip_in(name, feature, i, label_size); 
     344                        break; 
     345                case SENSORS_FEATURE_FAN: 
     346                        print_generic_chip_fan(name, feature, i, label_size); 
     347                        break; 
     348                case SENSORS_FEATURE_VID: 
     349                        print_vid_info(name, feature->number, label_size); 
     350                        break; 
     351                default: 
     352                        continue; 
     353                } 
     354        } 
     355}