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

Revision 4900, 11.7 KB (checked in by khali, 7 years ago)

The lm-sensors team has no legal existence and thus can't hold a copyright.
I tried to assign the copyright back to the original author where possible.

  • 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> and
4                             Mark D. Studebaker <mdsxyz123@yahoo.com>
5    Copyright (C) 2007       Jean Delvare <khali@linux-fr.org>
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#include "lib/error.h"
30
31void print_chip_raw(const sensors_chip_name *name)
32{
33        int a, b, err;
34        const sensors_feature *feature;
35        const sensors_subfeature *sub;
36        char *label;
37        double val;
38
39        a = 0;
40        while ((feature = sensors_get_features(name, &a))) {
41                if (!(label = sensors_get_label(name, feature))) {
42                        fprintf(stderr, "ERROR: Can't get label of feature "
43                                "%s!\n", feature->name);
44                        continue;
45                }
46                printf("%s:\n", label);
47                free(label);
48
49                b = 0;
50                while ((sub = sensors_get_all_subfeatures(name, feature, &b))) {
51                        if (sub->flags & SENSORS_MODE_R) {
52                                if ((err = sensors_get_value(name, sub->number,
53                                                             &val)))
54                                        fprintf(stderr, "ERROR: Can't get "
55                                                "value of subfeature %s: %s\n",
56                                                sub->name,
57                                                sensors_strerror(err));
58                                else
59                                        printf("  %s: %.2f\n", sub->name, val);
60                        } else
61                                printf("(%s)\n", label);
62                }
63        }
64}
65
66static inline double deg_ctof(double cel)
67{
68        return cel * (9.0F / 5.0F) + 32.0F;
69}
70
71static void print_label(const char *label, int space)
72{
73        int len = strlen(label)+1;
74        printf("%s:%*s", label, space - len, "");
75}
76
77static double get_value(const sensors_chip_name *name,
78                        const sensors_subfeature *sub)
79{
80        double val;
81        int err;
82
83        err = sensors_get_value(name, sub->number, &val);
84        if (err) {
85                fprintf(stderr, "ERROR: Can't get value of subfeature %s: %s\n",
86                        sub->name, sensors_strerror(err));
87                val = 0;
88        }
89        return val;
90}
91
92static int get_label_size(const sensors_chip_name *name)
93{
94        int i;
95        const sensors_feature *iter;
96        char *label;
97        unsigned int max_size = 11;     /* 11 as minumum label width */
98
99        i = 0;
100        while ((iter = sensors_get_features(name, &i))) {
101                if ((label = sensors_get_label(name, iter)) &&
102                    strlen(label) > max_size)
103                        max_size = strlen(label);
104                free(label);
105        }
106        return max_size + 1;
107}
108
109static void print_temp_limits(double limit1, double limit2,
110                              const char *name1, const char *name2, int alarm)
111{
112        if (fahrenheit) {
113                limit1 = deg_ctof(limit1);
114                limit2 = deg_ctof(limit2);
115        }
116
117        if (name2) {
118                printf("(%-4s = %+5.1f%s, %-4s = %+5.1f%s)  ",
119                       name1, limit1, degstr,
120                       name2, limit2, degstr);
121        } else if (name1) {
122                printf("(%-4s = %+5.1f%s)                  ",
123                       name1, limit1, degstr);
124        } else {
125                printf("                                  ");
126        }
127
128        if (alarm)
129                printf("ALARM  ");
130}
131
132static void print_chip_temp(const sensors_chip_name *name,
133                            const sensors_feature *feature,
134                            int label_size)
135{
136        const sensors_subfeature *sf, *sfmin, *sfmax, *sfcrit, *sfhyst;
137        double val, limit1, limit2;
138        const char *s1, *s2;
139        int alarm, crit_displayed = 0;
140        char *label;
141
142        if (!(label = sensors_get_label(name, feature))) {
143                fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
144                        feature->name);
145                return;
146        }
147        print_label(label, label_size);
148        free(label);
149
150        sf = sensors_get_subfeature(name, feature,
151                                    SENSORS_SUBFEATURE_TEMP_INPUT);
152        val = sf ? get_value(name, sf) : 0;
153
154        sf = sensors_get_subfeature(name, feature,
155                                    SENSORS_SUBFEATURE_TEMP_ALARM);
156        alarm = sf && get_value(name, sf);
157
158        sfmin = sensors_get_subfeature(name, feature,
159                                       SENSORS_SUBFEATURE_TEMP_MIN);
160        sfmax = sensors_get_subfeature(name, feature,
161                                       SENSORS_SUBFEATURE_TEMP_MAX);
162        sfcrit = sensors_get_subfeature(name, feature,
163                                        SENSORS_SUBFEATURE_TEMP_CRIT);
164        if (sfmax) {
165                sf = sensors_get_subfeature(name, feature,
166                                        SENSORS_SUBFEATURE_TEMP_MAX_ALARM);
167                if (sf && get_value(name, sf))
168                        alarm |= 1;
169
170                if (sfmin) {
171                        limit1 = get_value(name, sfmin);
172                        s1 = "low";
173                        limit2 = get_value(name, sfmax);
174                        s2 = "high";
175
176                        sf = sensors_get_subfeature(name, feature,
177                                        SENSORS_SUBFEATURE_TEMP_MIN_ALARM);
178                        if (sf && get_value(name, sf))
179                                alarm |= 1;
180                } else {
181                        limit1 = get_value(name, sfmax);
182                        s1 = "high";
183
184                        sfhyst = sensors_get_subfeature(name, feature,
185                                        SENSORS_SUBFEATURE_TEMP_MAX_HYST);
186                        if (sfhyst) {
187                                limit2 = get_value(name, sfhyst);
188                                s2 = "hyst";
189                        } else if (sfcrit) {
190                                limit2 = get_value(name, sfcrit);
191                                s2 = "crit";
192
193                                sf = sensors_get_subfeature(name, feature,
194                                        SENSORS_SUBFEATURE_TEMP_CRIT_ALARM);
195                                if (sf && get_value(name, sf))
196                                        alarm |= 1;
197                                crit_displayed = 1;
198                        } else {
199                                limit2 = 0;
200                                s2 = NULL;
201                        }
202                }
203        } else if (sfcrit) {
204                limit1 = get_value(name, sfcrit);
205                s1 = "crit";
206
207                sfhyst = sensors_get_subfeature(name, feature,
208                                        SENSORS_SUBFEATURE_TEMP_CRIT_HYST);
209                if (sfhyst) {
210                        limit2 = get_value(name, sfhyst);
211                        s2 = "hyst";
212                } else {
213                        limit2 = 0;
214                        s2 = NULL;
215                }
216
217                sf = sensors_get_subfeature(name, feature,
218                                        SENSORS_SUBFEATURE_TEMP_CRIT_ALARM);
219                if (sf && get_value(name, sf))
220                        alarm |= 1;
221                crit_displayed = 1;
222        } else {
223                limit1 = limit2 = 0;
224                s1 = s2 = NULL;
225        }
226
227
228        sf = sensors_get_subfeature(name, feature,
229                                    SENSORS_SUBFEATURE_TEMP_FAULT);
230        if (sf && get_value(name, sf)) {
231                printf("   FAULT  ");
232        } else {
233                if (fahrenheit)
234                        val = deg_ctof(val);
235                printf("%+6.1f%s  ", val, degstr);
236        }
237        print_temp_limits(limit1, limit2, s1, s2, alarm);
238
239        if (!crit_displayed && sfcrit) {
240                limit1 = get_value(name, sfcrit);
241                s1 = "crit";
242
243                sfhyst = sensors_get_subfeature(name, feature,
244                                        SENSORS_SUBFEATURE_TEMP_CRIT_HYST);
245                if (sfhyst) {
246                        limit2 = get_value(name, sfhyst);
247                        s2 = "hyst";
248                } else {
249                        limit2 = 0;
250                        s2 = NULL;
251                }
252
253                sf = sensors_get_subfeature(name, feature,
254                                        SENSORS_SUBFEATURE_TEMP_CRIT_ALARM);
255                alarm = sf && get_value(name, sf);
256
257                printf("\n%*s", label_size + 10, "");
258                print_temp_limits(limit1, limit2, s1, s2, alarm);
259        }
260
261        /* print out temperature sensor info */
262        sf = sensors_get_subfeature(name, feature,
263                                    SENSORS_SUBFEATURE_TEMP_TYPE);
264        if (sf) {
265                int sens = (int)get_value(name, sf);
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
283static void print_chip_in(const sensors_chip_name *name,
284                          const sensors_feature *feature,
285                          int label_size)
286{
287        const sensors_subfeature *sf, *sfmin, *sfmax;
288        double val, alarm_max, alarm_min;
289        char *label;
290
291        if (!(label = sensors_get_label(name, feature))) {
292                fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
293                        feature->name);
294                return;
295        }
296        print_label(label, label_size);
297        free(label);
298
299        sf = sensors_get_subfeature(name, feature,
300                                    SENSORS_SUBFEATURE_IN_INPUT);
301        val = sf ? get_value(name, sf) : 0;
302        printf("%+6.2f V", val);
303
304        sfmin = sensors_get_subfeature(name, feature,
305                                       SENSORS_SUBFEATURE_IN_MIN);
306        sfmax = sensors_get_subfeature(name, feature,
307                                       SENSORS_SUBFEATURE_IN_MAX);
308        if (sfmin && sfmax)
309                printf("  (min = %+6.2f V, max = %+6.2f V)",
310                       get_value(name, sfmin),
311                       get_value(name, sfmax));
312        else if (sfmin)
313                printf("  (min = %+6.2f V)",
314                       get_value(name, sfmin));
315        else if (sfmax)
316                printf("  (max = %+6.2f V)",
317                       get_value(name, sfmax));
318
319        sf = sensors_get_subfeature(name, feature,
320                                    SENSORS_SUBFEATURE_IN_ALARM);
321        sfmin = sensors_get_subfeature(name, feature,
322                                       SENSORS_SUBFEATURE_IN_MIN_ALARM);
323        sfmax = sensors_get_subfeature(name, feature,
324                                       SENSORS_SUBFEATURE_IN_MAX_ALARM);
325        if (sfmin || sfmax) {
326                alarm_max = sfmax ? get_value(name, sfmax) : 0;
327                alarm_min = sfmin ? get_value(name, sfmin) : 0;
328
329                if (alarm_min || alarm_max) {
330                        printf(" ALARM (");
331
332                        if (alarm_min)
333                                printf("MIN");
334                        if (alarm_max)
335                                printf("%sMAX", (alarm_min) ? ", " : "");
336
337                        printf(")");
338                }
339        } else if (sf) {
340                printf("   %s",
341                       get_value(name, sf) ? "ALARM" : "");
342        }
343
344        printf("\n");
345}
346
347static void print_chip_fan(const sensors_chip_name *name,
348                           const sensors_feature *feature,
349                           int label_size)
350{
351        const sensors_subfeature *sf, *sfmin, *sfdiv;
352        char *label;
353        double val;
354
355        if (!(label = sensors_get_label(name, feature))) {
356                fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
357                        feature->name);
358                return;
359        }
360        print_label(label, label_size);
361        free(label);
362
363        sf = sensors_get_subfeature(name, feature,
364                                    SENSORS_SUBFEATURE_FAN_INPUT);
365        val = sf ? get_value(name, sf) : 0;
366        sf = sensors_get_subfeature(name, feature,
367                                    SENSORS_SUBFEATURE_FAN_FAULT);
368        if (sf && get_value(name, sf))
369                printf("   FAULT");
370        else
371                printf("%4.0f RPM", val);
372
373        sfmin = sensors_get_subfeature(name, feature,
374                                       SENSORS_SUBFEATURE_FAN_MIN);
375        sfdiv = sensors_get_subfeature(name, feature,
376                                       SENSORS_SUBFEATURE_FAN_DIV);
377        if (sfmin && sfdiv)
378                printf("  (min = %4.0f RPM, div = %1.0f)",
379                       get_value(name, sfmin),
380                       get_value(name, sfdiv));
381        else if (sfmin)
382                printf("  (min = %4.0f RPM)",
383                       get_value(name, sfmin));
384        else if (sfdiv)
385                printf("  (div = %1.0f)",
386                       get_value(name, sfdiv));
387
388        sf = sensors_get_subfeature(name, feature,
389                                    SENSORS_SUBFEATURE_FAN_ALARM);
390        if (sf && get_value(name, sf)) {
391                printf("  ALARM");
392        }
393
394        printf("\n");
395}
396
397static void print_chip_vid(const sensors_chip_name *name,
398                           const sensors_feature *feature,
399                           int label_size)
400{
401        char *label;
402        const sensors_subfeature *subfeature;
403        double vid;
404
405        subfeature = sensors_get_subfeature(name, feature,
406                                            SENSORS_SUBFEATURE_VID);
407        if (!subfeature)
408                return;
409
410        if ((label = sensors_get_label(name, feature))
411         && !sensors_get_value(name, subfeature->number, &vid)) {
412                print_label(label, label_size);
413                printf("%+6.3f V\n", vid);
414        }
415        free(label);
416}
417
418static void print_chip_beep_enable(const sensors_chip_name *name,
419                                   const sensors_feature *feature,
420                                   int label_size)
421{
422        char *label;
423        const sensors_subfeature *subfeature;
424        double beep_enable;
425
426        subfeature = sensors_get_subfeature(name, feature,
427                                            SENSORS_SUBFEATURE_BEEP_ENABLE);
428        if (!subfeature)
429                return;
430
431        if ((label = sensors_get_label(name, feature))
432         && !sensors_get_value(name, subfeature->number, &beep_enable)) {
433                print_label(label, label_size);
434                printf("%s\n", beep_enable ? "enabled" : "disabled");
435        }
436        free(label);
437}
438
439void print_chip(const sensors_chip_name *name)
440{
441        const sensors_feature *feature;
442        int i, label_size;
443
444        label_size = get_label_size(name);
445
446        i = 0;
447        while ((feature = sensors_get_features(name, &i))) {
448                switch (feature->type) {
449                case SENSORS_FEATURE_TEMP:
450                        print_chip_temp(name, feature, label_size);
451                        break;
452                case SENSORS_FEATURE_IN:
453                        print_chip_in(name, feature, label_size);
454                        break;
455                case SENSORS_FEATURE_FAN:
456                        print_chip_fan(name, feature, label_size);
457                        break;
458                case SENSORS_FEATURE_VID:
459                        print_chip_vid(name, feature, label_size);
460                        break;
461                case SENSORS_FEATURE_BEEP_ENABLE:
462                        print_chip_beep_enable(name, feature, label_size);
463                        break;
464                default:
465                        continue;
466                }
467        }
468}
Note: See TracBrowser for help on using the browser.