Show
Ignore:
Timestamp:
08/26/07 14:19:07 (7 years ago)
Author:
khali
Message:

Merge chips_generic.c into chips.c. The boundary between both files was
only historical, and prevents us from doing a number of cleanups.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • lm-sensors/branches/lm-sensors-3.0.0/prog/sensors/chips.c

    r4708 r4710  
    3636} 
    3737 
     38#define HYST 0 
     39#define MINMAX 1 
     40#define MAXONLY 2 
     41#define CRIT 3 
     42#define SINGLE 4 
     43#define HYSTONLY 5 
     44 
    3845/* minmax = 0 for limit/hysteresis, 1 for max/min, 2 for max only; 
    3946   curprec and limitprec are # of digits after decimal point 
    4047   for the current temp and the limits 
    4148   note: symbolic constants defined in chips.h */ 
    42 void print_temp_info(float n_cur, float n_over, float n_hyst, 
    43                      int minmax, int curprec, int limitprec) 
     49static void print_temp_info(float n_cur, float n_over, float n_hyst, 
     50                            int minmax, int curprec, int limitprec) 
    4451{ 
    4552        /* note: deg_ctof() will preserve HUGEVAL */ 
     
    7885} 
    7986 
    80 void print_label(const char *label, int space) 
     87static void print_label(const char *label, int space) 
    8188{ 
    8289        int len = strlen(label)+1; 
     
    8794} 
    8895 
    89 void print_vid_info(const sensors_chip_name *name, int f_vid, int label_size) 
     96static void print_vid_info(const sensors_chip_name *name, int f_vid, 
     97                           int label_size) 
    9098{ 
    9199        char *label; 
     
    131139        } 
    132140} 
     141 
     142static int get_feature_value(const sensors_chip_name *name, 
     143                             const sensors_feature_data *feature, 
     144                             double *val) 
     145{ 
     146        return sensors_get_value(name, feature->number, val); 
     147} 
     148 
     149static void sensors_get_available_features(const sensors_chip_name *name, 
     150                                           const sensors_feature_data *feature, 
     151                                           int i, short *has_features, 
     152                                           double *feature_vals, int size, 
     153                                           int first_val) 
     154{ 
     155        const sensors_feature_data *iter; 
     156 
     157        while ((iter = sensors_get_all_features(name, &i)) && 
     158               iter->mapping == feature->number) { 
     159                int indx; 
     160 
     161                indx = iter->type - first_val - 1; 
     162                if (indx < 0 || indx >= size) { 
     163                        printf("ERROR: Bug in sensors: index out of bound"); 
     164                        return; 
     165                } 
     166 
     167                if (get_feature_value(name, iter, &feature_vals[indx])) 
     168                        printf("ERROR: Can't get %s data!\n", iter->name); 
     169 
     170                has_features[indx] = 1; 
     171        } 
     172} 
     173 
     174static int sensors_get_label_size(const sensors_chip_name *name) 
     175{ 
     176        int i; 
     177        const sensors_feature_data *iter; 
     178        char *label; 
     179        unsigned int max_size = 11;     /* 11 as minumum label width */ 
     180 
     181        i = 0; 
     182        while ((iter = sensors_get_all_features(name, &i))) { 
     183                if ((label = sensors_get_label(name, iter->number)) && 
     184                    strlen(label) > max_size) 
     185                        max_size = strlen(label); 
     186                free(label); 
     187        } 
     188        return max_size + 1; 
     189} 
     190 
     191#define TEMP_FEATURE(x)         has_features[x - SENSORS_FEATURE_TEMP - 1] 
     192#define TEMP_FEATURE_VAL(x)     feature_vals[x - SENSORS_FEATURE_TEMP - 1] 
     193static void print_generic_chip_temp(const sensors_chip_name *name, 
     194                                    const sensors_feature_data *feature, 
     195                                    int i, int label_size) 
     196{ 
     197        double val, max, min; 
     198        char *label; 
     199        int type; 
     200        const int size = SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP; 
     201        short has_features[SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP] = { 0, }; 
     202        double feature_vals[SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP] = { 0.0, }; 
     203 
     204        if (!(label = sensors_get_label(name, feature->number))) { 
     205                printf("ERROR: Can't get temperature label!\n"); 
     206                return; 
     207        } 
     208 
     209        if (get_feature_value(name, feature, &val)) { 
     210                printf("ERROR: Can't get %s data!\n", label); 
     211                free(label); 
     212                return; 
     213        } 
     214 
     215        sensors_get_available_features(name, feature, i, has_features, 
     216                                       feature_vals, size, 
     217                                       SENSORS_FEATURE_TEMP); 
     218 
     219        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX)) { 
     220                max = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX); 
     221 
     222                if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN)) { 
     223                        min = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MIN); 
     224                        type = MINMAX; 
     225                } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_HYST)) { 
     226                        min = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX_HYST); 
     227                        type = HYST; 
     228                } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) { 
     229                        min = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT); 
     230                        type = CRIT; 
     231                } else { 
     232                        min = 0; 
     233                        type = MAXONLY; 
     234                } 
     235        } else { 
     236                min = max = 0; 
     237                type = SINGLE; 
     238        } 
     239 
     240        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_FAULT) && 
     241            TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_FAULT)) 
     242                val = HUGE_VAL; 
     243 
     244        print_label(label, label_size); 
     245        free(label); 
     246 
     247        print_temp_info(val, max, min, type, 1, 1); 
     248 
     249        /* ALARM features */ 
     250        if ((TEMP_FEATURE(SENSORS_FEATURE_TEMP_ALARM) && 
     251             TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_ALARM) > 0.5) 
     252         || (type == MINMAX && 
     253             TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN_ALARM) && 
     254             TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MIN_ALARM) > 0.5) 
     255         || (type == MINMAX && 
     256             TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_ALARM) && 
     257             TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX_ALARM) > 0.5) 
     258         || (type == CRIT && 
     259             TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) && 
     260             TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM) > 0.5)) { 
     261                printf("ALARM  "); 
     262        } 
     263 
     264        if (type != CRIT && TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) { 
     265                if (fahrenheit) { 
     266                        TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT) = deg_ctof( 
     267                                TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT)); 
     268                        TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST) = deg_ctof( 
     269                                TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST)); 
     270                } 
     271 
     272                if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_HYST)) 
     273                        printf("\n%*s(crit = %+5.1f%s, hyst = %+5.1f%s)  ", 
     274                               label_size + 10, "", 
     275                               TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT), 
     276                               degstr, 
     277                               TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST), 
     278                               degstr); 
     279                else 
     280                        printf("\n%*s(crit = %+5.1f%s)  ", 
     281                               label_size + 10, "", 
     282                               TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT), 
     283                               degstr); 
     284 
     285                if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) && 
     286                    TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM)) { 
     287                        printf("ALARM  "); 
     288                } 
     289        } 
     290 
     291        /* print out temperature sensor info */ 
     292        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_SENS)) { 
     293                int sens = (int)TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_SENS); 
     294 
     295                /* older kernels / drivers sometimes report a beta value for 
     296                   thermistors */ 
     297                if (sens > 1000) 
     298                        sens = 4; 
     299 
     300                printf("sensor = %s", sens == 0 ? "disabled" : 
     301                       sens == 1 ? "diode" : 
     302                       sens == 2 ? "transistor" : 
     303                       sens == 3 ? "thermal diode" : 
     304                       sens == 4 ? "thermistor" : 
     305                       sens == 5 ? "AMD AMDSI" : 
     306                       sens == 6 ? "Intel PECI" : "unknown"); 
     307        } 
     308        printf("\n"); 
     309} 
     310 
     311#define IN_FEATURE(x)           has_features[x - SENSORS_FEATURE_IN - 1] 
     312#define IN_FEATURE_VAL(x)       feature_vals[x - SENSORS_FEATURE_IN - 1] 
     313static void print_generic_chip_in(const sensors_chip_name *name, 
     314                                  const sensors_feature_data *feature, 
     315                                  int i, int label_size) 
     316{ 
     317        const int size = SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN; 
     318        short has_features[SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN] = { 0, }; 
     319        double feature_vals[SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN] = { 0.0, }; 
     320        double val, alarm_max, alarm_min; 
     321        char *label; 
     322 
     323        if (!(label = sensors_get_label(name, feature->number))) { 
     324                printf("ERROR: Can't get in label!\n"); 
     325                return; 
     326        } 
     327 
     328        if (get_feature_value(name, feature, &val)) { 
     329                printf("ERROR: Can't get %s data!\n", label); 
     330                free(label); 
     331                return; 
     332        } 
     333 
     334        sensors_get_available_features(name, feature, i, has_features, 
     335                                       feature_vals, size, SENSORS_FEATURE_IN); 
     336 
     337        print_label(label, label_size); 
     338        free(label); 
     339        printf("%+6.2f V", val); 
     340 
     341        if (IN_FEATURE(SENSORS_FEATURE_IN_MIN) && 
     342            IN_FEATURE(SENSORS_FEATURE_IN_MAX)) 
     343                printf("  (min = %+6.2f V, max = %+6.2f V)", 
     344                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN), 
     345                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX)); 
     346        else if (IN_FEATURE(SENSORS_FEATURE_IN_MIN)) 
     347                printf("  (min = %+6.2f V)", 
     348                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN)); 
     349        else if (IN_FEATURE(SENSORS_FEATURE_IN_MAX)) 
     350                printf("  (max = %+6.2f V)", 
     351                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX)); 
     352 
     353        if (IN_FEATURE(SENSORS_FEATURE_IN_MAX_ALARM) || 
     354            IN_FEATURE(SENSORS_FEATURE_IN_MIN_ALARM)) { 
     355                alarm_max = IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX_ALARM); 
     356                alarm_min = IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN_ALARM); 
     357 
     358                if (alarm_min || alarm_max) { 
     359                        printf(" ALARM ("); 
     360 
     361                        if (alarm_min) 
     362                                printf("MIN"); 
     363                        if (alarm_max) 
     364                                printf("%sMAX", (alarm_min) ? ", " : ""); 
     365 
     366                        printf(")"); 
     367                } 
     368        } else if (IN_FEATURE(SENSORS_FEATURE_IN_ALARM)) { 
     369                printf("   %s", 
     370                IN_FEATURE_VAL(SENSORS_FEATURE_IN_ALARM) ? "ALARM" : ""); 
     371        } 
     372 
     373        printf("\n"); 
     374} 
     375 
     376#define FAN_FEATURE(x)          has_features[x - SENSORS_FEATURE_FAN - 1] 
     377#define FAN_FEATURE_VAL(x)      feature_vals[x - SENSORS_FEATURE_FAN - 1] 
     378static void print_generic_chip_fan(const sensors_chip_name *name, 
     379                                   const sensors_feature_data *feature, 
     380                                   int i, int label_size) 
     381{ 
     382        char *label; 
     383        const int size = SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN; 
     384        short has_features[SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN] = { 0, }; 
     385        double feature_vals[SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN] = { 0.0, }; 
     386        double val; 
     387 
     388        if (!(label = sensors_get_label(name, feature->number))) { 
     389                printf("ERROR: Can't get fan label!\n"); 
     390                return; 
     391        } 
     392 
     393        if (get_feature_value(name, feature, &val)) { 
     394                printf("ERROR: Can't get %s data!\n", label); 
     395                free(label); 
     396                return; 
     397        } 
     398 
     399        print_label(label, label_size); 
     400        free(label); 
     401 
     402        if (FAN_FEATURE(SENSORS_FEATURE_FAN_FAULT) && 
     403            FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_FAULT)) 
     404                printf("   FAULT"); 
     405        else 
     406                printf("%4.0f RPM", val); 
     407 
     408        sensors_get_available_features(name, feature, i, has_features, 
     409                                       feature_vals, size, SENSORS_FEATURE_FAN); 
     410 
     411        if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN) && 
     412            FAN_FEATURE(SENSORS_FEATURE_FAN_DIV)) 
     413                printf("  (min = %4.0f RPM, div = %1.0f)", 
     414                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_MIN), 
     415                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_DIV)); 
     416        else if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN)) 
     417                printf("  (min = %4.0f RPM)", 
     418                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_MIN)); 
     419        else if (FAN_FEATURE(SENSORS_FEATURE_FAN_DIV)) 
     420                printf("  (div = %1.0f)", 
     421                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_DIV)); 
     422 
     423        if (FAN_FEATURE(SENSORS_FEATURE_FAN_ALARM) && 
     424            FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_ALARM)) { 
     425                printf("  ALARM"); 
     426        } 
     427 
     428        printf("\n"); 
     429} 
     430 
     431void print_generic_chip(const sensors_chip_name *name) 
     432{ 
     433        const sensors_feature_data *feature; 
     434        int i, label_size; 
     435 
     436        label_size = sensors_get_label_size(name); 
     437 
     438        i = 0; 
     439        while ((feature = sensors_get_all_features(name, &i))) { 
     440                if (feature->mapping != SENSORS_NO_MAPPING) 
     441                        continue; 
     442 
     443                switch (feature->type) { 
     444                case SENSORS_FEATURE_TEMP: 
     445                        print_generic_chip_temp(name, feature, i, label_size); 
     446                        break; 
     447                case SENSORS_FEATURE_IN: 
     448                        print_generic_chip_in(name, feature, i, label_size); 
     449                        break; 
     450                case SENSORS_FEATURE_FAN: 
     451                        print_generic_chip_fan(name, feature, i, label_size); 
     452                        break; 
     453                case SENSORS_FEATURE_VID: 
     454                        print_vid_info(name, feature->number, label_size); 
     455                        break; 
     456                default: 
     457                        continue; 
     458                } 
     459        } 
     460}