Changeset 4838

Show
Ignore:
Timestamp:
09/23/07 14:16:50 (7 years ago)
Author:
khali
Message:

Introduce a separate type for main features. Make subfeatures map to
the real main feature rather than the first subfeature.

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

Legend:

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

    r4836 r4838  
    102102                                return NULL; 
    103103                        return sensors_proc_chips[i].subfeature + subfeat_nr; 
     104                } 
     105        return NULL; 
     106} 
     107 
     108/* Look up a feature in the intern chip list, and return a pointer to it. 
     109   Do not modify the struct the return value points to! Returns NULL if 
     110   not found.*/ 
     111static const sensors_feature * 
     112sensors_lookup_feature_nr(const sensors_chip_name *chip, int feat_nr) 
     113{ 
     114        int i; 
     115 
     116        for (i = 0; i < sensors_proc_chips_count; i++) 
     117                if (sensors_match_chip(&sensors_proc_chips[i].chip, chip)) { 
     118                        if (feat_nr < 0 || 
     119                            feat_nr >= sensors_proc_chips[i].feature_count) 
     120                                return NULL; 
     121                        return sensors_proc_chips[i].feature + feat_nr; 
    104122                } 
    105123        return NULL; 
     
    209227{ 
    210228        const sensors_subfeature *subfeature; 
    211         const sensors_subfeature *alt_feature; 
     229        const sensors_feature *feature; 
    212230        const sensors_chip *chip; 
    213231        const sensors_expr *expr = NULL; 
    214232        double val; 
    215233        int res, i; 
    216         int final_expr = 0; 
    217234 
    218235        if (sensors_chip_name_has_wildcards(name)) 
     
    222239 
    223240        if (subfeature->flags & SENSORS_COMPUTE_MAPPING) 
    224                 alt_feature = sensors_lookup_subfeature_nr(name, 
     241                feature = sensors_lookup_feature_nr(name, 
    225242                                        subfeature->mapping); 
    226243        else 
    227                 alt_feature = NULL; 
     244                feature = NULL; 
    228245 
    229246        if (!(subfeature->flags & SENSORS_MODE_R)) 
     
    231248        for (chip = NULL; 
    232249             !expr && (chip = sensors_for_all_config_chips(name, chip));) 
    233                 for (i = 0; !final_expr && (i < chip->computes_count); i++) { 
    234                         if (!strcmp(subfeature->name, chip->computes[i].name)) { 
    235                                 expr = chip->computes[i].from_proc; 
    236                                 final_expr = 1; 
    237                         } else if (alt_feature && !strcmp(alt_feature->name, 
     250                for (i = 0; !expr && (i < chip->computes_count); i++) { 
     251                        if (feature && !strcmp(feature->name, 
    238252                                               chip->computes[i].name)) { 
    239253                                expr = chip->computes[i].from_proc; 
     
    256270{ 
    257271        const sensors_subfeature *subfeature; 
    258         const sensors_subfeature *alt_feature; 
     272        const sensors_feature *feature; 
    259273        const sensors_chip *chip; 
    260274        const sensors_expr *expr = NULL; 
    261275        int i, res; 
    262         int final_expr = 0; 
    263276        double to_write; 
    264277 
     
    269282 
    270283        if (subfeature->flags & SENSORS_COMPUTE_MAPPING) 
    271                 alt_feature = sensors_lookup_subfeature_nr(name, 
     284                feature = sensors_lookup_feature_nr(name, 
    272285                                        subfeature->mapping); 
    273286        else 
    274                 alt_feature = NULL; 
     287                feature = NULL; 
    275288 
    276289        if (!(subfeature->flags & SENSORS_MODE_W)) 
     
    278291        for (chip = NULL; 
    279292             !expr && (chip = sensors_for_all_config_chips(name, chip));) 
    280                 for (i = 0; !final_expr && (i < chip->computes_count); i++) 
    281                         if (!strcmp(subfeature->name, chip->computes[i].name)) { 
    282                                 expr = chip->computes->to_proc; 
    283                                 final_expr = 1; 
    284                         } else if (alt_feature && !strcmp(alt_feature->name, 
     293                for (i = 0; !expr && (i < chip->computes_count); i++) { 
     294                        if (feature && !strcmp(feature->name, 
    285295                                               chip->computes[i].name)) { 
    286296                                expr = chip->computes[i].to_proc; 
    287297                        } 
     298                } 
    288299 
    289300        to_write = value; 
     
    368379                                return NULL;    /* end of list */ 
    369380                        subfeature = &sensors_proc_chips[i].subfeature[(*nr)++]; 
    370                         if (subfeature->number == feature->first_subfeature || 
    371                             subfeature->mapping == feature->first_subfeature) 
     381                        if (subfeature->mapping == feature->number) 
    372382                                return subfeature; 
    373383                        return NULL;    /* end of subfeature list */ 
  • lm-sensors/branches/lm-sensors-3.0.0/lib/libsensors.3

    r4836 r4838  
    135135\fBconst sensors_subfeature *sensors_get_all_subfeatures(const sensors_chip_name *name, const sensors_feature *feature, int *nr);\fP 
    136136.br 
    137 This returns all subfeatures of a given main feature (including that 
    138 main feature itself, in first position.) nr is an internally used 
    139 variable. Set it to zero to start at the begin of the list. If no more 
    140 subfeatures are found NULL is returned. 
     137This returns all subfeatures of a given main feature. nr is an internally 
     138used variable. Set it to zero to start at the begin of the list. If no 
     139more subfeatures are found NULL is returned. 
    141140Do not try to change the returned structure; you will corrupt internal 
    142141data structures. 
  • lm-sensors/branches/lm-sensors-3.0.0/lib/sensors.h

    r4837 r4838  
    124124   mapping is available */ 
    125125#define SENSORS_NO_MAPPING -1 
     126 
     127/* These must match the subfeature constants below (shifted by 8 bits) */ 
     128typedef enum sensors_feature_type { 
     129        SENSORS_FEATURE_IN              = 0x00, 
     130        SENSORS_FEATURE_FAN             = 0x01, 
     131        SENSORS_FEATURE_TEMP            = 0x02, 
     132        SENSORS_FEATURE_VID             = 0x10, 
     133        SENSORS_FEATURE_BEEP_ENABLE     = 0x11, 
     134        SENSORS_FEATURE_UNKNOWN         = INT_MAX, 
     135} sensors_feature_type; 
    126136 
    127137/* This enum contains some "magic" used by sensors_read_dynamic_chip() from 
     
    170180struct sensors_feature { 
    171181        char *name; 
     182        int number; 
     183        sensors_feature_type type; 
    172184        int first_subfeature; 
    173         sensors_subfeature_type type; 
    174185}; 
    175186 
     
    202213sensors_get_features(const sensors_chip_name *name, int *nr); 
    203214 
    204 /* This returns all subfeatures of a given main feature (including that 
    205    main feature itself, in first position.) nr is an internally used 
    206    variable. Set it to zero to start at the begin of the list. If no more 
    207    features are found NULL is returned. 
     215/* This returns all subfeatures of a given main feature. nr is an internally 
     216   used variable. Set it to zero to start at the begin of the list. If no 
     217   more features are found NULL is returned. 
    208218   Do not try to change the returned structure; you will corrupt internal 
    209219   data structures. */ 
  • lm-sensors/branches/lm-sensors-3.0.0/lib/sysfs.c

    r4837 r4838  
    6464                return 1; 
    6565        } 
     66} 
     67 
     68static 
     69char *get_feature_name(sensors_feature_type ftype, char *sfname) 
     70{ 
     71        char *name, *underscore; 
     72 
     73        switch (ftype) { 
     74        case SENSORS_FEATURE_IN: 
     75        case SENSORS_FEATURE_FAN: 
     76        case SENSORS_FEATURE_TEMP: 
     77                underscore = strchr(sfname, '_'); 
     78                name = strndup(sfname, underscore - sfname); 
     79                break; 
     80        default: 
     81                name = strdup(sfname); 
     82        } 
     83 
     84        return name; 
    6685} 
    6786 
     
    161180                                     struct sysfs_device *sysdir) 
    162181{ 
    163         int i, type, fnum = 0; 
     182        int i, fnum = 0, sfnum = 0, prev_slot; 
    164183        struct sysfs_attribute *attr; 
    165184        struct dlist *attrs; 
     
    167186        sensors_subfeature *dyn_subfeatures; 
    168187        sensors_feature *dyn_features; 
     188        sensors_feature_type ftype; 
     189        sensors_subfeature_type sftype; 
    169190 
    170191        attrs = sysfs_get_device_attributes(sysdir); 
     
    185206                int nr; 
    186207 
    187                 type = sensors_subfeature_get_type(name, &nr); 
    188                 if (type == SENSORS_SUBFEATURE_UNKNOWN) 
     208                sftype = sensors_subfeature_get_type(name, &nr); 
     209                if (sftype == SENSORS_SUBFEATURE_UNKNOWN) 
    189210                        continue; 
    190211 
    191212                /* Adjust the channel number */ 
    192                 switch (type & 0xFF00) { 
     213                switch (sftype & 0xFF00) { 
    193214                        case SENSORS_SUBFEATURE_FAN_INPUT: 
    194215                        case SENSORS_SUBFEATURE_TEMP_INPUT: 
     
    207228                /* "calculate" a place to store the subfeature in our sparse, 
    208229                   sorted table */ 
    209                 switch (type) { 
     230                switch (sftype) { 
    210231                case SENSORS_SUBFEATURE_VID: 
    211232                        i = nr + MAX_SENSORS_PER_TYPE * MAX_SUBFEATURES * 6; 
     
    216237                        break; 
    217238                default: 
    218                         i = (type >> 8) * MAX_SENSORS_PER_TYPE * 
     239                        i = (sftype >> 8) * MAX_SENSORS_PER_TYPE * 
    219240                            MAX_SUBFEATURES * 2 + nr * MAX_SUBFEATURES * 2 + 
    220                             ((type & 0x10) >> 4) * MAX_SUBFEATURES + 
    221                             (type & 0x0F); 
     241                            ((sftype & 0x10) >> 4) * MAX_SUBFEATURES + 
     242                            (sftype & 0x0F); 
    222243                } 
    223244 
     
    230251 
    231252                /* fill in the subfeature members */ 
    232                 all_subfeatures[i].type = type; 
    233  
    234                 /* check for _input extension and remove */ 
    235                 nr = strlen(name); 
    236                 if (nr > 6 && !strcmp(name + nr - 6, "_input")) 
    237                         all_subfeatures[i].name = strndup(name, nr - 6); 
    238                 else 
    239                         all_subfeatures[i].name = strdup(name); 
    240  
    241                 if ((type & 0x00FF) == 0) { 
    242                         /* main subfeature */ 
    243                         all_subfeatures[i].mapping = SENSORS_NO_MAPPING; 
    244                 } else { 
    245                         /* The mapping is set below after numbering */ 
    246                         if (!(type & 0x10)) 
    247                                 all_subfeatures[i].flags |= SENSORS_COMPUTE_MAPPING; 
    248                 } 
    249  
     253                all_subfeatures[i].type = sftype; 
     254                all_subfeatures[i].name = strdup(name); 
     255                if (!(sftype & 0x10)) 
     256                        all_subfeatures[i].flags |= SENSORS_COMPUTE_MAPPING; 
    250257                if (attr->method & SYSFS_METHOD_SHOW) 
    251258                        all_subfeatures[i].flags |= SENSORS_MODE_R; 
     
    253260                        all_subfeatures[i].flags |= SENSORS_MODE_W; 
    254261 
    255                 fnum++; 
    256         } 
    257  
    258         if (!fnum) { /* No subfeature */ 
     262                sfnum++; 
     263        } 
     264 
     265        if (!sfnum) { /* No subfeature */ 
    259266                chip->subfeature = NULL; 
    260267                goto exit_free; 
    261268        } 
    262269 
    263         dyn_subfeatures = calloc(fnum, sizeof(sensors_subfeature)); 
    264         if (dyn_subfeatures == NULL) { 
     270        /* How many main features? */ 
     271        prev_slot = -1; 
     272        for (i = 0; i < ALL_POSSIBLE_SUBFEATURES; i++) { 
     273                if (!all_subfeatures[i].name) 
     274                        continue; 
     275 
     276                if (i >= MAX_SENSORS_PER_TYPE * MAX_SUBFEATURES * 6 || 
     277                    i / (MAX_SUBFEATURES * 2) != prev_slot) { 
     278                        fnum++; 
     279                        prev_slot = i / (MAX_SUBFEATURES * 2); 
     280                } 
     281        } 
     282 
     283        dyn_subfeatures = calloc(sfnum, sizeof(sensors_subfeature)); 
     284        dyn_features = calloc(fnum, sizeof(sensors_feature)); 
     285        if (!dyn_subfeatures || !dyn_features) 
    265286                sensors_fatal_error(__FUNCTION__, "Out of memory"); 
    266         } 
    267  
    268         fnum = 0; 
     287 
     288        /* Copy from the sparse array to the compact array */ 
     289        sfnum = 0; 
     290        fnum = -1; 
     291        prev_slot = -1; 
    269292        for (i = 0; i < ALL_POSSIBLE_SUBFEATURES; i++) { 
    270                 if (all_subfeatures[i].name) { 
    271                         dyn_subfeatures[fnum] = all_subfeatures[i]; 
     293                if (!all_subfeatures[i].name) 
     294                        continue; 
     295 
     296                /* New main feature? */ 
     297                if (i >= MAX_SENSORS_PER_TYPE * MAX_SUBFEATURES * 6 || 
     298                    i / (MAX_SUBFEATURES * 2) != prev_slot) { 
     299                        ftype = all_subfeatures[i].type >> 8; 
    272300                        fnum++; 
    273                 } 
    274         } 
    275  
    276         /* Number the subfeatures linearly, so that subfeature number N is at 
    277            position N in the array. This allows for O(1) look-ups. */ 
    278         for (i = 0; i < fnum; i++) { 
    279                 int j; 
    280  
    281                 dyn_subfeatures[i].number = i; 
    282                 if (dyn_subfeatures[i].mapping == SENSORS_NO_MAPPING) { 
    283                         /* Main feature, set the mapping field of all its 
    284                            subfeatures */ 
    285                         for (j = i + 1; j < fnum && 
    286                              dyn_subfeatures[j].mapping != SENSORS_NO_MAPPING; 
    287                              j++) 
    288                                 dyn_subfeatures[j].mapping = i; 
    289                 } 
     301                        prev_slot = i / (MAX_SUBFEATURES * 2); 
     302 
     303                        dyn_features[fnum].name = get_feature_name(ftype, 
     304                                                all_subfeatures[i].name); 
     305                        dyn_features[fnum].number = fnum; 
     306                        dyn_features[fnum].first_subfeature = sfnum; 
     307                        dyn_features[fnum].type = ftype; 
     308                } 
     309 
     310                dyn_subfeatures[sfnum] = all_subfeatures[i]; 
     311                dyn_subfeatures[sfnum].number = sfnum; 
     312                /* Back to the feature */ 
     313                dyn_subfeatures[sfnum].mapping = fnum; 
     314 
     315                sfnum++; 
    290316        } 
    291317 
    292318        chip->subfeature = dyn_subfeatures; 
    293         chip->subfeature_count = fnum; 
    294  
    295         /* And now the main features */ 
    296         fnum = 0; 
    297         for (i = 0; i < chip->subfeature_count; i++) { 
    298                 if (chip->subfeature[i].mapping == SENSORS_NO_MAPPING) 
    299                         fnum++; 
    300         } 
    301  
    302         dyn_features = calloc(fnum, sizeof(sensors_feature)); 
    303         if (dyn_features == NULL) { 
    304                 sensors_fatal_error(__FUNCTION__, "Out of memory"); 
    305         } 
    306  
    307         fnum = 0; 
    308         for (i = 0; i < chip->subfeature_count; i++) { 
    309                 if (chip->subfeature[i].mapping == SENSORS_NO_MAPPING) { 
    310                         dyn_features[fnum].name = strdup(chip->subfeature[i].name); 
    311                         dyn_features[fnum].first_subfeature = i; 
    312                         dyn_features[fnum].type = chip->subfeature[i].type; 
    313                         fnum++; 
    314                 } 
    315         } 
    316  
     319        chip->subfeature_count = sfnum; 
    317320        chip->feature = dyn_features; 
    318         chip->feature_count = fnum; 
     321        chip->feature_count = ++fnum; 
    319322 
    320323exit_free: 
     
    545548        char n[NAME_MAX]; 
    546549        FILE *f; 
    547         const char *suffix = ""; 
    548550 
    549551        if (!(subfeature = sensors_lookup_subfeature_nr(name, subfeat_nr))) 
    550552                return -SENSORS_ERR_NO_ENTRY; 
    551553 
    552         /* REVISIT: this is a ugly hack */ 
    553         if (subfeature->type == SENSORS_SUBFEATURE_IN_INPUT 
    554          || subfeature->type == SENSORS_SUBFEATURE_FAN_INPUT 
    555          || subfeature->type == SENSORS_SUBFEATURE_TEMP_INPUT) 
    556                 suffix = "_input"; 
    557  
    558         snprintf(n, NAME_MAX, "%s/%s%s", name->path, subfeature->name, 
    559                  suffix); 
     554        snprintf(n, NAME_MAX, "%s/%s", name->path, subfeature->name); 
    560555        if ((f = fopen(n, "r"))) { 
    561556                int res = fscanf(f, "%lf", value); 
     
    576571        char n[NAME_MAX]; 
    577572        FILE *f; 
    578         const char *suffix = ""; 
    579573 
    580574        if (!(subfeature = sensors_lookup_subfeature_nr(name, subfeat_nr))) 
    581575                return -SENSORS_ERR_NO_ENTRY; 
    582576 
    583         /* REVISIT: this is a ugly hack */ 
    584         if (subfeature->type == SENSORS_SUBFEATURE_IN_INPUT 
    585          || subfeature->type == SENSORS_SUBFEATURE_FAN_INPUT 
    586          || subfeature->type == SENSORS_SUBFEATURE_TEMP_INPUT) 
    587                 suffix = "_input"; 
    588  
    589         snprintf(n, NAME_MAX, "%s/%s%s", name->path, subfeature->name, 
    590                  suffix); 
     577        snprintf(n, NAME_MAX, "%s/%s", name->path, subfeature->name); 
    591578        if ((f = fopen(n, "w"))) { 
    592579                value *= get_type_scaling(subfeature->type); 
  • lm-sensors/branches/lm-sensors-3.0.0/prog/sensord/chips.c

    r4837 r4838  
    374374        while ((sensor = sensors_get_features(chip, &nr))) { 
    375375                switch (sensor->type) { 
    376                 case SENSORS_SUBFEATURE_TEMP_INPUT: 
     376                case SENSORS_FEATURE_TEMP: 
    377377                        fillChipTemperature(&features[count], chip, sensor); 
    378378                        break; 
    379                 case SENSORS_SUBFEATURE_IN_INPUT: 
     379                case SENSORS_FEATURE_IN: 
    380380                        fillChipVoltage(&features[count], chip, sensor); 
    381381                        break; 
    382                 case SENSORS_SUBFEATURE_FAN_INPUT: 
     382                case SENSORS_FEATURE_FAN: 
    383383                        fillChipFan(&features[count], chip, sensor); 
    384384                        break; 
    385                 case SENSORS_SUBFEATURE_VID: 
     385                case SENSORS_FEATURE_VID: 
    386386                        fillChipVid(&features[count], chip, sensor); 
    387387                        break; 
    388                 case SENSORS_SUBFEATURE_BEEP_ENABLE: 
     388                case SENSORS_FEATURE_BEEP_ENABLE: 
    389389                        fillChipBeepEnable(&features[count], chip, sensor); 
    390390                        break; 
  • lm-sensors/branches/lm-sensors-3.0.0/prog/sensors/chips.c

    r4837 r4838  
    436436        while ((feature = sensors_get_features(name, &i))) { 
    437437                switch (feature->type) { 
    438                 case SENSORS_SUBFEATURE_TEMP_INPUT: 
     438                case SENSORS_FEATURE_TEMP: 
    439439                        print_chip_temp(name, feature, label_size); 
    440440                        break; 
    441                 case SENSORS_SUBFEATURE_IN_INPUT: 
     441                case SENSORS_FEATURE_IN: 
    442442                        print_chip_in(name, feature, label_size); 
    443443                        break; 
    444                 case SENSORS_SUBFEATURE_FAN_INPUT: 
     444                case SENSORS_FEATURE_FAN: 
    445445                        print_chip_fan(name, feature, label_size); 
    446446                        break; 
    447                 case SENSORS_SUBFEATURE_VID: 
     447                case SENSORS_FEATURE_VID: 
    448448                        print_chip_vid(name, feature, label_size); 
    449449                        break; 
    450                 case SENSORS_SUBFEATURE_BEEP_ENABLE: 
     450                case SENSORS_FEATURE_BEEP_ENABLE: 
    451451                        print_chip_beep_enable(name, feature, label_size); 
    452452                        break;