root/lm-sensors/branches/lm-sensors-3.0.0/prog/sensors/chips.c @ 4719

Revision 4719, 12.0 KB (checked in by khali, 7 years ago)

Avoid the conversions from double to float.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2    chips.c - Part of sensors, a user-space program for hardware monitoring
3    Copyright (c) 1998-2003 Frodo Looijaard <frodol@dds.nl>
4                            and Mark D. Studebaker <mdsxyz123@yahoo.com>
5    Copyright (c) 2003-2006 The lm_sensors team
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20*/
21
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25
26#include "main.h"
27#include "chips.h"
28#include "lib/sensors.h"
29
30static inline double deg_ctof(double cel)
31{
32        return cel * (9.0F / 5.0F) + 32.0F;
33}
34
35static void print_label(const char *label, int space)
36{
37        int len = strlen(label)+1;
38        printf("%s:%*s", label, space - len, "");
39}
40
41static void print_vid_info(const sensors_chip_name *name, int f_vid,
42                           int label_size)
43{
44        char *label;
45        double vid;
46
47        if ((label = sensors_get_label(name, f_vid))
48         && !sensors_get_value(name, f_vid, &vid)) {
49                print_label(label, label_size);
50                printf("%+6.3f V\n", vid);
51        }
52        free(label);
53}
54
55void print_chip_raw(const sensors_chip_name *name)
56{
57        int a;
58        const sensors_feature_data *data;
59        char *label;
60        double val;
61
62        a = 0;
63        while ((data = sensors_get_all_features(name, &a))) {
64                if (!(label = sensors_get_label(name, data->number))) {
65                        printf("ERROR: Can't get feature `%s' data!\n",
66                               data->name);
67                        continue;
68                }
69                if (data->mode & SENSORS_MODE_R) {
70                        if (sensors_get_value(name, data->number, &val)) {
71                                printf("ERROR: Can't get feature `%s' data!\n",
72                                       data->name);
73                                continue;
74                        }
75                        if (data->mapping != SENSORS_NO_MAPPING)
76                                printf("  %s: %.2f (%s)\n", label, val,
77                                       data->name);
78                        else
79                                printf("%s: %.2f (%s)\n", label, val,
80                                       data->name);
81                } else
82                        printf("(%s)\n", label);
83                free(label);
84        }
85}
86
87static int get_feature_value(const sensors_chip_name *name,
88                             const sensors_feature_data *feature,
89                             double *val)
90{
91        return sensors_get_value(name, feature->number, val);
92}
93
94static void sensors_get_available_features(const sensors_chip_name *name,
95                                           const sensors_feature_data *feature,
96                                           int i, short *has_features,
97                                           double *feature_vals, int size,
98                                           int first_val)
99{
100        const sensors_feature_data *iter;
101
102        while ((iter = sensors_get_all_features(name, &i)) &&
103               iter->mapping == feature->number) {
104                int indx;
105
106                indx = iter->type - first_val - 1;
107                if (indx < 0 || indx >= size) {
108                        printf("ERROR: Bug in sensors: index out of bound");
109                        return;
110                }
111
112                if (get_feature_value(name, iter, &feature_vals[indx]))
113                        printf("ERROR: Can't get %s data!\n", iter->name);
114
115                has_features[indx] = 1;
116        }
117}
118
119static int sensors_get_label_size(const sensors_chip_name *name)
120{
121        int i;
122        const sensors_feature_data *iter;
123        char *label;
124        unsigned int max_size = 11;     /* 11 as minumum label width */
125
126        i = 0;
127        while ((iter = sensors_get_all_features(name, &i))) {
128                if (iter->mapping != SENSORS_NO_MAPPING)
129                        continue;
130                if ((label = sensors_get_label(name, iter->number)) &&
131                    strlen(label) > max_size)
132                        max_size = strlen(label);
133                free(label);
134        }
135        return max_size + 1;
136}
137
138static void print_temp_limits(double limit1, double limit2,
139                              const char *name1, const char *name2, int alarm)
140{
141        if (fahrenheit) {
142                limit1 = deg_ctof(limit1);
143                limit2 = deg_ctof(limit2);
144        }
145
146        if (name2) {
147                printf("(%-4s = %+5.1f%s, %-4s = %+5.1f%s)  ",
148                       name1, limit1, degstr,
149                       name2, limit2, degstr);
150        } else if (name1) {
151                printf("(%-4s = %+5.1f%s)                  ",
152                       name1, limit1, degstr);
153        } else {
154                printf("                                  ");
155        }
156
157        if (alarm)
158                printf("ALARM  ");
159}
160
161#define TEMP_FEATURE(x)         has_features[x - SENSORS_FEATURE_TEMP - 1]
162#define TEMP_FEATURE_VAL(x)     feature_vals[x - SENSORS_FEATURE_TEMP - 1]
163static void print_generic_chip_temp(const sensors_chip_name *name,
164                                    const sensors_feature_data *feature,
165                                    int i, int label_size)
166{
167        double val, limit1, limit2;
168        const char *s1, *s2;
169        int alarm, crit_displayed = 0;
170        char *label;
171        const int size = SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP;
172        short has_features[SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP] = { 0, };
173        double feature_vals[SENSORS_FEATURE_TEMP_SENS - SENSORS_FEATURE_TEMP] = { 0.0, };
174
175        if (!(label = sensors_get_label(name, feature->number))) {
176                printf("ERROR: Can't get temperature label!\n");
177                return;
178        }
179
180        if (get_feature_value(name, feature, &val)) {
181                printf("ERROR: Can't get %s data!\n", label);
182                free(label);
183                return;
184        }
185
186        sensors_get_available_features(name, feature, i, has_features,
187                                       feature_vals, size,
188                                       SENSORS_FEATURE_TEMP);
189
190        alarm = TEMP_FEATURE(SENSORS_FEATURE_TEMP_ALARM) &&
191                TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_ALARM);
192        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX)) {
193                if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_ALARM) &&
194                    TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX_ALARM))
195                        alarm |= 1;
196
197                if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN)) {
198                        limit1 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MIN);
199                        s1 = "low";
200                        limit2 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX);
201                        s2 = "high";
202
203                        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MIN_ALARM) &&
204                            TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MIN_ALARM))
205                                alarm |= 1;
206                } else {
207                        limit1 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX);
208                        s1 = "high";
209
210                        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_MAX_HYST)) {
211                                limit2 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_MAX_HYST);
212                                s2 = "hyst";
213                        } else if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) {
214                                limit2 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT);
215                                s2 = "crit";
216
217                                if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) &&
218                                    TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM))
219                                        alarm |= 1;
220                                crit_displayed = 1;
221                        } else {
222                                limit2 = 0;
223                                s2 = NULL;
224                        }
225                }
226        } else {
227                limit1 = limit2 = 0;
228                s1 = s2 = NULL;
229        }
230
231        print_label(label, label_size);
232        free(label);
233
234        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_FAULT) &&
235            TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_FAULT)) {
236                printf("   FAULT  ");
237        } else {
238                if (fahrenheit)
239                        val = deg_ctof(val);
240                printf("%+6.1f%s  ", val, degstr);
241        }
242        print_temp_limits(limit1, limit2, s1, s2, alarm);
243
244        if (!crit_displayed && TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT)) {
245                limit1 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT);
246                s1 = "crit";
247
248                if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_HYST)) {
249                        limit2 = TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_HYST);
250                        s2 = "hyst";
251                } else {
252                        limit2 = 0;
253                        s2 = NULL;
254                }
255
256                alarm = TEMP_FEATURE(SENSORS_FEATURE_TEMP_CRIT_ALARM) &&
257                        TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_CRIT_ALARM);
258
259                printf("\n%*s", label_size + 10, "");
260                print_temp_limits(limit1, limit2, s1, s2, alarm);
261        }
262
263        /* print out temperature sensor info */
264        if (TEMP_FEATURE(SENSORS_FEATURE_TEMP_SENS)) {
265                int sens = (int)TEMP_FEATURE_VAL(SENSORS_FEATURE_TEMP_SENS);
266
267                /* older kernels / drivers sometimes report a beta value for
268                   thermistors */
269                if (sens > 1000)
270                        sens = 4;
271
272                printf("sensor = %s", sens == 0 ? "disabled" :
273                       sens == 1 ? "diode" :
274                       sens == 2 ? "transistor" :
275                       sens == 3 ? "thermal diode" :
276                       sens == 4 ? "thermistor" :
277                       sens == 5 ? "AMD AMDSI" :
278                       sens == 6 ? "Intel PECI" : "unknown");
279        }
280        printf("\n");
281}
282
283#define IN_FEATURE(x)           has_features[x - SENSORS_FEATURE_IN - 1]
284#define IN_FEATURE_VAL(x)       feature_vals[x - SENSORS_FEATURE_IN - 1]
285static void print_generic_chip_in(const sensors_chip_name *name,
286                                  const sensors_feature_data *feature,
287                                  int i, int label_size)
288{
289        const int size = SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN;
290        short has_features[SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN] = { 0, };
291        double feature_vals[SENSORS_FEATURE_IN_MAX_ALARM - SENSORS_FEATURE_IN] = { 0.0, };
292        double val, alarm_max, alarm_min;
293        char *label;
294
295        if (!(label = sensors_get_label(name, feature->number))) {
296                printf("ERROR: Can't get in label!\n");
297                return;
298        }
299
300        if (get_feature_value(name, feature, &val)) {
301                printf("ERROR: Can't get %s data!\n", label);
302                free(label);
303                return;
304        }
305
306        sensors_get_available_features(name, feature, i, has_features,
307                                       feature_vals, size, SENSORS_FEATURE_IN);
308
309        print_label(label, label_size);
310        free(label);
311        printf("%+6.2f V", val);
312
313        if (IN_FEATURE(SENSORS_FEATURE_IN_MIN) &&
314            IN_FEATURE(SENSORS_FEATURE_IN_MAX))
315                printf("  (min = %+6.2f V, max = %+6.2f V)",
316                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN),
317                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX));
318        else if (IN_FEATURE(SENSORS_FEATURE_IN_MIN))
319                printf("  (min = %+6.2f V)",
320                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN));
321        else if (IN_FEATURE(SENSORS_FEATURE_IN_MAX))
322                printf("  (max = %+6.2f V)",
323                       IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX));
324
325        if (IN_FEATURE(SENSORS_FEATURE_IN_MAX_ALARM) ||
326            IN_FEATURE(SENSORS_FEATURE_IN_MIN_ALARM)) {
327                alarm_max = IN_FEATURE_VAL(SENSORS_FEATURE_IN_MAX_ALARM);
328                alarm_min = IN_FEATURE_VAL(SENSORS_FEATURE_IN_MIN_ALARM);
329
330                if (alarm_min || alarm_max) {
331                        printf(" ALARM (");
332
333                        if (alarm_min)
334                                printf("MIN");
335                        if (alarm_max)
336                                printf("%sMAX", (alarm_min) ? ", " : "");
337
338                        printf(")");
339                }
340        } else if (IN_FEATURE(SENSORS_FEATURE_IN_ALARM)) {
341                printf("   %s",
342                IN_FEATURE_VAL(SENSORS_FEATURE_IN_ALARM) ? "ALARM" : "");
343        }
344
345        printf("\n");
346}
347
348#define FAN_FEATURE(x)          has_features[x - SENSORS_FEATURE_FAN - 1]
349#define FAN_FEATURE_VAL(x)      feature_vals[x - SENSORS_FEATURE_FAN - 1]
350static void print_generic_chip_fan(const sensors_chip_name *name,
351                                   const sensors_feature_data *feature,
352                                   int i, int label_size)
353{
354        char *label;
355        const int size = SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN;
356        short has_features[SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN] = { 0, };
357        double feature_vals[SENSORS_FEATURE_FAN_DIV - SENSORS_FEATURE_FAN] = { 0.0, };
358        double val;
359
360        if (!(label = sensors_get_label(name, feature->number))) {
361                printf("ERROR: Can't get fan label!\n");
362                return;
363        }
364
365        if (get_feature_value(name, feature, &val)) {
366                printf("ERROR: Can't get %s data!\n", label);
367                free(label);
368                return;
369        }
370
371        print_label(label, label_size);
372        free(label);
373
374        if (FAN_FEATURE(SENSORS_FEATURE_FAN_FAULT) &&
375            FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_FAULT))
376                printf("   FAULT");
377        else
378                printf("%4.0f RPM", val);
379
380        sensors_get_available_features(name, feature, i, has_features,
381                                       feature_vals, size, SENSORS_FEATURE_FAN);
382
383        if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN) &&
384            FAN_FEATURE(SENSORS_FEATURE_FAN_DIV))
385                printf("  (min = %4.0f RPM, div = %1.0f)",
386                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_MIN),
387                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_DIV));
388        else if (FAN_FEATURE(SENSORS_FEATURE_FAN_MIN))
389                printf("  (min = %4.0f RPM)",
390                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_MIN));
391        else if (FAN_FEATURE(SENSORS_FEATURE_FAN_DIV))
392                printf("  (div = %1.0f)",
393                       FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_DIV));
394
395        if (FAN_FEATURE(SENSORS_FEATURE_FAN_ALARM) &&
396            FAN_FEATURE_VAL(SENSORS_FEATURE_FAN_ALARM)) {
397                printf("  ALARM");
398        }
399
400        printf("\n");
401}
402
403void print_generic_chip(const sensors_chip_name *name)
404{
405        const sensors_feature_data *feature;
406        int i, label_size;
407
408        label_size = sensors_get_label_size(name);
409
410        i = 0;
411        while ((feature = sensors_get_all_features(name, &i))) {
412                if (feature->mapping != SENSORS_NO_MAPPING)
413                        continue;
414
415                switch (feature->type) {
416                case SENSORS_FEATURE_TEMP:
417                        print_generic_chip_temp(name, feature, i, label_size);
418                        break;
419                case SENSORS_FEATURE_IN:
420                        print_generic_chip_in(name, feature, i, label_size);
421                        break;
422                case SENSORS_FEATURE_FAN:
423                        print_generic_chip_fan(name, feature, i, label_size);
424                        break;
425                case SENSORS_FEATURE_VID:
426                        print_vid_info(name, feature->number, label_size);
427                        break;
428                default:
429                        continue;
430                }
431        }
432}
Note: See TracBrowser for help on using the browser.