root/lm-sensors/trunk/prog/sensors/chips.c @ 1615

Revision 1615, 138.4 KB (checked in by mds, 11 years ago)

BMC cleanup
  • 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, 1999, 2001  Frodo Looijaard <frodol@dds.nl>
4    and Mark D. Studebaker <mdsxyz123@yahoo.com>
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19*/
20
21#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
24
25#include "chips.h"
26#include "lib/sensors.h"
27#include "lib/chips.h"
28#include "kernel/include/sensors.h"
29
30static char *spacestr(int n);
31static void print_label(const char *label, int space);
32static void free_the_label(char **label);
33static void print_temp_info(float, float, float, int, int, int);
34static inline float deg_ctof( float );
35
36extern int fahrenheit;
37
38char *spacestr(int n)
39{
40  static char buf[80];
41  int i;
42  for (i = 0; i < n; i++)
43    buf[i]=' ';
44  buf[n] = '\0';
45  return buf;
46}
47
48inline float deg_ctof( float cel )
49{
50   return ( cel * ( 9.0F / 5.0F ) + 32.0F );
51}
52
53#define HYST 0
54#define MINMAX 1
55#define MAXONLY 2
56/* minmax = 0 for limit/hysteresis, 1 for max/min, 2 for max only;
57   curprec and limitprec are # of digits after decimal point
58   for the current temp and the limits */
59void print_temp_info(float n_cur, float n_over, float n_hyst,
60                     int minmax, int curprec, int limitprec)
61{
62   char degv[5];
63
64   if (fahrenheit) {
65      sprintf(degv, "%cF", 176);
66      n_cur  = deg_ctof(n_cur);
67      n_over = deg_ctof(n_over);
68      n_hyst = deg_ctof(n_hyst);
69   } else {
70      sprintf(degv, "%cC", 176);
71   }
72
73/* use %* to pass size and precision as arguments */
74   if(minmax == MINMAX)
75        printf( "%+6.*f%s  (min = %+*.*f%s, max = %+*.*f%s)",
76            curprec, n_cur, degv,
77            limitprec + 4, limitprec, n_hyst, degv,
78            limitprec + 4, limitprec, n_over, degv);
79   else if(minmax == MAXONLY)
80        printf( "%+6.*f%s  (limit = %+*.*f%s)                      ",
81            curprec, n_cur, degv,
82            limitprec + 4, limitprec, n_over, degv);
83   else /* HYST */
84        printf( "%+6.*f%s  (limit = %+*.*f%s, hysteresis = %+*.*f%s)",
85            curprec, n_cur, degv,
86            limitprec + 4, limitprec, n_over, degv,
87            limitprec + 4, limitprec, n_hyst, degv);
88}
89
90void print_label(const char *label, int space)
91{
92  int len=strlen(label)+1;
93  if (len > space)
94    printf("%s:\n%s",label,spacestr(space));
95  else
96    printf("%s:%s",label,spacestr(space - len));
97}
98
99void free_the_label(char **label)
100{
101  if (*label)
102    free(*label);
103  *label = NULL;
104}
105
106int sensors_get_label_and_valid(sensors_chip_name name, int feature, char **label,
107                        int *valid)
108{
109  int err;
110  err = sensors_get_label(name,feature,label);
111  if (!err)
112    err = sensors_get_ignored(name,feature);
113  if (err >= 0) {
114    *valid = err;
115    err = 0;
116  }
117  return err;
118}
119
120void print_ds1621(const sensors_chip_name *name)
121{
122  char *label;
123  double cur,hyst,over;
124  int alarms, valid;
125
126  if (!sensors_get_feature(*name,SENSORS_LM78_ALARMS,&cur)) 
127    alarms = cur + 0.5;
128  else {
129    printf("ERROR: Can't get alarm data!\n");
130    alarms = 0;
131  }
132
133  if (!sensors_get_label_and_valid(*name,SENSORS_DS1621_TEMP,&label,&valid) &&
134      !sensors_get_feature(*name,SENSORS_DS1621_TEMP,&cur) &&
135      !sensors_get_feature(*name,SENSORS_DS1621_TEMP_HYST,&hyst) &&
136      !sensors_get_feature(*name,SENSORS_DS1621_TEMP_OVER,&over))  {
137    if (valid) {
138      print_label(label,10);
139      print_temp_info( cur, over, hyst, MINMAX, 2, 1);
140      if (alarms & (DS1621_ALARM_TEMP_HIGH | DS1621_ALARM_TEMP_LOW)) {
141        printf("ALARM (");
142        if (alarms & DS1621_ALARM_TEMP_LOW) {
143          printf("LOW");
144        }
145        if (alarms & DS1621_ALARM_TEMP_HIGH)
146          printf("%sHIGH",(alarms & DS1621_ALARM_TEMP_LOW)?",":"");
147        printf(")");
148      }
149      printf("\n");
150    }
151  } else
152    printf("ERROR: Can't get temperature data!\n");
153  free_the_label(&label);
154}
155
156void print_lm75(const sensors_chip_name *name)
157{
158  char *label;
159  double cur,hyst,over;
160  int valid;
161
162  if (!sensors_get_label_and_valid(*name,SENSORS_LM75_TEMP,&label,&valid) &&
163      !sensors_get_feature(*name,SENSORS_LM75_TEMP,&cur) &&
164      !sensors_get_feature(*name,SENSORS_LM75_TEMP_HYST,&hyst) &&
165      !sensors_get_feature(*name,SENSORS_LM75_TEMP_OVER,&over))  {
166    if (valid) {
167      print_label(label,10);
168      print_temp_info( cur, over, hyst, HYST, 1, 1);
169      printf( "\n" );
170    }
171  } else
172    printf("ERROR: Can't get temperature data!\n");
173  free_the_label(&label);
174}
175
176void print_adm1021(const sensors_chip_name *name)
177{
178  char *label;
179  double cur,hyst,over;
180  int alarms,i,valid;
181
182  if (!sensors_get_feature(*name,SENSORS_ADM1021_ALARMS,&cur)) 
183    alarms = cur + 0.5;
184  else {
185    printf("ERROR: Can't get alarm data!\n");
186    alarms = 0;
187  }
188
189  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1021_TEMP,&label,&valid) &&
190      !sensors_get_feature(*name,SENSORS_ADM1021_TEMP,&cur) &&
191      !sensors_get_feature(*name,SENSORS_ADM1021_TEMP_HYST,&hyst) &&
192      !sensors_get_feature(*name,SENSORS_ADM1021_TEMP_OVER,&over))  {
193    if (valid) {
194      print_label(label,10);
195      print_temp_info( cur, over, hyst, MINMAX, 0, 0);
196      if (alarms & (ADM1021_ALARM_TEMP_HIGH | ADM1021_ALARM_TEMP_LOW)) {
197        printf("ALARM (");
198        i = 0;
199        if (alarms & ADM1021_ALARM_TEMP_LOW) {
200          printf("LOW");
201          i++;
202        }
203        if (alarms & ADM1021_ALARM_TEMP_HIGH)
204          printf("%sHIGH",i?",":"");
205        printf(")");
206      }
207      printf("\n");
208    }
209  } else
210    printf("ERROR: Can't get temperature data!\n");
211  free_the_label(&label);
212
213  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1021_REMOTE_TEMP,
214                                   &label,&valid) &&
215      !sensors_get_feature(*name,SENSORS_ADM1021_REMOTE_TEMP,&cur) &&
216      !sensors_get_feature(*name,SENSORS_ADM1021_REMOTE_TEMP_HYST,&hyst) &&
217      !sensors_get_feature(*name,SENSORS_ADM1021_REMOTE_TEMP_OVER,&over))  {
218    if (valid) {
219      print_label(label,10);
220      print_temp_info( cur, over, hyst, MINMAX, 0, 0);
221      if (alarms & (ADM1021_ALARM_RTEMP_HIGH | ADM1021_ALARM_RTEMP_LOW |
222                    ADM1021_ALARM_RTEMP_NA)) {
223        printf("ALARM (");
224        i = 0;
225          if (alarms & ADM1021_ALARM_RTEMP_NA) {
226          printf("N/A");
227          i++;
228        }
229        if (alarms & ADM1021_ALARM_RTEMP_LOW) {
230          printf("%sLOW",i?",":"");
231          i++;
232        }
233        if (alarms & ADM1021_ALARM_RTEMP_HIGH)
234          printf("%sHIGH",i?",":"");
235        printf(")");
236      }
237      printf("\n");
238    }
239  } else
240    printf("ERROR: Can't get temperature data!\n");
241  free_the_label(&label);
242
243  if (!strcmp(name->prefix,"adm1021")) {
244    if (!sensors_get_label_and_valid(*name,SENSORS_ADM1021_DIE_CODE,
245                                     &label,&valid) &&
246        !sensors_get_feature(*name,SENSORS_ADM1021_DIE_CODE,&cur)) {
247      if (valid) {
248        print_label(label,10);
249        printf("%4.0f\n",cur);
250      }
251    } else
252      printf("ERROR: Can't get die-code data!\n");
253    free_the_label(&label);
254  }
255}
256
257void print_adm9240(const sensors_chip_name *name)
258{
259  char *label = NULL;
260  double cur,min,max,fdiv;
261  int alarms;
262  int valid;
263
264  if (!sensors_get_feature(*name,SENSORS_ADM9240_ALARMS,&cur)) 
265    alarms = cur + 0.5;
266  else {
267    printf("ERROR: Can't get alarm data!\n");
268    alarms = 0;
269  }
270
271  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN0,&label,&valid) &&
272      !sensors_get_feature(*name,SENSORS_ADM9240_IN0,&cur) &&
273      !sensors_get_feature(*name,SENSORS_ADM9240_IN0_MIN,&min) &&
274      !sensors_get_feature(*name,SENSORS_ADM9240_IN0_MAX,&max)) {
275    if (valid) {
276      print_label(label,10);
277      printf( "%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
278             cur,min,max,alarms&ADM9240_ALARM_IN0?"ALARM":"");
279    }
280  } else
281    printf("ERROR: Can't get IN0 data!\n");
282  free_the_label(&label);
283  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN1,&label,&valid) &&
284      !sensors_get_feature(*name,SENSORS_ADM9240_IN1,&cur) &&
285      !sensors_get_feature(*name,SENSORS_ADM9240_IN1_MIN,&min) &&
286      !sensors_get_feature(*name,SENSORS_ADM9240_IN1_MAX,&max)) {
287    if (valid) {
288      print_label(label,10);
289      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
290             cur,min,max,alarms&ADM9240_ALARM_IN1?"ALARM":"");
291    }
292  } else
293    printf("ERROR: Can't get IN1 data!\n");
294  free_the_label(&label);
295  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN2,&label,&valid) &&
296      !sensors_get_feature(*name,SENSORS_ADM9240_IN2,&cur) &&
297      !sensors_get_feature(*name,SENSORS_ADM9240_IN2_MIN,&min) &&
298      !sensors_get_feature(*name,SENSORS_ADM9240_IN2_MAX,&max)) {
299    if (valid) {
300      print_label(label,10);
301      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
302             cur,min,max,alarms&ADM9240_ALARM_IN2?"ALARM":"");
303    }
304  } else
305    printf("ERROR: Can't get IN2 data!\n");
306  free_the_label(&label);
307  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN3,&label,&valid) &&
308      !sensors_get_feature(*name,SENSORS_ADM9240_IN3,&cur) &&
309      !sensors_get_feature(*name,SENSORS_ADM9240_IN3_MIN,&min) &&
310      !sensors_get_feature(*name,SENSORS_ADM9240_IN3_MAX,&max)) {
311    if (valid) {
312      print_label(label,10);
313      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
314             cur,min,max,alarms&ADM9240_ALARM_IN3?"ALARM":"");
315    }
316  } else
317    printf("ERROR: Can't get IN3 data!\n");
318  free_the_label(&label);
319  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN4,&label,&valid) &&
320      !sensors_get_feature(*name,SENSORS_ADM9240_IN4,&cur) &&
321      !sensors_get_feature(*name,SENSORS_ADM9240_IN4_MIN,&min) &&
322      !sensors_get_feature(*name,SENSORS_ADM9240_IN4_MAX,&max)) {
323    if (valid) {
324      print_label(label,10);
325      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
326             cur,min,max,alarms&ADM9240_ALARM_IN4?"ALARM":"");
327    }
328  } else
329    printf("ERROR: Can't get IN4 data!\n");
330  free_the_label(&label);
331  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN5,&label,&valid) &&
332      !sensors_get_feature(*name,SENSORS_ADM9240_IN5,&cur) &&
333      !sensors_get_feature(*name,SENSORS_ADM9240_IN5_MIN,&min) &&
334      !sensors_get_feature(*name,SENSORS_ADM9240_IN5_MAX,&max)) {
335    if (valid) {
336      print_label(label,10);
337      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
338             cur,min,max,alarms&ADM9240_ALARM_IN5?"ALARM":"");
339    }
340  } else
341    printf("ERROR: Can't get IN5 data!\n");
342  free_the_label(&label);
343
344  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_FAN1,&label,&valid) &&
345      !sensors_get_feature(*name,SENSORS_ADM9240_FAN1,&cur) &&
346      !sensors_get_feature(*name,SENSORS_ADM9240_FAN1_DIV,&fdiv) &&
347      !sensors_get_feature(*name,SENSORS_ADM9240_FAN1_MIN,&min)) {
348    if (valid) {
349      print_label(label,10);
350      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
351             cur,min,fdiv, alarms&ADM9240_ALARM_FAN1?"ALARM":"");
352    }
353  } else
354    printf("ERROR: Can't get FAN1 data!\n");
355  free_the_label(&label);
356  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_FAN2,&label,&valid) &&
357      !sensors_get_feature(*name,SENSORS_ADM9240_FAN2,&cur) &&
358      !sensors_get_feature(*name,SENSORS_ADM9240_FAN2_DIV,&fdiv) &&
359      !sensors_get_feature(*name,SENSORS_ADM9240_FAN2_MIN,&min)) {
360    if (valid) {
361      print_label(label,10);
362      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
363             cur,min,fdiv, alarms&ADM9240_ALARM_FAN2?"ALARM":"");
364    }
365  } else
366    printf("ERROR: Can't get FAN2 data!\n");
367  free_the_label(&label);
368
369  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_TEMP,&label,&valid) &&
370      !sensors_get_feature(*name,SENSORS_ADM9240_TEMP,&cur) &&
371      !sensors_get_feature(*name,SENSORS_ADM9240_TEMP_HYST,&min) &&
372      !sensors_get_feature(*name,SENSORS_ADM9240_TEMP_OVER,&max)) {
373    if (valid) {
374      print_label(label,10);
375      print_temp_info( cur, max, min, HYST, 1, 0);
376      printf( " %s\n", alarms & ADM9240_ALARM_TEMP ? "ALARM" : "" );
377    }
378  } else
379    printf("ERROR: Can't get TEMP data!\n");
380  free_the_label(&label);
381
382  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_VID,&label,&valid) &&
383      !sensors_get_feature(*name,SENSORS_ADM9240_VID,&cur)) {
384    if (valid) {
385      print_label(label,10);
386      printf("%+6.2f V\n",cur);
387    }
388  }
389  free_the_label(&label);
390   
391  if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_ALARMS,&label,&valid)) {
392    if (valid) {
393      print_label(label,10);
394      if(alarms & ADM9240_ALARM_CHAS)
395        printf("Chassis intrusion detection                  ALARM\n");
396      else
397        printf("\n");
398    }
399  }
400  free_the_label(&label);
401}
402
403void print_adm1024(const sensors_chip_name *name)
404{
405  char *label = NULL;
406  double cur,min,max,fdiv;
407  int alarms;
408  int valid;
409
410  if (!sensors_get_feature(*name,SENSORS_ADM1024_ALARMS,&cur)) 
411    alarms = cur + 0.5;
412  else {
413    printf("ERROR: Can't get alarm data!\n");
414    alarms = 0;
415  }
416
417  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN0,&label,&valid) &&
418      !sensors_get_feature(*name,SENSORS_ADM1024_IN0,&cur) &&
419      !sensors_get_feature(*name,SENSORS_ADM1024_IN0_MIN,&min) &&
420      !sensors_get_feature(*name,SENSORS_ADM1024_IN0_MAX,&max)) {
421    if (valid) {
422      print_label(label,10);
423      printf( "%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
424             cur,min,max,alarms&ADM1024_ALARM_IN0?"ALARM":"");
425    }
426  } else
427    printf("ERROR: Can't get IN0 data!\n");
428  free_the_label(&label);
429  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN1,&label,&valid) &&
430      !sensors_get_feature(*name,SENSORS_ADM1024_IN1,&cur) &&
431      !sensors_get_feature(*name,SENSORS_ADM1024_IN1_MIN,&min) &&
432      !sensors_get_feature(*name,SENSORS_ADM1024_IN1_MAX,&max)) {
433    if (valid) {
434      print_label(label,10);
435      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
436             cur,min,max,alarms&ADM1024_ALARM_IN1?"ALARM":"");
437    }
438  } else
439    printf("ERROR: Can't get IN1 data!\n");
440  free_the_label(&label);
441  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN2,&label,&valid) &&
442      !sensors_get_feature(*name,SENSORS_ADM1024_IN2,&cur) &&
443      !sensors_get_feature(*name,SENSORS_ADM1024_IN2_MIN,&min) &&
444      !sensors_get_feature(*name,SENSORS_ADM1024_IN2_MAX,&max)) {
445    if (valid) {
446      print_label(label,10);
447      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
448             cur,min,max,alarms&ADM1024_ALARM_IN2?"ALARM":"");
449    }
450  } else
451    printf("ERROR: Can't get IN2 data!\n");
452  free_the_label(&label);
453  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN3,&label,&valid) &&
454      !sensors_get_feature(*name,SENSORS_ADM1024_IN3,&cur) &&
455      !sensors_get_feature(*name,SENSORS_ADM1024_IN3_MIN,&min) &&
456      !sensors_get_feature(*name,SENSORS_ADM1024_IN3_MAX,&max)) {
457    if (valid) {
458      print_label(label,10);
459      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
460             cur,min,max,alarms&ADM1024_ALARM_IN3?"ALARM":"");
461    }
462  } else
463    printf("ERROR: Can't get IN3 data!\n");
464  free_the_label(&label);
465  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN4,&label,&valid) &&
466      !sensors_get_feature(*name,SENSORS_ADM1024_IN4,&cur) &&
467      !sensors_get_feature(*name,SENSORS_ADM1024_IN4_MIN,&min) &&
468      !sensors_get_feature(*name,SENSORS_ADM1024_IN4_MAX,&max)) {
469    if (valid) {
470      print_label(label,10);
471      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
472             cur,min,max,alarms&ADM1024_ALARM_IN4?"ALARM":"");
473    }
474  } else
475    printf("ERROR: Can't get IN4 data!\n");
476  free_the_label(&label);
477  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN5,&label,&valid) &&
478      !sensors_get_feature(*name,SENSORS_ADM1024_IN5,&cur) &&
479      !sensors_get_feature(*name,SENSORS_ADM1024_IN5_MIN,&min) &&
480      !sensors_get_feature(*name,SENSORS_ADM1024_IN5_MAX,&max)) {
481    if (valid) {
482      print_label(label,10);
483      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
484             cur,min,max,alarms&ADM1024_ALARM_IN5?"ALARM":"");
485    }
486  } else
487    printf("ERROR: Can't get IN5 data!\n");
488  free_the_label(&label);
489
490  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_FAN1,&label,&valid) &&
491      !sensors_get_feature(*name,SENSORS_ADM1024_FAN1,&cur) &&
492      !sensors_get_feature(*name,SENSORS_ADM1024_FAN1_DIV,&fdiv) &&
493      !sensors_get_feature(*name,SENSORS_ADM1024_FAN1_MIN,&min)) {
494    if (valid) {
495      print_label(label,10);
496      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
497             cur,min,fdiv, alarms&ADM1024_ALARM_FAN1?"ALARM":"");
498    }
499  } else
500    printf("ERROR: Can't get FAN1 data!\n");
501  free_the_label(&label);
502  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_FAN2,&label,&valid) &&
503      !sensors_get_feature(*name,SENSORS_ADM1024_FAN2,&cur) &&
504      !sensors_get_feature(*name,SENSORS_ADM1024_FAN2_DIV,&fdiv) &&
505      !sensors_get_feature(*name,SENSORS_ADM1024_FAN2_MIN,&min)) {
506    if (valid) {
507      print_label(label,10);
508      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
509             cur,min,fdiv, alarms&ADM1024_ALARM_FAN2?"ALARM":"");
510    }
511  } else
512    printf("ERROR: Can't get FAN2 data!\n");
513  free_the_label(&label);
514
515  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_TEMP,&label,&valid) &&
516      !sensors_get_feature(*name,SENSORS_ADM1024_TEMP,&cur) &&
517      !sensors_get_feature(*name,SENSORS_ADM1024_TEMP_HYST,&min) &&
518      !sensors_get_feature(*name,SENSORS_ADM1024_TEMP_OVER,&max)) {
519    if (valid) {
520      print_label(label,10);
521      print_temp_info( cur, min, max, HYST, 1, 0);
522      printf( " %s\n", alarms & ADM1024_ALARM_TEMP ? "ALARM" : "" );
523    }
524  } else
525    printf("ERROR: Can't get TEMP data!\n");
526  free_the_label(&label);
527
528  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_TEMP1,&label,&valid) &&
529      !sensors_get_feature(*name,SENSORS_ADM1024_TEMP1,&cur) &&
530      !sensors_get_feature(*name,SENSORS_ADM1024_TEMP1_HYST,&min) &&
531      !sensors_get_feature(*name,SENSORS_ADM1024_TEMP1_OVER,&max)) {
532    if (valid) {
533      print_label(label,10);
534      print_temp_info( cur, min, max, HYST, 1, 0);
535      printf( " %s\n", alarms & ADM1024_ALARM_TEMP1 ? "ALARM" : "" );
536    }
537  } else
538    printf("ERROR: Can't get TEMP1 data!\n");
539  free_the_label(&label);
540
541  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_TEMP2,&label,&valid) &&
542      !sensors_get_feature(*name,SENSORS_ADM1024_TEMP2,&cur) &&
543      !sensors_get_feature(*name,SENSORS_ADM1024_TEMP2_HYST,&min) &&
544      !sensors_get_feature(*name,SENSORS_ADM1024_TEMP2_OVER,&max)) {
545    if (valid) {
546      print_label(label,10);
547      print_temp_info( cur, min, max, HYST, 1, 0);
548      printf( " %s\n", alarms & ADM1024_ALARM_TEMP2 ? "ALARM" : "" );
549    }
550  } else
551    printf("ERROR: Can't get TEMP2 data!\n");
552  free_the_label(&label);
553
554  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_VID,&label,&valid) &&
555      !sensors_get_feature(*name,SENSORS_ADM1024_VID,&cur)) {
556    if (valid) {
557      print_label(label,10);
558      printf("%+6.2f V\n",cur);
559    }
560  }
561  free_the_label(&label);
562   
563  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_ALARMS,&label,&valid)) {
564    if (valid) {
565      print_label(label,10);
566      if(alarms & ADM1024_ALARM_CHAS)
567        printf("Chassis intrusion detection                  ALARM\n");
568      else
569        printf("\n");
570    }
571  }
572  free_the_label(&label);
573}
574
575void print_sis5595(const sensors_chip_name *name)
576{
577  char *label = NULL;
578  double cur,min,max,fdiv;
579  int alarms,valid;
580
581  if (!sensors_get_feature(*name,SENSORS_SIS5595_ALARMS,&cur)) 
582    alarms = cur + 0.5;
583  else {
584    printf("ERROR: Can't get alarm data!\n");
585    alarms = 0;
586  }
587
588  if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN0,&label,&valid) &&
589      !sensors_get_feature(*name,SENSORS_SIS5595_IN0,&cur) &&
590      !sensors_get_feature(*name,SENSORS_SIS5595_IN0_MIN,&min) &&
591      !sensors_get_feature(*name,SENSORS_SIS5595_IN0_MAX,&max)) {
592    if (valid) {
593      print_label(label,10);
594      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
595             cur,min,max,alarms&SIS5595_ALARM_IN0?"ALARM":"");
596    }
597  } else
598    printf("ERROR: Can't get IN0 data!\n");
599  free_the_label(&label);
600  if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN1,&label,&valid) &&
601      !sensors_get_feature(*name,SENSORS_SIS5595_IN1,&cur) &&
602      !sensors_get_feature(*name,SENSORS_SIS5595_IN1_MIN,&min) &&
603      !sensors_get_feature(*name,SENSORS_SIS5595_IN1_MAX,&max)) {
604    if (valid) {
605      print_label(label,10);
606      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
607             cur,min,max,alarms&SIS5595_ALARM_IN1?"ALARM":"");
608    }
609  } else
610    printf("ERROR: Can't get IN1 data!\n");
611  free_the_label(&label);
612  if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN2,&label,&valid) &&
613      !sensors_get_feature(*name,SENSORS_SIS5595_IN2,&cur) &&
614      !sensors_get_feature(*name,SENSORS_SIS5595_IN2_MIN,&min) &&
615      !sensors_get_feature(*name,SENSORS_SIS5595_IN2_MAX,&max)) {
616    if (valid) {
617      print_label(label,10);
618      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
619             cur,min,max,alarms&SIS5595_ALARM_IN2?"ALARM":"");
620    }
621  } else
622    printf("ERROR: Can't get IN2 data!\n");
623  free_the_label(&label);
624  if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN3,&label,&valid) &&
625      !sensors_get_feature(*name,SENSORS_SIS5595_IN3,&cur) &&
626      !sensors_get_feature(*name,SENSORS_SIS5595_IN3_MIN,&min) &&
627      !sensors_get_feature(*name,SENSORS_SIS5595_IN3_MAX,&max)) {
628    if (valid) {
629      print_label(label,10);
630      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
631             cur,min,max,alarms&SIS5595_ALARM_IN3?"ALARM":"");
632    }
633  } else
634    printf("ERROR: Can't get IN3 data!\n");
635  free_the_label(&label);
636
637  if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_FAN1,&label,&valid) &&
638      !sensors_get_feature(*name,SENSORS_SIS5595_FAN1,&cur) &&
639      !sensors_get_feature(*name,SENSORS_SIS5595_FAN1_DIV,&fdiv) &&
640      !sensors_get_feature(*name,SENSORS_SIS5595_FAN1_MIN,&min)) {
641    if (valid) {
642      print_label(label,10);
643      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
644             cur,min,fdiv, alarms&SIS5595_ALARM_FAN1?"ALARM":"");
645    }
646  } else
647    printf("ERROR: Can't get FAN1 data!\n");
648  free_the_label(&label);
649  if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_FAN2,&label,&valid) &&
650      !sensors_get_feature(*name,SENSORS_SIS5595_FAN2,&cur) &&
651      !sensors_get_feature(*name,SENSORS_SIS5595_FAN2_DIV,&fdiv) &&
652      !sensors_get_feature(*name,SENSORS_SIS5595_FAN2_MIN,&min)) {
653    if (valid) {
654    print_label(label,10);
655    printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
656           cur,min,fdiv, alarms&SIS5595_ALARM_FAN2?"ALARM":"");
657    }
658  } else
659    printf("ERROR: Can't get FAN2 data!\n");
660  free_the_label(&label);
661
662  if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_TEMP,&label,&valid) &&
663      !sensors_get_feature(*name,SENSORS_SIS5595_TEMP,&cur) &&
664      !sensors_get_feature(*name,SENSORS_SIS5595_TEMP_HYST,&min) &&
665      !sensors_get_feature(*name,SENSORS_SIS5595_TEMP_OVER,&max)) {
666    if (valid) {
667      print_label(label,10);
668      print_temp_info( cur, max, min, HYST, 0, 0);
669      printf( " %s\n", alarms & SIS5595_ALARM_TEMP ? "ALARM" : "" );
670    }
671  } else
672    printf("ERROR: Can't get TEMP data!\n");
673  free_the_label(&label);
674
675  if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_ALARMS,&label,&valid)
676      && valid) {
677    print_label(label,10);
678    printf("Board temperature input (usually LM75 chips) %s\n",
679           alarms & SIS5595_ALARM_BTI ?"ALARM":"     ");
680  }
681  free_the_label(&label);
682
683}
684
685void print_via686a(const sensors_chip_name *name)
686{
687  char *label = NULL;
688  double cur,min,max,fdiv;
689  int alarms,valid;
690
691  if (!sensors_get_feature(*name,SENSORS_VIA686A_ALARMS,&cur)) 
692    alarms = cur + 0.5;
693  else {
694    printf("ERROR: Can't get alarm data!\n");
695    alarms = 0;
696  }
697
698  if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN0,&label,&valid) &&
699      !sensors_get_feature(*name,SENSORS_VIA686A_IN0,&cur) &&
700      !sensors_get_feature(*name,SENSORS_VIA686A_IN0_MIN,&min) &&
701      !sensors_get_feature(*name,SENSORS_VIA686A_IN0_MAX,&max)) {
702    if (valid) {
703      print_label(label,10);
704      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
705             cur,min,max,alarms&VIA686A_ALARM_IN0?"ALARM":"");
706    }
707  } else
708    printf("ERROR: Can't get IN0 data!\n");
709  free_the_label(&label);
710  if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN1,&label,&valid) &&
711      !sensors_get_feature(*name,SENSORS_VIA686A_IN1,&cur) &&
712      !sensors_get_feature(*name,SENSORS_VIA686A_IN1_MIN,&min) &&
713      !sensors_get_feature(*name,SENSORS_VIA686A_IN1_MAX,&max)) {
714    if (valid) {
715      print_label(label,10);
716      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
717             cur,min,max,alarms&VIA686A_ALARM_IN1?"ALARM":"");
718    }
719  } else
720    printf("ERROR: Can't get IN1 data!\n");
721  free_the_label(&label);
722  if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN2,&label,&valid) &&
723      !sensors_get_feature(*name,SENSORS_VIA686A_IN2,&cur) &&
724      !sensors_get_feature(*name,SENSORS_VIA686A_IN2_MIN,&min) &&
725      !sensors_get_feature(*name,SENSORS_VIA686A_IN2_MAX,&max)) {
726    if (valid) {
727      print_label(label,10);
728      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
729             cur,min,max,alarms&VIA686A_ALARM_IN2?"ALARM":"");
730    }
731  } else
732    printf("ERROR: Can't get IN2 data!\n");
733  free_the_label(&label);
734  if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN3,&label,&valid) &&
735      !sensors_get_feature(*name,SENSORS_VIA686A_IN3,&cur) &&
736      !sensors_get_feature(*name,SENSORS_VIA686A_IN3_MIN,&min) &&
737      !sensors_get_feature(*name,SENSORS_VIA686A_IN3_MAX,&max)) {
738    if (valid) {
739      print_label(label,10);
740      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
741             cur,min,max,alarms&VIA686A_ALARM_IN3?"ALARM":"");
742    }
743  } else
744    printf("ERROR: Can't get IN3 data!\n");
745  free_the_label(&label);
746  if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN4,&label,&valid) &&
747      !sensors_get_feature(*name,SENSORS_VIA686A_IN4,&cur) &&
748      !sensors_get_feature(*name,SENSORS_VIA686A_IN4_MIN,&min) &&
749      !sensors_get_feature(*name,SENSORS_VIA686A_IN4_MAX,&max)) {
750    if (valid) {
751      print_label(label,10);
752      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
753             cur,min,max,alarms&VIA686A_ALARM_IN4?"ALARM":"");
754    }
755  } else
756    printf("ERROR: Can't get IN4 data!\n");
757  free_the_label(&label);
758
759  if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_FAN1,&label,&valid) &&
760      !sensors_get_feature(*name,SENSORS_VIA686A_FAN1,&cur) &&
761      !sensors_get_feature(*name,SENSORS_VIA686A_FAN1_DIV,&fdiv) &&
762      !sensors_get_feature(*name,SENSORS_VIA686A_FAN1_MIN,&min)) {
763    if (valid) {
764      print_label(label,10);
765      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
766             cur,min,fdiv, alarms&VIA686A_ALARM_FAN1?"ALARM":"");
767    }
768  } else
769    printf("ERROR: Can't get FAN1 data!\n");
770  free_the_label(&label);
771  if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_FAN2,&label,&valid) &&
772      !sensors_get_feature(*name,SENSORS_VIA686A_FAN2,&cur) &&
773      !sensors_get_feature(*name,SENSORS_VIA686A_FAN2_DIV,&fdiv) &&
774      !sensors_get_feature(*name,SENSORS_VIA686A_FAN2_MIN,&min)) {
775    if (valid) {
776    print_label(label,10);
777    printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
778           cur,min,fdiv, alarms&VIA686A_ALARM_FAN2?"ALARM":"");
779    }
780  } else
781    printf("ERROR: Can't get FAN2 data!\n");
782  free_the_label(&label);
783
784  if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_TEMP,&label,&valid) &&
785      !sensors_get_feature(*name,SENSORS_VIA686A_TEMP,&cur) &&
786      !sensors_get_feature(*name,SENSORS_VIA686A_TEMP_HYST,&min) &&
787      !sensors_get_feature(*name,SENSORS_VIA686A_TEMP_OVER,&max)) {
788    if (valid) {
789      print_label(label,10);
790      print_temp_info( cur, max, min, HYST, 1, 0);
791      printf(" %s\n", alarms & VIA686A_ALARM_TEMP ? "ALARM" : "" );
792    }
793  } else
794    printf("ERROR: Can't get TEMP data!\n");
795  free_the_label(&label);
796  if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_TEMP2,&label,&valid) &&
797      !sensors_get_feature(*name,SENSORS_VIA686A_TEMP2,&cur) &&
798      !sensors_get_feature(*name,SENSORS_VIA686A_TEMP2_HYST,&min) &&
799      !sensors_get_feature(*name,SENSORS_VIA686A_TEMP2_OVER,&max)) {
800    if (valid) {
801      print_label(label,10);
802      print_temp_info( cur, max, min, HYST, 1, 0);
803      printf(" %s\n", alarms & VIA686A_ALARM_TEMP2 ? "ALARM" : "" );
804    }
805  } else
806    printf("ERROR: Can't get TEMP2 data!\n");
807  free_the_label(&label);
808  if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_TEMP3,&label,&valid) &&
809      !sensors_get_feature(*name,SENSORS_VIA686A_TEMP3,&cur) &&
810      !sensors_get_feature(*name,SENSORS_VIA686A_TEMP3_HYST,&min) &&
811      !sensors_get_feature(*name,SENSORS_VIA686A_TEMP3_OVER,&max)) {
812    if (valid) {
813      print_label(label,10);
814      print_temp_info( cur, max, min, HYST, 1, 0);
815      printf(" %s\n", alarms & VIA686A_ALARM_TEMP3 ? "ALARM" : "" );
816    }
817  } else
818    printf("ERROR: Can't get TEMP3 data!\n");
819  free_the_label(&label);
820
821}
822
823void print_lm78(const sensors_chip_name *name)
824{
825  char *label = NULL;
826  double cur,min,max,fdiv;
827  int alarms,valid;
828
829  if (!sensors_get_feature(*name,SENSORS_LM78_ALARMS,&cur)) 
830    alarms = cur + 0.5;
831  else {
832    printf("ERROR: Can't get alarm data!\n");
833    alarms = 0;
834  }
835
836
837  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN0,&label,&valid) &&
838      !sensors_get_feature(*name,SENSORS_LM78_IN0,&cur) &&
839      !sensors_get_feature(*name,SENSORS_LM78_IN0_MIN,&min) &&
840      !sensors_get_feature(*name,SENSORS_LM78_IN0_MAX,&max)) {
841    if (valid) {
842      print_label(label,10);
843      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
844             cur,min,max,alarms&LM78_ALARM_IN0?"ALARM":"");
845    }
846  } else
847    printf("ERROR: Can't get IN0 data!\n");
848  free_the_label(&label);
849  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN1,&label,&valid) &&
850      !sensors_get_feature(*name,SENSORS_LM78_IN1,&cur) &&
851      !sensors_get_feature(*name,SENSORS_LM78_IN1_MIN,&min) &&
852      !sensors_get_feature(*name,SENSORS_LM78_IN1_MAX,&max)) {
853    if (valid) {
854      print_label(label,10);
855      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
856             cur,min,max,alarms&LM78_ALARM_IN1?"ALARM":"");
857    }
858  } else
859    printf("ERROR: Can't get IN1 data!\n");
860  free_the_label(&label);
861  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN2,&label,&valid) &&
862      !sensors_get_feature(*name,SENSORS_LM78_IN2,&cur) &&
863      !sensors_get_feature(*name,SENSORS_LM78_IN2_MIN,&min) &&
864      !sensors_get_feature(*name,SENSORS_LM78_IN2_MAX,&max)) {
865    if (valid) {
866      print_label(label,10);
867      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
868             cur,min,max,alarms&LM78_ALARM_IN2?"ALARM":"");
869    }
870  } else
871    printf("ERROR: Can't get IN2 data!\n");
872  free_the_label(&label);
873  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN3,&label,&valid) &&
874      !sensors_get_feature(*name,SENSORS_LM78_IN3,&cur) &&
875      !sensors_get_feature(*name,SENSORS_LM78_IN3_MIN,&min) &&
876      !sensors_get_feature(*name,SENSORS_LM78_IN3_MAX,&max)) {
877    if (valid) {
878      print_label(label,10);
879      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
880             cur,min,max,alarms&LM78_ALARM_IN3?"ALARM":"");
881    }
882  } else
883    printf("ERROR: Can't get IN3 data!\n");
884  free_the_label(&label);
885  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN4,&label,&valid) &&
886      !sensors_get_feature(*name,SENSORS_LM78_IN4,&cur) &&
887      !sensors_get_feature(*name,SENSORS_LM78_IN4_MIN,&min) &&
888      !sensors_get_feature(*name,SENSORS_LM78_IN4_MAX,&max)) {
889    if (valid) {
890      print_label(label,10);
891      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
892             cur,min,max,alarms&LM78_ALARM_IN4?"ALARM":"");
893    }
894  } else
895    printf("ERROR: Can't get IN4 data!\n");
896  free_the_label(&label);
897  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN5,&label,&valid) &&
898      !sensors_get_feature(*name,SENSORS_LM78_IN5,&cur) &&
899      !sensors_get_feature(*name,SENSORS_LM78_IN5_MIN,&min) &&
900      !sensors_get_feature(*name,SENSORS_LM78_IN5_MAX,&max)) {
901    if (valid) {
902      print_label(label,10);
903      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
904             cur,min,max,alarms&LM78_ALARM_IN5?"ALARM":"");
905    }
906  } else
907    printf("ERROR: Can't get IN5 data!\n");
908  free_the_label(&label);
909  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN6,&label,&valid) &&
910      !sensors_get_feature(*name,SENSORS_LM78_IN6,&cur) &&
911      !sensors_get_feature(*name,SENSORS_LM78_IN6_MIN,&min) &&
912      !sensors_get_feature(*name,SENSORS_LM78_IN6_MAX,&max)) {
913    if (valid) {
914      print_label(label,10);
915      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
916             cur,min,max,alarms&LM78_ALARM_IN6?"ALARM":"");
917    }
918  } else
919    printf("ERROR: Can't get IN6 data!\n");
920  free_the_label(&label);
921
922  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_FAN1,&label,&valid) &&
923      !sensors_get_feature(*name,SENSORS_LM78_FAN1,&cur) &&
924      !sensors_get_feature(*name,SENSORS_LM78_FAN1_DIV,&fdiv) &&
925      !sensors_get_feature(*name,SENSORS_LM78_FAN1_MIN,&min)) {
926    if (valid) {
927      print_label(label,10);
928      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
929             cur,min,fdiv, alarms&LM78_ALARM_FAN1?"ALARM":"");
930    }
931  } else
932    printf("ERROR: Can't get FAN1 data!\n");
933  free_the_label(&label);
934  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_FAN2,&label,&valid) &&
935      !sensors_get_feature(*name,SENSORS_LM78_FAN2,&cur) &&
936      !sensors_get_feature(*name,SENSORS_LM78_FAN2_DIV,&fdiv) &&
937      !sensors_get_feature(*name,SENSORS_LM78_FAN2_MIN,&min)) {
938    if (valid) {
939      print_label(label,10);
940      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
941             cur,min,fdiv, alarms&LM78_ALARM_FAN2?"ALARM":"");
942    }
943  } else
944    printf("ERROR: Can't get FAN2 data!\n");
945  free_the_label(&label);
946  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_FAN3,&label,&valid) &&
947      !sensors_get_feature(*name,SENSORS_LM78_FAN3,&cur) &&
948      !sensors_get_feature(*name,SENSORS_LM78_FAN3_DIV,&fdiv) &&
949      !sensors_get_feature(*name,SENSORS_LM78_FAN3_MIN,&min)) {
950    if (valid) {
951      print_label(label,10);
952      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
953             cur,min,fdiv, alarms&LM78_ALARM_FAN3?"ALARM":"");
954    }
955  } else
956    printf("ERROR: Can't get FAN3 data!\n");
957  free_the_label(&label);
958
959  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_TEMP,&label,&valid) &&
960      !sensors_get_feature(*name,SENSORS_LM78_TEMP,&cur) &&
961      !sensors_get_feature(*name,SENSORS_LM78_TEMP_HYST,&min) &&
962      !sensors_get_feature(*name,SENSORS_LM78_TEMP_OVER,&max)) {
963    if (valid) {
964      print_label(label,10);
965      print_temp_info( cur, max, min, HYST, 1, 0);
966      printf( " %s\n", alarms & LM78_ALARM_TEMP ? "ALARM" : "" );
967    }
968  } else
969    printf("ERROR: Can't get TEMP data!\n");
970  free_the_label(&label);
971
972  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_VID,&label,&valid) &&
973      !sensors_get_feature(*name,SENSORS_LM78_VID,&cur)) {
974    if (valid) {
975      print_label(label,10);
976      printf("%+6.2f V\n",cur);
977    }
978  }
979  free_the_label(&label);
980   
981  if (!sensors_get_label_and_valid(*name,SENSORS_LM78_ALARMS,&label,&valid)
982      && valid) {
983    if(alarms & LM78_ALARM_BTI) {
984      print_label(label,10);
985      printf("Board temperature input (LM75)               ALARM\n");
986    }
987    if(alarms & LM78_ALARM_CHAS) {
988      print_label(label,10);
989      printf("Chassis intrusion detection                  ALARM\n");
990    }
991  }
992  free_the_label(&label);
993}
994
995void print_gl518(const sensors_chip_name *name)
996{
997  char *label = NULL;
998  double cur,min,max,fdiv;
999  int alarms,beeps,valid;
1000  int is_r00;
1001
1002  cur = 0.0;
1003  sensors_get_feature(*name,SENSORS_GL518_ITERATE,&cur); 
1004  is_r00 = ((int) (cur + 0.5)) != 3;
1005  if (!sensors_get_feature(*name,SENSORS_GL518_ALARMS,&cur)) 
1006    alarms = cur + 0.5;
1007  else {
1008    printf("ERROR: Can't get alarm data!\n");
1009    alarms = 0;
1010  }
1011  if (!sensors_get_feature(*name,SENSORS_GL518_BEEPS,&cur)) 
1012    beeps = cur + 0.5;
1013  else {
1014    printf("ERROR: Can't get beep data!\n");
1015    beeps = 0;
1016  }
1017
1018  /* We need special treatment for the R00 chips, because they can't display
1019     actual readings! We hardcode this, as this is the easiest way. */
1020  if (is_r00) {
1021    if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VDD,&label,&valid) &&
1022        !sensors_get_feature(*name,SENSORS_GL518_VDD,&cur) &&
1023        !sensors_get_feature(*name,SENSORS_GL518_VDD_MIN,&min) &&
1024        !sensors_get_feature(*name,SENSORS_GL518_VDD_MAX,&max)) {
1025      if (valid) {
1026        print_label(label,10);
1027        if (cur == 0.0)
1028          printf("(n/a)     ");
1029        else
1030          printf("%+6.2f V  ",cur);
1031        printf(  "(min = %+6.2f V, max = %+6.2f V)   %s  %s\n",
1032               min,max,alarms&GL518_ALARM_VDD?"ALARM":"     ",
1033               beeps&GL518_ALARM_VDD?"(beep)":"");
1034      }
1035    } else
1036      printf("ERROR: Can't get VDD data!\n");
1037    free_the_label(&label);
1038
1039    if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN1,&label,&valid) &&
1040        !sensors_get_feature(*name,SENSORS_GL518_VIN1,&cur) &&
1041        !sensors_get_feature(*name,SENSORS_GL518_VIN1_MIN,&min) &&
1042        !sensors_get_feature(*name,SENSORS_GL518_VIN1_MAX,&max)) {
1043      if (valid) {
1044        print_label(label,10);
1045        if (cur == 0.0)
1046          printf("(n/a)     ");
1047        else
1048          printf("%+6.2f V  ",cur);
1049        printf("(min = %+6.2f V, max = %+6.2f V)   %s  %s\n",
1050               min,max,alarms&GL518_ALARM_VIN1?"ALARM":"     ",
1051               beeps&GL518_ALARM_VIN1?"(beep)":"");
1052      }
1053    } else
1054      printf("ERROR: Can't get VIN1 data!\n");
1055    free_the_label(&label);
1056    if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN2,&label,&valid) &&
1057        !sensors_get_feature(*name,SENSORS_GL518_VIN2,&cur) &&
1058        !sensors_get_feature(*name,SENSORS_GL518_VIN2_MIN,&min) &&
1059        !sensors_get_feature(*name,SENSORS_GL518_VIN2_MAX,&max)) {
1060      if (valid) {
1061        print_label(label,10);
1062        if (cur == 0.0)
1063          printf("(n/a)     ");
1064        else
1065          printf("%+6.2f V  ",cur);
1066        printf("(min = %+6.2f V, max = %+6.2f V)   %s  %s\n",
1067               min,max,alarms&GL518_ALARM_VIN2?"ALARM":"     ",
1068               beeps&GL518_ALARM_VIN2?"(beep)":"");
1069      }
1070    } else
1071      printf("ERROR: Can't get IN2 data!\n");
1072    free_the_label(&label);
1073  } else {
1074    if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VDD,&label,&valid) &&
1075        !sensors_get_feature(*name,SENSORS_GL518_VDD,&cur) &&
1076        !sensors_get_feature(*name,SENSORS_GL518_VDD_MIN,&min) &&
1077        !sensors_get_feature(*name,SENSORS_GL518_VDD_MAX,&max)) {
1078      if (valid) {
1079        print_label(label,10);
1080        printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s  %s\n",
1081               cur,min,max,alarms&GL518_ALARM_VDD?"ALARM":"     ",
1082               beeps&GL518_ALARM_VDD?"(beep)":"");
1083      }
1084    } else
1085      printf("ERROR: Can't get VDD data!\n");
1086    free_the_label(&label);
1087    if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN1,&label,&valid) &&
1088        !sensors_get_feature(*name,SENSORS_GL518_VIN1,&cur) &&
1089        !sensors_get_feature(*name,SENSORS_GL518_VIN1_MIN,&min) &&
1090        !sensors_get_feature(*name,SENSORS_GL518_VIN1_MAX,&max)) {
1091      if (valid) {
1092        print_label(label,10);
1093        printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s  %s\n",
1094               cur,min,max,alarms&GL518_ALARM_VIN1?"ALARM":"     ",
1095               beeps&GL518_ALARM_VIN1?"(beep)":"");
1096      }
1097    } else
1098      printf("ERROR: Can't get VIN1 data!\n");
1099    free_the_label(&label);
1100    if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN2,&label,&valid) &&
1101        !sensors_get_feature(*name,SENSORS_GL518_VIN2,&cur) &&
1102        !sensors_get_feature(*name,SENSORS_GL518_VIN2_MIN,&min) &&
1103        !sensors_get_feature(*name,SENSORS_GL518_VIN2_MAX,&max)) {
1104      if (valid) {
1105        print_label(label,10);
1106        printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s  %s\n",
1107               cur,min,max,alarms&GL518_ALARM_VIN2?"ALARM":"     ",
1108               beeps&GL518_ALARM_VIN2?"(beep)":"");
1109      }
1110    } else
1111      printf("ERROR: Can't get IN2 data!\n");
1112    free_the_label(&label);
1113  }
1114
1115  if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN3,&label,&valid) &&
1116      !sensors_get_feature(*name,SENSORS_GL518_VIN3,&cur) &&
1117      !sensors_get_feature(*name,SENSORS_GL518_VIN3_MIN,&min) &&
1118      !sensors_get_feature(*name,SENSORS_GL518_VIN3_MAX,&max)) {
1119    if (valid) {
1120      print_label(label,10);
1121      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s  %s\n",
1122             cur,min,max,alarms&GL518_ALARM_VIN3?"ALARM":"     ",
1123             beeps&GL518_ALARM_VIN3?"(beep)":"");
1124     }
1125  } else
1126    printf("ERROR: Can't get VIN3 data!\n");
1127  free_the_label(&label);
1128 
1129  if (!sensors_get_label_and_valid(*name,SENSORS_GL518_FAN1,&label,&valid) &&
1130      !sensors_get_feature(*name,SENSORS_GL518_FAN1,&cur) &&
1131      !sensors_get_feature(*name,SENSORS_GL518_FAN1_DIV,&fdiv) &&
1132      !sensors_get_feature(*name,SENSORS_GL518_FAN1_MIN,&min)) {
1133    if (valid) {
1134      print_label(label,10);
1135      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s  %s\n",
1136             cur,min,fdiv, alarms&GL518_ALARM_FAN1?"ALARM":"     ",
1137             beeps&GL518_ALARM_FAN1?"(beep)":"");
1138    }
1139  } else
1140    printf("ERROR: Can't get FAN1 data!\n");
1141  free_the_label(&label);
1142  if (!sensors_get_label_and_valid(*name,SENSORS_GL518_FAN2,&label,&valid) &&
1143      !sensors_get_feature(*name,SENSORS_GL518_FAN2,&cur) &&
1144      !sensors_get_feature(*name,SENSORS_GL518_FAN2_DIV,&fdiv) &&
1145      !sensors_get_feature(*name,SENSORS_GL518_FAN2_MIN,&min)) {
1146    if (valid) {
1147      print_label(label,10);
1148      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s  %s\n",
1149             cur,min,fdiv, alarms&GL518_ALARM_FAN2?"ALARM":"     ",
1150             beeps&GL518_ALARM_FAN2?"(beep)":"");
1151    }
1152  } else
1153    printf("ERROR: Can't get FAN2 data!\n");
1154  free_the_label(&label);
1155
1156  if (!sensors_get_label_and_valid(*name,SENSORS_GL518_TEMP,&label,&valid) &&
1157      !sensors_get_feature(*name,SENSORS_GL518_TEMP,&cur) &&
1158      !sensors_get_feature(*name,SENSORS_GL518_TEMP_OVER,&max) &&
1159      !sensors_get_feature(*name,SENSORS_GL518_TEMP_HYST,&min)) {
1160    if (valid) {
1161      print_label(label,10);
1162      print_temp_info( cur, max, min, HYST, 1, 0);
1163      printf("%s  %s\n", alarms&GL518_ALARM_TEMP?"ALARM":"     ",
1164             beeps&GL518_ALARM_TEMP?"(beep)":"");
1165    }
1166  } else
1167    printf("ERROR: Can't get TEMP data!\n");
1168  free_the_label(&label);
1169
1170  if (!sensors_get_label_and_valid(*name,SENSORS_GL518_BEEP_ENABLE,&label,&valid)
1171      && valid) {
1172    if (!sensors_get_feature(*name,SENSORS_GL518_BEEP_ENABLE,&cur)) {
1173      print_label(label,10);
1174      if (cur < 0.5) 
1175        printf("Sound alarm disabled\n");
1176      else
1177        printf("Sound alarm enabled\n");
1178    } else
1179      printf("ERROR: Can't get BEEP data!\n");
1180  }
1181  free_the_label(&label);
1182}
1183
1184void print_adm1025(const sensors_chip_name *name)
1185{
1186  char *label = NULL;
1187  double cur,min,max;
1188  int alarms,valid;
1189
1190  if (!sensors_get_feature(*name,SENSORS_ADM1025_ALARMS,&cur)) 
1191    alarms = cur + 0.5;
1192  else {
1193    printf("ERROR: Can't get alarm data!\n");
1194    alarms = 0;
1195  }
1196
1197  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN0,&label,&valid) &&
1198      !sensors_get_feature(*name,SENSORS_ADM1025_IN0,&cur) &&
1199      !sensors_get_feature(*name,SENSORS_ADM1025_IN0_MIN,&min) &&
1200      !sensors_get_feature(*name,SENSORS_ADM1025_IN0_MAX,&max)) {
1201    if (valid) {
1202      print_label(label,10);
1203      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1204           cur,min,max,alarms&ADM1025_ALARM_IN0?"ALARM":"");
1205    }
1206  } else
1207    printf("ERROR: Can't get IN0 data!\n");
1208  free_the_label(&label);
1209  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN1,&label,&valid) &&
1210      !sensors_get_feature(*name,SENSORS_ADM1025_IN1,&cur) &&
1211      !sensors_get_feature(*name,SENSORS_ADM1025_IN1_MIN,&min) &&
1212      !sensors_get_feature(*name,SENSORS_ADM1025_IN1_MAX,&max)) {
1213    if (valid) {
1214      print_label(label,10);
1215      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1216           cur,min,max,alarms&ADM1025_ALARM_IN1?"ALARM":"");
1217    }
1218  } else
1219    printf("ERROR: Can't get IN1 data!\n");
1220  free_the_label(&label);
1221  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN2,&label,&valid) &&
1222      !sensors_get_feature(*name,SENSORS_ADM1025_IN2,&cur) &&
1223      !sensors_get_feature(*name,SENSORS_ADM1025_IN2_MIN,&min) &&
1224      !sensors_get_feature(*name,SENSORS_ADM1025_IN2_MAX,&max)) {
1225    if (valid) {
1226      print_label(label,10);
1227      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1228           cur,min,max,alarms&ADM1025_ALARM_IN2?"ALARM":"");
1229    }
1230  } else
1231    printf("ERROR: Can't get IN2 data!\n");
1232  free_the_label(&label);
1233  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN3,&label,&valid) &&
1234      !sensors_get_feature(*name,SENSORS_ADM1025_IN3,&cur) &&
1235      !sensors_get_feature(*name,SENSORS_ADM1025_IN3_MIN,&min) &&
1236      !sensors_get_feature(*name,SENSORS_ADM1025_IN3_MAX,&max)) {
1237    if (valid) {
1238      print_label(label,10);
1239      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1240           cur,min,max,alarms&ADM1025_ALARM_IN3?"ALARM":"");
1241    }
1242  } else
1243    printf("ERROR: Can't get IN3 data!\n");
1244  free_the_label(&label);
1245  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN4,&label,&valid) &&
1246      !sensors_get_feature(*name,SENSORS_ADM1025_IN4,&cur) &&
1247      !sensors_get_feature(*name,SENSORS_ADM1025_IN4_MIN,&min) &&
1248      !sensors_get_feature(*name,SENSORS_ADM1025_IN4_MAX,&max)) {
1249    if (valid) {
1250      print_label(label,10);
1251      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1252           cur,min,max,alarms&ADM1025_ALARM_IN4?"ALARM":"");
1253    }
1254  } else
1255    printf("ERROR: Can't get IN4 data!\n");
1256  free_the_label(&label);
1257  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN5,&label,&valid) &&
1258      !sensors_get_feature(*name,SENSORS_ADM1025_IN5,&cur) &&
1259      !sensors_get_feature(*name,SENSORS_ADM1025_IN5_MIN,&min) &&
1260      !sensors_get_feature(*name,SENSORS_ADM1025_IN5_MAX,&max)) {
1261    if (valid) {
1262      print_label(label,10);
1263      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1264           cur,min,max,alarms&ADM1025_ALARM_IN5?"ALARM":"");
1265    }
1266  } else
1267    printf("ERROR: Can't get IN5 data!\n");
1268  free_the_label(&label);
1269
1270  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_TEMP1,&label,&valid) &&
1271      !sensors_get_feature(*name,SENSORS_ADM1025_TEMP1,&cur) &&
1272      !sensors_get_feature(*name,SENSORS_ADM1025_TEMP1_HYST,&min) &&
1273      !sensors_get_feature(*name,SENSORS_ADM1025_TEMP1_OVER,&max)) {
1274    if (valid) {
1275      print_label(label,10);
1276      print_temp_info( cur, max, min, MINMAX, 1, 0);
1277      printf(" %s\n", alarms&ADM1025_ALARM_TEMP?"ALARM":"");
1278    }
1279  } else
1280    printf("ERROR: Can't get TEMP1 data!\n");
1281  free_the_label(&label);
1282
1283  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_TEMP2,&label,&valid) &&
1284      !sensors_get_feature(*name,SENSORS_ADM1025_TEMP2,&cur) &&
1285      !sensors_get_feature(*name,SENSORS_ADM1025_TEMP2_HYST,&min) &&
1286      !sensors_get_feature(*name,SENSORS_ADM1025_TEMP2_OVER,&max)) {
1287    if (valid) {
1288      print_label(label,10);
1289      print_temp_info( cur, max, min, MINMAX, 1, 0);
1290      printf(" %s\n", alarms&ADM1025_ALARM_RTEMP ? "ALARM":"");
1291    }
1292  } else
1293    printf("ERROR: Can't get TEMP2 data!\n");
1294  free_the_label(&label);
1295
1296  if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_VID,&label,&valid) &&
1297      !sensors_get_feature(*name,SENSORS_ADM1025_VID,&cur)) {
1298    if (valid) {
1299      print_label(label,10);
1300      printf("%+6.2f V\n",cur);
1301    }
1302  }
1303  free_the_label(&label);
1304}
1305
1306void print_lm80(const sensors_chip_name *name)
1307{
1308  char *label = NULL;
1309  double cur,min,max,min2,max2,fdiv;
1310  int alarms,valid;
1311
1312  if (!sensors_get_feature(*name,SENSORS_LM80_ALARMS,&cur)) 
1313    alarms = cur + 0.5;
1314  else {
1315    printf("ERROR: Can't get alarm data!\n");
1316    alarms = 0;
1317  }
1318
1319  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN0,&label,&valid) &&
1320      !sensors_get_feature(*name,SENSORS_LM80_IN0,&cur) &&
1321      !sensors_get_feature(*name,SENSORS_LM80_IN0_MIN,&min) &&
1322      !sensors_get_feature(*name,SENSORS_LM80_IN0_MAX,&max)) {
1323    if (valid) {
1324      print_label(label,10);
1325      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1326           cur,min,max,alarms&LM80_ALARM_IN0?"ALARM":"");
1327    }
1328  } else
1329    printf("ERROR: Can't get IN0 data!\n");
1330  free_the_label(&label);
1331  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN1,&label,&valid) &&
1332      !sensors_get_feature(*name,SENSORS_LM80_IN1,&cur) &&
1333      !sensors_get_feature(*name,SENSORS_LM80_IN1_MIN,&min) &&
1334      !sensors_get_feature(*name,SENSORS_LM80_IN1_MAX,&max)) {
1335    if (valid) {
1336      print_label(label,10);
1337      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1338           cur,min,max,alarms&LM80_ALARM_IN1?"ALARM":"");
1339    }
1340  } else
1341    printf("ERROR: Can't get IN1 data!\n");
1342  free_the_label(&label);
1343  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN2,&label,&valid) &&
1344      !sensors_get_feature(*name,SENSORS_LM80_IN2,&cur) &&
1345      !sensors_get_feature(*name,SENSORS_LM80_IN2_MIN,&min) &&
1346      !sensors_get_feature(*name,SENSORS_LM80_IN2_MAX,&max)) {
1347    if (valid) {
1348      print_label(label,10);
1349      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1350           cur,min,max,alarms&LM80_ALARM_IN2?"ALARM":"");
1351    }
1352  } else
1353    printf("ERROR: Can't get IN2 data!\n");
1354  free_the_label(&label);
1355  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN3,&label,&valid) &&
1356      !sensors_get_feature(*name,SENSORS_LM80_IN3,&cur) &&
1357      !sensors_get_feature(*name,SENSORS_LM80_IN3_MIN,&min) &&
1358      !sensors_get_feature(*name,SENSORS_LM80_IN3_MAX,&max)) {
1359    if (valid) {
1360      print_label(label,10);
1361      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1362           cur,min,max,alarms&LM80_ALARM_IN3?"ALARM":"");
1363    }
1364  } else
1365    printf("ERROR: Can't get IN3 data!\n");
1366  free_the_label(&label);
1367  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN4,&label,&valid) &&
1368      !sensors_get_feature(*name,SENSORS_LM80_IN4,&cur) &&
1369      !sensors_get_feature(*name,SENSORS_LM80_IN4_MIN,&min) &&
1370      !sensors_get_feature(*name,SENSORS_LM80_IN4_MAX,&max)) {
1371    if (valid) {
1372      print_label(label,10);
1373      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1374           cur,min,max,alarms&LM80_ALARM_IN4?"ALARM":"");
1375    }
1376  } else
1377    printf("ERROR: Can't get IN4 data!\n");
1378  free_the_label(&label);
1379  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN5,&label,&valid) &&
1380      !sensors_get_feature(*name,SENSORS_LM80_IN5,&cur) &&
1381      !sensors_get_feature(*name,SENSORS_LM80_IN5_MIN,&min) &&
1382      !sensors_get_feature(*name,SENSORS_LM80_IN5_MAX,&max)) {
1383    if (valid) {
1384      print_label(label,10);
1385      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1386           cur,min,max,alarms&LM80_ALARM_IN5?"ALARM":"");
1387    }
1388  } else
1389    printf("ERROR: Can't get IN5 data!\n");
1390  free_the_label(&label);
1391  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN6,&label,&valid) &&
1392      !sensors_get_feature(*name,SENSORS_LM80_IN6,&cur) &&
1393      !sensors_get_feature(*name,SENSORS_LM80_IN6_MIN,&min) &&
1394      !sensors_get_feature(*name,SENSORS_LM80_IN6_MAX,&max)) {
1395    if (valid) {
1396      print_label(label,10);
1397      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1398           cur,min,max,alarms&LM80_ALARM_IN6?"ALARM":"");
1399    }
1400  } else
1401    printf("ERROR: Can't get IN6 data!\n");
1402  free_the_label(&label);
1403
1404  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_FAN1,&label,&valid) &&
1405      !sensors_get_feature(*name,SENSORS_LM80_FAN1,&cur) &&
1406      !sensors_get_feature(*name,SENSORS_LM80_FAN1_DIV,&fdiv) &&
1407      !sensors_get_feature(*name,SENSORS_LM80_FAN1_MIN,&min)) {
1408    if (valid) {
1409      print_label(label,10);
1410      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
1411           cur,min,fdiv, alarms&LM80_ALARM_FAN1?"ALARM":"");
1412    }
1413  } else
1414    printf("ERROR: Can't get FAN1 data!\n");
1415  free_the_label(&label);
1416  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_FAN2,&label,&valid) &&
1417      !sensors_get_feature(*name,SENSORS_LM80_FAN2,&cur) &&
1418      !sensors_get_feature(*name,SENSORS_LM80_FAN2_DIV,&fdiv) &&
1419      !sensors_get_feature(*name,SENSORS_LM80_FAN2_MIN,&min)) {
1420    if (valid) {
1421      print_label(label,10);
1422      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
1423           cur,min,fdiv, alarms&LM80_ALARM_FAN2?"ALARM":"");
1424    }
1425  } else
1426    printf("ERROR: Can't get FAN2 data!\n");
1427  free_the_label(&label);
1428
1429  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_TEMP,&label,&valid) &&
1430      !sensors_get_feature(*name,SENSORS_LM80_TEMP,&cur) &&
1431      !sensors_get_feature(*name,SENSORS_LM80_TEMP_HOT_HYST,&min) &&
1432      !sensors_get_feature(*name,SENSORS_LM80_TEMP_HOT_MAX,&max) &&
1433      !sensors_get_feature(*name,SENSORS_LM80_TEMP_OS_HYST,&min2) &&
1434      !sensors_get_feature(*name,SENSORS_LM80_TEMP_OS_MAX,&max2)) {
1435    if (valid) {
1436      print_label(label,10);
1437
1438      if ( fahrenheit )
1439      {
1440      printf("%+3.2f°C (hot:limit = %+3.0f°F,  hysteresis = %+3.0f°F) %s\n",
1441           deg_ctof(cur),deg_ctof(max),deg_ctof(min), alarms&LM80_ALARM_TEMP_HOT?"ALARM":"");
1442    printf("         (os: limit = %+3.0f°F,  hysteresis = %+3.0f°F) %s\n",
1443           deg_ctof(max2),deg_ctof(min2), alarms&LM80_ALARM_TEMP_HOT?"ALARM":"");
1444      }
1445      else
1446      {
1447      printf("%+3.2f °C (hot:limit = %+3.0f°C,  hysteresis = %+3.0f°C) %s\n",
1448           cur,max,min, alarms&LM80_ALARM_TEMP_HOT?"ALARM":"");
1449    printf("         (os: limit = %+3.0f°C,  hysteresis = %+3.0f°C) %s\n",
1450           max2,min2, alarms&LM80_ALARM_TEMP_HOT?"ALARM":"");
1451      }
1452    }
1453  } else
1454    printf("ERROR: Can't get TEMP data!\n");
1455  free_the_label(&label);
1456
1457  if (!sensors_get_label_and_valid(*name,SENSORS_LM80_ALARMS,&label,&valid)
1458      && valid) {
1459    if (alarms & LM80_ALARM_BTI) {
1460      print_label(label,10);
1461      printf("Board temperature input (LM75)               ALARM\n");
1462    }
1463    if (alarms & LM80_ALARM_CHAS) {
1464      print_label(label,10);
1465      printf("Chassis intrusion detection                  ALARM\n");
1466    }
1467  }
1468  free_the_label(&label);
1469}
1470
1471void print_lm87(const sensors_chip_name *name)
1472{
1473  char *label = NULL;
1474  double cur,min,max,fdiv;
1475  int alarms,valid;
1476
1477  if (!sensors_get_feature(*name,SENSORS_LM87_ALARMS,&cur))
1478    alarms = cur + 0.5;
1479  else {
1480    printf("ERROR: Can't get alarm data!\n");
1481    alarms = 0;
1482  }
1483
1484
1485  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN0,&label,&valid) &&
1486      !sensors_get_feature(*name,SENSORS_LM87_IN0,&cur) &&
1487      !sensors_get_feature(*name,SENSORS_LM87_IN0_MIN,&min) &&
1488      !sensors_get_feature(*name,SENSORS_LM87_IN0_MAX,&max)) {
1489    if (valid) {
1490      print_label(label,10);
1491      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1492             cur,min,max,alarms&LM87_ALARM_IN0?"ALARM":"");
1493    }
1494  }
1495  free_the_label(&label);
1496  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN1,&label,&valid) &&
1497      !sensors_get_feature(*name,SENSORS_LM87_IN1,&cur) &&
1498      !sensors_get_feature(*name,SENSORS_LM87_IN1_MIN,&min) &&
1499      !sensors_get_feature(*name,SENSORS_LM87_IN1_MAX,&max)) {
1500    if (valid) {
1501      print_label(label,10);
1502      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1503             cur,min,max,alarms&LM87_ALARM_IN1?"ALARM":"");
1504    }
1505  } else
1506    printf("ERROR: Can't get IN1 data!\n");
1507  free_the_label(&label);
1508  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN2,&label,&valid) &&
1509      !sensors_get_feature(*name,SENSORS_LM87_IN2,&cur) &&
1510      !sensors_get_feature(*name,SENSORS_LM87_IN2_MIN,&min) &&
1511      !sensors_get_feature(*name,SENSORS_LM87_IN2_MAX,&max)) {
1512    if (valid) {
1513      print_label(label,10);
1514      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1515             cur,min,max,alarms&LM87_ALARM_IN2?"ALARM":"");
1516    }
1517  }
1518  free_the_label(&label);
1519  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN3,&label,&valid) &&
1520      !sensors_get_feature(*name,SENSORS_LM87_IN3,&cur) &&
1521      !sensors_get_feature(*name,SENSORS_LM87_IN3_MIN,&min) &&
1522      !sensors_get_feature(*name,SENSORS_LM87_IN3_MAX,&max)) {
1523    if (valid) {
1524      print_label(label,10);
1525      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1526             cur,min,max,alarms&LM87_ALARM_IN3?"ALARM":"");
1527    }
1528  } else
1529    printf("ERROR: Can't get IN3 data!\n");
1530  free_the_label(&label);
1531  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN4,&label,&valid) &&
1532      !sensors_get_feature(*name,SENSORS_LM87_IN4,&cur) &&
1533      !sensors_get_feature(*name,SENSORS_LM87_IN4_MIN,&min) &&
1534      !sensors_get_feature(*name,SENSORS_LM87_IN4_MAX,&max)) {
1535    if (valid) {
1536      print_label(label,10);
1537      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1538             cur,min,max,alarms&LM87_ALARM_IN4?"ALARM":"");
1539    }
1540  } else
1541    printf("ERROR: Can't get IN4 data!\n");
1542  free_the_label(&label);
1543  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN5,&label,&valid) &&
1544      !sensors_get_feature(*name,SENSORS_LM87_IN5,&cur) &&
1545      !sensors_get_feature(*name,SENSORS_LM87_IN5_MIN,&min) &&
1546      !sensors_get_feature(*name,SENSORS_LM87_IN5_MAX,&max)) {
1547    if (valid) {
1548      print_label(label,10);
1549      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1550             cur,min,max,alarms&LM87_ALARM_IN5?"ALARM":"");
1551    }
1552  }
1553  free_the_label(&label);
1554  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_AIN1,&label,&valid) &&
1555      !sensors_get_feature(*name,SENSORS_LM87_AIN1,&cur) &&
1556      !sensors_get_feature(*name,SENSORS_LM87_AIN1_MIN,&min) &&
1557      !sensors_get_feature(*name,SENSORS_LM87_AIN1_MAX,&max)) {
1558    if (valid) {
1559      print_label(label,10);
1560      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1561             cur,min,max,alarms&LM87_ALARM_FAN1?"ALARM":"");
1562    }
1563  }
1564  free_the_label(&label);
1565  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_AIN2,&label,&valid) &&
1566      !sensors_get_feature(*name,SENSORS_LM87_AIN2,&cur) &&
1567      !sensors_get_feature(*name,SENSORS_LM87_AIN2_MIN,&min) &&
1568      !sensors_get_feature(*name,SENSORS_LM87_AIN2_MAX,&max)) {
1569    if (valid) {
1570      print_label(label,10);
1571      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1572             cur,min,max,alarms&LM87_ALARM_FAN2?"ALARM":"");
1573    }
1574  }
1575  free_the_label(&label);
1576
1577  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_FAN1,&label,&valid) &&
1578      !sensors_get_feature(*name,SENSORS_LM87_FAN1,&cur) &&
1579      !sensors_get_feature(*name,SENSORS_LM87_FAN1_DIV,&fdiv) &&
1580      !sensors_get_feature(*name,SENSORS_LM87_FAN1_MIN,&min)) {
1581    if (valid) {
1582      print_label(label,10);
1583      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
1584             cur,min,fdiv, alarms&LM87_ALARM_FAN1?"ALARM":"");
1585    }
1586  }
1587  free_the_label(&label);
1588  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_FAN2,&label,&valid) &&
1589      !sensors_get_feature(*name,SENSORS_LM87_FAN2,&cur) &&
1590      !sensors_get_feature(*name,SENSORS_LM87_FAN2_DIV,&fdiv) &&
1591      !sensors_get_feature(*name,SENSORS_LM87_FAN2_MIN,&min)) {
1592    if (valid) {
1593      print_label(label,10);
1594      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
1595             cur,min,fdiv, alarms&LM87_ALARM_FAN2 ?"ALARM":"");
1596    }
1597  }
1598  free_the_label(&label);
1599
1600  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP1,&label,&valid) &&
1601      !sensors_get_feature(*name,SENSORS_LM87_TEMP1,&cur) &&
1602      !sensors_get_feature(*name,SENSORS_LM87_TEMP1_HYST,&min) &&
1603      !sensors_get_feature(*name,SENSORS_LM87_TEMP1_OVER,&max)) {
1604    if (valid) {
1605      print_label(label,10);
1606      print_temp_info( cur, max, min, MINMAX, 0, 0);
1607      printf(" %s%s\n", alarms&LM87_ALARM_TEMP1?"ALARM":"",
1608        alarms&LM87_ALARM_THERM_SIG?" THERM#":"");
1609    }
1610  } else
1611    printf("ERROR: Can't get TEMP1 data!\n");
1612  free_the_label(&label);
1613
1614  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP2,&label,&valid) &&
1615      !sensors_get_feature(*name,SENSORS_LM87_TEMP2,&cur) &&
1616      !sensors_get_feature(*name,SENSORS_LM87_TEMP2_HYST,&min) &&
1617      !sensors_get_feature(*name,SENSORS_LM87_TEMP2_OVER,&max)) {
1618    if (valid) {
1619      print_label(label,10);
1620      print_temp_info( cur, max, min, MINMAX, 0, 0);
1621      printf(" %s%s\n", alarms&LM87_ALARM_TEMP2?"ALARM":"",
1622        alarms&LM87_ALARM_TEMP2_FAULT?" FAULT":"");
1623    }
1624  } else
1625    printf("ERROR: Can't get TEMP2 data!\n");
1626  free_the_label(&label);
1627
1628  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP3,&label,&valid) &&
1629      !sensors_get_feature(*name,SENSORS_LM87_TEMP3,&cur) &&
1630      !sensors_get_feature(*name,SENSORS_LM87_TEMP3_HYST,&min) &&
1631      !sensors_get_feature(*name,SENSORS_LM87_TEMP3_OVER,&max)) {
1632    if (valid) {
1633      print_label(label,10);
1634      print_temp_info( cur, max, min, MINMAX, 0, 0);
1635      printf(" %s%s\n", alarms&LM87_ALARM_TEMP3?"ALARM":"",
1636        alarms&LM87_ALARM_TEMP3_FAULT?" FAULT":"");
1637    }
1638  }
1639  free_the_label(&label);
1640
1641  if (!sensors_get_label_and_valid(*name,SENSORS_LM87_VID,&label,&valid) &&
1642      !sensors_get_feature(*name,SENSORS_LM87_VID,&cur)) {
1643    if (valid) {
1644      print_label(label,10);
1645      printf("%+6.2f V\n",cur);
1646    }
1647  }
1648  free_the_label(&label);
1649}
1650
1651void print_mtp008(const sensors_chip_name *name)
1652{
1653  char *label = NULL;
1654  double cur,min,max,fdiv;
1655  int alarms,valid;
1656
1657  if (!sensors_get_feature(*name,SENSORS_MTP008_ALARMS,&cur))
1658    alarms = cur + 0.5;
1659  else {
1660    printf("ERROR: Can't get alarm data!\n");
1661    alarms = 0;
1662  }
1663
1664
1665  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN0,&label,&valid) &&
1666      !sensors_get_feature(*name,SENSORS_MTP008_IN0,&cur) &&
1667      !sensors_get_feature(*name,SENSORS_MTP008_IN0_MIN,&min) &&
1668      !sensors_get_feature(*name,SENSORS_MTP008_IN0_MAX,&max)) {
1669    if (valid) {
1670      print_label(label,10);
1671      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1672             cur,min,max,alarms&MTP008_ALARM_IN0?"ALARM":"");
1673    }
1674  } else
1675    printf("ERROR: Can't get IN0 data!\n");
1676  free_the_label(&label);
1677  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN1,&label,&valid) &&
1678      !sensors_get_feature(*name,SENSORS_MTP008_IN1,&cur) &&
1679      !sensors_get_feature(*name,SENSORS_MTP008_IN1_MIN,&min) &&
1680      !sensors_get_feature(*name,SENSORS_MTP008_IN1_MAX,&max)) {
1681    if (valid) {
1682      print_label(label,10);
1683      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1684             cur,min,max,alarms&MTP008_ALARM_IN1?"ALARM":"");
1685    }
1686  } else
1687    printf("ERROR: Can't get IN1 data!\n");
1688  free_the_label(&label);
1689  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN2,&label,&valid) &&
1690      !sensors_get_feature(*name,SENSORS_MTP008_IN2,&cur) &&
1691      !sensors_get_feature(*name,SENSORS_MTP008_IN2_MIN,&min) &&
1692      !sensors_get_feature(*name,SENSORS_MTP008_IN2_MAX,&max)) {
1693    if (valid) {
1694      print_label(label,10);
1695      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1696             cur,min,max,alarms&MTP008_ALARM_IN2?"ALARM":"");
1697    }
1698  } else
1699    printf("ERROR: Can't get IN2 data!\n");
1700  free_the_label(&label);
1701  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN3,&label,&valid) &&
1702      !sensors_get_feature(*name,SENSORS_MTP008_IN3,&cur) &&
1703      !sensors_get_feature(*name,SENSORS_MTP008_IN3_MIN,&min) &&
1704      !sensors_get_feature(*name,SENSORS_MTP008_IN3_MAX,&max)) {
1705    if (valid) {
1706      print_label(label,10);
1707      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1708             cur,min,max,alarms&MTP008_ALARM_IN3?"ALARM":"");
1709    }
1710  } else
1711    printf("ERROR: Can't get IN3 data!\n");
1712  free_the_label(&label);
1713  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN4,&label,&valid) &&
1714      !sensors_get_feature(*name,SENSORS_MTP008_IN4,&cur) &&
1715      !sensors_get_feature(*name,SENSORS_MTP008_IN4_MIN,&min) &&
1716      !sensors_get_feature(*name,SENSORS_MTP008_IN4_MAX,&max)) {
1717    if (valid) {
1718      print_label(label,10);
1719      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1720             cur,min,max,alarms&MTP008_ALARM_IN4?"ALARM":"");
1721    }
1722  } else
1723    printf("ERROR: Can't get IN4 data!\n");
1724  free_the_label(&label);
1725  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN5,&label,&valid) &&
1726      !sensors_get_feature(*name,SENSORS_MTP008_IN5,&cur) &&
1727      !sensors_get_feature(*name,SENSORS_MTP008_IN5_MIN,&min) &&
1728      !sensors_get_feature(*name,SENSORS_MTP008_IN5_MAX,&max)) {
1729    if (valid) {
1730      print_label(label,10);
1731      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1732             cur,min,max,alarms&MTP008_ALARM_IN5?"ALARM":"");
1733    }
1734  } else
1735    printf("ERROR: Can't get IN5 data!\n");
1736  free_the_label(&label);
1737  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN6,&label,&valid) &&
1738      !sensors_get_feature(*name,SENSORS_MTP008_IN6,&cur) &&
1739      !sensors_get_feature(*name,SENSORS_MTP008_IN6_MIN,&min) &&
1740      !sensors_get_feature(*name,SENSORS_MTP008_IN6_MAX,&max)) {
1741    if (valid) {
1742      print_label(label,10);
1743      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
1744             cur,min,max,alarms&MTP008_ALARM_IN6?"ALARM":"");
1745    }
1746  } else
1747    printf("ERROR: Can't get IN6 data!\n");
1748  free_the_label(&label);
1749
1750  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN1,&label,&valid) &&
1751      !sensors_get_feature(*name,SENSORS_MTP008_FAN1,&cur) &&
1752      !sensors_get_feature(*name,SENSORS_MTP008_FAN1_DIV,&fdiv) &&
1753      !sensors_get_feature(*name,SENSORS_MTP008_FAN1_MIN,&min)) {
1754    if (valid) {
1755      print_label(label,10);
1756      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
1757             cur,min,fdiv, alarms&MTP008_ALARM_FAN1?"ALARM":"");
1758    }
1759  } else
1760    printf("ERROR: Can't get FAN1 data!\n");
1761  free_the_label(&label);
1762  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN2,&label,&valid) &&
1763      !sensors_get_feature(*name,SENSORS_MTP008_FAN2,&cur) &&
1764      !sensors_get_feature(*name,SENSORS_MTP008_FAN2_DIV,&fdiv) &&
1765      !sensors_get_feature(*name,SENSORS_MTP008_FAN2_MIN,&min)) {
1766    if (valid) {
1767      print_label(label,10);
1768      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
1769             cur,min,fdiv, alarms&MTP008_ALARM_FAN2?"ALARM":"");
1770    }
1771  } else
1772    printf("ERROR: Can't get FAN2 data!\n");
1773  free_the_label(&label);
1774  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN3,&label,&valid) &&
1775      !sensors_get_feature(*name,SENSORS_MTP008_FAN3,&cur) &&
1776      !sensors_get_feature(*name,SENSORS_MTP008_FAN3_DIV,&fdiv) &&
1777      !sensors_get_feature(*name,SENSORS_MTP008_FAN3_MIN,&min)) {
1778    if (valid) {
1779      print_label(label,10);
1780      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
1781             cur,min,fdiv, alarms&MTP008_ALARM_FAN3?"ALARM":"");
1782    }
1783  } else
1784    printf("ERROR: Can't get FAN3 data!\n");
1785  free_the_label(&label);
1786
1787  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP1,&label,&valid) &&
1788      !sensors_get_feature(*name,SENSORS_MTP008_TEMP1,&cur) &&
1789      !sensors_get_feature(*name,SENSORS_MTP008_TEMP1_HYST,&min) &&
1790      !sensors_get_feature(*name,SENSORS_MTP008_TEMP1_OVER,&max)) {
1791    if (valid) {
1792      print_label(label,10);
1793      print_temp_info( cur, max, min, HYST, 0, 0);
1794      printf(" %s\n", alarms&MTP008_ALARM_TEMP1?"ALARM":"");
1795    }
1796  } else
1797    printf("ERROR: Can't get TEMP1 data!\n");
1798  free_the_label(&label);
1799
1800  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP2,&label,&valid) &&
1801      !sensors_get_feature(*name,SENSORS_MTP008_TEMP2,&cur) &&
1802      !sensors_get_feature(*name,SENSORS_MTP008_TEMP2_HYST,&min) &&
1803      !sensors_get_feature(*name,SENSORS_MTP008_TEMP2_OVER,&max)) {
1804    if (valid) {
1805      print_label(label,10);
1806      print_temp_info( cur, max, min, HYST, 0, 0);
1807      printf(" %s\n", alarms&MTP008_ALARM_TEMP2?"ALARM":"");
1808    }
1809  } else
1810    printf("ERROR: Can't get TEMP2 data!\n");
1811  free_the_label(&label);
1812
1813  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP3,&label,&valid) &&
1814      !sensors_get_feature(*name,SENSORS_MTP008_TEMP3,&cur) &&
1815      !sensors_get_feature(*name,SENSORS_MTP008_TEMP3_HYST,&min) &&
1816      !sensors_get_feature(*name,SENSORS_MTP008_TEMP3_OVER,&max)) {
1817    if (valid) {
1818      print_label(label,10);
1819      print_temp_info( cur, max, min, HYST, 0, 0);
1820      printf(" %s\n", alarms&MTP008_ALARM_TEMP3?"ALARM":"");
1821    }
1822  } else
1823    printf("ERROR: Can't get TEMP3 data!\n");
1824  free_the_label(&label);
1825
1826  if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_VID,&label,&valid) &&
1827      !sensors_get_feature(*name,SENSORS_MTP008_VID,&cur)) {
1828    if (valid) {
1829      print_label(label,10);
1830      printf("%+6.2f V\n",cur);
1831    }
1832  }
1833  free_the_label(&label);
1834}
1835
1836void print_w83781d(const sensors_chip_name *name)
1837{
1838  char *label = NULL;
1839  double cur,min,max,fdiv,sens;
1840  int alarms,beeps;
1841  int is82d, is83s, is697hf, valid;
1842
1843  is82d = (!strcmp(name->prefix,"w83782d")) ||
1844          (!strcmp(name->prefix,"w83627hf"));
1845  is83s = !strcmp(name->prefix,"w83783s");
1846  is697hf = !strcmp(name->prefix,"w83697hf");
1847  if (!sensors_get_feature(*name,SENSORS_W83781D_ALARMS,&cur)) 
1848    alarms = cur + 0.5;
1849  else {
1850    printf("ERROR: Can't get alarm data!\n");
1851    alarms = 0;
1852  }
1853
1854  if (!sensors_get_feature(*name,SENSORS_W83781D_BEEPS,&cur)) {
1855    beeps = cur + 0.5;
1856    /* strangely, as99127f beep bits are inverted */
1857    if (!strcmp(name->prefix,"as99127f"))
1858      beeps = ~beeps;
1859  } else {
1860    printf("ERROR: Can't get beep data!\n");
1861    beeps = 0;
1862  }
1863
1864  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN0,&label,&valid) &&
1865      !sensors_get_feature(*name,SENSORS_W83781D_IN0,&cur) &&
1866      !sensors_get_feature(*name,SENSORS_W83781D_IN0_MIN,&min) &&
1867      !sensors_get_feature(*name,SENSORS_W83781D_IN0_MAX,&max)) {
1868    if (valid) {
1869      print_label(label,10);
1870      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n",
1871           cur,min,max,alarms&W83781D_ALARM_IN0?"ALARM":"     ",
1872           beeps&W83781D_ALARM_IN0?"(beep)":"");
1873    }
1874  } else
1875    printf("ERROR: Can't get IN0 data!\n");
1876  free_the_label(&label);
1877  if ((!is83s) && (!is697hf)) {
1878    if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN1,&label,&valid) &&
1879        !sensors_get_feature(*name,SENSORS_W83781D_IN1,&cur) &&
1880        !sensors_get_feature(*name,SENSORS_W83781D_IN1_MIN,&min) &&
1881        !sensors_get_feature(*name,SENSORS_W83781D_IN1_MAX,&max)) {
1882      if (valid) {
1883        print_label(label,10);
1884        printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n",
1885             cur,min,max,alarms&W83781D_ALARM_IN1?"ALARM":"     ",
1886             beeps&W83781D_ALARM_IN1?"(beep)":"");
1887      }
1888    } else
1889      printf("ERROR: Can't get IN1 data!\n");
1890    free_the_label(&label);
1891  }
1892  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN2,&label,&valid) &&
1893      !sensors_get_feature(*name,SENSORS_W83781D_IN2,&cur) &&
1894      !sensors_get_feature(*name,SENSORS_W83781D_IN2_MIN,&min) &&
1895      !sensors_get_feature(*name,SENSORS_W83781D_IN2_MAX,&max)) {
1896    if (valid) {
1897      print_label(label,10);
1898      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n",
1899           cur,min,max,alarms&W83781D_ALARM_IN2?"ALARM":"     ",
1900           beeps&W83781D_ALARM_IN2?"(beep)":"");
1901    }
1902  } else
1903    printf("ERROR: Can't get IN2 data!\n");
1904  free_the_label(&label);
1905  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN3,&label,&valid) &&
1906      !sensors_get_feature(*name,SENSORS_W83781D_IN3,&cur) &&
1907      !sensors_get_feature(*name,SENSORS_W83781D_IN3_MIN,&min) &&
1908      !sensors_get_feature(*name,SENSORS_W83781D_IN3_MAX,&max)) {
1909    if (valid) {
1910      print_label(label,10);
1911      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n",
1912           cur,min,max,alarms&W83781D_ALARM_IN3?"ALARM":"     ",
1913           beeps&W83781D_ALARM_IN3?"(beep)":"");
1914    }
1915  } else
1916    printf("ERROR: Can't get IN3 data!\n");
1917  free_the_label(&label);
1918  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN4,&label,&valid) &&
1919      !sensors_get_feature(*name,SENSORS_W83781D_IN4,&cur) &&
1920      !sensors_get_feature(*name,SENSORS_W83781D_IN4_MIN,&min) &&
1921      !sensors_get_feature(*name,SENSORS_W83781D_IN4_MAX,&max)) {
1922    if (valid) {
1923      print_label(label,10);
1924      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n",
1925           cur,min,max,alarms&W83781D_ALARM_IN4?"ALARM":"     ",
1926           beeps&W83781D_ALARM_IN4?"(beep)":"");
1927    }
1928  } else
1929    printf("ERROR: Can't get IN4 data!\n");
1930  free_the_label(&label);
1931  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN5,&label,&valid) &&
1932      !sensors_get_feature(*name,SENSORS_W83781D_IN5,&cur) &&
1933      !sensors_get_feature(*name,SENSORS_W83781D_IN5_MIN,&min) &&
1934      !sensors_get_feature(*name,SENSORS_W83781D_IN5_MAX,&max)) {
1935    if (valid) {
1936      print_label(label,10);
1937      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n",
1938           cur,min,max,alarms&W83781D_ALARM_IN5?"ALARM":"     ",
1939           beeps&W83781D_ALARM_IN5?"(beep)":"");
1940    }
1941  } else
1942    printf("ERROR: Can't get IN5 data!\n");
1943  free_the_label(&label);
1944  if (1) {
1945    if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN6,&label,&valid) &&
1946        !sensors_get_feature(*name,SENSORS_W83781D_IN6,&cur) &&
1947        !sensors_get_feature(*name,SENSORS_W83781D_IN6_MIN,&min) &&
1948        !sensors_get_feature(*name,SENSORS_W83781D_IN6_MAX,&max)) {
1949      if (valid) {
1950        print_label(label,10);
1951        printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n",
1952             cur,min,max,alarms&W83781D_ALARM_IN6?"ALARM":"     ",
1953             beeps&W83781D_ALARM_IN6?"(beep)":"");
1954      }
1955    } else
1956      printf("ERROR: Can't get IN6 data!\n");
1957    free_the_label(&label);
1958  }
1959  if (is82d || is697hf) {
1960    if (!sensors_get_label_and_valid(*name,SENSORS_W83782D_IN7,&label,&valid) &&
1961        !sensors_get_feature(*name,SENSORS_W83782D_IN7,&cur) &&
1962        !sensors_get_feature(*name,SENSORS_W83782D_IN7_MIN,&min) &&
1963        !sensors_get_feature(*name,SENSORS_W83782D_IN7_MAX,&max)) {
1964      if (valid) {
1965        print_label(label,10);
1966        printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n",
1967             cur,min,max,alarms&W83782D_ALARM_IN7?"ALARM":"     ",
1968             beeps&W83782D_ALARM_IN7?"(beep)":"");
1969      }
1970    } else
1971      printf("ERROR: Can't get IN7 data!\n");
1972    free_the_label(&label);
1973    if (!sensors_get_label_and_valid(*name,SENSORS_W83782D_IN8,&label,&valid) &&
1974        !sensors_get_feature(*name,SENSORS_W83782D_IN8,&cur) &&
1975        !sensors_get_feature(*name,SENSORS_W83782D_IN8_MIN,&min) &&
1976        !sensors_get_feature(*name,SENSORS_W83782D_IN8_MAX,&max)) {
1977      if (valid) {
1978        print_label(label,10);
1979        printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n",
1980             cur,min,max,alarms&W83782D_ALARM_IN8?"ALARM":"     ",
1981             beeps&W83782D_ALARM_IN8?"(beep)":"");
1982      }
1983    } else
1984      printf("ERROR: Can't get IN8 data!\n");
1985    free_the_label(&label);
1986  }
1987
1988  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN1,&label,&valid) &&
1989      !sensors_get_feature(*name,SENSORS_W83781D_FAN1,&cur) &&
1990      !sensors_get_feature(*name,SENSORS_W83781D_FAN1_DIV,&fdiv) &&
1991      !sensors_get_feature(*name,SENSORS_W83781D_FAN1_MIN,&min)) {
1992    if (valid) {
1993      print_label(label,10);
1994      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s  %s\n",
1995           cur,min,fdiv, alarms&W83781D_ALARM_FAN1?"ALARM":"     ",
1996           beeps&W83781D_ALARM_FAN1?"(beep)":"");
1997    }
1998  } else
1999    printf("ERROR: Can't get FAN1 data!\n");
2000  free_the_label(&label);
2001  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN2,&label,&valid) &&
2002      !sensors_get_feature(*name,SENSORS_W83781D_FAN2,&cur) &&
2003      !sensors_get_feature(*name,SENSORS_W83781D_FAN2_DIV,&fdiv) &&
2004      !sensors_get_feature(*name,SENSORS_W83781D_FAN2_MIN,&min)) {
2005    if (valid) {
2006      print_label(label,10);
2007      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s  %s\n",
2008           cur,min,fdiv, alarms&W83781D_ALARM_FAN2?"ALARM":"     ",
2009           beeps&W83781D_ALARM_FAN2?"(beep)":"");
2010    }
2011  } else
2012    printf("ERROR: Can't get FAN2 data!\n");
2013  free_the_label(&label);
2014
2015  if(!is697hf) {
2016    if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN3,&label,&valid) &&
2017        !sensors_get_feature(*name,SENSORS_W83781D_FAN3,&cur) &&
2018        !sensors_get_feature(*name,SENSORS_W83781D_FAN3_DIV,&fdiv) &&
2019        !sensors_get_feature(*name,SENSORS_W83781D_FAN3_MIN,&min)) {
2020      if (valid) {
2021        print_label(label,10);
2022        printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s  %s\n",
2023             cur,min,fdiv, alarms&W83781D_ALARM_FAN3?"ALARM":"     ",
2024             beeps&W83781D_ALARM_FAN3?"(beep)":"");
2025      }
2026    } else
2027      printf("ERROR: Can't get FAN3 data!\n");
2028    free_the_label(&label);
2029  }
2030
2031  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP1,&label,&valid) &&
2032      !sensors_get_feature(*name,SENSORS_W83781D_TEMP1,&cur) &&
2033      !sensors_get_feature(*name,SENSORS_W83781D_TEMP1_HYST,&min) &&
2034      !sensors_get_feature(*name,SENSORS_W83781D_TEMP1_OVER,&max)) {
2035    if (valid) {
2036      if((!is82d) && (!is83s) && (!is697hf)) {
2037        print_label(label,10);
2038        if(min == 127)
2039          print_temp_info( cur, max, 0, MAXONLY, 0, 0);
2040        else
2041          print_temp_info( cur, max, min, HYST, 0, 0);
2042        printf(" %s  %s\n", alarms&W83781D_ALARM_TEMP1 ?"ALARM":"     ",
2043               beeps&W83781D_ALARM_TEMP1?"(beep)":"");
2044      } else {
2045        if(!sensors_get_feature(*name,SENSORS_W83781D_SENS1,&sens)) {
2046          print_label(label,10);
2047          if(min == 127)
2048            print_temp_info( cur, max, 0, MAXONLY, 0, 0);
2049          else
2050            print_temp_info( cur, max, min, HYST, 0, 0);
2051          printf( " sensor = %s   %s   %s\n",
2052                 (((int)sens)==1)?"PII/Celeron diode":(((int)sens)==2)?
2053                 "3904 transistor":"thermistor",
2054                 alarms&W83781D_ALARM_TEMP1?"ALARM":"     ",
2055                 beeps&W83781D_ALARM_TEMP1?"(beep)":"");
2056        } else {
2057          printf("ERROR: Can't get TEMP1 data!\n");
2058        }
2059      }
2060    }
2061  } else
2062    printf("ERROR: Can't get TEMP1 data!\n");
2063  free_the_label(&label);
2064
2065  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP2,&label,&valid) &&
2066      !sensors_get_feature(*name,SENSORS_W83781D_TEMP2,&cur) &&
2067      !sensors_get_feature(*name,SENSORS_W83781D_TEMP2_HYST,&min) &&
2068      !sensors_get_feature(*name,SENSORS_W83781D_TEMP2_OVER,&max)) {
2069    if (valid) {
2070      if((!is82d) && (!is83s) && (!is697hf)) {
2071        print_label(label,10);
2072        print_temp_info( cur, max, min, HYST, 1, 0);
2073        printf(" %s  %s\n", alarms&W83781D_ALARM_TEMP2 ?"ALARM":"     ",
2074               beeps&W83781D_ALARM_TEMP2?"(beep)":"");
2075      } else {
2076        if(!sensors_get_feature(*name,SENSORS_W83781D_SENS2,&sens)) {
2077          print_label(label,10);
2078          print_temp_info( cur, max, min, HYST, 1, 0);
2079          printf( " sensor = %s   %s   %s\n",
2080                 (((int)sens)==1)?"PII/Celeron diode":(((int)sens)==2)?
2081                 "3904 transistor":"thermistor",
2082                 alarms&W83781D_ALARM_TEMP2?"ALARM":"     ",
2083                 beeps&W83781D_ALARM_TEMP2?"(beep)":"");
2084        } else {
2085          printf("ERROR: Can't get TEMP2 data!\n");
2086        }
2087      }
2088    }
2089  } else
2090    printf("ERROR: Can't get TEMP2 data!\n");
2091  free_the_label(&label);
2092
2093  if ((!is83s) && (!is697hf)) {
2094    if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP3,&label,&valid) &&
2095        !sensors_get_feature(*name,SENSORS_W83781D_TEMP3,&cur) &&
2096        !sensors_get_feature(*name,SENSORS_W83781D_TEMP3_HYST,&min) &&
2097        !sensors_get_feature(*name,SENSORS_W83781D_TEMP3_OVER,&max)) {
2098      if (valid) {
2099        if(!is82d) {
2100          print_label(label,10);
2101          print_temp_info( cur, max, min, HYST, 1, 0);
2102          printf(" %s  %s\n", alarms&W83781D_ALARM_TEMP3 ?"ALARM":"     ",
2103                 beeps&W83781D_ALARM_TEMP3?"(beep)":"");
2104        } else {
2105          if(!sensors_get_feature(*name,SENSORS_W83781D_SENS3,&sens)) {
2106            print_label(label,10);
2107            print_temp_info( cur, max, min, HYST, 1, 0);
2108            printf( " sensor = %s   %s   %s\n",
2109                   (((int)sens)==1)?"PII/Celeron diode":(((int)sens)==2)?
2110                   "3904 transistor":"thermistor",
2111                   alarms&W83781D_ALARM_TEMP3?"ALARM":"     ",
2112                   beeps&W83781D_ALARM_TEMP3?"(beep)":"");
2113          } else {
2114            printf("ERROR: Can't get TEMP3 data!\n");
2115          }
2116        }
2117      }
2118    } else
2119      printf("ERROR: Can't get TEMP3 data!\n");
2120    free_the_label(&label);
2121  }
2122
2123  if(!is697hf) {
2124    if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_VID,&label,&valid) &&
2125        !sensors_get_feature(*name,SENSORS_W83781D_VID,&cur)) {
2126      if (valid) {
2127        print_label(label,10);
2128        printf("%+5.3f V\n",cur);
2129      }
2130    } else {
2131      printf("ERROR: Can't get VID data!\n");
2132    }
2133    free_the_label(&label);
2134  }
2135   
2136  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_ALARMS,&label,&valid)
2137      && valid && !is83s) {
2138    print_label(label,10);
2139    if (alarms & W83781D_ALARM_CHAS)
2140      printf("Chassis intrusion detection                      ALARM\n");
2141    else
2142      printf("\n");
2143  }
2144  free_the_label(&label);
2145
2146  if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_BEEP_ENABLE,&label,&valid)
2147      && valid) {
2148    if (!sensors_get_feature(*name,SENSORS_W83781D_BEEP_ENABLE,&cur)) {
2149      print_label(label,10);
2150      if (cur < 0.5) 
2151        printf("Sound alarm disabled\n");
2152      else
2153        printf("Sound alarm enabled\n");
2154    } else
2155      printf("ERROR: Can't get BEEP data!\n");
2156  }
2157  free_the_label(&label);
2158}
2159
2160void print_maxilife(const sensors_chip_name *name)
2161{
2162   char  *label = NULL;
2163   double cur, min, max;
2164   int    alarms,valid;
2165
2166   if (!sensors_get_feature(*name, SENSORS_MAXI_CG_ALARMS, &cur)) 
2167      alarms = cur + 0.5;
2168   else {
2169      printf("ERROR: Can't get alarm data!\n");
2170      alarms = 0;
2171   }
2172
2173   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP1, &label,&valid) &&
2174       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1, &cur) &&
2175       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1_MAX, &max) &&
2176       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1_HYST, &min)) {
2177      if (valid && (cur || max || min)) {
2178         print_label(label, 12);
2179         print_temp_info( cur, max, min, HYST, 1, 0);
2180         printf("\n");
2181      }
2182   } else
2183      printf("ERROR: Can't get TEMP1 data!\n");
2184   free_the_label(&label);
2185
2186   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP2, &label,&valid) &&
2187       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2, &cur) &&
2188       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2_MAX, &max) &&
2189       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2_HYST, &min)) {
2190      if (valid && (cur || max || min)) {
2191         print_label(label, 12);
2192         print_temp_info( cur, max, min, HYST, 1, 0);
2193         printf(" %s\n", alarms&MAXI_ALARM_TEMP2 ? "ALARM" : "");
2194      }
2195   } else
2196      printf("ERROR: Can't get TEMP2 data!\n");
2197   free_the_label(&label);
2198
2199   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP3, &label,&valid) &&
2200       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3, &cur) &&
2201       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3_MAX, &max) &&
2202       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3_HYST, &min)) {
2203      if (valid && (cur || max || min)) {
2204         print_label(label, 12);
2205         print_temp_info( cur, max, min, HYST, 1, 0);
2206         printf("\n");
2207      }
2208   } else
2209      printf("ERROR: Can't get TEMP3 data!\n");
2210   free_the_label(&label);
2211
2212   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP4, &label,&valid) &&
2213       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4, &cur) &&
2214       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4_MAX, &max) &&
2215       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4_HYST, &min)) {
2216      if (valid && (cur || max || min)) {
2217         print_label(label, 12);
2218         print_temp_info( cur, max, min, HYST, 1, 0);
2219         printf(" %s\n", alarms&MAXI_ALARM_TEMP4 ? "ALARM" : "");
2220      }
2221   } else
2222      printf("ERROR: Can't get TEMP4 data!\n");
2223   free_the_label(&label);
2224
2225   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP5, &label,&valid) &&
2226       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5, &cur) &&
2227       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5_MAX, &max) &&
2228       !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5_HYST, &min)) {
2229      if (valid && (cur || max || min)) {
2230         print_label(label, 12);
2231         print_temp_info( cur, max, min, HYST, 1, 0);
2232         printf(" %s\n", alarms&MAXI_ALARM_TEMP5 ? "ALARM" : "");
2233      }
2234   } else
2235      printf("ERROR: Can't get TEMP5 data!\n");
2236   free_the_label(&label);
2237   
2238   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN1, &label,&valid) &&
2239       !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1, &cur) &&
2240       !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1_MIN, &min) &&
2241       !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1_DIV, &max)) {
2242      if (valid && (cur || min || max)) {
2243         print_label(label, 12);
2244         if (cur < 0)
2245            printf("  OFF       (min = %4.0f RPM, div = %1.0f)      %s\n",
2246                   min/max, max, alarms&MAXI_ALARM_FAN1 ? "ALARM" : "");
2247         else
2248            printf("%5.0f RPM   (min = %4.0f RPM, div = %1.0f)      %s\n",
2249                   cur/max, min/max, max, alarms&MAXI_ALARM_FAN1 ? "ALARM" : "");
2250      }
2251   } else
2252      printf("ERROR: Can't get FAN1 data!\n");
2253   free_the_label(&label);
2254
2255   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN2, &label,&valid) &&
2256       !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2, &cur) &&
2257       !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2_MIN, &min) &&
2258       !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2_DIV, &max)) {
2259      if (valid && (cur || min || max)) {
2260         print_label(label, 12);
2261         if (cur < 0)
2262            printf("  OFF       (min = %4.0f RPM, div = %1.0f)      %s\n",
2263                   min/max, max, alarms&MAXI_ALARM_FAN2 ? "ALARM" : "");
2264         else
2265            printf("%5.0f RPM   (min = %4.0f RPM, div = %1.0f)      %s\n",
2266                   cur/max, min/max, max, alarms&MAXI_ALARM_FAN2 ? "ALARM" : "");
2267      }
2268   } else
2269      printf("ERROR: Can't get FAN2 data!\n");
2270   free_the_label(&label);
2271
2272   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN3, &label,&valid) &&
2273       !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3, &cur) &&
2274       !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3_MIN, &min) &&
2275       !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3_DIV, &max)) {
2276      if (valid && (cur || min || max)) {
2277         print_label(label, 12);
2278         if (cur < 0)
2279            printf("  OFF       (min = %4.0f RPM, div = %1.0f)      %s\n",
2280                   min/max, max, alarms&MAXI_ALARM_FAN3 ? "ALARM" : "");
2281         else
2282            printf("%5.0f RPM   (min = %4.0f RPM, div = %1.0f)      %s\n",
2283                   cur/max, min/max, max, alarms&MAXI_ALARM_FAN3 ? "ALARM" : "");
2284      }
2285   } else
2286      printf("ERROR: Can't get FAN3 data!\n");
2287   free_the_label(&label);
2288
2289   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_PLL, &label,&valid) &&
2290       !sensors_get_feature(*name, SENSORS_MAXI_CG_PLL, &cur) &&
2291       !sensors_get_feature(*name, SENSORS_MAXI_CG_PLL_MIN, &min) &&
2292       !sensors_get_feature(*name, SENSORS_MAXI_CG_PLL_MAX, &max)) {
2293      if (valid && (cur || min || max)) {
2294         print_label(label, 12);
2295         printf("%4.2f MHz   (min = %4.2f MHz, max = %4.2f MHz) %s\n",
2296                cur, min, max, alarms&MAXI_ALARM_PLL ? "ALARM" : "");
2297      }
2298   } else
2299      printf("ERROR: Can't get PLL data!\n");
2300   free_the_label(&label);
2301
2302   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID1, &label,&valid) &&
2303       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID1, &cur) &&
2304       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID1_MIN, &min) &&
2305       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID1_MAX, &max)) {
2306      if (valid && (cur || min || max)) {
2307         print_label(label, 12);
2308         printf("%+6.2f V    (min = %+6.2f V, max = %+6.2f V)   %s\n",
2309                cur, min, max, alarms&MAXI_ALARM_VID1 ? "ALARM" : "");
2310      }
2311   } else
2312      printf("ERROR: Can't get VID1 data!\n");
2313   free_the_label(&label);
2314
2315   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID2, &label,&valid) &&
2316       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID2, &cur) &&
2317       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID2_MIN, &min) &&
2318       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID2_MAX, &max)) {
2319      if (valid && (cur || min || max)) {
2320         print_label(label, 12);
2321         printf("%+6.2f V    (min = %+6.2f V, max = %+6.2f V)   %s\n",
2322                cur, min, max, alarms&MAXI_ALARM_VID2 ? "ALARM" : "");
2323      }
2324   } else
2325      printf("ERROR: Can't get VID2 data!\n");
2326   free_the_label(&label);
2327
2328   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID3, &label,&valid) &&
2329       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID3, &cur) &&
2330       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID3_MIN, &min) &&
2331       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID3_MAX, &max)) {
2332      if (valid && (cur || min || max)) {
2333         print_label(label, 12);
2334         printf("%+6.2f V    (min = %+6.2f V, max = %+6.2f V)   %s\n",
2335                cur, min, max, alarms&MAXI_ALARM_VID3 ? "ALARM" : "");
2336      }
2337   } else
2338      printf("ERROR: Can't get VID3 data!\n");
2339   free_the_label(&label);
2340
2341   if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID4, &label,&valid) &&
2342       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID4, &cur) &&
2343       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID4_MIN, &min) &&
2344       !sensors_get_feature(*name, SENSORS_MAXI_CG_VID4_MAX, &max)) {
2345      if (valid && (cur || min || max)) {
2346         print_label(label, 12);
2347         printf("%+6.2f V    (min = %+6.2f V, max = %+6.2f V)   %s\n",
2348                cur, min, max, alarms&MAXI_ALARM_VID4 ? "ALARM" : "");
2349      }
2350   } else
2351      printf("ERROR: Can't get VID4 data!\n");
2352   free_the_label(&label);
2353}
2354
2355void print_ddcmon(const sensors_chip_name *name)
2356{
2357        char  *label = NULL;
2358        double a, b;
2359        int    valid, i;
2360        char  s[8];
2361       
2362   if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_ID, &label,&valid) &&
2363       !sensors_get_feature(*name, SENSORS_DDCMON_ID, &a)) {
2364      if (valid) {
2365        i = (int) a;   
2366        s[0] = ((i >> 10) & 0x1f) | 0x40;
2367        s[1] = ((i >> 5) & 0x1f) | 0x40;
2368        s[2] = (i & 0x1f) | 0x40;
2369        s[3] = ((i >> 20) & 0x0f) + '0';
2370        s[4] = ((i >> 16) & 0x0f) + '0';
2371        s[5] = ((i >> 28) & 0x0f) + '0';
2372        s[6] = ((i >> 24) & 0x0f) + '0';
2373        s[7] = 0;
2374         print_label(label, 24);
2375         printf("%s\n", s);
2376      }
2377   } else
2378      printf("ERROR: data 1\n");
2379   free_the_label(&label);
2380
2381   if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_SERIAL, &label,&valid) &&
2382       !sensors_get_feature(*name, SENSORS_DDCMON_SERIAL, &a)) {
2383      if (valid) {
2384         print_label(label, 24);
2385         printf("%d\n", (int) a);
2386      }
2387   } else
2388      printf("ERROR: data 2\n");
2389   free_the_label(&label);
2390
2391   if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_VERSIZE, &label,&valid) &&
2392       !sensors_get_feature(*name, SENSORS_DDCMON_VERSIZE, &a) &&
2393       !sensors_get_feature(*name, SENSORS_DDCMON_HORSIZE, &b)) {
2394      if (valid) {
2395         print_label(label, 24);
2396         printf("%dx%d\n", (int) a, (int) b);
2397      }
2398   } else
2399      printf("ERROR: data 3\n");
2400   free_the_label(&label);
2401
2402   if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_VERSYNCMIN, &label,&valid) &&
2403       !sensors_get_feature(*name, SENSORS_DDCMON_VERSYNCMIN, &a) &&
2404       !sensors_get_feature(*name, SENSORS_DDCMON_VERSYNCMAX, &b)) {
2405      if (valid) {
2406         print_label(label, 24);
2407         printf("%d-%d\n", (int) a, (int) b);
2408      }
2409   } else
2410      printf("ERROR: data 4\n");
2411   free_the_label(&label);
2412
2413   if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_HORSYNCMIN, &label,&valid) &&
2414       !sensors_get_feature(*name, SENSORS_DDCMON_HORSYNCMIN, &a) &&
2415       !sensors_get_feature(*name, SENSORS_DDCMON_HORSYNCMAX, &b)) {
2416      if (valid) {
2417         print_label(label, 24);
2418         printf("%d-%d\n", (int) a, (int) b);
2419      }
2420   } else
2421      printf("ERROR: data 5\n");
2422   free_the_label(&label);
2423
2424}
2425
2426void print_eeprom(const sensors_chip_name *name)
2427{
2428        char  *label = NULL;
2429        double a, b, c, d;
2430        int    valid, i, rambus=0, vaio=0;
2431
2432   if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_TYPE, &label,&valid) &&
2433       !sensors_get_feature(*name, SENSORS_EEPROM_TYPE, &a)) {
2434      if (valid) {
2435        if(((int) a) == 4) {
2436           print_label(label, 24);
2437           printf("SDRAM DIMM SPD\n");
2438        } else if(((int) a) == 7) {
2439           print_label(label, 24);
2440           printf("DDR SDRAM DIMM SPD\n");
2441        } else if(((int) a) == 17) {
2442           print_label(label, 24);
2443           printf("RAMBUS RIMM SPD\n");
2444           rambus = 1;
2445        } else
2446           vaio = 1;
2447      }
2448   } else
2449      printf("ERROR: data 1\n");
2450   free_the_label(&label);
2451   
2452   if(vaio)
2453   {
2454      char buffer[33];
2455      memset(buffer, '\0', 33);
2456     
2457      if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_VAIO_NAME, &label,&valid) &&
2458          valid) {
2459         a=1;
2460         for(i=0; i<32 && a!=0; i++)
2461            if(!sensors_get_feature(*name, SENSORS_EEPROM_VAIO_NAME+i, &a) && a!=0)
2462               buffer[i]=(char)a;
2463         print_label(label, 24);
2464         printf("%s\n", buffer);
2465      } else
2466         printf("ERROR: data Vaio 1\n");
2467      free_the_label(&label);
2468
2469      if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_VAIO_SERIAL, &label,&valid) &&
2470          valid) {
2471         a=1;
2472         for(i=0; i<32 && a!=0; i++) /* stop at first zero */
2473            if(!sensors_get_feature(*name, SENSORS_EEPROM_VAIO_SERIAL+i, &a) && a!=0)
2474               buffer[i]=(char)a;
2475         print_label(label, 24);
2476         printf("%s\n", buffer);
2477      } else
2478         printf("ERROR: data Vaio 2\n");
2479      free_the_label(&label);
2480
2481      return;
2482   }
2483
2484   if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_ROWADDR, &label,&valid) &&
2485       !sensors_get_feature(*name, SENSORS_EEPROM_ROWADDR, &a) &&
2486       !sensors_get_feature(*name, SENSORS_EEPROM_COLADDR, &b) &&
2487       !sensors_get_feature(*name, SENSORS_EEPROM_NUMROWS, &c) &&
2488       !sensors_get_feature(*name, SENSORS_EEPROM_BANKS, &d)) {
2489      if (valid) {
2490         print_label(label, 24);
2491         if(rambus) {   
2492             i = (((int) a) & 0x0f) + ((((int) a) & 0xf0) >> 4) +
2493                 (((int) c) & 0x07) - 13;
2494             if(i > 0 && i <= 12)
2495                 printf("%d\n", (1 << i));
2496             else
2497             {
2498                printf("invalid\n");
2499                printf("%d %d %d %d\n", (int) a, (int) b, (int) c, (int) d);
2500             }
2501         } else {
2502             i = (((int) a) & 0x0f) + (((int) b) & 0x0f) - 17;
2503             if(i > 0 && i <= 12 && c <= 8 && d <= 8)
2504                 printf("%d\n", (1 << i) * ((int) c) * ((int) d));
2505             else
2506             {
2507                printf("invalid\n");
2508                printf("%d %d %d %d\n", (int) a, (int) b, (int) c, (int) d);
2509             }
2510         }
2511      }
2512   } else
2513      printf("ERROR: data 2\n");
2514   free_the_label(&label);
2515
2516}
2517
2518void print_it87(const sensors_chip_name *name)
2519{
2520  char *label = NULL;
2521  double cur, min, max, fdiv;
2522  int alarms, valid;
2523
2524  if (!sensors_get_feature(*name,SENSORS_IT87_ALARMS, &cur)) {
2525    alarms = cur + 0.5;
2526  }
2527  else {
2528    printf("ERROR: Can't get alarm data!\n");
2529    alarms = 0;
2530  }
2531
2532  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN0,&label,&valid) &&
2533      !sensors_get_feature(*name,SENSORS_IT87_IN0,&cur) &&
2534      !sensors_get_feature(*name,SENSORS_IT87_IN0_MIN,&min) &&
2535      !sensors_get_feature(*name,SENSORS_IT87_IN0_MAX,&max)) {
2536    if (valid) {
2537      print_label(label,10);
2538      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
2539             cur,min,max,alarms&IT87_ALARM_IN0?"ALARM":"");
2540    }
2541  } else
2542    printf("ERROR: Can't get IN0 data!\n");
2543  free_the_label(&label);
2544  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN1,&label,&valid) &&
2545      !sensors_get_feature(*name,SENSORS_IT87_IN1,&cur) &&
2546      !sensors_get_feature(*name,SENSORS_IT87_IN1_MIN,&min) &&
2547      !sensors_get_feature(*name,SENSORS_IT87_IN1_MAX,&max)) {
2548    if (valid) {
2549      print_label(label,10);
2550      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
2551             cur,min,max,alarms&IT87_ALARM_IN1?"ALARM":"");
2552    }
2553  } else
2554    printf("ERROR: Can't get IN1 data!\n");
2555  free_the_label(&label);
2556  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN2,&label,&valid) &&
2557      !sensors_get_feature(*name,SENSORS_IT87_IN2,&cur) &&
2558      !sensors_get_feature(*name,SENSORS_IT87_IN2_MIN,&min) &&
2559      !sensors_get_feature(*name,SENSORS_IT87_IN2_MAX,&max)) {
2560    if (valid) {
2561      print_label(label,10);
2562      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
2563             cur,min,max,alarms&IT87_ALARM_IN2?"ALARM":"");
2564    }
2565  } else
2566    printf("ERROR: Can't get IN2 data!\n");
2567  free_the_label(&label);
2568  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN3,&label,&valid) &&
2569      !sensors_get_feature(*name,SENSORS_IT87_IN3,&cur) &&
2570      !sensors_get_feature(*name,SENSORS_IT87_IN3_MIN,&min) &&
2571      !sensors_get_feature(*name,SENSORS_IT87_IN3_MAX,&max)) {
2572    if (valid) {
2573      print_label(label,10);
2574      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
2575             cur,min,max,alarms&IT87_ALARM_IN3?"ALARM":"");
2576    }
2577  } else
2578    printf("ERROR: Can't get IN3 data!\n");
2579  free_the_label(&label);
2580  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN4,&label,&valid) &&
2581      !sensors_get_feature(*name,SENSORS_IT87_IN4,&cur) &&
2582      !sensors_get_feature(*name,SENSORS_IT87_IN4_MIN,&min) &&
2583      !sensors_get_feature(*name,SENSORS_IT87_IN4_MAX,&max)) {
2584    if (valid) {
2585      print_label(label,10);
2586      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
2587             cur,min,max,alarms&IT87_ALARM_IN4?"ALARM":"");
2588    }
2589  } else
2590    printf("ERROR: Can't get IN4 data!\n");
2591  free_the_label(&label);
2592  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN5,&label,&valid) &&
2593      !sensors_get_feature(*name,SENSORS_IT87_IN5,&cur) &&
2594      !sensors_get_feature(*name,SENSORS_IT87_IN5_MIN,&min) &&
2595      !sensors_get_feature(*name,SENSORS_IT87_IN5_MAX,&max)) {
2596    if (valid) {
2597      print_label(label,10);
2598      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
2599             cur,min,max,alarms&IT87_ALARM_IN5?"ALARM":"");
2600    }
2601  } else
2602    printf("ERROR: Can't get IN5 data!\n");
2603  free_the_label(&label);
2604  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN6,&label,&valid) &&
2605      !sensors_get_feature(*name,SENSORS_IT87_IN6,&cur) &&
2606      !sensors_get_feature(*name,SENSORS_IT87_IN6_MIN,&min) &&
2607      !sensors_get_feature(*name,SENSORS_IT87_IN6_MAX,&max)) {
2608    if (valid) {
2609      print_label(label,10);
2610      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
2611             cur,min,max,alarms&IT87_ALARM_IN6?"ALARM":"");
2612    }
2613  } else
2614    printf("ERROR: Can't get IN6 data!\n");
2615  free_the_label(&label);
2616  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN7,&label,&valid) &&
2617      !sensors_get_feature(*name,SENSORS_IT87_IN7,&cur) &&
2618      !sensors_get_feature(*name,SENSORS_IT87_IN7_MIN,&min) &&
2619      !sensors_get_feature(*name,SENSORS_IT87_IN7_MAX,&max)) {
2620    if (valid) {
2621      print_label(label,10);
2622      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
2623             cur,min,max,alarms&IT87_ALARM_IN7?"ALARM":"");
2624    }
2625  } else
2626    printf("ERROR: Can't get IN7 data!\n");
2627  free_the_label(&label);
2628  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN8,&label,&valid) &&
2629      !sensors_get_feature(*name,SENSORS_IT87_IN8,&cur)) {
2630    if (valid) {
2631      print_label(label,10);
2632      printf("%+6.2f V\n", cur);
2633    }
2634  } else 
2635    printf("ERROR: Can't get IN8 data!\n");
2636  free_the_label(&label);
2637
2638  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN1,&label,&valid) &&
2639      !sensors_get_feature(*name,SENSORS_IT87_FAN1,&cur) &&
2640      !sensors_get_feature(*name,SENSORS_IT87_FAN1_DIV,&fdiv) &&
2641      !sensors_get_feature(*name,SENSORS_IT87_FAN1_MIN,&min)) {
2642    if (valid) {
2643      print_label(label,10);
2644      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
2645             cur,min,fdiv, alarms&IT87_ALARM_FAN1?"ALARM":"");
2646    }
2647  } else
2648    printf("ERROR: Can't get FAN1 data!\n");
2649  free_the_label(&label);
2650  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN2,&label,&valid) &&
2651      !sensors_get_feature(*name,SENSORS_IT87_FAN2,&cur) &&
2652      !sensors_get_feature(*name,SENSORS_IT87_FAN2_DIV,&fdiv) &&
2653      !sensors_get_feature(*name,SENSORS_IT87_FAN2_MIN,&min)) {
2654    if (valid) {
2655      print_label(label,10);
2656      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
2657             cur,min,fdiv, alarms&IT87_ALARM_FAN2?"ALARM":"");
2658    }
2659  } else
2660    printf("ERROR: Can't get FAN2 data!\n");
2661  free_the_label(&label);
2662  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN3,&label,&valid) &&
2663      !sensors_get_feature(*name,SENSORS_IT87_FAN3,&cur) &&
2664      !sensors_get_feature(*name,SENSORS_IT87_FAN3_DIV,&fdiv) &&
2665      !sensors_get_feature(*name,SENSORS_IT87_FAN3_MIN,&min)) {
2666    if (valid) {
2667      print_label(label,10);
2668      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
2669             cur,min,fdiv, alarms&IT87_ALARM_FAN3?"ALARM":"");
2670    }
2671  } else
2672    printf("ERROR: Can't get FAN3 data!\n");
2673  free_the_label(&label);
2674
2675  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP1,&label,&valid) &&
2676      !sensors_get_feature(*name,SENSORS_IT87_TEMP1,&cur) &&
2677      !sensors_get_feature(*name,SENSORS_IT87_TEMP1_LOW,&min) &&
2678      !sensors_get_feature(*name,SENSORS_IT87_TEMP1_HIGH,&max)) {
2679    if (valid) {
2680      print_label(label,10);
2681      print_temp_info( cur, max, min, MINMAX, 0, 0);
2682      printf( " %s\n", alarms & IT87_ALARM_TEMP1 ? "ALARM" : "" );
2683    }
2684  } else
2685    printf("ERROR: Can't get TEMP1 data!\n");
2686  free_the_label(&label);
2687  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP2,&label,&valid) &&
2688      !sensors_get_feature(*name,SENSORS_IT87_TEMP2,&cur) &&
2689      !sensors_get_feature(*name,SENSORS_IT87_TEMP2_LOW,&min) &&
2690      !sensors_get_feature(*name,SENSORS_IT87_TEMP2_HIGH,&max)) {
2691    if (valid) {
2692      print_label(label,10);
2693      print_temp_info( cur, max, min, MINMAX, 0, 0);
2694      printf( " %s\n", alarms & IT87_ALARM_TEMP2 ? "ALARM" : "" );
2695    }
2696  } else
2697    printf("ERROR: Can't get TEMP2 data!\n");
2698  free_the_label(&label);
2699  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP3,&label,&valid) &&
2700      !sensors_get_feature(*name,SENSORS_IT87_TEMP3,&cur) &&
2701      !sensors_get_feature(*name,SENSORS_IT87_TEMP3_LOW,&min) &&
2702      !sensors_get_feature(*name,SENSORS_IT87_TEMP3_HIGH,&max)) {
2703    if (valid) {
2704      print_label(label,10);
2705      print_temp_info( cur, max, min, MINMAX, 0, 0);
2706      printf( " %s\n", alarms & IT87_ALARM_TEMP3 ? "ALARM" : "" );
2707    }
2708  } else
2709    printf("ERROR: Can't get TEMP3 data!\n");
2710  free_the_label(&label);
2711
2712  if (!sensors_get_label_and_valid(*name,SENSORS_IT87_VID,&label,&valid) &&
2713      !sensors_get_feature(*name,SENSORS_IT87_VID,&cur)) {
2714    if (valid) {
2715      print_label(label,10);
2716      printf("%+6.2f V\n",cur);
2717    }
2718  }
2719  free_the_label(&label);
2720}
2721
2722void print_fscpos(const sensors_chip_name *name)
2723{
2724  char *label = NULL;
2725  double voltage, temp,state,fan,min_rpm;
2726 int valid;
2727
2728  if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP1,&label,&valid) &&
2729      !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP1,&temp) &&
2730      !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP1_STATE,&state)) { 
2731    if (valid) {
2732      print_label(label,10);
2733        if((int) state & 0x01)
2734              printf("\t%+6.2f C \n",temp);
2735        else
2736                printf("\tfailed\n");
2737    }
2738  }
2739  free_the_label(&label);
2740  if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP2,&label,&valid) &&
2741      !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP2,&temp) &&
2742      !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP2_STATE,&state)) { 
2743    if (valid) {
2744      print_label(label,10);
2745        if((int) state & 0x01)
2746              printf("\t%+6.2f C \n",temp);
2747        else
2748                printf("\tfailed\n");
2749    }
2750  }
2751  free_the_label(&label);
2752  if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP3,&label,&valid) &&
2753      !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP3,&temp) &&
2754      !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP3_STATE,&state)) { 
2755    if (valid) {
2756      print_label(label,10);
2757        if((int) state & 0x01)
2758              printf("\t%+6.2f C \n",temp);
2759        else
2760                printf("\tfailed\n");
2761    }
2762  }
2763  free_the_label(&label);
2764  if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN1,&label,&valid) &&
2765      !sensors_get_feature(*name,SENSORS_FSCPOS_FAN1,&fan) &&
2766      !sensors_get_feature(*name,SENSORS_FSCPOS_FAN1_MIN,&min_rpm) &&
2767      !sensors_get_feature(*name,SENSORS_FSCPOS_FAN1_STATE,&state)) { 
2768    if (valid) {
2769      print_label(label,10);
2770        if((int) state & 0x02)
2771                printf("\tfaulty\n");
2772        else if (fan < min_rpm)
2773                printf("\t%6.0f RPM (not present or faulty)\n",fan);
2774        else
2775              printf("\t%6.0f RPM \n",fan);
2776    }
2777  }
2778  free_the_label(&label);
2779  if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN2,&label,&valid) &&
2780      !sensors_get_feature(*name,SENSORS_FSCPOS_FAN2,&fan) &&
2781      !sensors_get_feature(*name,SENSORS_FSCPOS_FAN2_MIN,&min_rpm) &&
2782      !sensors_get_feature(*name,SENSORS_FSCPOS_FAN2_STATE,&state)) { 
2783    if (valid) {
2784      print_label(label,10);
2785        if((int) state & 0x02)
2786                printf("\tfaulty\n");
2787        else if (fan < min_rpm)
2788                printf("\t%6.0f RPM (not present or faulty)\n",fan);
2789        else
2790              printf("\t%6.0f RPM \n",fan);
2791    }
2792  }
2793  free_the_label(&label);
2794  if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN3,&label,&valid) &&
2795      !sensors_get_feature(*name,SENSORS_FSCPOS_FAN3,&fan) &&
2796      !sensors_get_feature(*name,SENSORS_FSCPOS_FAN3_STATE,&state)) { 
2797    if (valid) {
2798      print_label(label,10);
2799        if((int) state & 0x02)
2800                printf("\tfaulty\n");
2801        else
2802              printf("\t%6.0f RPM \n",fan);
2803    }
2804  }
2805  free_the_label(&label);
2806  if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE1,&label,&valid) &&
2807      !sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE1,&voltage)) {
2808    if (valid) {
2809      print_label(label,10);
2810      printf("\t%+6.2f V\n",voltage);
2811    }
2812  }
2813  free_the_label(&label);
2814  if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE2,&label,&valid) &&
2815      !sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE2,&voltage)) {
2816    if (valid) {
2817      print_label(label,10);
2818      printf("\t%+6.2f V\n",voltage);
2819    }
2820  }
2821  free_the_label(&label);
2822  if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE3,&label,&valid) &&
2823      !sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE3,&voltage)) {
2824    if (valid) {
2825      print_label(label,10);
2826      printf("\t%+6.2f V\n",voltage);
2827    }
2828  }
2829  free_the_label(&label);
2830}
2831
2832void print_fscscy(const sensors_chip_name *name)
2833{
2834  char *label = NULL;
2835  double voltage, temp, tempmin, tempmax, templim, state,fan,min_rpm;
2836 int valid;
2837
2838  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP1,&label,&valid) &&
2839      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1,&temp) &&
2840      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_LIM,&templim) &&
2841      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_MIN,&tempmin) &&
2842      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_MAX,&tempmax) &&
2843      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_STATE,&state)) { 
2844    if (valid) {
2845      print_label(label,10);
2846        if((int) state & 0x01)
2847              printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
2848                temp,tempmin,tempmax,templim);
2849        else
2850                printf("\tfailed\n");
2851    }
2852  }
2853  free_the_label(&label);
2854  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP2,&label,&valid) &&
2855      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2,&temp) &&
2856      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_LIM,&templim) &&
2857      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_MIN,&tempmin) &&
2858      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_MAX,&tempmax) &&
2859      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_STATE,&state)) { 
2860    if (valid) {
2861      print_label(label,10);
2862        if((int) state & 0x01)
2863              printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
2864                temp,tempmin,tempmax,templim);
2865        else
2866                printf("\tfailed\n");
2867    }
2868  }
2869  free_the_label(&label);
2870  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP3,&label,&valid) &&
2871      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3,&temp) &&
2872      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_LIM,&templim) &&
2873      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_MIN,&tempmin) &&
2874      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_MAX,&tempmax) &&
2875      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_STATE,&state)) { 
2876    if (valid) {
2877      print_label(label,10);
2878        if((int) state & 0x01)
2879              printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
2880                temp,tempmin,tempmax,templim);
2881        else
2882                printf("\tfailed\n");
2883    }
2884  }
2885  free_the_label(&label);
2886  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP4,&label,&valid) &&
2887      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4,&temp) &&
2888      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_LIM,&templim) &&
2889      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_MIN,&tempmin) &&
2890      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_MAX,&tempmax) &&
2891      !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_STATE,&state)) { 
2892    if (valid) {
2893      print_label(label,10);
2894        if((int) state & 0x01)
2895              printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
2896                temp,tempmin,tempmax,templim);
2897        else
2898                printf("\tfailed\n");
2899    }
2900  }
2901  free_the_label(&label);
2902  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN1,&label,&valid) &&
2903      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN1,&fan) &&
2904      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN1_MIN,&min_rpm) &&
2905      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN1_STATE,&state)) { 
2906    if (valid) {
2907      print_label(label,10);
2908        if((int) state & 0x02)
2909                printf("\tfaulty\n");
2910        else if (fan < min_rpm)
2911                printf("\t%6.0f RPM (not present or faulty)\n",fan);
2912        else
2913              printf("\t%6.0f RPM \n",fan);
2914    }
2915  }
2916  free_the_label(&label);
2917  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN2,&label,&valid) &&
2918      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN2,&fan) &&
2919      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN2_MIN,&min_rpm) &&
2920      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN2_STATE,&state)) { 
2921    if (valid) {
2922      print_label(label,10);
2923        if((int) state & 0x02)
2924                printf("\tfaulty\n");
2925        else if (fan < min_rpm)
2926                printf("\t%6.0f RPM (not present or faulty)\n",fan);
2927        else
2928              printf("\t%6.0f RPM \n",fan);
2929    }
2930  }
2931  free_the_label(&label);
2932  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN3,&label,&valid) &&
2933      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN3,&fan) &&
2934      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN3_MIN,&min_rpm) &&
2935      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN3_STATE,&state)) { 
2936    if (valid) {
2937      print_label(label,10);
2938        if((int) state & 0x02)
2939                printf("\tfaulty\n");
2940        else if (fan < min_rpm)
2941                printf("\t%6.0f RPM (not present or faulty)\n",fan);
2942        else
2943              printf("\t%6.0f RPM \n",fan);
2944    }
2945  }
2946  free_the_label(&label);
2947  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN4,&label,&valid) &&
2948      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN4,&fan) &&
2949      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN4_MIN,&min_rpm) &&
2950      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN4_STATE,&state)) { 
2951    if (valid) {
2952      print_label(label,10);
2953        if((int) state & 0x02)
2954                printf("\tfaulty\n");
2955        else if (fan < min_rpm)
2956                printf("\t%6.0f RPM (not present or faulty)\n",fan);
2957        else
2958              printf("\t%6.0f RPM \n",fan);
2959    }
2960  }
2961  free_the_label(&label);
2962  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN5,&label,&valid) &&
2963      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN5,&fan) &&
2964      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN5_MIN,&min_rpm) &&
2965      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN5_STATE,&state)) { 
2966    if (valid) {
2967      print_label(label,10);
2968        if((int) state & 0x02)
2969                printf("\tfaulty\n");
2970        else if (fan < min_rpm)
2971                printf("\t%6.0f RPM (not present or faulty)\n",fan);
2972        else
2973              printf("\t%6.0f RPM \n",fan);
2974    }
2975  }
2976  free_the_label(&label);
2977  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN6,&label,&valid) &&
2978      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN6,&fan) &&
2979      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN6_MIN,&min_rpm) &&
2980      !sensors_get_feature(*name,SENSORS_FSCSCY_FAN6_STATE,&state)) { 
2981    if (valid) {
2982      print_label(label,10);
2983        if((int) state & 0x02)
2984                printf("\tfaulty\n");
2985        else if (fan < min_rpm)
2986                printf("\t%6.0f RPM (not present or faulty)\n",fan);
2987        else
2988              printf("\t%6.0f RPM \n",fan);
2989    }
2990  }
2991  free_the_label(&label);
2992  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE1,&label,&valid) &&
2993      !sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE1,&voltage)) {
2994    if (valid) {
2995      print_label(label,10);
2996      printf("\t%+6.2f V\n",voltage);
2997    }
2998  }
2999  free_the_label(&label);
3000  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE2,&label,&valid) &&
3001      !sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE2,&voltage)) {
3002    if (valid) {
3003      print_label(label,10);
3004      printf("\t%+6.2f V\n",voltage);
3005    }
3006  }
3007  free_the_label(&label);
3008  if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE3,&label,&valid) &&
3009      !sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE3,&voltage)) {
3010    if (valid) {
3011      print_label(label,10);
3012      printf("\t%+6.2f V\n",voltage);
3013    }
3014  }
3015  free_the_label(&label);
3016}
3017
3018void print_pcf8591(const sensors_chip_name *name)
3019{
3020  char *label;
3021  double ain_conf, ch0, ch1, ch2, ch3;
3022  double aout_enable, aout;
3023  int valid;
3024
3025  if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_AIN_CONF,&label,&valid) &&
3026      !sensors_get_feature(*name,SENSORS_PCF8591_AIN_CONF,&ain_conf)) {
3027        if (valid) {
3028          print_label(label,10);
3029          switch ((int)ain_conf)
3030          {
3031            case 0: printf("four single ended inputs\n");
3032                    break;
3033            case 1: printf("three differential inputs\n");
3034                    break;
3035            case 2: printf("single ended and differential mixed\n");
3036                    break;
3037            case 3: printf("two differential inputs\n");
3038                    break;
3039          }
3040        }
3041      }
3042  else printf("ERROR: Can't read analog inputs configuration!\n");
3043  free_the_label(&label);
3044
3045  if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH0,&label,&valid) &&
3046      !sensors_get_feature(*name,SENSORS_PCF8591_CH0,&ch0)) {
3047        if (valid) {
3048          print_label(label,10);
3049          printf("%0.0f\n", ch0);
3050        }
3051      }
3052  else printf("ERROR: Can't read ch0!\n");
3053  free_the_label(&label);
3054
3055  if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH1,&label,&valid) &&
3056      !sensors_get_feature(*name,SENSORS_PCF8591_CH1,&ch1)) {
3057        if (valid) {
3058          print_label(label,10);
3059          printf("%0.0f\n", ch1);
3060        }
3061      }
3062  else printf("ERROR: Can't read ch1!\n");
3063  free_the_label(&label);
3064
3065  if (ain_conf != 3) {
3066    if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH2,&label,&valid) &&
3067        !sensors_get_feature(*name,SENSORS_PCF8591_CH2,&ch2)) {
3068          if (valid) {
3069            print_label(label,10);
3070            printf("%0.0f\n", ch2);
3071          }
3072        }
3073    else printf("ERROR: Can't read ch2!\n");
3074    free_the_label(&label);
3075  }
3076
3077  if (ain_conf == 0) {
3078    if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH3,&label,&valid) &&
3079        !sensors_get_feature(*name,SENSORS_PCF8591_CH3,&ch3)) {
3080          if (valid) {
3081            print_label(label,10);
3082            printf("%0.0f\n", ch3);
3083          }
3084        }
3085    else printf("ERROR: Can't read ch3!\n");
3086    free_the_label(&label);
3087  }
3088
3089  if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_AOUT,&label,&valid) &&
3090      !sensors_get_feature(*name,SENSORS_PCF8591_AOUT,&aout) &&
3091      !sensors_get_feature(*name,SENSORS_PCF8591_AOUT_ENABLE,&aout_enable)) {
3092        if (valid) {
3093          print_label(label,10);
3094          printf("%0.0f (%s)\n", aout, aout_enable?"enabled":"disabled");
3095        }
3096      }
3097  else printf("ERROR: Can't read aout!\n");
3098  free_the_label(&label);
3099
3100}
3101
3102void print_vt1211(const sensors_chip_name *name)
3103{
3104  char *label = NULL;
3105  double cur,min,max,fdiv;
3106  int alarms,valid;
3107
3108  if (!sensors_get_feature(*name,SENSORS_VT1211_ALARMS,&cur)) 
3109    alarms = cur + 0.5;
3110  else {
3111    printf("ERROR: Can't get alarm data!\n");
3112    alarms = 0;
3113  }
3114
3115  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN0,&label,&valid) &&
3116      !sensors_get_feature(*name,SENSORS_VT1211_IN0,&cur) &&
3117      !sensors_get_feature(*name,SENSORS_VT1211_IN0_MIN,&min) &&
3118      !sensors_get_feature(*name,SENSORS_VT1211_IN0_MAX,&max)) {
3119    if (valid) {
3120      print_label(label,10);
3121      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3122             cur,min,max,alarms&VT1211_ALARM_IN0?"ALARM":"");
3123    }
3124  } else
3125    printf("ERROR: Can't get IN0 data!\n");
3126  free_the_label(&label);
3127  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN1,&label,&valid) &&
3128      !sensors_get_feature(*name,SENSORS_VT1211_IN1,&cur) &&
3129      !sensors_get_feature(*name,SENSORS_VT1211_IN1_MIN,&min) &&
3130      !sensors_get_feature(*name,SENSORS_VT1211_IN1_MAX,&max)) {
3131    if (valid) {
3132      print_label(label,10);
3133      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3134             cur,min,max,alarms&VT1211_ALARM_IN1?"ALARM":"");
3135    }
3136  } else
3137    printf("ERROR: Can't get IN1 data!\n");
3138  free_the_label(&label);
3139  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN2,&label,&valid) &&
3140      !sensors_get_feature(*name,SENSORS_VT1211_IN2,&cur) &&
3141      !sensors_get_feature(*name,SENSORS_VT1211_IN2_MIN,&min) &&
3142      !sensors_get_feature(*name,SENSORS_VT1211_IN2_MAX,&max)) {
3143    if (valid) {
3144      print_label(label,10);
3145      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3146             cur,min,max,alarms&VT1211_ALARM_IN2?"ALARM":"");
3147    }
3148  } else
3149    printf("ERROR: Can't get IN2 data!\n");
3150  free_the_label(&label);
3151  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN3,&label,&valid) &&
3152      !sensors_get_feature(*name,SENSORS_VT1211_IN3,&cur) &&
3153      !sensors_get_feature(*name,SENSORS_VT1211_IN3_MIN,&min) &&
3154      !sensors_get_feature(*name,SENSORS_VT1211_IN3_MAX,&max)) {
3155    if (valid) {
3156      print_label(label,10);
3157      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3158             cur,min,max,alarms&VT1211_ALARM_IN3?"ALARM":"");
3159    }
3160  } else
3161    printf("ERROR: Can't get IN3 data!\n");
3162  free_the_label(&label);
3163  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN4,&label,&valid) &&
3164      !sensors_get_feature(*name,SENSORS_VT1211_IN4,&cur) &&
3165      !sensors_get_feature(*name,SENSORS_VT1211_IN4_MIN,&min) &&
3166      !sensors_get_feature(*name,SENSORS_VT1211_IN4_MAX,&max)) {
3167    if (valid) {
3168      print_label(label,10);
3169      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3170             cur,min,max,alarms&VT1211_ALARM_IN4?"ALARM":"");
3171    }
3172  } else
3173    printf("ERROR: Can't get IN4 data!\n");
3174  free_the_label(&label);
3175  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN5,&label,&valid) &&
3176      !sensors_get_feature(*name,SENSORS_VT1211_IN5,&cur) &&
3177      !sensors_get_feature(*name,SENSORS_VT1211_IN5_MIN,&min) &&
3178      !sensors_get_feature(*name,SENSORS_VT1211_IN5_MAX,&max)) {
3179    if (valid) {
3180      print_label(label,10);
3181      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3182             cur,min,max,alarms&VT1211_ALARM_IN5?"ALARM":"");
3183    }
3184  } else
3185    printf("ERROR: Can't get IN5 data!\n");
3186  free_the_label(&label);
3187  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN6,&label,&valid) &&
3188      !sensors_get_feature(*name,SENSORS_VT1211_IN6,&cur) &&
3189      !sensors_get_feature(*name,SENSORS_VT1211_IN6_MIN,&min) &&
3190      !sensors_get_feature(*name,SENSORS_VT1211_IN6_MAX,&max)) {
3191    if (valid) {
3192      print_label(label,10);
3193      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3194             cur,min,max,alarms&VT1211_ALARM_IN6?"ALARM":"");
3195    }
3196  } else
3197    printf("ERROR: Can't get IN6 data!\n");
3198  free_the_label(&label);
3199
3200  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_FAN1,&label,&valid) &&
3201      !sensors_get_feature(*name,SENSORS_VT1211_FAN1,&cur) &&
3202      !sensors_get_feature(*name,SENSORS_VT1211_FAN1_DIV,&fdiv) &&
3203      !sensors_get_feature(*name,SENSORS_VT1211_FAN1_MIN,&min)) {
3204    if (valid) {
3205      print_label(label,10);
3206      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
3207             cur,min,fdiv, alarms&VT1211_ALARM_FAN1?"ALARM":"");
3208    }
3209  } else
3210    printf("ERROR: Can't get FAN1 data!\n");
3211  free_the_label(&label);
3212  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_FAN2,&label,&valid) &&
3213      !sensors_get_feature(*name,SENSORS_VT1211_FAN2,&cur) &&
3214      !sensors_get_feature(*name,SENSORS_VT1211_FAN2_DIV,&fdiv) &&
3215      !sensors_get_feature(*name,SENSORS_VT1211_FAN2_MIN,&min)) {
3216    if (valid) {
3217    print_label(label,10);
3218    printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
3219           cur,min,fdiv, alarms&VT1211_ALARM_FAN2?"ALARM":"");
3220    }
3221  } else
3222    printf("ERROR: Can't get FAN2 data!\n");
3223  free_the_label(&label);
3224
3225  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP,&label,&valid) &&
3226      !sensors_get_feature(*name,SENSORS_VT1211_TEMP,&cur) &&
3227      !sensors_get_feature(*name,SENSORS_VT1211_TEMP_HYST,&min) &&
3228      !sensors_get_feature(*name,SENSORS_VT1211_TEMP_OVER,&max)) {
3229    if (valid) {
3230      print_label(label,10);
3231      print_temp_info( cur, max, min, HYST, 1, 0);
3232      printf(" %s\n", alarms & VT1211_ALARM_TEMP ? "ALARM" : "" );
3233    }
3234  } else
3235    printf("ERROR: Can't get TEMP data!\n");
3236  free_the_label(&label);
3237  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP2,&label,&valid) &&
3238      !sensors_get_feature(*name,SENSORS_VT1211_TEMP2,&cur) &&
3239      !sensors_get_feature(*name,SENSORS_VT1211_TEMP2_HYST,&min) &&
3240      !sensors_get_feature(*name,SENSORS_VT1211_TEMP2_OVER,&max)) {
3241    if (valid) {
3242      print_label(label,10);
3243      print_temp_info( cur, max, min, HYST, 1, 0);
3244      printf(" %s\n", alarms & VT1211_ALARM_TEMP2 ? "ALARM" : "" );
3245    }
3246  } else
3247    printf("ERROR: Can't get TEMP2 data!\n");
3248  free_the_label(&label);
3249  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP3,&label,&valid) &&
3250      !sensors_get_feature(*name,SENSORS_VT1211_TEMP3,&cur) &&
3251      !sensors_get_feature(*name,SENSORS_VT1211_TEMP3_HYST,&min) &&
3252      !sensors_get_feature(*name,SENSORS_VT1211_TEMP3_OVER,&max)) {
3253    if (valid) {
3254      print_label(label,10);
3255      print_temp_info( cur, max, min, HYST, 1, 0);
3256      printf(" %s\n", alarms & VT1211_ALARM_TEMP3 ? "ALARM" : "" );
3257    }
3258  } else
3259    printf("ERROR: Can't get TEMP3 data!\n");
3260  free_the_label(&label);
3261  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP4,&label,&valid) &&
3262      !sensors_get_feature(*name,SENSORS_VT1211_TEMP4,&cur) &&
3263      !sensors_get_feature(*name,SENSORS_VT1211_TEMP4_HYST,&min) &&
3264      !sensors_get_feature(*name,SENSORS_VT1211_TEMP4_OVER,&max)) {
3265    if (valid) {
3266      print_label(label,10);
3267      print_temp_info( cur, max, min, HYST, 1, 0);
3268      printf(" %s\n", alarms & VT1211_ALARM_TEMP4 ? "ALARM" : "" );
3269    }
3270  } else
3271    printf("ERROR: Can't get TEMP4 data!\n");
3272  free_the_label(&label);
3273  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP5,&label,&valid) &&
3274      !sensors_get_feature(*name,SENSORS_VT1211_TEMP5,&cur) &&
3275      !sensors_get_feature(*name,SENSORS_VT1211_TEMP5_HYST,&min) &&
3276      !sensors_get_feature(*name,SENSORS_VT1211_TEMP5_OVER,&max)) {
3277    if (valid) {
3278      print_label(label,10);
3279      print_temp_info( cur, max, min, HYST, 1, 0);
3280      printf(" %s\n", alarms & VT1211_ALARM_TEMP5 ? "ALARM" : "" );
3281    }
3282  } else
3283    printf("ERROR: Can't get TEMP5 data!\n");
3284  free_the_label(&label);
3285  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP6,&label,&valid) &&
3286      !sensors_get_feature(*name,SENSORS_VT1211_TEMP6,&cur) &&
3287      !sensors_get_feature(*name,SENSORS_VT1211_TEMP6_HYST,&min) &&
3288      !sensors_get_feature(*name,SENSORS_VT1211_TEMP6_OVER,&max)) {
3289    if (valid) {
3290      print_label(label,10);
3291      print_temp_info( cur, max, min, HYST, 1, 0);
3292      printf(" %s\n", alarms & VT1211_ALARM_TEMP6 ? "ALARM" : "" );
3293    }
3294  } else
3295    printf("ERROR: Can't get TEMP6 data!\n");
3296  free_the_label(&label);
3297  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP7,&label,&valid) &&
3298      !sensors_get_feature(*name,SENSORS_VT1211_TEMP7,&cur) &&
3299      !sensors_get_feature(*name,SENSORS_VT1211_TEMP7_HYST,&min) &&
3300      !sensors_get_feature(*name,SENSORS_VT1211_TEMP7_OVER,&max)) {
3301    if (valid) {
3302      print_label(label,10);
3303      print_temp_info( cur, max, min, HYST, 1, 0);
3304      printf(" %s\n", alarms & VT1211_ALARM_TEMP7 ? "ALARM" : "" );
3305    }
3306  } else
3307    printf("ERROR: Can't get TEMP7 data!\n");
3308  free_the_label(&label);
3309
3310  if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_VID,&label,&valid) &&
3311      !sensors_get_feature(*name,SENSORS_VT1211_VID,&cur)) {
3312    if (valid) {
3313      print_label(label,10);
3314      printf("%+6.2f V\n",cur);
3315    }
3316  }
3317  free_the_label(&label);
3318
3319}
3320
3321void print_smsc47m1(const sensors_chip_name *name)
3322{
3323  char *label = NULL;
3324  double cur,min,fdiv;
3325  int alarms,valid;
3326
3327  if (!sensors_get_feature(*name,SENSORS_SMSC47M1_ALARMS,&cur)) 
3328    alarms = cur + 0.5;
3329  else {
3330    printf("ERROR: Can't get alarm data!\n");
3331    alarms = 0;
3332  }
3333
3334  if (!sensors_get_label_and_valid(*name,SENSORS_SMSC47M1_FAN1,&label,&valid) &&
3335      !sensors_get_feature(*name,SENSORS_SMSC47M1_FAN1,&cur) &&
3336      !sensors_get_feature(*name,SENSORS_SMSC47M1_FAN1_DIV,&fdiv) &&
3337      !sensors_get_feature(*name,SENSORS_SMSC47M1_FAN1_MIN,&min)) {
3338    if (valid) {
3339    print_label(label,10);
3340    printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
3341           cur,min,fdiv, alarms&SMSC47M1_ALARM_FAN1?"ALARM":"");
3342    }
3343  } else
3344    printf("ERROR: Can't get FAN1 data!\n");
3345  free_the_label(&label);
3346
3347  if (!sensors_get_label_and_valid(*name,SENSORS_SMSC47M1_FAN2,&label,&valid) &&
3348      !sensors_get_feature(*name,SENSORS_SMSC47M1_FAN2,&cur) &&
3349      !sensors_get_feature(*name,SENSORS_SMSC47M1_FAN2_DIV,&fdiv) &&
3350      !sensors_get_feature(*name,SENSORS_SMSC47M1_FAN2_MIN,&min)) {
3351    if (valid) {
3352    print_label(label,10);
3353    printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
3354           cur,min,fdiv, alarms&SMSC47M1_ALARM_FAN2?"ALARM":"");
3355    }
3356  } else
3357    printf("ERROR: Can't get FAN2 data!\n");
3358  free_the_label(&label);
3359
3360}
3361
3362static void lm92_print_temp (float n_cur,float n_high,float n_low,float n_crit,float n_hyst)
3363{
3364        char suffix[5];
3365
3366        if (fahrenheit) {
3367                sprintf (suffix,"%cF",176);
3368                n_cur = deg_ctof (n_cur);
3369                n_high = deg_ctof (n_high);
3370                n_low = deg_ctof (n_low);
3371                n_crit = deg_ctof (n_crit);
3372                n_hyst = deg_ctof (n_hyst);
3373        } else sprintf (suffix,"%cC",176);
3374
3375        printf ("%+6.4f%s (high = %+6.4f%s, low = %+6.4f%s, crit = %+6.4f%s, hyst = %+6.4f%s)",
3376                        n_cur,suffix,
3377                        n_high,suffix,
3378                        n_low,suffix,
3379                        n_crit,suffix,
3380                        n_hyst,suffix);
3381}
3382
3383void print_lm92 (const sensors_chip_name *name)
3384{
3385        char *label = NULL;
3386        double temp[5];
3387        int valid,alarms;
3388
3389        if (!sensors_get_feature (*name,SENSORS_LM92_ALARMS,temp)) {
3390                alarms = *temp + 0.5;
3391        } else {
3392                printf ("ERROR: Can't get alarm data!\n");
3393                return;
3394        }
3395
3396        if (!sensors_get_label_and_valid (*name,SENSORS_LM92_TEMP,&label,&valid) &&
3397                !sensors_get_feature (*name,SENSORS_LM92_TEMP,temp) &&
3398                !sensors_get_feature (*name,SENSORS_LM92_TEMP_HIGH,temp + 1) &&
3399                !sensors_get_feature (*name,SENSORS_LM92_TEMP_LOW,temp + 2) &&
3400                !sensors_get_feature (*name,SENSORS_LM92_TEMP_CRIT,temp + 3) &&
3401                !sensors_get_feature (*name,SENSORS_LM92_TEMP_HYST,temp + 4)) {
3402                if (valid) {
3403                        print_label (label,10);
3404                        lm92_print_temp (temp[0],temp[1],temp[2],temp[3],temp[4]);
3405                        if (alarms) {
3406                                printf (" ALARMS (");
3407
3408                                if ((alarms & LM92_ALARM_TEMP_HIGH))
3409                                        printf ("HIGH");
3410
3411                                if (alarms & LM92_ALARM_TEMP_LOW)
3412                                        printf ("%sLOW",(alarms & LM92_ALARM_TEMP_HIGH) ? "," : "");
3413
3414                                if (alarms & LM92_ALARM_TEMP_CRIT)
3415                                        printf ("%sCRIT",(alarms & (LM92_ALARM_TEMP_HIGH | LM92_ALARM_TEMP_LOW)) ? "," : "");
3416
3417                                printf (")");
3418                        }
3419                        printf ("\n");
3420                }
3421        } else printf ("ERROR: Can't get temperature data!\n");
3422
3423        free_the_label (&label);
3424}
3425
3426void print_vt8231(const sensors_chip_name *name)
3427{
3428  char *label = NULL;
3429  double cur,min,max,fdiv;
3430  int alarms,valid;
3431
3432  if (!sensors_get_feature(*name,SENSORS_VT8231_ALARMS,&cur)) 
3433    alarms = cur + 0.5;
3434  else {
3435    printf("ERROR: Can't get alarm data!\n");
3436    alarms = 0;
3437  }
3438
3439  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN0,&label,&valid) &&
3440      !sensors_get_feature(*name,SENSORS_VT8231_IN0,&cur) &&
3441      !sensors_get_feature(*name,SENSORS_VT8231_IN0_MIN,&min) &&
3442      !sensors_get_feature(*name,SENSORS_VT8231_IN0_MAX,&max)) {
3443    if (valid) {
3444      print_label(label,10);
3445      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3446             cur,min,max,alarms&VT8231_ALARM_IN0?"ALARM":"");
3447    }
3448  } else
3449    printf("ERROR: Can't get IN0 data!\n");
3450  free_the_label(&label);
3451  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN1,&label,&valid) &&
3452      !sensors_get_feature(*name,SENSORS_VT8231_IN1,&cur) &&
3453      !sensors_get_feature(*name,SENSORS_VT8231_IN1_MIN,&min) &&
3454      !sensors_get_feature(*name,SENSORS_VT8231_IN1_MAX,&max)) {
3455    if (valid) {
3456      print_label(label,10);
3457      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3458             cur,min,max,alarms&VT8231_ALARM_IN1?"ALARM":"");
3459    }
3460  } else
3461    printf("ERROR: Can't get IN1 data!\n");
3462  free_the_label(&label);
3463  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN2,&label,&valid) &&
3464      !sensors_get_feature(*name,SENSORS_VT8231_IN2,&cur) &&
3465      !sensors_get_feature(*name,SENSORS_VT8231_IN2_MIN,&min) &&
3466      !sensors_get_feature(*name,SENSORS_VT8231_IN2_MAX,&max)) {
3467    if (valid) {
3468      print_label(label,10);
3469      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3470             cur,min,max,alarms&VT8231_ALARM_IN2?"ALARM":"");
3471    }
3472  } else
3473    printf("ERROR: Can't get IN2 data!\n");
3474  free_the_label(&label);
3475  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN3,&label,&valid) &&
3476      !sensors_get_feature(*name,SENSORS_VT8231_IN3,&cur) &&
3477      !sensors_get_feature(*name,SENSORS_VT8231_IN3_MIN,&min) &&
3478      !sensors_get_feature(*name,SENSORS_VT8231_IN3_MAX,&max)) {
3479    if (valid) {
3480      print_label(label,10);
3481      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3482             cur,min,max,alarms&VT8231_ALARM_IN3?"ALARM":"");
3483    }
3484  } else
3485    printf("ERROR: Can't get IN3 data!\n");
3486  free_the_label(&label);
3487  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN4,&label,&valid) &&
3488      !sensors_get_feature(*name,SENSORS_VT8231_IN4,&cur) &&
3489      !sensors_get_feature(*name,SENSORS_VT8231_IN4_MIN,&min) &&
3490      !sensors_get_feature(*name,SENSORS_VT8231_IN4_MAX,&max)) {
3491    if (valid) {
3492      print_label(label,10);
3493      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3494             cur,min,max,alarms&VT8231_ALARM_IN4?"ALARM":"");
3495    }
3496  } else
3497    printf("ERROR: Can't get IN4 data!\n");
3498  free_the_label(&label);
3499  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN5,&label,&valid) &&
3500      !sensors_get_feature(*name,SENSORS_VT8231_IN5,&cur) &&
3501      !sensors_get_feature(*name,SENSORS_VT8231_IN5_MIN,&min) &&
3502      !sensors_get_feature(*name,SENSORS_VT8231_IN5_MAX,&max)) {
3503    if (valid) {
3504      print_label(label,10);
3505      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3506             cur,min,max,alarms&VT8231_ALARM_IN5?"ALARM":"");
3507    }
3508  } else
3509    printf("ERROR: Can't get IN5 data!\n");
3510  free_the_label(&label);
3511  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN6,&label,&valid) &&
3512      !sensors_get_feature(*name,SENSORS_VT8231_IN6,&cur) &&
3513      !sensors_get_feature(*name,SENSORS_VT8231_IN6_MIN,&min) &&
3514      !sensors_get_feature(*name,SENSORS_VT8231_IN6_MAX,&max)) {
3515    if (valid) {
3516      print_label(label,10);
3517      printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3518             cur,min,max,alarms&VT8231_ALARM_IN6?"ALARM":"");
3519    }
3520  } else
3521    printf("ERROR: Can't get IN6 data!\n");
3522  free_the_label(&label);
3523
3524  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_FAN1,&label,&valid) &&
3525      !sensors_get_feature(*name,SENSORS_VT8231_FAN1,&cur) &&
3526      !sensors_get_feature(*name,SENSORS_VT8231_FAN1_DIV,&fdiv) &&
3527      !sensors_get_feature(*name,SENSORS_VT8231_FAN1_MIN,&min)) {
3528    if (valid) {
3529      print_label(label,10);
3530      printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
3531             cur,min,fdiv, alarms&VT8231_ALARM_FAN1?"ALARM":"");
3532    }
3533  } else
3534    printf("ERROR: Can't get FAN1 data!\n");
3535  free_the_label(&label);
3536  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_FAN2,&label,&valid) &&
3537      !sensors_get_feature(*name,SENSORS_VT8231_FAN2,&cur) &&
3538      !sensors_get_feature(*name,SENSORS_VT8231_FAN2_DIV,&fdiv) &&
3539      !sensors_get_feature(*name,SENSORS_VT8231_FAN2_MIN,&min)) {
3540    if (valid) {
3541    print_label(label,10);
3542    printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n",
3543           cur,min,fdiv, alarms&VT8231_ALARM_FAN2?"ALARM":"");
3544    }
3545  } else
3546    printf("ERROR: Can't get FAN2 data!\n");
3547  free_the_label(&label);
3548
3549  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP,&label,&valid) &&
3550      !sensors_get_feature(*name,SENSORS_VT8231_TEMP,&cur) &&
3551      !sensors_get_feature(*name,SENSORS_VT8231_TEMP_HYST,&min) &&
3552      !sensors_get_feature(*name,SENSORS_VT8231_TEMP_OVER,&max)) {
3553    if (valid) {
3554      print_label(label,10);
3555      print_temp_info( cur, max, min, HYST, 1, 0);
3556      printf(" %s\n", alarms & VT8231_ALARM_TEMP ? "ALARM" : "" );
3557    }
3558  } else
3559    printf("ERROR: Can't get TEMP data!\n");
3560  free_the_label(&label);
3561  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP2,&label,&valid) &&
3562      !sensors_get_feature(*name,SENSORS_VT8231_TEMP2,&cur) &&
3563      !sensors_get_feature(*name,SENSORS_VT8231_TEMP2_HYST,&min) &&
3564      !sensors_get_feature(*name,SENSORS_VT8231_TEMP2_OVER,&max)) {
3565    if (valid) {
3566      print_label(label,10);
3567      print_temp_info( cur, max, min, HYST, 1, 0);
3568      printf(" %s\n", alarms & VT8231_ALARM_TEMP2 ? "ALARM" : "" );
3569    }
3570  } else
3571    printf("ERROR: Can't get TEMP2 data!\n");
3572  free_the_label(&label);
3573  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP3,&label,&valid) &&
3574      !sensors_get_feature(*name,SENSORS_VT8231_TEMP3,&cur) &&
3575      !sensors_get_feature(*name,SENSORS_VT8231_TEMP3_HYST,&min) &&
3576      !sensors_get_feature(*name,SENSORS_VT8231_TEMP3_OVER,&max)) {
3577    if (valid) {
3578      print_label(label,10);
3579      print_temp_info( cur, max, min, HYST, 1, 0);
3580      printf(" %s\n", alarms & VT8231_ALARM_TEMP3 ? "ALARM" : "" );
3581    }
3582  } else
3583    printf("ERROR: Can't get TEMP3 data!\n");
3584  free_the_label(&label);
3585  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP4,&label,&valid) &&
3586      !sensors_get_feature(*name,SENSORS_VT8231_TEMP4,&cur) &&
3587      !sensors_get_feature(*name,SENSORS_VT8231_TEMP4_HYST,&min) &&
3588      !sensors_get_feature(*name,SENSORS_VT8231_TEMP4_OVER,&max)) {
3589    if (valid) {
3590      print_label(label,10);
3591      print_temp_info( cur, max, min, HYST, 1, 0);
3592      printf(" %s\n", alarms & VT8231_ALARM_TEMP4 ? "ALARM" : "" );
3593    }
3594  } else
3595    printf("ERROR: Can't get TEMP4 data!\n");
3596  free_the_label(&label);
3597  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP5,&label,&valid) &&
3598      !sensors_get_feature(*name,SENSORS_VT8231_TEMP5,&cur) &&
3599      !sensors_get_feature(*name,SENSORS_VT8231_TEMP5_HYST,&min) &&
3600      !sensors_get_feature(*name,SENSORS_VT8231_TEMP5_OVER,&max)) {
3601    if (valid) {
3602      print_label(label,10);
3603      print_temp_info( cur, max, min, HYST, 1, 0);
3604      printf(" %s\n", alarms & VT8231_ALARM_TEMP5 ? "ALARM" : "" );
3605    }
3606  } else
3607    printf("ERROR: Can't get TEMP5 data!\n");
3608  free_the_label(&label);
3609  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP6,&label,&valid) &&
3610      !sensors_get_feature(*name,SENSORS_VT8231_TEMP6,&cur) &&
3611      !sensors_get_feature(*name,SENSORS_VT8231_TEMP6_HYST,&min) &&
3612      !sensors_get_feature(*name,SENSORS_VT8231_TEMP6_OVER,&max)) {
3613    if (valid) {
3614      print_label(label,10);
3615      print_temp_info( cur, max, min, HYST, 1, 0);
3616      printf(" %s\n", alarms & VT8231_ALARM_TEMP6 ? "ALARM" : "" );
3617    }
3618  } else
3619    printf("ERROR: Can't get TEMP6 data!\n");
3620  free_the_label(&label);
3621  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP7,&label,&valid) &&
3622      !sensors_get_feature(*name,SENSORS_VT8231_TEMP7,&cur) &&
3623      !sensors_get_feature(*name,SENSORS_VT8231_TEMP7_HYST,&min) &&
3624      !sensors_get_feature(*name,SENSORS_VT8231_TEMP7_OVER,&max)) {
3625    if (valid) {
3626      print_label(label,10);
3627      print_temp_info( cur, max, min, HYST, 1, 0);
3628      printf(" %s\n", alarms & VT8231_ALARM_TEMP7 ? "ALARM" : "" );
3629    }
3630  } else
3631    printf("ERROR: Can't get TEMP7 data!\n");
3632  free_the_label(&label);
3633
3634  if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_VID,&label,&valid) &&
3635      !sensors_get_feature(*name,SENSORS_VT8231_VID,&cur)) {
3636    if (valid) {
3637      print_label(label,10);
3638      printf("%+6.2f V\n",cur);
3639    }
3640  }
3641  free_the_label(&label);
3642
3643}
3644
3645#define BMC_MAX_INS 10
3646#define BMC_MAX_FANS 10
3647#define BMC_MAX_TEMPS 10
3648
3649void print_bmc(const sensors_chip_name *name)
3650{
3651  char *label = NULL;
3652  double cur,min,max;
3653  int alarms, valid, i;
3654
3655/*
3656  if (!sensors_get_feature(*name,SENSORS_VT8231_ALARMS,&cur))
3657    alarms = cur + 0.5;
3658  else {
3659    printf("ERROR: Can't get alarm data!\n");
3660    alarms = 0;
3661  }
3662*/
3663#define BMC_ALARM_IN1 0
3664#define BMC_ALARM_FAN1 0
3665#define BMC_ALARM_TEMP1 0
3666
3667    alarms = 0;
3668  for(i = 0; i < BMC_MAX_INS; i++) {
3669          if (!sensors_get_label_and_valid(*name,SENSORS_BMC_IN1+i,&label,&valid) &&
3670              !sensors_get_feature(*name,SENSORS_BMC_IN1+i,&cur) &&
3671              !sensors_get_feature(*name,SENSORS_BMC_IN1_MIN+i,&min) &&
3672              !sensors_get_feature(*name,SENSORS_BMC_IN1_MAX+i,&max)) {
3673            if (valid) {
3674              print_label(label,10);
3675              printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n",
3676                     cur,min,max,alarms&BMC_ALARM_IN1?"ALARM":"");
3677            }
3678          }
3679          free_the_label(&label);
3680  }
3681
3682  for(i = 0; i < BMC_MAX_FANS; i++) {
3683          if (!sensors_get_label_and_valid(*name,SENSORS_BMC_FAN1+i,&label,&valid) &&
3684              !sensors_get_feature(*name,SENSORS_BMC_FAN1+i,&cur) &&
3685              !sensors_get_feature(*name,SENSORS_BMC_FAN1_MIN+i,&min)) {
3686            if (valid) {
3687              print_label(label,10);
3688              printf("%4.0f RPM  (min = %4.0f RPM)                  %s\n",
3689                     cur,min,alarms&BMC_ALARM_FAN1?"ALARM":"");
3690            }
3691          }
3692          free_the_label(&label);
3693  }
3694
3695  for(i = 0; i < BMC_MAX_TEMPS; i++) {
3696          if (!sensors_get_label_and_valid(*name,SENSORS_BMC_TEMP1+i,&label,&valid) &&
3697              !sensors_get_feature(*name,SENSORS_BMC_TEMP1+i,&cur) &&
3698              !sensors_get_feature(*name,SENSORS_BMC_TEMP1_MIN+i,&min) &&
3699              !sensors_get_feature(*name,SENSORS_BMC_TEMP1_MAX+i,&max)) {
3700            if (valid) {
3701              print_label(label,10);
3702              print_temp_info( cur, max, min, HYST, 1, 0);
3703              printf(" %s\n", alarms & BMC_ALARM_TEMP1 ? "ALARM" : "" );
3704            }
3705          }
3706          free_the_label(&label);
3707  }     
3708}
3709
3710void print_unknown_chip(const sensors_chip_name *name)
3711{
3712  int a,b,valid;
3713  const sensors_feature_data *data;
3714  char *label;
3715  double val;
3716 
3717  a=b=0;
3718  while((data=sensors_get_all_features(*name,&a,&b))) {
3719    if (sensors_get_label_and_valid(*name,data->number,&label,&valid)) {
3720      printf("ERROR: Can't get feature `%s' data!",data->name);
3721      continue;
3722    }
3723    if (! valid)
3724      continue;
3725    if (data->mode & SENSORS_MODE_R) {
3726      if(sensors_get_feature(*name,data->number,&val)) {
3727        printf("ERROR: Can't get feature `%s' data!",data->name);
3728        continue;
3729      }
3730      if (data->mapping != SENSORS_NO_MAPPING)
3731        printf("  %s: %.2f (%s)\n",label,val,data->name);
3732      else
3733        printf("%s: %.2f (%s)\n",label,val,data->name);
3734    } else 
3735      printf("(%s)",label);
3736  }
3737}
3738
Note: See TracBrowser for help on using the browser.