Context Navigation

chips.c @ 2306

Revision 2306, 174.6 KB (checked in by khali, 9 years ago)

Better interpretation of it87 temperature sensor types.

(Takeru Komoriya)

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" :
3149	(((int)sens)==0) ? "disabled" : "invalid");
3150	printf( " %s\n", alarms & IT87_ALARM_TEMP1 ? "ALARM" : "" );
3151	}
3152	} else
3153	printf("ERROR: Can't get TEMP1 data!\n");
3154	free_the_label(&label);
3155	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP2,&label,&valid) &&
3156	!sensors_get_feature(*name,SENSORS_IT87_TEMP2,&cur) &&
3157	!sensors_get_feature(*name,SENSORS_IT87_TEMP2_LOW,&min) &&
3158	!sensors_get_feature(*name,SENSORS_IT87_SENS2,&sens) &&
3159	!sensors_get_feature(*name,SENSORS_IT87_TEMP2_HIGH,&max)) {
3160	if (valid) {
3161	print_label(label,10);
3162	print_temp_info( cur, max, min, MINMAX, 0, 0);
3163	printf(" sensor = %s ", (((int)sens)==3) ? "diode" :
3164	(((int)sens)==2) ? "thermistor" :
3165	(((int)sens)==0) ? "disabled" : "invalid");
3166	printf( " %s\n", alarms & IT87_ALARM_TEMP2 ? "ALARM" : "" );
3167	}
3168	} else
3169	printf("ERROR: Can't get TEMP2 data!\n");
3170	free_the_label(&label);
3171	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP3,&label,&valid) &&
3172	!sensors_get_feature(*name,SENSORS_IT87_TEMP3,&cur) &&
3173	!sensors_get_feature(*name,SENSORS_IT87_TEMP3_LOW,&min) &&
3174	!sensors_get_feature(*name,SENSORS_IT87_SENS3,&sens) &&
3175	!sensors_get_feature(*name,SENSORS_IT87_TEMP3_HIGH,&max)) {
3176	if (valid) {
3177	print_label(label,10);
3178	print_temp_info( cur, max, min, MINMAX, 0, 0);
3179	printf(" sensor = %s ", (((int)sens)==3) ? "diode" :
3180	(((int)sens)==2) ? "thermistor" :
3181	(((int)sens)==0) ? "disabled" : "invalid");
3182	printf( " %s\n", alarms & IT87_ALARM_TEMP3 ? "ALARM" : "" );
3183	}
3184	} else
3185	printf("ERROR: Can't get TEMP3 data!\n");
3186	free_the_label(&label);
3187
3188	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_VID,&label,&valid) &&
3189	!sensors_get_feature(*name,SENSORS_IT87_VID,&cur)) {
3190	if (valid) {
3191	print_label(label,10);
3192	printf("%+6.2f V\n",cur);
3193	}
3194	}
3195	free_the_label(&label);
3196	}
3197
3198	void print_fscpos(const sensors_chip_name *name)
3199	{
3200	char *label = NULL;
3201	double voltage, temp, state, fan;
3202	int valid;
3203
3204	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP1,&label,&valid) &&
3205	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP1,&temp) &&
3206	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP1_STATE,&state)) {
3207	if (valid) {
3208	print_label(label,10);
3209	if((int) state & 0x01)
3210	printf("\t%+6.2f C \n",temp);
3211	else
3212	printf("\tfailed\n");
3213	}
3214	} else
3215	printf("ERROR: Can't get TEMP1 data!\n");
3216	free_the_label(&label);
3217
3218	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP2,&label,&valid) &&
3219	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP2,&temp) &&
3220	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP2_STATE,&state)) {
3221	if (valid) {
3222	print_label(label,10);
3223	if((int) state & 0x01)
3224	printf("\t%+6.2f C \n",temp);
3225	else
3226	printf("\tfailed\n");
3227	}
3228	} else
3229	printf("ERROR: Can't get TEMP2 data!\n");
3230	free_the_label(&label);
3231
3232	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP3,&label,&valid) &&
3233	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP3,&temp) &&
3234	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP3_STATE,&state)) {
3235	if (valid) {
3236	print_label(label,10);
3237	if((int) state & 0x01)
3238	printf("\t%+6.2f C \n",temp);
3239	else
3240	printf("\tfailed\n");
3241	}
3242	} else
3243	printf("ERROR: Can't get TEMP3 data!\n");
3244	free_the_label(&label);
3245
3246	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN1,&label,&valid) &&
3247	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN1,&fan) &&
3248	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN1_STATE,&state)) {
3249	if (valid) {
3250	print_label(label,10);
3251	if((int) state & 0x04)
3252	printf("\tfaulty\n");
3253	else
3254	printf("\t%6.0f RPM \n",fan);
3255	}
3256	} else
3257	printf("ERROR: Can't get FAN1 data!\n");
3258	free_the_label(&label);
3259
3260	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN2,&label,&valid) &&
3261	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN2,&fan) &&
3262	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN2_STATE,&state)) {
3263	if (valid) {
3264	print_label(label,10);
3265	if((int) state & 0x04)
3266	printf("\tfaulty\n");
3267	else
3268	printf("\t%6.0f RPM \n",fan);
3269	}
3270	} else
3271	printf("ERROR: Can't get FAN2 data!\n");
3272	free_the_label(&label);
3273
3274	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN3,&label,&valid) &&
3275	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN3,&fan) &&
3276	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN3_STATE,&state)) {
3277	if (valid) {
3278	print_label(label,10);
3279	if((int) state & 0x04)
3280	printf("\tfaulty\n");
3281	else
3282	printf("\t%6.0f RPM \n",fan);
3283	}
3284	} else
3285	printf("ERROR: Can't get FAN3 data!\n");
3286	free_the_label(&label);
3287
3288	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE1,&label,&valid) &&
3289	!sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE1,&voltage)) {
3290	if (valid) {
3291	print_label(label,10);
3292	printf("\t%+6.2f V\n",voltage);
3293	}
3294	} else
3295	printf("ERROR: Can't get IN0 data!\n");
3296	free_the_label(&label);
3297
3298	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE2,&label,&valid) &&
3299	!sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE2,&voltage)) {
3300	if (valid) {
3301	print_label(label,10);
3302	printf("\t%+6.2f V\n",voltage);
3303	}
3304	} else
3305	printf("ERROR: Can't get IN1 data!\n");
3306	free_the_label(&label);
3307
3308	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE3,&label,&valid) &&
3309	!sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE3,&voltage)) {
3310	if (valid) {
3311	print_label(label,10);
3312	printf("\t%+6.2f V\n",voltage);
3313	}
3314	} else
3315	printf("ERROR: Can't get IN2 data!\n");
3316	free_the_label(&label);
3317	}
3318
3319	void print_fscscy(const sensors_chip_name *name)
3320	{
3321	char *label = NULL;
3322	double voltage, temp, tempmin, tempmax, templim, state, fan;
3323	int valid;
3324
3325	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP1,&label,&valid) &&
3326	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1,&temp) &&
3327	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_LIM,&templim) &&
3328	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_MIN,&tempmin) &&
3329	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_MAX,&tempmax) &&
3330	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_STATE,&state)) {
3331	if (valid) {
3332	print_label(label,10);
3333	if((int) state & 0x01)
3334	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3335	temp,tempmin,tempmax,templim);
3336	else
3337	printf("\tfailed\n");
3338	}
3339	} else
3340	printf("ERROR: Can't get TEMP1 data!\n");
3341	free_the_label(&label);
3342
3343	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP2,&label,&valid) &&
3344	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2,&temp) &&
3345	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_LIM,&templim) &&
3346	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_MIN,&tempmin) &&
3347	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_MAX,&tempmax) &&
3348	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_STATE,&state)) {
3349	if (valid) {
3350	print_label(label,10);
3351	if((int) state & 0x01)
3352	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3353	temp,tempmin,tempmax,templim);
3354	else
3355	printf("\tfailed\n");
3356	}
3357	} else
3358	printf("ERROR: Can't get TEMP2 data!\n");
3359	free_the_label(&label);
3360
3361	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP3,&label,&valid) &&
3362	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3,&temp) &&
3363	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_LIM,&templim) &&
3364	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_MIN,&tempmin) &&
3365	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_MAX,&tempmax) &&
3366	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_STATE,&state)) {
3367	if (valid) {
3368	print_label(label,10);
3369	if((int) state & 0x01)
3370	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3371	temp,tempmin,tempmax,templim);
3372	else
3373	printf("\tfailed\n");
3374	}
3375	} else
3376	printf("ERROR: Can't get TEMP3 data!\n");
3377	free_the_label(&label);
3378
3379	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP4,&label,&valid) &&
3380	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4,&temp) &&
3381	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_LIM,&templim) &&
3382	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_MIN,&tempmin) &&
3383	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_MAX,&tempmax) &&
3384	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_STATE,&state)) {
3385	if (valid) {
3386	print_label(label,10);
3387	if((int) state & 0x01)
3388	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3389	temp,tempmin,tempmax,templim);
3390	else
3391	printf("\tfailed\n");
3392	}
3393	} else
3394	printf("ERROR: Can't get TEMP4 data!\n");
3395	free_the_label(&label);
3396
3397	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN1,&label,&valid) &&
3398	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN1,&fan) &&
3399	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN1_STATE,&state)) {
3400	if (valid) {
3401	print_label(label,10);
3402	if((int) state & 0x02)
3403	printf("\tfaulty\n");
3404	else
3405	printf("\t%6.0f RPM \n",fan);
3406	}
3407	} else
3408	printf("ERROR: Can't get FAN1 data!\n");
3409	free_the_label(&label);
3410
3411	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN2,&label,&valid) &&
3412	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN2,&fan) &&
3413	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN2_STATE,&state)) {
3414	if (valid) {
3415	print_label(label,10);
3416	if((int) state & 0x02)
3417	printf("\tfaulty\n");
3418	else
3419	printf("\t%6.0f RPM \n",fan);
3420	}
3421	} else
3422	printf("ERROR: Can't get FAN2 data!\n");
3423	free_the_label(&label);
3424
3425	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN3,&label,&valid) &&
3426	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN3,&fan) &&
3427	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN3_STATE,&state)) {
3428	if (valid) {
3429	print_label(label,10);
3430	if((int) state & 0x02)
3431	printf("\tfaulty\n");
3432	else
3433	printf("\t%6.0f RPM \n",fan);
3434	}
3435	} else
3436	printf("ERROR: Can't get FAN3 data!\n");
3437	free_the_label(&label);
3438
3439	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN4,&label,&valid) &&
3440	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN4,&fan) &&
3441	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN4_STATE,&state)) {
3442	if (valid) {
3443	print_label(label,10);
3444	if((int) state & 0x02)
3445	printf("\tfaulty\n");
3446	else
3447	printf("\t%6.0f RPM \n",fan);
3448	}
3449	} else
3450	printf("ERROR: Can't get FAN4 data!\n");
3451	free_the_label(&label);
3452
3453	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN5,&label,&valid) &&
3454	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN5,&fan) &&
3455	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN5_STATE,&state)) {
3456	if (valid) {
3457	print_label(label,10);
3458	if((int) state & 0x02)
3459	printf("\tfaulty\n");
3460	else
3461	printf("\t%6.0f RPM \n",fan);
3462	}
3463	} else
3464	printf("ERROR: Can't get FAN5 data!\n");
3465	free_the_label(&label);
3466
3467	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN6,&label,&valid) &&
3468	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN6,&fan) &&
3469	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN6_STATE,&state)) {
3470	if (valid) {
3471	print_label(label,10);
3472	if((int) state & 0x02)
3473	printf("\tfaulty\n");
3474	else
3475	printf("\t%6.0f RPM \n",fan);
3476	}
3477	} else
3478	printf("ERROR: Can't get FAN6 data!\n");
3479	free_the_label(&label);
3480
3481	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE1,&label,&valid) &&
3482	!sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE1,&voltage)) {
3483	if (valid) {
3484	print_label(label,10);
3485	printf("\t%+6.2f V\n",voltage);
3486	}
3487	} else
3488	printf("ERROR: Can't get IN0 data!\n");
3489	free_the_label(&label);
3490
3491	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE2,&label,&valid) &&
3492	!sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE2,&voltage)) {
3493	if (valid) {
3494	print_label(label,10);
3495	printf("\t%+6.2f V\n",voltage);
3496	}
3497	} else
3498	printf("ERROR: Can't get IN1 data!\n");
3499	free_the_label(&label);
3500
3501	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE3,&label,&valid) &&
3502	!sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE3,&voltage)) {
3503	if (valid) {
3504	print_label(label,10);
3505	printf("\t%+6.2f V\n",voltage);
3506	}
3507	} else
3508	printf("ERROR: Can't get IN2 data!\n");
3509	free_the_label(&label);
3510	}
3511
3512	void print_fscher(const sensors_chip_name *name)
3513	{
3514	char *label = NULL;
3515	double voltage, temp, state, fan;
3516	int valid;
3517
3518	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP1,&label,&valid)
3519	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP1,&temp)
3520	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP1_STATE,&state)) {
3521	if (valid) {
3522	print_label(label,10);
3523	if((int) state & 0x01)
3524	printf("\t%+6.2f C \n",temp);
3525	else
3526	printf("\tfailed\n");
3527	}
3528	} else
3529	printf("ERROR: Can't get TEMP1 data!\n");
3530	free_the_label(&label);
3531
3532	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP2,&label,&valid)
3533	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP2,&temp)
3534	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP2_STATE,&state)) {
3535	if (valid) {
3536	print_label(label,10);
3537	if((int) state & 0x01)
3538	printf("\t%+6.2f C \n",temp);
3539	else
3540	printf("\tfailed\n");
3541	}
3542	} else
3543	printf("ERROR: Can't get TEMP2 data!\n");
3544	free_the_label(&label);
3545
3546	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP3,&label,&valid)
3547	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP3,&temp)
3548	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP3_STATE,&state)) {
3549	if (valid) {
3550	print_label(label,10);
3551	if((int) state & 0x01)
3552	printf("\t%+6.2f C \n",temp);
3553	else
3554	printf("\tfailed\n");
3555	}
3556	} else
3557	printf("ERROR: Can't get TEMP3 data!\n");
3558	free_the_label(&label);
3559
3560	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN1,&label,&valid)
3561	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN1,&fan)
3562	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN1_STATE,&state)) {
3563	if (valid) {
3564	print_label(label,10);
3565	if((int) state & 0x04)
3566	printf("\tfaulty\n");
3567	else
3568	printf("\t%6.0f RPM \n",fan);
3569	}
3570	} else
3571	printf("ERROR: Can't get FAN1 data!\n");
3572	free_the_label(&label);
3573
3574	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN2,&label,&valid)
3575	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN2,&fan)
3576	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN2_STATE,&state)) {
3577	if (valid) {
3578	print_label(label,10);
3579	if((int) state & 0x04)
3580	printf("\tfaulty\n");
3581	else
3582	printf("\t%6.0f RPM \n",fan);
3583	}
3584	} else
3585	printf("ERROR: Can't get FAN2 data!\n");
3586	free_the_label(&label);
3587
3588	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN3,&label,&valid)
3589	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN3,&fan)
3590	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN3_STATE,&state)) {
3591	if (valid) {
3592	print_label(label,10);
3593	if((int) state & 0x04)
3594	printf("\tfaulty\n");
3595	else
3596	printf("\t%6.0f RPM \n",fan);
3597	}
3598	} else
3599	printf("ERROR: Can't get FAN3 data!\n");
3600	free_the_label(&label);
3601
3602	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE1,&label,&valid)
3603	&& !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE1,&voltage)) {
3604	if (valid) {
3605	print_label(label,10);
3606	printf("\t%+6.2f V\n",voltage);
3607	}
3608	} else
3609	printf("ERROR: Can't get IN0 data!\n");
3610	free_the_label(&label);
3611
3612	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE2,&label,&valid)
3613	&& !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE2,&voltage)) {
3614	if (valid) {
3615	print_label(label,10);
3616	printf("\t%+6.2f V\n",voltage);
3617	}
3618	} else
3619	printf("ERROR: Can't get IN1 data!\n");
3620	free_the_label(&label);
3621
3622	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE3,&label,&valid)
3623	&& !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE3,&voltage)) {
3624	if (valid) {
3625	print_label(label,10);
3626	printf("\t%+6.2f V\n",voltage);
3627	}
3628	} else
3629	printf("ERROR: Can't get IN2 data!\n");
3630	free_the_label(&label);
3631	}
3632
3633	void print_pcf8591(const sensors_chip_name *name)
3634	{
3635	char *label;
3636	double ain_conf, ch0, ch1, ch2, ch3;
3637	double aout_enable, aout;
3638	int valid;
3639
3640	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_AIN_CONF,&label,&valid) &&
3641	!sensors_get_feature(*name,SENSORS_PCF8591_AIN_CONF,&ain_conf)) {
3642	if (valid) {
3643	print_label(label,10);
3644	switch ((int)ain_conf)
3645	{
3646	case 0: printf("four single ended inputs\n");
3647	break;
3648	case 1: printf("three differential inputs\n");
3649	break;
3650	case 2: printf("single ended and differential mixed\n");
3651	break;
3652	case 3: printf("two differential inputs\n");
3653	break;
3654	}
3655	}
3656	}
3657	else printf("ERROR: Can't read analog inputs configuration!\n");
3658	free_the_label(&label);
3659
3660	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH0,&label,&valid) &&
3661	!sensors_get_feature(*name,SENSORS_PCF8591_CH0,&ch0)) {
3662	if (valid) {
3663	print_label(label,10);
3664	printf("%0.0f\n", ch0);
3665	}
3666	}
3667	else printf("ERROR: Can't read ch0!\n");
3668	free_the_label(&label);
3669
3670	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH1,&label,&valid) &&
3671	!sensors_get_feature(*name,SENSORS_PCF8591_CH1,&ch1)) {
3672	if (valid) {
3673	print_label(label,10);
3674	printf("%0.0f\n", ch1);
3675	}
3676	}
3677	else printf("ERROR: Can't read ch1!\n");
3678	free_the_label(&label);
3679
3680	if (ain_conf != 3) {
3681	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH2,&label,&valid) &&
3682	!sensors_get_feature(*name,SENSORS_PCF8591_CH2,&ch2)) {
3683	if (valid) {
3684	print_label(label,10);
3685	printf("%0.0f\n", ch2);
3686	}
3687	}
3688	else printf("ERROR: Can't read ch2!\n");
3689	free_the_label(&label);
3690	}
3691
3692	if (ain_conf == 0) {
3693	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH3,&label,&valid) &&
3694	!sensors_get_feature(*name,SENSORS_PCF8591_CH3,&ch3)) {
3695	if (valid) {
3696	print_label(label,10);
3697	printf("%0.0f\n", ch3);
3698	}
3699	}
3700	else printf("ERROR: Can't read ch3!\n");
3701	free_the_label(&label);
3702	}
3703
3704	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_AOUT,&label,&valid) &&
3705	!sensors_get_feature(*name,SENSORS_PCF8591_AOUT,&aout) &&
3706	!sensors_get_feature(*name,SENSORS_PCF8591_AOUT_ENABLE,&aout_enable)) {
3707	if (valid) {
3708	print_label(label,10);
3709	printf("%0.0f (%s)\n", aout, aout_enable?"enabled":"disabled");
3710	}
3711	}
3712	else printf("ERROR: Can't read aout!\n");
3713	free_the_label(&label);
3714
3715	}
3716
3717	void print_vt1211(const sensors_chip_name *name)
3718	{
3719	char *label = NULL;
3720	double cur,min,max,fdiv;
3721	int alarms,valid;
3722
3723	if (!sensors_get_feature(*name,SENSORS_VT1211_ALARMS,&cur))
3724	alarms = cur + 0.5;
3725	else {
3726	printf("ERROR: Can't get alarm data!\n");
3727	alarms = 0;
3728	}
3729
3730	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN0,&label,&valid) &&
3731	!sensors_get_feature(*name,SENSORS_VT1211_IN0,&cur) &&
3732	!sensors_get_feature(*name,SENSORS_VT1211_IN0_MIN,&min) &&
3733	!sensors_get_feature(*name,SENSORS_VT1211_IN0_MAX,&max)) {
3734	if (valid) {
3735	print_label(label,10);
3736	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3737	cur,min,max,alarms&VT1211_ALARM_IN0?"ALARM":"");
3738	}
3739	} else
3740	printf("ERROR: Can't get IN0 data!\n");
3741	free_the_label(&label);
3742	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN1,&label,&valid) &&
3743	!sensors_get_feature(*name,SENSORS_VT1211_IN1,&cur) &&
3744	!sensors_get_feature(*name,SENSORS_VT1211_IN1_MIN,&min) &&
3745	!sensors_get_feature(*name,SENSORS_VT1211_IN1_MAX,&max)) {
3746	if (valid) {
3747	print_label(label,10);
3748	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3749	cur,min,max,alarms&VT1211_ALARM_IN1?"ALARM":"");
3750	}
3751	} else
3752	printf("ERROR: Can't get IN1 data!\n");
3753	free_the_label(&label);
3754	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN2,&label,&valid) &&
3755	!sensors_get_feature(*name,SENSORS_VT1211_IN2,&cur) &&
3756	!sensors_get_feature(*name,SENSORS_VT1211_IN2_MIN,&min) &&
3757	!sensors_get_feature(*name,SENSORS_VT1211_IN2_MAX,&max)) {
3758	if (valid) {
3759	print_label(label,10);
3760	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3761	cur,min,max,alarms&VT1211_ALARM_IN2?"ALARM":"");
3762	}
3763	} else
3764	printf("ERROR: Can't get IN2 data!\n");
3765	free_the_label(&label);
3766	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN3,&label,&valid) &&
3767	!sensors_get_feature(*name,SENSORS_VT1211_IN3,&cur) &&
3768	!sensors_get_feature(*name,SENSORS_VT1211_IN3_MIN,&min) &&
3769	!sensors_get_feature(*name,SENSORS_VT1211_IN3_MAX,&max)) {
3770	if (valid) {
3771	print_label(label,10);
3772	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3773	cur,min,max,alarms&VT1211_ALARM_IN3?"ALARM":"");
3774	}
3775	} else
3776	printf("ERROR: Can't get IN3 data!\n");
3777	free_the_label(&label);
3778	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN4,&label,&valid) &&
3779	!sensors_get_feature(*name,SENSORS_VT1211_IN4,&cur) &&
3780	!sensors_get_feature(*name,SENSORS_VT1211_IN4_MIN,&min) &&
3781	!sensors_get_feature(*name,SENSORS_VT1211_IN4_MAX,&max)) {
3782	if (valid) {
3783	print_label(label,10);
3784	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3785	cur,min,max,alarms&VT1211_ALARM_IN4?"ALARM":"");
3786	}
3787	} else
3788	printf("ERROR: Can't get IN4 data!\n");
3789	free_the_label(&label);
3790	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN5,&label,&valid) &&
3791	!sensors_get_feature(*name,SENSORS_VT1211_IN5,&cur) &&
3792	!sensors_get_feature(*name,SENSORS_VT1211_IN5_MIN,&min) &&
3793	!sensors_get_feature(*name,SENSORS_VT1211_IN5_MAX,&max)) {
3794	if (valid) {
3795	print_label(label,10);
3796	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3797	cur,min,max,alarms&VT1211_ALARM_IN5?"ALARM":"");
3798	}
3799	} else
3800	printf("ERROR: Can't get IN5 data!\n");
3801	free_the_label(&label);
3802	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_IN6,&label,&valid) &&
3803	!sensors_get_feature(*name,SENSORS_VT1211_IN6,&cur) &&
3804	!sensors_get_feature(*name,SENSORS_VT1211_IN6_MIN,&min) &&
3805	!sensors_get_feature(*name,SENSORS_VT1211_IN6_MAX,&max)) {
3806	if (valid) {
3807	print_label(label,10);
3808	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3809	cur,min,max,alarms&VT1211_ALARM_IN6?"ALARM":"");
3810	}
3811	} else
3812	printf("ERROR: Can't get IN6 data!\n");
3813	free_the_label(&label);
3814
3815	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_FAN1,&label,&valid) &&
3816	!sensors_get_feature(*name,SENSORS_VT1211_FAN1,&cur) &&
3817	!sensors_get_feature(*name,SENSORS_VT1211_FAN1_DIV,&fdiv) &&
3818	!sensors_get_feature(*name,SENSORS_VT1211_FAN1_MIN,&min)) {
3819	if (valid) {
3820	print_label(label,10);
3821	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3822	cur,min,fdiv, alarms&VT1211_ALARM_FAN1?"ALARM":"");
3823	}
3824	} else
3825	printf("ERROR: Can't get FAN1 data!\n");
3826	free_the_label(&label);
3827	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_FAN2,&label,&valid) &&
3828	!sensors_get_feature(*name,SENSORS_VT1211_FAN2,&cur) &&
3829	!sensors_get_feature(*name,SENSORS_VT1211_FAN2_DIV,&fdiv) &&
3830	!sensors_get_feature(*name,SENSORS_VT1211_FAN2_MIN,&min)) {
3831	if (valid) {
3832	print_label(label,10);
3833	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3834	cur,min,fdiv, alarms&VT1211_ALARM_FAN2?"ALARM":"");
3835	}
3836	} else
3837	printf("ERROR: Can't get FAN2 data!\n");
3838	free_the_label(&label);
3839
3840	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP,&label,&valid) &&
3841	!sensors_get_feature(*name,SENSORS_VT1211_TEMP,&cur) &&
3842	!sensors_get_feature(*name,SENSORS_VT1211_TEMP_HYST,&min) &&
3843	!sensors_get_feature(*name,SENSORS_VT1211_TEMP_OVER,&max)) {
3844	if (valid) {
3845	print_label(label,10);
3846	print_temp_info( cur, max, min, HYST, 1, 0);
3847	printf(" %s\n", alarms & VT1211_ALARM_TEMP ? "ALARM" : "" );
3848	}
3849	} else
3850	printf("ERROR: Can't get TEMP data!\n");
3851	free_the_label(&label);
3852	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP2,&label,&valid) &&
3853	!sensors_get_feature(*name,SENSORS_VT1211_TEMP2,&cur) &&
3854	!sensors_get_feature(*name,SENSORS_VT1211_TEMP2_HYST,&min) &&
3855	!sensors_get_feature(*name,SENSORS_VT1211_TEMP2_OVER,&max)) {
3856	if (valid) {
3857	print_label(label,10);
3858	print_temp_info( cur, max, min, HYST, 1, 0);
3859	printf(" %s\n", alarms & VT1211_ALARM_TEMP2 ? "ALARM" : "" );
3860	}
3861	} else
3862	printf("ERROR: Can't get TEMP2 data!\n");
3863	free_the_label(&label);
3864	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP3,&label,&valid) &&
3865	!sensors_get_feature(*name,SENSORS_VT1211_TEMP3,&cur) &&
3866	!sensors_get_feature(*name,SENSORS_VT1211_TEMP3_HYST,&min) &&
3867	!sensors_get_feature(*name,SENSORS_VT1211_TEMP3_OVER,&max)) {
3868	if (valid) {
3869	print_label(label,10);
3870	print_temp_info( cur, max, min, HYST, 1, 0);
3871	printf(" %s\n", alarms & VT1211_ALARM_TEMP3 ? "ALARM" : "" );
3872	}
3873	} else
3874	printf("ERROR: Can't get TEMP3 data!\n");
3875	free_the_label(&label);
3876	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP4,&label,&valid) &&
3877	!sensors_get_feature(*name,SENSORS_VT1211_TEMP4,&cur) &&
3878	!sensors_get_feature(*name,SENSORS_VT1211_TEMP4_HYST,&min) &&
3879	!sensors_get_feature(*name,SENSORS_VT1211_TEMP4_OVER,&max)) {
3880	if (valid) {
3881	print_label(label,10);
3882	print_temp_info( cur, max, min, HYST, 1, 0);
3883	printf(" %s\n", alarms & VT1211_ALARM_TEMP4 ? "ALARM" : "" );
3884	}
3885	} else
3886	printf("ERROR: Can't get TEMP4 data!\n");
3887	free_the_label(&label);
3888	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP5,&label,&valid) &&
3889	!sensors_get_feature(*name,SENSORS_VT1211_TEMP5,&cur) &&
3890	!sensors_get_feature(*name,SENSORS_VT1211_TEMP5_HYST,&min) &&
3891	!sensors_get_feature(*name,SENSORS_VT1211_TEMP5_OVER,&max)) {
3892	if (valid) {
3893	print_label(label,10);
3894	print_temp_info( cur, max, min, HYST, 1, 0);
3895	printf(" %s\n", alarms & VT1211_ALARM_TEMP5 ? "ALARM" : "" );
3896	}
3897	} else
3898	printf("ERROR: Can't get TEMP5 data!\n");
3899	free_the_label(&label);
3900	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP6,&label,&valid) &&
3901	!sensors_get_feature(*name,SENSORS_VT1211_TEMP6,&cur) &&
3902	!sensors_get_feature(*name,SENSORS_VT1211_TEMP6_HYST,&min) &&
3903	!sensors_get_feature(*name,SENSORS_VT1211_TEMP6_OVER,&max)) {
3904	if (valid) {
3905	print_label(label,10);
3906	print_temp_info( cur, max, min, HYST, 1, 0);
3907	printf(" %s\n", alarms & VT1211_ALARM_TEMP6 ? "ALARM" : "" );
3908	}
3909	} else
3910	printf("ERROR: Can't get TEMP6 data!\n");
3911	free_the_label(&label);
3912	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP7,&label,&valid) &&
3913	!sensors_get_feature(*name,SENSORS_VT1211_TEMP7,&cur) &&
3914	!sensors_get_feature(*name,SENSORS_VT1211_TEMP7_HYST,&min) &&
3915	!sensors_get_feature(*name,SENSORS_VT1211_TEMP7_OVER,&max)) {
3916	if (valid) {
3917	print_label(label,10);
3918	print_temp_info( cur, max, min, HYST, 1, 0);
3919	printf(" %s\n", alarms & VT1211_ALARM_TEMP7 ? "ALARM" : "" );
3920	}
3921	} else
3922	printf("ERROR: Can't get TEMP7 data!\n");
3923	free_the_label(&label);
3924
3925	if (!sensors_get_label_and_valid(*name,SENSORS_VT1211_VID,&label,&valid) &&
3926	!sensors_get_feature(*name,SENSORS_VT1211_VID,&cur)) {
3927	if (valid) {
3928	print_label(label,10);
3929	printf("%+6.2f V\n",cur);
3930	}
3931	}
3932	free_the_label(&label);
3933
3934	}
3935
3936	void print_smsc47m1(const sensors_chip_name *name)
3937	{
3938	char *label = NULL;
3939	double cur,min,fdiv;
3940	int alarms,valid;
3941
3942	if (!sensors_get_feature(*name,SENSORS_SMSC47M1_ALARMS,&cur))
3943	alarms = cur + 0.5;
3944	else {
3945	printf("ERROR: Can't get alarm data!\n");
3946	alarms = 0;
3947	}
3948
3949	if (!sensors_get_label_and_valid(*name,SENSORS_SMSC47M1_FAN1,&label,&valid) &&
3950	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN1,&cur) &&
3951	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN1_DIV,&fdiv) &&
3952	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN1_MIN,&min)) {
3953	if (valid) {
3954	print_label(label,10);
3955	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3956	cur,min,fdiv, alarms&SMSC47M1_ALARM_FAN1?"ALARM":"");
3957	}
3958	} else
3959	printf("ERROR: Can't get FAN1 data!\n");
3960	free_the_label(&label);
3961
3962	if (!sensors_get_label_and_valid(*name,SENSORS_SMSC47M1_FAN2,&label,&valid) &&
3963	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN2,&cur) &&
3964	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN2_DIV,&fdiv) &&
3965	!sensors_get_feature(*name,SENSORS_SMSC47M1_FAN2_MIN,&min)) {
3966	if (valid) {
3967	print_label(label,10);
3968	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3969	cur,min,fdiv, alarms&SMSC47M1_ALARM_FAN2?"ALARM":"");
3970	}
3971	} else
3972	printf("ERROR: Can't get FAN2 data!\n");
3973	free_the_label(&label);
3974
3975	}
3976
3977	static void lm92_print_temp (float n_cur,float n_high,float n_low,float n_crit,float n_hyst)
3978	{
3979	if (fahrenheit) {
3980	n_cur = deg_ctof (n_cur);
3981	n_high = deg_ctof (n_high);
3982	n_low = deg_ctof (n_low);
3983	n_crit = deg_ctof (n_crit);
3984	n_hyst = deg_ctof (n_hyst);
3985	}
3986
3987	printf ("%+6.4f%s (high = %+6.4f%s, low = %+6.4f%s, crit = %+6.4f%s, hyst = %+6.4f%s)",
3988	n_cur, degstr,
3989	n_high, degstr,
3990	n_low, degstr,
3991	n_crit, degstr,
3992	n_hyst, degstr);
3993	}
3994
3995	void print_lm92 (const sensors_chip_name *name)
3996	{
3997	char *label = NULL;
3998	double temp[5];
3999	int valid,alarms;
4000
4001	if (!sensors_get_feature (*name,SENSORS_LM92_ALARMS,temp)) {
4002	alarms = *temp + 0.5;
4003	} else {
4004	printf ("ERROR: Can't get alarm data!\n");
4005	return;
4006	}
4007
4008	if (!sensors_get_label_and_valid (*name,SENSORS_LM92_TEMP,&label,&valid) &&
4009	!sensors_get_feature (*name,SENSORS_LM92_TEMP,temp) &&
4010	!sensors_get_feature (*name,SENSORS_LM92_TEMP_HIGH,temp + 1) &&
4011	!sensors_get_feature (*name,SENSORS_LM92_TEMP_LOW,temp + 2) &&
4012	!sensors_get_feature (*name,SENSORS_LM92_TEMP_CRIT,temp + 3) &&
4013	!sensors_get_feature (*name,SENSORS_LM92_TEMP_HYST,temp + 4)) {
4014	if (valid) {
4015	print_label (label,10);
4016	lm92_print_temp (temp[0],temp[1],temp[2],temp[3],temp[4]);
4017	if (alarms) {
4018	printf (" ALARMS (");
4019
4020	if ((alarms & LM92_ALARM_TEMP_HIGH))
4021	printf ("HIGH");
4022
4023	if (alarms & LM92_ALARM_TEMP_LOW)
4024	printf ("%sLOW",(alarms & LM92_ALARM_TEMP_HIGH) ? "," : "");
4025
4026	if (alarms & LM92_ALARM_TEMP_CRIT)
4027	printf ("%sCRIT",(alarms & (LM92_ALARM_TEMP_HIGH \| LM92_ALARM_TEMP_LOW)) ? "," : "");
4028
4029	printf (")");
4030	}
4031	printf ("\n");
4032	}
4033	} else printf ("ERROR: Can't get temperature data!\n");
4034
4035	free_the_label (&label);
4036	}
4037
4038	void print_vt8231(const sensors_chip_name *name)
4039	{
4040	char *label = NULL;
4041	double cur,min,max,fdiv;
4042	int alarms,valid;
4043
4044	if (!sensors_get_feature(*name,SENSORS_VT8231_ALARMS,&cur))
4045	alarms = cur + 0.5;
4046	else {
4047	printf("ERROR: Can't get alarm data!\n");
4048	alarms = 0;
4049	}
4050
4051	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN0,&label,&valid) &&
4052	!sensors_get_feature(*name,SENSORS_VT8231_IN0,&cur) &&
4053	!sensors_get_feature(*name,SENSORS_VT8231_IN0_MIN,&min) &&
4054	!sensors_get_feature(*name,SENSORS_VT8231_IN0_MAX,&max)) {
4055	if (valid) {
4056	print_label(label,10);
4057	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4058	cur,min,max,alarms&VT8231_ALARM_IN0?"ALARM":"");
4059	}
4060	} else
4061	printf("ERROR: Can't get IN0 data!\n");
4062	free_the_label(&label);
4063	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN1,&label,&valid) &&
4064	!sensors_get_feature(*name,SENSORS_VT8231_IN1,&cur) &&
4065	!sensors_get_feature(*name,SENSORS_VT8231_IN1_MIN,&min) &&
4066	!sensors_get_feature(*name,SENSORS_VT8231_IN1_MAX,&max)) {
4067	if (valid) {
4068	print_label(label,10);
4069	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4070	cur,min,max,alarms&VT8231_ALARM_IN1?"ALARM":"");
4071	}
4072	} else
4073	printf("ERROR: Can't get IN1 data!\n");
4074	free_the_label(&label);
4075	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN2,&label,&valid) &&
4076	!sensors_get_feature(*name,SENSORS_VT8231_IN2,&cur) &&
4077	!sensors_get_feature(*name,SENSORS_VT8231_IN2_MIN,&min) &&
4078	!sensors_get_feature(*name,SENSORS_VT8231_IN2_MAX,&max)) {
4079	if (valid) {
4080	print_label(label,10);
4081	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4082	cur,min,max,alarms&VT8231_ALARM_IN2?"ALARM":"");
4083	}
4084	} else
4085	printf("ERROR: Can't get IN2 data!\n");
4086	free_the_label(&label);
4087	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN3,&label,&valid) &&
4088	!sensors_get_feature(*name,SENSORS_VT8231_IN3,&cur) &&
4089	!sensors_get_feature(*name,SENSORS_VT8231_IN3_MIN,&min) &&
4090	!sensors_get_feature(*name,SENSORS_VT8231_IN3_MAX,&max)) {
4091	if (valid) {
4092	print_label(label,10);
4093	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4094	cur,min,max,alarms&VT8231_ALARM_IN3?"ALARM":"");
4095	}
4096	} else
4097	printf("ERROR: Can't get IN3 data!\n");
4098	free_the_label(&label);
4099	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN4,&label,&valid) &&
4100	!sensors_get_feature(*name,SENSORS_VT8231_IN4,&cur) &&
4101	!sensors_get_feature(*name,SENSORS_VT8231_IN4_MIN,&min) &&
4102	!sensors_get_feature(*name,SENSORS_VT8231_IN4_MAX,&max)) {
4103	if (valid) {
4104	print_label(label,10);
4105	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4106	cur,min,max,alarms&VT8231_ALARM_IN4?"ALARM":"");
4107	}
4108	} else
4109	printf("ERROR: Can't get IN4 data!\n");
4110	free_the_label(&label);
4111	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN5,&label,&valid) &&
4112	!sensors_get_feature(*name,SENSORS_VT8231_IN5,&cur) &&
4113	!sensors_get_feature(*name,SENSORS_VT8231_IN5_MIN,&min) &&
4114	!sensors_get_feature(*name,SENSORS_VT8231_IN5_MAX,&max)) {
4115	if (valid) {
4116	print_label(label,10);
4117	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4118	cur,min,max,alarms&VT8231_ALARM_IN5?"ALARM":"");
4119	}
4120	} else
4121	printf("ERROR: Can't get IN5 data!\n");
4122	free_the_label(&label);
4123	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN6,&label,&valid) &&
4124	!sensors_get_feature(*name,SENSORS_VT8231_IN6,&cur) &&
4125	!sensors_get_feature(*name,SENSORS_VT8231_IN6_MIN,&min) &&
4126	!sensors_get_feature(*name,SENSORS_VT8231_IN6_MAX,&max)) {
4127	if (valid) {
4128	print_label(label,10);
4129	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4130	cur,min,max,alarms&VT8231_ALARM_IN6?"ALARM":"");
4131	}
4132	} else
4133	printf("ERROR: Can't get IN6 data!\n");
4134	free_the_label(&label);
4135
4136	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_FAN1,&label,&valid) &&
4137	!sensors_get_feature(*name,SENSORS_VT8231_FAN1,&cur) &&
4138	!sensors_get_feature(*name,SENSORS_VT8231_FAN1_DIV,&fdiv) &&
4139	!sensors_get_feature(*name,SENSORS_VT8231_FAN1_MIN,&min)) {
4140	if (valid) {
4141	print_label(label,10);
4142	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4143	cur,min,fdiv, alarms&VT8231_ALARM_FAN1?"ALARM":"");
4144	}
4145	} else
4146	printf("ERROR: Can't get FAN1 data!\n");
4147	free_the_label(&label);
4148	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_FAN2,&label,&valid) &&
4149	!sensors_get_feature(*name,SENSORS_VT8231_FAN2,&cur) &&
4150	!sensors_get_feature(*name,SENSORS_VT8231_FAN2_DIV,&fdiv) &&
4151	!sensors_get_feature(*name,SENSORS_VT8231_FAN2_MIN,&min)) {
4152	if (valid) {
4153	print_label(label,10);
4154	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4155	cur,min,fdiv, alarms&VT8231_ALARM_FAN2?"ALARM":"");
4156	}
4157	} else
4158	printf("ERROR: Can't get FAN2 data!\n");
4159	free_the_label(&label);
4160
4161	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP,&label,&valid) &&
4162	!sensors_get_feature(*name,SENSORS_VT8231_TEMP,&cur) &&
4163	!sensors_get_feature(*name,SENSORS_VT8231_TEMP_HYST,&min) &&
4164	!sensors_get_feature(*name,SENSORS_VT8231_TEMP_OVER,&max)) {
4165	if (valid) {
4166	print_label(label,10);
4167	print_temp_info( cur, max, min, HYST, 1, 0);
4168	printf(" %s\n", alarms & VT8231_ALARM_TEMP ? "ALARM" : "" );
4169	}
4170	} else
4171	printf("ERROR: Can't get TEMP data!\n");
4172	free_the_label(&label);
4173	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP2,&label,&valid) &&
4174	!sensors_get_feature(*name,SENSORS_VT8231_TEMP2,&cur) &&
4175	!sensors_get_feature(*name,SENSORS_VT8231_TEMP2_HYST,&min) &&
4176	!sensors_get_feature(*name,SENSORS_VT8231_TEMP2_OVER,&max)) {
4177	if (valid) {
4178	print_label(label,10);
4179	print_temp_info( cur, max, min, HYST, 1, 0);
4180	printf(" %s\n", alarms & VT8231_ALARM_TEMP2 ? "ALARM" : "" );
4181	}
4182	} else
4183	printf("ERROR: Can't get TEMP2 data!\n");
4184	free_the_label(&label);
4185	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP3,&label,&valid) &&
4186	!sensors_get_feature(*name,SENSORS_VT8231_TEMP3,&cur) &&
4187	!sensors_get_feature(*name,SENSORS_VT8231_TEMP3_HYST,&min) &&
4188	!sensors_get_feature(*name,SENSORS_VT8231_TEMP3_OVER,&max)) {
4189	if (valid) {
4190	print_label(label,10);
4191	print_temp_info( cur, max, min, HYST, 1, 0);
4192	printf(" %s\n", alarms & VT8231_ALARM_TEMP3 ? "ALARM" : "" );
4193	}
4194	} else
4195	printf("ERROR: Can't get TEMP3 data!\n");
4196	free_the_label(&label);
4197	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP4,&label,&valid) &&
4198	!sensors_get_feature(*name,SENSORS_VT8231_TEMP4,&cur) &&
4199	!sensors_get_feature(*name,SENSORS_VT8231_TEMP4_HYST,&min) &&
4200	!sensors_get_feature(*name,SENSORS_VT8231_TEMP4_OVER,&max)) {
4201	if (valid) {
4202	print_label(label,10);
4203	print_temp_info( cur, max, min, HYST, 1, 0);
4204	printf(" %s\n", alarms & VT8231_ALARM_TEMP4 ? "ALARM" : "" );
4205	}
4206	} else
4207	printf("ERROR: Can't get TEMP4 data!\n");
4208	free_the_label(&label);
4209	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP5,&label,&valid) &&
4210	!sensors_get_feature(*name,SENSORS_VT8231_TEMP5,&cur) &&
4211	!sensors_get_feature(*name,SENSORS_VT8231_TEMP5_HYST,&min) &&
4212	!sensors_get_feature(*name,SENSORS_VT8231_TEMP5_OVER,&max)) {
4213	if (valid) {
4214	print_label(label,10);
4215	print_temp_info( cur, max, min, HYST, 1, 0);
4216	printf(" %s\n", alarms & VT8231_ALARM_TEMP5 ? "ALARM" : "" );
4217	}
4218	} else
4219	printf("ERROR: Can't get TEMP5 data!\n");
4220	free_the_label(&label);
4221	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP6,&label,&valid) &&
4222	!sensors_get_feature(*name,SENSORS_VT8231_TEMP6,&cur) &&
4223	!sensors_get_feature(*name,SENSORS_VT8231_TEMP6_HYST,&min) &&
4224	!sensors_get_feature(*name,SENSORS_VT8231_TEMP6_OVER,&max)) {
4225	if (valid) {
4226	print_label(label,10);
4227	print_temp_info( cur, max, min, HYST, 1, 0);
4228	printf(" %s\n", alarms & VT8231_ALARM_TEMP6 ? "ALARM" : "" );
4229	}
4230	} else
4231	printf("ERROR: Can't get TEMP6 data!\n");
4232	free_the_label(&label);
4233	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP7,&label,&valid) &&
4234	!sensors_get_feature(*name,SENSORS_VT8231_TEMP7,&cur) &&
4235	!sensors_get_feature(*name,SENSORS_VT8231_TEMP7_HYST,&min) &&
4236	!sensors_get_feature(*name,SENSORS_VT8231_TEMP7_OVER,&max)) {
4237	if (valid) {
4238	print_label(label,10);
4239	print_temp_info( cur, max, min, HYST, 1, 0);
4240	printf(" %s\n", alarms & VT8231_ALARM_TEMP7 ? "ALARM" : "" );
4241	}
4242	} else
4243	printf("ERROR: Can't get TEMP7 data!\n");
4244	free_the_label(&label);
4245
4246	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_VID,&label,&valid) &&
4247	!sensors_get_feature(*name,SENSORS_VT8231_VID,&cur)) {
4248	if (valid) {
4249	print_label(label,10);
4250	printf("%+6.2f V\n",cur);
4251	}
4252	}
4253	free_the_label(&label);
4254
4255	}
4256
4257	#define BMC_MAX_INS 10
4258	#define BMC_MAX_FANS 10
4259	#define BMC_MAX_TEMPS 10
4260
4261	void print_bmc(const sensors_chip_name *name)
4262	{
4263	char *label = NULL;
4264	double cur,min,max;
4265	int alarms, valid, i;
4266
4267	/*
4268	if (!sensors_get_feature(*name,SENSORS_VT8231_ALARMS,&cur))
4269	alarms = cur + 0.5;
4270	else {
4271	printf("ERROR: Can't get alarm data!\n");
4272	alarms = 0;
4273	}
4274	*/
4275	#define BMC_ALARM_IN1 0
4276	#define BMC_ALARM_FAN1 0
4277	#define BMC_ALARM_TEMP1 0
4278
4279	alarms = 0;
4280	for(i = 0; i < BMC_MAX_INS; i++) {
4281	if (!sensors_get_label_and_valid(*name,SENSORS_BMC_IN1+i,&label,&valid) &&
4282	!sensors_get_feature(*name,SENSORS_BMC_IN1+i,&cur) &&
4283	!sensors_get_feature(*name,SENSORS_BMC_IN1_MIN+i,&min) &&
4284	!sensors_get_feature(*name,SENSORS_BMC_IN1_MAX+i,&max)) {
4285	if (valid) {
4286	print_label(label,10);
4287	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4288	cur,min,max,alarms&BMC_ALARM_IN1?"ALARM":"");
4289	}
4290	}
4291	free_the_label(&label);
4292	}
4293
4294	for(i = 0; i < BMC_MAX_FANS; i++) {
4295	if (!sensors_get_label_and_valid(*name,SENSORS_BMC_FAN1+i,&label,&valid) &&
4296	!sensors_get_feature(*name,SENSORS_BMC_FAN1+i,&cur) &&
4297	!sensors_get_feature(*name,SENSORS_BMC_FAN1_MIN+i,&min)) {
4298	if (valid) {
4299	print_label(label,10);
4300	printf("%4.0f RPM (min = %4.0f RPM) %s\n",
4301	cur,min,alarms&BMC_ALARM_FAN1?"ALARM":"");
4302	}
4303	}
4304	free_the_label(&label);
4305	}
4306
4307	for(i = 0; i < BMC_MAX_TEMPS; i++) {
4308	if (!sensors_get_label_and_valid(*name,SENSORS_BMC_TEMP1+i,&label,&valid) &&
4309	!sensors_get_feature(*name,SENSORS_BMC_TEMP1+i,&cur) &&
4310	!sensors_get_feature(*name,SENSORS_BMC_TEMP1_MIN+i,&min) &&
4311	!sensors_get_feature(*name,SENSORS_BMC_TEMP1_MAX+i,&max)) {
4312	if (valid) {
4313	print_label(label,10);
4314	print_temp_info( cur, max, min, HYST, 1, 0);
4315	printf(" %s\n", alarms & BMC_ALARM_TEMP1 ? "ALARM" : "" );
4316	}
4317	}
4318	free_the_label(&label);
4319	}
4320	}
4321
4322	static long adm1026_alarms_in[] = {
4323	ADM1026_ALARM_IN0, ADM1026_ALARM_IN1, ADM1026_ALARM_IN2,
4324	ADM1026_ALARM_IN3, ADM1026_ALARM_IN4, ADM1026_ALARM_IN5,
4325	ADM1026_ALARM_IN6, ADM1026_ALARM_IN7, ADM1026_ALARM_IN8,
4326	ADM1026_ALARM_IN9, ADM1026_ALARM_IN10, ADM1026_ALARM_IN11,
4327	ADM1026_ALARM_IN12, ADM1026_ALARM_IN13, ADM1026_ALARM_IN14,
4328	ADM1026_ALARM_IN15, ADM1026_ALARM_IN16
4329	};
4330	static long adm1026_alarms_temp[] = {
4331	ADM1026_ALARM_TEMP1, ADM1026_ALARM_TEMP2, ADM1026_ALARM_TEMP3
4332	};
4333
4334	void print_adm1026(const sensors_chip_name *name)
4335	{
4336	char *label = NULL;
4337	double cur,min,max;
4338	long alarms;
4339	int valid, i;
4340
4341	if (!sensors_get_feature(*name,SENSORS_ADM1026_ALARMS,&cur)) {
4342	alarms = cur + 0.5;
4343	} else {
4344	printf("ERROR: Can't get alarm data!\n");
4345	alarms = 0;
4346	}
4347
4348	/* Seventeen voltage sensors */
4349	for (i = 0; i <= 16 ; ++i) {
4350	int feat_base = SENSORS_ADM1026_IN0 + (3 * i);
4351	int feat_max = feat_base +1, feat_min = feat_base +2;
4352	if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) &&
4353	!sensors_get_feature(*name,feat_base,&cur) &&
4354	!sensors_get_feature(*name,feat_min,&min) &&
4355	!sensors_get_feature(*name,feat_max,&max)) {
4356	if (valid) {
4357	print_label(label,10);
4358	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4359	cur,min,max,(alarms&adm1026_alarms_in[i])?"ALARM":"");
4360	}
4361	} else {
4362	printf("ERROR: Can't get IN%d data!\n",i);
4363	}
4364	free_the_label(&label);
4365	};
4366
4367	/* Eight fan sensors */
4368	for (i = 0; i <= 7 ; ++i) {
4369	int feat_base = SENSORS_ADM1026_FAN0 + (3 * i);
4370	int feat_div = feat_base +1, feat_min = feat_base +2;
4371	if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) &&
4372	!sensors_get_feature(*name,feat_base,&cur) &&
4373	!sensors_get_feature(*name,feat_min,&min) &&
4374	!sensors_get_feature(*name,feat_div,&max)) {
4375	if (valid) {
4376	print_label(label,10);
4377	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4378	cur,min,max,(alarms&(ADM1026_ALARM_FAN0<<i))?"ALARM":"");
4379	}
4380	} else {
4381	printf("ERROR: Can't get FAN%d data!\n",i);
4382	}
4383	free_the_label(&label);
4384	};
4385
4386	/* Three temperature sensors
4387	* NOTE: 6 config values per temperature
4388	* 0 current
4389	* 1 max
4390	* 2 min
4391	* 3 offset (to current)
4392	* 4 therm (SMBAlert)
4393	* 5 tmin (AFC)
4394	*/
4395	for (i = 0; i <= 2 ; ++i) {
4396	int feat_base = SENSORS_ADM1026_TEMP1 + (6 * i);
4397	int feat_max = feat_base +1;
4398	int feat_min = feat_base +2;
4399
4400	if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) &&
4401	!sensors_get_feature(*name,feat_base,&cur) &&
4402	!sensors_get_feature(*name,feat_min,&min) &&
4403	!sensors_get_feature(*name,feat_max,&max)) {
4404	if (valid) {
4405	print_label(label,10);
4406	print_temp_info( cur, max, min, MINMAX, 0, 0);
4407	puts( (alarms&adm1026_alarms_temp[i])?" ALARM":"" );
4408	}
4409	} else {
4410	printf("ERROR: Can't get TEMP%d data!\n",i+1);
4411	}
4412	free_the_label(&label);
4413	};
4414
4415	/* VID/VRM */
4416	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1026_VID,&label,&valid)
4417	&& !sensors_get_feature(*name,SENSORS_ADM1026_VID,&cur)
4418	&& !sensors_get_feature(*name,SENSORS_ADM1026_VRM,&min) ) {
4419	if (valid) {
4420	print_label(label,10);
4421	printf("%+6.3f V (VRM Version %4.1f)\n",cur,min);
4422	}
4423	}
4424	free_the_label(&label);
4425
4426	}
4427
4428	void print_lm83(const sensors_chip_name *name)
4429	{
4430	char *label;
4431	double cur,high,crit;
4432	int valid,alarms;
4433
4434	if (!sensors_get_feature(*name,SENSORS_LM83_ALARMS,&cur))
4435	alarms = cur + 0.5;
4436	else {
4437	printf("ERROR: Can't get alarm data!\n");
4438	alarms = 0;
4439	}
4440
4441	if (sensors_get_feature(*name,SENSORS_LM83_TCRIT,&crit)) {
4442	printf("ERROR: Can't get tcrit data!\n");
4443	crit = 127;
4444	}
4445
4446	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_LOCAL_TEMP,&label,&valid) &&
4447	!sensors_get_feature(*name,SENSORS_LM83_LOCAL_TEMP,&cur) &&
4448	!sensors_get_feature(*name,SENSORS_LM83_LOCAL_HIGH,&high)) {
4449	if (valid) {
4450	print_label(label,10);
4451	print_temp_info( cur, high, crit, CRIT, 0, 0);
4452	printf(" %s\n",
4453	alarms&LM83_ALARM_LOCAL_CRIT?"CRITICAL":
4454	alarms&LM83_ALARM_LOCAL_HIGH?"ALARM":"");
4455	}
4456	} else
4457	printf("ERROR: Can't get local temperature data!\n");
4458	free_the_label(&label);
4459
4460	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE1_TEMP,&label,&valid) &&
4461	!sensors_get_feature(*name,SENSORS_LM83_REMOTE1_TEMP,&cur) &&
4462	!sensors_get_feature(*name,SENSORS_LM83_REMOTE1_HIGH,&high)) {
4463	if (valid) {
4464	print_label(label,10);
4465	print_temp_info( cur, high, crit, CRIT, 0, 0);
4466	printf(" %s\n",
4467	alarms&LM83_ALARM_REMOTE1_OPEN?"DISCONNECT":
4468	alarms&LM83_ALARM_REMOTE1_CRIT?"CRITICAL":
4469	alarms&LM83_ALARM_REMOTE1_HIGH?"ALARM":"");
4470	}
4471	} else
4472	printf("ERROR: Can't get remote temperature 1 data!\n");
4473	free_the_label(&label);
4474
4475	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE2_TEMP,&label,&valid) &&
4476	!sensors_get_feature(*name,SENSORS_LM83_REMOTE2_TEMP,&cur) &&
4477	!sensors_get_feature(*name,SENSORS_LM83_REMOTE2_HIGH,&high)) {
4478	if (valid) {
4479	print_label(label,10);
4480	print_temp_info( cur, high, crit, CRIT, 0, 0);
4481	printf(" %s\n",
4482	alarms&LM83_ALARM_REMOTE2_OPEN?"DISCONNECT":
4483	alarms&LM83_ALARM_REMOTE2_CRIT?"CRITICAL":
4484	alarms&LM83_ALARM_REMOTE2_HIGH?"ALARM":"");
4485	}
4486	} else
4487	printf("ERROR: Can't get remote temperature 2 data!\n");
4488	free_the_label(&label);
4489
4490	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE3_TEMP,&label,&valid) &&
4491	!sensors_get_feature(*name,SENSORS_LM83_REMOTE3_TEMP,&cur) &&
4492	!sensors_get_feature(*name,SENSORS_LM83_REMOTE3_HIGH,&high)) {
4493	if (valid) {
4494	print_label(label,10);
4495	print_temp_info( cur, high, crit, CRIT, 0, 0);
4496	printf(" %s\n",
4497	alarms&LM83_ALARM_REMOTE3_OPEN?"DISCONNECT":
4498	alarms&LM83_ALARM_REMOTE3_CRIT?"CRITICAL":
4499	alarms&LM83_ALARM_REMOTE3_HIGH?"ALARM":"");
4500	}
4501	} else
4502	printf("ERROR: Can't get remote temperature 3 data!\n");
4503	free_the_label(&label);
4504	}
4505
4506	void print_lm90(const sensors_chip_name *name)
4507	{
4508	char *label;
4509	double cur, high, low, hyst;
4510	int valid, alarms;
4511
4512	if (!sensors_get_feature(*name, SENSORS_LM90_ALARMS, &cur))
4513	alarms = cur + 0.5;
4514	else {
4515	printf("ERROR: Can't get alarm data!\n");
4516	alarms = 0;
4517	}
4518
4519	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_LOCAL_TEMP,
4520	&label, &valid)
4521	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TEMP, &cur)
4522	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_HIGH, &high)
4523	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_LOW, &low)) {
4524	if (valid) {
4525	print_label(label, 10);
4526	print_temp_info(cur, high, low, MINMAX, 0, 0);
4527	printf(" %s\n",
4528	alarms&LM90_ALARM_LOCAL_CRIT?"CRITICAL":
4529	alarms&(LM90_ALARM_LOCAL_HIGH\|LM90_ALARM_LOCAL_LOW)?"ALARM":"");
4530	}
4531	} else
4532	printf("ERROR: Can't get local temperature data!\n");
4533	free_the_label(&label);
4534
4535	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_REMOTE_TEMP,
4536	&label, &valid)
4537	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TEMP, &cur)
4538	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_HIGH, &high)
4539	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_LOW, &low)) {
4540	if (valid) {
4541	print_label(label, 10);
4542	print_temp_info(cur, high, low, MINMAX, 1, 1);
4543	printf(" %s\n",
4544	alarms&LM90_ALARM_REMOTE_OPEN?"DISCONNECT":
4545	alarms&LM90_ALARM_REMOTE_CRIT?"CRITICAL":
4546	alarms&(LM90_ALARM_REMOTE_HIGH\|LM90_ALARM_REMOTE_LOW)?"ALARM":"");
4547	}
4548	} else
4549	printf("ERROR: Can't get remote temperature data!\n");
4550	free_the_label(&label);
4551
4552	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_LOCAL_TCRIT,
4553	&label, &valid)
4554	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TCRIT, &high)
4555	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TCRIT_HYST, &hyst)) {
4556	if (valid) {
4557	print_label(label, 10);
4558	print_temp_info(high, hyst, 0, HYSTONLY, 0, 0);
4559	printf("\n");
4560	}
4561	} else
4562	printf("ERROR: Can't get local tcrit data!\n");
4563	free_the_label(&label);
4564
4565	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_REMOTE_TCRIT,
4566	&label, &valid)
4567	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TCRIT, &high)
4568	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TCRIT_HYST, &hyst)) {
4569	if (valid) {
4570	print_label(label, 10);
4571	print_temp_info(high, hyst, 0, HYSTONLY, 0, 0);
4572	printf("\n");
4573	}
4574	} else
4575	printf("ERROR: Can't get remote tcrit data!\n");
4576	free_the_label(&label);
4577	}
4578
4579	void print_xeontemp(const sensors_chip_name *name)
4580	{
4581	char *label;
4582	double cur,hyst,over;
4583	int alarms,i,valid;
4584
4585	if (!sensors_get_feature(*name,SENSORS_XEONTEMP_ALARMS,&cur))
4586	alarms = cur + 0.5;
4587	else {
4588	printf("ERROR: Can't get alarm data!\n");
4589	alarms = 0;
4590	}
4591
4592	if (!sensors_get_label_and_valid(*name,SENSORS_XEONTEMP_REMOTE_TEMP,
4593	&label,&valid) &&
4594	!sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP,&cur) &&
4595	!sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP_HYST,&hyst) &&
4596	!sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP_OVER,&over)) {
4597	if (valid) {
4598	print_label(label,10);
4599	print_temp_info( cur, over, hyst, MINMAX, 0, 0);
4600	if (alarms & (XEONTEMP_ALARM_RTEMP_HIGH \| XEONTEMP_ALARM_RTEMP_LOW \|
4601	XEONTEMP_ALARM_RTEMP_NA)) {
4602	printf("ALARM (");
4603	i = 0;
4604	if (alarms & XEONTEMP_ALARM_RTEMP_NA) {
4605	printf("N/A");
4606	i++;
4607	}
4608	if (alarms & XEONTEMP_ALARM_RTEMP_LOW) {
4609	printf("%sLOW",i?",":"");
4610	i++;
4611	}
4612	if (alarms & XEONTEMP_ALARM_RTEMP_HIGH)
4613	printf("%sHIGH",i?",":"");
4614	printf(")");
4615	}
4616	printf("\n");
4617	}
4618	} else
4619	printf("ERROR: Can't get temperature data!\n");
4620	free_the_label(&label);
4621	}
4622
4623	void print_max6650(const sensors_chip_name *name)
4624	{
4625	char *label = NULL;
4626	double tach, speed;
4627	int valid, i;
4628
4629	static const struct
4630	{
4631	int tag;
4632	char *name;
4633	}
4634	tach_list[] =
4635	{
4636	{ SENSORS_MAX6650_FAN1_TACH, "FAN1" },
4637	{ SENSORS_MAX6650_FAN2_TACH, "FAN2" },
4638	{ SENSORS_MAX6650_FAN3_TACH, "FAN3" },
4639	{ SENSORS_MAX6650_FAN4_TACH, "FAN4" }
4640	};
4641
4642	/* Display full config for fan1, which is controlled */
4643
4644	if (!sensors_get_label_and_valid(*name,tach_list[0].tag,&label,&valid) &&
4645	!sensors_get_feature(*name,tach_list[0].tag,&tach) &&
4646	!sensors_get_feature(*name,SENSORS_MAX6650_SPEED,&speed)) {
4647	if (valid) {
4648	print_label(label,10);
4649	printf("configured %4.0f RPM, actual %4.0f RPM.\n", speed, tach);
4650	}
4651	} else
4652	printf("ERROR: Can't get %s data!