src/lib/lmsensor.c

   1 /*
   2     Copyright (C) 2010-2011 jeanfi@gmail.com
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17     02110-1301 USA
  18 */
  19
  20 #include <locale.h>
  21 #include <libintl.h>
  22 #define _(str) gettext(str)
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include <sensors/sensors.h>
  29 #include <sensors/error.h>
  30
  31 #include "psensor.h"
  32
  33 static double get_value(const sensors_chip_name *name,
  34                         const sensors_subfeature *sub)
  35 {
  36         double val;
  37         int err;
  38
  39         err = sensors_get_value(name, sub->number, &val);
  40         if (err) {
  41                 fprintf(stderr,
  42                         _("ERROR: Can't get value of subfeature %s: %s\n"),
  43                         sub->name, sensors_strerror(err));
  44                 val = UNKNOWN_DBL_VALUE;
  45         }
  46         return val;
  47 }
  48
  49 static double get_temp_input(struct psensor *sensor)
  50 {
  51         const sensors_chip_name *chip = sensor->iname;
  52         const sensors_feature *feature = sensor->feature;
  53
  54         const sensors_subfeature *sf;
  55
  56         sf = sensors_get_subfeature(chip,
  57                                     feature, SENSORS_SUBFEATURE_TEMP_INPUT);
  58         if (sf)
  59                 return get_value(chip, sf);
  60         else
  61                 return UNKNOWN_DBL_VALUE;
  62 }
  63
  64 static double get_fan_input(struct psensor *sensor)
  65 {
  66         const sensors_chip_name *chip = sensor->iname;
  67         const sensors_feature *feature = sensor->feature;
  68
  69         const sensors_subfeature *sf;
  70
  71         sf = sensors_get_subfeature(chip,
  72                                     feature, SENSORS_SUBFEATURE_FAN_INPUT);
  73         if (sf)
  74                 return get_value(chip, sf);
  75         else
  76                 return UNKNOWN_DBL_VALUE;
  77 }
  78
  79 void lmsensor_psensor_list_update(struct psensor **sensors)
  80 {
  81         struct psensor **s_ptr = sensors;
  82
  83         while (*s_ptr) {
  84                 struct psensor *sensor = *s_ptr;
  85
  86                 if (sensor->type == SENSOR_TYPE_LMSENSOR_TEMP)
  87                         psensor_set_current_value
  88                             (sensor, get_temp_input(sensor));
  89                 else if (sensor->type == SENSOR_TYPE_LMSENSOR_FAN)
  90                         psensor_set_current_value(sensor,
  91                                                   get_fan_input(sensor));
  92
  93                 s_ptr++;
  94         }
  95 }
  96
  97 struct psensor *
  98 lmsensor_psensor_create(const sensors_chip_name *chip,
  99                         const sensors_feature *feature,
 100                         int values_max_length)
 101 {
 102         char name[200];
 103         const sensors_subfeature *sf;
 104         char *label;
 105         int type;
 106         char *id;
 107         struct psensor *psensor;
 108         sensors_subfeature_type fault_subfeature;
 109
 110         if (sensors_snprintf_chip_name(name, 200, chip) < 0)
 111                 return NULL;
 112
 113         if (feature->type == SENSORS_FEATURE_TEMP) {
 114                 fault_subfeature = SENSORS_SUBFEATURE_TEMP_FAULT;
 115
 116         } else if (feature->type == SENSORS_FEATURE_FAN) {
 117                 fault_subfeature = SENSORS_SUBFEATURE_FAN_FAULT;
 118
 119         } else {
 120                 fprintf(stderr,
 121                         _("ERROR: create_sensor, wrong feature type\n"));
 122                 return NULL;
 123         }
 124
 125         sf = sensors_get_subfeature(chip, feature, fault_subfeature);
 126         if (sf && get_value(chip, sf))
 127                 return NULL;
 128
 129         label = sensors_get_label(chip, feature);
 130         if (!label)
 131                 return NULL;
 132
 133         type = 0;
 134         if (feature->type == SENSORS_FEATURE_TEMP)
 135                 type = SENSOR_TYPE_LMSENSOR_TEMP;
 136         else if (feature->type == SENSORS_FEATURE_FAN)
 137                 type = SENSOR_TYPE_LMSENSOR_FAN;
 138         else
 139                 return NULL;
 140
 141         id = malloc(strlen("lmsensor ") + 1 + strlen(name) + 1 + strlen(label) +
 142                     1);
 143         sprintf(id, "lmsensor %s %s", name, label);
 144
 145         psensor = psensor_create(id, label, type, values_max_length);
 146
 147         psensor->iname = chip;
 148         psensor->feature = feature;
 149
 150         if (feature->type == SENSORS_FEATURE_TEMP
 151             && (get_temp_input(psensor) == UNKNOWN_DBL_VALUE)) {
 152                 free(psensor);
 153                 return NULL;
 154         }
 155
 156         return psensor;
 157 }
 158
 159 int lmsensor_init()
 160 {
 161         int err = sensors_init(NULL);
 162
 163         if (err) {
 164                 fprintf(stderr,
 165                         _("ERROR: lm-sensors initialization failure: %s\n"),
 166                         sensors_strerror(err));
 167                 return 0;
 168         } else {
 169                 return 1;
 170         }
 171 }
 172
 173 struct psensor **lmsensor_psensor_list_add(struct psensor **sensors,
 174                                            int vn)
 175 {
 176         const sensors_chip_name *chip;
 177         int chip_nr = 0;
 178         struct psensor **tmp, **result;
 179         const sensors_feature *feature;
 180         struct psensor *s;
 181         int i;
 182
 183         result = sensors;
 184         while ((chip = sensors_get_detected_chips(NULL, &chip_nr))) {
 185
 186                 i = 0;
 187                 while ((feature = sensors_get_features(chip, &i))) {
 188
 189                         if (feature->type == SENSORS_FEATURE_TEMP
 190                             || feature->type == SENSORS_FEATURE_FAN) {
 191
 192                                 s = lmsensor_psensor_create(chip, feature, vn);
 193
 194                                 if (s) {
 195                                         tmp = psensor_list_add(result, s);
 196
 197                                         if (tmp != sensors)
 198                                                 free(result);
 199
 200                                         result = tmp;
 201                                 }
 202                         }
 203                 }
 204         }
 205
 206         return result;
 207 }