Context Navigation

chips.c @ 2289

Revision 2289, 174.4 KB (checked in by khali, 9 years ago)
Add support for the W83637HF.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`

Line
1	/*
2	chips.c - Part of sensors, a user-space program for hardware monitoring
3	Copyright (c) 1998-2003 Frodo Looijaard <frodol@dds.nl>, Mark D.
4	Studebaker <mdsxyz123@yahoo.com> and the lm_sensors team
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
30	static void print_label(const char *label, int space);
31	static void free_the_label(char **label);
32	static void print_temp_info(float, float, float, int, int, int);
33	static inline float deg_ctof( float );
34
35	extern int fahrenheit;
36	extern char degstr[5];
37
38	inline float deg_ctof( float cel )
39	{
40	return ( cel * ( 9.0F / 5.0F ) + 32.0F );
41	}
42
43	#define HYST 0
44	#define MINMAX 1
45	#define MAXONLY 2
46	#define CRIT 3
47	#define SINGLE 4
48	#define HYSTONLY 5
49	/* minmax = 0 for limit/hysteresis, 1 for max/min, 2 for max only;
50	curprec and limitprec are # of digits after decimal point
51	for the current temp and the limits */
52	void print_temp_info(float n_cur, float n_over, float n_hyst,
53	int minmax, int curprec, int limitprec)
54	{
55	if (fahrenheit) {
56	n_cur = deg_ctof(n_cur);
57	n_over = deg_ctof(n_over);
58	n_hyst = deg_ctof(n_hyst);
59	}
60
61	/* use %* to pass precision as an argument */
62	if(minmax == MINMAX)
63	printf("%+6.f%s (low = %+5.f%s, high = %+5.*f%s) ",
64	curprec, n_cur, degstr,
65	limitprec, n_hyst, degstr,
66	limitprec, n_over, degstr);
67	else if(minmax == MAXONLY)
68	printf("%+6.f%s (high = %+5.f%s) ",
69	curprec, n_cur, degstr,
70	limitprec, n_over, degstr);
71	else if(minmax == CRIT)
72	printf("%+6.f%s (high = %+5.f%s, crit = %+5.*f%s) ",
73	curprec, n_cur, degstr,
74	limitprec, n_over, degstr,
75	limitprec, n_hyst, degstr);
76	else if(minmax == HYST)
77	printf("%+6.f%s (high = %+5.f%s, hyst = %+5.*f%s) ",
78	curprec, n_cur, degstr,
79	limitprec, n_over, degstr,
80	limitprec, n_hyst, degstr);
81	else if(minmax == SINGLE)
82	printf("%+6.*f%s",
83	curprec, n_cur, degstr);
84	else if(minmax == HYSTONLY)
85	printf( "%+6.f%s (hyst = %+5.f%s) ",
86	curprec, n_cur, degstr,
87	limitprec, n_over, degstr);
88	else
89	printf("Unknown temperature mode!");
90	}
91
92	void print_label(const char *label, int space)
93	{
94	int len=strlen(label)+1;
95	if (len > space)
96	printf("%s:\n%*s", label, space, "");
97	else
98	printf("%s:%*s", label, space - len, "");
99	}
100
101	void free_the_label(char **label)
102	{
103	if (*label)
104	free(*label);
105	*label = NULL;
106	}
107
108	int sensors_get_label_and_valid(sensors_chip_name name, int feature, char **label,
109	int *valid)
110	{
111	int err;
112	err = sensors_get_label(name,feature,label);
113	if (!err)
114	err = sensors_get_ignored(name,feature);
115	if (err >= 0) {
116	*valid = err;
117	err = 0;
118	}
119	return err;
120	}
121
122	void print_ds1621(const sensors_chip_name *name)
123	{
124	char *label;
125	double cur,hyst,over;
126	int alarms, valid;
127
128	if (!sensors_get_feature(*name,SENSORS_LM78_ALARMS,&cur))
129	alarms = cur + 0.5;
130	else {
131	printf("ERROR: Can't get alarm data!\n");
132	alarms = 0;
133	}
134
135	if (!sensors_get_label_and_valid(*name,SENSORS_DS1621_TEMP,&label,&valid) &&
136	!sensors_get_feature(*name,SENSORS_DS1621_TEMP,&cur) &&
137	!sensors_get_feature(*name,SENSORS_DS1621_TEMP_HYST,&hyst) &&
138	!sensors_get_feature(*name,SENSORS_DS1621_TEMP_OVER,&over)) {
139	if (valid) {
140	print_label(label,10);
141	print_temp_info( cur, over, hyst, MINMAX, 2, 1);
142	if (alarms & (DS1621_ALARM_TEMP_HIGH \| DS1621_ALARM_TEMP_LOW)) {
143	printf("ALARM (");
144	if (alarms & DS1621_ALARM_TEMP_LOW) {
145	printf("LOW");
146	}
147	if (alarms & DS1621_ALARM_TEMP_HIGH)
148	printf("%sHIGH",(alarms & DS1621_ALARM_TEMP_LOW)?",":"");
149	printf(")");
150	}
151	printf("\n");
152	}
153	} else
154	printf("ERROR: Can't get temperature data!\n");
155	free_the_label(&label);
156	}
157
158	void print_lm75(const sensors_chip_name *name)
159	{
160	char *label;
161	double cur,hyst,over;
162	int valid;
163
164	if (!sensors_get_label_and_valid(*name,SENSORS_LM75_TEMP,&label,&valid) &&
165	!sensors_get_feature(*name,SENSORS_LM75_TEMP,&cur) &&
166	!sensors_get_feature(*name,SENSORS_LM75_TEMP_HYST,&hyst) &&
167	!sensors_get_feature(*name,SENSORS_LM75_TEMP_OVER,&over)) {
168	if (valid) {
169	print_label(label,10);
170	print_temp_info( cur, over, hyst, HYST, 1, 1);
171	printf( "\n" );
172	}
173	} else
174	printf("ERROR: Can't get temperature data!\n");
175	free_the_label(&label);
176	}
177
178	void print_adm1021(const sensors_chip_name *name)
179	{
180	char *label;
181	double cur,hyst,over;
182	int alarms,i,valid;
183
184	if (!sensors_get_feature(*name,SENSORS_ADM1021_ALARMS,&cur))
185	alarms = cur + 0.5;
186	else {
187	printf("ERROR: Can't get alarm data!\n");
188	alarms = 0;
189	}
190
191	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1021_TEMP,&label,&valid) &&
192	!sensors_get_feature(*name,SENSORS_ADM1021_TEMP,&cur) &&
193	!sensors_get_feature(*name,SENSORS_ADM1021_TEMP_HYST,&hyst) &&
194	!sensors_get_feature(*name,SENSORS_ADM1021_TEMP_OVER,&over)) {
195	if (valid) {
196	print_label(label,10);
197	print_temp_info( cur, over, hyst, MINMAX, 0, 0);
198	if (alarms & (ADM1021_ALARM_TEMP_HIGH \| ADM1021_ALARM_TEMP_LOW)) {
199	printf("ALARM (");
200	i = 0;
201	if (alarms & ADM1021_ALARM_TEMP_LOW) {
202	printf("LOW");
203	i++;
204	}
205	if (alarms & ADM1021_ALARM_TEMP_HIGH)
206	printf("%sHIGH",i?",":"");
207	printf(")");
208	}
209	printf("\n");
210	}
211	} else
212	printf("ERROR: Can't get temperature data!\n");
213	free_the_label(&label);
214
215	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1021_REMOTE_TEMP,
216	&label,&valid) &&
217	!sensors_get_feature(*name,SENSORS_ADM1021_REMOTE_TEMP,&cur) &&
218	!sensors_get_feature(*name,SENSORS_ADM1021_REMOTE_TEMP_HYST,&hyst) &&
219	!sensors_get_feature(*name,SENSORS_ADM1021_REMOTE_TEMP_OVER,&over)) {
220	if (valid) {
221	print_label(label,10);
222	print_temp_info( cur, over, hyst, MINMAX, 0, 0);
223	if (alarms & (ADM1021_ALARM_RTEMP_HIGH \| ADM1021_ALARM_RTEMP_LOW \|
224	ADM1021_ALARM_RTEMP_NA)) {
225	printf("ALARM (");
226	i = 0;
227	if (alarms & ADM1021_ALARM_RTEMP_NA) {
228	printf("N/A");
229	i++;
230	}
231	if (alarms & ADM1021_ALARM_RTEMP_LOW) {
232	printf("%sLOW",i?",":"");
233	i++;
234	}
235	if (alarms & ADM1021_ALARM_RTEMP_HIGH)
236	printf("%sHIGH",i?",":"");
237	printf(")");
238	}
239	printf("\n");
240	}
241	} else
242	printf("ERROR: Can't get temperature data!\n");
243	free_the_label(&label);
244
245	if (!strcmp(name->prefix,"adm1021")) {
246	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1021_DIE_CODE,
247	&label,&valid) &&
248	!sensors_get_feature(*name,SENSORS_ADM1021_DIE_CODE,&cur)) {
249	if (valid) {
250	print_label(label,10);
251	printf("%4.0f\n",cur);
252	}
253	} else
254	printf("ERROR: Can't get die-code data!\n");
255	free_the_label(&label);
256	}
257	}
258
259	void print_adm9240(const sensors_chip_name *name)
260	{
261	char *label = NULL;
262	double cur,min,max,fdiv;
263	int alarms;
264	int valid;
265
266	if (!sensors_get_feature(*name,SENSORS_ADM9240_ALARMS,&cur))
267	alarms = cur + 0.5;
268	else {
269	printf("ERROR: Can't get alarm data!\n");
270	alarms = 0;
271	}
272
273	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN0,&label,&valid) &&
274	!sensors_get_feature(*name,SENSORS_ADM9240_IN0,&cur) &&
275	!sensors_get_feature(*name,SENSORS_ADM9240_IN0_MIN,&min) &&
276	!sensors_get_feature(*name,SENSORS_ADM9240_IN0_MAX,&max)) {
277	if (valid) {
278	print_label(label,10);
279	printf( "%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
280	cur,min,max,alarms&ADM9240_ALARM_IN0?"ALARM":"");
281	}
282	} else
283	printf("ERROR: Can't get IN0 data!\n");
284	free_the_label(&label);
285	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN1,&label,&valid) &&
286	!sensors_get_feature(*name,SENSORS_ADM9240_IN1,&cur) &&
287	!sensors_get_feature(*name,SENSORS_ADM9240_IN1_MIN,&min) &&
288	!sensors_get_feature(*name,SENSORS_ADM9240_IN1_MAX,&max)) {
289	if (valid) {
290	print_label(label,10);
291	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
292	cur,min,max,alarms&ADM9240_ALARM_IN1?"ALARM":"");
293	}
294	} else
295	printf("ERROR: Can't get IN1 data!\n");
296	free_the_label(&label);
297	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN2,&label,&valid) &&
298	!sensors_get_feature(*name,SENSORS_ADM9240_IN2,&cur) &&
299	!sensors_get_feature(*name,SENSORS_ADM9240_IN2_MIN,&min) &&
300	!sensors_get_feature(*name,SENSORS_ADM9240_IN2_MAX,&max)) {
301	if (valid) {
302	print_label(label,10);
303	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
304	cur,min,max,alarms&ADM9240_ALARM_IN2?"ALARM":"");
305	}
306	} else
307	printf("ERROR: Can't get IN2 data!\n");
308	free_the_label(&label);
309	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN3,&label,&valid) &&
310	!sensors_get_feature(*name,SENSORS_ADM9240_IN3,&cur) &&
311	!sensors_get_feature(*name,SENSORS_ADM9240_IN3_MIN,&min) &&
312	!sensors_get_feature(*name,SENSORS_ADM9240_IN3_MAX,&max)) {
313	if (valid) {
314	print_label(label,10);
315	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
316	cur,min,max,alarms&ADM9240_ALARM_IN3?"ALARM":"");
317	}
318	} else
319	printf("ERROR: Can't get IN3 data!\n");
320	free_the_label(&label);
321	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN4,&label,&valid) &&
322	!sensors_get_feature(*name,SENSORS_ADM9240_IN4,&cur) &&
323	!sensors_get_feature(*name,SENSORS_ADM9240_IN4_MIN,&min) &&
324	!sensors_get_feature(*name,SENSORS_ADM9240_IN4_MAX,&max)) {
325	if (valid) {
326	print_label(label,10);
327	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
328	cur,min,max,alarms&ADM9240_ALARM_IN4?"ALARM":"");
329	}
330	} else
331	printf("ERROR: Can't get IN4 data!\n");
332	free_the_label(&label);
333	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN5,&label,&valid) &&
334	!sensors_get_feature(*name,SENSORS_ADM9240_IN5,&cur) &&
335	!sensors_get_feature(*name,SENSORS_ADM9240_IN5_MIN,&min) &&
336	!sensors_get_feature(*name,SENSORS_ADM9240_IN5_MAX,&max)) {
337	if (valid) {
338	print_label(label,10);
339	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
340	cur,min,max,alarms&ADM9240_ALARM_IN5?"ALARM":"");
341	}
342	} else
343	printf("ERROR: Can't get IN5 data!\n");
344	free_the_label(&label);
345
346	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_FAN1,&label,&valid) &&
347	!sensors_get_feature(*name,SENSORS_ADM9240_FAN1,&cur) &&
348	!sensors_get_feature(*name,SENSORS_ADM9240_FAN1_DIV,&fdiv) &&
349	!sensors_get_feature(*name,SENSORS_ADM9240_FAN1_MIN,&min)) {
350	if (valid) {
351	print_label(label,10);
352	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
353	cur,min,fdiv, alarms&ADM9240_ALARM_FAN1?"ALARM":"");
354	}
355	} else
356	printf("ERROR: Can't get FAN1 data!\n");
357	free_the_label(&label);
358	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_FAN2,&label,&valid) &&
359	!sensors_get_feature(*name,SENSORS_ADM9240_FAN2,&cur) &&
360	!sensors_get_feature(*name,SENSORS_ADM9240_FAN2_DIV,&fdiv) &&
361	!sensors_get_feature(*name,SENSORS_ADM9240_FAN2_MIN,&min)) {
362	if (valid) {
363	print_label(label,10);
364	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
365	cur,min,fdiv, alarms&ADM9240_ALARM_FAN2?"ALARM":"");
366	}
367	} else
368	printf("ERROR: Can't get FAN2 data!\n");
369	free_the_label(&label);
370
371	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_TEMP,&label,&valid) &&
372	!sensors_get_feature(*name,SENSORS_ADM9240_TEMP,&cur) &&
373	!sensors_get_feature(*name,SENSORS_ADM9240_TEMP_HYST,&min) &&
374	!sensors_get_feature(*name,SENSORS_ADM9240_TEMP_OVER,&max)) {
375	if (valid) {
376	print_label(label,10);
377	print_temp_info( cur, max, min, HYST, 1, 0);
378	printf( " %s\n", alarms & ADM9240_ALARM_TEMP ? "ALARM" : "" );
379	}
380	} else
381	printf("ERROR: Can't get TEMP data!\n");
382	free_the_label(&label);
383
384	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_VID,&label,&valid) &&
385	!sensors_get_feature(*name,SENSORS_ADM9240_VID,&cur)) {
386	if (valid) {
387	print_label(label,10);
388	printf("%+6.2f V\n",cur);
389	}
390	}
391	free_the_label(&label);
392
393	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_ALARMS,&label,&valid)) {
394	if (valid) {
395	print_label(label,10);
396	if(alarms & ADM9240_ALARM_CHAS)
397	printf("Chassis intrusion detection ALARM\n");
398	else
399	printf("\n");
400	}
401	}
402	free_the_label(&label);
403	}
404
405	void print_adm1024(const sensors_chip_name *name)
406	{
407	char *label = NULL;
408	double cur,min,max,fdiv;
409	int alarms;
410	int valid;
411
412	if (!sensors_get_feature(*name,SENSORS_ADM1024_ALARMS,&cur))
413	alarms = cur + 0.5;
414	else {
415	printf("ERROR: Can't get alarm data!\n");
416	alarms = 0;
417	}
418
419	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN0,&label,&valid) &&
420	!sensors_get_feature(*name,SENSORS_ADM1024_IN0,&cur) &&
421	!sensors_get_feature(*name,SENSORS_ADM1024_IN0_MIN,&min) &&
422	!sensors_get_feature(*name,SENSORS_ADM1024_IN0_MAX,&max)) {
423	if (valid) {
424	print_label(label,10);
425	printf( "%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
426	cur,min,max,alarms&ADM1024_ALARM_IN0?"ALARM":"");
427	}
428	} else
429	printf("ERROR: Can't get IN0 data!\n");
430	free_the_label(&label);
431	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN1,&label,&valid) &&
432	!sensors_get_feature(*name,SENSORS_ADM1024_IN1,&cur) &&
433	!sensors_get_feature(*name,SENSORS_ADM1024_IN1_MIN,&min) &&
434	!sensors_get_feature(*name,SENSORS_ADM1024_IN1_MAX,&max)) {
435	if (valid) {
436	print_label(label,10);
437	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
438	cur,min,max,alarms&ADM1024_ALARM_IN1?"ALARM":"");
439	}
440	} else
441	printf("ERROR: Can't get IN1 data!\n");
442	free_the_label(&label);
443	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN2,&label,&valid) &&
444	!sensors_get_feature(*name,SENSORS_ADM1024_IN2,&cur) &&
445	!sensors_get_feature(*name,SENSORS_ADM1024_IN2_MIN,&min) &&
446	!sensors_get_feature(*name,SENSORS_ADM1024_IN2_MAX,&max)) {
447	if (valid) {
448	print_label(label,10);
449	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
450	cur,min,max,alarms&ADM1024_ALARM_IN2?"ALARM":"");
451	}
452	} else
453	printf("ERROR: Can't get IN2 data!\n");
454	free_the_label(&label);
455	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN3,&label,&valid) &&
456	!sensors_get_feature(*name,SENSORS_ADM1024_IN3,&cur) &&
457	!sensors_get_feature(*name,SENSORS_ADM1024_IN3_MIN,&min) &&
458	!sensors_get_feature(*name,SENSORS_ADM1024_IN3_MAX,&max)) {
459	if (valid) {
460	print_label(label,10);
461	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
462	cur,min,max,alarms&ADM1024_ALARM_IN3?"ALARM":"");
463	}
464	} else
465	printf("ERROR: Can't get IN3 data!\n");
466	free_the_label(&label);
467	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN4,&label,&valid) &&
468	!sensors_get_feature(*name,SENSORS_ADM1024_IN4,&cur) &&
469	!sensors_get_feature(*name,SENSORS_ADM1024_IN4_MIN,&min) &&
470	!sensors_get_feature(*name,SENSORS_ADM1024_IN4_MAX,&max)) {
471	if (valid) {
472	print_label(label,10);
473	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
474	cur,min,max,alarms&ADM1024_ALARM_IN4?"ALARM":"");
475	}
476	} else
477	printf("ERROR: Can't get IN4 data!\n");
478	free_the_label(&label);
479	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN5,&label,&valid) &&
480	!sensors_get_feature(*name,SENSORS_ADM1024_IN5,&cur) &&
481	!sensors_get_feature(*name,SENSORS_ADM1024_IN5_MIN,&min) &&
482	!sensors_get_feature(*name,SENSORS_ADM1024_IN5_MAX,&max)) {
483	if (valid) {
484	print_label(label,10);
485	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
486	cur,min,max,alarms&ADM1024_ALARM_IN5?"ALARM":"");
487	}
488	} else
489	printf("ERROR: Can't get IN5 data!\n");
490	free_the_label(&label);
491
492	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_FAN1,&label,&valid) &&
493	!sensors_get_feature(*name,SENSORS_ADM1024_FAN1,&cur) &&
494	!sensors_get_feature(*name,SENSORS_ADM1024_FAN1_DIV,&fdiv) &&
495	!sensors_get_feature(*name,SENSORS_ADM1024_FAN1_MIN,&min)) {
496	if (valid) {
497	print_label(label,10);
498	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
499	cur,min,fdiv, alarms&ADM1024_ALARM_FAN1?"ALARM":"");
500	}
501	} else
502	printf("ERROR: Can't get FAN1 data!\n");
503	free_the_label(&label);
504	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_FAN2,&label,&valid) &&
505	!sensors_get_feature(*name,SENSORS_ADM1024_FAN2,&cur) &&
506	!sensors_get_feature(*name,SENSORS_ADM1024_FAN2_DIV,&fdiv) &&
507	!sensors_get_feature(*name,SENSORS_ADM1024_FAN2_MIN,&min)) {
508	if (valid) {
509	print_label(label,10);
510	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
511	cur,min,fdiv, alarms&ADM1024_ALARM_FAN2?"ALARM":"");
512	}
513	} else
514	printf("ERROR: Can't get FAN2 data!\n");
515	free_the_label(&label);
516
517	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_TEMP,&label,&valid) &&
518	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP,&cur) &&
519	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP_HYST,&min) &&
520	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP_OVER,&max)) {
521	if (valid) {
522	print_label(label,10);
523	print_temp_info( cur, min, max, HYST, 1, 0);
524	printf( " %s\n", alarms & ADM1024_ALARM_TEMP ? "ALARM" : "" );
525	}
526	} else
527	printf("ERROR: Can't get TEMP data!\n");
528	free_the_label(&label);
529
530	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_TEMP1,&label,&valid) &&
531	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP1,&cur) &&
532	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP1_HYST,&min) &&
533	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP1_OVER,&max)) {
534	if (valid) {
535	print_label(label,10);
536	print_temp_info( cur, min, max, HYST, 1, 0);
537	printf( " %s\n", alarms & ADM1024_ALARM_TEMP1 ? "ALARM" : "" );
538	}
539	} else
540	printf("ERROR: Can't get TEMP1 data!\n");
541	free_the_label(&label);
542
543	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_TEMP2,&label,&valid) &&
544	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP2,&cur) &&
545	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP2_HYST,&min) &&
546	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP2_OVER,&max)) {
547	if (valid) {
548	print_label(label,10);
549	print_temp_info( cur, min, max, HYST, 1, 0);
550	printf( " %s\n", alarms & ADM1024_ALARM_TEMP2 ? "ALARM" : "" );
551	}
552	} else
553	printf("ERROR: Can't get TEMP2 data!\n");
554	free_the_label(&label);
555
556	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_VID,&label,&valid) &&
557	!sensors_get_feature(*name,SENSORS_ADM1024_VID,&cur)) {
558	if (valid) {
559	print_label(label,10);
560	printf("%+6.2f V\n",cur);
561	}
562	}
563	free_the_label(&label);
564
565	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_ALARMS,&label,&valid)) {
566	if (valid) {
567	print_label(label,10);
568	if(alarms & ADM1024_ALARM_CHAS)
569	printf("Chassis intrusion detection ALARM\n");
570	else
571	printf("\n");
572	}
573	}
574	free_the_label(&label);
575	}
576
577	void print_sis5595(const sensors_chip_name *name)
578	{
579	char *label = NULL;
580	double cur,min,max,fdiv;
581	int alarms,valid;
582
583	if (!sensors_get_feature(*name,SENSORS_SIS5595_ALARMS,&cur))
584	alarms = cur + 0.5;
585	else {
586	printf("ERROR: Can't get alarm data!\n");
587	alarms = 0;
588	}
589
590	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN0,&label,&valid) &&
591	!sensors_get_feature(*name,SENSORS_SIS5595_IN0,&cur) &&
592	!sensors_get_feature(*name,SENSORS_SIS5595_IN0_MIN,&min) &&
593	!sensors_get_feature(*name,SENSORS_SIS5595_IN0_MAX,&max)) {
594	if (valid) {
595	print_label(label,10);
596	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
597	cur,min,max,alarms&SIS5595_ALARM_IN0?"ALARM":"");
598	}
599	} else
600	printf("ERROR: Can't get IN0 data!\n");
601	free_the_label(&label);
602	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN1,&label,&valid) &&
603	!sensors_get_feature(*name,SENSORS_SIS5595_IN1,&cur) &&
604	!sensors_get_feature(*name,SENSORS_SIS5595_IN1_MIN,&min) &&
605	!sensors_get_feature(*name,SENSORS_SIS5595_IN1_MAX,&max)) {
606	if (valid) {
607	print_label(label,10);
608	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
609	cur,min,max,alarms&SIS5595_ALARM_IN1?"ALARM":"");
610	}
611	} else
612	printf("ERROR: Can't get IN1 data!\n");
613	free_the_label(&label);
614	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN2,&label,&valid) &&
615	!sensors_get_feature(*name,SENSORS_SIS5595_IN2,&cur) &&
616	!sensors_get_feature(*name,SENSORS_SIS5595_IN2_MIN,&min) &&
617	!sensors_get_feature(*name,SENSORS_SIS5595_IN2_MAX,&max)) {
618	if (valid) {
619	print_label(label,10);
620	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
621	cur,min,max,alarms&SIS5595_ALARM_IN2?"ALARM":"");
622	}
623	} else
624	printf("ERROR: Can't get IN2 data!\n");
625	free_the_label(&label);
626	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN3,&label,&valid) &&
627	!sensors_get_feature(*name,SENSORS_SIS5595_IN3,&cur) &&
628	!sensors_get_feature(*name,SENSORS_SIS5595_IN3_MIN,&min) &&
629	!sensors_get_feature(*name,SENSORS_SIS5595_IN3_MAX,&max)) {
630	if (valid) {
631	print_label(label,10);
632	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
633	cur,min,max,alarms&SIS5595_ALARM_IN3?"ALARM":"");
634	}
635	} else
636	printf("ERROR: Can't get IN3 data!\n");
637	free_the_label(&label);
638
639	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_FAN1,&label,&valid) &&
640	!sensors_get_feature(*name,SENSORS_SIS5595_FAN1,&cur) &&
641	!sensors_get_feature(*name,SENSORS_SIS5595_FAN1_DIV,&fdiv) &&
642	!sensors_get_feature(*name,SENSORS_SIS5595_FAN1_MIN,&min)) {
643	if (valid) {
644	print_label(label,10);
645	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
646	cur,min,fdiv, alarms&SIS5595_ALARM_FAN1?"ALARM":"");
647	}
648	} else
649	printf("ERROR: Can't get FAN1 data!\n");
650	free_the_label(&label);
651	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_FAN2,&label,&valid) &&
652	!sensors_get_feature(*name,SENSORS_SIS5595_FAN2,&cur) &&
653	!sensors_get_feature(*name,SENSORS_SIS5595_FAN2_DIV,&fdiv) &&
654	!sensors_get_feature(*name,SENSORS_SIS5595_FAN2_MIN,&min)) {
655	if (valid) {
656	print_label(label,10);
657	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
658	cur,min,fdiv, alarms&SIS5595_ALARM_FAN2?"ALARM":"");
659	}
660	} else
661	printf("ERROR: Can't get FAN2 data!\n");
662	free_the_label(&label);
663
664	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_TEMP,&label,&valid) &&
665	!sensors_get_feature(*name,SENSORS_SIS5595_TEMP,&cur) &&
666	!sensors_get_feature(*name,SENSORS_SIS5595_TEMP_HYST,&min) &&
667	!sensors_get_feature(*name,SENSORS_SIS5595_TEMP_OVER,&max)) {
668	if (valid) {
669	print_label(label,10);
670	print_temp_info( cur, max, min, HYST, 0, 0);
671	printf( " %s\n", alarms & SIS5595_ALARM_TEMP ? "ALARM" : "" );
672	}
673	} else
674	printf("ERROR: Can't get TEMP data!\n");
675	free_the_label(&label);
676
677	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_ALARMS,&label,&valid)
678	&& valid) {
679	print_label(label,10);
680	printf("Board temperature input (usually LM75 chips) %s\n",
681	alarms & SIS5595_ALARM_BTI ?"ALARM":" ");
682	}
683	free_the_label(&label);
684
685	}
686
687	void print_via686a(const sensors_chip_name *name)
688	{
689	char *label = NULL;
690	double cur,min,max,fdiv;
691	int alarms,valid;
692
693	if (!sensors_get_feature(*name,SENSORS_VIA686A_ALARMS,&cur))
694	alarms = cur + 0.5;
695	else {
696	printf("ERROR: Can't get alarm data!\n");
697	alarms = 0;
698	}
699
700	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN0,&label,&valid) &&
701	!sensors_get_feature(*name,SENSORS_VIA686A_IN0,&cur) &&
702	!sensors_get_feature(*name,SENSORS_VIA686A_IN0_MIN,&min) &&
703	!sensors_get_feature(*name,SENSORS_VIA686A_IN0_MAX,&max)) {
704	if (valid) {
705	print_label(label,10);
706	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
707	cur,min,max,alarms&VIA686A_ALARM_IN0?"ALARM":"");
708	}
709	} else
710	printf("ERROR: Can't get IN0 data!\n");
711	free_the_label(&label);
712	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN1,&label,&valid) &&
713	!sensors_get_feature(*name,SENSORS_VIA686A_IN1,&cur) &&
714	!sensors_get_feature(*name,SENSORS_VIA686A_IN1_MIN,&min) &&
715	!sensors_get_feature(*name,SENSORS_VIA686A_IN1_MAX,&max)) {
716	if (valid) {
717	print_label(label,10);
718	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
719	cur,min,max,alarms&VIA686A_ALARM_IN1?"ALARM":"");
720	}
721	} else
722	printf("ERROR: Can't get IN1 data!\n");
723	free_the_label(&label);
724	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN2,&label,&valid) &&
725	!sensors_get_feature(*name,SENSORS_VIA686A_IN2,&cur) &&
726	!sensors_get_feature(*name,SENSORS_VIA686A_IN2_MIN,&min) &&
727	!sensors_get_feature(*name,SENSORS_VIA686A_IN2_MAX,&max)) {
728	if (valid) {
729	print_label(label,10);
730	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
731	cur,min,max,alarms&VIA686A_ALARM_IN2?"ALARM":"");
732	}
733	} else
734	printf("ERROR: Can't get IN2 data!\n");
735	free_the_label(&label);
736	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN3,&label,&valid) &&
737	!sensors_get_feature(*name,SENSORS_VIA686A_IN3,&cur) &&
738	!sensors_get_feature(*name,SENSORS_VIA686A_IN3_MIN,&min) &&
739	!sensors_get_feature(*name,SENSORS_VIA686A_IN3_MAX,&max)) {
740	if (valid) {
741	print_label(label,10);
742	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
743	cur,min,max,alarms&VIA686A_ALARM_IN3?"ALARM":"");
744	}
745	} else
746	printf("ERROR: Can't get IN3 data!\n");
747	free_the_label(&label);
748	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN4,&label,&valid) &&
749	!sensors_get_feature(*name,SENSORS_VIA686A_IN4,&cur) &&
750	!sensors_get_feature(*name,SENSORS_VIA686A_IN4_MIN,&min) &&
751	!sensors_get_feature(*name,SENSORS_VIA686A_IN4_MAX,&max)) {
752	if (valid) {
753	print_label(label,10);
754	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
755	cur,min,max,alarms&VIA686A_ALARM_IN4?"ALARM":"");
756	}
757	} else
758	printf("ERROR: Can't get IN4 data!\n");
759	free_the_label(&label);
760
761	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_FAN1,&label,&valid) &&
762	!sensors_get_feature(*name,SENSORS_VIA686A_FAN1,&cur) &&
763	!sensors_get_feature(*name,SENSORS_VIA686A_FAN1_DIV,&fdiv) &&
764	!sensors_get_feature(*name,SENSORS_VIA686A_FAN1_MIN,&min)) {
765	if (valid) {
766	print_label(label,10);
767	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
768	cur,min,fdiv, alarms&VIA686A_ALARM_FAN1?"ALARM":"");
769	}
770	} else
771	printf("ERROR: Can't get FAN1 data!\n");
772	free_the_label(&label);
773	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_FAN2,&label,&valid) &&
774	!sensors_get_feature(*name,SENSORS_VIA686A_FAN2,&cur) &&
775	!sensors_get_feature(*name,SENSORS_VIA686A_FAN2_DIV,&fdiv) &&
776	!sensors_get_feature(*name,SENSORS_VIA686A_FAN2_MIN,&min)) {
777	if (valid) {
778	print_label(label,10);
779	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
780	cur,min,fdiv, alarms&VIA686A_ALARM_FAN2?"ALARM":"");
781	}
782	} else
783	printf("ERROR: Can't get FAN2 data!\n");
784	free_the_label(&label);
785
786	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_TEMP,&label,&valid) &&
787	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP,&cur) &&
788	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP_HYST,&min) &&
789	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP_OVER,&max)) {
790	if (valid) {
791	print_label(label,10);
792	print_temp_info( cur, max, min, HYST, 1, 0);
793	printf(" %s\n", alarms & VIA686A_ALARM_TEMP ? "ALARM" : "" );
794	}
795	} else
796	printf("ERROR: Can't get TEMP data!\n");
797	free_the_label(&label);
798	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_TEMP2,&label,&valid) &&
799	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP2,&cur) &&
800	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP2_HYST,&min) &&
801	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP2_OVER,&max)) {
802	if (valid) {
803	print_label(label,10);
804	print_temp_info( cur, max, min, HYST, 1, 0);
805	printf(" %s\n", alarms & VIA686A_ALARM_TEMP2 ? "ALARM" : "" );
806	}
807	} else
808	printf("ERROR: Can't get TEMP2 data!\n");
809	free_the_label(&label);
810	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_TEMP3,&label,&valid) &&
811	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP3,&cur) &&
812	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP3_HYST,&min) &&
813	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP3_OVER,&max)) {
814	if (valid) {
815	print_label(label,10);
816	print_temp_info( cur, max, min, HYST, 1, 0);
817	printf(" %s\n", alarms & VIA686A_ALARM_TEMP3 ? "ALARM" : "" );
818	}
819	} else
820	printf("ERROR: Can't get TEMP3 data!\n");
821	free_the_label(&label);
822
823	}
824
825	void print_lm78(const sensors_chip_name *name)
826	{
827	char *label = NULL;
828	double cur,min,max,fdiv;
829	int alarms,valid;
830
831	if (!sensors_get_feature(*name,SENSORS_LM78_ALARMS,&cur))
832	alarms = cur + 0.5;
833	else {
834	printf("ERROR: Can't get alarm data!\n");
835	alarms = 0;
836	}
837
838
839	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN0,&label,&valid) &&
840	!sensors_get_feature(*name,SENSORS_LM78_IN0,&cur) &&
841	!sensors_get_feature(*name,SENSORS_LM78_IN0_MIN,&min) &&
842	!sensors_get_feature(*name,SENSORS_LM78_IN0_MAX,&max)) {
843	if (valid) {
844	print_label(label,10);
845	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
846	cur,min,max,alarms&LM78_ALARM_IN0?"ALARM":"");
847	}
848	} else
849	printf("ERROR: Can't get IN0 data!\n");
850	free_the_label(&label);
851	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN1,&label,&valid) &&
852	!sensors_get_feature(*name,SENSORS_LM78_IN1,&cur) &&
853	!sensors_get_feature(*name,SENSORS_LM78_IN1_MIN,&min) &&
854	!sensors_get_feature(*name,SENSORS_LM78_IN1_MAX,&max)) {
855	if (valid) {
856	print_label(label,10);
857	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
858	cur,min,max,alarms&LM78_ALARM_IN1?"ALARM":"");
859	}
860	} else
861	printf("ERROR: Can't get IN1 data!\n");
862	free_the_label(&label);
863	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN2,&label,&valid) &&
864	!sensors_get_feature(*name,SENSORS_LM78_IN2,&cur) &&
865	!sensors_get_feature(*name,SENSORS_LM78_IN2_MIN,&min) &&
866	!sensors_get_feature(*name,SENSORS_LM78_IN2_MAX,&max)) {
867	if (valid) {
868	print_label(label,10);
869	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
870	cur,min,max,alarms&LM78_ALARM_IN2?"ALARM":"");
871	}
872	} else
873	printf("ERROR: Can't get IN2 data!\n");
874	free_the_label(&label);
875	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN3,&label,&valid) &&
876	!sensors_get_feature(*name,SENSORS_LM78_IN3,&cur) &&
877	!sensors_get_feature(*name,SENSORS_LM78_IN3_MIN,&min) &&
878	!sensors_get_feature(*name,SENSORS_LM78_IN3_MAX,&max)) {
879	if (valid) {
880	print_label(label,10);
881	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
882	cur,min,max,alarms&LM78_ALARM_IN3?"ALARM":"");
883	}
884	} else
885	printf("ERROR: Can't get IN3 data!\n");
886	free_the_label(&label);
887	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN4,&label,&valid) &&
888	!sensors_get_feature(*name,SENSORS_LM78_IN4,&cur) &&
889	!sensors_get_feature(*name,SENSORS_LM78_IN4_MIN,&min) &&
890	!sensors_get_feature(*name,SENSORS_LM78_IN4_MAX,&max)) {
891	if (valid) {
892	print_label(label,10);
893	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
894	cur,min,max,alarms&LM78_ALARM_IN4?"ALARM":"");
895	}
896	} else
897	printf("ERROR: Can't get IN4 data!\n");
898	free_the_label(&label);
899	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN5,&label,&valid) &&
900	!sensors_get_feature(*name,SENSORS_LM78_IN5,&cur) &&
901	!sensors_get_feature(*name,SENSORS_LM78_IN5_MIN,&min) &&
902	!sensors_get_feature(*name,SENSORS_LM78_IN5_MAX,&max)) {
903	if (valid) {
904	print_label(label,10);
905	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
906	cur,min,max,alarms&LM78_ALARM_IN5?"ALARM":"");
907	}
908	} else
909	printf("ERROR: Can't get IN5 data!\n");
910	free_the_label(&label);
911	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN6,&label,&valid) &&
912	!sensors_get_feature(*name,SENSORS_LM78_IN6,&cur) &&
913	!sensors_get_feature(*name,SENSORS_LM78_IN6_MIN,&min) &&
914	!sensors_get_feature(*name,SENSORS_LM78_IN6_MAX,&max)) {
915	if (valid) {
916	print_label(label,10);
917	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
918	cur,min,max,alarms&LM78_ALARM_IN6?"ALARM":"");
919	}
920	} else
921	printf("ERROR: Can't get IN6 data!\n");
922	free_the_label(&label);
923
924	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_FAN1,&label,&valid) &&
925	!sensors_get_feature(*name,SENSORS_LM78_FAN1,&cur) &&
926	!sensors_get_feature(*name,SENSORS_LM78_FAN1_DIV,&fdiv) &&
927	!sensors_get_feature(*name,SENSORS_LM78_FAN1_MIN,&min)) {
928	if (valid) {
929	print_label(label,10);
930	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
931	cur,min,fdiv, alarms&LM78_ALARM_FAN1?"ALARM":"");
932	}
933	} else
934	printf("ERROR: Can't get FAN1 data!\n");
935	free_the_label(&label);
936	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_FAN2,&label,&valid) &&
937	!sensors_get_feature(*name,SENSORS_LM78_FAN2,&cur) &&
938	!sensors_get_feature(*name,SENSORS_LM78_FAN2_DIV,&fdiv) &&
939	!sensors_get_feature(*name,SENSORS_LM78_FAN2_MIN,&min)) {
940	if (valid) {
941	print_label(label,10);
942	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
943	cur,min,fdiv, alarms&LM78_ALARM_FAN2?"ALARM":"");
944	}
945	} else
946	printf("ERROR: Can't get FAN2 data!\n");
947	free_the_label(&label);
948	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_FAN3,&label,&valid) &&
949	!sensors_get_feature(*name,SENSORS_LM78_FAN3,&cur) &&
950	!sensors_get_feature(*name,SENSORS_LM78_FAN3_DIV,&fdiv) &&
951	!sensors_get_feature(*name,SENSORS_LM78_FAN3_MIN,&min)) {
952	if (valid) {
953	print_label(label,10);
954	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
955	cur,min,fdiv, alarms&LM78_ALARM_FAN3?"ALARM":"");
956	}
957	} else
958	printf("ERROR: Can't get FAN3 data!\n");
959	free_the_label(&label);
960
961	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_TEMP,&label,&valid) &&
962	!sensors_get_feature(*name,SENSORS_LM78_TEMP,&cur) &&
963	!sensors_get_feature(*name,SENSORS_LM78_TEMP_HYST,&min) &&
964	!sensors_get_feature(*name,SENSORS_LM78_TEMP_OVER,&max)) {
965	if (valid) {
966	print_label(label,10);
967	print_temp_info( cur, max, min, HYST, 1, 0);
968	printf( " %s\n", alarms & LM78_ALARM_TEMP ? "ALARM" : "" );
969	}
970	} else
971	printf("ERROR: Can't get TEMP data!\n");
972	free_the_label(&label);
973
974	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_VID,&label,&valid) &&
975	!sensors_get_feature(*name,SENSORS_LM78_VID,&cur)) {
976	if (valid) {
977	print_label(label,10);
978	printf("%+6.2f V\n",cur);
979	}
980	}
981	free_the_label(&label);
982
983	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_ALARMS,&label,&valid)
984	&& valid) {
985	if(alarms & LM78_ALARM_BTI) {
986	print_label(label,10);
987	printf("Board temperature input (LM75) ALARM\n");
988	}
989	if(alarms & LM78_ALARM_CHAS) {
990	print_label(label,10);
991	printf("Chassis intrusion detection ALARM\n");
992	}
993	}
994	free_the_label(&label);
995	}
996
997	void print_gl518(const sensors_chip_name *name)
998	{
999	char *label = NULL;
1000	double cur,min,max,fdiv;
1001	int alarms,beeps,valid;
1002
1003	if (!sensors_get_feature(*name,SENSORS_GL518_ALARMS,&cur))
1004	alarms = cur + 0.5;
1005	else {
1006	printf("ERROR: Can't get ALARMS data!\n");
1007	alarms = 0;
1008	}
1009	if (!sensors_get_feature(*name,SENSORS_GL518_BEEPS,&cur))
1010	beeps = cur + 0.5;
1011	else {
1012	printf("ERROR: Can't get BEEPS data!\n");
1013	beeps = 0;
1014	}
1015
1016	/* VCC, VIN1 and VIN2 are handled specially because on early releases (0x00)
1017	* of the GL518SM, we cannot read their values. This is detected when the
1018	* reading would be 0.0 V and displayed as "(n/a)" instead. */
1019	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VDD,&label,&valid) &&
1020	!sensors_get_feature(*name,SENSORS_GL518_VDD,&cur) &&
1021	!sensors_get_feature(*name,SENSORS_GL518_VDD_MIN,&min) &&
1022	!sensors_get_feature(*name,SENSORS_GL518_VDD_MAX,&max)) {
1023	if (valid) {
1024	print_label(label,10);
1025	if (cur == 0.0)
1026	printf("(n/a) ");
1027	else
1028	printf("%+6.2f V ",cur);
1029	printf( "(min = %+6.2f V, max = %+6.2f V) %s %s\n",
1030	min,max,alarms&GL518_ALARM_VDD?"ALARM":" ",
1031	beeps&GL518_ALARM_VDD?"(beep)":"");
1032	}
1033	} else
1034	printf("ERROR: Can't get VDD data!\n");
1035	free_the_label(&label);
1036
1037	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN1,&label,&valid) &&
1038	!sensors_get_feature(*name,SENSORS_GL518_VIN1,&cur) &&
1039	!sensors_get_feature(*name,SENSORS_GL518_VIN1_MIN,&min) &&
1040	!sensors_get_feature(*name,SENSORS_GL518_VIN1_MAX,&max)) {
1041	if (valid) {
1042	print_label(label,10);
1043	if (cur == 0.0)
1044	printf("(n/a) ");
1045	else
1046	printf("%+6.2f V ",cur);
1047	printf("(min = %+6.2f V, max = %+6.2f V) %s %s\n",
1048	min,max,alarms&GL518_ALARM_VIN1?"ALARM":" ",
1049	beeps&GL518_ALARM_VIN1?"(beep)":"");
1050	}
1051	} else
1052	printf("ERROR: Can't get VIN1 data!\n");
1053	free_the_label(&label);
1054
1055	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN2,&label,&valid) &&
1056	!sensors_get_feature(*name,SENSORS_GL518_VIN2,&cur) &&
1057	!sensors_get_feature(*name,SENSORS_GL518_VIN2_MIN,&min) &&
1058	!sensors_get_feature(*name,SENSORS_GL518_VIN2_MAX,&max)) {
1059	if (valid) {
1060	print_label(label,10);
1061	if (cur == 0.0)
1062	printf("(n/a) ");
1063	else
1064	printf("%+6.2f V ",cur);
1065	printf("(min = %+6.2f V, max = %+6.2f V) %s %s\n",
1066	min,max,alarms&GL518_ALARM_VIN2?"ALARM":" ",
1067	beeps&GL518_ALARM_VIN2?"(beep)":"");
1068	}
1069	} else
1070	printf("ERROR: Can't get VIN2 data!\n");
1071	free_the_label(&label);
1072
1073	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN3,&label,&valid) &&
1074	!sensors_get_feature(*name,SENSORS_GL518_VIN3,&cur) &&
1075	!sensors_get_feature(*name,SENSORS_GL518_VIN3_MIN,&min) &&
1076	!sensors_get_feature(*name,SENSORS_GL518_VIN3_MAX,&max)) {
1077	if (valid) {
1078	print_label(label,10);
1079	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
1080	cur,min,max,alarms&GL518_ALARM_VIN3?"ALARM":" ",
1081	beeps&GL518_ALARM_VIN3?"(beep)":"");
1082	}
1083	} else
1084	printf("ERROR: Can't get VIN3 data!\n");
1085	free_the_label(&label);
1086
1087	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_FAN1,&label,&valid) &&
1088	!sensors_get_feature(*name,SENSORS_GL518_FAN1,&cur) &&
1089	!sensors_get_feature(*name,SENSORS_GL518_FAN1_DIV,&fdiv) &&
1090	!sensors_get_feature(*name,SENSORS_GL518_FAN1_MIN,&min)) {
1091	if (valid) {
1092	print_label(label,10);
1093	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
1094	cur,min,fdiv, alarms&GL518_ALARM_FAN1?"ALARM":" ",
1095	beeps&GL518_ALARM_FAN1?"(beep)":"");
1096	}
1097	} else
1098	printf("ERROR: Can't get FAN1 data!\n");
1099	free_the_label(&label);
1100
1101	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_FAN2,&label,&valid) &&
1102	!sensors_get_feature(*name,SENSORS_GL518_FAN2,&cur) &&
1103	!sensors_get_feature(*name,SENSORS_GL518_FAN2_DIV,&fdiv) &&
1104	!sensors_get_feature(*name,SENSORS_GL518_FAN2_MIN,&min)) {
1105	if (valid) {
1106	print_label(label,10);
1107	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
1108	cur,min,fdiv, alarms&GL518_ALARM_FAN2?"ALARM":" ",
1109	beeps&GL518_ALARM_FAN2?"(beep)":"");
1110	}
1111	} else
1112	printf("ERROR: Can't get FAN2 data!\n");
1113	free_the_label(&label);
1114
1115	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_TEMP,&label,&valid) &&
1116	!sensors_get_feature(*name,SENSORS_GL518_TEMP,&cur) &&
1117	!sensors_get_feature(*name,SENSORS_GL518_TEMP_OVER,&max) &&
1118	!sensors_get_feature(*name,SENSORS_GL518_TEMP_HYST,&min)) {
1119	if (valid) {
1120	print_label(label,10);
1121	print_temp_info( cur, max, min, HYST, 1, 0);
1122	printf("%s %s\n", alarms&GL518_ALARM_TEMP?"ALARM":" ",
1123	beeps&GL518_ALARM_TEMP?"(beep)":"");
1124	}
1125	} else
1126	printf("ERROR: Can't get TEMP data!\n");
1127	free_the_label(&label);
1128
1129	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_BEEP_ENABLE,&label,&valid)
1130	&& valid) {
1131	if (!sensors_get_feature(*name,SENSORS_GL518_BEEP_ENABLE,&cur)) {
1132	print_label(label,10);
1133	if (cur < 0.5)
1134	printf("Sound alarm disabled\n");
1135	else
1136	printf("Sound alarm enabled\n");
1137	} else
1138	printf("ERROR: Can't get BEEP ENABLE data!\n");
1139	}
1140	free_the_label(&label);
1141	}
1142
1143	void print_adm1025(const sensors_chip_name *name)
1144	{
1145	char *label = NULL;
1146	double cur,min,max;
1147	int alarms,valid;
1148
1149	if (!sensors_get_feature(*name,SENSORS_ADM1025_ALARMS,&cur))
1150	alarms = cur + 0.5;
1151	else {
1152	printf("ERROR: Can't get alarm data!\n");
1153	alarms = 0;
1154	}
1155
1156	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN0,&label,&valid) &&
1157	!sensors_get_feature(*name,SENSORS_ADM1025_IN0,&cur) &&
1158	!sensors_get_feature(*name,SENSORS_ADM1025_IN0_MIN,&min) &&
1159	!sensors_get_feature(*name,SENSORS_ADM1025_IN0_MAX,&max)) {
1160	if (valid) {
1161	print_label(label,10);
1162	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1163	cur,min,max,alarms&ADM1025_ALARM_IN0?"ALARM":"");
1164	}
1165	} else
1166	printf("ERROR: Can't get IN0 data!\n");
1167	free_the_label(&label);
1168	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN1,&label,&valid) &&
1169	!sensors_get_feature(*name,SENSORS_ADM1025_IN1,&cur) &&
1170	!sensors_get_feature(*name,SENSORS_ADM1025_IN1_MIN,&min) &&
1171	!sensors_get_feature(*name,SENSORS_ADM1025_IN1_MAX,&max)) {
1172	if (valid) {
1173	print_label(label,10);
1174	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1175	cur,min,max,alarms&ADM1025_ALARM_IN1?"ALARM":"");
1176	}
1177	} else
1178	printf("ERROR: Can't get IN1 data!\n");
1179	free_the_label(&label);
1180	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN2,&label,&valid) &&
1181	!sensors_get_feature(*name,SENSORS_ADM1025_IN2,&cur) &&
1182	!sensors_get_feature(*name,SENSORS_ADM1025_IN2_MIN,&min) &&
1183	!sensors_get_feature(*name,SENSORS_ADM1025_IN2_MAX,&max)) {
1184	if (valid) {
1185	print_label(label,10);
1186	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1187	cur,min,max,alarms&ADM1025_ALARM_IN2?"ALARM":"");
1188	}
1189	} else
1190	printf("ERROR: Can't get IN2 data!\n");
1191	free_the_label(&label);
1192	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN3,&label,&valid) &&
1193	!sensors_get_feature(*name,SENSORS_ADM1025_IN3,&cur) &&
1194	!sensors_get_feature(*name,SENSORS_ADM1025_IN3_MIN,&min) &&
1195	!sensors_get_feature(*name,SENSORS_ADM1025_IN3_MAX,&max)) {
1196	if (valid) {
1197	print_label(label,10);
1198	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1199	cur,min,max,alarms&ADM1025_ALARM_IN3?"ALARM":"");
1200	}
1201	} else
1202	printf("ERROR: Can't get IN3 data!\n");
1203	free_the_label(&label);
1204	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN4,&label,&valid) &&
1205	!sensors_get_feature(*name,SENSORS_ADM1025_IN4,&cur) &&
1206	!sensors_get_feature(*name,SENSORS_ADM1025_IN4_MIN,&min) &&
1207	!sensors_get_feature(*name,SENSORS_ADM1025_IN4_MAX,&max)) {
1208	if (valid) {
1209	print_label(label,10);
1210	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1211	cur,min,max,alarms&ADM1025_ALARM_IN4?"ALARM":"");
1212	}
1213	} else
1214	printf("ERROR: Can't get IN4 data!\n");
1215	free_the_label(&label);
1216	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN5,&label,&valid) &&
1217	!sensors_get_feature(*name,SENSORS_ADM1025_IN5,&cur) &&
1218	!sensors_get_feature(*name,SENSORS_ADM1025_IN5_MIN,&min) &&
1219	!sensors_get_feature(*name,SENSORS_ADM1025_IN5_MAX,&max)) {
1220	if (valid) {
1221	print_label(label,10);
1222	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1223	cur,min,max,alarms&ADM1025_ALARM_IN5?"ALARM":"");
1224	}
1225	} else
1226	printf("ERROR: Can't get IN5 data!\n");
1227	free_the_label(&label);
1228
1229	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_TEMP1,&label,&valid) &&
1230	!sensors_get_feature(*name,SENSORS_ADM1025_TEMP1,&cur) &&
1231	!sensors_get_feature(*name,SENSORS_ADM1025_TEMP1_LOW,&min) &&
1232	!sensors_get_feature(*name,SENSORS_ADM1025_TEMP1_HIGH,&max)) {
1233	if (valid) {
1234	print_label(label,10);
1235	print_temp_info( cur, max, min, MINMAX, 1, 0);
1236	printf(" %s\n", alarms&ADM1025_ALARM_RFAULT?"FAULT":
1237	alarms&ADM1025_ALARM_RTEMP?"ALARM":"");
1238	}
1239	} else
1240	printf("ERROR: Can't get TEMP1 data!\n");
1241	free_the_label(&label);
1242
1243	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_TEMP2,&label,&valid) &&
1244	!sensors_get_feature(*name,SENSORS_ADM1025_TEMP2,&cur) &&
1245	!sensors_get_feature(*name,SENSORS_ADM1025_TEMP2_LOW,&min) &&
1246	!sensors_get_feature(*name,SENSORS_ADM1025_TEMP2_HIGH,&max)) {
1247	if (valid) {
1248	print_label(label,10);
1249	print_temp_info( cur, max, min, MINMAX, 1, 0);
1250	printf(" %s\n", alarms&ADM1025_ALARM_TEMP ? "ALARM":"");
1251	}
1252	} else
1253	printf("ERROR: Can't get TEMP2 data!\n");
1254	free_the_label(&label);
1255
1256	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_VID,&label,&valid) &&
1257	!sensors_get_feature(*name,SENSORS_ADM1025_VID,&cur)) {
1258	if (valid) {
1259	print_label(label,10);
1260	printf("%+6.2f V\n",cur);
1261	}
1262	}
1263	free_the_label(&label);
1264	}
1265
1266	void print_lm80(const sensors_chip_name *name)
1267	{
1268	char *label = NULL;
1269	double cur,min,max,min2,max2,fdiv;
1270	int alarms,valid;
1271
1272	if (!sensors_get_feature(*name,SENSORS_LM80_ALARMS,&cur))
1273	alarms = cur + 0.5;
1274	else {
1275	printf("ERROR: Can't get alarm data!\n");
1276	alarms = 0;
1277	}
1278
1279	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN0,&label,&valid) &&
1280	!sensors_get_feature(*name,SENSORS_LM80_IN0,&cur) &&
1281	!sensors_get_feature(*name,SENSORS_LM80_IN0_MIN,&min) &&
1282	!sensors_get_feature(*name,SENSORS_LM80_IN0_MAX,&max)) {
1283	if (valid) {
1284	print_label(label,10);
1285	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1286	cur,min,max,alarms&LM80_ALARM_IN0?"ALARM":"");
1287	}
1288	} else
1289	printf("ERROR: Can't get IN0 data!\n");
1290	free_the_label(&label);
1291	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN1,&label,&valid) &&
1292	!sensors_get_feature(*name,SENSORS_LM80_IN1,&cur) &&
1293	!sensors_get_feature(*name,SENSORS_LM80_IN1_MIN,&min) &&
1294	!sensors_get_feature(*name,SENSORS_LM80_IN1_MAX,&max)) {
1295	if (valid) {
1296	print_label(label,10);
1297	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1298	cur,min,max,alarms&LM80_ALARM_IN1?"ALARM":"");
1299	}
1300	} else
1301	printf("ERROR: Can't get IN1 data!\n");
1302	free_the_label(&label);
1303	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN2,&label,&valid) &&
1304	!sensors_get_feature(*name,SENSORS_LM80_IN2,&cur) &&
1305	!sensors_get_feature(*name,SENSORS_LM80_IN2_MIN,&min) &&
1306	!sensors_get_feature(*name,SENSORS_LM80_IN2_MAX,&max)) {
1307	if (valid) {
1308	print_label(label,10);
1309	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1310	cur,min,max,alarms&LM80_ALARM_IN2?"ALARM":"");
1311	}
1312	} else
1313	printf("ERROR: Can't get IN2 data!\n");
1314	free_the_label(&label);
1315	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN3,&label,&valid) &&
1316	!sensors_get_feature(*name,SENSORS_LM80_IN3,&cur) &&
1317	!sensors_get_feature(*name,SENSORS_LM80_IN3_MIN,&min) &&
1318	!sensors_get_feature(*name,SENSORS_LM80_IN3_MAX,&max)) {
1319	if (valid) {
1320	print_label(label,10);
1321	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1322	cur,min,max,alarms&LM80_ALARM_IN3?"ALARM":"");
1323	}
1324	} else
1325	printf("ERROR: Can't get IN3 data!\n");
1326	free_the_label(&label);
1327	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN4,&label,&valid) &&
1328	!sensors_get_feature(*name,SENSORS_LM80_IN4,&cur) &&
1329	!sensors_get_feature(*name,SENSORS_LM80_IN4_MIN,&min) &&
1330	!sensors_get_feature(*name,SENSORS_LM80_IN4_MAX,&max)) {
1331	if (valid) {
1332	print_label(label,10);
1333	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1334	cur,min,max,alarms&LM80_ALARM_IN4?"ALARM":"");
1335	}
1336	} else
1337	printf("ERROR: Can't get IN4 data!\n");
1338	free_the_label(&label);
1339	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN5,&label,&valid) &&
1340	!sensors_get_feature(*name,SENSORS_LM80_IN5,&cur) &&
1341	!sensors_get_feature(*name,SENSORS_LM80_IN5_MIN,&min) &&
1342	!sensors_get_feature(*name,SENSORS_LM80_IN5_MAX,&max)) {
1343	if (valid) {
1344	print_label(label,10);
1345	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1346	cur,min,max,alarms&LM80_ALARM_IN5?"ALARM":"");
1347	}
1348	} else
1349	printf("ERROR: Can't get IN5 data!\n");
1350	free_the_label(&label);
1351	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN6,&label,&valid) &&
1352	!sensors_get_feature(*name,SENSORS_LM80_IN6,&cur) &&
1353	!sensors_get_feature(*name,SENSORS_LM80_IN6_MIN,&min) &&
1354	!sensors_get_feature(*name,SENSORS_LM80_IN6_MAX,&max)) {
1355	if (valid) {
1356	print_label(label,10);
1357	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1358	cur,min,max,alarms&LM80_ALARM_IN6?"ALARM":"");
1359	}
1360	} else
1361	printf("ERROR: Can't get IN6 data!\n");
1362	free_the_label(&label);
1363
1364	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_FAN1,&label,&valid) &&
1365	!sensors_get_feature(*name,SENSORS_LM80_FAN1,&cur) &&
1366	!sensors_get_feature(*name,SENSORS_LM80_FAN1_DIV,&fdiv) &&
1367	!sensors_get_feature(*name,SENSORS_LM80_FAN1_MIN,&min)) {
1368	if (valid) {
1369	print_label(label,10);
1370	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
1371	cur,min,fdiv, alarms&LM80_ALARM_FAN1?"ALARM":"");
1372	}
1373	} else
1374	printf("ERROR: Can't get FAN1 data!\n");
1375	free_the_label(&label);
1376	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_FAN2,&label,&valid) &&
1377	!sensors_get_feature(*name,SENSORS_LM80_FAN2,&cur) &&
1378	!sensors_get_feature(*name,SENSORS_LM80_FAN2_DIV,&fdiv) &&
1379	!sensors_get_feature(*name,SENSORS_LM80_FAN2_MIN,&min)) {
1380	if (valid) {
1381	print_label(label,10);
1382	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
1383	cur,min,fdiv, alarms&LM80_ALARM_FAN2?"ALARM":"");
1384	}
1385	} else
1386	printf("ERROR: Can't get FAN2 data!\n");
1387	free_the_label(&label);
1388
1389	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_TEMP,&label,&valid) &&
1390	!sensors_get_feature(*name,SENSORS_LM80_TEMP,&cur) &&
1391	!sensors_get_feature(*name,SENSORS_LM80_TEMP_HOT_HYST,&min) &&
1392	!sensors_get_feature(*name,SENSORS_LM80_TEMP_HOT_MAX,&max) &&
1393	!sensors_get_feature(*name,SENSORS_LM80_TEMP_OS_HYST,&min2) &&
1394	!sensors_get_feature(*name,SENSORS_LM80_TEMP_OS_MAX,&max2)) {
1395	if (valid) {
1396	if (fahrenheit) {
1397	cur = deg_ctof(cur);
1398	max = deg_ctof(max);
1399	min = deg_ctof(min);
1400	max2 = deg_ctof(max2);
1401	min2 = deg_ctof(min2);
1402	}
1403
1404	print_label(label,10);
1405	printf("%+6.2f%s (hot: limit = %+3.0f%s, hyst = %+3.0f%s) %s\n",
1406	cur, degstr, max, degstr, min, degstr,
1407	alarms&LM80_ALARM_TEMP_HOT?"ALARM":"");
1408	print_label("",10);
1409	printf(" (os: limit = %+3.0f%s, hyst = %+3.0f%s) %s\n",
1410	max2, degstr, min2, degstr,
1411	alarms&LM80_ALARM_TEMP_HOT?"ALARM":"");
1412	}
1413	} else
1414	printf("ERROR: Can't get TEMP data!\n");
1415	free_the_label(&label);
1416
1417	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_ALARMS,&label,&valid)
1418	&& valid) {
1419	if (alarms & LM80_ALARM_BTI) {
1420	print_label(label,10);
1421	printf("Board temperature input (LM75) ALARM\n");
1422	}
1423	if (alarms & LM80_ALARM_CHAS) {
1424	print_label(label,10);
1425	printf("Chassis intrusion detection ALARM\n");
1426	}
1427	}
1428	free_the_label(&label);
1429	}
1430
1431	void print_lm85(const sensors_chip_name *name)
1432	{
1433	char *label = NULL;
1434	double cur, min, max;
1435	int alarms, alarm_mask, valid;
1436	int is85, is1027, is6d100;
1437
1438	is85 = !strcmp(name->prefix,"lm85")
1439	\|\| !strcmp(name->prefix,"lm85b")
1440	\|\| !strcmp(name->prefix,"lm85c") ;
1441	is1027 = !strcmp(name->prefix,"adm1027")
1442	\|\| !strcmp(name->prefix,"adt7463") ;
1443	is6d100 = !strcmp(name->prefix,"emc6d100") ;
1444
1445	if (!sensors_get_feature(*name,SENSORS_LM85_ALARMS,&cur))
1446	alarms = cur + 0.5;
1447	else {
1448	printf("ERROR: Can't get alarm data!\n");
1449	alarms = 0;
1450	}
1451
1452	if( is1027 ) {
1453	if (!sensors_get_feature(*name,SENSORS_ADM1027_ALARM_MASK,&cur))
1454	alarm_mask = cur + 0.5;
1455	else {
1456	printf("ERROR: Can't get alarm mask data!\n");
1457	alarm_mask = 0;
1458	}
1459	} else {
1460	alarm_mask = 0 ;
1461	}
1462
1463	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN0,&label,&valid) &&
1464	!sensors_get_feature(*name,SENSORS_LM85_IN0,&cur) &&
1465	!sensors_get_feature(*name,SENSORS_LM85_IN0_MIN,&min) &&
1466	!sensors_get_feature(*name,SENSORS_LM85_IN0_MAX,&max)) {
1467	if (valid) {
1468	print_label(label,10);
1469	printf("%+7.*f V (min = %+6.2f V, max = %+6.2f V) %s",
1470	(is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN0?"ALARM":"");
1471	if (is1027) { printf(alarm_mask&LM85_ALARM_IN0?" MASKED":""); }
1472	putchar( '\n' );
1473	}
1474	} else
1475	printf("ERROR: Can't get IN0 data!\n");
1476	free_the_label(&label);
1477	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN1,&label,&valid) &&
1478	!sensors_get_feature(*name,SENSORS_LM85_IN1,&cur) &&
1479	!sensors_get_feature(*name,SENSORS_LM85_IN1_MIN,&min) &&
1480	!sensors_get_feature(*name,SENSORS_LM85_IN1_MAX,&max)) {
1481	if (valid) {
1482	print_label(label,10);
1483	printf("%+7.*f V (min = %+6.2f V, max = %+6.2f V) %s",
1484	(is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN1?"ALARM":"");
1485	if (is1027) { printf(alarm_mask&LM85_ALARM_IN1?" MASKED":""); }
1486	putchar( '\n' );
1487	}
1488	} else
1489	printf("ERROR: Can't get IN1 data!\n");
1490	free_the_label(&label);
1491	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN2,&label,&valid) &&
1492	!sensors_get_feature(*name,SENSORS_LM85_IN2,&cur) &&
1493	!sensors_get_feature(*name,SENSORS_LM85_IN2_MIN,&min) &&
1494	!sensors_get_feature(*name,SENSORS_LM85_IN2_MAX,&max)) {
1495	if (valid) {
1496	print_label(label,10);
1497	printf("%+7.*f V (min = %+6.2f V, max = %+6.2f V) %s",
1498	(is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN2?"ALARM":"");
1499	if (is1027) { printf(alarm_mask&LM85_ALARM_IN2?" MASKED":""); }
1500	putchar( '\n' );
1501	}
1502	} else
1503	printf("ERROR: Can't get IN2 data!\n");
1504	free_the_label(&label);
1505	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN3,&label,&valid) &&
1506	!sensors_get_feature(*name,SENSORS_LM85_IN3,&cur) &&
1507	!sensors_get_feature(*name,SENSORS_LM85_IN3_MIN,&min) &&
1508	!sensors_get_feature(*name,SENSORS_LM85_IN3_MAX,&max)) {
1509	if (valid) {
1510	print_label(label,10);
1511	printf("%+6.*f V (min = %+6.2f V, max = %+6.2f V) %s",
1512	(is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN3?"ALARM":"");
1513	if (is1027) { printf(alarm_mask&LM85_ALARM_IN3?" MASKED":""); }
1514	putchar( '\n' );
1515	}
1516	} else
1517	printf("ERROR: Can't get IN3 data!\n");
1518	free_the_label(&label);
1519	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN4,&label,&valid) &&
1520	!sensors_get_feature(*name,SENSORS_LM85_IN4,&cur) &&
1521	!sensors_get_feature(*name,SENSORS_LM85_IN4_MIN,&min) &&
1522	!sensors_get_feature(*name,SENSORS_LM85_IN4_MAX,&max)) {
1523	if (valid) {
1524	print_label(label,10);
1525	printf("%+6.*f V (min = %+6.2f V, max = %+6.2f V) %s",
1526	(is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN4?"ALARM":"");
1527	if (is1027) { printf(alarm_mask&LM85_ALARM_IN4?" MASKED":""); }
1528	putchar( '\n' );
1529	}
1530	} else
1531	printf("ERROR: Can't get IN4 data!\n");
1532	free_the_label(&label);
1533
1534	if( is6d100 ) {
1535	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN5,&label,&valid) &&
1536	!sensors_get_feature(*name,SENSORS_LM85_IN5,&cur) &&
1537	!sensors_get_feature(*name,SENSORS_LM85_IN5_MIN,&min) &&
1538	!sensors_get_feature(*name,SENSORS_LM85_IN5_MAX,&max)) {
1539	if (valid) {
1540	print_label(label,10);
1541	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1542	cur,min,max,alarms&LM85_ALARM_IN5?"ALARM":"");
1543	}
1544	} else
1545	printf("ERROR: Can't get IN5 data!\n");
1546	free_the_label(&label);
1547	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN6,&label,&valid) &&
1548	!sensors_get_feature(*name,SENSORS_LM85_IN6,&cur) &&
1549	!sensors_get_feature(*name,SENSORS_LM85_IN6_MIN,&min) &&
1550	!sensors_get_feature(*name,SENSORS_LM85_IN6_MAX,&max)) {
1551	if (valid) {
1552	print_label(label,10);
1553	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1554	cur,min,max,alarms&LM85_ALARM_IN6?"ALARM":"");
1555	}
1556	} else
1557	printf("ERROR: Can't get IN6 data!\n");
1558	free_the_label(&label);
1559	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN7,&label,&valid) &&
1560	!sensors_get_feature(*name,SENSORS_LM85_IN7,&cur) &&
1561	!sensors_get_feature(*name,SENSORS_LM85_IN7_MIN,&min) &&
1562	!sensors_get_feature(*name,SENSORS_LM85_IN7_MAX,&max)) {
1563	if (valid) {
1564	print_label(label,10);
1565	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1566	cur,min,max,alarms&LM85_ALARM_IN7?"ALARM":"");
1567	}
1568	} else
1569	printf("ERROR: Can't get IN7 data!\n");
1570	free_the_label(&label);
1571	}
1572
1573	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN1,&label,&valid) &&
1574	!sensors_get_feature(*name,SENSORS_LM85_FAN1,&cur) &&
1575	!sensors_get_feature(*name,SENSORS_LM85_FAN1_MIN,&min)) {
1576	if (valid) {
1577	print_label(label,10);
1578	printf("%5.0f RPM (min = %4.0f RPM) %s",
1579	cur,min, alarms&LM85_ALARM_FAN1?"ALARM":"");
1580	if (is1027) { printf(alarm_mask&LM85_ALARM_FAN1?" MASKED":""); }
1581	putchar( '\n' );
1582	}
1583	} else
1584	printf("ERROR: Can't get FAN1 data!\n");
1585	free_the_label(&label);
1586	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN2,&label,&valid) &&
1587	!sensors_get_feature(*name,SENSORS_LM85_FAN2,&cur) &&
1588	!sensors_get_feature(*name,SENSORS_LM85_FAN2_MIN,&min)) {
1589	if (valid) {
1590	print_label(label,10);
1591	printf("%5.0f RPM (min = %4.0f RPM) %s",
1592	cur,min, alarms&LM85_ALARM_FAN2?"ALARM":"");
1593	if (is1027) { printf(alarm_mask&LM85_ALARM_FAN2?" MASKED":""); }
1594	putchar( '\n' );
1595	}
1596	} else
1597	printf("ERROR: Can't get FAN2 data!\n");
1598	free_the_label(&label);
1599	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN3,&label,&valid) &&
1600	!sensors_get_feature(*name,SENSORS_LM85_FAN3,&cur) &&
1601	!sensors_get_feature(*name,SENSORS_LM85_FAN3_MIN,&min)) {
1602	if (valid) {
1603	print_label(label,10);
1604	printf("%5.0f RPM (min = %4.0f RPM) %s",
1605	cur,min, alarms&LM85_ALARM_FAN3?"ALARM":"");
1606	if (is1027) { printf(alarm_mask&LM85_ALARM_FAN3?" MASKED":""); }
1607	putchar( '\n' );
1608	}
1609	} else
1610	printf("ERROR: Can't get FAN3 data!\n");
1611	free_the_label(&label);
1612	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN4,&label,&valid) &&
1613	!sensors_get_feature(*name,SENSORS_LM85_FAN4,&cur) &&
1614	!sensors_get_feature(*name,SENSORS_LM85_FAN4_MIN,&min)) {
1615	if (valid) {
1616	print_label(label,10);
1617	printf("%5.0f RPM (min = %4.0f RPM) %s",
1618	cur,min, alarms&LM85_ALARM_FAN4?"ALARM":"");
1619	if (is1027) { printf(alarm_mask&LM85_ALARM_FAN4?" MASKED":""); }
1620	putchar( '\n' );
1621	}
1622	} else
1623	printf("ERROR: Can't get FAN4 data!\n");
1624	free_the_label(&label);
1625
1626	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_TEMP1,&label,&valid) &&
1627	!sensors_get_feature(*name,SENSORS_LM85_TEMP1,&cur) &&
1628	!sensors_get_feature(*name,SENSORS_LM85_TEMP1_MIN,&min) &&
1629	!sensors_get_feature(*name,SENSORS_LM85_TEMP1_MAX,&max)) {
1630	if (valid) {
1631	print_label(label,10);
1632	print_temp_info( cur, max, min, MINMAX, (is1027 ? 2 : 0), 0);
1633	printf( " %s %s %s\n",
1634	alarms&LM85_ALARM_TEMP1?"ALARM":"",
1635	alarms&LM85_ALARM_TEMP1_FAULT?"FAULT":"",
1636	is1027&&(alarm_mask&LM85_ALARM_TEMP1)?"MASKED":""
1637	);
1638	}
1639	} else
1640	printf("ERROR: Can't get TEMP1 data!\n");
1641	free_the_label(&label);
1642	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_TEMP2,&label,&valid) &&
1643	!sensors_get_feature(*name,SENSORS_LM85_TEMP2,&cur) &&
1644	!sensors_get_feature(*name,SENSORS_LM85_TEMP2_MIN,&min) &&
1645	!sensors_get_feature(*name,SENSORS_LM85_TEMP2_MAX,&max)) {
1646	if (valid) {
1647	print_label(label,10);
1648	print_temp_info( cur, max, min, MINMAX, (is1027 ? 2 : 0), 0);
1649	printf( " %s %s\n",
1650	alarms&LM85_ALARM_TEMP2?"ALARM":"",
1651	is1027&&(alarm_mask&LM85_ALARM_TEMP2)?"MASKED":""
1652	);
1653	}
1654	} else
1655	printf("ERROR: Can't get TEMP2 data!\n");
1656	free_the_label(&label);
1657	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_TEMP3,&label,&valid) &&
1658	!sensors_get_feature(*name,SENSORS_LM85_TEMP3,&cur) &&
1659	!sensors_get_feature(*name,SENSORS_LM85_TEMP3_MIN,&min) &&
1660	!sensors_get_feature(*name,SENSORS_LM85_TEMP3_MAX,&max)) {
1661	if (valid) {
1662	print_label(label,10);
1663	print_temp_info( cur, max, min, MINMAX, (is1027 ? 2 : 0), 0);
1664	printf( " %s %s %s\n",
1665	alarms&LM85_ALARM_TEMP3?"ALARM":"",
1666	alarms&LM85_ALARM_TEMP3_FAULT?"FAULT":"",
1667	is1027&&(alarm_mask&LM85_ALARM_TEMP3)?"MASKED":""
1668	);
1669	}
1670	} else
1671	printf("ERROR: Can't get TEMP3 data!\n");
1672	free_the_label(&label);
1673
1674	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_PWM1,&label,&valid) &&
1675	!sensors_get_feature(*name,SENSORS_LM85_PWM1,&cur)) {
1676	if (valid) {
1677	print_label(label,10);
1678	printf("%4.0f\n", cur);
1679	}
1680	} else
1681	printf("ERROR: Can't get PWM1 data!\n");
1682	free_the_label(&label);
1683	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_PWM2,&label,&valid) &&
1684	!sensors_get_feature(*name,SENSORS_LM85_PWM2,&cur)) {
1685	if (valid) {
1686	print_label(label,10);
1687	printf("%4.0f\n", cur);
1688	}
1689	} else
1690	printf("ERROR: Can't get PWM2 data!\n");
1691	free_the_label(&label);
1692	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_PWM3,&label,&valid) &&
1693	!sensors_get_feature(*name,SENSORS_LM85_PWM3,&cur)) {
1694	if (valid) {
1695	print_label(label,10);
1696	printf("%4.0f\n", cur);
1697	}
1698	} else
1699	printf("ERROR: Can't get PWM3 data!\n");
1700	free_the_label(&label);
1701
1702	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_VID,&label,&valid)
1703	&& !sensors_get_feature(*name,SENSORS_LM85_VID,&cur)
1704	&& !sensors_get_feature(*name,SENSORS_LM85_VRM,&min) ) {
1705	if (valid) {
1706	print_label(label,10);
1707	printf("%+6.3f V (VRM Version %4.1f)\n",cur,min);
1708	}
1709	}
1710	free_the_label(&label);
1711	}
1712
1713	void print_lm87(const sensors_chip_name *name)
1714	{
1715	char *label = NULL;
1716	double cur,min,max,fdiv;
1717	int alarms,valid;
1718
1719	if (!sensors_get_feature(*name,SENSORS_LM87_ALARMS,&cur))
1720	alarms = cur + 0.5;
1721	else {
1722	printf("ERROR: Can't get alarm data!\n");
1723	alarms = 0;
1724	}
1725
1726
1727	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN0,&label,&valid) &&
1728	!sensors_get_feature(*name,SENSORS_LM87_IN0,&cur) &&
1729	!sensors_get_feature(*name,SENSORS_LM87_IN0_MIN,&min) &&
1730	!sensors_get_feature(*name,SENSORS_LM87_IN0_MAX,&max)) {
1731	if (valid) {
1732	print_label(label,10);
1733	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1734	cur,min,max,alarms&LM87_ALARM_IN0?"ALARM":"");
1735	}
1736	}
1737	free_the_label(&label);
1738	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN1,&label,&valid) &&
1739	!sensors_get_feature(*name,SENSORS_LM87_IN1,&cur) &&
1740	!sensors_get_feature(*name,SENSORS_LM87_IN1_MIN,&min) &&
1741	!sensors_get_feature(*name,SENSORS_LM87_IN1_MAX,&max)) {
1742	if (valid) {
1743	print_label(label,10);
1744	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1745	cur,min,max,alarms&LM87_ALARM_IN1?"ALARM":"");
1746	}
1747	} else
1748	printf("ERROR: Can't get IN1 data!\n");
1749	free_the_label(&label);
1750	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN2,&label,&valid) &&
1751	!sensors_get_feature(*name,SENSORS_LM87_IN2,&cur) &&
1752	!sensors_get_feature(*name,SENSORS_LM87_IN2_MIN,&min) &&
1753	!sensors_get_feature(*name,SENSORS_LM87_IN2_MAX,&max)) {
1754	if (valid) {
1755	print_label(label,10);
1756	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1757	cur,min,max,alarms&LM87_ALARM_IN2?"ALARM":"");
1758	}
1759	}
1760	free_the_label(&label);
1761	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN3,&label,&valid) &&
1762	!sensors_get_feature(*name,SENSORS_LM87_IN3,&cur) &&
1763	!sensors_get_feature(*name,SENSORS_LM87_IN3_MIN,&min) &&
1764	!sensors_get_feature(*name,SENSORS_LM87_IN3_MAX,&max)) {
1765	if (valid) {
1766	print_label(label,10);
1767	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1768	cur,min,max,alarms&LM87_ALARM_IN3?"ALARM":"");
1769	}
1770	} else
1771	printf("ERROR: Can't get IN3 data!\n");
1772	free_the_label(&label);
1773	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN4,&label,&valid) &&
1774	!sensors_get_feature(*name,SENSORS_LM87_IN4,&cur) &&
1775	!sensors_get_feature(*name,SENSORS_LM87_IN4_MIN,&min) &&
1776	!sensors_get_feature(*name,SENSORS_LM87_IN4_MAX,&max)) {
1777	if (valid) {
1778	print_label(label,10);
1779	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1780	cur,min,max,alarms&LM87_ALARM_IN4?"ALARM":"");
1781	}
1782	} else
1783	printf("ERROR: Can't get IN4 data!\n");
1784	free_the_label(&label);
1785	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN5,&label,&valid) &&
1786	!sensors_get_feature(*name,SENSORS_LM87_IN5,&cur) &&
1787	!sensors_get_feature(*name,SENSORS_LM87_IN5_MIN,&min) &&
1788	!sensors_get_feature(*name,SENSORS_LM87_IN5_MAX,&max)) {
1789	if (valid) {
1790	print_label(label,10);
1791	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1792	cur,min,max,alarms&LM87_ALARM_IN5?"ALARM":"");
1793	}
1794	}
1795	free_the_label(&label);
1796	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_AIN1,&label,&valid) &&
1797	!sensors_get_feature(*name,SENSORS_LM87_AIN1,&cur) &&
1798	!sensors_get_feature(*name,SENSORS_LM87_AIN1_MIN,&min) &&
1799	!sensors_get_feature(*name,SENSORS_LM87_AIN1_MAX,&max)) {
1800	if (valid) {
1801	print_label(label,10);
1802	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1803	cur,min,max,alarms&LM87_ALARM_FAN1?"ALARM":"");
1804	}
1805	}
1806	free_the_label(&label);
1807	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_AIN2,&label,&valid) &&
1808	!sensors_get_feature(*name,SENSORS_LM87_AIN2,&cur) &&
1809	!sensors_get_feature(*name,SENSORS_LM87_AIN2_MIN,&min) &&
1810	!sensors_get_feature(*name,SENSORS_LM87_AIN2_MAX,&max)) {
1811	if (valid) {
1812	print_label(label,10);
1813	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1814	cur,min,max,alarms&LM87_ALARM_FAN2?"ALARM":"");
1815	}
1816	}
1817	free_the_label(&label);
1818
1819	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_FAN1,&label,&valid) &&
1820	!sensors_get_feature(*name,SENSORS_LM87_FAN1,&cur) &&
1821	!sensors_get_feature(*name,SENSORS_LM87_FAN1_DIV,&fdiv) &&
1822	!sensors_get_feature(*name,SENSORS_LM87_FAN1_MIN,&min)) {
1823	if (valid) {
1824	print_label(label,10);
1825	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
1826	cur,min,fdiv, alarms&LM87_ALARM_FAN1?"ALARM":"");
1827	}
1828	}
1829	free_the_label(&label);
1830	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_FAN2,&label,&valid) &&
1831	!sensors_get_feature(*name,SENSORS_LM87_FAN2,&cur) &&
1832	!sensors_get_feature(*name,SENSORS_LM87_FAN2_DIV,&fdiv) &&
1833	!sensors_get_feature(*name,SENSORS_LM87_FAN2_MIN,&min)) {
1834	if (valid) {
1835	print_label(label,10);
1836	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
1837	cur,min,fdiv, alarms&LM87_ALARM_FAN2 ?"ALARM":"");
1838	}
1839	}
1840	free_the_label(&label);
1841
1842	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP1,&label,&valid) &&
1843	!sensors_get_feature(*name,SENSORS_LM87_TEMP1,&cur) &&
1844	!sensors_get_feature(*name,SENSORS_LM87_TEMP1_HYST,&min) &&
1845	!sensors_get_feature(*name,SENSORS_LM87_TEMP1_OVER,&max)) {
1846	if (valid) {
1847	print_label(label,10);
1848	print_temp_info( cur, max, min, MINMAX, 0, 0);
1849	printf(" %s%s\n", alarms&LM87_ALARM_TEMP1?"ALARM":"",
1850	alarms&LM87_ALARM_THERM_SIG?" THERM#":"");
1851	}
1852	} else
1853	printf("ERROR: Can't get TEMP1 data!\n");
1854	free_the_label(&label);
1855
1856	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP2,&label,&valid) &&
1857	!sensors_get_feature(*name,SENSORS_LM87_TEMP2,&cur) &&
1858	!sensors_get_feature(*name,SENSORS_LM87_TEMP2_HYST,&min) &&
1859	!sensors_get_feature(*name,SENSORS_LM87_TEMP2_OVER,&max)) {
1860	if (valid) {
1861	print_label(label,10);
1862	print_temp_info( cur, max, min, MINMAX, 0, 0);
1863	printf(" %s%s\n", alarms&LM87_ALARM_TEMP2?"ALARM":"",
1864	alarms&LM87_ALARM_TEMP2_FAULT?" FAULT":"");
1865	}
1866	} else
1867	printf("ERROR: Can't get TEMP2 data!\n");
1868	free_the_label(&label);
1869
1870	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP3,&label,&valid) &&
1871	!sensors_get_feature(*name,SENSORS_LM87_TEMP3,&cur) &&
1872	!sensors_get_feature(*name,SENSORS_LM87_TEMP3_HYST,&min) &&
1873	!sensors_get_feature(*name,SENSORS_LM87_TEMP3_OVER,&max)) {
1874	if (valid) {
1875	print_label(label,10);
1876	print_temp_info( cur, max, min, MINMAX, 0, 0);
1877	printf(" %s%s\n", alarms&LM87_ALARM_TEMP3?"ALARM":"",
1878	alarms&LM87_ALARM_TEMP3_FAULT?" FAULT":"");
1879	}
1880	}
1881	free_the_label(&label);
1882
1883	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_VID,&label,&valid) &&
1884	!sensors_get_feature(*name,SENSORS_LM87_VID,&cur)) {
1885	if (valid) {
1886	print_label(label,10);
1887	printf("%+6.2f V\n",cur);
1888	}
1889	}
1890	free_the_label(&label);
1891	}
1892
1893	void print_mtp008(const sensors_chip_name *name)
1894	{
1895	char *label = NULL;
1896	double cur,min,max,fdiv;
1897	int alarms,valid;
1898
1899	if (!sensors_get_feature(*name,SENSORS_MTP008_ALARMS,&cur))
1900	alarms = cur + 0.5;
1901	else {
1902	printf("ERROR: Can't get alarm data!\n");
1903	alarms = 0;
1904	}
1905
1906
1907	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN0,&label,&valid) &&
1908	!sensors_get_feature(*name,SENSORS_MTP008_IN0,&cur) &&
1909	!sensors_get_feature(*name,SENSORS_MTP008_IN0_MIN,&min) &&
1910	!sensors_get_feature(*name,SENSORS_MTP008_IN0_MAX,&max)) {
1911	if (valid) {
1912	print_label(label,10);
1913	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1914	cur,min,max,alarms&MTP008_ALARM_IN0?"ALARM":"");
1915	}
1916	} else
1917	printf("ERROR: Can't get IN0 data!\n");
1918	free_the_label(&label);
1919	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN1,&label,&valid) &&
1920	!sensors_get_feature(*name,SENSORS_MTP008_IN1,&cur) &&
1921	!sensors_get_feature(*name,SENSORS_MTP008_IN1_MIN,&min) &&
1922	!sensors_get_feature(*name,SENSORS_MTP008_IN1_MAX,&max)) {
1923	if (valid) {
1924	print_label(label,10);
1925	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1926	cur,min,max,alarms&MTP008_ALARM_IN1?"ALARM":"");
1927	}
1928	} else
1929	printf("ERROR: Can't get IN1 data!\n");
1930	free_the_label(&label);
1931	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN2,&label,&valid) &&
1932	!sensors_get_feature(*name,SENSORS_MTP008_IN2,&cur) &&
1933	!sensors_get_feature(*name,SENSORS_MTP008_IN2_MIN,&min) &&
1934	!sensors_get_feature(*name,SENSORS_MTP008_IN2_MAX,&max)) {
1935	if (valid) {
1936	print_label(label,10);
1937	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1938	cur,min,max,alarms&MTP008_ALARM_IN2?"ALARM":"");
1939	}
1940	} else
1941	printf("ERROR: Can't get IN2 data!\n");
1942	free_the_label(&label);
1943	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN3,&label,&valid) &&
1944	!sensors_get_feature(*name,SENSORS_MTP008_IN3,&cur) &&
1945	!sensors_get_feature(*name,SENSORS_MTP008_IN3_MIN,&min) &&
1946	!sensors_get_feature(*name,SENSORS_MTP008_IN3_MAX,&max)) {
1947	if (valid) {
1948	print_label(label,10);
1949	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1950	cur,min,max,alarms&MTP008_ALARM_IN3?"ALARM":"");
1951	}
1952	} else
1953	printf("ERROR: Can't get IN3 data!\n");
1954	free_the_label(&label);
1955	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN4,&label,&valid) &&
1956	!sensors_get_feature(*name,SENSORS_MTP008_IN4,&cur) &&
1957	!sensors_get_feature(*name,SENSORS_MTP008_IN4_MIN,&min) &&
1958	!sensors_get_feature(*name,SENSORS_MTP008_IN4_MAX,&max)) {
1959	if (valid) {
1960	print_label(label,10);
1961	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1962	cur,min,max,alarms&MTP008_ALARM_IN4?"ALARM":"");
1963	}
1964	} else
1965	printf("ERROR: Can't get IN4 data!\n");
1966	free_the_label(&label);
1967	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN5,&label,&valid) &&
1968	!sensors_get_feature(*name,SENSORS_MTP008_IN5,&cur) &&
1969	!sensors_get_feature(*name,SENSORS_MTP008_IN5_MIN,&min) &&
1970	!sensors_get_feature(*name,SENSORS_MTP008_IN5_MAX,&max)) {
1971	if (valid) {
1972	print_label(label,10);
1973	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1974	cur,min,max,alarms&MTP008_ALARM_IN5?"ALARM":"");
1975	}
1976	} else
1977	printf("ERROR: Can't get IN5 data!\n");
1978	free_the_label(&label);
1979	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN6,&label,&valid) &&
1980	!sensors_get_feature(*name,SENSORS_MTP008_IN6,&cur) &&
1981	!sensors_get_feature(*name,SENSORS_MTP008_IN6_MIN,&min) &&
1982	!sensors_get_feature(*name,SENSORS_MTP008_IN6_MAX,&max)) {
1983	if (valid) {
1984	print_label(label,10);
1985	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1986	cur,min,max,alarms&MTP008_ALARM_IN6?"ALARM":"");
1987	}
1988	} else
1989	printf("ERROR: Can't get IN6 data!\n");
1990	free_the_label(&label);
1991
1992	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN1,&label,&valid) &&
1993	!sensors_get_feature(*name,SENSORS_MTP008_FAN1,&cur) &&
1994	!sensors_get_feature(*name,SENSORS_MTP008_FAN1_DIV,&fdiv) &&
1995	!sensors_get_feature(*name,SENSORS_MTP008_FAN1_MIN,&min)) {
1996	if (valid) {
1997	print_label(label,10);
1998	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
1999	cur,min,fdiv, alarms&MTP008_ALARM_FAN1?"ALARM":"");
2000	}
2001	} else
2002	printf("ERROR: Can't get FAN1 data!\n");
2003	free_the_label(&label);
2004	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN2,&label,&valid) &&
2005	!sensors_get_feature(*name,SENSORS_MTP008_FAN2,&cur) &&
2006	!sensors_get_feature(*name,SENSORS_MTP008_FAN2_DIV,&fdiv) &&
2007	!sensors_get_feature(*name,SENSORS_MTP008_FAN2_MIN,&min)) {
2008	if (valid) {
2009	print_label(label,10);
2010	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2011	cur,min,fdiv, alarms&MTP008_ALARM_FAN2?"ALARM":"");
2012	}
2013	} else
2014	printf("ERROR: Can't get FAN2 data!\n");
2015	free_the_label(&label);
2016	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN3,&label,&valid) &&
2017	!sensors_get_feature(*name,SENSORS_MTP008_FAN3,&cur) &&
2018	!sensors_get_feature(*name,SENSORS_MTP008_FAN3_DIV,&fdiv) &&
2019	!sensors_get_feature(*name,SENSORS_MTP008_FAN3_MIN,&min)) {
2020	if (valid) {
2021	print_label(label,10);
2022	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2023	cur,min,fdiv, alarms&MTP008_ALARM_FAN3?"ALARM":"");
2024	}
2025	} else
2026	printf("ERROR: Can't get FAN3 data!\n");
2027	free_the_label(&label);
2028
2029	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP1,&label,&valid) &&
2030	!sensors_get_feature(*name,SENSORS_MTP008_TEMP1,&cur) &&
2031	!sensors_get_feature(*name,SENSORS_MTP008_TEMP1_HYST,&min) &&
2032	!sensors_get_feature(*name,SENSORS_MTP008_TEMP1_OVER,&max)) {
2033	if (valid) {
2034	print_label(label,10);
2035	print_temp_info( cur, max, min, HYST, 0, 0);
2036	printf(" %s\n", alarms&MTP008_ALARM_TEMP1?"ALARM":"");
2037	}
2038	} else
2039	printf("ERROR: Can't get TEMP1 data!\n");
2040	free_the_label(&label);
2041
2042	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP2,&label,&valid) &&
2043	!sensors_get_feature(*name,SENSORS_MTP008_TEMP2,&cur) &&
2044	!sensors_get_feature(*name,SENSORS_MTP008_TEMP2_HYST,&min) &&
2045	!sensors_get_feature(*name,SENSORS_MTP008_TEMP2_OVER,&max)) {
2046	if (valid) {
2047	print_label(label,10);
2048	print_temp_info( cur, max, min, HYST, 0, 0);
2049	printf(" %s\n", alarms&MTP008_ALARM_TEMP2?"ALARM":"");
2050	}
2051	} else
2052	printf("ERROR: Can't get TEMP2 data!\n");
2053	free_the_label(&label);
2054
2055	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP3,&label,&valid) &&
2056	!sensors_get_feature(*name,SENSORS_MTP008_TEMP3,&cur) &&
2057	!sensors_get_feature(*name,SENSORS_MTP008_TEMP3_HYST,&min) &&
2058	!sensors_get_feature(*name,SENSORS_MTP008_TEMP3_OVER,&max)) {
2059	if (valid) {
2060	print_label(label,10);
2061	print_temp_info( cur, max, min, HYST, 0, 0);
2062	printf(" %s\n", alarms&MTP008_ALARM_TEMP3?"ALARM":"");
2063	}
2064	} else
2065	printf("ERROR: Can't get TEMP3 data!\n");
2066	free_the_label(&label);
2067
2068	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_VID,&label,&valid) &&
2069	!sensors_get_feature(*name,SENSORS_MTP008_VID,&cur)) {
2070	if (valid) {
2071	print_label(label,10);
2072	printf("%+6.2f V\n",cur);
2073	}
2074	}
2075	free_the_label(&label);
2076	}
2077
2078	void print_w83781d(const sensors_chip_name *name)
2079	{
2080	char *label = NULL;
2081	double cur,min,max,fdiv,sens;
2082	int alarms,beeps;
2083	int is82d, is83s, is697hf, is627thf, valid;
2084
2085	is82d = (!strcmp(name->prefix,"w83782d")) \|\|
2086	(!strcmp(name->prefix,"w83627hf")) \|\|
2087	(!strcmp(name->prefix,"w83637hf")) \|\|
2088	(!strcmp(name->prefix,"w83627thf"));
2089	is83s = !strcmp(name->prefix,"w83783s");
2090	is627thf = (!strcmp(name->prefix,"w83627thf")) \|\|
2091	(!strcmp(name->prefix,"w83637hf"));
2092	is697hf = !strcmp(name->prefix,"w83697hf");
2093
2094	if (!sensors_get_feature(*name,SENSORS_W83781D_ALARMS,&cur))
2095	alarms = cur + 0.5;
2096	else {
2097	printf("ERROR: Can't get alarm data!\n");
2098	alarms = 0;
2099	}
2100
2101	if (!sensors_get_feature(*name,SENSORS_W83781D_BEEPS,&cur)) {
2102	beeps = cur + 0.5;
2103	/* strangely, as99127f beep bits are inverted */
2104	if (!strcmp(name->prefix,"as99127f"))
2105	beeps = ~beeps;
2106	} else {
2107	printf("ERROR: Can't get beep data!\n");
2108	beeps = 0;
2109	}
2110
2111	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN0,&label,&valid) &&
2112	!sensors_get_feature(*name,SENSORS_W83781D_IN0,&cur) &&
2113	!sensors_get_feature(*name,SENSORS_W83781D_IN0_MIN,&min) &&
2114	!sensors_get_feature(*name,SENSORS_W83781D_IN0_MAX,&max)) {
2115	if (valid) {
2116	print_label(label,10);
2117	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2118	cur,min,max,alarms&W83781D_ALARM_IN0?"ALARM":" ",
2119	beeps&W83781D_ALARM_IN0?"(beep)":"");
2120	}
2121	} else
2122	printf("ERROR: Can't get IN0 data!\n");
2123	free_the_label(&label);
2124	if ((!is83s) && (!is697hf)) {
2125	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN1,&label,&valid) &&
2126	!sensors_get_feature(*name,SENSORS_W83781D_IN1,&cur) &&
2127	!sensors_get_feature(*name,SENSORS_W83781D_IN1_MIN,&min) &&
2128	!sensors_get_feature(*name,SENSORS_W83781D_IN1_MAX,&max)) {
2129	if (valid) {
2130	print_label(label,10);
2131	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2132	cur,min,max,alarms&W83781D_ALARM_IN1?"ALARM":" ",
2133	beeps&W83781D_ALARM_IN1?"(beep)":"");
2134	}
2135	} else
2136	printf("ERROR: Can't get IN1 data!\n");
2137	free_the_label(&label);
2138	}
2139	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN2,&label,&valid) &&
2140	!sensors_get_feature(*name,SENSORS_W83781D_IN2,&cur) &&
2141	!sensors_get_feature(*name,SENSORS_W83781D_IN2_MIN,&min) &&
2142	!sensors_get_feature(*name,SENSORS_W83781D_IN2_MAX,&max)) {
2143	if (valid) {
2144	print_label(label,10);
2145	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2146	cur,min,max,alarms&W83781D_ALARM_IN2?"ALARM":" ",
2147	beeps&W83781D_ALARM_IN2?"(beep)":"");
2148	}
2149	} else
2150	printf("ERROR: Can't get IN2 data!\n");
2151	free_the_label(&label);
2152	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN3,&label,&valid) &&
2153	!sensors_get_feature(*name,SENSORS_W83781D_IN3,&cur) &&
2154	!sensors_get_feature(*name,SENSORS_W83781D_IN3_MIN,&min) &&
2155	!sensors_get_feature(*name,SENSORS_W83781D_IN3_MAX,&max)) {
2156	if (valid) {
2157	print_label(label,10);
2158	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2159	cur,min,max,alarms&W83781D_ALARM_IN3?"ALARM":" ",
2160	beeps&W83781D_ALARM_IN3?"(beep)":"");
2161	}
2162	} else
2163	printf("ERROR: Can't get IN3 data!\n");
2164	free_the_label(&label);
2165	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN4,&label,&valid) &&
2166	!sensors_get_feature(*name,SENSORS_W83781D_IN4,&cur) &&
2167	!sensors_get_feature(*name,SENSORS_W83781D_IN4_MIN,&min) &&
2168	!sensors_get_feature(*name,SENSORS_W83781D_IN4_MAX,&max)) {
2169	if (valid) {
2170	print_label(label,10);
2171	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2172	cur,min,max,alarms&W83781D_ALARM_IN4?"ALARM":" ",
2173	beeps&W83781D_ALARM_IN4?"(beep)":"");
2174	}
2175	} else
2176	printf("ERROR: Can't get IN4 data!\n");
2177	free_the_label(&label);
2178	if (!is627thf) {
2179	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN5,&label,&valid) &&
2180	!sensors_get_feature(*name,SENSORS_W83781D_IN5,&cur) &&
2181	!sensors_get_feature(*name,SENSORS_W83781D_IN5_MIN,&min) &&
2182	!sensors_get_feature(*name,SENSORS_W83781D_IN5_MAX,&max)) {
2183	if (valid) {
2184	print_label(label,10);
2185	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2186	cur,min,max,alarms&W83781D_ALARM_IN5?"ALARM":" ",
2187	beeps&W83781D_ALARM_IN5?"(beep)":"");
2188	}
2189	} else
2190	printf("ERROR: Can't get IN5 data!\n");
2191	free_the_label(&label);
2192	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN6,&label,&valid) &&
2193	!sensors_get_feature(*name,SENSORS_W83781D_IN6,&cur) &&
2194	!sensors_get_feature(*name,SENSORS_W83781D_IN6_MIN,&min) &&
2195	!sensors_get_feature(*name,SENSORS_W83781D_IN6_MAX,&max)) {
2196	if (valid) {
2197	print_label(label,10);
2198	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2199	cur,min,max,alarms&W83781D_ALARM_IN6?"ALARM":" ",
2200	beeps&W83781D_ALARM_IN6?"(beep)":"");
2201	}
2202	} else
2203	printf("ERROR: Can't get IN6 data!\n");
2204	free_the_label(&label);
2205	} /* !is627thf */
2206	if (is82d \|\| is697hf \|\| is627thf) {
2207	if (!sensors_get_label_and_valid(*name,SENSORS_W83782D_IN7,&label,&valid) &&
2208	!sensors_get_feature(*name,SENSORS_W83782D_IN7,&cur) &&
2209	!sensors_get_feature(*name,SENSORS_W83782D_IN7_MIN,&min) &&
2210	!sensors_get_feature(*name,SENSORS_W83782D_IN7_MAX,&max)) {
2211	if (valid) {
2212	print_label(label,10);
2213	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2214	cur,min,max,alarms&W83782D_ALARM_IN7?"ALARM":" ",
2215	beeps&W83782D_ALARM_IN7?"(beep)":"");
2216	}
2217	} else
2218	printf("ERROR: Can't get IN7 data!\n");
2219	free_the_label(&label);
2220	if (!sensors_get_label_and_valid(*name,SENSORS_W83782D_IN8,&label,&valid) &&
2221	!sensors_get_feature(*name,SENSORS_W83782D_IN8,&cur) &&
2222	!sensors_get_feature(*name,SENSORS_W83782D_IN8_MIN,&min) &&
2223	!sensors_get_feature(*name,SENSORS_W83782D_IN8_MAX,&max)) {
2224	if (valid) {
2225	print_label(label,10);
2226	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2227	cur,min,max,alarms&W83782D_ALARM_IN8?"ALARM":" ",
2228	beeps&W83782D_ALARM_IN8?"(beep)":"");
2229	}
2230	} else
2231	printf("ERROR: Can't get IN8 data!\n");
2232	free_the_label(&label);
2233	}
2234
2235	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN1,&label,&valid) &&
2236	!sensors_get_feature(*name,SENSORS_W83781D_FAN1,&cur) &&
2237	!sensors_get_feature(*name,SENSORS_W83781D_FAN1_DIV,&fdiv) &&
2238	!sensors_get_feature(*name,SENSORS_W83781D_FAN1_MIN,&min)) {
2239	if (valid) {
2240	print_label(label,10);
2241	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
2242	cur,min,fdiv, alarms&W83781D_ALARM_FAN1?"ALARM":" ",
2243	beeps&W83781D_ALARM_FAN1?"(beep)":"");
2244	}
2245	} else
2246	printf("ERROR: Can't get FAN1 data!\n");
2247	free_the_label(&label);
2248	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN2,&label,&valid) &&
2249	!sensors_get_feature(*name,SENSORS_W83781D_FAN2,&cur) &&
2250	!sensors_get_feature(*name,SENSORS_W83781D_FAN2_DIV,&fdiv) &&
2251	!sensors_get_feature(*name,SENSORS_W83781D_FAN2_MIN,&min)) {
2252	if (valid) {
2253	print_label(label,10);
2254	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
2255	cur,min,fdiv, alarms&W83781D_ALARM_FAN2?"ALARM":" ",
2256	beeps&W83781D_ALARM_FAN2?"(beep)":"");
2257	}
2258	} else
2259	printf("ERROR: Can't get FAN2 data!\n");
2260	free_the_label(&label);
2261
2262	if(!is697hf) {
2263	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN3,&label,&valid) &&
2264	!sensors_get_feature(*name,SENSORS_W83781D_FAN3,&cur) &&
2265	!sensors_get_feature(*name,SENSORS_W83781D_FAN3_DIV,&fdiv) &&
2266	!sensors_get_feature(*name,SENSORS_W83781D_FAN3_MIN,&min)) {
2267	if (valid) {
2268	print_label(label,10);
2269	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
2270	cur,min,fdiv, alarms&W83781D_ALARM_FAN3?"ALARM":" ",
2271	beeps&W83781D_ALARM_FAN3?"(beep)":"");
2272	}
2273	} else
2274	printf("ERROR: Can't get FAN3 data!\n");
2275	free_the_label(&label);
2276	}
2277
2278	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP1,&label,&valid) &&
2279	!sensors_get_feature(*name,SENSORS_W83781D_TEMP1,&cur) &&
2280	!sensors_get_feature(*name,SENSORS_W83781D_TEMP1_HYST,&min) &&
2281	!sensors_get_feature(*name,SENSORS_W83781D_TEMP1_OVER,&max)) {
2282	if (valid) {
2283	if((!is82d) && (!is83s) && (!is697hf)) {
2284	print_label(label,10);
2285	if(min == 127)
2286	print_temp_info( cur, max, 0, MAXONLY, 0, 0);
2287	else
2288	print_temp_info( cur, max, min, HYST, 0, 0);
2289	printf(" %s %s\n", alarms&W83781D_ALARM_TEMP1 ?"ALARM":" ",
2290	beeps&W83781D_ALARM_TEMP1?"(beep)":"");
2291	} else {
2292	if(!sensors_get_feature(*name,SENSORS_W83781D_SENS1,&sens)) {
2293	print_label(label,10);
2294	if(min == 127)
2295	print_temp_info( cur, max, 0, MAXONLY, 0, 0);
2296	else
2297	print_temp_info( cur, max, min, HYST, 0, 0);
2298	printf( " sensor = %s %s %s\n",
2299	(((int)sens)==1)?"PII/Celeron diode":(((int)sens)==2)?
2300	"3904 transistor":"thermistor",
2301	alarms&W83781D_ALARM_TEMP1?"ALARM":" ",
2302	beeps&W83781D_ALARM_TEMP1?"(beep)":"");
2303	} else {
2304	printf("ERROR: Can't get TEMP1 data!\n");
2305	}
2306	}
2307	}
2308	} else
2309	printf("ERROR: Can't get TEMP1 data!\n");
2310	free_the_label(&label);
2311
2312	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP2,&label,&valid) &&
2313	!sensors_get_feature(*name,SENSORS_W83781D_TEMP2,&cur) &&
2314	!sensors_get_feature(*name,SENSORS_W83781D_TEMP2_HYST,&min) &&
2315	!sensors_get_feature(*name,SENSORS_W83781D_TEMP2_OVER,&max)) {
2316	if (valid) {
2317	if((!is82d) && (!is83s) && (!is697hf)) {
2318	print_label(label,10);
2319	print_temp_info( cur, max, min, HYST, 1, 0);
2320	printf(" %s %s\n", alarms&W83781D_ALARM_TEMP2 ?"ALARM":" ",
2321	beeps&W83781D_ALARM_TEMP2?"(beep)":"");
2322	} else {
2323	if(!sensors_get_feature(*name,SENSORS_W83781D_SENS2,&sens)) {
2324	print_label(label,10);
2325	print_temp_info( cur, max, min, HYST, 1, 0);
2326	printf( " sensor = %s %s %s\n",
2327	(((int)sens)==1)?"PII/Celeron diode":(((int)sens)==2)?
2328	"3904 transistor":"thermistor",
2329	alarms&W83781D_ALARM_TEMP2?"ALARM":" ",
2330	beeps&W83781D_ALARM_TEMP2?"(beep)":"");
2331	} else {
2332	printf("ERROR: Can't get TEMP2 data!\n");
2333	}
2334	}
2335	}
2336	} else
2337	printf("ERROR: Can't get TEMP2 data!\n");
2338	free_the_label(&label);
2339
2340	if ((!is83s) && (!is697hf)) {
2341	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP3,&label,&valid) &&
2342	!sensors_get_feature(*name,SENSORS_W83781D_TEMP3,&cur) &&
2343	!sensors_get_feature(*name,SENSORS_W83781D_TEMP3_HYST,&min) &&
2344	!sensors_get_feature(*name,SENSORS_W83781D_TEMP3_OVER,&max)) {
2345	if (valid) {
2346	if(!is82d) {
2347	print_label(label,10);
2348	print_temp_info( cur, max, min, HYST, 1, 0);
2349	printf(" %s %s\n", alarms&W83781D_ALARM_TEMP3 ?"ALARM":" ",
2350	beeps&W83781D_ALARM_TEMP3?"(beep)":"");
2351	} else {
2352	if(!sensors_get_feature(*name,SENSORS_W83781D_SENS3,&sens)) {
2353	print_label(label,10);
2354	print_temp_info( cur, max, min, HYST, 1, 0);
2355	printf( " sensor = %s %s %s\n",
2356	(((int)sens)==1)?"PII/Celeron diode":(((int)sens)==2)?
2357	"3904 transistor":"thermistor",
2358	alarms&W83781D_ALARM_TEMP3?"ALARM":" ",
2359	beeps&W83781D_ALARM_TEMP3?"(beep)":"");
2360	} else {
2361	printf("ERROR: Can't get TEMP3 data!\n");
2362	}
2363	}
2364	}
2365	} else
2366	printf("ERROR: Can't get TEMP3 data!\n");
2367	free_the_label(&label);
2368	}
2369
2370	if(!is697hf) {
2371	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_VID,&label,&valid) &&
2372	!sensors_get_feature(*name,SENSORS_W83781D_VID,&cur)) {
2373	if (valid) {
2374	print_label(label,10);
2375	printf("%+5.3f V\n",cur);
2376	}
2377	} else {
2378	printf("ERROR: Can't get VID data!\n");
2379	}
2380	free_the_label(&label);
2381	}
2382
2383	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_ALARMS,&label,&valid)
2384	&& valid && !is83s) {
2385	print_label(label,10);
2386	if (alarms & W83781D_ALARM_CHAS)
2387	printf("Chassis intrusion detection ALARM\n");
2388	else
2389	printf("\n");
2390	}
2391	free_the_label(&label);
2392
2393	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_BEEP_ENABLE,&label,&valid)
2394	&& valid) {
2395	if (!sensors_get_feature(*name,SENSORS_W83781D_BEEP_ENABLE,&cur)) {
2396	print_label(label,10);
2397	if (cur < 0.5)
2398	printf("Sound alarm disabled\n");
2399	else
2400	printf("Sound alarm enabled\n");
2401	} else
2402	printf("ERROR: Can't get BEEP data!\n");
2403	}
2404	free_the_label(&label);
2405	}
2406
2407	void print_w83l785ts(const sensors_chip_name *name)
2408	{
2409	char *label;
2410	double cur, over;
2411	int valid;
2412
2413	if (!sensors_get_label_and_valid(*name, SENSORS_W83L785TS_TEMP, &label, &valid)
2414	&& !sensors_get_feature(*name, SENSORS_W83L785TS_TEMP, &cur)
2415	&& !sensors_get_feature(*name, SENSORS_W83L785TS_TEMP_OVER, &over)) {
2416	if (valid) {
2417	print_label(label, 10);
2418	print_temp_info(cur, over, 0, MAXONLY, 0, 0);
2419	printf("\n");
2420	}
2421	} else
2422	printf("ERROR: Can't get temperature data!\n");
2423	free_the_label(&label);
2424	}
2425
2426	void print_maxilife(const sensors_chip_name *name)
2427	{
2428	char *label = NULL;
2429	double cur, min, max;
2430	int alarms,valid;
2431
2432	if (!sensors_get_feature(*name, SENSORS_MAXI_CG_ALARMS, &cur))
2433	alarms = cur + 0.5;
2434	else {
2435	printf("ERROR: Can't get alarm data!\n");
2436	alarms = 0;
2437	}
2438
2439	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP1, &label,&valid) &&
2440	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1, &cur) &&
2441	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1_MAX, &max) &&
2442	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1_HYST, &min)) {
2443	if (valid && (cur \|\| max \|\| min)) {
2444	print_label(label, 12);
2445	print_temp_info( cur, max, min, HYST, 1, 0);
2446	printf("\n");
2447	}
2448	} else
2449	printf("ERROR: Can't get TEMP1 data!\n");
2450	free_the_label(&label);
2451
2452	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP2, &label,&valid) &&
2453	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2, &cur) &&
2454	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2_MAX, &max) &&
2455	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2_HYST, &min)) {
2456	if (valid && (cur \|\| max \|\| min)) {
2457	print_label(label, 12);
2458	print_temp_info( cur, max, min, HYST, 1, 0);
2459	printf(" %s\n", alarms&MAXI_ALARM_TEMP2 ? "ALARM" : "");
2460	}
2461	} else
2462	printf("ERROR: Can't get TEMP2 data!\n");
2463	free_the_label(&label);
2464
2465	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP3, &label,&valid) &&
2466	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3, &cur) &&
2467	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3_MAX, &max) &&
2468	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3_HYST, &min)) {
2469	if (valid && (cur \|\| max \|\| min)) {
2470	print_label(label, 12);
2471	print_temp_info( cur, max, min, HYST, 1, 0);
2472	printf("\n");
2473	}
2474	} else
2475	printf("ERROR: Can't get TEMP3 data!\n");
2476	free_the_label(&label);
2477
2478	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP4, &label,&valid) &&
2479	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4, &cur) &&
2480	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4_MAX, &max) &&
2481	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4_HYST, &min)) {
2482	if (valid && (cur \|\| max \|\| min)) {
2483	print_label(label, 12);
2484	print_temp_info( cur, max, min, HYST, 1, 0);
2485	printf(" %s\n", alarms&MAXI_ALARM_TEMP4 ? "ALARM" : "");
2486	}
2487	} else
2488	printf("ERROR: Can't get TEMP4 data!\n");
2489	free_the_label(&label);
2490
2491	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP5, &label,&valid) &&
2492	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5, &cur) &&
2493	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5_MAX, &max) &&
2494	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5_HYST, &min)) {
2495	if (valid && (cur \|\| max \|\| min)) {
2496	print_label(label, 12);
2497	print_temp_info( cur, max, min, HYST, 1, 0);
2498	printf(" %s\n", alarms&MAXI_ALARM_TEMP5 ? "ALARM" : "");
2499	}
2500	} else
2501	printf("ERROR: Can't get TEMP5 data!\n");
2502	free_the_label(&label);
2503
2504	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN1, &label,&valid) &&
2505	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1, &cur) &&
2506	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1_MIN, &min) &&
2507	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1_DIV, &max)) {
2508	if (valid && (cur \|\| min \|\| max)) {
2509	print_label(label, 12);
2510	if (cur < 0)
2511	printf(" OFF (min = %4.0f RPM, div = %1.0f) %s\n",
2512	min/max, max, alarms&MAXI_ALARM_FAN1 ? "ALARM" : "");
2513	else
2514	printf("%5.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2515	cur/max, min/max, max, alarms&MAXI_ALARM_FAN1 ? "ALARM" : "");
2516	}
2517	} else
2518	printf("ERROR: Can't get FAN1 data!\n");
2519	free_the_label(&label);
2520
2521	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN2, &label,&valid) &&
2522	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2, &cur) &&
2523	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2_MIN, &min) &&
2524	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2_DIV, &max)) {
2525	if (valid && (cur \|\| min \|\| max)) {
2526	print_label(label, 12);
2527	if (cur < 0)
2528	printf(" OFF (min = %4.0f RPM, div = %1.0f) %s\n",
2529	min/max, max, alarms&MAXI_ALARM_FAN2 ? "ALARM" : "");
2530	else
2531	printf("%5.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2532	cur/max, min/max, max, alarms&MAXI_ALARM_FAN2 ? "ALARM" : "");
2533	}
2534	} else
2535	printf("ERROR: Can't get FAN2 data!\n");
2536	free_the_label(&label);
2537
2538	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN3, &label,&valid) &&
2539	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3, &cur) &&
2540	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3_MIN, &min) &&
2541	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3_DIV, &max)) {
2542	if (valid && (cur \|\| min \|\| max)) {
2543	print_label(label, 12);
2544	if (cur < 0)
2545	printf(" OFF (min = %4.0f RPM, div = %1.0f) %s\n",
2546	min/max, max, alarms&MAXI_ALARM_FAN3 ? "ALARM" : "");
2547	else
2548	printf("%5.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2549	cur/max, min/max, max, alarms&MAXI_ALARM_FAN3 ? "ALARM" : "");
2550	}
2551	} else
2552	printf("ERROR: Can't get FAN3 data!\n");
2553	free_the_label(&label);
2554
2555	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_PLL, &label,&valid) &&
2556	!sensors_get_feature(*name, SENSORS_MAXI_CG_PLL, &cur) &&
2557	!sensors_get_feature(*name, SENSORS_MAXI_CG_PLL_MIN, &min) &&
2558	!sensors_get_feature(*name, SENSORS_MAXI_CG_PLL_MAX, &max)) {
2559	if (valid && (cur \|\| min \|\| max)) {
2560	print_label(label, 12);
2561	printf("%4.2f MHz (min = %4.2f MHz, max = %4.2f MHz) %s\n",
2562	cur, min, max, alarms&MAXI_ALARM_PLL ? "ALARM" : "");
2563	}
2564	} else
2565	printf("ERROR: Can't get PLL data!\n");
2566	free_the_label(&label);
2567
2568	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID1, &label,&valid) &&
2569	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID1, &cur) &&
2570	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID1_MIN, &min) &&
2571	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID1_MAX, &max)) {
2572	if (valid && (cur \|\| min \|\| max)) {
2573	print_label(label, 12);
2574	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2575	cur, min, max, alarms&MAXI_ALARM_VID1 ? "ALARM" : "");
2576	}
2577	} else
2578	printf("ERROR: Can't get VID1 data!\n");
2579	free_the_label(&label);
2580
2581	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID2, &label,&valid) &&
2582	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID2, &cur) &&
2583	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID2_MIN, &min) &&
2584	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID2_MAX, &max)) {
2585	if (valid && (cur \|\| min \|\| max)) {
2586	print_label(label, 12);
2587	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2588	cur, min, max, alarms&MAXI_ALARM_VID2 ? "ALARM" : "");
2589	}
2590	} else
2591	printf("ERROR: Can't get VID2 data!\n");
2592	free_the_label(&label);
2593
2594	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID3, &label,&valid) &&
2595	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID3, &cur) &&
2596	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID3_MIN, &min) &&
2597	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID3_MAX, &max)) {
2598	if (valid && (cur \|\| min \|\| max)) {
2599	print_label(label, 12);
2600	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2601	cur, min, max, alarms&MAXI_ALARM_VID3 ? "ALARM" : "");
2602	}
2603	} else
2604	printf("ERROR: Can't get VID3 data!\n");
2605	free_the_label(&label);
2606
2607	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID4, &label,&valid) &&
2608	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID4, &cur) &&
2609	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID4_MIN, &min) &&
2610	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID4_MAX, &max)) {
2611	if (valid && (cur \|\| min \|\| max)) {
2612	print_label(label, 12);
2613	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2614	cur, min, max, alarms&MAXI_ALARM_VID4 ? "ALARM" : "");
2615	}
2616	} else
2617	printf("ERROR: Can't get VID4 data!\n");
2618	free_the_label(&label);
2619	}
2620
2621	void print_ddcmon(const sensors_chip_name *name)
2622	{
2623	char *label = NULL;
2624	double a, b, c;
2625	int valid, i;
2626
2627	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_MAN_ID, &label, &valid)
2628	&& !sensors_get_feature(*name, SENSORS_DDCMON_MAN_ID, &a)) {
2629	if (valid) {
2630	i = (int) a;
2631	print_label(label, 24);
2632	printf("%c%c%c\n",
2633	((i >> 10) & 0x1f) + 'A' - 1, ((i >> 5) & 0x1f) + 'A' - 1,
2634	(i & 0x1f) + 'A' - 1);
2635	}
2636	} else
2637	printf("ERROR: data 1\n");
2638	free_the_label(&label);
2639
2640	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_PROD_ID, &label, &valid)
2641	&& !sensors_get_feature(*name, SENSORS_DDCMON_PROD_ID, &a)) {
2642	if (valid) {
2643	i = (int) a;
2644	print_label(label, 24);
2645	printf("0x%04X\n", i);
2646	}
2647	} else
2648	printf("ERROR: data 2\n");
2649	free_the_label(&label);
2650
2651	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_SERIAL, &label,&valid) &&
2652	!sensors_get_feature(*name, SENSORS_DDCMON_SERIAL, &a)) {
2653	if (valid) {
2654	print_label(label, 24);
2655	printf("%d\n", (int) a);
2656	}
2657	} else
2658	printf("ERROR: data 3\n");
2659	free_the_label(&label);
2660
2661	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_YEAR, &label, &valid)
2662	&& !sensors_get_feature(*name, SENSORS_DDCMON_YEAR, &a)
2663	&& !sensors_get_feature(*name, SENSORS_DDCMON_WEEK, &b)) {
2664	if (valid) {
2665	print_label(label, 24);
2666	printf("%d-W%d\n", (int) a, (int) b);
2667	}
2668	} else
2669	printf("ERROR: data 4\n");
2670	free_the_label(&label);
2671
2672	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_EDID_VER, &label, &valid)
2673	&& !sensors_get_feature(*name, SENSORS_DDCMON_EDID_VER, &a)
2674	&& !sensors_get_feature(*name, SENSORS_DDCMON_EDID_REV, &b)) {
2675	if (valid) {
2676	print_label(label, 24);
2677	printf("%d.%d\n", (int) a, (int) b);
2678	}
2679	} else
2680	printf("ERROR: data 5\n");
2681	free_the_label(&label);
2682
2683	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_VERSIZE, &label,&valid) &&
2684	!sensors_get_feature(*name, SENSORS_DDCMON_VERSIZE, &a) &&
2685	!sensors_get_feature(*name, SENSORS_DDCMON_HORSIZE, &b)) {
2686	if (valid) {
2687	print_label(label, 24);
2688	printf("%dx%d\n", (int) a, (int) b);
2689	}
2690	} else
2691	printf("ERROR: data 6\n");
2692	free_the_label(&label);
2693
2694	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_GAMMA, &label, &valid)
2695	&& !sensors_get_feature(*name, SENSORS_DDCMON_GAMMA, &a)) {
2696	if (valid) {
2697	print_label(label, 24);
2698	printf("%.02f\n", a);
2699	}
2700	} else
2701	printf("ERROR: data 7\n");
2702	free_the_label(&label);
2703
2704	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_DPMS, &label, &valid)
2705	&& !sensors_get_feature(*name, SENSORS_DDCMON_DPMS, &a)) {
2706	if (valid) {
2707	i = (int) a;
2708	print_label(label, 24);
2709	if (i & 0xe0) {
2710	printf("%s%s%s%s%s\n",
2711	i & 0x20 ? "Active Off" : "",
2712	(i & 0x40) && (i & 0x20) ? ", ": "",
2713	i & 0x40 ? "Suspend" : "",
2714	(i & 0x80) && (i & 0x60) ? ", ": "",
2715	i & 0x80 ? "Standby" : "");
2716	} else {
2717	printf("None supported\n");
2718	}
2719	}
2720	} else
2721	printf("ERROR: data 8\n");
2722	free_the_label(&label);
2723
2724	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_TIMINGS, &label,&valid) &&
2725	!sensors_get_feature(*name, SENSORS_DDCMON_TIMINGS, &a)) {
2726	if (valid) {
2727	i = (int) a;
2728	if (i & 0x03) { /* 720x400 */
2729	print_label(label, 24);
2730	printf("720x400 @ %s%s%s Hz\n",
2731	i & 0x01 ? "70" : "",
2732	(i & 0x02) && (i & 0x01) ? "/" : "",
2733	i & 0x02 ? "88" : "");
2734	}
2735	if (i & 0x3c) { /* 640x480 */
2736	print_label(label, 24);
2737	printf("640x480 @ %s%s%s%s%s%s%s Hz\n",
2738	i & 0x04 ? "60" : "",
2739	(i & 0x08) && (i & 0x04) ? "/" : "",
2740	i & 0x08 ? "67" : "",
2741	(i & 0x10) && (i & 0x0c) ? "/" : "",
2742	i & 0x10 ? "72" : "",
2743	(i & 0x20) && (i & 0x1c) ? "/" : "",
2744	i & 0x20 ? "75" : "");
2745	}
2746	i >>= 6;
2747	if (i & 0x0f) { /* 800x600 */
2748	print_label(label, 24);
2749	printf("800x600 @ %s%s%s%s%s%s%s Hz\n",
2750	i & 0x01 ? "56" : "",
2751	(i & 0x02) && (i & 0x01) ? "/" : "",
2752	i & 0x02 ? "60" : "",
2753	(i & 0x04) && (i & 0x03) ? "/" : "",
2754	i & 0x04 ? "72" : "",
2755	(i & 0x08) && (i & 0x07) ? "/" : "",
2756	i & 0x08 ? "75" : "");
2757	}
2758	if (i & 0x10) { /* 832x624 */
2759	print_label(label, 24);
2760	printf("832x624 @ 75 Hz\n");
2761	}
2762	i >>= 5;
2763	if (i & 0x0f) { /* 1024x768 */
2764	print_label(label, 24);
2765	printf("1024x768 @ %s%s%s%s%s%s%s Hz\n",
2766	i & 0x01 ? "87i" : "",
2767	(i & 0x02) && (i & 0x01) ? "/" : "",
2768	i & 0x02 ? "60" : "",
2769	(i & 0x04) && (i & 0x03) ? "/" : "",
2770	i & 0x04 ? "70" : "",
2771	(i & 0x08) && (i & 0x07) ? "/" : "",
2772	i & 0x08 ? "75" : "");
2773	}
2774	if (i & 0x100) { /* 1152x870 */
2775	print_label(label, 24);
2776	printf("1152x870 @ 75 Hz\n");
2777	}
2778	if (i & 0x10) { /* 1280x1024 */
2779	print_label(label, 24);
2780	printf("1280x1024 @ 75 Hz\n");
2781	}
2782	}
2783	} else
2784	printf("ERROR: data 9\n");
2785	free_the_label(&label);
2786
2787	for(i = 0; i < 8; i++) {
2788	if (!sensors_get_label_and_valid(name, SENSORS_DDCMON_TIMING1_HOR + i 3, &label, &valid)
2789	&& !sensors_get_feature(name, SENSORS_DDCMON_TIMING1_HOR + i 3, &a)
2790	&& !sensors_get_feature(name, SENSORS_DDCMON_TIMING1_VER + i 3, &b)
2791	&& !sensors_get_feature(name, SENSORS_DDCMON_TIMING1_REF + i 3, &c)) {
2792	if (valid && ((int) a) != 0) {
2793	print_label(label, 24);
2794	printf("%dx%d @ %d Hz\n", (int) a, (int) b, (int) c);
2795	}
2796	} else
2797	printf("ERROR: data 10-%d\n", i+1);
2798	free_the_label(&label);
2799	}
2800
2801
2802	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_VERSYNCMIN, &label,&valid) &&
2803	!sensors_get_feature(*name, SENSORS_DDCMON_VERSYNCMIN, &a) &&
2804	!sensors_get_feature(*name, SENSORS_DDCMON_VERSYNCMAX, &b)) {
2805	if (valid && ((int) a) != 0) {
2806	print_label(label, 24);
2807	printf("%d-%d\n", (int) a, (int) b);
2808	}
2809	} else
2810	printf("ERROR: data 11\n");
2811	free_the_label(&label);
2812
2813	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_HORSYNCMIN, &label,&valid) &&
2814	!sensors_get_feature(*name, SENSORS_DDCMON_HORSYNCMIN, &a) &&
2815	!sensors_get_feature(*name, SENSORS_DDCMON_HORSYNCMAX, &b)) {
2816	if (valid && ((int) a) != 0) {
2817	print_label(label, 24);
2818	printf("%d-%d\n", (int) a, (int) b);
2819	}
2820	} else
2821	printf("ERROR: data 12\n");
2822	free_the_label(&label);
2823
2824	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_MAXCLOCK, &label, &valid)
2825	&& !sensors_get_feature(*name, SENSORS_DDCMON_MAXCLOCK, &a)) {
2826	if (valid && ((int) a) != 0) {
2827	print_label(label, 24);
2828	printf("%d\n", (int) a);
2829	}
2830	} else
2831	printf("ERROR: data 13\n");
2832	free_the_label(&label);
2833	}
2834
2835	/*
2836	* (Khali, 2003-07-17) Almost entierly rewritten. Reindented for clarity,
2837	* simplified at some places, added support for EDID EEPROMs (well,
2838	* redirection more than support).
2839	* (Khali, 2003-08-09) Rewrote Sony Vaio EEPROMs detection, and move it
2840	* to the top. This should prevent such EEPROMs from being accidentally
2841	* detected as valid memory modules.
2842	*/
2843	void print_eeprom(const sensors_chip_name *name)
2844	{
2845	char *label = NULL;
2846	double a, b, c, d;
2847	int valid, i, type;
2848
2849	/* handle Sony Vaio EEPROMs first */
2850	if (name->addr == 0x57) {
2851	char buffer[33];
2852
2853	/* first make sure it is a Sony Vaio EEPROM */
2854	if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_VAIO_NAME, &label, &valid)
2855	&& valid) {
2856	for (i = 0; i < 4; i++) /* stop at first zero */
2857	if (!sensors_get_feature(*name, SENSORS_EEPROM_VAIO_NAME+i, &a))
2858	buffer[i] = (char) a;
2859	if (strncmp(buffer, "PCG-", 4) == 0)
2860	{
2861	/* must be a real Sony Vaio EEPROM */
2862	memset(buffer + 4, '\0', 29);
2863	for (a = 1; i < 32 && a != 0; i++) /* stop at first zero */
2864	if (!sensors_get_feature(*name, SENSORS_EEPROM_VAIO_NAME+i, &a)
2865	&& a != 0)
2866	buffer[i] = (char) a;
2867	print_label(label, 24);
2868	printf("%s\n", buffer);
2869	free_the_label(&label);
2870
2871	memset(buffer, '\0', i);
2872	if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_VAIO_SERIAL, &label, &valid)
2873	&& valid) {
2874	for (i = 0, a = 1; i < 32 && a != 0; i++) /* stop at first zero */
2875	if (!sensors_get_feature(*name, SENSORS_EEPROM_VAIO_SERIAL+i, &a)
2876	&& a != 0)
2877	buffer[i] = (char) a;
2878	print_label(label, 24);
2879	printf("%s\n", buffer);
2880	} else
2881	printf("ERROR: data Vaio 3\n");
2882	free_the_label(&label);
2883
2884	return;
2885	}
2886	} else
2887	printf("ERROR: data Vaio 2\n");
2888	free_the_label(&label);
2889	}
2890
2891	if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_TYPE, &label, &valid)
2892	&& !sensors_get_feature(*name, SENSORS_EEPROM_TYPE, &a)) {
2893	if (valid) {
2894	type = (int) a;
2895	switch (type) {
2896	case 1:
2897	print_label(label, 24);
2898	printf("DRDRAM RIMM\n");
2899	break;
2900	case 2:
2901	print_label(label, 24);
2902	printf("EDO\n");
2903	break;
2904	case 4:
2905	print_label(label, 24);
2906	printf("SDR SDRAM DIMM\n");
2907	break;
2908	case 7:
2909	print_label(label, 24);
2910	printf("DDR SDRAM DIMM\n");
2911	break;
2912	case 17:
2913	print_label(label, 24);
2914	printf("RAMBUS RIMM\n");
2915	break;
2916	case 255: /* EDID EEPROM? */
2917	break;
2918	default:
2919	printf("Unknown EEPROM type (%d)\n", type);
2920	free_the_label(&label);
2921	return;
2922	}
2923	} else {
2924	free_the_label(&label);
2925	return;
2926	}
2927	} else {
2928	free_the_label(&label);
2929	printf("Memory type: Unavailable\n");
2930	return;
2931	}
2932	free_the_label(&label);
2933
2934	if (type == 255) { /* EDID EEPROM */
2935	/* make sure it is an EDID EEPROM */
2936	if (!sensors_get_feature(*name, SENSORS_EEPROM_ROWADDR, &a)
2937	&& !sensors_get_feature(*name, SENSORS_EEPROM_COLADDR, &b)
2938	&& !sensors_get_feature(*name, SENSORS_EEPROM_NUMROWS, &c)
2939	&& !sensors_get_feature(*name, SENSORS_EEPROM_EDID_HEADER, &d)) {
2940	if (((int) a) != 255 \|\| ((int) b) != 255 \|\| ((int) c) != 255
2941	\|\| ((int) d) != 0)
2942	printf("Unknown EEPROM type (255).\n");
2943	else if (name->addr == 0x50)
2944	/* must be an EDID EEPROM */
2945	printf("Either use the ddcmon driver instead of the eeprom driver,\n"
2946	"or run the decode-edid.pl script.\n");
2947	} else
2948	printf("ERROR: data EDID\n");
2949	return;
2950	}
2951
2952	/* regular memory chips */
2953	if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_ROWADDR, &label, &valid)
2954	&& !sensors_get_feature(*name, SENSORS_EEPROM_ROWADDR, &a)
2955	&& !sensors_get_feature(*name, SENSORS_EEPROM_COLADDR, &b)
2956	&& !sensors_get_feature(*name, SENSORS_EEPROM_NUMROWS, &c)
2957	&& !sensors_get_feature(*name, SENSORS_EEPROM_BANKS, &d)
2958	&& valid) {
2959	int k = 0; /* multiplier, 0 if invalid */
2960	print_label(label, 24);
2961	if (type == 17) { /* RAMBUS */
2962	i = (((int) a) & 0x0f) + (((int) a) >> 4) + (((int) c) & 0x07) - 13;
2963	k = 1;
2964	} else if (type == 1) { /* DRDRAM */
2965	i = (((int) b) & 0x0f) + (((int) b) >> 4) + (((int) c) & 0x07) - 13;
2966	k = 1;
2967	} else { /* SDRAM */
2968	i = (((int) a) & 0x0f) + (((int) b) & 0x0f) - 17;
2969	if (((int) c) <= 8 && ((int) d) <= 8)
2970	k = ((int) c) * ((int) d);
2971	}
2972	if(i > 0 && i <= 12 && k > 0)
2973	printf("%d\n", (1 << i) * k);
2974	else
2975	printf("invalid (%d %d %d %d)\n",
2976	(int) a, (int) b, (int) c, (int) d);
2977	} else
2978	printf("ERROR: data 2\n");
2979	free_the_label(&label);
2980	}
2981
2982	void print_it87(const sensors_chip_name *name)
2983	{
2984	char *label = NULL;
2985	double cur, min, max, fdiv, sens;
2986	int alarms, valid;
2987
2988	if (!sensors_get_feature(*name,SENSORS_IT87_ALARMS, &cur)) {
2989	alarms = cur + 0.5;
2990	}
2991	else {
2992	printf("ERROR: Can't get alarm data!\n");
2993	alarms = 0;
2994	}
2995
2996	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN0,&label,&valid) &&
2997	!sensors_get_feature(*name,SENSORS_IT87_IN0,&cur) &&
2998	!sensors_get_feature(*name,SENSORS_IT87_IN0_MIN,&min) &&
2999	!sensors_get_feature(*name,SENSORS_IT87_IN0_MAX,&max)) {
3000	if (valid) {
3001	print_label(label,10);
3002	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3003	cur,min,max,alarms&IT87_ALARM_IN0?"ALARM":"");
3004	}
3005	} else
3006	printf("ERROR: Can't get IN0 data!\n");
3007	free_the_label(&label);
3008	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN1,&label,&valid) &&
3009	!sensors_get_feature(*name,SENSORS_IT87_IN1,&cur) &&
3010	!sensors_get_feature(*name,SENSORS_IT87_IN1_MIN,&min) &&
3011	!sensors_get_feature(*name,SENSORS_IT87_IN1_MAX,&max)) {
3012	if (valid) {
3013	print_label(label,10);
3014	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3015	cur,min,max,alarms&IT87_ALARM_IN1?"ALARM":"");
3016	}
3017	} else
3018	printf("ERROR: Can't get IN1 data!\n");
3019	free_the_label(&label);
3020	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN2,&label,&valid) &&
3021	!sensors_get_feature(*name,SENSORS_IT87_IN2,&cur) &&
3022	!sensors_get_feature(*name,SENSORS_IT87_IN2_MIN,&min) &&
3023	!sensors_get_feature(*name,SENSORS_IT87_IN2_MAX,&max)) {
3024	if (valid) {
3025	print_label(label,10);
3026	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3027	cur,min,max,alarms&IT87_ALARM_IN2?"ALARM":"");
3028	}
3029	} else
3030	printf("ERROR: Can't get IN2 data!\n");
3031	free_the_label(&label);
3032	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN3,&label,&valid) &&
3033	!sensors_get_feature(*name,SENSORS_IT87_IN3,&cur) &&
3034	!sensors_get_feature(*name,SENSORS_IT87_IN3_MIN,&min) &&
3035	!sensors_get_feature(*name,SENSORS_IT87_IN3_MAX,&max)) {
3036	if (valid) {
3037	print_label(label,10);
3038	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3039	cur,min,max,alarms&IT87_ALARM_IN3?"ALARM":"");
3040	}
3041	} else
3042	printf("ERROR: Can't get IN3 data!\n");
3043	free_the_label(&label);
3044	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN4,&label,&valid) &&
3045	!sensors_get_feature(*name,SENSORS_IT87_IN4,&cur) &&
3046	!sensors_get_feature(*name,SENSORS_IT87_IN4_MIN,&min) &&
3047	!sensors_get_feature(*name,SENSORS_IT87_IN4_MAX,&max)) {
3048	if (valid) {
3049	print_label(label,10);
3050	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3051	cur,min,max,alarms&IT87_ALARM_IN4?"ALARM":"");
3052	}
3053	} else
3054	printf("ERROR: Can't get IN4 data!\n");
3055	free_the_label(&label);
3056	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN5,&label,&valid) &&
3057	!sensors_get_feature(*name,SENSORS_IT87_IN5,&cur) &&
3058	!sensors_get_feature(*name,SENSORS_IT87_IN5_MIN,&min) &&
3059	!sensors_get_feature(*name,SENSORS_IT87_IN5_MAX,&max)) {
3060	if (valid) {
3061	print_label(label,10);
3062	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3063	cur,min,max,alarms&IT87_ALARM_IN5?"ALARM":"");
3064	}
3065	} else
3066	printf("ERROR: Can't get IN5 data!\n");
3067	free_the_label(&label);
3068	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN6,&label,&valid) &&
3069	!sensors_get_feature(*name,SENSORS_IT87_IN6,&cur) &&
3070	!sensors_get_feature(*name,SENSORS_IT87_IN6_MIN,&min) &&
3071	!sensors_get_feature(*name,SENSORS_IT87_IN6_MAX,&max)) {
3072	if (valid) {
3073	print_label(label,10);
3074	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3075	cur,min,max,alarms&IT87_ALARM_IN6?"ALARM":"");
3076	}
3077	} else
3078	printf("ERROR: Can't get IN6 data!\n");
3079	free_the_label(&label);
3080	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN7,&label,&valid) &&
3081	!sensors_get_feature(*name,SENSORS_IT87_IN7,&cur) &&
3082	!sensors_get_feature(*name,SENSORS_IT87_IN7_MIN,&min) &&
3083	!sensors_get_feature(*name,SENSORS_IT87_IN7_MAX,&max)) {
3084	if (valid) {
3085	print_label(label,10);
3086	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3087	cur,min,max,alarms&IT87_ALARM_IN7?"ALARM":"");
3088	}
3089	} else
3090	printf("ERROR: Can't get IN7 data!\n");
3091	free_the_label(&label);
3092	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN8,&label,&valid) &&
3093	!sensors_get_feature(*name,SENSORS_IT87_IN8,&cur)) {
3094	if (valid) {
3095	print_label(label,10);
3096	printf("%+6.2f V\n", cur);
3097	}
3098	} else
3099	printf("ERROR: Can't get IN8 data!\n");
3100	free_the_label(&label);
3101
3102	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN1,&label,&valid) &&
3103	!sensors_get_feature(*name,SENSORS_IT87_FAN1,&cur) &&
3104	!sensors_get_feature(*name,SENSORS_IT87_FAN1_DIV,&fdiv) &&
3105	!sensors_get_feature(*name,SENSORS_IT87_FAN1_MIN,&min)) {
3106	if (valid) {
3107	print_label(label,10);
3108	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3109	cur,min,fdiv, alarms&IT87_ALARM_FAN1?"ALARM":"");
3110	}
3111	} else
3112	printf("ERROR: Can't get FAN1 data!\n");
3113	free_the_label(&label);
3114	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN2,&label,&valid) &&
3115	!sensors_get_feature(*name,SENSORS_IT87_FAN2,&cur) &&
3116	!sensors_get_feature(*name,SENSORS_IT87_FAN2_DIV,&fdiv) &&
3117	!sensors_get_feature(*name,SENSORS_IT87_FAN2_MIN,&min)) {
3118	if (valid) {
3119	print_label(label,10);
3120	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3121	cur,min,fdiv, alarms&IT87_ALARM_FAN2?"ALARM":"");
3122	}
3123	} else
3124	printf("ERROR: Can't get FAN2 data!\n");
3125	free_the_label(&label);
3126	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN3,&label,&valid) &&
3127	!sensors_get_feature(*name,SENSORS_IT87_FAN3,&cur) &&
3128	!sensors_get_feature(*name,SENSORS_IT87_FAN3_DIV,&fdiv) &&
3129	!sensors_get_feature(*name,SENSORS_IT87_FAN3_MIN,&min)) {
3130	if (valid) {
3131	print_label(label,10);
3132	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3133	cur,min,fdiv, alarms&IT87_ALARM_FAN3?"ALARM":"");
3134	}
3135	} else
3136	printf("ERROR: Can't get FAN3 data!\n");
3137	free_the_label(&label);
3138
3139	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP1,&label,&valid) &&
3140	!sensors_get_feature(*name,SENSORS_IT87_TEMP1,&cur) &&
3141	!sensors_get_feature(*name,SENSORS_IT87_TEMP1_LOW,&min) &&
3142	!sensors_get_feature(*name,SENSORS_IT87_SENS1,&sens) &&
3143	!sensors_get_feature(*name,SENSORS_IT87_TEMP1_HIGH,&max)) {
3144	if (valid) {
3145	print_label(label,10);
3146	print_temp_info( cur, max, min, MINMAX, 0, 0);
3147	printf(" sensor = %s ", (((int)sens)==3) ? "diode" :
3148	(((int)sens)==2) ? "thermistor" : "invalid");
3149	printf( " %s\n", alarms & IT87_ALARM_TEMP1 ? "ALARM" : "" );
3150	}
3151	} else
3152	printf("ERROR: Can't get TEMP1 data!\n");
3153	free_the_label(&label);
3154	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP2,&label,&valid) &&
3155	!sensors_get_feature(*name,SENSORS_IT87_TEMP2,&cur) &&
3156	!sensors_get_feature(*name,SENSORS_IT87_TEMP2_LOW,&min) &&
3157	!sensors_get_feature(*name,SENSORS_IT87_SENS2,&sens) &&
3158	!sensors_get_feature(*name,SENSORS_IT87_TEMP2_HIGH,&max)) {
3159	if (valid) {
3160	print_label(label,10);
3161	print_temp_info( cur, max, min, MINMAX, 0, 0);
3162	printf(" sensor = %s ", (((int)sens)==3) ? "diode" :
3163	(((int)sens)==2) ? "thermistor" : "invalid");
3164	printf( " %s\n", alarms & IT87_ALARM_TEMP2 ? "ALARM" : "" );
3165	}
3166	} else
3167	printf("ERROR: Can't get TEMP2 data!\n");
3168	free_the_label(&label);
3169	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP3,&label,&valid) &&
3170	!sensors_get_feature(*name,SENSORS_IT87_TEMP3,&cur) &&
3171	!sensors_get_feature(*name,SENSORS_IT87_TEMP3_LOW,&min) &&
3172	!sensors_get_feature(*name,SENSORS_IT87_SENS3,&sens) &&
3173	!sensors_get_feature(*name,SENSORS_IT87_TEMP3_HIGH,&max)) {
3174	if (valid) {
3175	print_label(label,10);
3176	print_temp_info( cur, max, min, MINMAX, 0, 0);
3177	printf(" sensor = %s ", (((int)sens)==3) ? "diode" :
3178	(((int)sens)==2) ? "thermistor" : "invalid");
3179	printf( " %s\n", alarms & IT87_ALARM_TEMP3 ? "ALARM" : "" );
3180	}
3181	} else
3182	printf("ERROR: Can't get TEMP3 data!\n");
3183	free_the_label(&label);
3184
3185	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_VID,&label,&valid) &&
3186	!sensors_get_feature(*name,SENSORS_IT87_VID,&cur)) {
3187	if (valid) {
3188	print_label(label,10);
3189	printf("%+6.2f V\n",cur);
3190	}
3191	}
3192	free_the_label(&label);
3193	}
3194
3195	void print_fscpos(const sensors_chip_name *name)
3196	{
3197	char *label = NULL;
3198	double voltage, temp, state, fan;
3199	int valid;
3200
3201	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP1,&label,&valid) &&
3202	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP1,&temp) &&
3203	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP1_STATE,&state)) {
3204	if (valid) {
3205	print_label(label,10);
3206	if((int) state & 0x01)
3207	printf("\t%+6.2f C \n",temp);
3208	else
3209	printf("\tfailed\n");
3210	}
3211	} else
3212	printf("ERROR: Can't get TEMP1 data!\n");
3213	free_the_label(&label);
3214
3215	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP2,&label,&valid) &&
3216	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP2,&temp) &&
3217	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP2_STATE,&state)) {
3218	if (valid) {
3219	print_label(label,10);
3220	if((int) state & 0x01)
3221	printf("\t%+6.2f C \n",temp);
3222	else
3223	printf("\tfailed\n");
3224	}
3225	} else
3226	printf("ERROR: Can't get TEMP2 data!\n");
3227	free_the_label(&label);
3228
3229	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP3,&label,&valid) &&
3230	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP3,&temp) &&
3231	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP3_STATE,&state)) {
3232	if (valid) {
3233	print_label(label,10);
3234	if((int) state & 0x01)
3235	printf("\t%+6.2f C \n",temp);
3236	else
3237	printf("\tfailed\n");
3238	}
3239	} else
3240	printf("ERROR: Can't get TEMP3 data!\n");
3241	free_the_label(&label);
3242
3243	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN1,&label,&valid) &&
3244	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN1,&fan) &&
3245	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN1_STATE,&state)) {
3246	if (valid) {
3247	print_label(label,10);
3248	if((int) state & 0x04)
3249	printf("\tfaulty\n");
3250	else
3251	printf("\t%6.0f RPM \n",fan);
3252	}
3253	} else
3254	printf("ERROR: Can't get FAN1 data!\n");
3255	free_the_label(&label);
3256
3257	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN2,&label,&valid) &&
3258	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN2,&fan) &&
3259	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN2_STATE,&state)) {
3260	if (valid) {
3261	print_label(label,10);
3262	if((int) state & 0x04)
3263	printf("\tfaulty\n");
3264	else
3265	printf("\t%6.0f RPM \n",fan);
3266	}
3267	} else
3268	printf("ERROR: Can't get FAN2 data!\n");
3269	free_the_label(&label);
3270
3271	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN3,&label,&valid) &&
3272	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN3,&fan) &&
3273	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN3_STATE,&state)) {
3274	if (valid) {
3275	print_label(label,10);
3276	if((int) state & 0x04)
3277	printf("\tfaulty\n");
3278	else
3279	printf("\t%6.0f RPM \n",fan);
3280	}
3281	} else
3282	printf("ERROR: Can't get FAN3 data!\n");
3283	free_the_label(&label);
3284
3285	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE1,&label,&valid) &&
3286	!sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE1,&voltage)) {
3287	if (valid) {
3288	print_label(label,10);
3289	printf("\t%+6.2f V\n",voltage);
3290	}
3291	} else
3292	printf("ERROR: Can't get IN0 data!\n");
3293	free_the_label(&label);
3294
3295	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE2,&label,&valid) &&
3296	!sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE2,&voltage)) {
3297	if (valid) {
3298	print_label(label,10);
3299	printf("\t%+6.2f V\n",voltage);
3300	}
3301	} else
3302	printf("ERROR: Can't get IN1 data!\n");
3303	free_the_label(&label);
3304
3305	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE3,&label,&valid) &&
3306	!sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE3,&voltage)) {
3307	if (valid) {
3308	print_label(label,10);
3309	printf("\t%+6.2f V\n",voltage);
3310	}
3311	} else
3312	printf("ERROR: Can't get IN2 data!\n");
3313	free_the_label(&label);
3314	}
3315
3316	void print_fscscy(const sensors_chip_name *name)
3317	{
3318	char *label = NULL;
3319	double voltage, temp, tempmin, tempmax, templim, state, fan;
3320	int valid;
3321
3322	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP1,&label,&valid) &&
3323	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1,&temp) &&
3324	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_LIM,&templim) &&
3325	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_MIN,&tempmin) &&
3326	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_MAX,&tempmax) &&
3327	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_STATE,&state)) {
3328	if (valid) {
3329	print_label(label,10);
3330	if((int) state & 0x01)
3331	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3332	temp,tempmin,tempmax,templim);
3333	else
3334	printf("\tfailed\n");
3335	}
3336	} else
3337	printf("ERROR: Can't get TEMP1 data!\n");
3338	free_the_label(&label);
3339
3340	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP2,&label,&valid) &&
3341	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2,&temp) &&
3342	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_LIM,&templim) &&
3343	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_MIN,&tempmin) &&
3344	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_MAX,&tempmax) &&
3345	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_STATE,&state)) {
3346	if (valid) {
3347	print_label(label,10);
3348	if((int) state & 0x01)
3349	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3350	temp,tempmin,tempmax,templim);
3351	else
3352	printf("\tfailed\n");
3353	}
3354	} else
3355	printf("ERROR: Can't get TEMP2 data!\n");
3356	free_the_label(&label);
3357
3358	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP3,&label,&valid) &&
3359	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3,&temp) &&
3360	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_LIM,&templim) &&
3361	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_MIN,&tempmin) &&
3362	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_MAX,&tempmax) &&
3363	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_STATE,&state)) {
3364	if (valid) {
3365	print_label(label,10);
3366	if((int) state & 0x01)
3367	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3368	temp,tempmin,tempmax,templim);
3369	else
3370	printf("\tfailed\n");
3371	}
3372	} else
3373	printf("ERROR: Can't get TEMP3 data!\n");
3374	free_the_label(&label);
3375
3376	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP4,&label,&valid) &&
3377	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4,&temp) &&
3378	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_LIM,&templim) &&
3379	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_MIN,&tempmin) &&
3380	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_MAX,&tempmax) &&
3381	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_STATE,&state)) {
3382	if (valid) {
3383	print_label(label,10);
3384	if((int) state & 0x01)
3385	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3386	temp,tempmin,tempmax,templim);
3387	else
3388	printf("\tfailed\n");
3389	}
3390	} else
3391	printf("ERROR: Can't get TEMP4 data!\n");
3392	free_the_label(&label);
3393
3394	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN1,&label,&valid) &&
3395	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN1,&fan) &&
3396	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN1_STATE,&state)) {
3397	if (valid) {
3398	print_label(label,10);
3399	if((int) state & 0x02)
3400	printf("\tfaulty\n");
3401	else
3402	printf("\t%6.0f RPM \n",fan);
3403	}
3404	} else
3405	printf("ERROR: Can't get FAN1 data!\n");
3406	free_the_label(&label);
3407
3408	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN2,&label,&valid) &&
3409	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN2,&fan) &&
3410	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN2_STATE,&state)) {
3411	if (valid) {
3412	print_label(label,10);
3413	if((int) state & 0x02)
3414	printf("\tfaulty\n");
3415	else
3416	printf("\t%6.0f RPM \n",fan);
3417	}
3418	} else
3419	printf("ERROR: Can't get FAN2 data!\n");
3420	free_the_label(&label);
3421
3422	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN3,&label,&valid) &&
3423	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN3,&fan) &&
3424	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN3_STATE,&state)) {
3425	if (valid) {
3426	print_label(label,10);
3427	if((int) state & 0x02)
3428	printf("\tfaulty\n");
3429	else
3430	printf("\t%6.0f RPM \n",fan);
3431	}
3432	} else
3433	printf("ERROR: Can't get FAN3 data!\n");
3434	free_the_label(&label);
3435
3436	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN4,&label,&valid) &&
3437	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN4,&fan) &&
3438	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN4_STATE,&state)) {
3439	if (valid) {
3440	print_label(label,10);
3441	if((int) state & 0x02)
3442	printf("\tfaulty\n");
3443	else
3444	printf("\t%6.0f RPM \n",fan);
3445	}
3446	} else
3447	printf("ERROR: Can't get FAN4 data!\n");
3448	free_the_label(&label);
3449
3450	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN5,&label,&valid) &&
3451	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN5,&fan) &&
3452	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN5_STATE,&state)) {
3453	if (valid) {
3454	print_label(label,10);
3455	if((int) state & 0x02)
3456	printf("\tfaulty\n");
3457	else
3458	printf("\t%6.0f RPM \n",fan);
3459	}
3460	} else
3461	printf("ERROR: Can't get FAN5 data!\n");
3462	free_the_label(&label);
3463
3464	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN6,&label,&valid) &&
3465	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN6,&fan) &&
3466	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN6_STATE,&state)) {
3467	if (valid) {
3468	print_label(label,10);
3469	if((int) state & 0x02)
3470	printf("\tfaulty\n");
3471	else
3472	printf("\t%6.0f RPM \n",fan);
3473	}
3474	} else
3475	printf("ERROR: Can't get FAN6 data!\n");
3476	free_the_label(&label);
3477
3478	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE1,&label,&valid) &&
3479	!sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE1,&voltage)) {
3480	if (valid) {
3481	print_label(label,10);
3482	printf("\t%+6.2f V\n",voltage);
3483	}
3484	} else
3485	printf("ERROR: Can't get IN0 data!\n");
3486	free_the_label(&label);
3487
3488	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE2,&label,&valid) &&
3489	!sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE2,&voltage)) {
3490	if (valid) {
3491	print_label(label,10);
3492	printf("\t%+6.2f V\n",voltage);
3493	}
3494	} else
3495	printf("ERROR: Can't get IN1 data!\n");
3496	free_the_label(&label);
3497
3498	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE3,&label,&valid) &&
3499	!sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE3,&voltage)) {
3500	if (valid) {
3501	print_label(label,10);
3502	printf("\t%+6.2f V\n",voltage);
3503	}
3504	} else
3505	printf("ERROR: Can't get IN2 data!\n");
3506	free_the_label(&label);
3507	}
3508
3509	void print_fscher(const sensors_chip_name *name)
3510	{
3511	char *label = NULL;
3512	double voltage, temp, state, fan;
3513	int valid;
3514
3515	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP1,&label,&valid)
3516	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP1,&temp)
3517	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP1_STATE,&state)) {
3518	if (valid) {
3519	print_label(label,10);
3520	if((int) state & 0x01)
3521	printf("\t%+6.2f C \n",temp);
3522	else
3523	printf("\tfailed\n");
3524	}
3525	} else
3526	printf("ERROR: Can't get TEMP1 data!\n");
3527	free_the_label(&label);
3528
3529	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP2,&label,&valid)
3530	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP2,&temp)
3531	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP2_STATE,&state)) {
3532	if (valid) {
3533	print_label(label,10);
3534	if((int) state & 0x01)
3535	printf("\t%+6.2f C \n",temp);
3536	else
3537	printf("\tfailed\n");
3538	}
3539	} else
3540	printf("ERROR: Can't get TEMP2 data!\n");
3541	free_the_label(&label);
3542
3543	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP3,&label,&valid)
3544	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP3,&temp)
3545	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP3_STATE,&state)) {
3546	if (valid) {
3547	print_label(label,10);
3548	if((int) state & 0x01)
3549	printf("\t%+6.2f C \n",temp);
3550	else
3551	printf("\tfailed\n");
3552	}
3553	} else
3554	printf("ERROR: Can't get TEMP3 data!\n");
3555	free_the_label(&label);
3556
3557	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN1,&label,&valid)
3558	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN1,&fan)
3559	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN1_STATE,&state)) {
3560	if (valid) {
3561	print_label(label,10);
3562	if((int) state & 0x04)
3563	printf("\tfaulty\n");
3564	else
3565	printf("\t%6.0f RPM \n",fan);
3566	}
3567	} else
3568	printf("ERROR: Can't get FAN1 data!\n");
3569	free_the_label(&label);
3570
3571	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN2,&label,&valid)
3572	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN2,&fan)
3573	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN2_STATE,&state)) {
3574	if (valid) {
3575	print_label(label,10);
3576	if((int) state & 0x04)
3577	printf("\tfaulty\n");
3578	else
3579	printf("\t%6.0f RPM \n",fan);
3580	}
3581	} else
3582	printf("ERROR: Can't get FAN2 data!\n");
3583	free_the_label(&label);
3584
3585	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN3,&label,&valid)
3586	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN3,&fan)
3587	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN3_STATE,&state)) {
3588	if (valid) {
3589	print_label(label,10);
3590	if((int) state & 0x04)
3591	printf("\tfaulty\n");
3592	else
3593	printf("\t%6.0f RPM \n",fan);
3594	}
3595	} else
3596	printf("ERROR: Can't get FAN3 data!\n");
3597	free_the_label(&label);
3598
3599	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE1,&label,&valid)
3600	&& !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE1,&voltage)) {
3601	if (valid) {
3602	print_label(label,10);
3603	printf("\t%+6.2f V\n",voltage);
3604	}
3605	} else
3606	printf("ERROR: Can't get IN0 data!\n");
3607	free_the_label(&label);
3608
3609	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE2,&label,&valid)
3610	&& !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE2,&voltage)) {
3611	if (valid) {
3612	print_label(label,10);
3613	printf("\t%+6.2f V\n",voltage);
3614	}
3615	} else
3616	printf("ERROR: Can't get IN1 data!\n");
3617	free_the_label(&label);
3618
3619	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE3,&label,&valid)
3620	&& !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE3,&voltage)) {
3621	if (valid) {
3622	print_label(label,10);
3623	printf("\t%+6.2f V\n",voltage);
3624	}
3625	} else
3626	printf("ERROR: Can't get IN2 data!\n");
3627	free_the_label(&label);
3628	}
3629
3630	void print_pcf8591(const sensors_chip_name *name)
3631	{
3632	char *label;
3633	double ain_conf, ch0, ch1, ch2, ch3;
3634	double aout_enable, aout;
3635	int valid;
3636
3637	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_AIN_CONF,&label,&valid) &&
3638	!sensors_get_feature(*name,SENSORS_PCF8591_AIN_CONF,&ain_conf)) {
3639	if (valid) {
3640	print_label(label,10);
3641	switch ((int)ain_conf)
3642	{
3643	case 0: printf("four single ended inputs\n");
3644	break;
3645	case 1: printf("three differential inputs\n");
3646	break;
3647	case 2: printf("single ended and differential mixed\n");
3648	break;
3649	case 3: printf("two differential inputs\n");
3650	break;
3651	}
3652	}
3653	}
3654	else printf("ERROR: Can't read analog inputs configuration!\n");
3655	free_the_label(&label);
3656
3657	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH0,&label,&valid) &&
3658	!sensors_get_feature(*name,SENSORS_PCF8591_CH0,&ch0)) {
3659	if (valid) {
3660	print_label(label,10);
3661	printf("%0.0f\n", ch0);
3662	}
3663	}
3664	else printf("ERROR: Can't read ch0!\n");
3665	free_the_label(&label);
3666
3667	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH1,&label,&valid) &&
3668	!sensors_get_feature(*name,SENSORS_PCF8591_CH1,&ch1)) {
3669	if (valid) {
3670	print_label(label,10);
3671	printf("%0.0f\n", ch1);
3672	}
3673	}
3674	else printf("ERROR: Can't read ch1!\n");
3675	free_the_label(&label);
3676
3677	if (ain_conf != 3) {
3678	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH2,&label,&valid) &&
3679	!sensors_get_feature(*name,SENSORS_PCF8591_CH2,&ch2)) {
3680	if (valid) {
3681	print_label(label,10);
3682	printf("%0.0f\n", ch2);
3683	}
3684	}
3685	else printf("ERROR: Can't read ch2!\n");
3686	free_the_label(&label);
3687	}
3688
3689	if (ain_conf == 0) {
3690	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH3,&label,&valid) &&
3691	!sensors_get_feature(*name,SENSORS_PCF8591_CH3,&ch3)) {
3692	if (valid) {
3693	print_label(label,10);
3694	printf("%0.0f\n", ch3);
3695	}
3696	}
3697	else printf("ERROR: Can't read ch3!\n");
3698	free_the_label(&label);
3699	}
3700
3701	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_AOUT,&label,&valid) &&
3702	!sensors_get_feature(*name,SENSORS_PCF8591_AOUT,&aout) &&
3703	!sensors_get_feature(*name,SENSORS_PCF8591_AOUT_ENABLE,&aout_enable)) {
3704	if (valid) {
3705	print_label(label,10);
3706	printf("%0.0f (%s)\n", aout, aout_enable?"enabled":"disabled");
3707	}
3708	}
3709	else printf("ERROR: Can't read aout!\n");
3710	free_the_label(&label);
3711
3712	}
3713
3714	void print_vt1211(const sensors_chip_name *name)
3715	{
3716	char *label = NULL;
3717	double cur,min,max,fdiv;
3718	int alarms,valid;
3719
3720	if (!sensors_get_feature(*name,SENSORS_VT1211_ALARMS,&cur))
3721	alarms = cur + 0.5;
3722	else {
3723	printf("ERROR: Can't get alarm data!\n");
3724	alarms = 0;
3725	}
3726
3727	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN0,&label,&valid) &&
3728	!sensors_get_feature(*name,SENSORS_VT1211_IN0,&cur) &&
3729	!sensors_get_feature(*name,SENSORS_VT1211_IN0_MIN,&min) &&
3730	!sensors_get_feature(*name,SENSORS_VT1211_IN0_MAX,&max)) {
3731	if (valid) {
3732	print_label(label,10);
3733	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3734	cur,min,max,alarms&VT1211_ALARM_IN0?"ALARM":"");
3735	}
3736	} else
3737	printf("ERROR: Can't get IN0 data!\n");
3738	free_the_label(&label);
3739	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN1,&label,&valid) &&
3740	!sensors_get_feature(*name,SENSORS_VT1211_IN1,&cur) &&
3741	!sensors_get_feature(*name,SENSORS_VT1211_IN1_MIN,&min) &&
3742	!sensors_get_feature(*name,SENSORS_VT1211_IN1_MAX,&max)) {
3743	if (valid) {
3744	print_label(label,10);
3745	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3746	cur,min,max,alarms&VT1211_ALARM_IN1?"ALARM":"");
3747	}
3748	} else
3749	printf("ERROR: Can't get IN1 data!\n");
3750	free_the_label(&label);
3751	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN2,&label,&valid) &&
3752	!sensors_get_feature(*name,SENSORS_VT1211_IN2,&cur) &&
3753	!sensors_get_feature(*name,SENSORS_VT1211_IN2_MIN,&min) &&
3754	!sensors_get_feature(*name,SENSORS_VT1211_IN2_MAX,&max)) {
3755	if (valid) {
3756	print_label(label,10);
3757	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3758	cur,min,max,alarms&VT1211_ALARM_IN2?"ALARM":"");
3759	}
3760	} else
3761	printf("ERROR: Can't get IN2 data!\n");
3762	free_the_label(&label);
3763	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN3,&label,&valid) &&
3764	!sensors_get_feature(*name,SENSORS_VT1211_IN3,&cur) &&
3765	!sensors_get_feature(*name,SENSORS_VT1211_IN3_MIN,&min) &&
3766	!sensors_get_feature(*name,SENSORS_VT1211_IN3_MAX,&max)) {
3767	if (valid) {
3768	print_label(label,10);
3769	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3770	cur,min,max,alarms&VT1211_ALARM_IN3?"ALARM":"");
3771	}
3772	} else
3773	printf("ERROR: Can't get IN3 data!\n");
3774	free_the_label(&label);
3775	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN4,&label,&valid) &&
3776	!sensors_get_feature(*name,SENSORS_VT1211_IN4,&cur) &&
3777	!sensors_get_feature(*name,SENSORS_VT1211_IN4_MIN,&min) &&
3778	!sensors_get_feature(*name,SENSORS_VT1211_IN4_MAX,&max)) {
3779	if (valid) {
3780	print_label(label,10);
3781	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3782	cur,min,max,alarms&VT1211_ALARM_IN4?"ALARM":"");
3783	}
3784	} else
3785	printf("ERROR: Can't get IN4 data!\n");
3786	free_the_label(&label);
3787	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN5,&label,&valid) &&
3788	!sensors_get_feature(*name,SENSORS_VT1211_IN5,&cur) &&
3789	!sensors_get_feature(*name,SENSORS_VT1211_IN5_MIN,&min) &&
3790	!sensors_get_feature(*name,SENSORS_VT1211_IN5_MAX,&max)) {
3791	if (valid) {
3792	print_label(label,10);
3793	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3794	cur,min,max,alarms&VT1211_ALARM_IN5?"ALARM":"");
3795	}
3796	} else
3797	printf("ERROR: Can't get IN5 data!\n");
3798	free_the_label(&label);
3799	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN6,&label,&valid) &&
3800	!sensors_get_feature(*name,SENSORS_VT1211_IN6,&cur) &&
3801	!sensors_get_feature(*name,SENSORS_VT1211_IN6_MIN,&min) &&
3802	!sensors_get_feature(*name,SENSORS_VT1211_IN6_MAX,&max)) {
3803	if (valid) {
3804	print_label(label,10);
3805	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3806	cur,min,max,alarms&VT1211_ALARM_IN6?"ALARM":"");
3807	}
3808	} else
3809	printf("ERROR: Can't get IN6 data!\n");
3810	free_the_label(&label);
3811
3812	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_FAN1,&label,&valid) &&
3813	!sensors_get_feature(*name,SENSORS_VT1211_FAN1,&cur) &&
3814	!sensors_get_feature(*name,SENSORS_VT1211_FAN1_DIV,&fdiv) &&
3815	!sensors_get_feature(*name,SENSORS_VT1211_FAN1_MIN,&min)) {
3816	if (valid) {
3817	print_label(label,10);
3818	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3819	cur,min,fdiv, alarms&VT1211_ALARM_FAN1?"ALARM":"");
3820	}
3821	} else
3822	printf("ERROR: Can't get FAN1 data!\n");
3823	free_the_label(&label);
3824	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_FAN2,&label,&valid) &&
3825	!sensors_get_feature(*name,SENSORS_VT1211_FAN2,&cur) &&
3826	!sensors_get_feature(*name,SENSORS_VT1211_FAN2_DIV,&fdiv) &&
3827	!sensors_get_feature(*name,SENSORS_VT1211_FAN2_MIN,&min)) {
3828	if (valid) {
3829	print_label(label,10);
3830	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3831	cur,min,fdiv, alarms&VT1211_ALARM_FAN2?"ALARM":"");
3832	}
3833	} else
3834	printf("ERROR: Can't get FAN2 data!\n");
3835	free_the_label(&label);
3836
3837	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP,&label,&valid) &&
3838	!sensors_get_feature(*name,SENSORS_VT1211_TEMP,&cur) &&
3839	!sensors_get_feature(*name,SENSORS_VT1211_TEMP_HYST,&min) &&
3840	!sensors_get_feature(*name,SENSORS_VT1211_TEMP_OVER,&max)) {
3841	if (valid) {
3842	print_label(label,10);
3843	print_temp_info( cur, max, min, HYST, 1, 0);
3844	printf(" %s\n", alarms & VT1211_ALARM_TEMP ? "ALARM" : "" );
3845	}
3846	} else
3847	printf("ERROR: Can't get TEMP data!\n");
3848	free_the_label(&label);
3849	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP2,&label,&valid) &&
3850	!sensors_get_feature(*name,SENSORS_VT1211_TEMP2,&cur) &&
3851	!sensors_get_feature(*name,SENSORS_VT1211_TEMP2_HYST,&min) &&
3852	!sensors_get_feature(*name,SENSORS_VT1211_TEMP2_OVER,&max)) {
3853	if (valid) {
3854	print_label(label,10);
3855	print_temp_info( cur, max, min, HYST, 1, 0);
3856	printf(" %s\n", alarms & VT1211_ALARM_TEMP2 ? "ALARM" : "" );
3857	}
3858	} else
3859	printf("ERROR: Can't get TEMP2 data!\n");
3860	free_the_label(&label);
3861	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP3,&label,&valid) &&
3862	!sensors_get_feature(*name,SENSORS_VT1211_TEMP3,&cur) &&
3863	!sensors_get_feature(*name,SENSORS_VT1211_TEMP3_HYST,&min) &&
3864	!sensors_get_feature(*name,SENSORS_VT1211_TEMP3_OVER,&max)) {
3865	if (valid) {
3866	print_label(label,10);
3867	print_temp_info( cur, max, min, HYST, 1, 0);
3868	printf(" %s\n", alarms & VT1211_ALARM_TEMP3 ? "ALARM" : "" );
3869	}
3870	} else
3871	printf("ERROR: Can't get TEMP3 data!\n");
3872	free_the_label(&label);
3873	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP4,&label,&valid) &&
3874	!sensors_get_feature(*name,SENSORS_VT1211_TEMP4,&cur) &&
3875	!sensors_get_feature(*name,SENSORS_VT1211_TEMP4_HYST,&min) &&
3876	!sensors_get_feature(*name,SENSORS_VT1211_TEMP4_OVER,&max)) {
3877	if (valid) {
3878	print_label(label,10);
3879	print_temp_info( cur, max, min, HYST, 1, 0);
3880	printf(" %s\n", alarms & VT1211_ALARM_TEMP4 ? "ALARM" : "" );
3881	}
3882	} else
3883	printf("ERROR: Can't get TEMP4 data!\n");
3884	free_the_label(&label);
3885	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP5,&label,&valid) &&
3886	!sensors_get_feature(*name,SENSORS_VT1211_TEMP5,&cur) &&
3887	!sensors_get_feature(*name,SENSORS_VT1211_TEMP5_HYST,&min) &&
3888	!sensors_get_feature(*name,SENSORS_VT1211_TEMP5_OVER,&max)) {
3889	if (valid) {
3890	print_label(label,10);
3891	print_temp_info( cur, max, min, HYST, 1, 0);
3892	printf(" %s\n", alarms & VT1211_ALARM_TEMP5 ? "ALARM" : "" );
3893	}
3894	} else
3895	printf("ERROR: Can't get TEMP5 data!\n");
3896	free_the_label(&label);
3897	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP6,&label,&valid) &&
3898	!sensors_get_feature(*name,SENSORS_VT1211_TEMP6,&cur) &&
3899	!sensors_get_feature(*name,SENSORS_VT1211_TEMP6_HYST,&min) &&
3900	!sensors_get_feature(*name,SENSORS_VT1211_TEMP6_OVER,&max)) {
3901	if (valid) {
3902	print_label(label,10);
3903	print_temp_info( cur, max, min, HYST, 1, 0);
3904	printf(" %s\n", alarms & VT1211_ALARM_TEMP6 ? "ALARM" : "" );
3905	}
3906	} else
3907	printf("ERROR: Can't get TEMP6 data!\n");
3908	free_the_label(&label);
3909	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP7,&label,&valid) &&
3910	!sensors_get_feature(*name,SENSORS_VT1211_TEMP7,&cur) &&
3911	!sensors_get_feature(*name,SENSORS_VT1211_TEMP7_HYST,&min) &&
3912	!sensors_get_feature(*name,SENSORS_VT1211_TEMP7_OVER,&max)) {
3913	if (valid) {
3914	print_label(label,10);
3915	print_temp_info( cur, max, min, HYST, 1, 0);
3916	printf(" %s\n", alarms & VT1211_ALARM_TEMP7 ? "ALARM" : "" );
3917	}
3918	} else
3919	printf("ERROR: Can't get TEMP7 data!\n");
3920	free_the_label(&label);
3921
3922	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_VID,&label,&valid) &&
3923	!sensors_get_feature(*name,SENSORS_VT1211_VID,&cur)) {
3924	if (valid) {
3925	print_label(label,10);
3926	printf("%+6.2f V\n",cur);
3927	}
3928	}
3929	free_the_label(&label);
3930
3931	}
3932
3933	void print_smsc47m1(const sensors_chip_name *name)
3934	{
3935	char *label = NULL;
3936	double cur,min,fdiv;
3937	int alarms,valid;
3938
3939	if (!sensors_get_feature(*name,SENSORS_SMSC47M1_ALARMS,&cur))
3940	alarms = cur + 0.5;
3941	else {
3942	printf("ERROR: Can't get alarm data!\n");
3943	alarms = 0;
3944	}
3945
3946	if (!sensors_get_label_and_valid(*name,SENSORS_SMSC47M1_FAN1,&label,&valid) &&
3947	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN1,&cur) &&
3948	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN1_DIV,&fdiv) &&
3949	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN1_MIN,&min)) {
3950	if (valid) {
3951	print_label(label,10);
3952	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3953	cur,min,fdiv, alarms&SMSC47M1_ALARM_FAN1?"ALARM":"");
3954	}
3955	} else
3956	printf("ERROR: Can't get FAN1 data!\n");
3957	free_the_label(&label);
3958
3959	if (!sensors_get_label_and_valid(*name,SENSORS_SMSC47M1_FAN2,&label,&valid) &&
3960	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN2,&cur) &&
3961	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN2_DIV,&fdiv) &&
3962	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN2_MIN,&min)) {
3963	if (valid) {
3964	print_label(label,10);
3965	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3966	cur,min,fdiv, alarms&SMSC47M1_ALARM_FAN2?"ALARM":"");
3967	}
3968	} else
3969	printf("ERROR: Can't get FAN2 data!\n");
3970	free_the_label(&label);
3971
3972	}
3973
3974	static void lm92_print_temp (float n_cur,float n_high,float n_low,float n_crit,float n_hyst)
3975	{
3976	if (fahrenheit) {
3977	n_cur = deg_ctof (n_cur);
3978	n_high = deg_ctof (n_high);
3979	n_low = deg_ctof (n_low);
3980	n_crit = deg_ctof (n_crit);
3981	n_hyst = deg_ctof (n_hyst);
3982	}
3983
3984	printf ("%+6.4f%s (high = %+6.4f%s, low = %+6.4f%s, crit = %+6.4f%s, hyst = %+6.4f%s)",
3985	n_cur, degstr,
3986	n_high, degstr,
3987	n_low, degstr,
3988	n_crit, degstr,
3989	n_hyst, degstr);
3990	}
3991
3992	void print_lm92 (const sensors_chip_name *name)
3993	{
3994	char *label = NULL;
3995	double temp[5];
3996	int valid,alarms;
3997
3998	if (!sensors_get_feature (*name,SENSORS_LM92_ALARMS,temp)) {
3999	alarms = *temp + 0.5;
4000	} else {
4001	printf ("ERROR: Can't get alarm data!\n");
4002	return;
4003	}
4004
4005	if (!sensors_get_label_and_valid (*name,SENSORS_LM92_TEMP,&label,&valid) &&
4006	!sensors_get_feature (*name,SENSORS_LM92_TEMP,temp) &&
4007	!sensors_get_feature (*name,SENSORS_LM92_TEMP_HIGH,temp + 1) &&
4008	!sensors_get_feature (*name,SENSORS_LM92_TEMP_LOW,temp + 2) &&
4009	!sensors_get_feature (*name,SENSORS_LM92_TEMP_CRIT,temp + 3) &&
4010	!sensors_get_feature (*name,SENSORS_LM92_TEMP_HYST,temp + 4)) {
4011	if (valid) {
4012	print_label (label,10);
4013	lm92_print_temp (temp[0],temp[1],temp[2],temp[3],temp[4]);
4014	if (alarms) {
4015	printf (" ALARMS (");
4016
4017	if ((alarms & LM92_ALARM_TEMP_HIGH))
4018	printf ("HIGH");
4019
4020	if (alarms & LM92_ALARM_TEMP_LOW)
4021	printf ("%sLOW",(alarms & LM92_ALARM_TEMP_HIGH) ? "," : "");
4022
4023	if (alarms & LM92_ALARM_TEMP_CRIT)
4024	printf ("%sCRIT",(alarms & (LM92_ALARM_TEMP_HIGH \| LM92_ALARM_TEMP_LOW)) ? "," : "");
4025
4026	printf (")");
4027	}
4028	printf ("\n");
4029	}
4030	} else printf ("ERROR: Can't get temperature data!\n");
4031
4032	free_the_label (&label);
4033	}
4034
4035	void print_vt8231(const sensors_chip_name *name)
4036	{
4037	char *label = NULL;
4038	double cur,min,max,fdiv;
4039	int alarms,valid;
4040
4041	if (!sensors_get_feature(*name,SENSORS_VT8231_ALARMS,&cur))
4042	alarms = cur + 0.5;
4043	else {
4044	printf("ERROR: Can't get alarm data!\n");
4045	alarms = 0;
4046	}
4047
4048	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN0,&label,&valid) &&
4049	!sensors_get_feature(*name,SENSORS_VT8231_IN0,&cur) &&
4050	!sensors_get_feature(*name,SENSORS_VT8231_IN0_MIN,&min) &&
4051	!sensors_get_feature(*name,SENSORS_VT8231_IN0_MAX,&max)) {
4052	if (valid) {
4053	print_label(label,10);
4054	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4055	cur,min,max,alarms&VT8231_ALARM_IN0?"ALARM":"");
4056	}
4057	} else
4058	printf("ERROR: Can't get IN0 data!\n");
4059	free_the_label(&label);
4060	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN1,&label,&valid) &&
4061	!sensors_get_feature(*name,SENSORS_VT8231_IN1,&cur) &&
4062	!sensors_get_feature(*name,SENSORS_VT8231_IN1_MIN,&min) &&
4063	!sensors_get_feature(*name,SENSORS_VT8231_IN1_MAX,&max)) {
4064	if (valid) {
4065	print_label(label,10);
4066	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4067	cur,min,max,alarms&VT8231_ALARM_IN1?"ALARM":"");
4068	}
4069	} else
4070	printf("ERROR: Can't get IN1 data!\n");
4071	free_the_label(&label);
4072	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN2,&label,&valid) &&
4073	!sensors_get_feature(*name,SENSORS_VT8231_IN2,&cur) &&
4074	!sensors_get_feature(*name,SENSORS_VT8231_IN2_MIN,&min) &&
4075	!sensors_get_feature(*name,SENSORS_VT8231_IN2_MAX,&max)) {
4076	if (valid) {
4077	print_label(label,10);
4078	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4079	cur,min,max,alarms&VT8231_ALARM_IN2?"ALARM":"");
4080	}
4081	} else
4082	printf("ERROR: Can't get IN2 data!\n");
4083	free_the_label(&label);
4084	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN3,&label,&valid) &&
4085	!sensors_get_feature(*name,SENSORS_VT8231_IN3,&cur) &&
4086	!sensors_get_feature(*name,SENSORS_VT8231_IN3_MIN,&min) &&
4087	!sensors_get_feature(*name,SENSORS_VT8231_IN3_MAX,&max)) {
4088	if (valid) {
4089	print_label(label,10);
4090	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4091	cur,min,max,alarms&VT8231_ALARM_IN3?"ALARM":"");
4092	}
4093	} else
4094	printf("ERROR: Can't get IN3 data!\n");
4095	free_the_label(&label);
4096	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN4,&label,&valid) &&
4097	!sensors_get_feature(*name,SENSORS_VT8231_IN4,&cur) &&
4098	!sensors_get_feature(*name,SENSORS_VT8231_IN4_MIN,&min) &&
4099	!sensors_get_feature(*name,SENSORS_VT8231_IN4_MAX,&max)) {
4100	if (valid) {
4101	print_label(label,10);
4102	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4103	cur,min,max,alarms&VT8231_ALARM_IN4?"ALARM":"");
4104	}
4105	} else
4106	printf("ERROR: Can't get IN4 data!\n");
4107	free_the_label(&label);
4108	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN5,&label,&valid) &&
4109	!sensors_get_feature(*name,SENSORS_VT8231_IN5,&cur) &&
4110	!sensors_get_feature(*name,SENSORS_VT8231_IN5_MIN,&min) &&
4111	!sensors_get_feature(*name,SENSORS_VT8231_IN5_MAX,&max)) {
4112	if (valid) {
4113	print_label(label,10);
4114	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4115	cur,min,max,alarms&VT8231_ALARM_IN5?"ALARM":"");
4116	}
4117	} else
4118	printf("ERROR: Can't get IN5 data!\n");
4119	free_the_label(&label);
4120	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN6,&label,&valid) &&
4121	!sensors_get_feature(*name,SENSORS_VT8231_IN6,&cur) &&
4122	!sensors_get_feature(*name,SENSORS_VT8231_IN6_MIN,&min) &&
4123	!sensors_get_feature(*name,SENSORS_VT8231_IN6_MAX,&max)) {
4124	if (valid) {
4125	print_label(label,10);
4126	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4127	cur,min,max,alarms&VT8231_ALARM_IN6?"ALARM":"");
4128	}
4129	} else
4130	printf("ERROR: Can't get IN6 data!\n");
4131	free_the_label(&label);
4132
4133	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_FAN1,&label,&valid) &&
4134	!sensors_get_feature(*name,SENSORS_VT8231_FAN1,&cur) &&
4135	!sensors_get_feature(*name,SENSORS_VT8231_FAN1_DIV,&fdiv) &&
4136	!sensors_get_feature(*name,SENSORS_VT8231_FAN1_MIN,&min)) {
4137	if (valid) {
4138	print_label(label,10);
4139	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4140	cur,min,fdiv, alarms&VT8231_ALARM_FAN1?"ALARM":"");
4141	}
4142	} else
4143	printf("ERROR: Can't get FAN1 data!\n");
4144	free_the_label(&label);
4145	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_FAN2,&label,&valid) &&
4146	!sensors_get_feature(*name,SENSORS_VT8231_FAN2,&cur) &&
4147	!sensors_get_feature(*name,SENSORS_VT8231_FAN2_DIV,&fdiv) &&
4148	!sensors_get_feature(*name,SENSORS_VT8231_FAN2_MIN,&min)) {
4149	if (valid) {
4150	print_label(label,10);
4151	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4152	cur,min,fdiv, alarms&VT8231_ALARM_FAN2?"ALARM":"");
4153	}
4154	} else
4155	printf("ERROR: Can't get FAN2 data!\n");
4156	free_the_label(&label);
4157
4158	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP,&label,&valid) &&
4159	!sensors_get_feature(*name,SENSORS_VT8231_TEMP,&cur) &&
4160	!sensors_get_feature(*name,SENSORS_VT8231_TEMP_HYST,&min) &&
4161	!sensors_get_feature(*name,SENSORS_VT8231_TEMP_OVER,&max)) {
4162	if (valid) {
4163	print_label(label,10);
4164	print_temp_info( cur, max, min, HYST, 1, 0);
4165	printf(" %s\n", alarms & VT8231_ALARM_TEMP ? "ALARM" : "" );
4166	}
4167	} else
4168	printf("ERROR: Can't get TEMP data!\n");
4169	free_the_label(&label);
4170	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP2,&label,&valid) &&
4171	!sensors_get_feature(*name,SENSORS_VT8231_TEMP2,&cur) &&
4172	!sensors_get_feature(*name,SENSORS_VT8231_TEMP2_HYST,&min) &&
4173	!sensors_get_feature(*name,SENSORS_VT8231_TEMP2_OVER,&max)) {
4174	if (valid) {
4175	print_label(label,10);
4176	print_temp_info( cur, max, min, HYST, 1, 0);
4177	printf(" %s\n", alarms & VT8231_ALARM_TEMP2 ? "ALARM" : "" );
4178	}
4179	} else
4180	printf("ERROR: Can't get TEMP2 data!\n");
4181	free_the_label(&label);
4182	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP3,&label,&valid) &&
4183	!sensors_get_feature(*name,SENSORS_VT8231_TEMP3,&cur) &&
4184	!sensors_get_feature(*name,SENSORS_VT8231_TEMP3_HYST,&min) &&
4185	!sensors_get_feature(*name,SENSORS_VT8231_TEMP3_OVER,&max)) {
4186	if (valid) {
4187	print_label(label,10);
4188	print_temp_info( cur, max, min, HYST, 1, 0);
4189	printf(" %s\n", alarms & VT8231_ALARM_TEMP3 ? "ALARM" : "" );
4190	}
4191	} else
4192	printf("ERROR: Can't get TEMP3 data!\n");
4193	free_the_label(&label);
4194	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP4,&label,&valid) &&
4195	!sensors_get_feature(*name,SENSORS_VT8231_TEMP4,&cur) &&
4196	!sensors_get_feature(*name,SENSORS_VT8231_TEMP4_HYST,&min) &&
4197	!sensors_get_feature(*name,SENSORS_VT8231_TEMP4_OVER,&max)) {
4198	if (valid) {
4199	print_label(label,10);
4200	print_temp_info( cur, max, min, HYST, 1, 0);
4201	printf(" %s\n", alarms & VT8231_ALARM_TEMP4 ? "ALARM" : "" );
4202	}
4203	} else
4204	printf("ERROR: Can't get TEMP4 data!\n");
4205	free_the_label(&label);
4206	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP5,&label,&valid) &&
4207	!sensors_get_feature(*name,SENSORS_VT8231_TEMP5,&cur) &&
4208	!sensors_get_feature(*name,SENSORS_VT8231_TEMP5_HYST,&min) &&
4209	!sensors_get_feature(*name,SENSORS_VT8231_TEMP5_OVER,&max)) {
4210	if (valid) {
4211	print_label(label,10);
4212	print_temp_info( cur, max, min, HYST, 1, 0);
4213	printf(" %s\n", alarms & VT8231_ALARM_TEMP5 ? "ALARM" : "" );
4214	}
4215	} else
4216	printf("ERROR: Can't get TEMP5 data!\n");
4217	free_the_label(&label);
4218	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP6,&label,&valid) &&
4219	!sensors_get_feature(*name,SENSORS_VT8231_TEMP6,&cur) &&
4220	!sensors_get_feature(*name,SENSORS_VT8231_TEMP6_HYST,&min) &&
4221	!sensors_get_feature(*name,SENSORS_VT8231_TEMP6_OVER,&max)) {
4222	if (valid) {
4223	print_label(label,10);
4224	print_temp_info( cur, max, min, HYST, 1, 0);
4225	printf(" %s\n", alarms & VT8231_ALARM_TEMP6 ? "ALARM" : "" );
4226	}
4227	} else
4228	printf("ERROR: Can't get TEMP6 data!\n");
4229	free_the_label(&label);
4230	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP7,&label,&valid) &&
4231	!sensors_get_feature(*name,SENSORS_VT8231_TEMP7,&cur) &&
4232	!sensors_get_feature(*name,SENSORS_VT8231_TEMP7_HYST,&min) &&
4233	!sensors_get_feature(*name,SENSORS_VT8231_TEMP7_OVER,&max)) {
4234	if (valid) {
4235	print_label(label,10);
4236	print_temp_info( cur, max, min, HYST, 1, 0);
4237	printf(" %s\n", alarms & VT8231_ALARM_TEMP7 ? "ALARM" : "" );
4238	}
4239	} else
4240	printf("ERROR: Can't get TEMP7 data!\n");
4241	free_the_label(&label);
4242
4243	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_VID,&label,&valid) &&
4244	!sensors_get_feature(*name,SENSORS_VT8231_VID,&cur)) {
4245	if (valid) {
4246	print_label(label,10);
4247	printf("%+6.2f V\n",cur);
4248	}
4249	}
4250	free_the_label(&label);
4251
4252	}
4253
4254	#define BMC_MAX_INS 10
4255	#define BMC_MAX_FANS 10
4256	#define BMC_MAX_TEMPS 10
4257
4258	void print_bmc(const sensors_chip_name *name)
4259	{
4260	char *label = NULL;
4261	double cur,min,max;
4262	int alarms, valid, i;
4263
4264	/*
4265	if (!sensors_get_feature(*name,SENSORS_VT8231_ALARMS,&cur))
4266	alarms = cur + 0.5;
4267	else {
4268	printf("ERROR: Can't get alarm data!\n");
4269	alarms = 0;
4270	}
4271	*/
4272	#define BMC_ALARM_IN1 0
4273	#define BMC_ALARM_FAN1 0
4274	#define BMC_ALARM_TEMP1 0
4275
4276	alarms = 0;
4277	for(i = 0; i < BMC_MAX_INS; i++) {
4278	if (!sensors_get_label_and_valid(*name,SENSORS_BMC_IN1+i,&label,&valid) &&
4279	!sensors_get_feature(*name,SENSORS_BMC_IN1+i,&cur) &&
4280	!sensors_get_feature(*name,SENSORS_BMC_IN1_MIN+i,&min) &&
4281	!sensors_get_feature(*name,SENSORS_BMC_IN1_MAX+i,&max)) {
4282	if (valid) {
4283	print_label(label,10);
4284	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4285	cur,min,max,alarms&BMC_ALARM_IN1?"ALARM":"");
4286	}
4287	}
4288	free_the_label(&label);
4289	}
4290
4291	for(i = 0; i < BMC_MAX_FANS; i++) {
4292	if (!sensors_get_label_and_valid(*name,SENSORS_BMC_FAN1+i,&label,&valid) &&
4293	!sensors_get_feature(*name,SENSORS_BMC_FAN1+i,&cur) &&
4294	!sensors_get_feature(*name,SENSORS_BMC_FAN1_MIN+i,&min)) {
4295	if (valid) {
4296	print_label(label,10);
4297	printf("%4.0f RPM (min = %4.0f RPM) %s\n",
4298	cur,min,alarms&BMC_ALARM_FAN1?"ALARM":"");
4299	}
4300	}
4301	free_the_label(&label);
4302	}
4303
4304	for(i = 0; i < BMC_MAX_TEMPS; i++) {
4305	if (!sensors_get_label_and_valid(*name,SENSORS_BMC_TEMP1+i,&label,&valid) &&
4306	!sensors_get_feature(*name,SENSORS_BMC_TEMP1+i,&cur) &&
4307	!sensors_get_feature(*name,SENSORS_BMC_TEMP1_MIN+i,&min) &&
4308	!sensors_get_feature(*name,SENSORS_BMC_TEMP1_MAX+i,&max)) {
4309	if (valid) {
4310	print_label(label,10);
4311	print_temp_info( cur, max, min, HYST, 1, 0);
4312	printf(" %s\n", alarms & BMC_ALARM_TEMP1 ? "ALARM" : "" );
4313	}
4314	}
4315	free_the_label(&label);
4316	}
4317	}
4318
4319	static long adm1026_alarms_in[] = {
4320	ADM1026_ALARM_IN0, ADM1026_ALARM_IN1, ADM1026_ALARM_IN2,
4321	ADM1026_ALARM_IN3, ADM1026_ALARM_IN4, ADM1026_ALARM_IN5,
4322	ADM1026_ALARM_IN6, ADM1026_ALARM_IN7, ADM1026_ALARM_IN8,
4323	ADM1026_ALARM_IN9, ADM1026_ALARM_IN10, ADM1026_ALARM_IN11,
4324	ADM1026_ALARM_IN12, ADM1026_ALARM_IN13, ADM1026_ALARM_IN14,
4325	ADM1026_ALARM_IN15, ADM1026_ALARM_IN16
4326	};
4327	static long adm1026_alarms_temp[] = {
4328	ADM1026_ALARM_TEMP1, ADM1026_ALARM_TEMP2, ADM1026_ALARM_TEMP3
4329	};
4330
4331	void print_adm1026(const sensors_chip_name *name)
4332	{
4333	char *label = NULL;
4334	double cur,min,max;
4335	long alarms;
4336	int valid, i;
4337
4338	if (!sensors_get_feature(*name,SENSORS_ADM1026_ALARMS,&cur)) {
4339	alarms = cur + 0.5;
4340	} else {
4341	printf("ERROR: Can't get alarm data!\n");
4342	alarms = 0;
4343	}
4344
4345	/* Seventeen voltage sensors */
4346	for (i = 0; i <= 16 ; ++i) {
4347	int feat_base = SENSORS_ADM1026_IN0 + (3 * i);
4348	int feat_max = feat_base +1, feat_min = feat_base +2;
4349	if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) &&
4350	!sensors_get_feature(*name,feat_base,&cur) &&
4351	!sensors_get_feature(*name,feat_min,&min) &&
4352	!sensors_get_feature(*name,feat_max,&max)) {
4353	if (valid) {
4354	print_label(label,10);
4355	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4356	cur,min,max,(alarms&adm1026_alarms_in[i])?"ALARM":"");
4357	}
4358	} else {
4359	printf("ERROR: Can't get IN%d data!\n",i);
4360	}
4361	free_the_label(&label);
4362	};
4363
4364	/* Eight fan sensors */
4365	for (i = 0; i <= 7 ; ++i) {
4366	int feat_base = SENSORS_ADM1026_FAN0 + (3 * i);
4367	int feat_div = feat_base +1, feat_min = feat_base +2;
4368	if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) &&
4369	!sensors_get_feature(*name,feat_base,&cur) &&
4370	!sensors_get_feature(*name,feat_min,&min) &&
4371	!sensors_get_feature(*name,feat_div,&max)) {
4372	if (valid) {
4373	print_label(label,10);
4374	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4375	cur,min,max,(alarms&(ADM1026_ALARM_FAN0<<i))?"ALARM":"");
4376	}
4377	} else {
4378	printf("ERROR: Can't get FAN%d data!\n",i);
4379	}
4380	free_the_label(&label);
4381	};
4382
4383	/* Three temperature sensors
4384	* NOTE: 6 config values per temperature
4385	* 0 current
4386	* 1 max
4387	* 2 min
4388	* 3 offset (to current)
4389	* 4 therm (SMBAlert)
4390	* 5 tmin (AFC)
4391	*/
4392	for (i = 0; i <= 2 ; ++i) {
4393	int feat_base = SENSORS_ADM1026_TEMP1 + (6 * i);
4394	int feat_max = feat_base +1;
4395	int feat_min = feat_base +2;
4396
4397	if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) &&
4398	!sensors_get_feature(*name,feat_base,&cur) &&
4399	!sensors_get_feature(*name,feat_min,&min) &&
4400	!sensors_get_feature(*name,feat_max,&max)) {
4401	if (valid) {
4402	print_label(label,10);
4403	print_temp_info( cur, max, min, MINMAX, 0, 0);
4404	puts( (alarms&adm1026_alarms_temp[i])?" ALARM":"" );
4405	}
4406	} else {
4407	printf("ERROR: Can't get TEMP%d data!\n",i+1);
4408	}
4409	free_the_label(&label);
4410	};
4411
4412	/* VID/VRM */
4413	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1026_VID,&label,&valid)
4414	&& !sensors_get_feature(*name,SENSORS_ADM1026_VID,&cur)
4415	&& !sensors_get_feature(*name,SENSORS_ADM1026_VRM,&min) ) {
4416	if (valid) {
4417	print_label(label,10);
4418	printf("%+6.3f V (VRM Version %4.1f)\n",cur,min);
4419	}
4420	}
4421	free_the_label(&label);
4422
4423	}
4424
4425	void print_lm83(const sensors_chip_name *name)
4426	{
4427	char *label;
4428	double cur,high,crit;
4429	int valid,alarms;
4430
4431	if (!sensors_get_feature(*name,SENSORS_LM83_ALARMS,&cur))
4432	alarms = cur + 0.5;
4433	else {
4434	printf("ERROR: Can't get alarm data!\n");
4435	alarms = 0;
4436	}
4437
4438	if (sensors_get_feature(*name,SENSORS_LM83_TCRIT,&crit)) {
4439	printf("ERROR: Can't get tcrit data!\n");
4440	crit = 127;
4441	}
4442
4443	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_LOCAL_TEMP,&label,&valid) &&
4444	!sensors_get_feature(*name,SENSORS_LM83_LOCAL_TEMP,&cur) &&
4445	!sensors_get_feature(*name,SENSORS_LM83_LOCAL_HIGH,&high)) {
4446	if (valid) {
4447	print_label(label,10);
4448	print_temp_info( cur, high, crit, CRIT, 0, 0);
4449	printf(" %s\n",
4450	alarms&LM83_ALARM_LOCAL_CRIT?"CRITICAL":
4451	alarms&LM83_ALARM_LOCAL_HIGH?"ALARM":"");
4452	}
4453	} else
4454	printf("ERROR: Can't get local temperature data!\n");
4455	free_the_label(&label);
4456
4457	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE1_TEMP,&label,&valid) &&
4458	!sensors_get_feature(*name,SENSORS_LM83_REMOTE1_TEMP,&cur) &&
4459	!sensors_get_feature(*name,SENSORS_LM83_REMOTE1_HIGH,&high)) {
4460	if (valid) {
4461	print_label(label,10);
4462	print_temp_info( cur, high, crit, CRIT, 0, 0);
4463	printf(" %s\n",
4464	alarms&LM83_ALARM_REMOTE1_OPEN?"DISCONNECT":
4465	alarms&LM83_ALARM_REMOTE1_CRIT?"CRITICAL":
4466	alarms&LM83_ALARM_REMOTE1_HIGH?"ALARM":"");
4467	}
4468	} else
4469	printf("ERROR: Can't get remote temperature 1 data!\n");
4470	free_the_label(&label);
4471
4472	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE2_TEMP,&label,&valid) &&
4473	!sensors_get_feature(*name,SENSORS_LM83_REMOTE2_TEMP,&cur) &&
4474	!sensors_get_feature(*name,SENSORS_LM83_REMOTE2_HIGH,&high)) {
4475	if (valid) {
4476	print_label(label,10);
4477	print_temp_info( cur, high, crit, CRIT, 0, 0);
4478	printf(" %s\n",
4479	alarms&LM83_ALARM_REMOTE2_OPEN?"DISCONNECT":
4480	alarms&LM83_ALARM_REMOTE2_CRIT?"CRITICAL":
4481	alarms&LM83_ALARM_REMOTE2_HIGH?"ALARM":"");
4482	}
4483	} else
4484	printf("ERROR: Can't get remote temperature 2 data!\n");
4485	free_the_label(&label);
4486
4487	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE3_TEMP,&label,&valid) &&
4488	!sensors_get_feature(*name,SENSORS_LM83_REMOTE3_TEMP,&cur) &&
4489	!sensors_get_feature(*name,SENSORS_LM83_REMOTE3_HIGH,&high)) {
4490	if (valid) {
4491	print_label(label,10);
4492	print_temp_info( cur, high, crit, CRIT, 0, 0);
4493	printf(" %s\n",
4494	alarms&LM83_ALARM_REMOTE3_OPEN?"DISCONNECT":
4495	alarms&LM83_ALARM_REMOTE3_CRIT?"CRITICAL":
4496	alarms&LM83_ALARM_REMOTE3_HIGH?"ALARM":"");
4497	}
4498	} else
4499	printf("ERROR: Can't get remote temperature 3 data!\n");
4500	free_the_label(&label);
4501	}
4502
4503	void print_lm90(const sensors_chip_name *name)
4504	{
4505	char *label;
4506	double cur, high, low, hyst;
4507	int valid, alarms;
4508
4509	if (!sensors_get_feature(*name, SENSORS_LM90_ALARMS, &cur))
4510	alarms = cur + 0.5;
4511	else {
4512	printf("ERROR: Can't get alarm data!\n");
4513	alarms = 0;
4514	}
4515
4516	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_LOCAL_TEMP,
4517	&label, &valid)
4518	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TEMP, &cur)
4519	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_HIGH, &high)
4520	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_LOW, &low)) {
4521	if (valid) {
4522	print_label(label, 10);
4523	print_temp_info(cur, high, low, MINMAX, 0, 0);
4524	printf(" %s\n",
4525	alarms&LM90_ALARM_LOCAL_CRIT?"CRITICAL":
4526	alarms&(LM90_ALARM_LOCAL_HIGH\|LM90_ALARM_LOCAL_LOW)?"ALARM":"");
4527	}
4528	} else
4529	printf("ERROR: Can't get local temperature data!\n");
4530	free_the_label(&label);
4531
4532	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_REMOTE_TEMP,
4533	&label, &valid)
4534	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TEMP, &cur)
4535	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_HIGH, &high)
4536	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_LOW, &low)) {
4537	if (valid) {
4538	print_label(label, 10);
4539	print_temp_info(cur, high, low, MINMAX, 1, 1);
4540	printf(" %s\n",
4541	alarms&LM90_ALARM_REMOTE_OPEN?"DISCONNECT":
4542	alarms&LM90_ALARM_REMOTE_CRIT?"CRITICAL":
4543	alarms&(LM90_ALARM_REMOTE_HIGH\|LM90_ALARM_REMOTE_LOW)?"ALARM":"");
4544	}
4545	} else
4546	printf("ERROR: Can't get remote temperature data!\n");
4547	free_the_label(&label);
4548
4549	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_LOCAL_TCRIT,
4550	&label, &valid)
4551	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TCRIT, &high)
4552	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TCRIT_HYST, &hyst)) {
4553	if (valid) {
4554	print_label(label, 10);
4555	print_temp_info(high, hyst, 0, HYSTONLY, 0, 0);
4556	printf("\n");
4557	}
4558	} else
4559	printf("ERROR: Can't get local tcrit data!\n");
4560	free_the_label(&label);
4561
4562	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_REMOTE_TCRIT,
4563	&label, &valid)
4564	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TCRIT, &high)
4565	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TCRIT_HYST, &hyst)) {
4566	if (valid) {
4567	print_label(label, 10);
4568	print_temp_info(high, hyst, 0, HYSTONLY, 0, 0);
4569	printf("\n");
4570	}
4571	} else
4572	printf("ERROR: Can't get remote tcrit data!\n");
4573	free_the_label(&label);
4574	}
4575
4576	void print_xeontemp(const sensors_chip_name *name)
4577	{
4578	char *label;
4579	double cur,hyst,over;
4580	int alarms,i,valid;
4581
4582	if (!sensors_get_feature(*name,SENSORS_XEONTEMP_ALARMS,&cur))
4583	alarms = cur + 0.5;
4584	else {
4585	printf("ERROR: Can't get alarm data!\n");
4586	alarms = 0;
4587	}
4588
4589	if (!sensors_get_label_and_valid(*name,SENSORS_XEONTEMP_REMOTE_TEMP,
4590	&label,&valid) &&
4591	!sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP,&cur) &&
4592	!sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP_HYST,&hyst) &&
4593	!sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP_OVER,&over)) {
4594	if (valid) {
4595	print_label(label,10);
4596	print_temp_info( cur, over, hyst, MINMAX, 0, 0);
4597	if (alarms & (XEONTEMP_ALARM_RTEMP_HIGH \| XEONTEMP_ALARM_RTEMP_LOW \|
4598	XEONTEMP_ALARM_RTEMP_NA)) {
4599	printf("ALARM (");
4600	i = 0;
4601	if (alarms & XEONTEMP_ALARM_RTEMP_NA) {
4602	printf("N/A");
4603	i++;
4604	}
4605	if (alarms & XEONTEMP_ALARM_RTEMP_LOW) {
4606	printf("%sLOW",i?",":"");
4607	i++;
4608	}
4609	if (alarms & XEONTEMP_ALARM_RTEMP_HIGH)
4610	printf("%sHIGH",i?",":"");
4611	printf(")");
4612	}
4613	printf("\n");
4614	}
4615	} else
4616	printf("ERROR: Can't get temperature data!\n");
4617	free_the_label(&label);
4618	}
4619
4620	void print_max6650(const sensors_chip_name *name)
4621	{
4622	char *label = NULL;
4623	double tach, speed;
4624	int valid, i;
4625
4626	static const struct
4627	{
4628	int tag;
4629	char *name;
4630	}
4631	tach_list[] =
4632	{
4633	{ SENSORS_MAX6650_FAN1_TACH, "FAN1" },
4634	{ SENSORS_MAX6650_FAN2_TACH, "FAN2" },
4635	{ SENSORS_MAX6650_FAN3_TACH, "FAN3" },
4636	{ SENSORS_MAX6650_FAN4_TACH, "FAN4" }
4637	};
4638
4639	/* Display full config for fan1, which is controlled */
4640
4641	if (!sensors_get_label_and_valid(*name,tach_list[0].tag,&label,&valid) &&
4642	!sensors_get_feature(*name,tach_list[0].tag,&tach) &&
4643	!sensors_get_feature(*name,SENSORS_MAX6650_SPEED,&speed)) {
4644	if (valid) {
4645	print_label(label,10);
4646	printf("configured %4.0f RPM, actual %4.0f RPM.\n", speed, tach);
4647	}
4648	} else
4649	printf("ERROR: Can't get %s data!\n", tach_list[0].name);
4650	free_the_label(&label);
4651
4652	/* Just display the measured speed for the other three, uncontrolled fans */
4653
4654	for (i = 1; i < 4; i++)
4655	{
4656	if (!sensors_get_label_and_v