Context Navigation

chips.c @ 1950

Revision 1950, 161.3 KB (checked in by khali, 10 years ago)

Change Sony Vaio EEPROMs detection procedure. This should

prevent EEPROMs with a password set from being randomly
detected as regular memory chips.

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

Note: See TracBrowser for help on using the browser.

Context Navigation

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

Download in other formats: