Changeset 4830

Show
Ignore:
Timestamp:
09/23/07 13:59:51 (7 years ago)
Author:
khali
Message:

sensors_feature_data and sensors_chip_feature are now the exact
same structure, so we can get rid of the former for simpler code.

Location:
lm-sensors/branches/lm-sensors-3.0.0/lib
Files:
6 modified

Legend:

Unmodified
Added
Removed
  • lm-sensors/branches/lm-sensors-3.0.0/lib/access.c

    r4796 r4830  
    9090   Do not modify the struct the return value points to! Returns NULL if  
    9191   not found.*/ 
    92 const sensors_chip_feature *sensors_lookup_feature_nr(const sensors_chip_name *chip, 
     92const sensors_feature_data *sensors_lookup_feature_nr(const sensors_chip_name *chip, 
    9393                                                      int feature) 
    9494{ 
     
    108108   Do not modify the struct the return value points to! Returns NULL if  
    109109   not found.*/ 
    110 static const sensors_chip_feature * 
     110static const sensors_feature_data * 
    111111sensors_lookup_feature_name(const sensors_chip_name *chip, const char *feature) 
    112112{ 
    113113        int i, j; 
    114         const sensors_chip_feature *features; 
     114        const sensors_feature_data *features; 
    115115 
    116116        for (i = 0; i < sensors_proc_chips_count; i++) 
     
    118118                        features = sensors_proc_chips[i].feature; 
    119119                        for (j = 0; j < sensors_proc_chips[i].feature_count; j++) 
    120                                 if (!strcmp(features[j].data.name, feature)) 
     120                                if (!strcmp(features[j].name, feature)) 
    121121                                        return features + j; 
    122122                } 
     
    146146        char *label; 
    147147        const sensors_chip *chip; 
    148         const sensors_chip_feature *featureptr; 
     148        const sensors_feature_data *featureptr; 
    149149        char buf[128], path[PATH_MAX]; 
    150150        FILE *f; 
     
    158158        for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));) 
    159159                for (i = 0; i < chip->labels_count; i++) 
    160                         if (!strcmp(featureptr->data.name, chip->labels[i].name)) { 
     160                        if (!strcmp(featureptr->name, chip->labels[i].name)) { 
    161161                                label = strdup(chip->labels[i].value); 
    162162                                goto sensors_get_label_exit; 
     
    165165        /* No user specified label, check for a _label sysfs file */ 
    166166        snprintf(path, PATH_MAX, "%s/%s_label", name->path, 
    167                 featureptr->data.name); 
     167                featureptr->name); 
    168168         
    169169        if ((f = fopen(path, "r"))) { 
     
    179179 
    180180        /* No label, return the feature name instead */ 
    181         label = strdup(featureptr->data.name); 
     181        label = strdup(featureptr->name); 
    182182         
    183183sensors_get_label_exit: 
     
    192192   mappings into account. */ 
    193193static int sensors_get_ignored(const sensors_chip_name *name, 
    194                                const sensors_chip_feature *feature) 
     194                               const sensors_feature_data *feature) 
    195195{ 
    196196        const sensors_chip *chip; 
     
    198198        int i; 
    199199 
    200         if (feature->data.mapping == SENSORS_NO_MAPPING) 
     200        if (feature->mapping == SENSORS_NO_MAPPING) 
    201201                main_feature_name = NULL; 
    202202        else 
    203203                main_feature_name = sensors_lookup_feature_nr(name, 
    204                                         feature->data.mapping)->data.name; 
     204                                        feature->mapping)->name; 
    205205 
    206206        for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));) 
    207207                for (i = 0; i < chip->ignores_count; i++) 
    208                         if (!strcmp(feature->data.name, chip->ignores[i].name) || 
     208                        if (!strcmp(feature->name, chip->ignores[i].name) || 
    209209                            (main_feature_name && 
    210210                             !strcmp(main_feature_name, chip->ignores[i].name))) 
     
    219219                      double *result) 
    220220{ 
    221         const sensors_chip_feature *main_feature; 
    222         const sensors_chip_feature *alt_feature; 
     221        const sensors_feature_data *main_feature; 
     222        const sensors_feature_data *alt_feature; 
    223223        const sensors_chip *chip; 
    224224        const sensors_expr *expr = NULL; 
     
    232232                return -SENSORS_ERR_NO_ENTRY; 
    233233 
    234         if (main_feature->data.flags & SENSORS_COMPUTE_MAPPING) 
     234        if (main_feature->flags & SENSORS_COMPUTE_MAPPING) 
    235235                alt_feature = sensors_lookup_feature_nr(name, 
    236                                         main_feature->data.mapping); 
     236                                        main_feature->mapping); 
    237237        else 
    238238                alt_feature = NULL; 
    239239 
    240         if (!(main_feature->data.flags & SENSORS_MODE_R)) 
     240        if (!(main_feature->flags & SENSORS_MODE_R)) 
    241241                return -SENSORS_ERR_ACCESS_R; 
    242242        for (chip = NULL; 
    243243             !expr && (chip = sensors_for_all_config_chips(name, chip));) 
    244244                for (i = 0; !final_expr && (i < chip->computes_count); i++) { 
    245                         if (!strcmp(main_feature->data.name, chip->computes[i].name)) { 
     245                        if (!strcmp(main_feature->name, chip->computes[i].name)) { 
    246246                                expr = chip->computes[i].from_proc; 
    247247                                final_expr = 1; 
    248                         } else if (alt_feature && !strcmp(alt_feature->data.name, 
     248                        } else if (alt_feature && !strcmp(alt_feature->name, 
    249249                                               chip->computes[i].name)) { 
    250250                                expr = chip->computes[i].from_proc; 
     
    266266                      double value) 
    267267{ 
    268         const sensors_chip_feature *main_feature; 
    269         const sensors_chip_feature *alt_feature; 
     268        const sensors_feature_data *main_feature; 
     269        const sensors_feature_data *alt_feature; 
    270270        const sensors_chip *chip; 
    271271        const sensors_expr *expr = NULL; 
     
    279279                return -SENSORS_ERR_NO_ENTRY; 
    280280 
    281         if (main_feature->data.flags & SENSORS_COMPUTE_MAPPING) 
     281        if (main_feature->flags & SENSORS_COMPUTE_MAPPING) 
    282282                alt_feature = sensors_lookup_feature_nr(name, 
    283                                         main_feature->data.mapping); 
     283                                        main_feature->mapping); 
    284284        else 
    285285                alt_feature = NULL; 
    286286 
    287         if (!(main_feature->data.flags & SENSORS_MODE_W)) 
     287        if (!(main_feature->flags & SENSORS_MODE_W)) 
    288288                return -SENSORS_ERR_ACCESS_W; 
    289289        for (chip = NULL; 
    290290             !expr && (chip = sensors_for_all_config_chips(name, chip));) 
    291291                for (i = 0; !final_expr && (i < chip->computes_count); i++) 
    292                         if (!strcmp(main_feature->data.name, chip->computes[i].name)) { 
     292                        if (!strcmp(main_feature->name, chip->computes[i].name)) { 
    293293                                expr = chip->computes->to_proc; 
    294294                                final_expr = 1; 
    295                         } else if (alt_feature && !strcmp(alt_feature->data.name, 
     295                        } else if (alt_feature && !strcmp(alt_feature->name, 
    296296                                               chip->computes[i].name)) { 
    297297                                expr = chip->computes[i].to_proc; 
     
    348348                                                     int *nr) 
    349349{ 
    350         sensors_chip_feature *feature_list; 
     350        sensors_feature_data *feature_list; 
    351351        int i; 
    352352 
     
    359359                        if (*nr == sensors_proc_chips[i].feature_count) 
    360360                                return NULL; 
    361                         return &feature_list[(*nr)++].data; 
     361                        return &feature_list[(*nr)++]; 
    362362                } 
    363363        return NULL; 
     
    371371        double res1, res2; 
    372372        int res; 
    373         const sensors_chip_feature *feature; 
     373        const sensors_feature_data *feature; 
    374374 
    375375        if (expr->kind == sensors_kind_val) { 
     
    385385                                                            expr->data.var))) 
    386386                        return SENSORS_ERR_NO_ENTRY; 
    387                 if (!(res = sensors_get_value(name, feature->data.number, result))) 
     387                if (!(res = sensors_get_value(name, feature->number, result))) 
    388388                        return res; 
    389389                return 0; 
     
    433433        int i, j; 
    434434        int err = 0, res; 
    435         const sensors_chip_feature *feature; 
     435        const sensors_feature_data *feature; 
    436436        int *feature_list = NULL; 
    437437        int feature_count = 0; 
     
    449449                                continue; 
    450450                        } 
    451                         feature_nr = feature->data.number; 
     451                        feature_nr = feature->number; 
    452452 
    453453                        /* Check whether we already set this feature */ 
  • lm-sensors/branches/lm-sensors-3.0.0/lib/access.h

    r4776 r4830  
    2727   Do not modify the struct the return value points to! Returns NULL if 
    2828   not found. */ 
    29 const sensors_chip_feature *sensors_lookup_feature_nr(const sensors_chip_name *chip, 
     29const sensors_feature_data *sensors_lookup_feature_nr(const sensors_chip_name *chip, 
    3030                                                      int feature); 
    3131 
  • lm-sensors/branches/lm-sensors-3.0.0/lib/data.h

    r4762 r4830  
    121121} sensors_bus; 
    122122 
    123 /* Internal data about a single chip feature. 
    124    name is the string name used to refer to this feature (both in config 
    125      files and through user functions); 
    126    number is the internal feature number, used in many functions to refer 
    127      to this feature 
    128    mapping is either SENSORS_NO_MAPPING if this is feature is the 
    129      main element of category; or it is the number of a feature with which 
    130      this feature is logically grouped (a group could be fan, fan_max and 
    131      fan_div) 
    132    flags is a bitfield, its value is a combination of SENSORS_MODE_R (readable), 
    133      SENSORS_MODE_W (writable) and SENSORS_COMPUTE_MAPPING (affected by the 
    134      computation rules of the main feature). */ 
    135 typedef struct sensors_chip_feature { 
    136         sensors_feature_data data; 
    137 } sensors_chip_feature; 
    138  
    139123/* Internal data about all features of a type of chip */ 
    140124typedef struct sensors_chip_features { 
    141125        struct sensors_chip_name chip; 
    142         struct sensors_chip_feature *feature; 
     126        struct sensors_feature_data *feature; 
    143127        int feature_count; 
    144128} sensors_chip_features; 
  • lm-sensors/branches/lm-sensors-3.0.0/lib/init.c

    r4778 r4830  
    5858 
    5959        for (i = 0; i < features->feature_count; i++) 
    60                 free(features->feature[i].data.name); 
     60                free(features->feature[i].name); 
    6161        free(features->feature); 
    6262} 
  • lm-sensors/branches/lm-sensors-3.0.0/lib/sensors.h

    r4826 r4830  
    164164} sensors_feature_type; 
    165165 
    166 /* This structure is used when you want to get all features of a specific 
    167    chip. */ 
     166/* Data about a single chip feature: 
     167   name is the string name used to refer to this feature (in config files) 
     168   number is the internal feature number, used in many functions to refer 
     169     to this feature 
     170   type is the feature or subfeature type 
     171   mapping is either SENSORS_NO_MAPPING if this is feature is the 
     172     main element of category; or it is the number of a feature with which 
     173     this subfeature is logically grouped (a group could be fan, fan_min 
     174     and fan_div) 
     175   flags is a bitfield, its value is a combination of SENSORS_MODE_R (readable), 
     176     SENSORS_MODE_W (writable) and SENSORS_COMPUTE_MAPPING (affected by the 
     177     computation rules of the main feature) */ 
    168178typedef struct sensors_feature_data { 
    169179        char *name; 
  • lm-sensors/branches/lm-sensors-3.0.0/lib/sysfs.c

    r4829 r4830  
    162162        struct sysfs_attribute *attr; 
    163163        struct dlist *attrs; 
    164         sensors_chip_feature *features; 
    165         sensors_chip_feature *dyn_features; 
     164        sensors_feature_data *features; 
     165        sensors_feature_data *dyn_features; 
    166166 
    167167        attrs = sysfs_get_device_attributes(sysdir); 
     
    173173           so that we can store them sorted at type and index and then later 
    174174           create a dense sorted table. */ 
    175         features = calloc(ALL_POSSIBLE_FEATURES, sizeof(sensors_chip_feature)); 
     175        features = calloc(ALL_POSSIBLE_FEATURES, sizeof(sensors_feature_data)); 
    176176        if (!features) 
    177177                sensors_fatal_error(__FUNCTION__, "Out of memory"); 
     
    218218                } 
    219219 
    220                 if (features[i].data.name) { 
     220                if (features[i].name) { 
    221221                        fprintf(stderr, "libsensors error, trying to add dupli" 
    222222                                "cate feature: %s to dynamic feature table\n", 
     
    226226 
    227227                /* fill in the feature members */ 
    228                 features[i].data.type = type; 
     228                features[i].type = type; 
    229229 
    230230                /* check for _input extension and remove */ 
    231231                nr = strlen(name); 
    232232                if (nr > 6 && !strcmp(name + nr - 6, "_input")) 
    233                         features[i].data.name = strndup(name, nr - 6); 
     233                        features[i].name = strndup(name, nr - 6); 
    234234                else 
    235                         features[i].data.name = strdup(name); 
     235                        features[i].name = strdup(name); 
    236236 
    237237                if ((type & 0x00FF) == 0) { 
    238238                        /* main feature */ 
    239                         features[i].data.mapping = SENSORS_NO_MAPPING; 
     239                        features[i].mapping = SENSORS_NO_MAPPING; 
    240240                } else { 
    241241                        /* sub feature */ 
    242242                        /* The mapping is set below after numbering */ 
    243243                        if (!(type & 0x10)) 
    244                                 features[i].data.flags |= SENSORS_COMPUTE_MAPPING; 
     244                                features[i].flags |= SENSORS_COMPUTE_MAPPING; 
    245245                } 
    246246 
    247247                if (attr->method & SYSFS_METHOD_SHOW) 
    248                         features[i].data.flags |= SENSORS_MODE_R; 
     248                        features[i].flags |= SENSORS_MODE_R; 
    249249                if (attr->method & SYSFS_METHOD_STORE) 
    250                         features[i].data.flags |= SENSORS_MODE_W; 
     250                        features[i].flags |= SENSORS_MODE_W; 
    251251 
    252252                fnum++; 
     
    258258        } 
    259259 
    260         dyn_features = calloc(fnum, sizeof(sensors_chip_feature)); 
     260        dyn_features = calloc(fnum, sizeof(sensors_feature_data)); 
    261261        if (dyn_features == NULL) { 
    262262                sensors_fatal_error(__FUNCTION__, "Out of memory"); 
     
    265265        fnum = 0; 
    266266        for (i = 0; i < ALL_POSSIBLE_FEATURES; i++) { 
    267                 if (features[i].data.name) { 
     267                if (features[i].name) { 
    268268                        dyn_features[fnum] = features[i]; 
    269269                        fnum++; 
     
    276276                int j; 
    277277 
    278                 dyn_features[i].data.number = i; 
    279                 if (dyn_features[i].data.mapping == SENSORS_NO_MAPPING) { 
     278                dyn_features[i].number = i; 
     279                if (dyn_features[i].mapping == SENSORS_NO_MAPPING) { 
    280280                        /* Main feature, set the mapping field of all its 
    281281                           subfeatures */ 
    282282                        for (j = i + 1; j < fnum && 
    283                              dyn_features[j].data.mapping != SENSORS_NO_MAPPING; 
     283                             dyn_features[j].mapping != SENSORS_NO_MAPPING; 
    284284                             j++) 
    285                                 dyn_features[j].data.mapping = i; 
     285                                dyn_features[j].mapping = i; 
    286286                } 
    287287        } 
     
    514514                            double *value) 
    515515{ 
    516         const sensors_chip_feature *the_feature; 
     516        const sensors_feature_data *the_feature; 
    517517        char n[NAME_MAX]; 
    518518        FILE *f; 
     
    523523 
    524524        /* REVISIT: this is a ugly hack */ 
    525         if (the_feature->data.type == SENSORS_FEATURE_IN 
    526          || the_feature->data.type == SENSORS_FEATURE_FAN 
    527          || the_feature->data.type == SENSORS_FEATURE_TEMP) 
     525        if (the_feature->type == SENSORS_FEATURE_IN 
     526         || the_feature->type == SENSORS_FEATURE_FAN 
     527         || the_feature->type == SENSORS_FEATURE_TEMP) 
    528528                suffix = "_input"; 
    529529 
    530         snprintf(n, NAME_MAX, "%s/%s%s", name->path, the_feature->data.name, 
     530        snprintf(n, NAME_MAX, "%s/%s%s", name->path, the_feature->name, 
    531531                 suffix); 
    532532        if ((f = fopen(n, "r"))) { 
     
    535535                if (res != 1) 
    536536                        return -SENSORS_ERR_PROC; 
    537                 *value /= get_type_scaling(the_feature->data.type); 
     537                *value /= get_type_scaling(the_feature->type); 
    538538        } else 
    539539                return -SENSORS_ERR_PROC; 
     
    545545                             double value) 
    546546{ 
    547         const sensors_chip_feature *the_feature; 
     547        const sensors_feature_data *the_feature; 
    548548        char n[NAME_MAX]; 
    549549        FILE *f; 
     
    554554 
    555555        /* REVISIT: this is a ugly hack */ 
    556         if (the_feature->data.type == SENSORS_FEATURE_IN 
    557          || the_feature->data.type == SENSORS_FEATURE_FAN 
    558          || the_feature->data.type == SENSORS_FEATURE_TEMP) 
     556        if (the_feature->type == SENSORS_FEATURE_IN 
     557         || the_feature->type == SENSORS_FEATURE_FAN 
     558         || the_feature->type == SENSORS_FEATURE_TEMP) 
    559559                suffix = "_input"; 
    560560 
    561         snprintf(n, NAME_MAX, "%s/%s%s", name->path, the_feature->data.name, 
     561        snprintf(n, NAME_MAX, "%s/%s%s", name->path, the_feature->name, 
    562562                 suffix); 
    563563        if ((f = fopen(n, "w"))) { 
    564                 value *= get_type_scaling(the_feature->data.type); 
     564                value *= get_type_scaling(the_feature->type); 
    565565                fprintf(f, "%d", (int) value); 
    566566                fclose(f);