Context Navigation

chips.c @ 3311

Revision 3311, 209.2 KB (checked in by khali, 4 years ago)
Let the user know that eeprom support is going away soon.
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 "lib/error.h"
29	#include "kernel/include/sensors.h"
30
31	static void print_label(const char *label, int space);
32	static void print_temp_info(float, float, float, int, int, int);
33	static inline float deg_ctof( float );
34
35	extern int fahrenheit;
36	extern char degstr[5];
37
38	inline float deg_ctof( float cel )
39	{
40	return ( cel * ( 9.0F / 5.0F ) + 32.0F );
41	}
42
43	#define HYST 0
44	#define MINMAX 1
45	#define MAXONLY 2
46	#define CRIT 3
47	#define SINGLE 4
48	#define HYSTONLY 5
49	/* minmax = 0 for limit/hysteresis, 1 for max/min, 2 for max only;
50	curprec and limitprec are # of digits after decimal point
51	for the current temp and the limits */
52	void print_temp_info(float n_cur, float n_over, float n_hyst,
53	int minmax, int curprec, int limitprec)
54	{
55	if (fahrenheit) {
56	n_cur = deg_ctof(n_cur);
57	n_over = deg_ctof(n_over);
58	n_hyst = deg_ctof(n_hyst);
59	}
60
61	/* use %* to pass precision as an argument */
62	if(minmax == MINMAX)
63	printf("%+6.f%s (low = %+5.f%s, high = %+5.*f%s) ",
64	curprec, n_cur, degstr,
65	limitprec, n_hyst, degstr,
66	limitprec, n_over, degstr);
67	else if(minmax == MAXONLY)
68	printf("%+6.f%s (high = %+5.f%s) ",
69	curprec, n_cur, degstr,
70	limitprec, n_over, degstr);
71	else if(minmax == CRIT)
72	printf("%+6.f%s (high = %+5.f%s, crit = %+5.*f%s) ",
73	curprec, n_cur, degstr,
74	limitprec, n_over, degstr,
75	limitprec, n_hyst, degstr);
76	else if(minmax == HYST)
77	printf("%+6.f%s (high = %+5.f%s, hyst = %+5.*f%s) ",
78	curprec, n_cur, degstr,
79	limitprec, n_over, degstr,
80	limitprec, n_hyst, degstr);
81	else if(minmax == SINGLE)
82	printf("%+6.*f%s",
83	curprec, n_cur, degstr);
84	else if(minmax == HYSTONLY)
85	printf( "%+6.f%s (hyst = %+5.f%s) ",
86	curprec, n_cur, degstr,
87	limitprec, n_over, degstr);
88	else
89	printf("Unknown temperature mode!");
90	}
91
92	void print_label(const char *label, int space)
93	{
94	int len=strlen(label)+1;
95	if (len > space)
96	printf("%s:\n%*s", label, space, "");
97	else
98	printf("%s:%*s", label, space - len, "");
99	}
100
101	int sensors_get_label_and_valid(sensors_chip_name name, int feature, char **label,
102	int *valid)
103	{
104	int err;
105	err = sensors_get_label(name,feature,label);
106	if (!err)
107	err = sensors_get_ignored(name,feature);
108	if (err >= 0) {
109	*valid = err;
110	err = 0;
111	}
112	return err;
113	}
114
115	void print_vid_info(const sensors_chip_name *name, int f_vid, int f_vrm)
116	{
117	char *label;
118	int valid;
119	double vid, vrm;
120
121	if (!sensors_get_label_and_valid(*name,f_vid,&label,&valid)
122	&& !sensors_get_feature(*name,f_vid,&vid) ) {
123	if (valid) {
124	print_label(label,10);
125	if(!sensors_get_feature(*name,f_vrm,&vrm))
126	printf("%+6.3f V (VRM Version %.1f)\n",vid,vrm);
127	else
128	printf("%+6.3f V\n",vid);
129	}
130	}
131	free(label);
132	}
133
134	/* Chip-specific print routines start here */
135
136	void print_ds1621(const sensors_chip_name *name)
137	{
138	char *label;
139	double cur,hyst,over;
140	int alarms, valid;
141
142	if (!sensors_get_feature(*name,SENSORS_DS1621_ALARMS,&cur))
143	alarms = cur + 0.5;
144	else {
145	printf("ERROR: Can't get alarm data!\n");
146	alarms = 0;
147	}
148
149	if (!sensors_get_label_and_valid(*name,SENSORS_DS1621_TEMP,&label,&valid) &&
150	!sensors_get_feature(*name,SENSORS_DS1621_TEMP,&cur) &&
151	!sensors_get_feature(*name,SENSORS_DS1621_TEMP_HYST,&hyst) &&
152	!sensors_get_feature(*name,SENSORS_DS1621_TEMP_OVER,&over)) {
153	if (valid) {
154	print_label(label,10);
155	print_temp_info( cur, over, hyst, MINMAX, 2, 1);
156	if (alarms & (DS1621_ALARM_TEMP_HIGH \| DS1621_ALARM_TEMP_LOW)) {
157	printf("ALARM (");
158	if (alarms & DS1621_ALARM_TEMP_LOW) {
159	printf("LOW");
160	}
161	if (alarms & DS1621_ALARM_TEMP_HIGH)
162	printf("%sHIGH",(alarms & DS1621_ALARM_TEMP_LOW)?",":"");
163	printf(")");
164	}
165	printf("\n");
166	}
167	} else
168	printf("ERROR: Can't get temperature data!\n");
169	free(label);
170	}
171
172	void print_lm75(const sensors_chip_name *name)
173	{
174	char *label;
175	double cur,hyst,over;
176	int valid;
177
178	if (!sensors_get_label_and_valid(*name,SENSORS_LM75_TEMP,&label,&valid) &&
179	!sensors_get_feature(*name,SENSORS_LM75_TEMP,&cur) &&
180	!sensors_get_feature(*name,SENSORS_LM75_TEMP_HYST,&hyst) &&
181	!sensors_get_feature(*name,SENSORS_LM75_TEMP_OVER,&over)) {
182	if (valid) {
183	print_label(label,10);
184	print_temp_info( cur, over, hyst, HYST, 1, 1);
185	printf( "\n" );
186	}
187	} else
188	printf("ERROR: Can't get temperature data!\n");
189	free(label);
190	}
191
192	void print_adm1021(const sensors_chip_name *name)
193	{
194	char *label;
195	double cur,hyst,over;
196	int alarms,i,valid;
197
198	if (!sensors_get_feature(*name,SENSORS_ADM1021_ALARMS,&cur))
199	alarms = cur + 0.5;
200	else {
201	printf("ERROR: Can't get alarm data!\n");
202	alarms = 0;
203	}
204
205	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1021_TEMP,&label,&valid) &&
206	!sensors_get_feature(*name,SENSORS_ADM1021_TEMP,&cur) &&
207	!sensors_get_feature(*name,SENSORS_ADM1021_TEMP_HYST,&hyst) &&
208	!sensors_get_feature(*name,SENSORS_ADM1021_TEMP_OVER,&over)) {
209	if (valid) {
210	print_label(label,10);
211	print_temp_info( cur, over, hyst, MINMAX, 0, 0);
212	if (alarms & (ADM1021_ALARM_TEMP_HIGH \| ADM1021_ALARM_TEMP_LOW)) {
213	printf("ALARM (");
214	i = 0;
215	if (alarms & ADM1021_ALARM_TEMP_LOW) {
216	printf("LOW");
217	i++;
218	}
219	if (alarms & ADM1021_ALARM_TEMP_HIGH)
220	printf("%sHIGH",i?",":"");
221	printf(")");
222	}
223	printf("\n");
224	}
225	} else
226	printf("ERROR: Can't get temperature data!\n");
227	free(label);
228
229	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1021_REMOTE_TEMP,
230	&label,&valid) &&
231	!sensors_get_feature(*name,SENSORS_ADM1021_REMOTE_TEMP,&cur) &&
232	!sensors_get_feature(*name,SENSORS_ADM1021_REMOTE_TEMP_HYST,&hyst) &&
233	!sensors_get_feature(*name,SENSORS_ADM1021_REMOTE_TEMP_OVER,&over)) {
234	if (valid) {
235	print_label(label,10);
236	print_temp_info( cur, over, hyst, MINMAX, 0, 0);
237	if (alarms & (ADM1021_ALARM_RTEMP_HIGH \| ADM1021_ALARM_RTEMP_LOW \|
238	ADM1021_ALARM_RTEMP_NA)) {
239	printf("ALARM (");
240	i = 0;
241	if (alarms & ADM1021_ALARM_RTEMP_NA) {
242	printf("N/A");
243	i++;
244	}
245	if (alarms & ADM1021_ALARM_RTEMP_LOW) {
246	printf("%sLOW",i?",":"");
247	i++;
248	}
249	if (alarms & ADM1021_ALARM_RTEMP_HIGH)
250	printf("%sHIGH",i?",":"");
251	printf(")");
252	}
253	printf("\n");
254	}
255	} else
256	printf("ERROR: Can't get temperature data!\n");
257	free(label);
258
259	if (!strcmp(name->prefix,"adm1021")) {
260	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1021_DIE_CODE,
261	&label,&valid) &&
262	!sensors_get_feature(*name,SENSORS_ADM1021_DIE_CODE,&cur)) {
263	if (valid) {
264	print_label(label,10);
265	printf("%4.0f\n",cur);
266	}
267	} else
268	printf("ERROR: Can't get die-code data!\n");
269	free(label);
270	}
271	}
272
273	void print_adm9240(const sensors_chip_name *name)
274	{
275	char *label;
276	double cur,min,max,fdiv;
277	int alarms;
278	int valid;
279
280	if (!sensors_get_feature(*name,SENSORS_ADM9240_ALARMS,&cur))
281	alarms = cur + 0.5;
282	else {
283	printf("ERROR: Can't get alarm data!\n");
284	alarms = 0;
285	}
286
287	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN0,&label,&valid) &&
288	!sensors_get_feature(*name,SENSORS_ADM9240_IN0,&cur) &&
289	!sensors_get_feature(*name,SENSORS_ADM9240_IN0_MIN,&min) &&
290	!sensors_get_feature(*name,SENSORS_ADM9240_IN0_MAX,&max)) {
291	if (valid) {
292	print_label(label,10);
293	printf( "%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
294	cur,min,max,alarms&ADM9240_ALARM_IN0?"ALARM":"");
295	}
296	} else
297	printf("ERROR: Can't get IN0 data!\n");
298	free(label);
299	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN1,&label,&valid) &&
300	!sensors_get_feature(*name,SENSORS_ADM9240_IN1,&cur) &&
301	!sensors_get_feature(*name,SENSORS_ADM9240_IN1_MIN,&min) &&
302	!sensors_get_feature(*name,SENSORS_ADM9240_IN1_MAX,&max)) {
303	if (valid) {
304	print_label(label,10);
305	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
306	cur,min,max,alarms&ADM9240_ALARM_IN1?"ALARM":"");
307	}
308	} else
309	printf("ERROR: Can't get IN1 data!\n");
310	free(label);
311	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN2,&label,&valid) &&
312	!sensors_get_feature(*name,SENSORS_ADM9240_IN2,&cur) &&
313	!sensors_get_feature(*name,SENSORS_ADM9240_IN2_MIN,&min) &&
314	!sensors_get_feature(*name,SENSORS_ADM9240_IN2_MAX,&max)) {
315	if (valid) {
316	print_label(label,10);
317	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
318	cur,min,max,alarms&ADM9240_ALARM_IN2?"ALARM":"");
319	}
320	} else
321	printf("ERROR: Can't get IN2 data!\n");
322	free(label);
323	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN3,&label,&valid) &&
324	!sensors_get_feature(*name,SENSORS_ADM9240_IN3,&cur) &&
325	!sensors_get_feature(*name,SENSORS_ADM9240_IN3_MIN,&min) &&
326	!sensors_get_feature(*name,SENSORS_ADM9240_IN3_MAX,&max)) {
327	if (valid) {
328	print_label(label,10);
329	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
330	cur,min,max,alarms&ADM9240_ALARM_IN3?"ALARM":"");
331	}
332	} else
333	printf("ERROR: Can't get IN3 data!\n");
334	free(label);
335	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN4,&label,&valid) &&
336	!sensors_get_feature(*name,SENSORS_ADM9240_IN4,&cur) &&
337	!sensors_get_feature(*name,SENSORS_ADM9240_IN4_MIN,&min) &&
338	!sensors_get_feature(*name,SENSORS_ADM9240_IN4_MAX,&max)) {
339	if (valid) {
340	print_label(label,10);
341	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
342	cur,min,max,alarms&ADM9240_ALARM_IN4?"ALARM":"");
343	}
344	} else
345	printf("ERROR: Can't get IN4 data!\n");
346	free(label);
347	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_IN5,&label,&valid) &&
348	!sensors_get_feature(*name,SENSORS_ADM9240_IN5,&cur) &&
349	!sensors_get_feature(*name,SENSORS_ADM9240_IN5_MIN,&min) &&
350	!sensors_get_feature(*name,SENSORS_ADM9240_IN5_MAX,&max)) {
351	if (valid) {
352	print_label(label,10);
353	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
354	cur,min,max,alarms&ADM9240_ALARM_IN5?"ALARM":"");
355	}
356	} else
357	printf("ERROR: Can't get IN5 data!\n");
358	free(label);
359
360	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_FAN1,&label,&valid) &&
361	!sensors_get_feature(*name,SENSORS_ADM9240_FAN1,&cur) &&
362	!sensors_get_feature(*name,SENSORS_ADM9240_FAN1_DIV,&fdiv) &&
363	!sensors_get_feature(*name,SENSORS_ADM9240_FAN1_MIN,&min)) {
364	if (valid) {
365	print_label(label,10);
366	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
367	cur,min,fdiv, alarms&ADM9240_ALARM_FAN1?"ALARM":"");
368	}
369	} else
370	printf("ERROR: Can't get FAN1 data!\n");
371	free(label);
372	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_FAN2,&label,&valid) &&
373	!sensors_get_feature(*name,SENSORS_ADM9240_FAN2,&cur) &&
374	!sensors_get_feature(*name,SENSORS_ADM9240_FAN2_DIV,&fdiv) &&
375	!sensors_get_feature(*name,SENSORS_ADM9240_FAN2_MIN,&min)) {
376	if (valid) {
377	print_label(label,10);
378	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
379	cur,min,fdiv, alarms&ADM9240_ALARM_FAN2?"ALARM":"");
380	}
381	} else
382	printf("ERROR: Can't get FAN2 data!\n");
383	free(label);
384
385	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_TEMP,&label,&valid) &&
386	!sensors_get_feature(*name,SENSORS_ADM9240_TEMP,&cur) &&
387	!sensors_get_feature(*name,SENSORS_ADM9240_TEMP_HYST,&min) &&
388	!sensors_get_feature(*name,SENSORS_ADM9240_TEMP_OVER,&max)) {
389	if (valid) {
390	print_label(label,10);
391	print_temp_info( cur, max, min, HYST, 1, 0);
392	printf( " %s\n", alarms & ADM9240_ALARM_TEMP ? "ALARM" : "" );
393	}
394	} else
395	printf("ERROR: Can't get TEMP data!\n");
396	free(label);
397
398	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_VID,&label,&valid) &&
399	!sensors_get_feature(*name,SENSORS_ADM9240_VID,&cur)) {
400	if (valid) {
401	print_label(label,10);
402	printf("%+6.2f V\n",cur);
403	}
404	}
405	free(label);
406
407	if (!sensors_get_label_and_valid(*name,SENSORS_ADM9240_ALARMS,&label,&valid)) {
408	if (valid) {
409	print_label(label,10);
410	if(alarms & ADM9240_ALARM_CHAS)
411	printf("Chassis intrusion detection ALARM\n");
412	else
413	printf("\n");
414	}
415	}
416	free(label);
417	}
418
419	void print_adm1024(const sensors_chip_name *name)
420	{
421	char *label;
422	double cur,min,max,fdiv;
423	int alarms;
424	int valid;
425
426	if (!sensors_get_feature(*name,SENSORS_ADM1024_ALARMS,&cur))
427	alarms = cur + 0.5;
428	else {
429	printf("ERROR: Can't get alarm data!\n");
430	alarms = 0;
431	}
432
433	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN0,&label,&valid) &&
434	!sensors_get_feature(*name,SENSORS_ADM1024_IN0,&cur) &&
435	!sensors_get_feature(*name,SENSORS_ADM1024_IN0_MIN,&min) &&
436	!sensors_get_feature(*name,SENSORS_ADM1024_IN0_MAX,&max)) {
437	if (valid) {
438	print_label(label,10);
439	printf( "%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
440	cur,min,max,alarms&ADM1024_ALARM_IN0?"ALARM":"");
441	}
442	} else
443	printf("ERROR: Can't get IN0 data!\n");
444	free(label);
445	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN1,&label,&valid) &&
446	!sensors_get_feature(*name,SENSORS_ADM1024_IN1,&cur) &&
447	!sensors_get_feature(*name,SENSORS_ADM1024_IN1_MIN,&min) &&
448	!sensors_get_feature(*name,SENSORS_ADM1024_IN1_MAX,&max)) {
449	if (valid) {
450	print_label(label,10);
451	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
452	cur,min,max,alarms&ADM1024_ALARM_IN1?"ALARM":"");
453	}
454	} else
455	printf("ERROR: Can't get IN1 data!\n");
456	free(label);
457	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN2,&label,&valid) &&
458	!sensors_get_feature(*name,SENSORS_ADM1024_IN2,&cur) &&
459	!sensors_get_feature(*name,SENSORS_ADM1024_IN2_MIN,&min) &&
460	!sensors_get_feature(*name,SENSORS_ADM1024_IN2_MAX,&max)) {
461	if (valid) {
462	print_label(label,10);
463	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
464	cur,min,max,alarms&ADM1024_ALARM_IN2?"ALARM":"");
465	}
466	} else
467	printf("ERROR: Can't get IN2 data!\n");
468	free(label);
469	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN3,&label,&valid) &&
470	!sensors_get_feature(*name,SENSORS_ADM1024_IN3,&cur) &&
471	!sensors_get_feature(*name,SENSORS_ADM1024_IN3_MIN,&min) &&
472	!sensors_get_feature(*name,SENSORS_ADM1024_IN3_MAX,&max)) {
473	if (valid) {
474	print_label(label,10);
475	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
476	cur,min,max,alarms&ADM1024_ALARM_IN3?"ALARM":"");
477	}
478	} else
479	printf("ERROR: Can't get IN3 data!\n");
480	free(label);
481	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN4,&label,&valid) &&
482	!sensors_get_feature(*name,SENSORS_ADM1024_IN4,&cur) &&
483	!sensors_get_feature(*name,SENSORS_ADM1024_IN4_MIN,&min) &&
484	!sensors_get_feature(*name,SENSORS_ADM1024_IN4_MAX,&max)) {
485	if (valid) {
486	print_label(label,10);
487	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
488	cur,min,max,alarms&ADM1024_ALARM_IN4?"ALARM":"");
489	}
490	} else
491	printf("ERROR: Can't get IN4 data!\n");
492	free(label);
493	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_IN5,&label,&valid) &&
494	!sensors_get_feature(*name,SENSORS_ADM1024_IN5,&cur) &&
495	!sensors_get_feature(*name,SENSORS_ADM1024_IN5_MIN,&min) &&
496	!sensors_get_feature(*name,SENSORS_ADM1024_IN5_MAX,&max)) {
497	if (valid) {
498	print_label(label,10);
499	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
500	cur,min,max,alarms&ADM1024_ALARM_IN5?"ALARM":"");
501	}
502	} else
503	printf("ERROR: Can't get IN5 data!\n");
504	free(label);
505
506	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_FAN1,&label,&valid) &&
507	!sensors_get_feature(*name,SENSORS_ADM1024_FAN1,&cur) &&
508	!sensors_get_feature(*name,SENSORS_ADM1024_FAN1_DIV,&fdiv) &&
509	!sensors_get_feature(*name,SENSORS_ADM1024_FAN1_MIN,&min)) {
510	if (valid) {
511	print_label(label,10);
512	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
513	cur,min,fdiv, alarms&ADM1024_ALARM_FAN1?"ALARM":"");
514	}
515	} else
516	printf("ERROR: Can't get FAN1 data!\n");
517	free(label);
518	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_FAN2,&label,&valid) &&
519	!sensors_get_feature(*name,SENSORS_ADM1024_FAN2,&cur) &&
520	!sensors_get_feature(*name,SENSORS_ADM1024_FAN2_DIV,&fdiv) &&
521	!sensors_get_feature(*name,SENSORS_ADM1024_FAN2_MIN,&min)) {
522	if (valid) {
523	print_label(label,10);
524	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
525	cur,min,fdiv, alarms&ADM1024_ALARM_FAN2?"ALARM":"");
526	}
527	} else
528	printf("ERROR: Can't get FAN2 data!\n");
529	free(label);
530
531	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_TEMP,&label,&valid) &&
532	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP,&cur) &&
533	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP_HYST,&min) &&
534	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP_OVER,&max)) {
535	if (valid) {
536	print_label(label,10);
537	print_temp_info( cur, min, max, HYST, 1, 0);
538	printf( " %s\n", alarms & ADM1024_ALARM_TEMP ? "ALARM" : "" );
539	}
540	} else
541	printf("ERROR: Can't get TEMP data!\n");
542	free(label);
543
544	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_TEMP1,&label,&valid) &&
545	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP1,&cur) &&
546	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP1_HYST,&min) &&
547	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP1_OVER,&max)) {
548	if (valid) {
549	print_label(label,10);
550	print_temp_info( cur, min, max, HYST, 1, 0);
551	printf( " %s\n", alarms & ADM1024_ALARM_TEMP1 ? "ALARM" : "" );
552	}
553	} else
554	printf("ERROR: Can't get TEMP1 data!\n");
555	free(label);
556
557	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_TEMP2,&label,&valid) &&
558	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP2,&cur) &&
559	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP2_HYST,&min) &&
560	!sensors_get_feature(*name,SENSORS_ADM1024_TEMP2_OVER,&max)) {
561	if (valid) {
562	print_label(label,10);
563	print_temp_info( cur, min, max, HYST, 1, 0);
564	printf( " %s\n", alarms & ADM1024_ALARM_TEMP2 ? "ALARM" : "" );
565	}
566	} else
567	printf("ERROR: Can't get TEMP2 data!\n");
568	free(label);
569
570	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_VID,&label,&valid) &&
571	!sensors_get_feature(*name,SENSORS_ADM1024_VID,&cur)) {
572	if (valid) {
573	print_label(label,10);
574	printf("%+6.2f V\n",cur);
575	}
576	}
577	free(label);
578
579	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1024_ALARMS,&label,&valid)) {
580	if (valid) {
581	print_label(label,10);
582	if(alarms & ADM1024_ALARM_CHAS)
583	printf("Chassis intrusion detection ALARM\n");
584	else
585	printf("\n");
586	}
587	}
588	free(label);
589	}
590
591	void print_sis5595(const sensors_chip_name *name)
592	{
593	char *label;
594	double cur,min,max,fdiv;
595	int alarms,valid;
596
597	if (!sensors_get_feature(*name,SENSORS_SIS5595_ALARMS,&cur))
598	alarms = cur + 0.5;
599	else {
600	printf("ERROR: Can't get alarm data!\n");
601	alarms = 0;
602	}
603
604	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN0,&label,&valid) &&
605	!sensors_get_feature(*name,SENSORS_SIS5595_IN0,&cur) &&
606	!sensors_get_feature(*name,SENSORS_SIS5595_IN0_MIN,&min) &&
607	!sensors_get_feature(*name,SENSORS_SIS5595_IN0_MAX,&max)) {
608	if (valid) {
609	print_label(label,10);
610	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
611	cur,min,max,alarms&SIS5595_ALARM_IN0?"ALARM":"");
612	}
613	} else
614	printf("ERROR: Can't get IN0 data!\n");
615	free(label);
616	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN1,&label,&valid) &&
617	!sensors_get_feature(*name,SENSORS_SIS5595_IN1,&cur) &&
618	!sensors_get_feature(*name,SENSORS_SIS5595_IN1_MIN,&min) &&
619	!sensors_get_feature(*name,SENSORS_SIS5595_IN1_MAX,&max)) {
620	if (valid) {
621	print_label(label,10);
622	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
623	cur,min,max,alarms&SIS5595_ALARM_IN1?"ALARM":"");
624	}
625	} else
626	printf("ERROR: Can't get IN1 data!\n");
627	free(label);
628	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN2,&label,&valid) &&
629	!sensors_get_feature(*name,SENSORS_SIS5595_IN2,&cur) &&
630	!sensors_get_feature(*name,SENSORS_SIS5595_IN2_MIN,&min) &&
631	!sensors_get_feature(*name,SENSORS_SIS5595_IN2_MAX,&max)) {
632	if (valid) {
633	print_label(label,10);
634	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
635	cur,min,max,alarms&SIS5595_ALARM_IN2?"ALARM":"");
636	}
637	} else
638	printf("ERROR: Can't get IN2 data!\n");
639	free(label);
640	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN3,&label,&valid) &&
641	!sensors_get_feature(*name,SENSORS_SIS5595_IN3,&cur) &&
642	!sensors_get_feature(*name,SENSORS_SIS5595_IN3_MIN,&min) &&
643	!sensors_get_feature(*name,SENSORS_SIS5595_IN3_MAX,&max)) {
644	if (valid) {
645	print_label(label,10);
646	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
647	cur,min,max,alarms&SIS5595_ALARM_IN3?"ALARM":"");
648	}
649	} else
650	printf("ERROR: Can't get IN3 data!\n");
651	free(label);
652	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_IN4,&label,&valid) &&
653	!sensors_get_feature(*name,SENSORS_SIS5595_IN4,&cur) &&
654	!sensors_get_feature(*name,SENSORS_SIS5595_IN4_MIN,&min) &&
655	!sensors_get_feature(*name,SENSORS_SIS5595_IN4_MAX,&max)) {
656	if (valid) {
657	print_label(label,10);
658	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
659	cur,min,max,alarms&SIS5595_ALARM_IN4?"ALARM":"");
660	}
661	} else
662	/* No error if IN4 is missing as it will happen with 2.6 kernels when
663	the chip is configured in 4 voltage + 1 temperature sensors. */
664	free(label);
665
666	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_FAN1,&label,&valid) &&
667	!sensors_get_feature(*name,SENSORS_SIS5595_FAN1,&cur) &&
668	!sensors_get_feature(*name,SENSORS_SIS5595_FAN1_DIV,&fdiv) &&
669	!sensors_get_feature(*name,SENSORS_SIS5595_FAN1_MIN,&min)) {
670	if (valid) {
671	print_label(label,10);
672	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
673	cur,min,fdiv, alarms&SIS5595_ALARM_FAN1?"ALARM":"");
674	}
675	} else
676	printf("ERROR: Can't get FAN1 data!\n");
677	free(label);
678	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_FAN2,&label,&valid) &&
679	!sensors_get_feature(*name,SENSORS_SIS5595_FAN2,&cur) &&
680	!sensors_get_feature(*name,SENSORS_SIS5595_FAN2_DIV,&fdiv) &&
681	!sensors_get_feature(*name,SENSORS_SIS5595_FAN2_MIN,&min)) {
682	if (valid) {
683	print_label(label,10);
684	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
685	cur,min,fdiv, alarms&SIS5595_ALARM_FAN2?"ALARM":"");
686	}
687	} else
688	printf("ERROR: Can't get FAN2 data!\n");
689	free(label);
690
691	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_TEMP,&label,&valid) &&
692	!sensors_get_feature(*name,SENSORS_SIS5595_TEMP,&cur) &&
693	!sensors_get_feature(*name,SENSORS_SIS5595_TEMP_HYST,&min) &&
694	!sensors_get_feature(*name,SENSORS_SIS5595_TEMP_OVER,&max)) {
695	if (valid) {
696	print_label(label,10);
697	print_temp_info( cur, max, min, HYST, 0, 0);
698	printf( " %s\n", alarms & SIS5595_ALARM_TEMP ? "ALARM" : "" );
699	}
700	} else
701	/* No error if TEMP is missing as it will happen with 2.6 kernels when
702	the chip is configured in 5 voltage sensors mode. */
703	free(label);
704
705	if (!sensors_get_label_and_valid(*name,SENSORS_SIS5595_ALARMS,&label,&valid)
706	&& valid) {
707	print_label(label,10);
708	printf("Board temperature input (usually LM75 chips) %s\n",
709	alarms & SIS5595_ALARM_BTI ?"ALARM":" ");
710	}
711	free(label);
712
713	}
714
715	void print_via686a(const sensors_chip_name *name)
716	{
717	char *label;
718	double cur,min,max,fdiv;
719	int alarms,valid;
720
721	if (!sensors_get_feature(*name,SENSORS_VIA686A_ALARMS,&cur))
722	alarms = cur + 0.5;
723	else {
724	printf("ERROR: Can't get alarm data!\n");
725	alarms = 0;
726	}
727
728	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN0,&label,&valid) &&
729	!sensors_get_feature(*name,SENSORS_VIA686A_IN0,&cur) &&
730	!sensors_get_feature(*name,SENSORS_VIA686A_IN0_MIN,&min) &&
731	!sensors_get_feature(*name,SENSORS_VIA686A_IN0_MAX,&max)) {
732	if (valid) {
733	print_label(label,10);
734	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
735	cur,min,max,alarms&VIA686A_ALARM_IN0?"ALARM":"");
736	}
737	} else
738	printf("ERROR: Can't get IN0 data!\n");
739	free(label);
740	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN1,&label,&valid) &&
741	!sensors_get_feature(*name,SENSORS_VIA686A_IN1,&cur) &&
742	!sensors_get_feature(*name,SENSORS_VIA686A_IN1_MIN,&min) &&
743	!sensors_get_feature(*name,SENSORS_VIA686A_IN1_MAX,&max)) {
744	if (valid) {
745	print_label(label,10);
746	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
747	cur,min,max,alarms&VIA686A_ALARM_IN1?"ALARM":"");
748	}
749	} else
750	printf("ERROR: Can't get IN1 data!\n");
751	free(label);
752	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN2,&label,&valid) &&
753	!sensors_get_feature(*name,SENSORS_VIA686A_IN2,&cur) &&
754	!sensors_get_feature(*name,SENSORS_VIA686A_IN2_MIN,&min) &&
755	!sensors_get_feature(*name,SENSORS_VIA686A_IN2_MAX,&max)) {
756	if (valid) {
757	print_label(label,10);
758	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
759	cur,min,max,alarms&VIA686A_ALARM_IN2?"ALARM":"");
760	}
761	} else
762	printf("ERROR: Can't get IN2 data!\n");
763	free(label);
764	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN3,&label,&valid) &&
765	!sensors_get_feature(*name,SENSORS_VIA686A_IN3,&cur) &&
766	!sensors_get_feature(*name,SENSORS_VIA686A_IN3_MIN,&min) &&
767	!sensors_get_feature(*name,SENSORS_VIA686A_IN3_MAX,&max)) {
768	if (valid) {
769	print_label(label,10);
770	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
771	cur,min,max,alarms&VIA686A_ALARM_IN3?"ALARM":"");
772	}
773	} else
774	printf("ERROR: Can't get IN3 data!\n");
775	free(label);
776	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_IN4,&label,&valid) &&
777	!sensors_get_feature(*name,SENSORS_VIA686A_IN4,&cur) &&
778	!sensors_get_feature(*name,SENSORS_VIA686A_IN4_MIN,&min) &&
779	!sensors_get_feature(*name,SENSORS_VIA686A_IN4_MAX,&max)) {
780	if (valid) {
781	print_label(label,10);
782	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
783	cur,min,max,alarms&VIA686A_ALARM_IN4?"ALARM":"");
784	}
785	} else
786	printf("ERROR: Can't get IN4 data!\n");
787	free(label);
788
789	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_FAN1,&label,&valid) &&
790	!sensors_get_feature(*name,SENSORS_VIA686A_FAN1,&cur) &&
791	!sensors_get_feature(*name,SENSORS_VIA686A_FAN1_DIV,&fdiv) &&
792	!sensors_get_feature(*name,SENSORS_VIA686A_FAN1_MIN,&min)) {
793	if (valid) {
794	print_label(label,10);
795	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
796	cur,min,fdiv, alarms&VIA686A_ALARM_FAN1?"ALARM":"");
797	}
798	} else
799	printf("ERROR: Can't get FAN1 data!\n");
800	free(label);
801	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_FAN2,&label,&valid) &&
802	!sensors_get_feature(*name,SENSORS_VIA686A_FAN2,&cur) &&
803	!sensors_get_feature(*name,SENSORS_VIA686A_FAN2_DIV,&fdiv) &&
804	!sensors_get_feature(*name,SENSORS_VIA686A_FAN2_MIN,&min)) {
805	if (valid) {
806	print_label(label,10);
807	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
808	cur,min,fdiv, alarms&VIA686A_ALARM_FAN2?"ALARM":"");
809	}
810	} else
811	printf("ERROR: Can't get FAN2 data!\n");
812	free(label);
813
814	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_TEMP,&label,&valid) &&
815	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP,&cur) &&
816	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP_HYST,&min) &&
817	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP_OVER,&max)) {
818	if (valid) {
819	print_label(label,10);
820	print_temp_info( cur, max, min, HYST, 1, 0);
821	printf(" %s\n", alarms & VIA686A_ALARM_TEMP ? "ALARM" : "" );
822	}
823	} else
824	printf("ERROR: Can't get TEMP data!\n");
825	free(label);
826	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_TEMP2,&label,&valid) &&
827	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP2,&cur) &&
828	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP2_HYST,&min) &&
829	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP2_OVER,&max)) {
830	if (valid) {
831	print_label(label,10);
832	print_temp_info( cur, max, min, HYST, 1, 0);
833	printf(" %s\n", alarms & VIA686A_ALARM_TEMP2 ? "ALARM" : "" );
834	}
835	} else
836	printf("ERROR: Can't get TEMP2 data!\n");
837	free(label);
838	if (!sensors_get_label_and_valid(*name,SENSORS_VIA686A_TEMP3,&label,&valid) &&
839	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP3,&cur) &&
840	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP3_HYST,&min) &&
841	!sensors_get_feature(*name,SENSORS_VIA686A_TEMP3_OVER,&max)) {
842	if (valid) {
843	print_label(label,10);
844	print_temp_info( cur, max, min, HYST, 1, 0);
845	printf(" %s\n", alarms & VIA686A_ALARM_TEMP3 ? "ALARM" : "" );
846	}
847	} else
848	printf("ERROR: Can't get TEMP3 data!\n");
849	free(label);
850
851	}
852
853	void print_lm78(const sensors_chip_name *name)
854	{
855	char *label;
856	double cur,min,max,fdiv;
857	int alarms,valid;
858
859	if (!sensors_get_feature(*name,SENSORS_LM78_ALARMS,&cur))
860	alarms = cur + 0.5;
861	else {
862	printf("ERROR: Can't get alarm data!\n");
863	alarms = 0;
864	}
865
866
867	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN0,&label,&valid) &&
868	!sensors_get_feature(*name,SENSORS_LM78_IN0,&cur) &&
869	!sensors_get_feature(*name,SENSORS_LM78_IN0_MIN,&min) &&
870	!sensors_get_feature(*name,SENSORS_LM78_IN0_MAX,&max)) {
871	if (valid) {
872	print_label(label,10);
873	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
874	cur,min,max,alarms&LM78_ALARM_IN0?"ALARM":"");
875	}
876	} else
877	printf("ERROR: Can't get IN0 data!\n");
878	free(label);
879	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN1,&label,&valid) &&
880	!sensors_get_feature(*name,SENSORS_LM78_IN1,&cur) &&
881	!sensors_get_feature(*name,SENSORS_LM78_IN1_MIN,&min) &&
882	!sensors_get_feature(*name,SENSORS_LM78_IN1_MAX,&max)) {
883	if (valid) {
884	print_label(label,10);
885	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
886	cur,min,max,alarms&LM78_ALARM_IN1?"ALARM":"");
887	}
888	} else
889	printf("ERROR: Can't get IN1 data!\n");
890	free(label);
891	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN2,&label,&valid) &&
892	!sensors_get_feature(*name,SENSORS_LM78_IN2,&cur) &&
893	!sensors_get_feature(*name,SENSORS_LM78_IN2_MIN,&min) &&
894	!sensors_get_feature(*name,SENSORS_LM78_IN2_MAX,&max)) {
895	if (valid) {
896	print_label(label,10);
897	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
898	cur,min,max,alarms&LM78_ALARM_IN2?"ALARM":"");
899	}
900	} else
901	printf("ERROR: Can't get IN2 data!\n");
902	free(label);
903	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN3,&label,&valid) &&
904	!sensors_get_feature(*name,SENSORS_LM78_IN3,&cur) &&
905	!sensors_get_feature(*name,SENSORS_LM78_IN3_MIN,&min) &&
906	!sensors_get_feature(*name,SENSORS_LM78_IN3_MAX,&max)) {
907	if (valid) {
908	print_label(label,10);
909	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
910	cur,min,max,alarms&LM78_ALARM_IN3?"ALARM":"");
911	}
912	} else
913	printf("ERROR: Can't get IN3 data!\n");
914	free(label);
915	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN4,&label,&valid) &&
916	!sensors_get_feature(*name,SENSORS_LM78_IN4,&cur) &&
917	!sensors_get_feature(*name,SENSORS_LM78_IN4_MIN,&min) &&
918	!sensors_get_feature(*name,SENSORS_LM78_IN4_MAX,&max)) {
919	if (valid) {
920	print_label(label,10);
921	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
922	cur,min,max,alarms&LM78_ALARM_IN4?"ALARM":"");
923	}
924	} else
925	printf("ERROR: Can't get IN4 data!\n");
926	free(label);
927	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN5,&label,&valid) &&
928	!sensors_get_feature(*name,SENSORS_LM78_IN5,&cur) &&
929	!sensors_get_feature(*name,SENSORS_LM78_IN5_MIN,&min) &&
930	!sensors_get_feature(*name,SENSORS_LM78_IN5_MAX,&max)) {
931	if (valid) {
932	print_label(label,10);
933	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
934	cur,min,max,alarms&LM78_ALARM_IN5?"ALARM":"");
935	}
936	} else
937	printf("ERROR: Can't get IN5 data!\n");
938	free(label);
939	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_IN6,&label,&valid) &&
940	!sensors_get_feature(*name,SENSORS_LM78_IN6,&cur) &&
941	!sensors_get_feature(*name,SENSORS_LM78_IN6_MIN,&min) &&
942	!sensors_get_feature(*name,SENSORS_LM78_IN6_MAX,&max)) {
943	if (valid) {
944	print_label(label,10);
945	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
946	cur,min,max,alarms&LM78_ALARM_IN6?"ALARM":"");
947	}
948	} else
949	printf("ERROR: Can't get IN6 data!\n");
950	free(label);
951
952	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_FAN1,&label,&valid) &&
953	!sensors_get_feature(*name,SENSORS_LM78_FAN1,&cur) &&
954	!sensors_get_feature(*name,SENSORS_LM78_FAN1_DIV,&fdiv) &&
955	!sensors_get_feature(*name,SENSORS_LM78_FAN1_MIN,&min)) {
956	if (valid) {
957	print_label(label,10);
958	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
959	cur,min,fdiv, alarms&LM78_ALARM_FAN1?"ALARM":"");
960	}
961	} else
962	printf("ERROR: Can't get FAN1 data!\n");
963	free(label);
964	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_FAN2,&label,&valid) &&
965	!sensors_get_feature(*name,SENSORS_LM78_FAN2,&cur) &&
966	!sensors_get_feature(*name,SENSORS_LM78_FAN2_DIV,&fdiv) &&
967	!sensors_get_feature(*name,SENSORS_LM78_FAN2_MIN,&min)) {
968	if (valid) {
969	print_label(label,10);
970	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
971	cur,min,fdiv, alarms&LM78_ALARM_FAN2?"ALARM":"");
972	}
973	} else
974	printf("ERROR: Can't get FAN2 data!\n");
975	free(label);
976	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_FAN3,&label,&valid) &&
977	!sensors_get_feature(*name,SENSORS_LM78_FAN3,&cur) &&
978	!sensors_get_feature(*name,SENSORS_LM78_FAN3_DIV,&fdiv) &&
979	!sensors_get_feature(*name,SENSORS_LM78_FAN3_MIN,&min)) {
980	if (valid) {
981	print_label(label,10);
982	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
983	cur,min,fdiv, alarms&LM78_ALARM_FAN3?"ALARM":"");
984	}
985	} else
986	printf("ERROR: Can't get FAN3 data!\n");
987	free(label);
988
989	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_TEMP,&label,&valid) &&
990	!sensors_get_feature(*name,SENSORS_LM78_TEMP,&cur) &&
991	!sensors_get_feature(*name,SENSORS_LM78_TEMP_HYST,&min) &&
992	!sensors_get_feature(*name,SENSORS_LM78_TEMP_OVER,&max)) {
993	if (valid) {
994	print_label(label,10);
995	print_temp_info( cur, max, min, HYST, 1, 0);
996	printf( " %s\n", alarms & LM78_ALARM_TEMP ? "ALARM" : "" );
997	}
998	} else
999	printf("ERROR: Can't get TEMP data!\n");
1000	free(label);
1001
1002	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_VID,&label,&valid) &&
1003	!sensors_get_feature(*name,SENSORS_LM78_VID,&cur)) {
1004	if (valid) {
1005	print_label(label,10);
1006	printf("%+6.2f V\n",cur);
1007	}
1008	}
1009	free(label);
1010
1011	if (!sensors_get_label_and_valid(*name,SENSORS_LM78_ALARMS,&label,&valid)
1012	&& valid) {
1013	if(alarms & LM78_ALARM_BTI) {
1014	print_label(label,10);
1015	printf("Board temperature input (LM75) ALARM\n");
1016	}
1017	if(alarms & LM78_ALARM_CHAS) {
1018	print_label(label,10);
1019	printf("Chassis intrusion detection ALARM\n");
1020	}
1021	}
1022	free(label);
1023	}
1024
1025	void print_gl518(const sensors_chip_name *name)
1026	{
1027	char *label;
1028	double cur,min,max,fdiv;
1029	int alarms,beeps,valid;
1030
1031	if (!sensors_get_feature(*name,SENSORS_GL518_ALARMS,&cur))
1032	alarms = cur + 0.5;
1033	else {
1034	printf("ERROR: Can't get ALARMS data!\n");
1035	alarms = 0;
1036	}
1037	if (!sensors_get_feature(*name,SENSORS_GL518_BEEPS,&cur))
1038	beeps = cur + 0.5;
1039	else {
1040	printf("ERROR: Can't get BEEPS data!\n");
1041	beeps = 0;
1042	}
1043
1044	/* VCC, VIN1 and VIN2 are handled specially because on early releases (0x00)
1045	* of the GL518SM, we cannot read their values. This is detected when the
1046	* reading would be 0.0 V and displayed as "(n/a)" instead. */
1047	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VDD,&label,&valid) &&
1048	!sensors_get_feature(*name,SENSORS_GL518_VDD,&cur) &&
1049	!sensors_get_feature(*name,SENSORS_GL518_VDD_MIN,&min) &&
1050	!sensors_get_feature(*name,SENSORS_GL518_VDD_MAX,&max)) {
1051	if (valid) {
1052	print_label(label,10);
1053	if (cur == 0.0)
1054	printf("(n/a) ");
1055	else
1056	printf("%+6.2f V ",cur);
1057	printf( "(min = %+6.2f V, max = %+6.2f V) %s %s\n",
1058	min,max,alarms&GL518_ALARM_VDD?"ALARM":" ",
1059	beeps&GL518_ALARM_VDD?"(beep)":"");
1060	}
1061	} else
1062	printf("ERROR: Can't get VDD data!\n");
1063	free(label);
1064
1065	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN1,&label,&valid) &&
1066	!sensors_get_feature(*name,SENSORS_GL518_VIN1,&cur) &&
1067	!sensors_get_feature(*name,SENSORS_GL518_VIN1_MIN,&min) &&
1068	!sensors_get_feature(*name,SENSORS_GL518_VIN1_MAX,&max)) {
1069	if (valid) {
1070	print_label(label,10);
1071	if (cur == 0.0)
1072	printf("(n/a) ");
1073	else
1074	printf("%+6.2f V ",cur);
1075	printf("(min = %+6.2f V, max = %+6.2f V) %s %s\n",
1076	min,max,alarms&GL518_ALARM_VIN1?"ALARM":" ",
1077	beeps&GL518_ALARM_VIN1?"(beep)":"");
1078	}
1079	} else
1080	printf("ERROR: Can't get VIN1 data!\n");
1081	free(label);
1082
1083	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN2,&label,&valid) &&
1084	!sensors_get_feature(*name,SENSORS_GL518_VIN2,&cur) &&
1085	!sensors_get_feature(*name,SENSORS_GL518_VIN2_MIN,&min) &&
1086	!sensors_get_feature(*name,SENSORS_GL518_VIN2_MAX,&max)) {
1087	if (valid) {
1088	print_label(label,10);
1089	if (cur == 0.0)
1090	printf("(n/a) ");
1091	else
1092	printf("%+6.2f V ",cur);
1093	printf("(min = %+6.2f V, max = %+6.2f V) %s %s\n",
1094	min,max,alarms&GL518_ALARM_VIN2?"ALARM":" ",
1095	beeps&GL518_ALARM_VIN2?"(beep)":"");
1096	}
1097	} else
1098	printf("ERROR: Can't get VIN2 data!\n");
1099	free(label);
1100
1101	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_VIN3,&label,&valid) &&
1102	!sensors_get_feature(*name,SENSORS_GL518_VIN3,&cur) &&
1103	!sensors_get_feature(*name,SENSORS_GL518_VIN3_MIN,&min) &&
1104	!sensors_get_feature(*name,SENSORS_GL518_VIN3_MAX,&max)) {
1105	if (valid) {
1106	print_label(label,10);
1107	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
1108	cur,min,max,alarms&GL518_ALARM_VIN3?"ALARM":" ",
1109	beeps&GL518_ALARM_VIN3?"(beep)":"");
1110	}
1111	} else
1112	printf("ERROR: Can't get VIN3 data!\n");
1113	free(label);
1114
1115	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_FAN1,&label,&valid) &&
1116	!sensors_get_feature(*name,SENSORS_GL518_FAN1,&cur) &&
1117	!sensors_get_feature(*name,SENSORS_GL518_FAN1_DIV,&fdiv) &&
1118	!sensors_get_feature(*name,SENSORS_GL518_FAN1_MIN,&min)) {
1119	if (valid) {
1120	print_label(label,10);
1121	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
1122	cur,min,fdiv, alarms&GL518_ALARM_FAN1?"ALARM":" ",
1123	beeps&GL518_ALARM_FAN1?"(beep)":"");
1124	}
1125	} else
1126	printf("ERROR: Can't get FAN1 data!\n");
1127	free(label);
1128
1129	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_FAN2,&label,&valid) &&
1130	!sensors_get_feature(*name,SENSORS_GL518_FAN2,&cur) &&
1131	!sensors_get_feature(*name,SENSORS_GL518_FAN2_DIV,&fdiv) &&
1132	!sensors_get_feature(*name,SENSORS_GL518_FAN2_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_FAN2?"ALARM":" ",
1137	beeps&GL518_ALARM_FAN2?"(beep)":"");
1138	}
1139	} else
1140	printf("ERROR: Can't get FAN2 data!\n");
1141	free(label);
1142
1143	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_TEMP,&label,&valid) &&
1144	!sensors_get_feature(*name,SENSORS_GL518_TEMP,&cur) &&
1145	!sensors_get_feature(*name,SENSORS_GL518_TEMP_OVER,&max) &&
1146	!sensors_get_feature(*name,SENSORS_GL518_TEMP_HYST,&min)) {
1147	if (valid) {
1148	print_label(label,10);
1149	print_temp_info( cur, max, min, HYST, 1, 0);
1150	printf("%s %s\n", alarms&GL518_ALARM_TEMP?"ALARM":" ",
1151	beeps&GL518_ALARM_TEMP?"(beep)":"");
1152	}
1153	} else
1154	printf("ERROR: Can't get TEMP data!\n");
1155	free(label);
1156
1157	if (!sensors_get_label_and_valid(*name,SENSORS_GL518_BEEP_ENABLE,&label,&valid)
1158	&& valid) {
1159	if (!sensors_get_feature(*name,SENSORS_GL518_BEEP_ENABLE,&cur)) {
1160	print_label(label,10);
1161	if (cur < 0.5)
1162	printf("Sound alarm disabled\n");
1163	else
1164	printf("Sound alarm enabled\n");
1165	} else
1166	printf("ERROR: Can't get BEEP ENABLE data!\n");
1167	}
1168	free(label);
1169	}
1170
1171	void print_gl520(const sensors_chip_name *name)
1172	{
1173	char *label;
1174	double cur,min,max;
1175	int alarms,beeps,valid;
1176	int two_temps = 0;
1177
1178	if (!sensors_get_feature(*name,SENSORS_GL520_ALARMS,&cur))
1179	alarms = cur + 0.5;
1180	else {
1181	printf("ERROR: Can't get ALARMS data!\n");
1182	alarms = 0;
1183	}
1184	if (!sensors_get_feature(*name,SENSORS_GL520_BEEPS,&cur))
1185	beeps = cur + 0.5;
1186	else {
1187	printf("ERROR: Can't get BEEPS data!\n");
1188	beeps = 0;
1189	}
1190
1191	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_VID,&label,&valid) &&
1192	!sensors_get_feature(*name,SENSORS_GL520_VID,&cur)) {
1193	if (valid) {
1194	print_label(label,10);
1195	printf("%+6.2f V\n",cur);
1196	}
1197	} else
1198	printf("ERROR: Can't get VID data!\n");
1199	free(label);
1200
1201	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_VDD,&label,&valid) &&
1202	!sensors_get_feature(*name,SENSORS_GL520_VDD,&cur) &&
1203	!sensors_get_feature(*name,SENSORS_GL520_VDD_MIN,&min) &&
1204	!sensors_get_feature(*name,SENSORS_GL520_VDD_MAX,&max)) {
1205	if (valid) {
1206	print_label(label,10);
1207	printf("%+6.2f V ",cur);
1208	printf( "(min = %+6.2f V, max = %+6.2f V) %s %s\n",
1209	min,max,alarms&GL520_ALARM_VDD?"ALARM":" ",
1210	beeps&GL520_ALARM_VDD?"(beep)":"");
1211	}
1212	} else
1213	printf("ERROR: Can't get VDD data!\n");
1214	free(label);
1215
1216	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_VIN1,&label,&valid) &&
1217	!sensors_get_feature(*name,SENSORS_GL520_VIN1,&cur) &&
1218	!sensors_get_feature(*name,SENSORS_GL520_VIN1_MIN,&min) &&
1219	!sensors_get_feature(*name,SENSORS_GL520_VIN1_MAX,&max)) {
1220	if (valid) {
1221	print_label(label,10);
1222	printf("%+6.2f V ",cur);
1223	printf("(min = %+6.2f V, max = %+6.2f V) %s %s\n",
1224	min,max,alarms&GL520_ALARM_VIN1?"ALARM":" ",
1225	beeps&GL520_ALARM_VIN1?"(beep)":"");
1226	}
1227	} else
1228	printf("ERROR: Can't get VIN1 data!\n");
1229	free(label);
1230
1231	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_VIN2,&label,&valid) &&
1232	!sensors_get_feature(*name,SENSORS_GL520_VIN2,&cur) &&
1233	!sensors_get_feature(*name,SENSORS_GL520_VIN2_MIN,&min) &&
1234	!sensors_get_feature(*name,SENSORS_GL520_VIN2_MAX,&max)) {
1235	if (valid) {
1236	print_label(label,10);
1237	printf("%+6.2f V ",cur);
1238	printf("(min = %+6.2f V, max = %+6.2f V) %s %s\n",
1239	min,max,alarms&GL520_ALARM_VIN2?"ALARM":" ",
1240	beeps&GL520_ALARM_VIN2?"(beep)":"");
1241	}
1242	} else
1243	printf("ERROR: Can't get VIN2 data!\n");
1244	free(label);
1245
1246	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_VIN3,&label,&valid) &&
1247	!sensors_get_feature(*name,SENSORS_GL520_VIN3,&cur) &&
1248	!sensors_get_feature(*name,SENSORS_GL520_VIN3_MIN,&min) &&
1249	!sensors_get_feature(*name,SENSORS_GL520_VIN3_MAX,&max)) {
1250	if (valid) {
1251	print_label(label,10);
1252	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
1253	cur,min,max,alarms&GL520_ALARM_VIN3?"ALARM":" ",
1254	beeps&GL520_ALARM_VIN3?"(beep)":"");
1255	}
1256	} else
1257	printf("ERROR: Can't get VIN3 data!\n");
1258	free(label);
1259
1260	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_VIN4,&label,&valid) &&
1261	!sensors_get_feature(*name,SENSORS_GL520_VIN4,&cur) &&
1262	!sensors_get_feature(*name,SENSORS_GL520_VIN4_MIN,&min) &&
1263	!sensors_get_feature(*name,SENSORS_GL520_VIN4_MAX,&max)) {
1264	if (valid) {
1265	print_label(label,10);
1266	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
1267	cur,min,max,alarms&GL520_ALARM_VIN4?"ALARM":" ",
1268	beeps&GL520_ALARM_VIN4?"(beep)":"");
1269	}
1270	} else
1271	two_temps = 1;
1272	free(label);
1273
1274	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_FAN1,&label,&valid) &&
1275	!sensors_get_feature(*name,SENSORS_GL520_FAN1,&cur) &&
1276	!sensors_get_feature(*name,SENSORS_GL520_FAN1_DIV,&max) &&
1277	!sensors_get_feature(*name,SENSORS_GL520_FAN1_MIN,&min)) {
1278	if (valid) {
1279	print_label(label,10);
1280	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
1281	cur,min,max, alarms&GL520_ALARM_FAN1?"ALARM":" ",
1282	beeps&GL520_ALARM_FAN1?"(beep)":"");
1283	}
1284	} else
1285	printf("ERROR: Can't get FAN1 data!\n");
1286	free(label);
1287
1288	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_FAN2,&label,&valid) &&
1289	!sensors_get_feature(*name,SENSORS_GL520_FAN2,&cur) &&
1290	!sensors_get_feature(*name,SENSORS_GL520_FAN2_DIV,&max) &&
1291	!sensors_get_feature(*name,SENSORS_GL520_FAN2_MIN,&min)) {
1292	if (valid) {
1293	print_label(label,10);
1294	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
1295	cur,min,max, alarms&GL520_ALARM_FAN2?"ALARM":" ",
1296	beeps&GL520_ALARM_FAN2?"(beep)":"");
1297	}
1298	} else
1299	printf("ERROR: Can't get FAN2 data!\n");
1300	free(label);
1301
1302	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_TEMP1,&label,&valid) &&
1303	!sensors_get_feature(*name,SENSORS_GL520_TEMP1,&cur) &&
1304	!sensors_get_feature(*name,SENSORS_GL520_TEMP1_OVER,&max) &&
1305	!sensors_get_feature(*name,SENSORS_GL520_TEMP1_HYST,&min)) {
1306	if (valid) {
1307	print_label(label,10);
1308	print_temp_info( cur, max, min, HYST, 1, 0);
1309	printf("%s %s\n", alarms&GL520_ALARM_TEMP1?"ALARM":" ",
1310	beeps&GL520_ALARM_TEMP1?"(beep)":"");
1311	}
1312	} else
1313	printf("ERROR: Can't get TEMP1 data!\n");
1314	free(label);
1315
1316	if (two_temps) {
1317	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_TEMP2,&label,&valid) &&
1318	!sensors_get_feature(*name,SENSORS_GL520_TEMP2,&cur) &&
1319	!sensors_get_feature(*name,SENSORS_GL520_TEMP2_OVER,&max) &&
1320	!sensors_get_feature(*name,SENSORS_GL520_TEMP2_HYST,&min)) {
1321	if (valid) {
1322	print_label(label,10);
1323	print_temp_info( cur, max, min, HYST, 1, 0);
1324	printf("%s %s\n", alarms&GL520_ALARM_TEMP2?"ALARM":" ",
1325	beeps&GL520_ALARM_TEMP2?"(beep)":"");
1326	}
1327	} else
1328	printf("ERROR: Can't get TEMP2 or VIN4 data!\n");
1329	free(label);
1330	}
1331
1332	if (!sensors_get_label_and_valid(*name,SENSORS_GL520_BEEP_ENABLE,&label,&valid)
1333	&& valid) {
1334	if (!sensors_get_feature(*name,SENSORS_GL520_BEEP_ENABLE,&cur)) {
1335	print_label(label,10);
1336	if (cur < 0.5)
1337	printf("Sound alarm disabled\n");
1338	else
1339	printf("Sound alarm enabled\n");
1340	} else
1341	printf("ERROR: Can't get BEEP ENABLE data!\n");
1342	}
1343	free(label);
1344	}
1345
1346	void print_adm1025(const sensors_chip_name *name)
1347	{
1348	char *label;
1349	double cur,min,max;
1350	int alarms,valid,i;
1351
1352	if (!sensors_get_feature(*name,SENSORS_ADM1025_ALARMS,&cur))
1353	alarms = cur + 0.5;
1354	else {
1355	printf("ERROR: Can't get alarm data!\n");
1356	alarms = 0;
1357	}
1358
1359	for (i=0; i<6; i++) {
1360	if (!sensors_get_label_and_valid(*name,SENSORS_ADM1025_IN0+i,&label,&valid) &&
1361	!sensors_get_feature(*name,SENSORS_ADM1025_IN0+i,&cur) &&
1362	!sensors_get_feature(*name,SENSORS_ADM1025_IN0_MIN+i,&min) &&
1363	!sensors_get_feature(*name,SENSORS_ADM1025_IN0_MAX+i,&max)) {
1364	if (valid) {
1365	print_label(label,10);
1366	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1367	cur,min,max,alarms&(ADM1025_ALARM_IN0<<(i+(i/4)*4))?"ALARM":"");
1368	}
1369	} else
1370	if (i!=4) /* Chip may have +12V input used for VID instead */
1371	printf("ERROR: Can't get IN%d data!\n", i);
1372	free(label);
1373	}
1374
1375	for (i=0; i<2; i++) {
1376	if (!sensors_get_label_and_valid(name,SENSORS_ADM1025_TEMP1+3i,&label,&valid) &&
1377	!sensors_get_feature(name,SENSORS_ADM1025_TEMP1+3i,&cur) &&
1378	!sensors_get_feature(name,SENSORS_ADM1025_TEMP1_LOW+3i,&min) &&
1379	!sensors_get_feature(name,SENSORS_ADM1025_TEMP1_HIGH+3i,&max)) {
1380	if (valid) {
1381	print_label(label,10);
1382	print_temp_info( cur, max, min, MINMAX, 1, 0);
1383	printf(" %s\n", i==0&&(alarms&ADM1025_ALARM_RFAULT)?"FAULT":
1384	alarms&(ADM1025_ALARM_RTEMP>>i)?"ALARM":"");
1385	}
1386	} else
1387	printf("ERROR: Can't get TEMP%d data!\n", i+1);
1388	free(label);
1389	}
1390
1391	print_vid_info(name, SENSORS_ADM1025_VID, SENSORS_ADM1025_VRM);
1392	}
1393
1394	void print_lm80(const sensors_chip_name *name)
1395	{
1396	char *label;
1397	double cur,min,max,min2,max2,fdiv;
1398	int alarms,valid;
1399
1400	if (!sensors_get_feature(*name,SENSORS_LM80_ALARMS,&cur))
1401	alarms = cur + 0.5;
1402	else {
1403	printf("ERROR: Can't get alarm data!\n");
1404	alarms = 0;
1405	}
1406
1407	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN0,&label,&valid) &&
1408	!sensors_get_feature(*name,SENSORS_LM80_IN0,&cur) &&
1409	!sensors_get_feature(*name,SENSORS_LM80_IN0_MIN,&min) &&
1410	!sensors_get_feature(*name,SENSORS_LM80_IN0_MAX,&max)) {
1411	if (valid) {
1412	print_label(label,10);
1413	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1414	cur,min,max,alarms&LM80_ALARM_IN0?"ALARM":"");
1415	}
1416	} else
1417	printf("ERROR: Can't get IN0 data!\n");
1418	free(label);
1419	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN1,&label,&valid) &&
1420	!sensors_get_feature(*name,SENSORS_LM80_IN1,&cur) &&
1421	!sensors_get_feature(*name,SENSORS_LM80_IN1_MIN,&min) &&
1422	!sensors_get_feature(*name,SENSORS_LM80_IN1_MAX,&max)) {
1423	if (valid) {
1424	print_label(label,10);
1425	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1426	cur,min,max,alarms&LM80_ALARM_IN1?"ALARM":"");
1427	}
1428	} else
1429	printf("ERROR: Can't get IN1 data!\n");
1430	free(label);
1431	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN2,&label,&valid) &&
1432	!sensors_get_feature(*name,SENSORS_LM80_IN2,&cur) &&
1433	!sensors_get_feature(*name,SENSORS_LM80_IN2_MIN,&min) &&
1434	!sensors_get_feature(*name,SENSORS_LM80_IN2_MAX,&max)) {
1435	if (valid) {
1436	print_label(label,10);
1437	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1438	cur,min,max,alarms&LM80_ALARM_IN2?"ALARM":"");
1439	}
1440	} else
1441	printf("ERROR: Can't get IN2 data!\n");
1442	free(label);
1443	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN3,&label,&valid) &&
1444	!sensors_get_feature(*name,SENSORS_LM80_IN3,&cur) &&
1445	!sensors_get_feature(*name,SENSORS_LM80_IN3_MIN,&min) &&
1446	!sensors_get_feature(*name,SENSORS_LM80_IN3_MAX,&max)) {
1447	if (valid) {
1448	print_label(label,10);
1449	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1450	cur,min,max,alarms&LM80_ALARM_IN3?"ALARM":"");
1451	}
1452	} else
1453	printf("ERROR: Can't get IN3 data!\n");
1454	free(label);
1455	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN4,&label,&valid) &&
1456	!sensors_get_feature(*name,SENSORS_LM80_IN4,&cur) &&
1457	!sensors_get_feature(*name,SENSORS_LM80_IN4_MIN,&min) &&
1458	!sensors_get_feature(*name,SENSORS_LM80_IN4_MAX,&max)) {
1459	if (valid) {
1460	print_label(label,10);
1461	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1462	cur,min,max,alarms&LM80_ALARM_IN4?"ALARM":"");
1463	}
1464	} else
1465	printf("ERROR: Can't get IN4 data!\n");
1466	free(label);
1467	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN5,&label,&valid) &&
1468	!sensors_get_feature(*name,SENSORS_LM80_IN5,&cur) &&
1469	!sensors_get_feature(*name,SENSORS_LM80_IN5_MIN,&min) &&
1470	!sensors_get_feature(*name,SENSORS_LM80_IN5_MAX,&max)) {
1471	if (valid) {
1472	print_label(label,10);
1473	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1474	cur,min,max,alarms&LM80_ALARM_IN5?"ALARM":"");
1475	}
1476	} else
1477	printf("ERROR: Can't get IN5 data!\n");
1478	free(label);
1479	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_IN6,&label,&valid) &&
1480	!sensors_get_feature(*name,SENSORS_LM80_IN6,&cur) &&
1481	!sensors_get_feature(*name,SENSORS_LM80_IN6_MIN,&min) &&
1482	!sensors_get_feature(*name,SENSORS_LM80_IN6_MAX,&max)) {
1483	if (valid) {
1484	print_label(label,10);
1485	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1486	cur,min,max,alarms&LM80_ALARM_IN6?"ALARM":"");
1487	}
1488	} else
1489	printf("ERROR: Can't get IN6 data!\n");
1490	free(label);
1491
1492	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_FAN1,&label,&valid) &&
1493	!sensors_get_feature(*name,SENSORS_LM80_FAN1,&cur) &&
1494	!sensors_get_feature(*name,SENSORS_LM80_FAN1_DIV,&fdiv) &&
1495	!sensors_get_feature(*name,SENSORS_LM80_FAN1_MIN,&min)) {
1496	if (valid) {
1497	print_label(label,10);
1498	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
1499	cur,min,fdiv, alarms&LM80_ALARM_FAN1?"ALARM":"");
1500	}
1501	} else
1502	printf("ERROR: Can't get FAN1 data!\n");
1503	free(label);
1504	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_FAN2,&label,&valid) &&
1505	!sensors_get_feature(*name,SENSORS_LM80_FAN2,&cur) &&
1506	!sensors_get_feature(*name,SENSORS_LM80_FAN2_DIV,&fdiv) &&
1507	!sensors_get_feature(*name,SENSORS_LM80_FAN2_MIN,&min)) {
1508	if (valid) {
1509	print_label(label,10);
1510	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
1511	cur,min,fdiv, alarms&LM80_ALARM_FAN2?"ALARM":"");
1512	}
1513	} else
1514	printf("ERROR: Can't get FAN2 data!\n");
1515	free(label);
1516
1517	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_TEMP,&label,&valid) &&
1518	!sensors_get_feature(*name,SENSORS_LM80_TEMP,&cur) &&
1519	!sensors_get_feature(*name,SENSORS_LM80_TEMP_HOT_HYST,&min) &&
1520	!sensors_get_feature(*name,SENSORS_LM80_TEMP_HOT_MAX,&max) &&
1521	!sensors_get_feature(*name,SENSORS_LM80_TEMP_OS_HYST,&min2) &&
1522	!sensors_get_feature(*name,SENSORS_LM80_TEMP_OS_MAX,&max2)) {
1523	if (valid) {
1524	if (fahrenheit) {
1525	cur = deg_ctof(cur);
1526	max = deg_ctof(max);
1527	min = deg_ctof(min);
1528	max2 = deg_ctof(max2);
1529	min2 = deg_ctof(min2);
1530	}
1531
1532	print_label(label,10);
1533	printf("%+6.2f%s (hot: limit = %+3.0f%s, hyst = %+3.0f%s) %s\n",
1534	cur, degstr, max, degstr, min, degstr,
1535	alarms&LM80_ALARM_TEMP_HOT?"ALARM":"");
1536	print_label("",10);
1537	printf(" (os: limit = %+3.0f%s, hyst = %+3.0f%s) %s\n",
1538	max2, degstr, min2, degstr,
1539	alarms&LM80_ALARM_TEMP_OS?"ALARM":"");
1540	}
1541	} else
1542	printf("ERROR: Can't get TEMP data!\n");
1543	free(label);
1544
1545	if (!sensors_get_label_and_valid(*name,SENSORS_LM80_ALARMS,&label,&valid)
1546	&& valid) {
1547	if (alarms & LM80_ALARM_BTI) {
1548	print_label(label,10);
1549	printf("Board temperature input (LM75) ALARM\n");
1550	}
1551	if (alarms & LM80_ALARM_CHAS) {
1552	print_label(label,10);
1553	printf("Chassis intrusion detection ALARM\n");
1554	}
1555	}
1556	free(label);
1557	}
1558
1559	void print_lm85(const sensors_chip_name *name)
1560	{
1561	char *label;
1562	double cur, min, max;
1563	int alarms, alarm_mask = 0, valid;
1564	int is85, is1027, is6d100;
1565
1566	is85 = !strcmp(name->prefix,"lm85")
1567	\|\| !strcmp(name->prefix,"lm85b")
1568	\|\| !strcmp(name->prefix,"lm85c") ;
1569	is1027 = !strcmp(name->prefix,"adm1027")
1570	\|\| !strcmp(name->prefix,"adt7463") ;
1571	is6d100 = !strcmp(name->prefix,"emc6d100") ;
1572
1573	if (!sensors_get_feature(*name,SENSORS_LM85_ALARMS,&cur))
1574	alarms = cur + 0.5;
1575	else {
1576	printf("ERROR: Can't get alarm data!\n");
1577	alarms = 0;
1578	}
1579
1580	if (is1027 &&
1581	!sensors_get_feature(*name, SENSORS_ADM1027_ALARM_MASK, &cur)) {
1582	alarm_mask = cur + 0.5;
1583	}
1584
1585	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN0,&label,&valid) &&
1586	!sensors_get_feature(*name,SENSORS_LM85_IN0,&cur) &&
1587	!sensors_get_feature(*name,SENSORS_LM85_IN0_MIN,&min) &&
1588	!sensors_get_feature(*name,SENSORS_LM85_IN0_MAX,&max)) {
1589	if (valid) {
1590	print_label(label,10);
1591	printf("%+7.*f V (min = %+6.2f V, max = %+6.2f V) %s",
1592	(is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN0?"ALARM":"");
1593	if (is1027) { printf(alarm_mask&LM85_ALARM_IN0?" MASKED":""); }
1594	putchar( '\n' );
1595	}
1596	} else
1597	printf("ERROR: Can't get IN0 data!\n");
1598	free(label);
1599	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN1,&label,&valid) &&
1600	!sensors_get_feature(*name,SENSORS_LM85_IN1,&cur) &&
1601	!sensors_get_feature(*name,SENSORS_LM85_IN1_MIN,&min) &&
1602	!sensors_get_feature(*name,SENSORS_LM85_IN1_MAX,&max)) {
1603	if (valid) {
1604	print_label(label,10);
1605	printf("%+7.*f V (min = %+6.2f V, max = %+6.2f V) %s",
1606	(is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN1?"ALARM":"");
1607	if (is1027) { printf(alarm_mask&LM85_ALARM_IN1?" MASKED":""); }
1608	putchar( '\n' );
1609	}
1610	} else
1611	printf("ERROR: Can't get IN1 data!\n");
1612	free(label);
1613	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN2,&label,&valid) &&
1614	!sensors_get_feature(*name,SENSORS_LM85_IN2,&cur) &&
1615	!sensors_get_feature(*name,SENSORS_LM85_IN2_MIN,&min) &&
1616	!sensors_get_feature(*name,SENSORS_LM85_IN2_MAX,&max)) {
1617	if (valid) {
1618	print_label(label,10);
1619	printf("%+7.*f V (min = %+6.2f V, max = %+6.2f V) %s",
1620	(is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN2?"ALARM":"");
1621	if (is1027) { printf(alarm_mask&LM85_ALARM_IN2?" MASKED":""); }
1622	putchar( '\n' );
1623	}
1624	} else
1625	printf("ERROR: Can't get IN2 data!\n");
1626	free(label);
1627	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN3,&label,&valid) &&
1628	!sensors_get_feature(*name,SENSORS_LM85_IN3,&cur) &&
1629	!sensors_get_feature(*name,SENSORS_LM85_IN3_MIN,&min) &&
1630	!sensors_get_feature(*name,SENSORS_LM85_IN3_MAX,&max)) {
1631	if (valid) {
1632	print_label(label,10);
1633	printf("%+6.*f V (min = %+6.2f V, max = %+6.2f V) %s",
1634	(is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN3?"ALARM":"");
1635	if (is1027) { printf(alarm_mask&LM85_ALARM_IN3?" MASKED":""); }
1636	putchar( '\n' );
1637	}
1638	} else
1639	printf("ERROR: Can't get IN3 data!\n");
1640	free(label);
1641	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN4,&label,&valid) &&
1642	!sensors_get_feature(*name,SENSORS_LM85_IN4,&cur) &&
1643	!sensors_get_feature(*name,SENSORS_LM85_IN4_MIN,&min) &&
1644	!sensors_get_feature(*name,SENSORS_LM85_IN4_MAX,&max)) {
1645	if (valid) {
1646	print_label(label,10);
1647	printf("%+6.*f V (min = %+6.2f V, max = %+6.2f V) %s",
1648	(is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN4?"ALARM":"");
1649	if (is1027) { printf(alarm_mask&LM85_ALARM_IN4?" MASKED":""); }
1650	putchar( '\n' );
1651	}
1652	} else
1653	printf("ERROR: Can't get IN4 data!\n");
1654	free(label);
1655
1656	if( is6d100 ) {
1657	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN5,&label,&valid) &&
1658	!sensors_get_feature(*name,SENSORS_LM85_IN5,&cur) &&
1659	!sensors_get_feature(*name,SENSORS_LM85_IN5_MIN,&min) &&
1660	!sensors_get_feature(*name,SENSORS_LM85_IN5_MAX,&max)) {
1661	if (valid) {
1662	print_label(label,10);
1663	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1664	cur,min,max,alarms&LM85_ALARM_IN5?"ALARM":"");
1665	}
1666	} else
1667	printf("ERROR: Can't get IN5 data!\n");
1668	free(label);
1669	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN6,&label,&valid) &&
1670	!sensors_get_feature(*name,SENSORS_LM85_IN6,&cur) &&
1671	!sensors_get_feature(*name,SENSORS_LM85_IN6_MIN,&min) &&
1672	!sensors_get_feature(*name,SENSORS_LM85_IN6_MAX,&max)) {
1673	if (valid) {
1674	print_label(label,10);
1675	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1676	cur,min,max,alarms&LM85_ALARM_IN6?"ALARM":"");
1677	}
1678	} else
1679	printf("ERROR: Can't get IN6 data!\n");
1680	free(label);
1681	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN7,&label,&valid) &&
1682	!sensors_get_feature(*name,SENSORS_LM85_IN7,&cur) &&
1683	!sensors_get_feature(*name,SENSORS_LM85_IN7_MIN,&min) &&
1684	!sensors_get_feature(*name,SENSORS_LM85_IN7_MAX,&max)) {
1685	if (valid) {
1686	print_label(label,10);
1687	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1688	cur,min,max,alarms&LM85_ALARM_IN7?"ALARM":"");
1689	}
1690	} else
1691	printf("ERROR: Can't get IN7 data!\n");
1692	free(label);
1693	}
1694
1695	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN1,&label,&valid) &&
1696	!sensors_get_feature(*name,SENSORS_LM85_FAN1,&cur) &&
1697	!sensors_get_feature(*name,SENSORS_LM85_FAN1_MIN,&min)) {
1698	if (valid) {
1699	print_label(label,10);
1700	printf("%5.0f RPM (min = %4.0f RPM) %s",
1701	cur,min, alarms&LM85_ALARM_FAN1?"ALARM":"");
1702	if (is1027) { printf(alarm_mask&LM85_ALARM_FAN1?" MASKED":""); }
1703	putchar( '\n' );
1704	}
1705	} else
1706	printf("ERROR: Can't get FAN1 data!\n");
1707	free(label);
1708	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN2,&label,&valid) &&
1709	!sensors_get_feature(*name,SENSORS_LM85_FAN2,&cur) &&
1710	!sensors_get_feature(*name,SENSORS_LM85_FAN2_MIN,&min)) {
1711	if (valid) {
1712	print_label(label,10);
1713	printf("%5.0f RPM (min = %4.0f RPM) %s",
1714	cur,min, alarms&LM85_ALARM_FAN2?"ALARM":"");
1715	if (is1027) { printf(alarm_mask&LM85_ALARM_FAN2?" MASKED":""); }
1716	putchar( '\n' );
1717	}
1718	} else
1719	printf("ERROR: Can't get FAN2 data!\n");
1720	free(label);
1721	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN3,&label,&valid) &&
1722	!sensors_get_feature(*name,SENSORS_LM85_FAN3,&cur) &&
1723	!sensors_get_feature(*name,SENSORS_LM85_FAN3_MIN,&min)) {
1724	if (valid) {
1725	print_label(label,10);
1726	printf("%5.0f RPM (min = %4.0f RPM) %s",
1727	cur,min, alarms&LM85_ALARM_FAN3?"ALARM":"");
1728	if (is1027) { printf(alarm_mask&LM85_ALARM_FAN3?" MASKED":""); }
1729	putchar( '\n' );
1730	}
1731	} else
1732	printf("ERROR: Can't get FAN3 data!\n");
1733	free(label);
1734	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN4,&label,&valid) &&
1735	!sensors_get_feature(*name,SENSORS_LM85_FAN4,&cur) &&
1736	!sensors_get_feature(*name,SENSORS_LM85_FAN4_MIN,&min)) {
1737	if (valid) {
1738	print_label(label,10);
1739	printf("%5.0f RPM (min = %4.0f RPM) %s",
1740	cur,min, alarms&LM85_ALARM_FAN4?"ALARM":"");
1741	if (is1027) { printf(alarm_mask&LM85_ALARM_FAN4?" MASKED":""); }
1742	putchar( '\n' );
1743	}
1744	} else
1745	printf("ERROR: Can't get FAN4 data!\n");
1746	free(label);
1747
1748	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_TEMP1,&label,&valid) &&
1749	!sensors_get_feature(*name,SENSORS_LM85_TEMP1,&cur) &&
1750	!sensors_get_feature(*name,SENSORS_LM85_TEMP1_MIN,&min) &&
1751	!sensors_get_feature(*name,SENSORS_LM85_TEMP1_MAX,&max)) {
1752	if (valid) {
1753	print_label(label,10);
1754	print_temp_info( cur, max, min, MINMAX, (is1027 ? 2 : 0), 0);
1755	printf( " %s %s %s\n",
1756	alarms&LM85_ALARM_TEMP1?"ALARM":"",
1757	alarms&LM85_ALARM_TEMP1_FAULT?"FAULT":"",
1758	is1027&&(alarm_mask&LM85_ALARM_TEMP1)?"MASKED":""
1759	);
1760	}
1761	} else
1762	printf("ERROR: Can't get TEMP1 data!\n");
1763	free(label);
1764	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_TEMP2,&label,&valid) &&
1765	!sensors_get_feature(*name,SENSORS_LM85_TEMP2,&cur) &&
1766	!sensors_get_feature(*name,SENSORS_LM85_TEMP2_MIN,&min) &&
1767	!sensors_get_feature(*name,SENSORS_LM85_TEMP2_MAX,&max)) {
1768	if (valid) {
1769	print_label(label,10);
1770	print_temp_info( cur, max, min, MINMAX, (is1027 ? 2 : 0), 0);
1771	printf( " %s %s\n",
1772	alarms&LM85_ALARM_TEMP2?"ALARM":"",
1773	is1027&&(alarm_mask&LM85_ALARM_TEMP2)?"MASKED":""
1774	);
1775	}
1776	} else
1777	printf("ERROR: Can't get TEMP2 data!\n");
1778	free(label);
1779	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_TEMP3,&label,&valid) &&
1780	!sensors_get_feature(*name,SENSORS_LM85_TEMP3,&cur) &&
1781	!sensors_get_feature(*name,SENSORS_LM85_TEMP3_MIN,&min) &&
1782	!sensors_get_feature(*name,SENSORS_LM85_TEMP3_MAX,&max)) {
1783	if (valid) {
1784	print_label(label,10);
1785	print_temp_info( cur, max, min, MINMAX, (is1027 ? 2 : 0), 0);
1786	printf( " %s %s %s\n",
1787	alarms&LM85_ALARM_TEMP3?"ALARM":"",
1788	alarms&LM85_ALARM_TEMP3_FAULT?"FAULT":"",
1789	is1027&&(alarm_mask&LM85_ALARM_TEMP3)?"MASKED":""
1790	);
1791	}
1792	} else
1793	printf("ERROR: Can't get TEMP3 data!\n");
1794	free(label);
1795
1796	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_PWM1,&label,&valid) &&
1797	!sensors_get_feature(*name,SENSORS_LM85_PWM1,&cur)) {
1798	if (valid) {
1799	print_label(label,10);
1800	printf("%4.0f\n", cur);
1801	}
1802	} else
1803	printf("ERROR: Can't get PWM1 data!\n");
1804	free(label);
1805	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_PWM2,&label,&valid) &&
1806	!sensors_get_feature(*name,SENSORS_LM85_PWM2,&cur)) {
1807	if (valid) {
1808	print_label(label,10);
1809	printf("%4.0f\n", cur);
1810	}
1811	} else
1812	printf("ERROR: Can't get PWM2 data!\n");
1813	free(label);
1814	if (!sensors_get_label_and_valid(*name,SENSORS_LM85_PWM3,&label,&valid) &&
1815	!sensors_get_feature(*name,SENSORS_LM85_PWM3,&cur)) {
1816	if (valid) {
1817	print_label(label,10);
1818	printf("%4.0f\n", cur);
1819	}
1820	} else
1821	printf("ERROR: Can't get PWM3 data!\n");
1822	free(label);
1823
1824	print_vid_info(name, SENSORS_LM85_VID, SENSORS_LM85_VRM);
1825	}
1826
1827	void print_lm87(const sensors_chip_name *name)
1828	{
1829	char *label;
1830	double cur,min,max,fdiv;
1831	int alarms,valid;
1832
1833	if (!sensors_get_feature(*name,SENSORS_LM87_ALARMS,&cur))
1834	alarms = cur + 0.5;
1835	else {
1836	printf("ERROR: Can't get alarm data!\n");
1837	alarms = 0;
1838	}
1839
1840
1841	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN0,&label,&valid) &&
1842	!sensors_get_feature(*name,SENSORS_LM87_IN0,&cur) &&
1843	!sensors_get_feature(*name,SENSORS_LM87_IN0_MIN,&min) &&
1844	!sensors_get_feature(*name,SENSORS_LM87_IN0_MAX,&max)) {
1845	if (valid) {
1846	print_label(label,10);
1847	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1848	cur,min,max,alarms&LM87_ALARM_IN0?"ALARM":"");
1849	}
1850	}
1851	free(label);
1852	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN1,&label,&valid) &&
1853	!sensors_get_feature(*name,SENSORS_LM87_IN1,&cur) &&
1854	!sensors_get_feature(*name,SENSORS_LM87_IN1_MIN,&min) &&
1855	!sensors_get_feature(*name,SENSORS_LM87_IN1_MAX,&max)) {
1856	if (valid) {
1857	print_label(label,10);
1858	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1859	cur,min,max,alarms&LM87_ALARM_IN1?"ALARM":"");
1860	}
1861	} else
1862	printf("ERROR: Can't get IN1 data!\n");
1863	free(label);
1864	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN2,&label,&valid) &&
1865	!sensors_get_feature(*name,SENSORS_LM87_IN2,&cur) &&
1866	!sensors_get_feature(*name,SENSORS_LM87_IN2_MIN,&min) &&
1867	!sensors_get_feature(*name,SENSORS_LM87_IN2_MAX,&max)) {
1868	if (valid) {
1869	print_label(label,10);
1870	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1871	cur,min,max,alarms&LM87_ALARM_IN2?"ALARM":"");
1872	}
1873	}
1874	free(label);
1875	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN3,&label,&valid) &&
1876	!sensors_get_feature(*name,SENSORS_LM87_IN3,&cur) &&
1877	!sensors_get_feature(*name,SENSORS_LM87_IN3_MIN,&min) &&
1878	!sensors_get_feature(*name,SENSORS_LM87_IN3_MAX,&max)) {
1879	if (valid) {
1880	print_label(label,10);
1881	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1882	cur,min,max,alarms&LM87_ALARM_IN3?"ALARM":"");
1883	}
1884	} else
1885	printf("ERROR: Can't get IN3 data!\n");
1886	free(label);
1887	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN4,&label,&valid) &&
1888	!sensors_get_feature(*name,SENSORS_LM87_IN4,&cur) &&
1889	!sensors_get_feature(*name,SENSORS_LM87_IN4_MIN,&min) &&
1890	!sensors_get_feature(*name,SENSORS_LM87_IN4_MAX,&max)) {
1891	if (valid) {
1892	print_label(label,10);
1893	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1894	cur,min,max,alarms&LM87_ALARM_IN4?"ALARM":"");
1895	}
1896	} else
1897	printf("ERROR: Can't get IN4 data!\n");
1898	free(label);
1899	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN5,&label,&valid) &&
1900	!sensors_get_feature(*name,SENSORS_LM87_IN5,&cur) &&
1901	!sensors_get_feature(*name,SENSORS_LM87_IN5_MIN,&min) &&
1902	!sensors_get_feature(*name,SENSORS_LM87_IN5_MAX,&max)) {
1903	if (valid) {
1904	print_label(label,10);
1905	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1906	cur,min,max,alarms&LM87_ALARM_IN5?"ALARM":"");
1907	}
1908	}
1909	free(label);
1910	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_AIN1,&label,&valid) &&
1911	!sensors_get_feature(*name,SENSORS_LM87_AIN1,&cur) &&
1912	!sensors_get_feature(*name,SENSORS_LM87_AIN1_MIN,&min) &&
1913	!sensors_get_feature(*name,SENSORS_LM87_AIN1_MAX,&max)) {
1914	if (valid) {
1915	print_label(label,10);
1916	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1917	cur,min,max,alarms&LM87_ALARM_FAN1?"ALARM":"");
1918	}
1919	}
1920	free(label);
1921	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_AIN2,&label,&valid) &&
1922	!sensors_get_feature(*name,SENSORS_LM87_AIN2,&cur) &&
1923	!sensors_get_feature(*name,SENSORS_LM87_AIN2_MIN,&min) &&
1924	!sensors_get_feature(*name,SENSORS_LM87_AIN2_MAX,&max)) {
1925	if (valid) {
1926	print_label(label,10);
1927	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
1928	cur,min,max,alarms&LM87_ALARM_FAN2?"ALARM":"");
1929	}
1930	}
1931	free(label);
1932
1933	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_FAN1,&label,&valid) &&
1934	!sensors_get_feature(*name,SENSORS_LM87_FAN1,&cur) &&
1935	!sensors_get_feature(*name,SENSORS_LM87_FAN1_DIV,&fdiv) &&
1936	!sensors_get_feature(*name,SENSORS_LM87_FAN1_MIN,&min)) {
1937	if (valid) {
1938	print_label(label,10);
1939	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
1940	cur,min,fdiv, alarms&LM87_ALARM_FAN1?"ALARM":"");
1941	}
1942	}
1943	free(label);
1944	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_FAN2,&label,&valid) &&
1945	!sensors_get_feature(*name,SENSORS_LM87_FAN2,&cur) &&
1946	!sensors_get_feature(*name,SENSORS_LM87_FAN2_DIV,&fdiv) &&
1947	!sensors_get_feature(*name,SENSORS_LM87_FAN2_MIN,&min)) {
1948	if (valid) {
1949	print_label(label,10);
1950	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
1951	cur,min,fdiv, alarms&LM87_ALARM_FAN2 ?"ALARM":"");
1952	}
1953	}
1954	free(label);
1955
1956	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP1,&label,&valid) &&
1957	!sensors_get_feature(*name,SENSORS_LM87_TEMP1,&cur) &&
1958	!sensors_get_feature(*name,SENSORS_LM87_TEMP1_HYST,&min) &&
1959	!sensors_get_feature(*name,SENSORS_LM87_TEMP1_OVER,&max)) {
1960	if (valid) {
1961	print_label(label,10);
1962	print_temp_info( cur, max, min, MINMAX, 0, 0);
1963	printf(" %s%s\n", alarms&LM87_ALARM_TEMP1?"ALARM":"",
1964	alarms&LM87_ALARM_THERM_SIG?" THERM#":"");
1965	}
1966	} else
1967	printf("ERROR: Can't get TEMP1 data!\n");
1968	free(label);
1969
1970	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP2,&label,&valid) &&
1971	!sensors_get_feature(*name,SENSORS_LM87_TEMP2,&cur) &&
1972	!sensors_get_feature(*name,SENSORS_LM87_TEMP2_HYST,&min) &&
1973	!sensors_get_feature(*name,SENSORS_LM87_TEMP2_OVER,&max)) {
1974	if (valid) {
1975	print_label(label,10);
1976	print_temp_info( cur, max, min, MINMAX, 0, 0);
1977	printf(" %s%s\n", alarms&LM87_ALARM_TEMP2?"ALARM":"",
1978	alarms&LM87_ALARM_TEMP2_FAULT?" FAULT":"");
1979	}
1980	} else
1981	printf("ERROR: Can't get TEMP2 data!\n");
1982	free(label);
1983
1984	if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP3,&label,&valid) &&
1985	!sensors_get_feature(*name,SENSORS_LM87_TEMP3,&cur) &&
1986	!sensors_get_feature(*name,SENSORS_LM87_TEMP3_HYST,&min) &&
1987	!sensors_get_feature(*name,SENSORS_LM87_TEMP3_OVER,&max)) {
1988	if (valid) {
1989	print_label(label,10);
1990	print_temp_info( cur, max, min, MINMAX, 0, 0);
1991	printf(" %s%s\n", alarms&LM87_ALARM_TEMP3?"ALARM":"",
1992	alarms&LM87_ALARM_TEMP3_FAULT?" FAULT":"");
1993	}
1994	}
1995	free(label);
1996
1997	print_vid_info(name, SENSORS_LM87_VID, SENSORS_LM87_VRM);
1998	}
1999
2000	void print_mtp008(const sensors_chip_name *name)
2001	{
2002	char *label;
2003	double cur,min,max,fdiv;
2004	int alarms,valid;
2005
2006	if (!sensors_get_feature(*name,SENSORS_MTP008_ALARMS,&cur))
2007	alarms = cur + 0.5;
2008	else {
2009	printf("ERROR: Can't get alarm data!\n");
2010	alarms = 0;
2011	}
2012
2013
2014	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN0,&label,&valid) &&
2015	!sensors_get_feature(*name,SENSORS_MTP008_IN0,&cur) &&
2016	!sensors_get_feature(*name,SENSORS_MTP008_IN0_MIN,&min) &&
2017	!sensors_get_feature(*name,SENSORS_MTP008_IN0_MAX,&max)) {
2018	if (valid) {
2019	print_label(label,10);
2020	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2021	cur,min,max,alarms&MTP008_ALARM_IN0?"ALARM":"");
2022	}
2023	} else
2024	printf("ERROR: Can't get IN0 data!\n");
2025	free(label);
2026	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN1,&label,&valid) &&
2027	!sensors_get_feature(*name,SENSORS_MTP008_IN1,&cur) &&
2028	!sensors_get_feature(*name,SENSORS_MTP008_IN1_MIN,&min) &&
2029	!sensors_get_feature(*name,SENSORS_MTP008_IN1_MAX,&max)) {
2030	if (valid) {
2031	print_label(label,10);
2032	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2033	cur,min,max,alarms&MTP008_ALARM_IN1?"ALARM":"");
2034	}
2035	} else
2036	printf("ERROR: Can't get IN1 data!\n");
2037	free(label);
2038	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN2,&label,&valid) &&
2039	!sensors_get_feature(*name,SENSORS_MTP008_IN2,&cur) &&
2040	!sensors_get_feature(*name,SENSORS_MTP008_IN2_MIN,&min) &&
2041	!sensors_get_feature(*name,SENSORS_MTP008_IN2_MAX,&max)) {
2042	if (valid) {
2043	print_label(label,10);
2044	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2045	cur,min,max,alarms&MTP008_ALARM_IN2?"ALARM":"");
2046	}
2047	} else
2048	printf("ERROR: Can't get IN2 data!\n");
2049	free(label);
2050	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN3,&label,&valid) &&
2051	!sensors_get_feature(*name,SENSORS_MTP008_IN3,&cur) &&
2052	!sensors_get_feature(*name,SENSORS_MTP008_IN3_MIN,&min) &&
2053	!sensors_get_feature(*name,SENSORS_MTP008_IN3_MAX,&max)) {
2054	if (valid) {
2055	print_label(label,10);
2056	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2057	cur,min,max,alarms&MTP008_ALARM_IN3?"ALARM":"");
2058	}
2059	} else
2060	printf("ERROR: Can't get IN3 data!\n");
2061	free(label);
2062	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN4,&label,&valid) &&
2063	!sensors_get_feature(*name,SENSORS_MTP008_IN4,&cur) &&
2064	!sensors_get_feature(*name,SENSORS_MTP008_IN4_MIN,&min) &&
2065	!sensors_get_feature(*name,SENSORS_MTP008_IN4_MAX,&max)) {
2066	if (valid) {
2067	print_label(label,10);
2068	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2069	cur,min,max,alarms&MTP008_ALARM_IN4?"ALARM":"");
2070	}
2071	} else
2072	printf("ERROR: Can't get IN4 data!\n");
2073	free(label);
2074	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN5,&label,&valid) &&
2075	!sensors_get_feature(*name,SENSORS_MTP008_IN5,&cur) &&
2076	!sensors_get_feature(*name,SENSORS_MTP008_IN5_MIN,&min) &&
2077	!sensors_get_feature(*name,SENSORS_MTP008_IN5_MAX,&max)) {
2078	if (valid) {
2079	print_label(label,10);
2080	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2081	cur,min,max,alarms&MTP008_ALARM_IN5?"ALARM":"");
2082	}
2083	} else
2084	printf("ERROR: Can't get IN5 data!\n");
2085	free(label);
2086	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN6,&label,&valid) &&
2087	!sensors_get_feature(*name,SENSORS_MTP008_IN6,&cur) &&
2088	!sensors_get_feature(*name,SENSORS_MTP008_IN6_MIN,&min) &&
2089	!sensors_get_feature(*name,SENSORS_MTP008_IN6_MAX,&max)) {
2090	if (valid) {
2091	print_label(label,10);
2092	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2093	cur,min,max,alarms&MTP008_ALARM_IN6?"ALARM":"");
2094	}
2095	} else
2096	printf("ERROR: Can't get IN6 data!\n");
2097	free(label);
2098
2099	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN1,&label,&valid) &&
2100	!sensors_get_feature(*name,SENSORS_MTP008_FAN1,&cur) &&
2101	!sensors_get_feature(*name,SENSORS_MTP008_FAN1_DIV,&fdiv) &&
2102	!sensors_get_feature(*name,SENSORS_MTP008_FAN1_MIN,&min)) {
2103	if (valid) {
2104	print_label(label,10);
2105	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2106	cur,min,fdiv, alarms&MTP008_ALARM_FAN1?"ALARM":"");
2107	}
2108	} else
2109	printf("ERROR: Can't get FAN1 data!\n");
2110	free(label);
2111	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN2,&label,&valid) &&
2112	!sensors_get_feature(*name,SENSORS_MTP008_FAN2,&cur) &&
2113	!sensors_get_feature(*name,SENSORS_MTP008_FAN2_DIV,&fdiv) &&
2114	!sensors_get_feature(*name,SENSORS_MTP008_FAN2_MIN,&min)) {
2115	if (valid) {
2116	print_label(label,10);
2117	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2118	cur,min,fdiv, alarms&MTP008_ALARM_FAN2?"ALARM":"");
2119	}
2120	} else
2121	printf("ERROR: Can't get FAN2 data!\n");
2122	free(label);
2123	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN3,&label,&valid) &&
2124	!sensors_get_feature(*name,SENSORS_MTP008_FAN3,&cur) &&
2125	!sensors_get_feature(*name,SENSORS_MTP008_FAN3_DIV,&fdiv) &&
2126	!sensors_get_feature(*name,SENSORS_MTP008_FAN3_MIN,&min)) {
2127	if (valid) {
2128	print_label(label,10);
2129	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2130	cur,min,fdiv, alarms&MTP008_ALARM_FAN3?"ALARM":"");
2131	}
2132	} else
2133	printf("ERROR: Can't get FAN3 data!\n");
2134	free(label);
2135
2136	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP1,&label,&valid) &&
2137	!sensors_get_feature(*name,SENSORS_MTP008_TEMP1,&cur) &&
2138	!sensors_get_feature(*name,SENSORS_MTP008_TEMP1_HYST,&min) &&
2139	!sensors_get_feature(*name,SENSORS_MTP008_TEMP1_OVER,&max)) {
2140	if (valid) {
2141	print_label(label,10);
2142	print_temp_info( cur, max, min, HYST, 0, 0);
2143	printf(" %s\n", alarms&MTP008_ALARM_TEMP1?"ALARM":"");
2144	}
2145	} else
2146	printf("ERROR: Can't get TEMP1 data!\n");
2147	free(label);
2148
2149	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP2,&label,&valid) &&
2150	!sensors_get_feature(*name,SENSORS_MTP008_TEMP2,&cur) &&
2151	!sensors_get_feature(*name,SENSORS_MTP008_TEMP2_HYST,&min) &&
2152	!sensors_get_feature(*name,SENSORS_MTP008_TEMP2_OVER,&max)) {
2153	if (valid) {
2154	print_label(label,10);
2155	print_temp_info( cur, max, min, HYST, 0, 0);
2156	printf(" %s\n", alarms&MTP008_ALARM_TEMP2?"ALARM":"");
2157	}
2158	} else
2159	printf("ERROR: Can't get TEMP2 data!\n");
2160	free(label);
2161
2162	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP3,&label,&valid) &&
2163	!sensors_get_feature(*name,SENSORS_MTP008_TEMP3,&cur) &&
2164	!sensors_get_feature(*name,SENSORS_MTP008_TEMP3_HYST,&min) &&
2165	!sensors_get_feature(*name,SENSORS_MTP008_TEMP3_OVER,&max)) {
2166	if (valid) {
2167	print_label(label,10);
2168	print_temp_info( cur, max, min, HYST, 0, 0);
2169	printf(" %s\n", alarms&MTP008_ALARM_TEMP3?"ALARM":"");
2170	}
2171	} else
2172	printf("ERROR: Can't get TEMP3 data!\n");
2173	free(label);
2174
2175	if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_VID,&label,&valid) &&
2176	!sensors_get_feature(*name,SENSORS_MTP008_VID,&cur)) {
2177	if (valid) {
2178	print_label(label,10);
2179	printf("%+6.2f V\n",cur);
2180	}
2181	}
2182	free(label);
2183	}
2184
2185	void print_w83781d(const sensors_chip_name *name)
2186	{
2187	char *label;
2188	double cur,min,max,fdiv,sens;
2189	int alarms,beeps;
2190	int is81d, is82d, is83s, is697hf, is627thf, valid;
2191
2192	is81d = !strcmp(name->prefix,"w83781d");
2193	is82d = (!strcmp(name->prefix,"w83782d")) \|\|
2194	(!strcmp(name->prefix,"w83627hf")) \|\|
2195	(!strcmp(name->prefix,"w83637hf")) \|\|
2196	(!strcmp(name->prefix, "w83627thf")) \|\|
2197	(!strcmp(name->prefix, "w83687thf"));
2198	is83s = !strcmp(name->prefix,"w83783s");
2199	is627thf = (!strcmp(name->prefix,"w83627thf")) \|\|
2200	(!strcmp(name->prefix, "w83637hf")) \|\|
2201	(!strcmp(name->prefix, "w83687thf"));
2202	is697hf = !strcmp(name->prefix,"w83697hf");
2203
2204	if (!sensors_get_feature(*name,SENSORS_W83781D_ALARMS,&cur))
2205	alarms = cur + 0.5;
2206	else {
2207	printf("ERROR: Can't get alarm data!\n");
2208	alarms = 0;
2209	}
2210
2211	if (!sensors_get_feature(*name,SENSORS_W83781D_BEEPS,&cur)) {
2212	beeps = cur + 0.5;
2213	} else {
2214	printf("ERROR: Can't get beep data!\n");
2215	beeps = 0;
2216	}
2217
2218	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN0,&label,&valid) &&
2219	!sensors_get_feature(*name,SENSORS_W83781D_IN0,&cur) &&
2220	!sensors_get_feature(*name,SENSORS_W83781D_IN0_MIN,&min) &&
2221	!sensors_get_feature(*name,SENSORS_W83781D_IN0_MAX,&max)) {
2222	if (valid) {
2223	print_label(label,10);
2224	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2225	cur,min,max,alarms&W83781D_ALARM_IN0?"ALARM":" ",
2226	beeps&W83781D_ALARM_IN0?"(beep)":"");
2227	}
2228	} else
2229	printf("ERROR: Can't get IN0 data!\n");
2230	free(label);
2231	if ((!is83s) && (!is697hf)) {
2232	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN1,&label,&valid) &&
2233	!sensors_get_feature(*name,SENSORS_W83781D_IN1,&cur) &&
2234	!sensors_get_feature(*name,SENSORS_W83781D_IN1_MIN,&min) &&
2235	!sensors_get_feature(*name,SENSORS_W83781D_IN1_MAX,&max)) {
2236	if (valid) {
2237	print_label(label,10);
2238	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2239	cur,min,max,alarms&W83781D_ALARM_IN1?"ALARM":" ",
2240	beeps&W83781D_ALARM_IN1?"(beep)":"");
2241	}
2242	} else
2243	printf("ERROR: Can't get IN1 data!\n");
2244	free(label);
2245	}
2246	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN2,&label,&valid) &&
2247	!sensors_get_feature(*name,SENSORS_W83781D_IN2,&cur) &&
2248	!sensors_get_feature(*name,SENSORS_W83781D_IN2_MIN,&min) &&
2249	!sensors_get_feature(*name,SENSORS_W83781D_IN2_MAX,&max)) {
2250	if (valid) {
2251	print_label(label,10);
2252	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2253	cur,min,max,alarms&W83781D_ALARM_IN2?"ALARM":" ",
2254	beeps&W83781D_ALARM_IN2?"(beep)":"");
2255	}
2256	} else
2257	printf("ERROR: Can't get IN2 data!\n");
2258	free(label);
2259	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN3,&label,&valid) &&
2260	!sensors_get_feature(*name,SENSORS_W83781D_IN3,&cur) &&
2261	!sensors_get_feature(*name,SENSORS_W83781D_IN3_MIN,&min) &&
2262	!sensors_get_feature(*name,SENSORS_W83781D_IN3_MAX,&max)) {
2263	if (valid) {
2264	print_label(label,10);
2265	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2266	cur,min,max,alarms&W83781D_ALARM_IN3?"ALARM":" ",
2267	beeps&W83781D_ALARM_IN3?"(beep)":"");
2268	}
2269	} else
2270	printf("ERROR: Can't get IN3 data!\n");
2271	free(label);
2272	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN4,&label,&valid) &&
2273	!sensors_get_feature(*name,SENSORS_W83781D_IN4,&cur) &&
2274	!sensors_get_feature(*name,SENSORS_W83781D_IN4_MIN,&min) &&
2275	!sensors_get_feature(*name,SENSORS_W83781D_IN4_MAX,&max)) {
2276	if (valid) {
2277	print_label(label,10);
2278	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2279	cur,min,max,alarms&W83781D_ALARM_IN4?"ALARM":" ",
2280	beeps&W83781D_ALARM_IN4?"(beep)":"");
2281	}
2282	} else
2283	printf("ERROR: Can't get IN4 data!\n");
2284	free(label);
2285	if (!is627thf) {
2286	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN5,&label,&valid) &&
2287	!sensors_get_feature(*name,SENSORS_W83781D_IN5,&cur) &&
2288	!sensors_get_feature(*name,SENSORS_W83781D_IN5_MIN,&min) &&
2289	!sensors_get_feature(*name,SENSORS_W83781D_IN5_MAX,&max)) {
2290	if (valid) {
2291	print_label(label,10);
2292	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2293	cur,min,max,alarms&W83781D_ALARM_IN5?"ALARM":" ",
2294	beeps&W83781D_ALARM_IN5?"(beep)":"");
2295	}
2296	} else
2297	printf("ERROR: Can't get IN5 data!\n");
2298	free(label);
2299	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN6,&label,&valid) &&
2300	!sensors_get_feature(*name,SENSORS_W83781D_IN6,&cur) &&
2301	!sensors_get_feature(*name,SENSORS_W83781D_IN6_MIN,&min) &&
2302	!sensors_get_feature(*name,SENSORS_W83781D_IN6_MAX,&max)) {
2303	if (valid) {
2304	print_label(label,10);
2305	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2306	cur,min,max,alarms&W83781D_ALARM_IN6?"ALARM":" ",
2307	beeps&W83781D_ALARM_IN6?"(beep)":"");
2308	}
2309	} else
2310	printf("ERROR: Can't get IN6 data!\n");
2311	free(label);
2312	} /* !is627thf */
2313	if (is82d \|\| is697hf \|\| is627thf) {
2314	if (!sensors_get_label_and_valid(*name,SENSORS_W83782D_IN7,&label,&valid) &&
2315	!sensors_get_feature(*name,SENSORS_W83782D_IN7,&cur) &&
2316	!sensors_get_feature(*name,SENSORS_W83782D_IN7_MIN,&min) &&
2317	!sensors_get_feature(*name,SENSORS_W83782D_IN7_MAX,&max)) {
2318	if (valid) {
2319	print_label(label,10);
2320	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2321	cur,min,max,alarms&W83782D_ALARM_IN7?"ALARM":" ",
2322	beeps&W83782D_ALARM_IN7?"(beep)":"");
2323	}
2324	} else
2325	printf("ERROR: Can't get IN7 data!\n");
2326	free(label);
2327	if (!sensors_get_label_and_valid(*name,SENSORS_W83782D_IN8,&label,&valid) &&
2328	!sensors_get_feature(*name,SENSORS_W83782D_IN8,&cur) &&
2329	!sensors_get_feature(*name,SENSORS_W83782D_IN8_MIN,&min) &&
2330	!sensors_get_feature(*name,SENSORS_W83782D_IN8_MAX,&max)) {
2331	if (valid) {
2332	print_label(label,10);
2333	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s %s\n",
2334	cur,min,max,alarms&W83782D_ALARM_IN8?"ALARM":" ",
2335	beeps&W83782D_ALARM_IN8?"(beep)":"");
2336	}
2337	} else
2338	printf("ERROR: Can't get IN8 data!\n");
2339	free(label);
2340	}
2341
2342	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN1,&label,&valid) &&
2343	!sensors_get_feature(*name,SENSORS_W83781D_FAN1,&cur) &&
2344	!sensors_get_feature(*name,SENSORS_W83781D_FAN1_DIV,&fdiv) &&
2345	!sensors_get_feature(*name,SENSORS_W83781D_FAN1_MIN,&min)) {
2346	if (valid) {
2347	print_label(label,10);
2348	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
2349	cur,min,fdiv, alarms&W83781D_ALARM_FAN1?"ALARM":" ",
2350	beeps&W83781D_ALARM_FAN1?"(beep)":"");
2351	}
2352	} else
2353	printf("ERROR: Can't get FAN1 data!\n");
2354	free(label);
2355	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN2,&label,&valid) &&
2356	!sensors_get_feature(*name,SENSORS_W83781D_FAN2,&cur) &&
2357	!sensors_get_feature(*name,SENSORS_W83781D_FAN2_DIV,&fdiv) &&
2358	!sensors_get_feature(*name,SENSORS_W83781D_FAN2_MIN,&min)) {
2359	if (valid) {
2360	print_label(label,10);
2361	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
2362	cur,min,fdiv, alarms&W83781D_ALARM_FAN2?"ALARM":" ",
2363	beeps&W83781D_ALARM_FAN2?"(beep)":"");
2364	}
2365	} else
2366	printf("ERROR: Can't get FAN2 data!\n");
2367	free(label);
2368
2369	if(!is697hf) {
2370	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN3,&label,&valid) &&
2371	!sensors_get_feature(*name,SENSORS_W83781D_FAN3,&cur) &&
2372	!sensors_get_feature(*name,SENSORS_W83781D_FAN3_DIV,&fdiv) &&
2373	!sensors_get_feature(*name,SENSORS_W83781D_FAN3_MIN,&min)) {
2374	if (valid) {
2375	print_label(label,10);
2376	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s %s\n",
2377	cur,min,fdiv, alarms&W83781D_ALARM_FAN3?"ALARM":" ",
2378	beeps&W83781D_ALARM_FAN3?"(beep)":"");
2379	}
2380	} else
2381	printf("ERROR: Can't get FAN3 data!\n");
2382	free(label);
2383	}
2384
2385	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP1,&label,&valid) &&
2386	!sensors_get_feature(*name,SENSORS_W83781D_TEMP1,&cur) &&
2387	!sensors_get_feature(*name,SENSORS_W83781D_TEMP1_HYST,&min) &&
2388	!sensors_get_feature(*name,SENSORS_W83781D_TEMP1_OVER,&max)) {
2389	if (valid) {
2390	if((!is82d) && (!is83s) && (!is697hf)) {
2391	print_label(label,10);
2392	if(min == 127)
2393	print_temp_info( cur, max, 0, MAXONLY, 0, 0);
2394	else
2395	print_temp_info( cur, max, min, HYST, 0, 0);
2396	printf(" %s %s\n", alarms&W83781D_ALARM_TEMP1 ?"ALARM":" ",
2397	beeps&W83781D_ALARM_TEMP1?"(beep)":"");
2398	} else {
2399	if(!sensors_get_feature(*name,SENSORS_W83781D_SENS1,&sens)) {
2400	print_label(label,10);
2401	if(min == 127)
2402	print_temp_info( cur, max, 0, MAXONLY, 0, 0);
2403	else
2404	print_temp_info( cur, max, min, HYST, 0, 0);
2405	printf( " sensor = %s %s %s\n",
2406	(((int)sens)==1)?"diode":(((int)sens)==2)?
2407	"transistor":"thermistor",
2408	alarms&W83781D_ALARM_TEMP1?"ALARM":" ",
2409	beeps&W83781D_ALARM_TEMP1?"(beep)":"");
2410	} else {
2411	printf("ERROR: Can't get TEMP1 data!\n");
2412	}
2413	}
2414	}
2415	} else
2416	printf("ERROR: Can't get TEMP1 data!\n");
2417	free(label);
2418
2419	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP2,&label,&valid) &&
2420	!sensors_get_feature(*name,SENSORS_W83781D_TEMP2,&cur) &&
2421	!sensors_get_feature(*name,SENSORS_W83781D_TEMP2_HYST,&min) &&
2422	!sensors_get_feature(*name,SENSORS_W83781D_TEMP2_OVER,&max)) {
2423	if (valid) {
2424	if((!is82d) && (!is83s) && (!is697hf)) {
2425	print_label(label,10);
2426	print_temp_info( cur, max, min, HYST, 1, 0);
2427	printf(" %s %s\n", alarms&W83781D_ALARM_TEMP2 ?"ALARM":" ",
2428	beeps&W83781D_ALARM_TEMP2?"(beep)":"");
2429	} else {
2430	if(!sensors_get_feature(*name,SENSORS_W83781D_SENS2,&sens)) {
2431	print_label(label,10);
2432	print_temp_info( cur, max, min, HYST, 1, 0);
2433	printf( " sensor = %s %s %s\n",
2434	(((int)sens)==1)?"diode":(((int)sens)==2)?
2435	"transistor":"thermistor",
2436	alarms&W83781D_ALARM_TEMP2?"ALARM":" ",
2437	beeps&W83781D_ALARM_TEMP2?"(beep)":"");
2438	} else {
2439	printf("ERROR: Can't get TEMP2 data!\n");
2440	}
2441	}
2442	}
2443	} else
2444	printf("ERROR: Can't get TEMP2 data!\n");
2445	free(label);
2446
2447	if ((!is83s) && (!is697hf)) {
2448	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP3,&label,&valid) &&
2449	!sensors_get_feature(*name,SENSORS_W83781D_TEMP3,&cur) &&
2450	!sensors_get_feature(*name,SENSORS_W83781D_TEMP3_HYST,&min) &&
2451	!sensors_get_feature(*name,SENSORS_W83781D_TEMP3_OVER,&max)) {
2452	if (valid) {
2453	if(!is82d) {
2454	print_label(label,10);
2455	print_temp_info( cur, max, min, HYST, 1, 0);
2456	if (!is81d)
2457	printf(" %s %s\n", alarms&W83781D_ALARM_TEMP3?"ALARM":" ",
2458	beeps&W83781D_ALARM_TEMP3?"(beep)":"");
2459	else
2460	printf(" %s %s\n", alarms&W83781D_ALARM_TEMP23?"ALARM":" ",
2461	beeps&W83781D_ALARM_TEMP23?"(beep)":"");
2462	} else {
2463	if(!sensors_get_feature(*name,SENSORS_W83781D_SENS3,&sens)) {
2464	print_label(label,10);
2465	print_temp_info( cur, max, min, HYST, 1, 0);
2466	printf( " sensor = %s %s %s\n",
2467	(((int)sens)==1)?"diode":(((int)sens)==2)?
2468	"transistor":"thermistor",
2469	alarms&W83781D_ALARM_TEMP3?"ALARM":" ",
2470	beeps&W83781D_ALARM_TEMP3?"(beep)":"");
2471	} else {
2472	printf("ERROR: Can't get TEMP3 data!\n");
2473	}
2474	}
2475	}
2476	} else
2477	printf("ERROR: Can't get TEMP3 data!\n");
2478	free(label);
2479	}
2480
2481	if(!is697hf) {
2482	print_vid_info(name, SENSORS_W83781D_VID, SENSORS_W83781D_VRM);
2483	}
2484
2485	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_ALARMS,&label,&valid)
2486	&& valid && !is83s) {
2487	print_label(label,10);
2488	if (alarms & W83781D_ALARM_CHAS)
2489	printf("Chassis intrusion detection ALARM\n");
2490	else
2491	printf("\n");
2492	}
2493	free(label);
2494
2495	if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_BEEP_ENABLE,&label,&valid)
2496	&& valid) {
2497	if (!sensors_get_feature(*name,SENSORS_W83781D_BEEP_ENABLE,&cur)) {
2498	print_label(label,10);
2499	if (cur < 0.5)
2500	printf("Sound alarm disabled\n");
2501	else
2502	printf("Sound alarm enabled\n");
2503	} else
2504	printf("ERROR: Can't get BEEP data!\n");
2505	}
2506	free(label);
2507	}
2508
2509
2510	void print_w83792d(const sensors_chip_name *name)
2511	{
2512	char *label;
2513	int alarms;
2514	double cur,min,max,fdiv;
2515	int valid = 0;
2516
2517	if (!sensors_get_feature(*name,SENSORS_W83792D_ALARMS,&cur))
2518	alarms = cur + 0.5;
2519	else {
2520	printf("ERROR: Can't get alarm data!\n");
2521	alarms = 0;
2522	}
2523
2524	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN0,&label,&valid) &&
2525	!sensors_get_feature(*name,SENSORS_W83792D_IN0,&cur) &&
2526	!sensors_get_feature(*name,SENSORS_W83792D_IN0_MIN,&min) &&
2527	!sensors_get_feature(*name,SENSORS_W83792D_IN0_MAX,&max)) {
2528	if (valid) {
2529	print_label(label,10);
2530	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2531	cur,min,max, (alarms&W83792D_ALARM_IN0)?"ALARM":"");
2532	}
2533	} else
2534	printf("ERROR: Can't get IN0 data!\n");
2535	free(label);
2536
2537	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN1,&label,&valid) &&
2538	!sensors_get_feature(*name,SENSORS_W83792D_IN1,&cur) &&
2539	!sensors_get_feature(*name,SENSORS_W83792D_IN1_MIN,&min) &&
2540	!sensors_get_feature(*name,SENSORS_W83792D_IN1_MAX,&max)) {
2541	if (valid) {
2542	print_label(label,10);
2543	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2544	cur,min,max, (alarms&W83792D_ALARM_IN1)?"ALARM":"");
2545	}
2546	} else
2547	printf("ERROR: Can't get IN1 data!\n");
2548	free(label);
2549
2550	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN2,&label,&valid) &&
2551	!sensors_get_feature(*name,SENSORS_W83792D_IN2,&cur) &&
2552	!sensors_get_feature(*name,SENSORS_W83792D_IN2_MIN,&min) &&
2553	!sensors_get_feature(*name,SENSORS_W83792D_IN2_MAX,&max)) {
2554	if (valid) {
2555	print_label(label,10);
2556	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2557	cur,min,max, (alarms&W83792D_ALARM_IN2)?"ALARM":"");
2558	}
2559	} else
2560	printf("ERROR: Can't get IN2 data!\n");
2561	free(label);
2562
2563	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN3,&label,&valid) &&
2564	!sensors_get_feature(*name,SENSORS_W83792D_IN3,&cur) &&
2565	!sensors_get_feature(*name,SENSORS_W83792D_IN3_MIN,&min) &&
2566	!sensors_get_feature(*name,SENSORS_W83792D_IN3_MAX,&max)) {
2567	if (valid) {
2568	print_label(label,10);
2569	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2570	cur,min,max, (alarms&W83792D_ALARM_IN3)?"ALARM":"");
2571	}
2572	} else
2573	printf("ERROR: Can't get IN3 data!\n");
2574	free(label);
2575
2576	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN4,&label,&valid) &&
2577	!sensors_get_feature(*name,SENSORS_W83792D_IN4,&cur) &&
2578	!sensors_get_feature(*name,SENSORS_W83792D_IN4_MIN,&min) &&
2579	!sensors_get_feature(*name,SENSORS_W83792D_IN4_MAX,&max)) {
2580	if (valid) {
2581	print_label(label,10);
2582	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2583	cur,min,max, (alarms&W83792D_ALARM_IN4)?"ALARM":"");
2584	}
2585	} else
2586	printf("ERROR: Can't get IN4 data!\n");
2587	free(label);
2588
2589	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN5,&label,&valid) &&
2590	!sensors_get_feature(*name,SENSORS_W83792D_IN5,&cur) &&
2591	!sensors_get_feature(*name,SENSORS_W83792D_IN5_MIN,&min) &&
2592	!sensors_get_feature(*name,SENSORS_W83792D_IN5_MAX,&max)) {
2593	if (valid) {
2594	print_label(label,10);
2595	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2596	cur,min,max, (alarms&W83792D_ALARM_IN5)?"ALARM":"");
2597	}
2598	} else
2599	printf("ERROR: Can't get IN5 data!\n");
2600	free(label);
2601
2602	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN6,&label,&valid) &&
2603	!sensors_get_feature(*name,SENSORS_W83792D_IN6,&cur) &&
2604	!sensors_get_feature(*name,SENSORS_W83792D_IN6_MIN,&min) &&
2605	!sensors_get_feature(*name,SENSORS_W83792D_IN6_MAX,&max)) {
2606	if (valid) {
2607	print_label(label,10);
2608	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2609	cur,min,max, (alarms&W83792D_ALARM_IN6)?"ALARM":"");
2610	}
2611	} else
2612	printf("ERROR: Can't get IN6 data!\n");
2613	free(label);
2614
2615	if (!sensors_get_label_and_valid(*name, SENSORS_W83792D_IN7,
2616	&label, &valid) &&
2617	!sensors_get_feature(*name, SENSORS_W83792D_IN7, &cur) &&
2618	!sensors_get_feature(*name, SENSORS_W83792D_IN7_MIN, &min) &&
2619	!sensors_get_feature(*name, SENSORS_W83792D_IN7_MAX, &max)) {
2620	if (valid) {
2621	print_label(label,10);
2622	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2623	cur,min,max, (alarms&W83792D_ALARM_IN7)?"ALARM":"");
2624	}
2625	} else
2626	printf("ERROR: Can't get IN7 data!\n");
2627	free(label);
2628
2629	if (!sensors_get_label_and_valid(*name, SENSORS_W83792D_IN8,
2630	&label, &valid) &&
2631	!sensors_get_feature(*name, SENSORS_W83792D_IN8, &cur) &&
2632	!sensors_get_feature(*name, SENSORS_W83792D_IN8_MIN, &min) &&
2633	!sensors_get_feature(*name, SENSORS_W83792D_IN8_MAX, &max)) {
2634	if (valid) {
2635	print_label(label,10);
2636	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2637	cur,min,max, (alarms&W83792D_ALARM_IN8)?"ALARM":"");
2638	}
2639	} else
2640	printf("ERROR: Can't get IN8 data!\n");
2641	free(label);
2642
2643	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN1,&label,&valid) &&
2644	!sensors_get_feature(*name,SENSORS_W83792D_FAN1,&cur) &&
2645	!sensors_get_feature(*name,SENSORS_W83792D_FAN1_DIV,&fdiv) &&
2646	!sensors_get_feature(*name,SENSORS_W83792D_FAN1_MIN,&min)) {
2647	if (valid) {
2648	print_label(label,10);
2649	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2650	cur,min,fdiv, (alarms&W83792D_ALARM_FAN1)?"ALARM":"");
2651	}
2652	} else
2653	printf("ERROR: Can't get FAN1 data!\n");
2654	free(label);
2655
2656	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN2,&label,&valid) &&
2657	!sensors_get_feature(*name,SENSORS_W83792D_FAN2,&cur) &&
2658	!sensors_get_feature(*name,SENSORS_W83792D_FAN2_DIV,&fdiv) &&
2659	!sensors_get_feature(*name,SENSORS_W83792D_FAN2_MIN,&min)) {
2660	if (valid) {
2661	print_label(label,10);
2662	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2663	cur,min,fdiv, (alarms&W83792D_ALARM_FAN2)?"ALARM":"");
2664	}
2665	} else
2666	printf("ERROR: Can't get FAN2 data!\n");
2667	free(label);
2668
2669	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN3,&label,&valid) &&
2670	!sensors_get_feature(*name,SENSORS_W83792D_FAN3,&cur) &&
2671	!sensors_get_feature(*name,SENSORS_W83792D_FAN3_DIV,&fdiv) &&
2672	!sensors_get_feature(*name,SENSORS_W83792D_FAN3_MIN,&min)) {
2673	if (valid) {
2674	print_label(label,10);
2675	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2676	cur,min,fdiv, (alarms&W83792D_ALARM_FAN3)?"ALARM":"");
2677	}
2678	} else
2679	printf("ERROR: Can't get FAN3 data!\n");
2680	free(label);
2681
2682	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN4,&label,&valid) &&
2683	!sensors_get_feature(*name,SENSORS_W83792D_FAN4,&cur) &&
2684	!sensors_get_feature(*name,SENSORS_W83792D_FAN4_DIV,&fdiv) &&
2685	!sensors_get_feature(*name,SENSORS_W83792D_FAN4_MIN,&min)) {
2686	if (valid) {
2687	print_label(label,10);
2688	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2689	cur,min,fdiv, (alarms&W83792D_ALARM_FAN4)?"ALARM":"");
2690	}
2691	}
2692	free(label);
2693
2694	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN5,&label,&valid) &&
2695	!sensors_get_feature(*name,SENSORS_W83792D_FAN5,&cur) &&
2696	!sensors_get_feature(*name,SENSORS_W83792D_FAN5_DIV,&fdiv) &&
2697	!sensors_get_feature(*name,SENSORS_W83792D_FAN5_MIN,&min)) {
2698	if (valid) {
2699	print_label(label,10);
2700	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2701	cur,min,fdiv, (alarms&W83792D_ALARM_FAN5)?"ALARM":"");
2702	}
2703	}
2704	free(label);
2705
2706	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN6,&label,&valid) &&
2707	!sensors_get_feature(*name,SENSORS_W83792D_FAN6,&cur) &&
2708	!sensors_get_feature(*name,SENSORS_W83792D_FAN6_DIV,&fdiv) &&
2709	!sensors_get_feature(*name,SENSORS_W83792D_FAN6_MIN,&min)) {
2710	if (valid) {
2711	print_label(label,10);
2712	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2713	cur,min,fdiv, (alarms&W83792D_ALARM_FAN6)?"ALARM":"");
2714	}
2715	}
2716	free(label);
2717
2718	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN7,&label,&valid) &&
2719	!sensors_get_feature(*name,SENSORS_W83792D_FAN7,&cur) &&
2720	!sensors_get_feature(*name,SENSORS_W83792D_FAN7_DIV,&fdiv) &&
2721	!sensors_get_feature(*name,SENSORS_W83792D_FAN7_MIN,&min)) {
2722	if (valid) {
2723	print_label(label,10);
2724	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2725	cur,min,fdiv, (alarms&W83792D_ALARM_FAN7)?"ALARM":"");
2726	}
2727	}
2728	free(label);
2729
2730	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_TEMP1,&label,&valid) &&
2731	!sensors_get_feature(*name,SENSORS_W83792D_TEMP1,&cur) &&
2732	!sensors_get_feature(*name,SENSORS_W83792D_TEMP1_HYST,&min) &&
2733	!sensors_get_feature(*name,SENSORS_W83792D_TEMP1_OVER,&max)) {
2734	if (valid) {
2735	print_label(label,10);
2736	if(min == 127){
2737	print_temp_info( cur, max, 0, MAXONLY, 1, 1);
2738	printf(" %s\n", (cur>max)?"ALARM":"");
2739	}else{
2740	print_temp_info( cur, max, min, HYST, 1, 1);
2741	printf(" %s\n", (alarms&W83792D_ALARM_TEMP1)?"ALARM":"");
2742	}
2743	}
2744	} else
2745	printf("ERROR: Can't get TEMP1 data!\n");
2746	free(label);
2747
2748	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_TEMP2,&label,&valid) &&
2749	!sensors_get_feature(*name,SENSORS_W83792D_TEMP2,&cur) &&
2750	!sensors_get_feature(*name,SENSORS_W83792D_TEMP2_HYST,&min) &&
2751	!sensors_get_feature(*name,SENSORS_W83792D_TEMP2_OVER,&max)) {
2752	if (valid) {
2753	print_label(label,10);
2754	print_temp_info( cur, max, min, HYST, 1, 1);
2755	printf(" %s\n", (alarms&W83792D_ALARM_TEMP2)?"ALARM":"");
2756	}
2757	} else
2758	printf("ERROR: Can't get TEMP2 data!\n");
2759	free(label);
2760
2761	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_TEMP3,&label,&valid) &&
2762	!sensors_get_feature(*name,SENSORS_W83792D_TEMP3,&cur) &&
2763	!sensors_get_feature(*name,SENSORS_W83792D_TEMP3_HYST,&min) &&
2764	!sensors_get_feature(*name,SENSORS_W83792D_TEMP3_OVER,&max)) {
2765	if (valid) {
2766	print_label(label,10);
2767	print_temp_info( cur, max, min, HYST, 1, 1);
2768	printf(" %s\n", (alarms&W83792D_ALARM_TEMP3)?"ALARM":"");
2769	}
2770	} else
2771	printf("ERROR: Can't get TEMP3 data!\n");
2772	free(label);
2773
2774	/* print_vid_info(name, SENSORS_W83792D_VID, SENSORS_W83792D_VRM); */
2775
2776	if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_CHASSIS,&label,&valid) &&
2777	!sensors_get_feature(*name,SENSORS_W83792D_CHASSIS,&cur) )
2778	{
2779	if (valid) {
2780	print_label(label,10);
2781	if (cur==1) {
2782	printf("Chassis intrusion detection ALARM\n");
2783	}else{
2784	printf("Chassis is normal.\n");
2785	}
2786	}
2787	}else{
2788	printf("ERROR: Can't get Chassis data!\n");
2789	}
2790	free(label);
2791	}
2792
2793	void print_w83l785ts(const sensors_chip_name *name)
2794	{
2795	char *label;
2796	double cur, over;
2797	int valid;
2798
2799	if (!sensors_get_label_and_valid(*name, SENSORS_W83L785TS_TEMP, &label, &valid)
2800	&& !sensors_get_feature(*name, SENSORS_W83L785TS_TEMP, &cur)
2801	&& !sensors_get_feature(*name, SENSORS_W83L785TS_TEMP_OVER, &over)) {
2802	if (valid) {
2803	print_label(label, 10);
2804	print_temp_info(cur, over, 0, MAXONLY, 0, 0);
2805	printf("\n");
2806	}
2807	} else
2808	printf("ERROR: Can't get temperature data!\n");
2809	free(label);
2810	}
2811
2812	void print_w83627ehf(const sensors_chip_name *name)
2813	{
2814	char *label;
2815	int i, valid;
2816	double cur, min, div, max, alarm, over, hyst;
2817
2818	for (i = 0; i < 10; i++) {
2819	if (!sensors_get_label_and_valid(*name,SENSORS_W83627EHF_IN0+i,
2820	&label,&valid)
2821	&& !sensors_get_feature(*name,SENSORS_W83627EHF_IN0+i,&cur)
2822	&& !sensors_get_feature(*name,SENSORS_W83627EHF_IN0_MIN+i,&min)
2823	&& !sensors_get_feature(*name,SENSORS_W83627EHF_IN0_MAX+i,&max)
2824	&& !sensors_get_feature(*name,SENSORS_W83627EHF_IN0_ALARM+i,&alarm)) {
2825	if (valid) {
2826	print_label(label,10);
2827	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
2828	cur,min,max,alarm ? "ALARM" : "");
2829	}
2830	}
2831	/* Earlier versions of the driver did not have voltage support, so we
2832	keep quiet on error */
2833	free(label);
2834	}
2835
2836	for (i = 0; i < 5; i++) {
2837	if (!sensors_get_label_and_valid(*name, SENSORS_W83627EHF_FAN1+i,
2838	&label, &valid)
2839	&& !sensors_get_feature(*name, SENSORS_W83627EHF_FAN1+i, &cur)
2840	&& !sensors_get_feature(*name, SENSORS_W83627EHF_FAN1_MIN+i, &min)) {
2841	if (valid) {
2842	print_label(label,10);
2843	printf("%4.0f RPM (min = %4.0f RPM", cur, min);
2844	if (!sensors_get_feature(*name, SENSORS_W83627EHF_FAN1_DIV+i, &div))
2845	printf(", div = %1.0f", div);
2846	printf(")");
2847	if (!sensors_get_feature(*name, SENSORS_W83627EHF_FAN1_ALARM+i,
2848	&alarm) && alarm)
2849	printf(" ALARM");
2850	printf("\n");
2851	}
2852	} else if (i < 3)
2853	printf("ERROR: Can't get FAN%d data!\n", i + 1);
2854	free(label);
2855	}
2856
2857	for (i = 0; i < 3; i++) {
2858	if (!sensors_get_label_and_valid(*name, SENSORS_W83627EHF_TEMP1+i,
2859	&label, &valid)
2860	&& !sensors_get_feature(*name, SENSORS_W83627EHF_TEMP1+i, &cur)
2861	&& !sensors_get_feature(*name, SENSORS_W83627EHF_TEMP1_OVER+i, &over)
2862	&& !sensors_get_feature(*name, SENSORS_W83627EHF_TEMP1_HYST+i, &hyst)) {
2863	if (valid) {
2864	print_label(label,10);
2865	print_temp_info(cur, over, hyst, HYST, i ? 1 : 0, i ? 1 : 0);
2866	if (!sensors_get_feature(*name, SENSORS_W83627EHF_TEMP1_ALARM+i,
2867	&alarm) && alarm)
2868	printf(" ALARM");
2869	printf("\n");
2870	}
2871	} else
2872	printf("ERROR: Can't get TEMP%d data!\n", i + 1);
2873	free(label);
2874	}
2875	}
2876
2877	void print_maxilife(const sensors_chip_name *name)
2878	{
2879	char *label;
2880	double cur, min, max;
2881	int alarms,valid;
2882
2883	if (!sensors_get_feature(*name, SENSORS_MAXI_CG_ALARMS, &cur))
2884	alarms = cur + 0.5;
2885	else {
2886	printf("ERROR: Can't get alarm data!\n");
2887	alarms = 0;
2888	}
2889
2890	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP1, &label,&valid) &&
2891	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1, &cur) &&
2892	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1_MAX, &max) &&
2893	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1_HYST, &min)) {
2894	if (valid && (cur \|\| max \|\| min)) {
2895	print_label(label, 12);
2896	print_temp_info( cur, max, min, HYST, 1, 0);
2897	printf("\n");
2898	}
2899	} else
2900	printf("ERROR: Can't get TEMP1 data!\n");
2901	free(label);
2902
2903	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP2, &label,&valid) &&
2904	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2, &cur) &&
2905	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2_MAX, &max) &&
2906	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2_HYST, &min)) {
2907	if (valid && (cur \|\| max \|\| min)) {
2908	print_label(label, 12);
2909	print_temp_info( cur, max, min, HYST, 1, 0);
2910	printf(" %s\n", alarms&MAXI_ALARM_TEMP2 ? "ALARM" : "");
2911	}
2912	} else
2913	printf("ERROR: Can't get TEMP2 data!\n");
2914	free(label);
2915
2916	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP3, &label,&valid) &&
2917	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3, &cur) &&
2918	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3_MAX, &max) &&
2919	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3_HYST, &min)) {
2920	if (valid && (cur \|\| max \|\| min)) {
2921	print_label(label, 12);
2922	print_temp_info( cur, max, min, HYST, 1, 0);
2923	printf("\n");
2924	}
2925	} else
2926	printf("ERROR: Can't get TEMP3 data!\n");
2927	free(label);
2928
2929	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP4, &label,&valid) &&
2930	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4, &cur) &&
2931	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4_MAX, &max) &&
2932	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4_HYST, &min)) {
2933	if (valid && (cur \|\| max \|\| min)) {
2934	print_label(label, 12);
2935	print_temp_info( cur, max, min, HYST, 1, 0);
2936	printf(" %s\n", alarms&MAXI_ALARM_TEMP4 ? "ALARM" : "");
2937	}
2938	} else
2939	printf("ERROR: Can't get TEMP4 data!\n");
2940	free(label);
2941
2942	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP5, &label,&valid) &&
2943	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5, &cur) &&
2944	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5_MAX, &max) &&
2945	!sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5_HYST, &min)) {
2946	if (valid && (cur \|\| max \|\| min)) {
2947	print_label(label, 12);
2948	print_temp_info( cur, max, min, HYST, 1, 0);
2949	printf(" %s\n", alarms&MAXI_ALARM_TEMP5 ? "ALARM" : "");
2950	}
2951	} else
2952	printf("ERROR: Can't get TEMP5 data!\n");
2953	free(label);
2954
2955	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN1, &label,&valid) &&
2956	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1, &cur) &&
2957	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1_MIN, &min) &&
2958	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1_DIV, &max)) {
2959	if (valid && (cur \|\| min \|\| max)) {
2960	print_label(label, 12);
2961	if (cur < 0)
2962	printf(" OFF (min = %4.0f RPM, div = %1.0f) %s\n",
2963	min/max, max, alarms&MAXI_ALARM_FAN1 ? "ALARM" : "");
2964	else
2965	printf("%5.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2966	cur/max, min/max, max, alarms&MAXI_ALARM_FAN1 ? "ALARM" : "");
2967	}
2968	} else
2969	printf("ERROR: Can't get FAN1 data!\n");
2970	free(label);
2971
2972	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN2, &label,&valid) &&
2973	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2, &cur) &&
2974	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2_MIN, &min) &&
2975	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2_DIV, &max)) {
2976	if (valid && (cur \|\| min \|\| max)) {
2977	print_label(label, 12);
2978	if (cur < 0)
2979	printf(" OFF (min = %4.0f RPM, div = %1.0f) %s\n",
2980	min/max, max, alarms&MAXI_ALARM_FAN2 ? "ALARM" : "");
2981	else
2982	printf("%5.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
2983	cur/max, min/max, max, alarms&MAXI_ALARM_FAN2 ? "ALARM" : "");
2984	}
2985	} else
2986	printf("ERROR: Can't get FAN2 data!\n");
2987	free(label);
2988
2989	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN3, &label,&valid) &&
2990	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3, &cur) &&
2991	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3_MIN, &min) &&
2992	!sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3_DIV, &max)) {
2993	if (valid && (cur \|\| min \|\| max)) {
2994	print_label(label, 12);
2995	if (cur < 0)
2996	printf(" OFF (min = %4.0f RPM, div = %1.0f) %s\n",
2997	min/max, max, alarms&MAXI_ALARM_FAN3 ? "ALARM" : "");
2998	else
2999	printf("%5.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3000	cur/max, min/max, max, alarms&MAXI_ALARM_FAN3 ? "ALARM" : "");
3001	}
3002	} else
3003	printf("ERROR: Can't get FAN3 data!\n");
3004	free(label);
3005
3006	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_PLL, &label,&valid) &&
3007	!sensors_get_feature(*name, SENSORS_MAXI_CG_PLL, &cur) &&
3008	!sensors_get_feature(*name, SENSORS_MAXI_CG_PLL_MIN, &min) &&
3009	!sensors_get_feature(*name, SENSORS_MAXI_CG_PLL_MAX, &max)) {
3010	if (valid && (cur \|\| min \|\| max)) {
3011	print_label(label, 12);
3012	printf("%4.2f MHz (min = %4.2f MHz, max = %4.2f MHz) %s\n",
3013	cur, min, max, alarms&MAXI_ALARM_PLL ? "ALARM" : "");
3014	}
3015	} else
3016	printf("ERROR: Can't get PLL data!\n");
3017	free(label);
3018
3019	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID1, &label,&valid) &&
3020	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID1, &cur) &&
3021	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID1_MIN, &min) &&
3022	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID1_MAX, &max)) {
3023	if (valid && (cur \|\| min \|\| max)) {
3024	print_label(label, 12);
3025	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3026	cur, min, max, alarms&MAXI_ALARM_VID1 ? "ALARM" : "");
3027	}
3028	} else
3029	printf("ERROR: Can't get VID1 data!\n");
3030	free(label);
3031
3032	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID2, &label,&valid) &&
3033	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID2, &cur) &&
3034	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID2_MIN, &min) &&
3035	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID2_MAX, &max)) {
3036	if (valid && (cur \|\| min \|\| max)) {
3037	print_label(label, 12);
3038	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3039	cur, min, max, alarms&MAXI_ALARM_VID2 ? "ALARM" : "");
3040	}
3041	} else
3042	printf("ERROR: Can't get VID2 data!\n");
3043	free(label);
3044
3045	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID3, &label,&valid) &&
3046	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID3, &cur) &&
3047	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID3_MIN, &min) &&
3048	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID3_MAX, &max)) {
3049	if (valid && (cur \|\| min \|\| max)) {
3050	print_label(label, 12);
3051	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3052	cur, min, max, alarms&MAXI_ALARM_VID3 ? "ALARM" : "");
3053	}
3054	} else
3055	printf("ERROR: Can't get VID3 data!\n");
3056	free(label);
3057
3058	if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID4, &label,&valid) &&
3059	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID4, &cur) &&
3060	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID4_MIN, &min) &&
3061	!sensors_get_feature(*name, SENSORS_MAXI_CG_VID4_MAX, &max)) {
3062	if (valid && (cur \|\| min \|\| max)) {
3063	print_label(label, 12);
3064	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3065	cur, min, max, alarms&MAXI_ALARM_VID4 ? "ALARM" : "");
3066	}
3067	} else
3068	printf("ERROR: Can't get VID4 data!\n");
3069	free(label);
3070	}
3071
3072	void print_ddcmon(const sensors_chip_name *name)
3073	{
3074	char *label;
3075	double a, b, c;
3076	int valid, i;
3077
3078	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_MAN_ID, &label, &valid)
3079	&& !sensors_get_feature(*name, SENSORS_DDCMON_MAN_ID, &a)) {
3080	if (valid) {
3081	i = (int) a;
3082	print_label(label, 24);
3083	printf("%c%c%c\n",
3084	((i >> 10) & 0x1f) + 'A' - 1, ((i >> 5) & 0x1f) + 'A' - 1,
3085	(i & 0x1f) + 'A' - 1);
3086	}
3087	} else
3088	printf("ERROR: data 1\n");
3089	free(label);
3090
3091	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_PROD_ID, &label, &valid)
3092	&& !sensors_get_feature(*name, SENSORS_DDCMON_PROD_ID, &a)) {
3093	if (valid) {
3094	i = (int) a;
3095	print_label(label, 24);
3096	printf("0x%04X\n", i);
3097	}
3098	} else
3099	printf("ERROR: data 2\n");
3100	free(label);
3101
3102	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_SERIAL, &label,&valid) &&
3103	!sensors_get_feature(*name, SENSORS_DDCMON_SERIAL, &a)) {
3104	if (valid) {
3105	print_label(label, 24);
3106	printf("%d\n", (int) a);
3107	}
3108	} else
3109	printf("ERROR: data 3\n");
3110	free(label);
3111
3112	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_YEAR, &label, &valid)
3113	&& !sensors_get_feature(*name, SENSORS_DDCMON_YEAR, &a)
3114	&& !sensors_get_feature(*name, SENSORS_DDCMON_WEEK, &b)) {
3115	if (valid) {
3116	print_label(label, 24);
3117	printf("%d-W%d\n", (int) a, (int) b);
3118	}
3119	} else
3120	printf("ERROR: data 4\n");
3121	free(label);
3122
3123	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_EDID_VER, &label, &valid)
3124	&& !sensors_get_feature(*name, SENSORS_DDCMON_EDID_VER, &a)
3125	&& !sensors_get_feature(*name, SENSORS_DDCMON_EDID_REV, &b)) {
3126	if (valid) {
3127	print_label(label, 24);
3128	printf("%d.%d\n", (int) a, (int) b);
3129	}
3130	} else
3131	printf("ERROR: data 5\n");
3132	free(label);
3133
3134	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_VERSIZE, &label,&valid) &&
3135	!sensors_get_feature(*name, SENSORS_DDCMON_VERSIZE, &a) &&
3136	!sensors_get_feature(*name, SENSORS_DDCMON_HORSIZE, &b)) {
3137	if (valid) {
3138	print_label(label, 24);
3139	printf("%dx%d\n", (int) a, (int) b);
3140	}
3141	} else
3142	printf("ERROR: data 6\n");
3143	free(label);
3144
3145	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_GAMMA, &label, &valid)
3146	&& !sensors_get_feature(*name, SENSORS_DDCMON_GAMMA, &a)) {
3147	if (valid) {
3148	print_label(label, 24);
3149	printf("%.02f\n", a);
3150	}
3151	} else
3152	printf("ERROR: data 7\n");
3153	free(label);
3154
3155	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_DPMS, &label, &valid)
3156	&& !sensors_get_feature(*name, SENSORS_DDCMON_DPMS, &a)) {
3157	if (valid) {
3158	i = (int) a;
3159	print_label(label, 24);
3160	if (i & 0xe0) {
3161	printf("%s%s%s%s%s\n",
3162	i & 0x20 ? "Active Off" : "",
3163	(i & 0x40) && (i & 0x20) ? ", ": "",
3164	i & 0x40 ? "Suspend" : "",
3165	(i & 0x80) && (i & 0x60) ? ", ": "",
3166	i & 0x80 ? "Standby" : "");
3167	} else {
3168	printf("None supported\n");
3169	}
3170	}
3171	} else
3172	printf("ERROR: data 8\n");
3173	free(label);
3174
3175	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_TIMINGS, &label,&valid) &&
3176	!sensors_get_feature(*name, SENSORS_DDCMON_TIMINGS, &a)) {
3177	if (valid) {
3178	i = (int) a;
3179	if (i & 0x03) { /* 720x400 */
3180	print_label(label, 24);
3181	printf("720x400 @ %s%s%s Hz\n",
3182	i & 0x01 ? "70" : "",
3183	(i & 0x02) && (i & 0x01) ? "/" : "",
3184	i & 0x02 ? "88" : "");
3185	}
3186	if (i & 0x3c) { /* 640x480 */
3187	print_label(label, 24);
3188	printf("640x480 @ %s%s%s%s%s%s%s Hz\n",
3189	i & 0x04 ? "60" : "",
3190	(i & 0x08) && (i & 0x04) ? "/" : "",
3191	i & 0x08 ? "67" : "",
3192	(i & 0x10) && (i & 0x0c) ? "/" : "",
3193	i & 0x10 ? "72" : "",
3194	(i & 0x20) && (i & 0x1c) ? "/" : "",
3195	i & 0x20 ? "75" : "");
3196	}
3197	i >>= 6;
3198	if (i & 0x0f) { /* 800x600 */
3199	print_label(label, 24);
3200	printf("800x600 @ %s%s%s%s%s%s%s Hz\n",
3201	i & 0x01 ? "56" : "",
3202	(i & 0x02) && (i & 0x01) ? "/" : "",
3203	i & 0x02 ? "60" : "",
3204	(i & 0x04) && (i & 0x03) ? "/" : "",
3205	i & 0x04 ? "72" : "",
3206	(i & 0x08) && (i & 0x07) ? "/" : "",
3207	i & 0x08 ? "75" : "");
3208	}
3209	if (i & 0x10) { /* 832x624 */
3210	print_label(label, 24);
3211	printf("832x624 @ 75 Hz\n");
3212	}
3213	i >>= 5;
3214	if (i & 0x0f) { /* 1024x768 */
3215	print_label(label, 24);
3216	printf("1024x768 @ %s%s%s%s%s%s%s Hz\n",
3217	i & 0x01 ? "87i" : "",
3218	(i & 0x02) && (i & 0x01) ? "/" : "",
3219	i & 0x02 ? "60" : "",
3220	(i & 0x04) && (i & 0x03) ? "/" : "",
3221	i & 0x04 ? "70" : "",
3222	(i & 0x08) && (i & 0x07) ? "/" : "",
3223	i & 0x08 ? "75" : "");
3224	}
3225	if (i & 0x100) { /* 1152x870 */
3226	print_label(label, 24);
3227	printf("1152x870 @ 75 Hz\n");
3228	}
3229	if (i & 0x10) { /* 1280x1024 */
3230	print_label(label, 24);
3231	printf("1280x1024 @ 75 Hz\n");
3232	}
3233	}
3234	} else
3235	printf("ERROR: data 9\n");
3236	free(label);
3237
3238	for(i = 0; i < 8; i++) {
3239	if (!sensors_get_label_and_valid(name, SENSORS_DDCMON_TIMING1_HOR + i 3, &label, &valid)
3240	&& !sensors_get_feature(name, SENSORS_DDCMON_TIMING1_HOR + i 3, &a)
3241	&& !sensors_get_feature(name, SENSORS_DDCMON_TIMING1_VER + i 3, &b)
3242	&& !sensors_get_feature(name, SENSORS_DDCMON_TIMING1_REF + i 3, &c)) {
3243	if (valid && ((int) a) != 0) {
3244	print_label(label, 24);
3245	printf("%dx%d @ %d Hz\n", (int) a, (int) b, (int) c);
3246	}
3247	} else
3248	printf("ERROR: data 10-%d\n", i+1);
3249	free(label);
3250	}
3251
3252
3253	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_VERSYNCMIN, &label,&valid) &&
3254	!sensors_get_feature(*name, SENSORS_DDCMON_VERSYNCMIN, &a) &&
3255	!sensors_get_feature(*name, SENSORS_DDCMON_VERSYNCMAX, &b)) {
3256	if (valid && ((int) a) != 0) {
3257	print_label(label, 24);
3258	printf("%d-%d\n", (int) a, (int) b);
3259	}
3260	} else
3261	printf("ERROR: data 11\n");
3262	free(label);
3263
3264	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_HORSYNCMIN, &label,&valid) &&
3265	!sensors_get_feature(*name, SENSORS_DDCMON_HORSYNCMIN, &a) &&
3266	!sensors_get_feature(*name, SENSORS_DDCMON_HORSYNCMAX, &b)) {
3267	if (valid && ((int) a) != 0) {
3268	print_label(label, 24);
3269	printf("%d-%d\n", (int) a, (int) b);
3270	}
3271	} else
3272	printf("ERROR: data 12\n");
3273	free(label);
3274
3275	if (!sensors_get_label_and_valid(*name, SENSORS_DDCMON_MAXCLOCK, &label, &valid)
3276	&& !sensors_get_feature(*name, SENSORS_DDCMON_MAXCLOCK, &a)) {
3277	if (valid && ((int) a) != 0) {
3278	print_label(label, 24);
3279	printf("%d\n", (int) a);
3280	}
3281	} else
3282	printf("ERROR: data 13\n");
3283	free(label);
3284
3285	printf("Note that the ddcmon driver is deprecated and will be deleted soon.\n");
3286	printf("Please use the eeprom driver and the ddcmon and/or decode-edid.pl\n"
3287	"scripts instead.\n");
3288	}
3289
3290	/*
3291	* (Khali, 2003-07-17) Almost entierly rewritten. Reindented for clarity,
3292	* simplified at some places, added support for EDID EEPROMs (well,
3293	* redirection more than support).
3294	* (Khali, 2003-08-09) Rewrote Sony Vaio EEPROMs detection, and move it
3295	* to the top. This should prevent such EEPROMs from being accidentally
3296	* detected as valid memory modules.
3297	* (Khali, 2004-02-23) Add support for Shuttle EEPROMs, which contain
3298	* MAC ethernet addresses.
3299	*/
3300	void print_eeprom(const sensors_chip_name *name)
3301	{
3302	char *label;
3303	double a, b, c, d;
3304	int valid, i, type;
3305
3306	/* handle Sony Vaio EEPROMs first */
3307	if (name->addr == 0x57) {
3308	char buffer[33];
3309
3310	/* first make sure it is a Sony Vaio EEPROM */
3311	if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_VAIO_NAME, &label, &valid)
3312	&& valid) {
3313	for (i = 0; i < 4; i++)
3314	if (!sensors_get_feature(*name, SENSORS_EEPROM_VAIO_NAME+i, &a))
3315	buffer[i] = (char) a;
3316	if (strncmp(buffer, "PCG-", 4) == 0
3317	\|\| strncmp(buffer, "VGN-", 4) == 0) {
3318	/* must be a real Sony Vaio EEPROM */
3319	memset(buffer + 4, '\0', 29);
3320	for (a = 1; i < 32 && a != 0; i++) /* stop at first zero */
3321	if (!sensors_get_feature(*name, SENSORS_EEPROM_VAIO_NAME+i, &a)
3322	&& a != 0)
3323	buffer[i] = (char) a;
3324	print_label(label, 24);
3325	printf("%s\n", buffer);
3326	free(label);
3327
3328	memset(buffer, '\0', i);
3329	if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_VAIO_SERIAL, &label, &valid)
3330	&& valid) {
3331	for (i = 0, a = 1; i < 32 && a != 0; i++) /* stop at first zero */
3332	if (!sensors_get_feature(*name, SENSORS_EEPROM_VAIO_SERIAL+i, &a)
3333	&& a != 0)
3334	buffer[i] = (char) a;
3335	print_label(label, 24);
3336	printf("%s\n", buffer);
3337	} else
3338	printf("ERROR: data Vaio 3\n");
3339	free(label);
3340
3341	printf("Note that eeprom support will be dropped from "
3342	"libsensors soon.\nPlease use the decode-vaio.pl "
3343	"script instead.\n");
3344	return;
3345	}
3346	} else
3347	printf("ERROR: data Vaio 2\n");
3348	free(label);
3349	}
3350
3351	/* then Shuttle EEPROMs */
3352	if (name->addr == 0x53) {
3353	unsigned char buffer[6];
3354
3355	/* first make sure it is a Shuttle EEPROM */
3356	if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_SHUTTLE, &label, &valid)
3357	&& valid) {
3358	for (i = 0; i < 3; i++)
3359	if (!sensors_get_feature(*name, SENSORS_EEPROM_SHUTTLE+i, &a))
3360	buffer[i] = (unsigned char) a;
3361	if (buffer[0] == 0x00
3362	&& buffer[1] == 0x30
3363	&& buffer[2] == 0x1b)
3364	{
3365	/* must be a real Shuttle EEPROM */
3366	for (i = 4; i < 6; i++)
3367	if (!sensors_get_feature(*name, SENSORS_EEPROM_SHUTTLE+i, &a))
3368	buffer[i] = (unsigned char) a;
3369
3370	print_label(label, 24);
3371	printf("%02X:%02X:%02X:%02X:%02X:%02X\n", buffer[0],
3372	buffer[1], buffer[2], buffer[3], buffer[4], buffer[5]);
3373	free(label);
3374
3375	return;
3376	}
3377	} else
3378	printf("ERROR: data Shuttle\n");
3379	free(label);
3380	}
3381
3382	if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_TYPE, &label, &valid)
3383	&& !sensors_get_feature(*name, SENSORS_EEPROM_TYPE, &a)) {
3384	if (valid) {
3385	type = (int) a;
3386	switch (type) {
3387	case 1:
3388	print_label(label, 24);
3389	printf("DRDRAM RIMM\n");
3390	break;
3391	case 2:
3392	print_label(label, 24);
3393	printf("EDO\n");
3394	break;
3395	case 4:
3396	print_label(label, 24);
3397	printf("SDR SDRAM DIMM\n");
3398	break;
3399	case 7:
3400	print_label(label, 24);
3401	printf("DDR SDRAM DIMM\n");
3402	break;
3403	case 8:
3404	print_label(label, 24);
3405	printf("DDR2 SDRAM DIMM\n");
3406	break;
3407	case 17:
3408	print_label(label, 24);
3409	printf("RAMBUS RIMM\n");
3410	break;
3411	case 255: /* EDID EEPROM? */
3412	break;
3413	default:
3414	printf("Unknown EEPROM type (%d)\n", type);
3415	free(label);
3416	return;
3417	}
3418	} else {
3419	free(label);
3420	return;
3421	}
3422	} else {
3423	free(label);
3424	printf("Memory type: Unavailable\n");
3425	return;
3426	}
3427	free(label);
3428
3429	if (type == 255) { /* EDID EEPROM */
3430	/* make sure it is an EDID EEPROM */
3431	if (!sensors_get_feature(*name, SENSORS_EEPROM_ROWADDR, &a)
3432	&& !sensors_get_feature(*name, SENSORS_EEPROM_COLADDR, &b)
3433	&& !sensors_get_feature(*name, SENSORS_EEPROM_NUMROWS, &c)
3434	&& !sensors_get_feature(*name, SENSORS_EEPROM_EDID_HEADER, &d)) {
3435	if (((int) a) != 255 \|\| ((int) b) != 255 \|\| ((int) c) != 255
3436	\|\| ((int) d) != 0)
3437	printf("Unknown EEPROM type (255).\n");
3438	else if (name->addr == 0x50)
3439	/* must be an EDID EEPROM */
3440	printf("Use the ddcmon and/or decode-edid.pl scripts.\n");
3441	} else
3442	printf("ERROR: data EDID\n");
3443	return;
3444	}
3445
3446	/* regular memory chips */
3447	if (!sensors_get_label_and_valid(*name, SENSORS_EEPROM_ROWADDR, &label, &valid)
3448	&& !sensors_get_feature(*name, SENSORS_EEPROM_ROWADDR, &a)
3449	&& !sensors_get_feature(*name, SENSORS_EEPROM_COLADDR, &b)
3450	&& !sensors_get_feature(*name, SENSORS_EEPROM_NUMROWS, &c)
3451	&& !sensors_get_feature(*name, SENSORS_EEPROM_BANKS, &d)
3452	&& valid) {
3453	int k = 0; /* multiplier, 0 if invalid */
3454	print_label(label, 24);
3455	if (type == 17) { /* RAMBUS */
3456	i = (((int) a) & 0x0f) + (((int) a) >> 4) + (((int) c) & 0x07) - 13;
3457	k = 1;
3458	} else if (type == 1) { /* DRDRAM */
3459	i = (((int) b) & 0x0f) + (((int) b) >> 4) + (((int) c) & 0x07) - 13;
3460	k = 1;
3461	} else if (type == 8) { /* DDR2 */
3462	i = (((int) a) & 0x0f) + (((int) b) & 0x0f) - 17;
3463	k = ((((int) c) & 0x7) + 1) * ((int) d);
3464	} else { /* SDRAM */
3465	i = (((int) a) & 0x0f) + (((int) b) & 0x0f) - 17;
3466	if (((int) c) <= 8 && ((int) d) <= 8)
3467	k = ((int) c) * ((int) d);
3468	}
3469	if(i > 0 && i <= 12 && k > 0)
3470	printf("%d\n", (1 << i) * k);
3471	else
3472	printf("invalid (%d %d %d %d)\n",
3473	(int) a, (int) b, (int) c, (int) d);
3474	} else
3475	printf("ERROR: data 2\n");
3476	free(label);
3477
3478	printf("Note that eeprom support will be dropped from "
3479	"libsensors soon.\nPlease use the decode-dimms.pl "
3480	"script instead.\n");
3481	}
3482
3483	void print_it87(const sensors_chip_name *name)
3484	{
3485	char *label;
3486	double cur, min, max, fdiv, sens;
3487	int alarms, valid;
3488
3489	if (!sensors_get_feature(*name,SENSORS_IT87_ALARMS, &cur)) {
3490	alarms = cur + 0.5;
3491	}
3492	else {
3493	printf("ERROR: Can't get alarm data!\n");
3494	alarms = 0;
3495	}
3496
3497	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN0,&label,&valid) &&
3498	!sensors_get_feature(*name,SENSORS_IT87_IN0,&cur) &&
3499	!sensors_get_feature(*name,SENSORS_IT87_IN0_MIN,&min) &&
3500	!sensors_get_feature(*name,SENSORS_IT87_IN0_MAX,&max)) {
3501	if (valid) {
3502	print_label(label,10);
3503	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3504	cur,min,max,alarms&IT87_ALARM_IN0?"ALARM":"");
3505	}
3506	} else
3507	printf("ERROR: Can't get IN0 data!\n");
3508	free(label);
3509	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN1,&label,&valid) &&
3510	!sensors_get_feature(*name,SENSORS_IT87_IN1,&cur) &&
3511	!sensors_get_feature(*name,SENSORS_IT87_IN1_MIN,&min) &&
3512	!sensors_get_feature(*name,SENSORS_IT87_IN1_MAX,&max)) {
3513	if (valid) {
3514	print_label(label,10);
3515	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3516	cur,min,max,alarms&IT87_ALARM_IN1?"ALARM":"");
3517	}
3518	} else
3519	printf("ERROR: Can't get IN1 data!\n");
3520	free(label);
3521	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN2,&label,&valid) &&
3522	!sensors_get_feature(*name,SENSORS_IT87_IN2,&cur) &&
3523	!sensors_get_feature(*name,SENSORS_IT87_IN2_MIN,&min) &&
3524	!sensors_get_feature(*name,SENSORS_IT87_IN2_MAX,&max)) {
3525	if (valid) {
3526	print_label(label,10);
3527	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3528	cur,min,max,alarms&IT87_ALARM_IN2?"ALARM":"");
3529	}
3530	} else
3531	printf("ERROR: Can't get IN2 data!\n");
3532	free(label);
3533	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN3,&label,&valid) &&
3534	!sensors_get_feature(*name,SENSORS_IT87_IN3,&cur) &&
3535	!sensors_get_feature(*name,SENSORS_IT87_IN3_MIN,&min) &&
3536	!sensors_get_feature(*name,SENSORS_IT87_IN3_MAX,&max)) {
3537	if (valid) {
3538	print_label(label,10);
3539	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3540	cur,min,max,alarms&IT87_ALARM_IN3?"ALARM":"");
3541	}
3542	} else
3543	printf("ERROR: Can't get IN3 data!\n");
3544	free(label);
3545	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN4,&label,&valid) &&
3546	!sensors_get_feature(*name,SENSORS_IT87_IN4,&cur) &&
3547	!sensors_get_feature(*name,SENSORS_IT87_IN4_MIN,&min) &&
3548	!sensors_get_feature(*name,SENSORS_IT87_IN4_MAX,&max)) {
3549	if (valid) {
3550	print_label(label,10);
3551	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3552	cur,min,max,alarms&IT87_ALARM_IN4?"ALARM":"");
3553	}
3554	} else
3555	printf("ERROR: Can't get IN4 data!\n");
3556	free(label);
3557	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN5,&label,&valid) &&
3558	!sensors_get_feature(*name,SENSORS_IT87_IN5,&cur) &&
3559	!sensors_get_feature(*name,SENSORS_IT87_IN5_MIN,&min) &&
3560	!sensors_get_feature(*name,SENSORS_IT87_IN5_MAX,&max)) {
3561	if (valid) {
3562	print_label(label,10);
3563	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3564	cur,min,max,alarms&IT87_ALARM_IN5?"ALARM":"");
3565	}
3566	} else
3567	printf("ERROR: Can't get IN5 data!\n");
3568	free(label);
3569	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN6,&label,&valid) &&
3570	!sensors_get_feature(*name,SENSORS_IT87_IN6,&cur) &&
3571	!sensors_get_feature(*name,SENSORS_IT87_IN6_MIN,&min) &&
3572	!sensors_get_feature(*name,SENSORS_IT87_IN6_MAX,&max)) {
3573	if (valid) {
3574	print_label(label,10);
3575	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3576	cur,min,max,alarms&IT87_ALARM_IN6?"ALARM":"");
3577	}
3578	} else
3579	printf("ERROR: Can't get IN6 data!\n");
3580	free(label);
3581	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN7,&label,&valid) &&
3582	!sensors_get_feature(*name,SENSORS_IT87_IN7,&cur) &&
3583	!sensors_get_feature(*name,SENSORS_IT87_IN7_MIN,&min) &&
3584	!sensors_get_feature(*name,SENSORS_IT87_IN7_MAX,&max)) {
3585	if (valid) {
3586	print_label(label,10);
3587	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
3588	cur,min,max,alarms&IT87_ALARM_IN7?"ALARM":"");
3589	}
3590	} else
3591	printf("ERROR: Can't get IN7 data!\n");
3592	free(label);
3593	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN8,&label,&valid) &&
3594	!sensors_get_feature(*name,SENSORS_IT87_IN8,&cur)) {
3595	if (valid) {
3596	print_label(label,10);
3597	printf("%+6.2f V\n", cur);
3598	}
3599	} else
3600	printf("ERROR: Can't get IN8 data!\n");
3601	free(label);
3602
3603	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN1,&label,&valid) &&
3604	!sensors_get_feature(*name,SENSORS_IT87_FAN1,&cur) &&
3605	!sensors_get_feature(*name,SENSORS_IT87_FAN1_DIV,&fdiv) &&
3606	!sensors_get_feature(*name,SENSORS_IT87_FAN1_MIN,&min)) {
3607	if (valid) {
3608	print_label(label,10);
3609	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3610	cur,min,fdiv, alarms&IT87_ALARM_FAN1?"ALARM":"");
3611	}
3612	} else
3613	printf("ERROR: Can't get FAN1 data!\n");
3614	free(label);
3615	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN2,&label,&valid) &&
3616	!sensors_get_feature(*name,SENSORS_IT87_FAN2,&cur) &&
3617	!sensors_get_feature(*name,SENSORS_IT87_FAN2_DIV,&fdiv) &&
3618	!sensors_get_feature(*name,SENSORS_IT87_FAN2_MIN,&min)) {
3619	if (valid) {
3620	print_label(label,10);
3621	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3622	cur,min,fdiv, alarms&IT87_ALARM_FAN2?"ALARM":"");
3623	}
3624	} else
3625	printf("ERROR: Can't get FAN2 data!\n");
3626	free(label);
3627	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN3,&label,&valid) &&
3628	!sensors_get_feature(*name,SENSORS_IT87_FAN3,&cur) &&
3629	!sensors_get_feature(*name,SENSORS_IT87_FAN3_DIV,&fdiv) &&
3630	!sensors_get_feature(*name,SENSORS_IT87_FAN3_MIN,&min)) {
3631	if (valid) {
3632	print_label(label,10);
3633	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
3634	cur,min,fdiv, alarms&IT87_ALARM_FAN3?"ALARM":"");
3635	}
3636	} else
3637	printf("ERROR: Can't get FAN3 data!\n");
3638	free(label);
3639
3640	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP1,&label,&valid) &&
3641	!sensors_get_feature(*name,SENSORS_IT87_TEMP1,&cur) &&
3642	!sensors_get_feature(*name,SENSORS_IT87_TEMP1_LOW,&min) &&
3643	!sensors_get_feature(*name,SENSORS_IT87_SENS1,&sens) &&
3644	!sensors_get_feature(*name,SENSORS_IT87_TEMP1_HIGH,&max)) {
3645	if (valid) {
3646	print_label(label,10);
3647	print_temp_info( cur, max, min, MINMAX, 0, 0);
3648	printf(" sensor = %s ", (((int)sens)==3) ? "diode" :
3649	(((int)sens)==2) ? "thermistor" :
3650	(((int)sens)==0) ? "disabled" : "invalid");
3651	printf( " %s\n", alarms & IT87_ALARM_TEMP1 ? "ALARM" : "" );
3652	}
3653	} else
3654	printf("ERROR: Can't get TEMP1 data!\n");
3655	free(label);
3656	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP2,&label,&valid) &&
3657	!sensors_get_feature(*name,SENSORS_IT87_TEMP2,&cur) &&
3658	!sensors_get_feature(*name,SENSORS_IT87_TEMP2_LOW,&min) &&
3659	!sensors_get_feature(*name,SENSORS_IT87_SENS2,&sens) &&
3660	!sensors_get_feature(*name,SENSORS_IT87_TEMP2_HIGH,&max)) {
3661	if (valid) {
3662	print_label(label,10);
3663	print_temp_info( cur, max, min, MINMAX, 0, 0);
3664	printf(" sensor = %s ", (((int)sens)==3) ? "diode" :
3665	(((int)sens)==2) ? "thermistor" :
3666	(((int)sens)==0) ? "disabled" : "invalid");
3667	printf( " %s\n", alarms & IT87_ALARM_TEMP2 ? "ALARM" : "" );
3668	}
3669	} else
3670	printf("ERROR: Can't get TEMP2 data!\n");
3671	free(label);
3672	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP3,&label,&valid) &&
3673	!sensors_get_feature(*name,SENSORS_IT87_TEMP3,&cur) &&
3674	!sensors_get_feature(*name,SENSORS_IT87_TEMP3_LOW,&min) &&
3675	!sensors_get_feature(*name,SENSORS_IT87_SENS3,&sens) &&
3676	!sensors_get_feature(*name,SENSORS_IT87_TEMP3_HIGH,&max)) {
3677	if (valid) {
3678	print_label(label,10);
3679	print_temp_info( cur, max, min, MINMAX, 0, 0);
3680	printf(" sensor = %s ", (((int)sens)==3) ? "diode" :
3681	(((int)sens)==2) ? "thermistor" :
3682	(((int)sens)==0) ? "disabled" : "invalid");
3683	printf( " %s\n", alarms & IT87_ALARM_TEMP3 ? "ALARM" : "" );
3684	}
3685	} else
3686	printf("ERROR: Can't get TEMP3 data!\n");
3687	free(label);
3688
3689	if (!sensors_get_label_and_valid(*name,SENSORS_IT87_VID,&label,&valid) &&
3690	!sensors_get_feature(*name,SENSORS_IT87_VID,&cur)) {
3691	if (valid) {
3692	print_label(label,10);
3693	printf("%+6.2f V\n",cur);
3694	}
3695	}
3696	free(label);
3697	}
3698
3699	void print_fscpos(const sensors_chip_name *name)
3700	{
3701	char *label;
3702	double voltage, temp, state, fan;
3703	int valid;
3704
3705	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP1,&label,&valid) &&
3706	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP1,&temp) &&
3707	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP1_STATE,&state)) {
3708	if (valid) {
3709	print_label(label,10);
3710	if((int) state & 0x01)
3711	printf("\t%+6.2f C\n", temp);
3712	else
3713	printf("\tfailed\n");
3714	}
3715	} else
3716	printf("ERROR: Can't get TEMP1 data!\n");
3717	free(label);
3718
3719	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP2,&label,&valid) &&
3720	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP2,&temp) &&
3721	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP2_STATE,&state)) {
3722	if (valid) {
3723	print_label(label,10);
3724	if((int) state & 0x01)
3725	printf("\t%+6.2f C\n", temp);
3726	else
3727	printf("\tfailed\n");
3728	}
3729	} else
3730	printf("ERROR: Can't get TEMP2 data!\n");
3731	free(label);
3732
3733	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP3,&label,&valid) &&
3734	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP3,&temp) &&
3735	!sensors_get_feature(*name,SENSORS_FSCPOS_TEMP3_STATE,&state)) {
3736	if (valid) {
3737	print_label(label,10);
3738	if((int) state & 0x01)
3739	printf("\t%+6.2f C\n", temp);
3740	else
3741	printf("\tfailed\n");
3742	}
3743	} else
3744	printf("ERROR: Can't get TEMP3 data!\n");
3745	free(label);
3746
3747	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN1,&label,&valid) &&
3748	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN1,&fan) &&
3749	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN1_STATE,&state)) {
3750	if (valid) {
3751	print_label(label,10);
3752	if((int) state & 0x04)
3753	printf("\tfaulty\n");
3754	else
3755	printf("\t%6.0f RPM\n", fan);
3756	}
3757	} else
3758	printf("ERROR: Can't get FAN1 data!\n");
3759	free(label);
3760
3761	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN2,&label,&valid) &&
3762	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN2,&fan) &&
3763	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN2_STATE,&state)) {
3764	if (valid) {
3765	print_label(label,10);
3766	if((int) state & 0x04)
3767	printf("\tfaulty\n");
3768	else
3769	printf("\t%6.0f RPM\n", fan);
3770	}
3771	} else
3772	printf("ERROR: Can't get FAN2 data!\n");
3773	free(label);
3774
3775	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN3,&label,&valid) &&
3776	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN3,&fan) &&
3777	!sensors_get_feature(*name,SENSORS_FSCPOS_FAN3_STATE,&state)) {
3778	if (valid) {
3779	print_label(label,10);
3780	if((int) state & 0x04)
3781	printf("\tfaulty\n");
3782	else
3783	printf("\t%6.0f RPM\n", fan);
3784	}
3785	} else
3786	printf("ERROR: Can't get FAN3 data!\n");
3787	free(label);
3788
3789	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE1,&label,&valid) &&
3790	!sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE1,&voltage)) {
3791	if (valid) {
3792	print_label(label,10);
3793	printf("\t%+6.2f V\n",voltage);
3794	}
3795	} else
3796	printf("ERROR: Can't get IN0 data!\n");
3797	free(label);
3798
3799	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE2,&label,&valid) &&
3800	!sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE2,&voltage)) {
3801	if (valid) {
3802	print_label(label,10);
3803	printf("\t%+6.2f V\n",voltage);
3804	}
3805	} else
3806	printf("ERROR: Can't get IN1 data!\n");
3807	free(label);
3808
3809	if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE3,&label,&valid) &&
3810	!sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE3,&voltage)) {
3811	if (valid) {
3812	print_label(label,10);
3813	printf("\t%+6.2f V\n",voltage);
3814	}
3815	} else
3816	printf("ERROR: Can't get IN2 data!\n");
3817	free(label);
3818	}
3819
3820	void print_fscscy(const sensors_chip_name *name)
3821	{
3822	char *label;
3823	double voltage, temp, tempmin, tempmax, templim, state, fan;
3824	int valid;
3825
3826	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP1,&label,&valid) &&
3827	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1,&temp) &&
3828	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_LIM,&templim) &&
3829	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_MIN,&tempmin) &&
3830	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_MAX,&tempmax) &&
3831	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_STATE,&state)) {
3832	if (valid) {
3833	print_label(label,10);
3834	if((int) state & 0x01)
3835	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3836	temp,tempmin,tempmax,templim);
3837	else
3838	printf("\tfailed\n");
3839	}
3840	} else
3841	printf("ERROR: Can't get TEMP1 data!\n");
3842	free(label);
3843
3844	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP2,&label,&valid) &&
3845	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2,&temp) &&
3846	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_LIM,&templim) &&
3847	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_MIN,&tempmin) &&
3848	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_MAX,&tempmax) &&
3849	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_STATE,&state)) {
3850	if (valid) {
3851	print_label(label,10);
3852	if((int) state & 0x01)
3853	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3854	temp,tempmin,tempmax,templim);
3855	else
3856	printf("\tfailed\n");
3857	}
3858	} else
3859	printf("ERROR: Can't get TEMP2 data!\n");
3860	free(label);
3861
3862	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP3,&label,&valid) &&
3863	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3,&temp) &&
3864	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_LIM,&templim) &&
3865	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_MIN,&tempmin) &&
3866	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_MAX,&tempmax) &&
3867	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_STATE,&state)) {
3868	if (valid) {
3869	print_label(label,10);
3870	if((int) state & 0x01)
3871	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3872	temp,tempmin,tempmax,templim);
3873	else
3874	printf("\tfailed\n");
3875	}
3876	} else
3877	printf("ERROR: Can't get TEMP3 data!\n");
3878	free(label);
3879
3880	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP4,&label,&valid) &&
3881	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4,&temp) &&
3882	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_LIM,&templim) &&
3883	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_MIN,&tempmin) &&
3884	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_MAX,&tempmax) &&
3885	!sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_STATE,&state)) {
3886	if (valid) {
3887	print_label(label,10);
3888	if((int) state & 0x01)
3889	printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n",
3890	temp,tempmin,tempmax,templim);
3891	else
3892	printf("\tfailed\n");
3893	}
3894	} else
3895	printf("ERROR: Can't get TEMP4 data!\n");
3896	free(label);
3897
3898	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN1,&label,&valid) &&
3899	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN1,&fan) &&
3900	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN1_STATE,&state)) {
3901	if (valid) {
3902	print_label(label,10);
3903	if((int) state & 0x02)
3904	printf("\tfaulty\n");
3905	else
3906	printf("\t%6.0f RPM\n", fan);
3907	}
3908	} else
3909	printf("ERROR: Can't get FAN1 data!\n");
3910	free(label);
3911
3912	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN2,&label,&valid) &&
3913	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN2,&fan) &&
3914	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN2_STATE,&state)) {
3915	if (valid) {
3916	print_label(label,10);
3917	if((int) state & 0x02)
3918	printf("\tfaulty\n");
3919	else
3920	printf("\t%6.0f RPM\n", fan);
3921	}
3922	} else
3923	printf("ERROR: Can't get FAN2 data!\n");
3924	free(label);
3925
3926	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN3,&label,&valid) &&
3927	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN3,&fan) &&
3928	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN3_STATE,&state)) {
3929	if (valid) {
3930	print_label(label,10);
3931	if((int) state & 0x02)
3932	printf("\tfaulty\n");
3933	else
3934	printf("\t%6.0f RPM\n", fan);
3935	}
3936	} else
3937	printf("ERROR: Can't get FAN3 data!\n");
3938	free(label);
3939
3940	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN4,&label,&valid) &&
3941	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN4,&fan) &&
3942	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN4_STATE,&state)) {
3943	if (valid) {
3944	print_label(label,10);
3945	if((int) state & 0x02)
3946	printf("\tfaulty\n");
3947	else
3948	printf("\t%6.0f RPM\n", fan);
3949	}
3950	} else
3951	printf("ERROR: Can't get FAN4 data!\n");
3952	free(label);
3953
3954	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN5,&label,&valid) &&
3955	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN5,&fan) &&
3956	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN5_STATE,&state)) {
3957	if (valid) {
3958	print_label(label,10);
3959	if((int) state & 0x02)
3960	printf("\tfaulty\n");
3961	else
3962	printf("\t%6.0f RPM\n", fan);
3963	}
3964	} else
3965	printf("ERROR: Can't get FAN5 data!\n");
3966	free(label);
3967
3968	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN6,&label,&valid) &&
3969	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN6,&fan) &&
3970	!sensors_get_feature(*name,SENSORS_FSCSCY_FAN6_STATE,&state)) {
3971	if (valid) {
3972	print_label(label,10);
3973	if((int) state & 0x02)
3974	printf("\tfaulty\n");
3975	else
3976	printf("\t%6.0f RPM\n", fan);
3977	}
3978	} else
3979	printf("ERROR: Can't get FAN6 data!\n");
3980	free(label);
3981
3982	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE1,&label,&valid) &&
3983	!sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE1,&voltage)) {
3984	if (valid) {
3985	print_label(label,10);
3986	printf("\t%+6.2f V\n",voltage);
3987	}
3988	} else
3989	printf("ERROR: Can't get IN0 data!\n");
3990	free(label);
3991
3992	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE2,&label,&valid) &&
3993	!sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE2,&voltage)) {
3994	if (valid) {
3995	print_label(label,10);
3996	printf("\t%+6.2f V\n",voltage);
3997	}
3998	} else
3999	printf("ERROR: Can't get IN1 data!\n");
4000	free(label);
4001
4002	if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE3,&label,&valid) &&
4003	!sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE3,&voltage)) {
4004	if (valid) {
4005	print_label(label,10);
4006	printf("\t%+6.2f V\n",voltage);
4007	}
4008	} else
4009	printf("ERROR: Can't get IN2 data!\n");
4010	free(label);
4011	}
4012
4013	void print_fscher(const sensors_chip_name *name)
4014	{
4015	char *label;
4016	double voltage, temp, state, fan;
4017	int valid;
4018
4019	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP1,&label,&valid)
4020	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP1,&temp)
4021	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP1_STATE,&state)) {
4022	if (valid) {
4023	print_label(label,10);
4024	if((int) state & 0x01)
4025	printf("\t%+6.2f C\n", temp);
4026	else
4027	printf("\tfailed\n");
4028	}
4029	} else
4030	printf("ERROR: Can't get TEMP1 data!\n");
4031	free(label);
4032
4033	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP2,&label,&valid)
4034	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP2,&temp)
4035	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP2_STATE,&state)) {
4036	if (valid) {
4037	print_label(label,10);
4038	if((int) state & 0x01)
4039	printf("\t%+6.2f C\n", temp);
4040	else
4041	printf("\tfailed\n");
4042	}
4043	} else
4044	printf("ERROR: Can't get TEMP2 data!\n");
4045	free(label);
4046
4047	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP3,&label,&valid)
4048	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP3,&temp)
4049	&& !sensors_get_feature(*name,SENSORS_FSCHER_TEMP3_STATE,&state)) {
4050	if (valid) {
4051	print_label(label,10);
4052	if((int) state & 0x01)
4053	printf("\t%+6.2f C\n", temp);
4054	else
4055	printf("\tfailed\n");
4056	}
4057	} else
4058	printf("ERROR: Can't get TEMP3 data!\n");
4059	free(label);
4060
4061	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN1,&label,&valid)
4062	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN1,&fan)
4063	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN1_STATE,&state)) {
4064	if (valid) {
4065	print_label(label,10);
4066	if((int) state & 0x04)
4067	printf("\tfaulty\n");
4068	else
4069	printf("\t%6.0f RPM\n", fan);
4070	}
4071	} else
4072	printf("ERROR: Can't get FAN1 data!\n");
4073	free(label);
4074
4075	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN2,&label,&valid)
4076	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN2,&fan)
4077	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN2_STATE,&state)) {
4078	if (valid) {
4079	print_label(label,10);
4080	if((int) state & 0x04)
4081	printf("\tfaulty\n");
4082	else
4083	printf("\t%6.0f RPM\n", fan);
4084	}
4085	} else
4086	printf("ERROR: Can't get FAN2 data!\n");
4087	free(label);
4088
4089	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN3,&label,&valid)
4090	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN3,&fan)
4091	&& !sensors_get_feature(*name,SENSORS_FSCHER_FAN3_STATE,&state)) {
4092	if (valid) {
4093	print_label(label,10);
4094	if((int) state & 0x04)
4095	printf("\tfaulty\n");
4096	else
4097	printf("\t%6.0f RPM\n", fan);
4098	}
4099	} else
4100	printf("ERROR: Can't get FAN3 data!\n");
4101	free(label);
4102
4103	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE1,&label,&valid)
4104	&& !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE1,&voltage)) {
4105	if (valid) {
4106	print_label(label,10);
4107	printf("\t%+6.2f V\n",voltage);
4108	}
4109	} else
4110	printf("ERROR: Can't get IN0 data!\n");
4111	free(label);
4112
4113	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE2,&label,&valid)
4114	&& !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE2,&voltage)) {
4115	if (valid) {
4116	print_label(label,10);
4117	printf("\t%+6.2f V\n",voltage);
4118	}
4119	} else
4120	printf("ERROR: Can't get IN1 data!\n");
4121	free(label);
4122
4123	if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE3,&label,&valid)
4124	&& !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE3,&voltage)) {
4125	if (valid) {
4126	print_label(label,10);
4127	printf("\t%+6.2f V\n",voltage);
4128	}
4129	} else
4130	printf("ERROR: Can't get IN2 data!\n");
4131	free(label);
4132	}
4133
4134	void print_pcf8591(const sensors_chip_name *name)
4135	{
4136	char *label;
4137	int ain_conf = -1;
4138	double ain;
4139	double aout_enable, aout;
4140	int valid;
4141
4142	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_AIN_CONF,&label,&valid) &&
4143	!sensors_get_feature(*name, SENSORS_PCF8591_AIN_CONF, &ain)) {
4144	ain_conf = (int)ain;
4145	if (valid) {
4146	print_label(label,10);
4147	switch (ain_conf)
4148	{
4149	case 0: printf("four single ended inputs\n");
4150	break;
4151	case 1: printf("three differential inputs\n");
4152	break;
4153	case 2: printf("single ended and differential mixed\n");
4154	break;
4155	case 3: printf("two differential inputs\n");
4156	break;
4157	}
4158	}
4159	}
4160	/* display no error, 2.6 driver doesn't have that file */
4161	free(label);
4162
4163	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH0,&label,&valid) &&
4164	!sensors_get_feature(*name, SENSORS_PCF8591_CH0, &ain)) {
4165	if (valid) {
4166	print_label(label,10);
4167	printf("%6.2f V\n", ain);
4168	}
4169	}
4170	else printf("ERROR: Can't read ch0!\n");
4171	free(label);
4172
4173	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH1,&label,&valid) &&
4174	!sensors_get_feature(*name, SENSORS_PCF8591_CH1, &ain)) {
4175	if (valid) {
4176	print_label(label,10);
4177	printf("%6.2f V\n", ain);
4178	}
4179	}
4180	else printf("ERROR: Can't read ch1!\n");
4181	free(label);
4182
4183	if (ain_conf != 3) {
4184	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH2,&label,&valid) &&
4185	!sensors_get_feature(*name, SENSORS_PCF8591_CH2, &ain)) {
4186	if (valid) {
4187	print_label(label,10);
4188	printf("%6.2f V\n", ain);
4189	}
4190	}
4191	else if (ain_conf >= 0) /* hide error for 2.6 kernel driver */
4192	printf("ERROR: Can't read ch2!\n");
4193	free(label);
4194	}
4195
4196	if (ain_conf <= 0) {
4197	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH3,&label,&valid) &&
4198	!sensors_get_feature(*name, SENSORS_PCF8591_CH3, &ain)) {
4199	if (valid) {
4200	print_label(label,10);
4201	printf("%6.2f V\n", ain);
4202	}
4203	}
4204	else if (ain_conf >= 0) /* hide error for 2.6 kernel driver */
4205	printf("ERROR: Can't read ch3!\n");
4206	free(label);
4207	}
4208
4209	if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_AOUT,&label,&valid) &&
4210	!sensors_get_feature(*name,SENSORS_PCF8591_AOUT,&aout) &&
4211	!sensors_get_feature(*name,SENSORS_PCF8591_AOUT_ENABLE,&aout_enable)) {
4212	if (valid) {
4213	print_label(label,10);
4214	printf("%6.2f V (%s)\n", aout, aout_enable?"enabled":"disabled");
4215	}
4216	}
4217	else printf("ERROR: Can't read aout!\n");
4218	free(label);
4219
4220	}
4221
4222	void print_vt1211(const sensors_chip_name *name)
4223	{
4224	char *label;
4225	double cur,min,max,fdiv;
4226	int alarms,valid;
4227	int err;
4228
4229	/* per vt1211.c driver, temps 1,5,6,7 and inputs 0,1,6 are optional */
4230	/* supress error messages reading from them */
4231
4232	if (!sensors_get_feature(*name,SENSORS_VT1211_ALARMS,&cur))
4233	alarms = cur + 0.5;
4234	else {
4235	printf("ERROR: Can't get alarm data!\n");
4236	alarms = 0;
4237	}
4238
4239	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN0,&label,&valid)) {
4240	printf("ERROR: Can't get IN0 config!\n");
4241	} else if (valid) {
4242	if (!(err = sensors_get_feature(*name,SENSORS_VT1211_IN0,&cur)) &&
4243	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN0_MIN,&min)) &&
4244	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN0_MAX,&max))) {
4245	print_label(label,10);
4246	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4247	cur,min,max,alarms&VT1211_ALARM_IN0?"ALARM":"");
4248	} else if (err != -SENSORS_ERR_PROC)
4249	printf("ERROR: Can't get IN0 data!\n");
4250	}
4251	free(label);
4252	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN1,&label,&valid)) {
4253	printf("ERROR: Can't get IN1 config!\n");
4254	} else if (valid) {
4255	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_IN1,&cur)) &&
4256	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN1_MIN,&min)) &&
4257	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN1_MAX,&max))) {
4258	print_label(label,10);
4259	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4260	cur,min,max,alarms&VT1211_ALARM_IN1?"ALARM":"");
4261	} else if (err != -SENSORS_ERR_PROC)
4262	printf("ERROR: Can't get IN1 data!\n");
4263	}
4264	free(label);
4265	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN2,&label,&valid)) {
4266	printf("ERROR: Can't get IN2 config!\n");
4267	} else if (valid) {
4268	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_IN2,&cur)) &&
4269	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN2_MIN,&min)) &&
4270	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN2_MAX,&max))) {
4271	print_label(label,10);
4272	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4273	cur,min,max,alarms&VT1211_ALARM_IN2?"ALARM":"");
4274	} else
4275	printf("ERROR: Can't get IN2 data!\n");
4276	}
4277	free(label);
4278	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN3,&label,&valid)) {
4279	printf("ERROR: Can't get IN3 config!\n");
4280	} else if (valid) {
4281	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_IN3,&cur)) &&
4282	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN3_MIN,&min)) &&
4283	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN3_MAX,&max))) {
4284	print_label(label,10);
4285	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4286	cur,min,max,alarms&VT1211_ALARM_IN3?"ALARM":"");
4287	} else
4288	printf("ERROR: Can't get IN3 data!\n");
4289	}
4290	free(label);
4291	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN4,&label,&valid)) {
4292	printf("ERROR: Can't get IN4 config!\n");
4293	} else if (valid) {
4294	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_IN4,&cur)) &&
4295	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN4_MIN,&min)) &&
4296	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN4_MAX,&max))) {
4297	print_label(label,10);
4298	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4299	cur,min,max,alarms&VT1211_ALARM_IN4?"ALARM":"");
4300	} else
4301	printf("ERROR: Can't get IN4 data!\n");
4302	}
4303	free(label);
4304	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN5,&label,&valid)) {
4305	printf("ERROR: Can't get IN5 config!\n");
4306	} else if (valid) {
4307	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_IN5,&cur)) &&
4308	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN5_MIN,&min)) &&
4309	!(err = sensors_get_feature(*name,SENSORS_VT1211_IN5_MAX,&max))) {
4310	print_label(label,10);
4311	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4312	cur,min,max,alarms&VT1211_ALARM_IN5?"ALARM":"");
4313	} else
4314	printf("ERROR: Can't get IN5 data!\n");
4315	}
4316	free(label);
4317	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_FAN1,&label,&valid)) {
4318	printf("ERROR: Can't get FAN1 config!\n");
4319	} else if (valid) {
4320	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_FAN1,&cur)) &&
4321	!(err = sensors_get_feature(*name,SENSORS_VT1211_FAN1_DIV,&fdiv)) &&
4322	!(err = sensors_get_feature(*name,SENSORS_VT1211_FAN1_MIN,&min))) {
4323	print_label(label,10);
4324	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4325	cur,min,fdiv, alarms&VT1211_ALARM_FAN1?"ALARM":"");
4326	} else
4327	printf("ERROR: Can't get FAN1 data!\n");
4328	}
4329	free(label);
4330	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_FAN2,&label,&valid)) {
4331	printf("ERROR: Can't get FAN2 config!\n");
4332	} else if (valid) {
4333	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_FAN2,&cur)) &&
4334	!(err = sensors_get_feature(*name,SENSORS_VT1211_FAN2_DIV,&fdiv)) &&
4335	!(err = sensors_get_feature(*name,SENSORS_VT1211_FAN2_MIN,&min))) {
4336	print_label(label,10);
4337	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4338	cur,min,fdiv, alarms&VT1211_ALARM_FAN2?"ALARM":"");
4339	} else
4340	printf("ERROR: Can't get FAN2 data!\n");
4341	}
4342	free(label);
4343	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP1,&label,&valid)) {
4344	printf("ERROR: Can't get TEMP1 config!\n");
4345	} else if (valid) {
4346	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP1,&cur)) &&
4347	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP1_HYST,&min)) &&
4348	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP1_OVER,&max))) {
4349	print_label(label,10);
4350	print_temp_info( cur, max, min, HYST, 1, 0);
4351	printf(" %s\n", alarms & VT1211_ALARM_TEMP1 ? "ALARM" : "" );
4352	} else
4353	printf("ERROR: Can't get TEMP1 data!\n");
4354	}
4355	free(label);
4356	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP2,&label,&valid)) {
4357	printf("ERROR: Can't get TEMP2 config!\n");
4358	} else if (valid) {
4359	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP2,&cur)) &&
4360	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP2_HYST,&min)) &&
4361	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP2_OVER,&max))) {
4362	print_label(label,10);
4363	print_temp_info( cur, max, min, HYST, 1, 0);
4364	printf(" %s\n", alarms & VT1211_ALARM_TEMP2 ? "ALARM" : "" );
4365	} else
4366	printf("ERROR: Can't get TEMP2 data!\n");
4367	}
4368	free(label);
4369	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP3,&label,&valid)) {
4370	printf("ERROR: Can't get TEMP3 config!\n");
4371	} else if (valid) {
4372	if (!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP3,&cur)) &&
4373	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP3_HYST,&min)) &&
4374	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP3_OVER,&max))) {
4375	print_label(label,10);
4376	print_temp_info( cur, max, min, HYST, 1, 0);
4377	printf(" %s\n", alarms & VT1211_ALARM_TEMP3 ? "ALARM" : "" );
4378	} else
4379	printf("ERROR: Can't get TEMP3 data!\n");
4380	}
4381	free(label);
4382	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP4,&label,&valid)) {
4383	printf("ERROR: Can't get TEMP4 config!\n");
4384	} else if (valid) {
4385	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP4,&cur)) &&
4386	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP4_HYST,&min)) &&
4387	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP4_OVER,&max))) {
4388	print_label(label,10);
4389	print_temp_info( cur, max, min, HYST, 1, 0);
4390	printf(" %s\n", alarms & VT1211_ALARM_TEMP4 ? "ALARM" : "" );
4391	} else
4392	printf("ERROR: Can't get TEMP4 data!\n");
4393	}
4394	free(label);
4395	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP5,&label,&valid)) {
4396	printf("ERROR: Can't get TEMP5 config!\n");
4397	} else if (valid) {
4398	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP5,&cur)) &&
4399	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP5_HYST,&min)) &&
4400	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP5_OVER,&max))) {
4401	print_label(label,10);
4402	print_temp_info( cur, max, min, HYST, 1, 0);
4403	printf(" %s\n", alarms & VT1211_ALARM_TEMP5 ? "ALARM" : "" );
4404	} else if (err != -SENSORS_ERR_PROC)
4405	printf("ERROR: Can't get TEMP5 data!\n");
4406	}
4407	free(label);
4408	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP6,&label,&valid)) {
4409	printf("ERROR: Can't get TEMP6 config!\n");
4410	} else if (valid) {
4411	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP6,&cur)) &&
4412	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP6_HYST,&min)) &&
4413	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP6_OVER,&max))) {
4414	print_label(label,10);
4415	print_temp_info( cur, max, min, HYST, 1, 0);
4416	printf(" %s\n", alarms & VT1211_ALARM_TEMP6 ? "ALARM" : "" );
4417	} else if (err != -SENSORS_ERR_PROC)
4418	printf("ERROR: Can't get TEMP6 data!\n");
4419	}
4420	free(label);
4421	if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP7,&label,&valid)) {
4422	printf("ERROR: Can't get TEMP7 config!\n");
4423	} else if (valid) {
4424	if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP7,&cur)) &&
4425	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP7_HYST,&min)) &&
4426	!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP7_OVER,&max))) {
4427	print_label(label,10);
4428	print_temp_info( cur, max, min, HYST, 1, 0);
4429	printf(" %s\n", alarms & VT1211_ALARM_TEMP7 ? "ALARM" : "" );
4430	} else if (err != -SENSORS_ERR_PROC)
4431	printf("ERROR: Can't get TEMP7 data!\n");
4432	}
4433	free(label);
4434
4435	print_vid_info(name, SENSORS_VT1211_VID, SENSORS_VT1211_VRM);
4436	}
4437
4438	void print_smsc47m1(const sensors_chip_name *name)
4439	{
4440	char *label;
4441	double cur, min, div;
4442	int alarms, valid, i;
4443
4444	if (!sensors_get_feature(*name,SENSORS_SMSC47M1_ALARMS,&cur))
4445	alarms = cur + 0.5;
4446	else {
4447	printf("ERROR: Can't get alarm data!\n");
4448	alarms = 0;
4449	}
4450
4451	for (i=0; i<2; i++) { /* 2 fans */
4452	if (!sensors_get_label_and_valid(*name, SENSORS_SMSC47M1_FAN1+i, &label, &valid)
4453	&& !sensors_get_feature(*name, SENSORS_SMSC47M1_FAN1+i, &cur)
4454	&& !sensors_get_feature(*name, SENSORS_SMSC47M1_FAN1_DIV+i, &div)
4455	&& !sensors_get_feature(*name, SENSORS_SMSC47M1_FAN1_MIN+i, &min)) {
4456	if (valid) {
4457	print_label(label, 10);
4458	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4459	cur, min, div, alarms&(SMSC47M1_ALARM_FAN1<<i) ?
4460	"ALARM" : "");
4461	}
4462	}
4463	/* In Linux 2.6, the original chip configuration is respected, so channels
4464	may be missing without it being considered an error; thus we don't
4465	print any error if this happens. */
4466	free(label);
4467	}
4468	}
4469
4470	void print_smsc47m192(const sensors_chip_name *name)
4471	{
4472	char *label;
4473	double cur, min, max;
4474	int valid, i;
4475
4476	for (i=0; i<8; i++) {
4477	if (!sensors_get_label_and_valid(*name, SENSORS_SMSC47M192_IN(i),
4478	&label, &valid) &&
4479	!sensors_get_feature(*name, SENSORS_SMSC47M192_IN(i), &cur) &&
4480	!sensors_get_feature(*name, SENSORS_SMSC47M192_IN_MIN(i), &min) &&
4481	!sensors_get_feature(*name, SENSORS_SMSC47M192_IN_MAX(i), &max)) {
4482	if (valid) {
4483	print_label(label,10);
4484	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) ", cur, min, max);
4485	if (!sensors_get_feature(*name, SENSORS_SMSC47M192_IN_ALARM(i), &cur))
4486	if (cur > 0.5)
4487	printf("ALARM");
4488	printf("\n");
4489	}
4490	} else
4491	if (i!=4) /* Chip may have +12V input used for VID instead */
4492	printf("ERROR: Can't get IN%d data!\n", i);
4493	free(label);
4494	}
4495	for (i=1; i<=3; i++) {
4496	if (!sensors_get_label_and_valid(*name, SENSORS_SMSC47M192_TEMP(i),
4497	&label, &valid) &&
4498	!sensors_get_feature(*name, SENSORS_SMSC47M192_TEMP(i), &cur) &&
4499	!sensors_get_feature(*name, SENSORS_SMSC47M192_TEMP_MIN(i), &min) &&
4500	!sensors_get_feature(*name, SENSORS_SMSC47M192_TEMP_MAX(i), &max)) {
4501	if (valid) {
4502	print_label(label,10);
4503	print_temp_info( cur, max, min, MINMAX, 1, 0);
4504	if (i > 1 && !sensors_get_feature(*name,
4505	SENSORS_SMSC47M192_TEMP_FAULT(i), &cur)) {
4506	if (cur > 0.5)
4507	printf("FAULT");
4508	} else
4509	if (!sensors_get_feature(*name, SENSORS_SMSC47M192_TEMP_ALARM(i), &cur))
4510	if (cur > 0.5)
4511	printf("ALARM");
4512	printf("\n");
4513	}
4514	} else
4515	printf("ERROR: Can't get TEMP%d data!\n", i);
4516	free(label);
4517	}
4518	print_vid_info(name, SENSORS_SMSC47M192_VID, SENSORS_SMSC47M192_VRM);
4519	}
4520
4521	void print_pc87360(const sensors_chip_name *name)
4522	{
4523	char *label;
4524	double cur, min, fdiv, tmp;
4525	int status, valid;
4526
4527	if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_FAN1, &label, &valid)
4528	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN1, &cur)
4529	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN1_DIV, &fdiv)
4530	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN1_MIN, &min)
4531	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN1_STATUS, &tmp)) {
4532	if (valid) {
4533	print_label(label, 10);
4534	status = tmp + 0.5;
4535	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4536	cur, min, fdiv,
4537	status&PC87360_STATUS_FAN_OVERFLOW?"OVERFLOW":
4538	status&PC87360_STATUS_FAN_LOW?"ALARM":"");
4539	}
4540	}
4541	free(label);
4542
4543	if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_FAN2, &label, &valid)
4544	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN2, &cur)
4545	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN2_DIV, &fdiv)
4546	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN2_MIN, &min)
4547	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN2_STATUS, &tmp)) {
4548	if (valid) {
4549	print_label(label, 10);
4550	status = tmp + 0.5;
4551	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4552	cur, min, fdiv,
4553	status&PC87360_STATUS_FAN_OVERFLOW?"OVERFLOW":
4554	status&PC87360_STATUS_FAN_LOW?"ALARM":"");
4555	}
4556	}
4557	free(label);
4558	}
4559
4560	void print_pc87364(const sensors_chip_name *name)
4561	{
4562	char *label;
4563	double cur, min, fdiv, tmp;
4564	int status, valid;
4565
4566	print_pc87360(name);
4567
4568	if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_FAN3, &label, &valid)
4569	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN3, &cur)
4570	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN3_DIV, &fdiv)
4571	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN3_MIN, &min)
4572	&& !sensors_get_feature(*name, SENSORS_PC87360_FAN3_STATUS, &tmp)) {
4573	if (valid) {
4574	print_label(label, 10);
4575	status = tmp + 0.5;
4576	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4577	cur, min, fdiv,
4578	status&PC87360_STATUS_FAN_OVERFLOW?"OVERFLOW":
4579	status&PC87360_STATUS_FAN_LOW?"ALARM":"");
4580	}
4581	}
4582	free(label);
4583	}
4584
4585	void print_pc87366(const sensors_chip_name *name)
4586	{
4587	char *label;
4588	double cur, min, max;
4589	int status, valid, i, tempnr = 2;
4590
4591	for (i = 0; i < 11; i++) {
4592	if (!sensors_get_feature(*name, SENSORS_PC87360_IN0_STATUS + i, &cur))
4593	status = cur + 0.5;
4594	else {
4595	printf("ERROR: Can't get IN%d status data!\n", i);
4596	status = 0;
4597	}
4598
4599	if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_IN0 + i, &label, &valid)
4600	&& !sensors_get_feature(*name, SENSORS_PC87360_IN0 + i, &cur)
4601	&& !sensors_get_feature(*name, SENSORS_PC87360_IN0_MIN + i, &min)
4602	&& !sensors_get_feature(*name, SENSORS_PC87360_IN0_MAX + i, &max)) {
4603	if (valid) {
4604	print_label(label, 10);
4605	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4606	cur, min, max,
4607	status&(PC87365_STATUS_IN_MIN
4608	\|PC87365_STATUS_IN_MAX)?"ALARM":"");
4609	}
4610	} else
4611	printf("ERROR: Can't get IN%d data!\n", i);
4612	free(label);
4613	}
4614
4615	print_pc87364(name);
4616
4617	if (!strcmp(name->prefix, "pc87366"))
4618	tempnr = 6;
4619
4620	for (i = 0; i < tempnr; i++) {
4621	if (!sensors_get_feature(*name, SENSORS_PC87360_TEMP1_STATUS + i, &cur))
4622	status = cur + 0.5;
4623	else {
4624	printf("ERROR: Can't get TEMP%d status data!\n", i + 1);
4625	status = 0;
4626	}
4627
4628	if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_TEMP1 + i, &label, &valid)
4629	&& !sensors_get_feature(*name, SENSORS_PC87360_TEMP1 + i, &cur)
4630	&& !sensors_get_feature(*name, SENSORS_PC87360_TEMP1_MIN + i, &min)
4631	&& !sensors_get_feature(*name, SENSORS_PC87360_TEMP1_MAX + i, &max)) {
4632	if (valid) {
4633	print_label(label, 10);
4634	print_temp_info(cur, max, min, MINMAX, 0, 0);
4635	if (i<3 && status&PC87365_STATUS_TEMP_OPEN)
4636	printf(" OPEN");
4637	else if (status&(PC87365_STATUS_TEMP_MIN\|PC87365_STATUS_TEMP_MAX))
4638	printf(" ALARM");
4639	printf("\n");
4640	}
4641	} else
4642	printf("ERROR: Can't get TEMP%d data!\n", i + 1);
4643	free(label);
4644
4645	if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_TEMP1_CRIT + i, &label, &valid)
4646	&& !sensors_get_feature(*name, SENSORS_PC87360_TEMP1_CRIT + i, &cur)) {
4647	if (valid) {
4648	print_label(label, 10);
4649	print_temp_info(cur, 0, 0, SINGLE, 0, 0);
4650	if (status&PC87365_STATUS_TEMP_CRIT)
4651	printf(" ALARM");
4652	printf("\n");
4653	}
4654	} else
4655	printf("ERROR: Can't get TEMP%d overtemperature data!\n", i + 1);
4656	free(label);
4657	}
4658
4659	print_vid_info(name, SENSORS_PC87360_VID, SENSORS_PC87360_VRM);
4660	}
4661
4662	static void lm92_print_temp (float n_cur,float n_high,float n_low,float n_crit,float n_hyst)
4663	{
4664	if (fahrenheit) {
4665	n_cur = deg_ctof (n_cur);
4666	n_high = deg_ctof (n_high);
4667	n_low = deg_ctof (n_low);
4668	n_crit = deg_ctof (n_crit);
4669	n_hyst = deg_ctof (n_hyst);
4670	}
4671
4672	printf ("%+6.4f%s (high = %+6.4f%s, low = %+6.4f%s, crit = %+6.4f%s, hyst = %+6.4f%s)",
4673	n_cur, degstr,
4674	n_high, degstr,
4675	n_low, degstr,
4676	n_crit, degstr,
4677	n_hyst, degstr);
4678	}
4679
4680	void print_lm92 (const sensors_chip_name *name)
4681	{
4682	char *label;
4683	double temp[5];
4684	int valid,alarms;
4685
4686	if (!sensors_get_feature (*name,SENSORS_LM92_ALARMS,temp)) {
4687	alarms = *temp + 0.5;
4688	} else {
4689	printf ("ERROR: Can't get alarm data!\n");
4690	return;
4691	}
4692
4693	if (!sensors_get_label_and_valid (*name,SENSORS_LM92_TEMP,&label,&valid) &&
4694	!sensors_get_feature (*name,SENSORS_LM92_TEMP,temp) &&
4695	!sensors_get_feature (*name,SENSORS_LM92_TEMP_HIGH,temp + 1) &&
4696	!sensors_get_feature (*name,SENSORS_LM92_TEMP_LOW,temp + 2) &&
4697	!sensors_get_feature (*name,SENSORS_LM92_TEMP_CRIT,temp + 3) &&
4698	!sensors_get_feature (*name,SENSORS_LM92_TEMP_HYST,temp + 4)) {
4699	if (valid) {
4700	print_label (label,10);
4701	lm92_print_temp (temp[0],temp[1],temp[2],temp[3],temp[4]);
4702	if (alarms) {
4703	printf (" ALARMS (");
4704
4705	if ((alarms & LM92_ALARM_TEMP_HIGH))
4706	printf ("HIGH");
4707
4708	if (alarms & LM92_ALARM_TEMP_LOW)
4709	printf ("%sLOW",(alarms & LM92_ALARM_TEMP_HIGH) ? "," : "");
4710
4711	if (alarms & LM92_ALARM_TEMP_CRIT)
4712	printf ("%sCRIT",(alarms & (LM92_ALARM_TEMP_HIGH \| LM92_ALARM_TEMP_LOW)) ? "," : "");
4713
4714	printf (")");
4715	}
4716	printf ("\n");
4717	}
4718	} else printf ("ERROR: Can't get temperature data!\n");
4719
4720	free(label);
4721	}
4722
4723	void print_vt8231(const sensors_chip_name *name)
4724	{
4725	char *label;
4726	double cur,min,max,fdiv;
4727	int alarms,valid;
4728
4729	if (!sensors_get_feature(*name,SENSORS_VT8231_ALARMS,&cur))
4730	alarms = cur + 0.5;
4731	else {
4732	printf("ERROR: Can't get alarm data!\n");
4733	alarms = 0;
4734	}
4735
4736	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN0,&label,&valid) &&
4737	!sensors_get_feature(*name,SENSORS_VT8231_IN0,&cur) &&
4738	!sensors_get_feature(*name,SENSORS_VT8231_IN0_MIN,&min) &&
4739	!sensors_get_feature(*name,SENSORS_VT8231_IN0_MAX,&max)) {
4740	if (valid) {
4741	print_label(label,10);
4742	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4743	cur,min,max,alarms&VT8231_ALARM_IN0?"ALARM":"");
4744	}
4745	}
4746	free(label);
4747	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN1,&label,&valid) &&
4748	!sensors_get_feature(*name,SENSORS_VT8231_IN1,&cur) &&
4749	!sensors_get_feature(*name,SENSORS_VT8231_IN1_MIN,&min) &&
4750	!sensors_get_feature(*name,SENSORS_VT8231_IN1_MAX,&max)) {
4751	if (valid) {
4752	print_label(label,10);
4753	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4754	cur,min,max,alarms&VT8231_ALARM_IN1?"ALARM":"");
4755	}
4756	}
4757	free(label);
4758	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN2,&label,&valid) &&
4759	!sensors_get_feature(*name,SENSORS_VT8231_IN2,&cur) &&
4760	!sensors_get_feature(*name,SENSORS_VT8231_IN2_MIN,&min) &&
4761	!sensors_get_feature(*name,SENSORS_VT8231_IN2_MAX,&max)) {
4762	if (valid) {
4763	print_label(label,10);
4764	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4765	cur,min,max,alarms&VT8231_ALARM_IN2?"ALARM":"");
4766	}
4767	}
4768	free(label);
4769	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN3,&label,&valid) &&
4770	!sensors_get_feature(*name,SENSORS_VT8231_IN3,&cur) &&
4771	!sensors_get_feature(*name,SENSORS_VT8231_IN3_MIN,&min) &&
4772	!sensors_get_feature(*name,SENSORS_VT8231_IN3_MAX,&max)) {
4773	if (valid) {
4774	print_label(label,10);
4775	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4776	cur,min,max,alarms&VT8231_ALARM_IN3?"ALARM":"");
4777	}
4778	}
4779	free(label);
4780	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN4,&label,&valid) &&
4781	!sensors_get_feature(*name,SENSORS_VT8231_IN4,&cur) &&
4782	!sensors_get_feature(*name,SENSORS_VT8231_IN4_MIN,&min) &&
4783	!sensors_get_feature(*name,SENSORS_VT8231_IN4_MAX,&max)) {
4784	if (valid) {
4785	print_label(label,10);
4786	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4787	cur,min,max,alarms&VT8231_ALARM_IN4?"ALARM":"");
4788	}
4789	}
4790	free(label);
4791	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN5,&label,&valid) &&
4792	!sensors_get_feature(*name,SENSORS_VT8231_IN5,&cur) &&
4793	!sensors_get_feature(*name,SENSORS_VT8231_IN5_MIN,&min) &&
4794	!sensors_get_feature(*name,SENSORS_VT8231_IN5_MAX,&max)) {
4795	if (valid) {
4796	print_label(label,10);
4797	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4798	cur,min,max,alarms&VT8231_ALARM_IN5?"ALARM":"");
4799	}
4800	} else
4801	printf("ERROR: Can't get IN5 data!\n");
4802	free(label);
4803
4804	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_FAN1,&label,&valid) &&
4805	!sensors_get_feature(*name,SENSORS_VT8231_FAN1,&cur) &&
4806	!sensors_get_feature(*name,SENSORS_VT8231_FAN1_DIV,&fdiv) &&
4807	!sensors_get_feature(*name,SENSORS_VT8231_FAN1_MIN,&min)) {
4808	if (valid) {
4809	print_label(label,10);
4810	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4811	cur,min,fdiv, alarms&VT8231_ALARM_FAN1?"ALARM":"");
4812	}
4813	} else
4814	printf("ERROR: Can't get FAN1 data!\n");
4815	free(label);
4816	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_FAN2,&label,&valid) &&
4817	!sensors_get_feature(*name,SENSORS_VT8231_FAN2,&cur) &&
4818	!sensors_get_feature(*name,SENSORS_VT8231_FAN2_DIV,&fdiv) &&
4819	!sensors_get_feature(*name,SENSORS_VT8231_FAN2_MIN,&min)) {
4820	if (valid) {
4821	print_label(label,10);
4822	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
4823	cur,min,fdiv, alarms&VT8231_ALARM_FAN2?"ALARM":"");
4824	}
4825	} else
4826	printf("ERROR: Can't get FAN2 data!\n");
4827	free(label);
4828
4829	if (!sensors_get_label_and_valid(*name, SENSORS_VT8231_TEMP,
4830	&label, &valid) &&
4831	!sensors_get_feature(*name, SENSORS_VT8231_TEMP, &cur) &&
4832	!sensors_get_feature(*name, SENSORS_VT8231_TEMP_HYST, &min) &&
4833	!sensors_get_feature(*name, SENSORS_VT8231_TEMP_OVER, &max)) {
4834	if (valid) {
4835	print_label(label, 10);
4836	print_temp_info(cur, max, min, HYST, 1, 0);
4837	printf(" %s\n", alarms & VT8231_ALARM_TEMP ? "ALARM" : "");
4838	}
4839	} else
4840	printf("ERROR: Can't get TEMP1 data!\n");
4841	free(label);
4842	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP2,&label,&valid) &&
4843	!sensors_get_feature(*name,SENSORS_VT8231_TEMP2,&cur) &&
4844	!sensors_get_feature(*name,SENSORS_VT8231_TEMP2_HYST,&min) &&
4845	!sensors_get_feature(*name,SENSORS_VT8231_TEMP2_OVER,&max)) {
4846	if (valid) {
4847	print_label(label,10);
4848	print_temp_info( cur, max, min, HYST, 1, 0);
4849	printf(" %s\n", alarms & VT8231_ALARM_TEMP2 ? "ALARM" : "" );
4850	}
4851	}
4852	free(label);
4853	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP3,&label,&valid) &&
4854	!sensors_get_feature(*name,SENSORS_VT8231_TEMP3,&cur) &&
4855	!sensors_get_feature(*name,SENSORS_VT8231_TEMP3_HYST,&min) &&
4856	!sensors_get_feature(*name,SENSORS_VT8231_TEMP3_OVER,&max)) {
4857	if (valid) {
4858	print_label(label,10);
4859	print_temp_info( cur, max, min, HYST, 1, 0);
4860	printf(" %s\n", alarms & VT8231_ALARM_TEMP3 ? "ALARM" : "" );
4861	}
4862	}
4863	free(label);
4864	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP4,&label,&valid) &&
4865	!sensors_get_feature(*name,SENSORS_VT8231_TEMP4,&cur) &&
4866	!sensors_get_feature(*name,SENSORS_VT8231_TEMP4_HYST,&min) &&
4867	!sensors_get_feature(*name,SENSORS_VT8231_TEMP4_OVER,&max)) {
4868	if (valid) {
4869	print_label(label,10);
4870	print_temp_info( cur, max, min, HYST, 1, 0);
4871	printf(" %s\n", alarms & VT8231_ALARM_TEMP4 ? "ALARM" : "" );
4872	}
4873	}
4874	free(label);
4875	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP5,&label,&valid) &&
4876	!sensors_get_feature(*name,SENSORS_VT8231_TEMP5,&cur) &&
4877	!sensors_get_feature(*name,SENSORS_VT8231_TEMP5_HYST,&min) &&
4878	!sensors_get_feature(*name,SENSORS_VT8231_TEMP5_OVER,&max)) {
4879	if (valid) {
4880	print_label(label,10);
4881	print_temp_info( cur, max, min, HYST, 1, 0);
4882	printf(" %s\n", alarms & VT8231_ALARM_TEMP5 ? "ALARM" : "" );
4883	}
4884	}
4885	free(label);
4886	if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP6,&label,&valid) &&
4887	!sensors_get_feature(*name,SENSORS_VT8231_TEMP6,&cur) &&
4888	!sensors_get_feature(*name,SENSORS_VT8231_TEMP6_HYST,&min) &&
4889	!sensors_get_feature(*name,SENSORS_VT8231_TEMP6_OVER,&max)) {
4890	if (valid) {
4891	print_label(label,10);
4892	print_temp_info( cur, max, min, HYST, 1, 0);
4893	printf(" %s\n", alarms & VT8231_ALARM_TEMP6 ? "ALARM" : "" );
4894	}
4895	}
4896	free(label);
4897
4898	print_vid_info(name, SENSORS_VT8231_VID, SENSORS_VT8231_VRM);
4899	}
4900
4901	#define BMC_MAX_INS 10
4902	#define BMC_MAX_FANS 10
4903	#define BMC_MAX_TEMPS 10
4904
4905	void print_bmc(const sensors_chip_name *name)
4906	{
4907	char *label;
4908	double cur,min,max;
4909	int alarms, valid, i;
4910
4911	/*
4912	if (!sensors_get_feature(*name,SENSORS_VT8231_ALARMS,&cur))
4913	alarms = cur + 0.5;
4914	else {
4915	printf("ERROR: Can't get alarm data!\n");
4916	alarms = 0;
4917	}
4918	*/
4919	#define BMC_ALARM_IN1 0
4920	#define BMC_ALARM_FAN1 0
4921	#define BMC_ALARM_TEMP1 0
4922
4923	alarms = 0;
4924	for(i = 0; i < BMC_MAX_INS; i++) {
4925	if (!sensors_get_label_and_valid(*name,SENSORS_BMC_IN1+i,&label,&valid) &&
4926	!sensors_get_feature(*name,SENSORS_BMC_IN1+i,&cur) &&
4927	!sensors_get_feature(*name,SENSORS_BMC_IN1_MIN+i,&min) &&
4928	!sensors_get_feature(*name,SENSORS_BMC_IN1_MAX+i,&max)) {
4929	if (valid) {
4930	print_label(label,10);
4931	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
4932	cur,min,max,alarms&BMC_ALARM_IN1?"ALARM":"");
4933	}
4934	}
4935	free(label);
4936	}
4937
4938	for(i = 0; i < BMC_MAX_FANS; i++) {
4939	if (!sensors_get_label_and_valid(*name,SENSORS_BMC_FAN1+i,&label,&valid) &&
4940	!sensors_get_feature(*name,SENSORS_BMC_FAN1+i,&cur) &&
4941	!sensors_get_feature(*name,SENSORS_BMC_FAN1_MIN+i,&min)) {
4942	if (valid) {
4943	print_label(label,10);
4944	printf("%4.0f RPM (min = %4.0f RPM) %s\n",
4945	cur,min,alarms&BMC_ALARM_FAN1?"ALARM":"");
4946	}
4947	}
4948	free(label);
4949	}
4950
4951	for(i = 0; i < BMC_MAX_TEMPS; i++) {
4952	if (!sensors_get_label_and_valid(*name,SENSORS_BMC_TEMP1+i,&label,&valid) &&
4953	!sensors_get_feature(*name,SENSORS_BMC_TEMP1+i,&cur) &&
4954	!sensors_get_feature(*name,SENSORS_BMC_TEMP1_MIN+i,&min) &&
4955	!sensors_get_feature(*name,SENSORS_BMC_TEMP1_MAX+i,&max)) {
4956	if (valid) {
4957	print_label(label,10);
4958	print_temp_info( cur, max, min, HYST, 1, 0);
4959	printf(" %s\n", alarms & BMC_ALARM_TEMP1 ? "ALARM" : "" );
4960	}
4961	}
4962	free(label);
4963	}
4964	}
4965
4966	static long adm1026_alarms_in[] = {
4967	ADM1026_ALARM_IN0, ADM1026_ALARM_IN1, ADM1026_ALARM_IN2,
4968	ADM1026_ALARM_IN3, ADM1026_ALARM_IN4, ADM1026_ALARM_IN5,
4969	ADM1026_ALARM_IN6, ADM1026_ALARM_IN7, ADM1026_ALARM_IN8,
4970	ADM1026_ALARM_IN9, ADM1026_ALARM_IN10, ADM1026_ALARM_IN11,
4971	ADM1026_ALARM_IN12, ADM1026_ALARM_IN13, ADM1026_ALARM_IN14,
4972	ADM1026_ALARM_IN15, ADM1026_ALARM_IN16
4973	};
4974	static long adm1026_alarms_temp[] = {
4975	ADM1026_ALARM_TEMP1, ADM1026_ALARM_TEMP2, ADM1026_ALARM_TEMP3
4976	};
4977
4978	void print_adm1026(const sensors_chip_name *name)
4979	{
4980	char *label;
4981	double cur,min,max;
4982	long alarms;
4983	int valid, i;
4984
4985	if (!sensors_get_feature(*name,SENSORS_ADM1026_ALARMS,&cur)) {
4986	alarms = cur + 0.5;
4987	} else {
4988	printf("ERROR: Can't get alarm data!\n");
4989	alarms = 0;
4990	}
4991
4992	/* Seventeen voltage sensors */
4993	for (i = 0; i <= 16 ; ++i) {
4994	int feat_base = SENSORS_ADM1026_IN0 + (3 * i);
4995	int feat_max = feat_base +1, feat_min = feat_base +2;
4996	if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) &&
4997	!sensors_get_feature(*name,feat_base,&cur) &&
4998	!sensors_get_feature(*name,feat_min,&min) &&
4999	!sensors_get_feature(*name,feat_max,&max)) {
5000	if (valid) {
5001	print_label(label,10);
5002	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
5003	cur,min,max,(alarms&adm1026_alarms_in[i])?"ALARM":"");
5004	}
5005	} else {
5006	printf("ERROR: Can't get IN%d data!\n",i);
5007	}
5008	free(label);
5009	};
5010
5011	/* Eight fan sensors */
5012	for (i = 0; i <= 7 ; ++i) {
5013	int feat_base = SENSORS_ADM1026_FAN0 + (3 * i);
5014	int feat_div = feat_base +1, feat_min = feat_base +2;
5015	if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) &&
5016	!sensors_get_feature(*name,feat_base,&cur) &&
5017	!sensors_get_feature(*name,feat_min,&min) &&
5018	!sensors_get_feature(*name,feat_div,&max)) {
5019	if (valid) {
5020	print_label(label,10);
5021	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
5022	cur,min,max,(alarms&(ADM1026_ALARM_FAN0<<i))?"ALARM":"");
5023	}
5024	} else {
5025	printf("ERROR: Can't get FAN%d data!\n",i);
5026	}
5027	free(label);
5028	};
5029
5030	/* Three temperature sensors
5031	* NOTE: 6 config values per temperature
5032	* 0 current
5033	* 1 max
5034	* 2 min
5035	* 3 offset (to current)
5036	* 4 therm (SMBAlert)
5037	* 5 tmin (AFC)
5038	*/
5039	for (i = 0; i <= 2 ; ++i) {
5040	int feat_base = SENSORS_ADM1026_TEMP1 + (6 * i);
5041	int feat_max = feat_base +1;
5042	int feat_min = feat_base +2;
5043
5044	if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) &&
5045	!sensors_get_feature(*name,feat_base,&cur) &&
5046	!sensors_get_feature(*name,feat_min,&min) &&
5047	!sensors_get_feature(*name,feat_max,&max)) {
5048	if (valid) {
5049	print_label(label,10);
5050	print_temp_info( cur, max, min, MINMAX, 0, 0);
5051	puts( (alarms&adm1026_alarms_temp[i])?" ALARM":"" );
5052	}
5053	} else {
5054	printf("ERROR: Can't get TEMP%d data!\n",i+1);
5055	}
5056	free(label);
5057	};
5058
5059	/* VID/VRM */
5060	print_vid_info(name, SENSORS_ADM1026_VID, SENSORS_ADM1026_VRM);
5061	}
5062
5063	void print_lm83(const sensors_chip_name *name)
5064	{
5065	char *label;
5066	double cur,high,crit;
5067	int valid,alarms;
5068
5069	if (!sensors_get_feature(*name,SENSORS_LM83_ALARMS,&cur))
5070	alarms = cur + 0.5;
5071	else {
5072	printf("ERROR: Can't get alarm data!\n");
5073	alarms = 0;
5074	}
5075
5076	if (sensors_get_feature(*name,SENSORS_LM83_TCRIT,&crit)) {
5077	printf("ERROR: Can't get tcrit data!\n");
5078	crit = 127;
5079	}
5080
5081	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_LOCAL_TEMP,&label,&valid) &&
5082	!sensors_get_feature(*name,SENSORS_LM83_LOCAL_TEMP,&cur) &&
5083	!sensors_get_feature(*name,SENSORS_LM83_LOCAL_HIGH,&high)) {
5084	if (valid) {
5085	print_label(label,10);
5086	print_temp_info( cur, high, crit, CRIT, 0, 0);
5087	printf(" %s\n",
5088	alarms&LM83_ALARM_LOCAL_CRIT?"CRITICAL":
5089	alarms&LM83_ALARM_LOCAL_HIGH?"ALARM":"");
5090	}
5091	} else
5092	printf("ERROR: Can't get local temperature data!\n");
5093	free(label);
5094
5095	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE1_TEMP,&label,&valid) &&
5096	!sensors_get_feature(*name,SENSORS_LM83_REMOTE1_TEMP,&cur) &&
5097	!sensors_get_feature(*name,SENSORS_LM83_REMOTE1_HIGH,&high)) {
5098	if (valid) {
5099	print_label(label,10);
5100	print_temp_info( cur, high, crit, CRIT, 0, 0);
5101	printf(" %s\n",
5102	alarms&LM83_ALARM_REMOTE1_OPEN?"DISCONNECT":
5103	alarms&LM83_ALARM_REMOTE1_CRIT?"CRITICAL":
5104	alarms&LM83_ALARM_REMOTE1_HIGH?"ALARM":"");
5105	}
5106	} else
5107	printf("ERROR: Can't get remote temperature 1 data!\n");
5108	free(label);
5109
5110	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE2_TEMP,&label,&valid) &&
5111	!sensors_get_feature(*name,SENSORS_LM83_REMOTE2_TEMP,&cur) &&
5112	!sensors_get_feature(*name,SENSORS_LM83_REMOTE2_HIGH,&high)) {
5113	if (valid) {
5114	print_label(label,10);
5115	print_temp_info( cur, high, crit, CRIT, 0, 0);
5116	printf(" %s\n",
5117	alarms&LM83_ALARM_REMOTE2_OPEN?"DISCONNECT":
5118	alarms&LM83_ALARM_REMOTE2_CRIT?"CRITICAL":
5119	alarms&LM83_ALARM_REMOTE2_HIGH?"ALARM":"");
5120	}
5121	} else
5122	printf("ERROR: Can't get remote temperature 2 data!\n");
5123	free(label);
5124
5125	if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE3_TEMP,&label,&valid) &&
5126	!sensors_get_feature(*name,SENSORS_LM83_REMOTE3_TEMP,&cur) &&
5127	!sensors_get_feature(*name,SENSORS_LM83_REMOTE3_HIGH,&high)) {
5128	if (valid) {
5129	print_label(label,10);
5130	print_temp_info( cur, high, crit, CRIT, 0, 0);
5131	printf(" %s\n",
5132	alarms&LM83_ALARM_REMOTE3_OPEN?"DISCONNECT":
5133	alarms&LM83_ALARM_REMOTE3_CRIT?"CRITICAL":
5134	alarms&LM83_ALARM_REMOTE3_HIGH?"ALARM":"");
5135	}
5136	} else
5137	printf("ERROR: Can't get remote temperature 3 data!\n");
5138	free(label);
5139	}
5140
5141	void print_lm90(const sensors_chip_name *name)
5142	{
5143	char *label;
5144	double cur, high, low, hyst;
5145	int valid, alarms;
5146
5147	if (!sensors_get_feature(*name, SENSORS_LM90_ALARMS, &cur))
5148	alarms = cur + 0.5;
5149	else {
5150	printf("ERROR: Can't get alarm data!\n");
5151	alarms = 0;
5152	}
5153
5154	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_LOCAL_TEMP,
5155	&label, &valid)
5156	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TEMP, &cur)
5157	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_HIGH, &high)
5158	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_LOW, &low)) {
5159	if (valid) {
5160	print_label(label, 10);
5161	print_temp_info(cur, high, low, MINMAX, 0, 0);
5162	printf(" %s\n",
5163	alarms&LM90_ALARM_LOCAL_CRIT?"CRITICAL":
5164	alarms&(LM90_ALARM_LOCAL_HIGH\|LM90_ALARM_LOCAL_LOW)?"ALARM":"");
5165	}
5166	} else
5167	printf("ERROR: Can't get local temperature data!\n");
5168	free(label);
5169
5170	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_REMOTE_TEMP,
5171	&label, &valid)
5172	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TEMP, &cur)
5173	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_HIGH, &high)
5174	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_LOW, &low)) {
5175	if (valid) {
5176	print_label(label, 10);
5177	print_temp_info(cur, high, low, MINMAX, 1, 1);
5178	printf(" %s\n",
5179	alarms&LM90_ALARM_REMOTE_OPEN?"DISCONNECT":
5180	alarms&LM90_ALARM_REMOTE_CRIT?"CRITICAL":
5181	alarms&(LM90_ALARM_REMOTE_HIGH\|LM90_ALARM_REMOTE_LOW)?"ALARM":"");
5182	}
5183	} else
5184	printf("ERROR: Can't get remote temperature data!\n");
5185	free(label);
5186
5187	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_LOCAL_TCRIT,
5188	&label, &valid)
5189	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TCRIT, &high)
5190	&& !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TCRIT_HYST, &hyst)) {
5191	if (valid) {
5192	print_label(label, 10);
5193	print_temp_info(high, hyst, 0, HYSTONLY, 0, 0);
5194	printf("\n");
5195	}
5196	} else
5197	printf("ERROR: Can't get local tcrit data!\n");
5198	free(label);
5199
5200	if (!sensors_get_label_and_valid(*name, SENSORS_LM90_REMOTE_TCRIT,
5201	&label, &valid)
5202	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TCRIT, &high)
5203	&& !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TCRIT_HYST, &hyst)) {
5204	if (valid) {
5205	print_label(label, 10);
5206	print_temp_info(high, hyst, 0, HYSTONLY, 0, 0);
5207	printf("\n");
5208	}
5209	} else
5210	printf("ERROR: Can't get remote tcrit data!\n");
5211	free(label);
5212	}
5213
5214	void print_lm63(const sensors_chip_name *name)
5215	{
5216	char *label;
5217	double cur, high, low;
5218	int valid, alarms;
5219
5220	if (!sensors_get_feature(*name, SENSORS_LM63_ALARMS, &cur))
5221	alarms = cur + 0.5;
5222	else {
5223	printf("ERROR: Can't get alarm data!\n");
5224	alarms = 0;
5225	}
5226
5227	if (!sensors_get_label_and_valid(*name, SENSORS_LM63_LOCAL_TEMP,
5228	&label, &valid)
5229	&& !sensors_get_feature(*name, SENSORS_LM63_LOCAL_TEMP, &cur)
5230	&& !sensors_get_feature(*name, SENSORS_LM63_LOCAL_HIGH, &high)) {
5231	if (valid) {
5232	print_label(label, 10);
5233	print_temp_info(cur, high, 0, MAXONLY, 0, 0);
5234	printf(" %s\n",
5235	alarms&LM63_ALARM_LOCAL_HIGH?"ALARM":"");
5236	}
5237	} else
5238	printf("ERROR: Can't get local temperature data!\n");
5239	free(label);
5240
5241	if (!sensors_get_label_and_valid(*name, SENSORS_LM63_REMOTE_TEMP,
5242	&label, &valid)
5243	&& !sensors_get_feature(*name, SENSORS_LM63_REMOTE_TEMP, &cur)
5244	&& !sensors_get_feature(*name, SENSORS_LM63_REMOTE_HIGH, &high)
5245	&& !sensors_get_feature(*name, SENSORS_LM63_REMOTE_LOW, &low)) {
5246	if (valid) {
5247	print_label(label, 10);
5248	print_temp_info(cur, high, low, MINMAX, 1, 1);
5249	printf(" %s\n",
5250	alarms&LM63_ALARM_REMOTE_OPEN?"OPEN":
5251	alarms&LM63_ALARM_REMOTE_CRIT?"CRITICAL":
5252	alarms&(LM63_ALARM_REMOTE_HIGH\|LM63_ALARM_REMOTE_LOW)?"ALARM":"");
5253	}
5254	} else
5255	printf("ERROR: Can't get remote temperature data!\n");
5256	free(label);
5257
5258	if (!sensors_get_label_and_valid(*name, SENSORS_LM63_REMOTE_TCRIT,
5259	&label, &valid)
5260	&& !sensors_get_feature(*name, SENSORS_LM63_REMOTE_TCRIT, &high)
5261	&& !sensors_get_feature(*name, SENSORS_LM63_REMOTE_TCRIT_HYST, &low)) {
5262	if (valid) {
5263	print_label(label, 10);
5264	print_temp_info(high, low, 0, HYSTONLY, 0, 0);
5265	printf("\n");
5266	}
5267	} else
5268	printf("ERROR: Can't get remote tcrit data!\n");
5269	free(label);
5270
5271	if (!sensors_get_label_and_valid(*name, SENSORS_LM63_FAN,
5272	&label, &valid)
5273	&& !sensors_get_feature(*name, SENSORS_LM63_FAN, &cur)
5274	&& !sensors_get_feature(*name, SENSORS_LM63_FAN_LOW, &low)) {
5275	if (valid) {
5276	print_label(label, 10);
5277	printf("%4.0f RPM (min = %4.0f RPM) %s\n", cur, low,
5278	alarms&LM63_ALARM_FAN_LOW?"ALARM":"");
5279	}
5280	}
5281	/* No error if fan files are missing as it will happen with 2.6
5282	kernels when the tachometer pin is used as an alarm output. */
5283	free(label);
5284	}
5285
5286	void print_adm1031(const sensors_chip_name *name)
5287	{
5288	char *label;
5289	double cur, high, low, crit, div;
5290	int valid, alarms, i;
5291	int is_1031 = !strncmp("adm1031", name->prefix, 7);
5292
5293	if (!sensors_get_feature(*name, SENSORS_ADM1031_ALARMS, &cur))
5294	alarms = cur;
5295	else {
5296	printf("ERROR: Can't get alarm data!\n");
5297	alarms = 0;
5298	}
5299
5300	for(i=0; i<(is_1031?2:1);i++) {
5301	if (!sensors_get_label_and_valid(name, SENSORS_ADM1031_FAN1+i10,
5302	&label, &valid)
5303	&& !sensors_get_feature(name, SENSORS_ADM1031_FAN1+i10, &cur)
5304	&& !sensors_get_feature(name, SENSORS_ADM1031_FAN1_MIN+i10, &low)
5305	&& !sensors_get_feature(name, SENSORS_ADM1031_FAN1_DIV+i10, &div)) {
5306	if (valid) {
5307	print_label(label, 10);
5308	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f)", cur, low, div);
5309	printf(" %s\n",
5310	alarms&(ADM1031_ALARM_FAN1_FLT<<(i*8))?"FAULT":
5311	alarms&(ADM1031_ALARM_FAN1_MIN<<(i*8))?"ALARM":"");
5312	}
5313	} else
5314	printf("ERROR: Can't get fan%d data!\n", i+1);
5315	free(label);
5316	}
5317
5318	if (!sensors_get_label_and_valid(*name, SENSORS_ADM1031_TEMP1,
5319	&label, &valid)
5320	&& !sensors_get_feature(*name, SENSORS_ADM1031_TEMP1, &cur)
5321	&& !sensors_get_feature(*name, SENSORS_ADM1031_TEMP1_MIN, &low)
5322	&& !sensors_get_feature(*name, SENSORS_ADM1031_TEMP1_MAX, &high)
5323	&& !sensors_get_feature(*name, SENSORS_ADM1031_TEMP1_CRIT, &crit)) {
5324	if (valid) {
5325	print_label(label, 10);
5326	print_temp_info(cur, high, low, MINMAX, 1, 0);
5327	printf(" %s\n",
5328	alarms&(ADM1031_ALARM_TEMP1_HIGH\|ADM1031_ALARM_TEMP1_LOW)?"ALARM":"");
5329	}
5330	} else
5331	printf("ERROR: Can't get temp1 temperature data!\n");
5332	free(label);
5333	if (!sensors_get_label_and_valid(*name, SENSORS_ADM1031_TEMP1_CRIT,
5334	&label, &valid)
5335	&& !sensors_get_feature(*name, SENSORS_ADM1031_TEMP1_CRIT, &cur)) {
5336	if (valid) {
5337	print_label(label, 10);
5338	print_temp_info(cur, 0, 0, SINGLE, 0, 0);
5339	printf(" %s\n",
5340	alarms&ADM1031_ALARM_TEMP1_CRIT?"CRITICAL":"");
5341	}
5342	} else
5343	printf("ERROR: Can't get temp1 temperature data!\n");
5344	free(label);
5345
5346	for (i=0; i < (is_1031 ? 2 : 1); i++) {
5347	if (!sensors_get_label_and_valid(name, SENSORS_ADM1031_TEMP2+i10,
5348	&label, &valid)
5349	&& !sensors_get_feature(name, SENSORS_ADM1031_TEMP2+i10, &cur)
5350	&& !sensors_get_feature(name, SENSORS_ADM1031_TEMP2_MIN+i10, &low)
5351	&& !sensors_get_feature(name, SENSORS_ADM1031_TEMP2_MAX+i10, &high)) {
5352	if (valid) {
5353	print_label(label, 10);
5354	print_temp_info(cur, high, low, MINMAX, 1, 0);
5355	printf(" %s\n",
5356	alarms&((ADM1031_ALARM_TEMP2_DIODE<<(i*8)))?"DISCONNECT":
5357	alarms&((ADM1031_ALARM_TEMP2_HIGH<<(i*8))\|
5358	(ADM1031_ALARM_TEMP2_LOW<<(i*8)))?"ALARM":"");
5359	}
5360	} else
5361	printf("ERROR: Can't get temp%d temperature data!\n", i+2);
5362	free(label);
5363	if (!sensors_get_label_and_valid(name, SENSORS_ADM1031_TEMP2_CRIT+i10,
5364	&label, &valid)
5365	&& !sensors_get_feature(name, SENSORS_ADM1031_TEMP2_CRIT+i10, &cur)) {
5366	if (valid) {
5367	print_label(label, 10);
5368	print_temp_info(cur, 0, 0, SINGLE, 0, 0);
5369	printf(" %s\n",
5370	alarms&((ADM1031_ALARM_TEMP2_CRIT<<(i*8)))?"CRITICAL":"");
5371	}
5372	} else
5373	printf("ERROR: Can't get temp%d crit temperature data!\n", i+2);
5374	free(label);
5375	}
5376	}
5377
5378	void print_xeontemp(const sensors_chip_name *name)
5379	{
5380	char *label;
5381	double cur,hyst,over;
5382	int alarms,i,valid;
5383
5384	if (!sensors_get_feature(*name,SENSORS_XEONTEMP_ALARMS,&cur))
5385	alarms = cur + 0.5;
5386	else {
5387	printf("ERROR: Can't get alarm data!\n");
5388	alarms = 0;
5389	}
5390
5391	if (!sensors_get_label_and_valid(*name,SENSORS_XEONTEMP_REMOTE_TEMP,
5392	&label,&valid) &&
5393	!sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP,&cur) &&
5394	!sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP_HYST,&hyst) &&
5395	!sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP_OVER,&over)) {
5396	if (valid) {
5397	print_label(label,10);
5398	print_temp_info( cur, over, hyst, MINMAX, 0, 0);
5399	if (alarms & (XEONTEMP_ALARM_RTEMP_HIGH \| XEONTEMP_ALARM_RTEMP_LOW \|
5400	XEONTEMP_ALARM_RTEMP_NA)) {
5401	printf("ALARM (");
5402	i = 0;
5403	if (alarms & XEONTEMP_ALARM_RTEMP_NA) {
5404	printf("N/A");
5405	i++;
5406	}
5407	if (alarms & XEONTEMP_ALARM_RTEMP_LOW) {
5408	printf("%sLOW",i?",":"");
5409	i++;
5410	}
5411	if (alarms & XEONTEMP_ALARM_RTEMP_HIGH)
5412	printf("%sHIGH",i?",":"");
5413	printf(")");
5414	}
5415	printf("\n");
5416	}
5417	} else
5418	printf("ERROR: Can't get temperature data!\n");
5419	free(label);
5420	}
5421
5422
5423	void print_max1619(const sensors_chip_name *name)
5424	{
5425	char *label;
5426	double cur, high, low;
5427	int valid, alarms;
5428
5429	if (!sensors_get_feature(*name, SENSORS_MAX1619_ALARMS, &cur))
5430	alarms = cur + 0.5;
5431	else {
5432	printf("ERROR: Can't get alarm data!\n");
5433	alarms = 0;
5434	}
5435
5436	if (!sensors_get_label_and_valid(*name, SENSORS_MAX1619_LOCAL_TEMP,
5437	&label, &valid)
5438	&& !sensors_get_feature(*name, SENSORS_MAX1619_LOCAL_TEMP, &cur)) {
5439	if (valid) {
5440	print_label(label, 10);
5441	print_temp_info(cur,0 ,0 ,SINGLE , 0, 0);
5442	printf("\n");
5443	}
5444	} else
5445	printf("ERROR: Can't get local temperature data!\n");
5446	free(label);
5447
5448	if (!sensors_get_label_and_valid(*name, SENSORS_MAX1619_REMOTE_TEMP,
5449	&label, &valid)
5450	&& !sensors_get_feature(*name, SENSORS_MAX1619_REMOTE_TEMP, &cur)
5451	&& !sensors_get_feature(*name, SENSORS_MAX1619_REMOTE_LOW, &low)
5452	&& !sensors_get_feature(*name, SENSORS_MAX1619_REMOTE_HIGH, &high)) {
5453	if (valid) {
5454	print_label(label, 10);
5455	print_temp_info(cur, low, high, MINMAX, 0, 0);
5456	printf(" %s\n",
5457	alarms&MAX1619_ALARM_REMOTE_OPEN?"DISCONNECT":
5458	alarms&(MAX1619_ALARM_REMOTE_THIGH\|MAX1619_ALARM_REMOTE_TLOW)?"ALARM":"");
5459	}
5460	} else
5461	printf("ERROR: Can't get remote temperature data!\n");
5462	free(label);
5463
5464	if (!sensors_get_label_and_valid(*name, SENSORS_MAX1619_REMOTE_MAX,
5465	&label, &valid)
5466	&& !sensors_get_feature(*name, SENSORS_MAX1619_REMOTE_MAX, &high)
5467	&& !sensors_get_feature(*name, SENSORS_MAX1619_REMOTE_HYST, &low)) {
5468	if (valid) {
5469	print_label(label, 10);
5470	print_temp_info(high, low, 0, HYSTONLY, 0, 0);
5471	printf("\n");
5472	}
5473	} else
5474	printf("ERROR: Can't get remote temperature max data!\n");
5475	free(label);
5476	}
5477
5478	void print_max6650(const sensors_chip_name *name)
5479	{
5480	char *label;
5481	double tach, speed;
5482	int valid, i;
5483
5484	static const struct
5485	{
5486	int tag;
5487	char *name;
5488	}
5489	tach_list[] =
5490	{
5491	{ SENSORS_MAX6650_FAN1_TACH, "FAN1" },
5492	{ SENSORS_MAX6650_FAN2_TACH, "FAN2" },
5493	{ SENSORS_MAX6650_FAN3_TACH, "FAN3" },
5494	{ SENSORS_MAX6650_FAN4_TACH, "FAN4" }
5495	};
5496
5497	/* Display full config for fan1, which is controlled */
5498
5499	if (!sensors_get_label_and_valid(*name,tach_list[0].tag,&label,&valid) &&
5500	!sensors_get_feature(*name,tach_list[0].tag,&tach) &&
5501	!sensors_get_feature(*name,SENSORS_MAX6650_SPEED,&speed)) {
5502	if (valid) {
5503	print_label(label,10);
5504	printf("configured %4.0f RPM, actual %4.0f RPM.\n", speed, tach);
5505	}
5506	} else
5507	printf("ERROR: Can't get %s data!\n", tach_list[0].name);
5508	free(label);
5509
5510	/* Just display the measured speed for the other three, uncontrolled fans */
5511
5512	for (i = 1; i < 4; i++)
5513	{
5514	if (!sensors_get_label_and_valid(*name,tach_list[i].tag,&label,&valid) &&
5515	!sensors_get_feature(*name,tach_list[i].tag,&tach)) {
5516	if (valid) {
5517	print_label(label,10);
5518	printf("%4.0f RPM\n", tach);
5519	}
5520	} else
5521	printf("ERROR: Can't get %s data!\n", tach_list[i].name);
5522
5523	free(label);
5524	}
5525	}
5526
5527	/* print_asb100_in()
5528	* where in, in_min, and in_max are sensors feature IDs
5529	*/
5530	static void print_asb100_in(const sensors_chip_name *name, int alarm,
5531	int in, int in_min, int in_max)
5532	{
5533	char *label;
5534	double cur, min, max;
5535	int valid;
5536
5537	if (!sensors_get_label_and_valid(*name,in,&label,&valid) &&
5538	!sensors_get_feature(*name,in,&cur) &&
5539	!sensors_get_feature(*name,in_min,&min) &&
5540	!sensors_get_feature(*name,in_max,&max)) {
5541	if (valid) {
5542	print_label(label,10);
5543	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
5544	cur, min, max, alarm ? "ALARM" : "");
5545	}
5546	} else
5547	printf("ERROR: Can't get IN data! (0x%04x)\n", in);
5548	free(label);
5549	}
5550
5551	#define PRINT_ASB100_IN(num, name, alarms) \
5552	print_asb100_in((name), ((alarms) & ASB100_ALARM_IN##num), \
5553	(SENSORS_ASB100_IN##num), \
5554	(SENSORS_ASB100_IN##num##_MIN), \
5555	(SENSORS_ASB100_IN##num##_MAX))
5556
5557	/* print_asb100_fan()
5558	* where fan, fan_div, and fan_min are sensors feature IDs
5559	*/
5560	static void print_asb100_fan(const sensors_chip_name *name, int alarm,
5561	int fan, int fan_div, int fan_min)
5562	{
5563	char *label;
5564	double cur, div, min;
5565	int valid;
5566
5567	if (!sensors_get_label_and_valid(*name,fan,&label,&valid) &&
5568	!sensors_get_feature(*name,fan,&cur) &&
5569	!sensors_get_feature(*name,fan_div,&div) &&
5570	!sensors_get_feature(*name,fan_min,&min)) {
5571	if (valid) {
5572	print_label(label,10);
5573	printf("%4.0f RPM (min = %4.0f RPM, div = %1.0f) %s\n",
5574	cur, min, div, alarm ? "ALARM" : "");
5575	}
5576	} else
5577	printf("ERROR: Can't get FAN data! (0x%04x)\n", fan);
5578	free(label);
5579	}
5580
5581	#define PRINT_ASB100_FAN(num, name, alarms) \
5582	print_asb100_fan((name), ((alarms) & ASB100_ALARM_FAN##num), \
5583	(SENSORS_ASB100_FAN##num), \
5584	(SENSORS_ASB100_FAN##num##_DIV), \
5585	(SENSORS_ASB100_FAN##num##_MIN))
5586
5587	/* print_asb100_temp()
5588	* where temp, temp_max, and temp_hyst are sensors feature IDs
5589	*/
5590	static void print_asb100_temp(const sensors_chip_name *name, int alarm,
5591	int temp, int temp_max, int temp_hyst)
5592	{
5593	char *label;
5594	double cur, max, hyst;
5595	int valid;
5596
5597	if (!sensors_get_label_and_valid(*name,temp,&label,&valid) &&
5598	!sensors_get_feature(*name,temp,&cur) &&
5599	!sensors_get_feature(*name,temp_max,&max) &&
5600	!sensors_get_feature(*name,temp_hyst,&hyst)) {
5601	if (valid) {
5602	print_label(label,10);
5603	if (hyst == 127)
5604	print_temp_info(cur, max, 0, MAXONLY, 0, 0);
5605	else
5606	print_temp_info(cur, max, hyst, HYST, 0, 0);
5607
5608	printf(" %s\n", alarm ? "ALARM" : "");
5609	}
5610	} else
5611	printf("ERROR: Can't get TEMP data! (0x%04x)\n", temp);
5612
5613	free(label);
5614	}
5615
5616	#ifndef ASB100_ALARM_TEMP4
5617	#define ASB100_ALARM_TEMP4 0
5618	#endif
5619
5620	#define PRINT_ASB100_TEMP(num, name, alarms) \
5621	print_asb100_temp((name), ((alarms) & ASB100_ALARM_TEMP##num), \
5622	(SENSORS_ASB100_TEMP##num), \
5623	(SENSORS_ASB100_TEMP##num##_OVER), \
5624	(SENSORS_ASB100_TEMP##num##_HYST))
5625
5626
5627	void print_asb100(const sensors_chip_name *name)
5628	{
5629	char *label;
5630	double cur;
5631	int valid, alarms = 0;
5632
5633	if (!sensors_get_feature(*name,SENSORS_ASB100_ALARMS,&cur))
5634	alarms = cur + 0.5;
5635	else
5636	printf("ERROR: Can't get alarm data!\n");
5637
5638	PRINT_ASB100_IN(0, name, alarms);
5639	PRINT_ASB100_IN(1, name, alarms);
5640	PRINT_ASB100_IN(2, name, alarms);
5641	PRINT_ASB100_IN(3, name, alarms);
5642	PRINT_ASB100_IN(4, name, alarms);
5643	PRINT_ASB100_IN(5, name, alarms);
5644	PRINT_ASB100_IN(6, name, alarms);
5645
5646	PRINT_ASB100_FAN(1, name, alarms);
5647	PRINT_ASB100_FAN(2, name, alarms);
5648	PRINT_ASB100_FAN(3, name, alarms);
5649
5650	PRINT_ASB100_TEMP(1, name, alarms);
5651	PRINT_ASB100_TEMP(2, name, alarms);
5652	PRINT_ASB100_TEMP(3, name, alarms);
5653	PRINT_ASB100_TEMP(4, name, alarms);
5654
5655	print_vid_info(name, SENSORS_ASB100_VID, SENSORS_ASB100_VRM);
5656
5657	if (!sensors_get_label_and_valid(*name,SENSORS_ASB100_ALARMS,&label,&valid)) {
5658	print_label(label,10);
5659	if (alarms & ASB100_ALARM_CHAS)
5660	printf("Chassis intrusion detection ALARM\n");
5661	else
5662	printf("\n");
5663	}
5664	free(label);
5665
5666	}
5667
5668	/* happens to be similar to asb100*/
5669	#define PRINT_LM93_IN(num, name, alarms) \
5670	print_asb100_in((name), ((alarms) & LM93_ALARM_IN##num), \
5671	(SENSORS_LM93_IN##num), \
5672	(SENSORS_LM93_IN##num##_MIN), \
5673	(SENSORS_LM93_IN##num##_MAX))
5674
5675	/* print_lm93_fan()
5676	* where fan and fan_min are sensors feature IDs
5677	*/
5678	static void print_lm93_fan(const sensors_chip_name *name, int alarm,
5679	int fan, int fan_min)
5680	{
5681	char *label;
5682	double cur, min;
5683	int valid;
5684
5685	if (!sensors_get_label_and_valid(*name,fan,&label,&valid) &&
5686	!sensors_get_feature(*name,fan,&cur) &&
5687	!sensors_get_feature(*name,fan_min,&min)) {
5688	if (valid) {
5689	print_label(label,10);
5690	printf("%4.0f RPM (min = %4.0f RPM) %s\n",
5691	cur, min, alarm ? "ALARM" : "");
5692	}
5693	} else
5694	printf("ERROR: Can't get FAN data! (0x%04x)\n", fan);
5695	free(label);
5696	}
5697
5698	#define PRINT_LM93_FAN(num, name, alarms) \
5699	print_lm93_fan((name), ((alarms) & LM93_ALARM_FAN##num), \
5700	(SENSORS_LM93_FAN##num), \
5701	(SENSORS_LM93_FAN##num##_MIN))
5702
5703	/* print_lm93_temp()
5704	* where temp, temp_min, and temp_max are sensors feature IDs
5705	*/
5706	static void print_lm93_temp(const sensors_chip_name *name, int alarm,
5707	int temp, int temp_min, int temp_max)
5708	{
5709	char *label;
5710	double cur, min, max;
5711	int valid;
5712
5713	if (!sensors_get_label_and_valid(*name,temp,&label,&valid) &&
5714	!sensors_get_feature(*name,temp,&cur) &&
5715	!sensors_get_feature(*name,temp_min,&min) &&
5716	!sensors_get_feature(*name,temp_max,&max)) {
5717	if (valid) {
5718	print_label(label,10);
5719	print_temp_info(cur, max, min, MINMAX, 0, 0);
5720	printf(" %s\n", alarm ? "ALARM" : "");
5721	}
5722	} else
5723	printf("ERROR: Can't get TEMP data! (0x%04x)\n", temp);
5724
5725	free(label);
5726	}
5727
5728	#define PRINT_LM93_TEMP(num, name, alarms) \
5729	print_lm93_temp((name), ((alarms) & LM93_ALARM_TEMP##num), \
5730	(SENSORS_LM93_TEMP##num), \
5731	(SENSORS_LM93_TEMP##num##_MIN), \
5732	(SENSORS_LM93_TEMP##num##_MAX))
5733
5734	/* print_lm93_vid()
5735	* where vid is a sensors feature ID
5736	*/
5737	static void print_lm93_vid(const sensors_chip_name *name, int vid)
5738	{
5739	char *label;
5740	double cur;
5741	int valid;
5742
5743	if (!sensors_get_label_and_valid(*name,vid,&label,&valid) &&
5744	!sensors_get_feature(*name,vid,&cur)) {
5745	if (valid) {
5746	print_label(label,10);
5747	printf("%+5.3f V\n",cur);
5748	}
5749	} else {
5750	printf("ERROR: Can't get VID data! (0x%04x)\n", vid);
5751	}
5752	free(label);
5753	}
5754
5755	void print_lm93(const sensors_chip_name *name)
5756	{
5757	double cur;
5758	int alarms = 0;
5759
5760	if (!sensors_get_feature(*name,SENSORS_LM93_ALARMS,&cur))
5761	alarms = cur + 0.5;
5762	else
5763	printf("ERROR: Can't get alarm data!\n");
5764
5765	PRINT_LM93_IN(1, name, alarms);
5766	PRINT_LM93_IN(2, name, alarms);
5767	PRINT_LM93_IN(3, name, alarms);
5768	PRINT_LM93_IN(4, name, alarms);
5769	PRINT_LM93_IN(5, name, alarms);
5770	PRINT_LM93_IN(6, name, alarms);
5771	PRINT_LM93_IN(7, name, alarms);
5772	PRINT_LM93_IN(8, name, alarms);
5773	PRINT_LM93_IN(9, name, alarms);
5774	PRINT_LM93_IN(10, name, alarms);
5775	PRINT_LM93_IN(11, name, alarms);
5776	PRINT_LM93_IN(12, name, alarms);
5777	PRINT_LM93_IN(13, name, alarms);
5778	PRINT_LM93_IN(14, name, alarms);
5779	PRINT_LM93_IN(15, name, alarms);
5780	PRINT_LM93_IN(16, name, alarms);
5781
5782	PRINT_LM93_FAN(1, name, alarms);
5783	PRINT_LM93_FAN(2, name, alarms);
5784	PRINT_LM93_FAN(3, name, alarms);
5785	PRINT_LM93_FAN(4, name, alarms);
5786
5787	PRINT_LM93_TEMP(1, name, alarms);
5788	PRINT_LM93_TEMP(2, name, alarms);
5789	PRINT_LM93_TEMP(3, name, alarms);
5790
5791	print_lm93_vid(name, SENSORS_LM93_VID1);
5792	print_lm93_vid(name, SENSORS_LM93_VID2);
5793	}
5794
5795	/* print_smsc47b397_temp()
5796	* where temp is a sensors feature ID
5797	*/
5798	static void print_smsc47b397_temp(const sensors_chip_name *name, int temp)
5799	{
5800	char *label;
5801	double cur;
5802	int valid;
5803
5804	if (!sensors_get_label_and_valid(*name,temp,&label,&valid) &&
5805	!sensors_get_feature(*name,temp,&cur)) {
5806	if (valid) {
5807	print_label(label,10);
5808	print_temp_info(cur, 0, 0, SINGLE, 0, 0);
5809	printf("\n");
5810	}
5811	} else
5812	printf("ERROR: Can't get TEMP data! (0x%04x)\n", temp);
5813
5814	free(label);
5815	}
5816
5817	#define PRINT_SMSC47B397_TEMP(num, name) \
5818	print_smsc47b397_temp((name), (SENSORS_SMSC47B397_TEMP1 + (num)))
5819
5820	/* print_smsc47b397_fan()
5821	* where fan is a sensors feature ID
5822	*/
5823	static void print_smsc47b397_fan(const sensors_chip_name *name, int fan)
5824	{
5825	char *label;
5826	double cur;
5827	int valid;
5828
5829	if (!sensors_get_label_and_valid(*name,fan,&label,&valid) &&
5830	!sensors_get_feature(*name,fan,&cur)) {
5831	if (valid) {
5832	print_label(label,10);
5833	printf("%4.0f RPM\n", cur);
5834	}
5835	} else
5836	printf("ERROR: Can't get FAN data! (0x%04x)\n", fan);
5837	free(label);
5838	}
5839
5840	#define PRINT_SMSC47B397_FAN(num, name) \
5841	print_smsc47b397_fan((name), (SENSORS_SMSC47B397_FAN1 + (num)))
5842
5843	void print_smsc47b397(const sensors_chip_name *name)
5844	{
5845	int ii;
5846
5847	for (ii=0;ii<4;ii++)
5848	PRINT_SMSC47B397_TEMP(ii, name);
5849
5850	for (ii=0;ii<4;ii++)
5851	PRINT_SMSC47B397_FAN(ii, name);
5852	}
5853
5854	void print_f71805f(const sensors_chip_name *name)
5855	{
5856	char *label;
5857	double cur, min, max;
5858	int alarms, valid, i;
5859
5860	if (!sensors_get_feature(*name, SENSORS_F71805F_ALARMS_IN, &cur))
5861	alarms = cur + 0.5;
5862	else {
5863	printf("ERROR: Can't get alarms_in data!\n");
5864	alarms = 0;
5865	}
5866
5867	for (i = 0; i < 9; i++) {
5868	if (!sensors_get_label_and_valid(*name, SENSORS_F71805F_IN(i),
5869	&label, &valid)
5870	&& !sensors_get_feature(*name, SENSORS_F71805F_IN(i), &cur)
5871	&& !sensors_get_feature(*name, SENSORS_F71805F_IN_MIN(i), &min)
5872	&& !sensors_get_feature(*name, SENSORS_F71805F_IN_MAX(i), &max)) {
5873	if (valid) {
5874	print_label(label, 10);
5875	printf("%+6.2f V (min = %+6.2f V, max = %+6.2f V) %s\n",
5876	cur, min, max, (alarms & (1 << i)) ? "ALARM" : "");
5877	}
5878	} else
5879	printf("ERROR: Can't get in%d data!\n", i);
5880	free(label);
5881	}
5882
5883	if (!sensors_get_feature(*name, SENSORS_F71805F_ALARMS_FAN, &cur))
5884	alarms = cur + 0.5;
5885	else {
5886	printf("ERROR: Can't get alarms_fan data!\n");
5887	alarms = 0;
5888	}
5889
5890	for (i = 1; i <= 3; i++) {
5891	if (!sensors_get_label_and_valid(*name, SENSORS_F71805F_FAN(i),
5892	&label, &valid)
5893	&& !sensors_get_feature(*name, SENSORS_F71805F_FAN(i), &cur)
5894	&& !sensors_get_feature(*name, SENSORS_F71805F_FAN_MIN(i), &min)) {
5895	if (valid) {
5896	print_label(label, 10);
5897	printf("%4.0f RPM (min = %4.0f RPM) %s\n",
5898	cur, min, (alarms & (1 << (i - 1))) ? "ALARM" : "");
5899	}
5900	} else
5901	printf("ERROR: Can't get fan%d data!\n", i);
5902	free(label);
5903	}
5904
5905	if (!sensors_get_feature(*name, SENSORS_F71805F_ALARMS_TEMP, &cur))
5906	alarms = cur + 0.5;
5907	else {
5908	printf("ERROR: Can't get alarms_temp data!\n");
5909	alarms = 0;
5910	}
5911
5912	for (i = 1; i <= 3; i++) {
5913	if (!sensors_get_label_and_valid(*name, SENSORS_F71805F_TEMP(i),
5914	&label, &valid)
5915	&& !sensors_get_feature(*name, SENSORS_F71805F_TEMP(i), &cur)
5916	&& !sensors_get_feature(*name, SENSORS_F71805F_TEMP_MAX(i), &max)
5917	&& !sensors_get_feature(*name, SENSORS_F71805F_TEMP_HYST(i), &min)) {
5918	if (valid) {
5919	print_label(label, 10);
5920	print_temp_info(cur, max, min, HYST, 0, 0);
5921	printf("%5s", (alarms & (1 << (i - 1))) ? "ALARM" : "");
5922	if (!sensors_get_feature(*name, SENSORS_F71805F_TEMP_TYPE(i), &cur)) {
5923	int sensor = cur + 0.5;
5924	printf(" [%s]", sensor == 3 ? "diode" : "thermistor");
5925	}
5926	printf("\n");
5927	}
5928	} else
5929	printf("ERROR: Can't get temp%d data!\n", i);
5930	free(label);
5931	}
5932	}
5933
5934	void print_unknown_chip(const sensors_chip_name *name)
5935	{
5936	int a,b,valid;
5937	const sensors_feature_data *data;
5938	char *label;
5939	double val;
5940
5941	a=b=0;
5942	while((data=sensors_get_all_features(*name,&a,&b))) {
5943	if (sensors_get_label_and_valid(*name,data->number,&label,&valid)) {
5944	printf("ERROR: Can't get feature `%s' data!\n",data->name);
5945	continue;
5946	}
5947	if (! valid)
5948	continue;
5949	if (data->mode & SENSORS_MODE_R) {
5950	if(sensors_get_feature(*name,data->number,&val)) {
5951	printf("ERROR: Can't get feature `%s' data!\n",data->name);
5952	continue;
5953	}
5954	if (data->mapping != SENSORS_NO_MAPPING)
5955	printf(" %s: %.2f (%s)\n",label,val,data->name);
5956	else
5957	printf("%s: %.2f (%s)\n",label,val,data->name);
5958	} else
5959	printf("(%s)\n",label);
5960	}
5961	}
5962

Note: See TracBrowser for help on using the browser.

Context Navigation

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

Download in other formats: