Changeset 4503

Show
Ignore:
Timestamp:
06/28/07 10:52:37 (6 years ago)
Author:
khali
Message:

Drop all the chip-specific handling and printing code from sensors. The
generic printing code should work now, and what doesn't work, will get
fixed.

Location:
lm-sensors/branches/lm-sensors-3.0.0
Files:
4 modified

Legend:

Unmodified
Added
Removed
  • lm-sensors/branches/lm-sensors-3.0.0/CHANGES

    r4479 r4503  
    3636               Add missing shell declarations 
    3737               Update URI 
    38   Program sensors: Drop ddcmon and eeprom support 
    39                    Add dme1737 support 
     38  Program sensors: Drop all the chip-specific support 
    4039                   Fix alignment of alarm for one-limit temperatures 
    4140  Program sensors-detect: Stop Super-I/O probe after first family success 
  • lm-sensors/branches/lm-sensors-3.0.0/prog/sensors/chips.c

    r4428 r4503  
    2626#include "chips.h" 
    2727#include "lib/sensors.h" 
    28 #include "lib/chips.h" 
    29 #include "lib/error.h" 
    30 #include "kernel/include/sensors.h" 
    3128 
    3229void print_label(const char *label, int space); 
     
    132129}        
    133130 
    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+3*i,&label,&valid) && 
    1377         !sensors_get_feature(*name,SENSORS_ADM1025_TEMP1+3*i,&cur) && 
    1378         !sensors_get_feature(*name,SENSORS_ADM1025_TEMP1_LOW+3*i,&min) && 
    1379         !sensors_get_feature(*name,SENSORS_ADM1025_TEMP1_HIGH+3*i,&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 is1027, is7463, is6d100; 
    1565  
    1566   is1027 = !strcmp(name->prefix,"adm1027") 
    1567            || !strcmp(name->prefix,"adt7463") ; 
    1568   is7463 = !strcmp(name->prefix, "adt7463"); 
    1569   is6d100 = !strcmp(name->prefix,"emc6d100") ; 
    1570  
    1571   if (!sensors_get_feature(*name,SENSORS_LM85_ALARMS,&cur))  
    1572     alarms = cur + 0.5; 
    1573   else { 
    1574     printf("ERROR: Can't get alarm data!\n"); 
    1575     alarms = 0; 
    1576   } 
    1577  
    1578   if (is1027 && 
    1579       !sensors_get_feature(*name, SENSORS_ADM1027_ALARM_MASK, &cur)) { 
    1580     alarm_mask = cur + 0.5; 
    1581   } 
    1582  
    1583   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN0,&label,&valid) && 
    1584       !sensors_get_feature(*name,SENSORS_LM85_IN0,&cur) && 
    1585       !sensors_get_feature(*name,SENSORS_LM85_IN0_MIN,&min) && 
    1586       !sensors_get_feature(*name,SENSORS_LM85_IN0_MAX,&max)) { 
    1587     if (valid) { 
    1588       print_label(label,10); 
    1589       printf("%+7.*f V  (min = %+6.2f V, max = %+6.2f V)   %s", 
    1590            (is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN0?"ALARM":""); 
    1591       if (is1027) { printf(alarm_mask&LM85_ALARM_IN0?" MASKED":""); } 
    1592       putchar( '\n' ); 
    1593     } 
    1594   } else 
    1595     printf("ERROR: Can't get IN0 data!\n"); 
    1596   free(label); 
    1597   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN1,&label,&valid) && 
    1598       !sensors_get_feature(*name,SENSORS_LM85_IN1,&cur) && 
    1599       !sensors_get_feature(*name,SENSORS_LM85_IN1_MIN,&min) && 
    1600       !sensors_get_feature(*name,SENSORS_LM85_IN1_MAX,&max)) { 
    1601     if (valid) { 
    1602       print_label(label,10); 
    1603       printf("%+7.*f V  (min = %+6.2f V, max = %+6.2f V)   %s", 
    1604            (is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN1?"ALARM":""); 
    1605       if (is1027) { printf(alarm_mask&LM85_ALARM_IN1?" MASKED":""); } 
    1606       putchar( '\n' ); 
    1607     } 
    1608   } else 
    1609     printf("ERROR: Can't get IN1 data!\n"); 
    1610   free(label); 
    1611   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN2,&label,&valid) && 
    1612       !sensors_get_feature(*name,SENSORS_LM85_IN2,&cur) && 
    1613       !sensors_get_feature(*name,SENSORS_LM85_IN2_MIN,&min) && 
    1614       !sensors_get_feature(*name,SENSORS_LM85_IN2_MAX,&max)) { 
    1615     if (valid) { 
    1616       print_label(label,10); 
    1617       printf("%+7.*f V  (min = %+6.2f V, max = %+6.2f V)   %s", 
    1618            (is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN2?"ALARM":""); 
    1619       if (is1027) { printf(alarm_mask&LM85_ALARM_IN2?" MASKED":""); } 
    1620       putchar( '\n' ); 
    1621     } 
    1622   } else 
    1623     printf("ERROR: Can't get IN2 data!\n"); 
    1624   free(label); 
    1625   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN3,&label,&valid) && 
    1626       !sensors_get_feature(*name,SENSORS_LM85_IN3,&cur) && 
    1627       !sensors_get_feature(*name,SENSORS_LM85_IN3_MIN,&min) && 
    1628       !sensors_get_feature(*name,SENSORS_LM85_IN3_MAX,&max)) { 
    1629     if (valid) { 
    1630       print_label(label,10); 
    1631       printf("%+7.*f V  (min = %+6.2f V, max = %+6.2f V)   %s", 
    1632            (is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN3?"ALARM":""); 
    1633       if (is1027) { printf(alarm_mask&LM85_ALARM_IN3?" MASKED":""); } 
    1634       putchar( '\n' ); 
    1635     } 
    1636   } else 
    1637     printf("ERROR: Can't get IN3 data!\n"); 
    1638   free(label); 
    1639   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN4,&label,&valid) && 
    1640       !sensors_get_feature(*name,SENSORS_LM85_IN4,&cur) && 
    1641       !sensors_get_feature(*name,SENSORS_LM85_IN4_MIN,&min) && 
    1642       !sensors_get_feature(*name,SENSORS_LM85_IN4_MAX,&max)) { 
    1643     if (valid) { 
    1644       print_label(label,10); 
    1645       printf("%+7.*f V  (min = %+6.2f V, max = %+6.2f V)   %s", 
    1646            (is1027?3:2),cur,min,max,alarms&LM85_ALARM_IN4?"ALARM":""); 
    1647       if (is1027) { printf(alarm_mask&LM85_ALARM_IN4?" MASKED":""); } 
    1648       putchar( '\n' ); 
    1649     } 
    1650   } else if (!is7463) 
    1651     printf("ERROR: Can't get IN4 data!\n"); 
    1652   free(label); 
    1653  
    1654   if( is6d100 ) { 
    1655     if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN5,&label,&valid) && 
    1656         !sensors_get_feature(*name,SENSORS_LM85_IN5,&cur) && 
    1657         !sensors_get_feature(*name,SENSORS_LM85_IN5_MIN,&min) && 
    1658         !sensors_get_feature(*name,SENSORS_LM85_IN5_MAX,&max)) { 
    1659       if (valid) { 
    1660         print_label(label,10); 
    1661         printf("%+7.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1662              cur,min,max,alarms&LM85_ALARM_IN5?"ALARM":""); 
    1663       } 
    1664     } else 
    1665       printf("ERROR: Can't get IN5 data!\n"); 
    1666     free(label); 
    1667     if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN6,&label,&valid) && 
    1668         !sensors_get_feature(*name,SENSORS_LM85_IN6,&cur) && 
    1669         !sensors_get_feature(*name,SENSORS_LM85_IN6_MIN,&min) && 
    1670         !sensors_get_feature(*name,SENSORS_LM85_IN6_MAX,&max)) { 
    1671       if (valid) { 
    1672         print_label(label,10); 
    1673         printf("%+7.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1674              cur,min,max,alarms&LM85_ALARM_IN6?"ALARM":""); 
    1675       } 
    1676     } else 
    1677       printf("ERROR: Can't get IN6 data!\n"); 
    1678     free(label); 
    1679     if (!sensors_get_label_and_valid(*name,SENSORS_LM85_IN7,&label,&valid) && 
    1680         !sensors_get_feature(*name,SENSORS_LM85_IN7,&cur) && 
    1681         !sensors_get_feature(*name,SENSORS_LM85_IN7_MIN,&min) && 
    1682         !sensors_get_feature(*name,SENSORS_LM85_IN7_MAX,&max)) { 
    1683       if (valid) { 
    1684         print_label(label,10); 
    1685         printf("%+7.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1686              cur,min,max,alarms&LM85_ALARM_IN7?"ALARM":""); 
    1687       } 
    1688     } else 
    1689       printf("ERROR: Can't get IN7 data!\n"); 
    1690     free(label); 
    1691   } 
    1692  
    1693   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN1,&label,&valid) && 
    1694       !sensors_get_feature(*name,SENSORS_LM85_FAN1,&cur) && 
    1695       !sensors_get_feature(*name,SENSORS_LM85_FAN1_MIN,&min)) { 
    1696     if (valid) { 
    1697       print_label(label,10); 
    1698       printf("%5.0f RPM  (min = %4.0f RPM)                     %s", 
    1699            cur,min, alarms&LM85_ALARM_FAN1?"ALARM":""); 
    1700       if (is1027) { printf(alarm_mask&LM85_ALARM_FAN1?" MASKED":""); } 
    1701       putchar( '\n' ); 
    1702     } 
    1703   } else 
    1704     printf("ERROR: Can't get FAN1 data!\n"); 
    1705   free(label); 
    1706   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN2,&label,&valid) && 
    1707       !sensors_get_feature(*name,SENSORS_LM85_FAN2,&cur) && 
    1708       !sensors_get_feature(*name,SENSORS_LM85_FAN2_MIN,&min)) { 
    1709     if (valid) { 
    1710       print_label(label,10); 
    1711       printf("%5.0f RPM  (min = %4.0f RPM)                     %s", 
    1712            cur,min, alarms&LM85_ALARM_FAN2?"ALARM":""); 
    1713       if (is1027) { printf(alarm_mask&LM85_ALARM_FAN2?" MASKED":""); } 
    1714       putchar( '\n' ); 
    1715     } 
    1716   } else 
    1717     printf("ERROR: Can't get FAN2 data!\n"); 
    1718   free(label); 
    1719   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN3,&label,&valid) && 
    1720       !sensors_get_feature(*name,SENSORS_LM85_FAN3,&cur) && 
    1721       !sensors_get_feature(*name,SENSORS_LM85_FAN3_MIN,&min)) { 
    1722     if (valid) { 
    1723       print_label(label,10); 
    1724       printf("%5.0f RPM  (min = %4.0f RPM)                     %s", 
    1725            cur,min, alarms&LM85_ALARM_FAN3?"ALARM":""); 
    1726       if (is1027) { printf(alarm_mask&LM85_ALARM_FAN3?" MASKED":""); } 
    1727       putchar( '\n' ); 
    1728     } 
    1729   } else 
    1730     printf("ERROR: Can't get FAN3 data!\n"); 
    1731   free(label); 
    1732   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_FAN4,&label,&valid) && 
    1733       !sensors_get_feature(*name,SENSORS_LM85_FAN4,&cur) && 
    1734       !sensors_get_feature(*name,SENSORS_LM85_FAN4_MIN,&min)) { 
    1735     if (valid) { 
    1736       print_label(label,10); 
    1737       printf("%5.0f RPM  (min = %4.0f RPM)                     %s", 
    1738            cur,min, alarms&LM85_ALARM_FAN4?"ALARM":""); 
    1739       if (is1027) { printf(alarm_mask&LM85_ALARM_FAN4?" MASKED":""); } 
    1740       putchar( '\n' ); 
    1741     } 
    1742   } else 
    1743     printf("ERROR: Can't get FAN4 data!\n"); 
    1744   free(label); 
    1745  
    1746   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_TEMP1,&label,&valid) && 
    1747       !sensors_get_feature(*name,SENSORS_LM85_TEMP1,&cur) && 
    1748       !sensors_get_feature(*name,SENSORS_LM85_TEMP1_MIN,&min) && 
    1749       !sensors_get_feature(*name,SENSORS_LM85_TEMP1_MAX,&max)) { 
    1750     if (valid) { 
    1751       print_label(label,10); 
    1752       print_temp_info( cur, max, min, MINMAX, (is1027 ? 2 : 0), 0); 
    1753       printf( "   %s %s %s\n", 
    1754                  alarms&LM85_ALARM_TEMP1?"ALARM":"", 
    1755                  alarms&LM85_ALARM_TEMP1_FAULT?"FAULT":"", 
    1756                  is1027&&(alarm_mask&LM85_ALARM_TEMP1)?"MASKED":"" 
    1757             ); 
    1758     } 
    1759   } else 
    1760     printf("ERROR: Can't get TEMP1 data!\n"); 
    1761   free(label); 
    1762   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_TEMP2,&label,&valid) && 
    1763       !sensors_get_feature(*name,SENSORS_LM85_TEMP2,&cur) && 
    1764       !sensors_get_feature(*name,SENSORS_LM85_TEMP2_MIN,&min) && 
    1765       !sensors_get_feature(*name,SENSORS_LM85_TEMP2_MAX,&max)) { 
    1766     if (valid) { 
    1767       print_label(label,10); 
    1768       print_temp_info( cur, max, min, MINMAX, (is1027 ? 2 : 0), 0); 
    1769       printf( "   %s %s\n", 
    1770                  alarms&LM85_ALARM_TEMP2?"ALARM":"", 
    1771                  is1027&&(alarm_mask&LM85_ALARM_TEMP2)?"MASKED":"" 
    1772             ); 
    1773     } 
    1774   } else 
    1775     printf("ERROR: Can't get TEMP2 data!\n"); 
    1776   free(label); 
    1777   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_TEMP3,&label,&valid) && 
    1778       !sensors_get_feature(*name,SENSORS_LM85_TEMP3,&cur) && 
    1779       !sensors_get_feature(*name,SENSORS_LM85_TEMP3_MIN,&min) && 
    1780       !sensors_get_feature(*name,SENSORS_LM85_TEMP3_MAX,&max)) { 
    1781     if (valid) { 
    1782       print_label(label,10); 
    1783       print_temp_info( cur, max, min, MINMAX, (is1027 ? 2 : 0), 0); 
    1784       printf( "   %s %s %s\n", 
    1785                  alarms&LM85_ALARM_TEMP3?"ALARM":"", 
    1786                  alarms&LM85_ALARM_TEMP3_FAULT?"FAULT":"", 
    1787                  is1027&&(alarm_mask&LM85_ALARM_TEMP3)?"MASKED":"" 
    1788             ); 
    1789     } 
    1790   } else 
    1791     printf("ERROR: Can't get TEMP3 data!\n"); 
    1792   free(label); 
    1793  
    1794   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_PWM1,&label,&valid) && 
    1795       !sensors_get_feature(*name,SENSORS_LM85_PWM1,&cur)) { 
    1796     if (valid) { 
    1797       print_label(label,10); 
    1798       printf("%4.0f\n", cur); 
    1799     } 
    1800   } else 
    1801     printf("ERROR: Can't get PWM1 data!\n"); 
    1802   free(label); 
    1803   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_PWM2,&label,&valid) && 
    1804       !sensors_get_feature(*name,SENSORS_LM85_PWM2,&cur)) { 
    1805     if (valid) { 
    1806       print_label(label,10); 
    1807       printf("%4.0f\n", cur); 
    1808     } 
    1809   } else 
    1810     printf("ERROR: Can't get PWM2 data!\n"); 
    1811   free(label); 
    1812   if (!sensors_get_label_and_valid(*name,SENSORS_LM85_PWM3,&label,&valid) && 
    1813       !sensors_get_feature(*name,SENSORS_LM85_PWM3,&cur)) { 
    1814     if (valid) { 
    1815       print_label(label,10); 
    1816       printf("%4.0f\n", cur); 
    1817     } 
    1818   } else 
    1819     printf("ERROR: Can't get PWM3 data!\n"); 
    1820   free(label); 
    1821  
    1822   print_vid_info(name, SENSORS_LM85_VID, SENSORS_LM85_VRM); 
    1823 } 
    1824  
    1825 void print_lm87(const sensors_chip_name *name) 
    1826 { 
    1827   char *label; 
    1828   double cur,min,max,fdiv; 
    1829   int alarms,valid; 
    1830  
    1831   if (!sensors_get_feature(*name,SENSORS_LM87_ALARMS,&cur)) 
    1832     alarms = cur + 0.5; 
    1833   else { 
    1834     printf("ERROR: Can't get alarm data!\n"); 
    1835     alarms = 0; 
    1836   } 
    1837  
    1838  
    1839   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN0,&label,&valid) && 
    1840       !sensors_get_feature(*name,SENSORS_LM87_IN0,&cur) && 
    1841       !sensors_get_feature(*name,SENSORS_LM87_IN0_MIN,&min) && 
    1842       !sensors_get_feature(*name,SENSORS_LM87_IN0_MAX,&max)) { 
    1843     if (valid) { 
    1844       print_label(label,10); 
    1845       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1846              cur,min,max,alarms&LM87_ALARM_IN0?"ALARM":""); 
    1847     } 
    1848   } 
    1849   free(label); 
    1850   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN1,&label,&valid) && 
    1851       !sensors_get_feature(*name,SENSORS_LM87_IN1,&cur) && 
    1852       !sensors_get_feature(*name,SENSORS_LM87_IN1_MIN,&min) && 
    1853       !sensors_get_feature(*name,SENSORS_LM87_IN1_MAX,&max)) { 
    1854     if (valid) { 
    1855       print_label(label,10); 
    1856       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1857              cur,min,max,alarms&LM87_ALARM_IN1?"ALARM":""); 
    1858     } 
    1859   } else 
    1860     printf("ERROR: Can't get IN1 data!\n"); 
    1861   free(label); 
    1862   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN2,&label,&valid) && 
    1863       !sensors_get_feature(*name,SENSORS_LM87_IN2,&cur) && 
    1864       !sensors_get_feature(*name,SENSORS_LM87_IN2_MIN,&min) && 
    1865       !sensors_get_feature(*name,SENSORS_LM87_IN2_MAX,&max)) { 
    1866     if (valid) { 
    1867       print_label(label,10); 
    1868       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1869              cur,min,max,alarms&LM87_ALARM_IN2?"ALARM":""); 
    1870     } 
    1871   } 
    1872   free(label); 
    1873   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN3,&label,&valid) && 
    1874       !sensors_get_feature(*name,SENSORS_LM87_IN3,&cur) && 
    1875       !sensors_get_feature(*name,SENSORS_LM87_IN3_MIN,&min) && 
    1876       !sensors_get_feature(*name,SENSORS_LM87_IN3_MAX,&max)) { 
    1877     if (valid) { 
    1878       print_label(label,10); 
    1879       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1880              cur,min,max,alarms&LM87_ALARM_IN3?"ALARM":""); 
    1881     } 
    1882   } else 
    1883     printf("ERROR: Can't get IN3 data!\n"); 
    1884   free(label); 
    1885   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN4,&label,&valid) && 
    1886       !sensors_get_feature(*name,SENSORS_LM87_IN4,&cur) && 
    1887       !sensors_get_feature(*name,SENSORS_LM87_IN4_MIN,&min) && 
    1888       !sensors_get_feature(*name,SENSORS_LM87_IN4_MAX,&max)) { 
    1889     if (valid) { 
    1890       print_label(label,10); 
    1891       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1892              cur,min,max,alarms&LM87_ALARM_IN4?"ALARM":""); 
    1893     } 
    1894   } else 
    1895     printf("ERROR: Can't get IN4 data!\n"); 
    1896   free(label); 
    1897   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_IN5,&label,&valid) && 
    1898       !sensors_get_feature(*name,SENSORS_LM87_IN5,&cur) && 
    1899       !sensors_get_feature(*name,SENSORS_LM87_IN5_MIN,&min) && 
    1900       !sensors_get_feature(*name,SENSORS_LM87_IN5_MAX,&max)) { 
    1901     if (valid) { 
    1902       print_label(label,10); 
    1903       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1904              cur,min,max,alarms&LM87_ALARM_IN5?"ALARM":""); 
    1905     } 
    1906   } 
    1907   free(label); 
    1908   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_AIN1,&label,&valid) && 
    1909       !sensors_get_feature(*name,SENSORS_LM87_AIN1,&cur) && 
    1910       !sensors_get_feature(*name,SENSORS_LM87_AIN1_MIN,&min) && 
    1911       !sensors_get_feature(*name,SENSORS_LM87_AIN1_MAX,&max)) { 
    1912     if (valid) { 
    1913       print_label(label,10); 
    1914       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1915              cur,min,max,alarms&LM87_ALARM_FAN1?"ALARM":""); 
    1916     } 
    1917   } 
    1918   free(label); 
    1919   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_AIN2,&label,&valid) && 
    1920       !sensors_get_feature(*name,SENSORS_LM87_AIN2,&cur) && 
    1921       !sensors_get_feature(*name,SENSORS_LM87_AIN2_MIN,&min) && 
    1922       !sensors_get_feature(*name,SENSORS_LM87_AIN2_MAX,&max)) { 
    1923     if (valid) { 
    1924       print_label(label,10); 
    1925       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    1926              cur,min,max,alarms&LM87_ALARM_FAN2?"ALARM":""); 
    1927     } 
    1928   } 
    1929   free(label); 
    1930  
    1931   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_FAN1,&label,&valid) && 
    1932       !sensors_get_feature(*name,SENSORS_LM87_FAN1,&cur) && 
    1933       !sensors_get_feature(*name,SENSORS_LM87_FAN1_DIV,&fdiv) && 
    1934       !sensors_get_feature(*name,SENSORS_LM87_FAN1_MIN,&min)) { 
    1935     if (valid) { 
    1936       print_label(label,10); 
    1937       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    1938              cur,min,fdiv, alarms&LM87_ALARM_FAN1?"ALARM":""); 
    1939     } 
    1940   } 
    1941   free(label); 
    1942   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_FAN2,&label,&valid) && 
    1943       !sensors_get_feature(*name,SENSORS_LM87_FAN2,&cur) && 
    1944       !sensors_get_feature(*name,SENSORS_LM87_FAN2_DIV,&fdiv) && 
    1945       !sensors_get_feature(*name,SENSORS_LM87_FAN2_MIN,&min)) { 
    1946     if (valid) { 
    1947       print_label(label,10); 
    1948       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    1949              cur,min,fdiv, alarms&LM87_ALARM_FAN2 ?"ALARM":""); 
    1950     } 
    1951   } 
    1952   free(label); 
    1953  
    1954   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP1,&label,&valid) && 
    1955       !sensors_get_feature(*name,SENSORS_LM87_TEMP1,&cur) && 
    1956       !sensors_get_feature(*name,SENSORS_LM87_TEMP1_HYST,&min) && 
    1957       !sensors_get_feature(*name,SENSORS_LM87_TEMP1_OVER,&max)) { 
    1958     if (valid) { 
    1959       print_label(label,10); 
    1960       print_temp_info( cur, max, min, MINMAX, 0, 0); 
    1961       printf(" %s%s\n", alarms&LM87_ALARM_TEMP1?"ALARM":"", 
    1962         alarms&LM87_ALARM_THERM_SIG?" THERM#":""); 
    1963     } 
    1964   } else 
    1965     printf("ERROR: Can't get TEMP1 data!\n"); 
    1966   free(label); 
    1967  
    1968   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP2,&label,&valid) && 
    1969       !sensors_get_feature(*name,SENSORS_LM87_TEMP2,&cur) && 
    1970       !sensors_get_feature(*name,SENSORS_LM87_TEMP2_HYST,&min) && 
    1971       !sensors_get_feature(*name,SENSORS_LM87_TEMP2_OVER,&max)) { 
    1972     if (valid) { 
    1973       print_label(label,10); 
    1974       print_temp_info( cur, max, min, MINMAX, 0, 0); 
    1975       printf(" %s%s\n", alarms&LM87_ALARM_TEMP2?"ALARM":"", 
    1976         alarms&LM87_ALARM_TEMP2_FAULT?" FAULT":""); 
    1977     } 
    1978   } else 
    1979     printf("ERROR: Can't get TEMP2 data!\n"); 
    1980   free(label); 
    1981  
    1982   if (!sensors_get_label_and_valid(*name,SENSORS_LM87_TEMP3,&label,&valid) && 
    1983       !sensors_get_feature(*name,SENSORS_LM87_TEMP3,&cur) && 
    1984       !sensors_get_feature(*name,SENSORS_LM87_TEMP3_HYST,&min) && 
    1985       !sensors_get_feature(*name,SENSORS_LM87_TEMP3_OVER,&max)) { 
    1986     if (valid) { 
    1987       print_label(label,10); 
    1988       print_temp_info( cur, max, min, MINMAX, 0, 0); 
    1989       printf(" %s%s\n", alarms&LM87_ALARM_TEMP3?"ALARM":"", 
    1990         alarms&LM87_ALARM_TEMP3_FAULT?" FAULT":""); 
    1991     } 
    1992   } 
    1993   free(label); 
    1994  
    1995   print_vid_info(name, SENSORS_LM87_VID, SENSORS_LM87_VRM); 
    1996 } 
    1997  
    1998 void print_mtp008(const sensors_chip_name *name) 
    1999 { 
    2000   char *label; 
    2001   double cur,min,max,fdiv; 
    2002   int alarms,valid; 
    2003  
    2004   if (!sensors_get_feature(*name,SENSORS_MTP008_ALARMS,&cur)) 
    2005     alarms = cur + 0.5; 
    2006   else { 
    2007     printf("ERROR: Can't get alarm data!\n"); 
    2008     alarms = 0; 
    2009   } 
    2010  
    2011  
    2012   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN0,&label,&valid) && 
    2013       !sensors_get_feature(*name,SENSORS_MTP008_IN0,&cur) && 
    2014       !sensors_get_feature(*name,SENSORS_MTP008_IN0_MIN,&min) && 
    2015       !sensors_get_feature(*name,SENSORS_MTP008_IN0_MAX,&max)) { 
    2016     if (valid) { 
    2017       print_label(label,10); 
    2018       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    2019              cur,min,max,alarms&MTP008_ALARM_IN0?"ALARM":""); 
    2020     } 
    2021   } else 
    2022     printf("ERROR: Can't get IN0 data!\n"); 
    2023   free(label); 
    2024   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN1,&label,&valid) && 
    2025       !sensors_get_feature(*name,SENSORS_MTP008_IN1,&cur) && 
    2026       !sensors_get_feature(*name,SENSORS_MTP008_IN1_MIN,&min) && 
    2027       !sensors_get_feature(*name,SENSORS_MTP008_IN1_MAX,&max)) { 
    2028     if (valid) { 
    2029       print_label(label,10); 
    2030       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    2031              cur,min,max,alarms&MTP008_ALARM_IN1?"ALARM":""); 
    2032     } 
    2033   } else 
    2034     printf("ERROR: Can't get IN1 data!\n"); 
    2035   free(label); 
    2036   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN2,&label,&valid) && 
    2037       !sensors_get_feature(*name,SENSORS_MTP008_IN2,&cur) && 
    2038       !sensors_get_feature(*name,SENSORS_MTP008_IN2_MIN,&min) && 
    2039       !sensors_get_feature(*name,SENSORS_MTP008_IN2_MAX,&max)) { 
    2040     if (valid) { 
    2041       print_label(label,10); 
    2042       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    2043              cur,min,max,alarms&MTP008_ALARM_IN2?"ALARM":""); 
    2044     } 
    2045   } else 
    2046     printf("ERROR: Can't get IN2 data!\n"); 
    2047   free(label); 
    2048   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN3,&label,&valid) && 
    2049       !sensors_get_feature(*name,SENSORS_MTP008_IN3,&cur) && 
    2050       !sensors_get_feature(*name,SENSORS_MTP008_IN3_MIN,&min) && 
    2051       !sensors_get_feature(*name,SENSORS_MTP008_IN3_MAX,&max)) { 
    2052     if (valid) { 
    2053       print_label(label,10); 
    2054       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    2055              cur,min,max,alarms&MTP008_ALARM_IN3?"ALARM":""); 
    2056     } 
    2057   } else 
    2058     printf("ERROR: Can't get IN3 data!\n"); 
    2059   free(label); 
    2060   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN4,&label,&valid) && 
    2061       !sensors_get_feature(*name,SENSORS_MTP008_IN4,&cur) && 
    2062       !sensors_get_feature(*name,SENSORS_MTP008_IN4_MIN,&min) && 
    2063       !sensors_get_feature(*name,SENSORS_MTP008_IN4_MAX,&max)) { 
    2064     if (valid) { 
    2065       print_label(label,10); 
    2066       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    2067              cur,min,max,alarms&MTP008_ALARM_IN4?"ALARM":""); 
    2068     } 
    2069   } else 
    2070     printf("ERROR: Can't get IN4 data!\n"); 
    2071   free(label); 
    2072   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN5,&label,&valid) && 
    2073       !sensors_get_feature(*name,SENSORS_MTP008_IN5,&cur) && 
    2074       !sensors_get_feature(*name,SENSORS_MTP008_IN5_MIN,&min) && 
    2075       !sensors_get_feature(*name,SENSORS_MTP008_IN5_MAX,&max)) { 
    2076     if (valid) { 
    2077       print_label(label,10); 
    2078       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    2079              cur,min,max,alarms&MTP008_ALARM_IN5?"ALARM":""); 
    2080     } 
    2081   } else 
    2082     printf("ERROR: Can't get IN5 data!\n"); 
    2083   free(label); 
    2084   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_IN6,&label,&valid) && 
    2085       !sensors_get_feature(*name,SENSORS_MTP008_IN6,&cur) && 
    2086       !sensors_get_feature(*name,SENSORS_MTP008_IN6_MIN,&min) && 
    2087       !sensors_get_feature(*name,SENSORS_MTP008_IN6_MAX,&max)) { 
    2088     if (valid) { 
    2089       print_label(label,10); 
    2090       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    2091              cur,min,max,alarms&MTP008_ALARM_IN6?"ALARM":""); 
    2092     } 
    2093   } else 
    2094     printf("ERROR: Can't get IN6 data!\n"); 
    2095   free(label); 
    2096  
    2097   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN1,&label,&valid) && 
    2098       !sensors_get_feature(*name,SENSORS_MTP008_FAN1,&cur) && 
    2099       !sensors_get_feature(*name,SENSORS_MTP008_FAN1_DIV,&fdiv) && 
    2100       !sensors_get_feature(*name,SENSORS_MTP008_FAN1_MIN,&min)) { 
    2101     if (valid) { 
    2102       print_label(label,10); 
    2103       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    2104              cur,min,fdiv, alarms&MTP008_ALARM_FAN1?"ALARM":""); 
    2105     } 
    2106   } else 
    2107     printf("ERROR: Can't get FAN1 data!\n"); 
    2108   free(label); 
    2109   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN2,&label,&valid) && 
    2110       !sensors_get_feature(*name,SENSORS_MTP008_FAN2,&cur) && 
    2111       !sensors_get_feature(*name,SENSORS_MTP008_FAN2_DIV,&fdiv) && 
    2112       !sensors_get_feature(*name,SENSORS_MTP008_FAN2_MIN,&min)) { 
    2113     if (valid) { 
    2114       print_label(label,10); 
    2115       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    2116              cur,min,fdiv, alarms&MTP008_ALARM_FAN2?"ALARM":""); 
    2117     } 
    2118   } else 
    2119     printf("ERROR: Can't get FAN2 data!\n"); 
    2120   free(label); 
    2121   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_FAN3,&label,&valid) && 
    2122       !sensors_get_feature(*name,SENSORS_MTP008_FAN3,&cur) && 
    2123       !sensors_get_feature(*name,SENSORS_MTP008_FAN3_DIV,&fdiv) && 
    2124       !sensors_get_feature(*name,SENSORS_MTP008_FAN3_MIN,&min)) { 
    2125     if (valid) { 
    2126       print_label(label,10); 
    2127       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    2128              cur,min,fdiv, alarms&MTP008_ALARM_FAN3?"ALARM":""); 
    2129     } 
    2130   } else 
    2131     printf("ERROR: Can't get FAN3 data!\n"); 
    2132   free(label); 
    2133  
    2134   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP1,&label,&valid) && 
    2135       !sensors_get_feature(*name,SENSORS_MTP008_TEMP1,&cur) && 
    2136       !sensors_get_feature(*name,SENSORS_MTP008_TEMP1_HYST,&min) && 
    2137       !sensors_get_feature(*name,SENSORS_MTP008_TEMP1_OVER,&max)) { 
    2138     if (valid) { 
    2139       print_label(label,10); 
    2140       print_temp_info( cur, max, min, HYST, 0, 0); 
    2141       printf(" %s\n", alarms&MTP008_ALARM_TEMP1?"ALARM":""); 
    2142     } 
    2143   } else 
    2144     printf("ERROR: Can't get TEMP1 data!\n"); 
    2145   free(label); 
    2146  
    2147   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP2,&label,&valid) && 
    2148       !sensors_get_feature(*name,SENSORS_MTP008_TEMP2,&cur) && 
    2149       !sensors_get_feature(*name,SENSORS_MTP008_TEMP2_HYST,&min) && 
    2150       !sensors_get_feature(*name,SENSORS_MTP008_TEMP2_OVER,&max)) { 
    2151     if (valid) { 
    2152       print_label(label,10); 
    2153       print_temp_info( cur, max, min, HYST, 0, 0); 
    2154       printf(" %s\n", alarms&MTP008_ALARM_TEMP2?"ALARM":""); 
    2155     } 
    2156   } else 
    2157     printf("ERROR: Can't get TEMP2 data!\n"); 
    2158   free(label); 
    2159  
    2160   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP3,&label,&valid) && 
    2161       !sensors_get_feature(*name,SENSORS_MTP008_TEMP3,&cur) && 
    2162       !sensors_get_feature(*name,SENSORS_MTP008_TEMP3_HYST,&min) && 
    2163       !sensors_get_feature(*name,SENSORS_MTP008_TEMP3_OVER,&max)) { 
    2164     if (valid) { 
    2165       print_label(label,10); 
    2166       print_temp_info( cur, max, min, HYST, 0, 0); 
    2167       printf(" %s\n", alarms&MTP008_ALARM_TEMP3?"ALARM":""); 
    2168     } 
    2169   } else 
    2170     printf("ERROR: Can't get TEMP3 data!\n"); 
    2171   free(label); 
    2172  
    2173   if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_VID,&label,&valid) && 
    2174       !sensors_get_feature(*name,SENSORS_MTP008_VID,&cur)) { 
    2175     if (valid) { 
    2176       print_label(label,10); 
    2177       printf("%+6.2f V\n",cur); 
    2178     } 
    2179   } 
    2180   free(label); 
    2181 } 
    2182  
    2183 void print_w83781d(const sensors_chip_name *name) 
    2184 { 
    2185   char *label; 
    2186   double cur,min,max,fdiv,sens; 
    2187   int alarms,beeps; 
    2188   int beep_mask; 
    2189   int is81d, is82d, is83s, is91d, is697hf, is627thf, valid; 
    2190  
    2191   is81d = !strcmp(name->prefix,"w83781d"); 
    2192   is82d = (!strcmp(name->prefix,"w83782d")) || 
    2193           (!strcmp(name->prefix,"w83627hf")) || 
    2194           (!strcmp(name->prefix,"w83637hf")) || 
    2195           (!strcmp(name->prefix, "w83627thf")) || 
    2196           (!strcmp(name->prefix, "w83687thf")); 
    2197   is83s = !strcmp(name->prefix,"w83783s"); 
    2198   is91d = !strcmp(name->prefix,"w83791d"); 
    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         /* for the w83791d, beep mask is different than the alarm mask */ 
    2238         if (is91d) 
    2239           beep_mask = W83791D_BEEP_IN1; 
    2240         else 
    2241           beep_mask = W83781D_ALARM_IN1; 
    2242  
    2243         print_label(label,10); 
    2244         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2245              cur,min,max,alarms&W83781D_ALARM_IN1?"ALARM":"     ", 
    2246              beeps&beep_mask?"(beep)":""); 
    2247       } 
    2248     } else 
    2249       printf("ERROR: Can't get IN1 data!\n"); 
    2250     free(label); 
    2251   } 
    2252   if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN2,&label,&valid) && 
    2253       !sensors_get_feature(*name,SENSORS_W83781D_IN2,&cur) && 
    2254       !sensors_get_feature(*name,SENSORS_W83781D_IN2_MIN,&min) && 
    2255       !sensors_get_feature(*name,SENSORS_W83781D_IN2_MAX,&max)) { 
    2256     if (valid) { 
    2257       print_label(label,10); 
    2258       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2259            cur,min,max,alarms&W83781D_ALARM_IN2?"ALARM":"     ", 
    2260            beeps&W83781D_ALARM_IN2?"(beep)":""); 
    2261     } 
    2262   } else 
    2263     printf("ERROR: Can't get IN2 data!\n"); 
    2264   free(label); 
    2265   if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN3,&label,&valid) && 
    2266       !sensors_get_feature(*name,SENSORS_W83781D_IN3,&cur) && 
    2267       !sensors_get_feature(*name,SENSORS_W83781D_IN3_MIN,&min) && 
    2268       !sensors_get_feature(*name,SENSORS_W83781D_IN3_MAX,&max)) { 
    2269     if (valid) { 
    2270       print_label(label,10); 
    2271       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2272            cur,min,max,alarms&W83781D_ALARM_IN3?"ALARM":"     ", 
    2273            beeps&W83781D_ALARM_IN3?"(beep)":""); 
    2274     } 
    2275   } else 
    2276     printf("ERROR: Can't get IN3 data!\n"); 
    2277   free(label); 
    2278   if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN4,&label,&valid) && 
    2279       !sensors_get_feature(*name,SENSORS_W83781D_IN4,&cur) && 
    2280       !sensors_get_feature(*name,SENSORS_W83781D_IN4_MIN,&min) && 
    2281       !sensors_get_feature(*name,SENSORS_W83781D_IN4_MAX,&max)) { 
    2282     if (valid) { 
    2283       print_label(label,10); 
    2284       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2285            cur,min,max,alarms&W83781D_ALARM_IN4?"ALARM":"     ", 
    2286            beeps&W83781D_ALARM_IN4?"(beep)":""); 
    2287     } 
    2288   } else 
    2289     printf("ERROR: Can't get IN4 data!\n"); 
    2290   free(label); 
    2291   if (!is627thf) { 
    2292     if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN5,&label,&valid) && 
    2293         !sensors_get_feature(*name,SENSORS_W83781D_IN5,&cur) && 
    2294         !sensors_get_feature(*name,SENSORS_W83781D_IN5_MIN,&min) && 
    2295         !sensors_get_feature(*name,SENSORS_W83781D_IN5_MAX,&max)) { 
    2296       if (valid) { 
    2297         print_label(label,10); 
    2298         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2299              cur,min,max,alarms&W83781D_ALARM_IN5?"ALARM":"     ", 
    2300              beeps&W83781D_ALARM_IN5?"(beep)":""); 
    2301       } 
    2302     } else 
    2303       printf("ERROR: Can't get IN5 data!\n"); 
    2304     free(label); 
    2305     if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_IN6,&label,&valid) && 
    2306         !sensors_get_feature(*name,SENSORS_W83781D_IN6,&cur) && 
    2307         !sensors_get_feature(*name,SENSORS_W83781D_IN6_MIN,&min) && 
    2308         !sensors_get_feature(*name,SENSORS_W83781D_IN6_MAX,&max)) { 
    2309       if (valid) { 
    2310         print_label(label,10); 
    2311         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2312              cur,min,max,alarms&W83781D_ALARM_IN6?"ALARM":"     ", 
    2313              beeps&W83781D_ALARM_IN6?"(beep)":""); 
    2314       } 
    2315     } else 
    2316       printf("ERROR: Can't get IN6 data!\n"); 
    2317     free(label); 
    2318   } /* !is627thf */ 
    2319   if (is82d || is697hf || is627thf) { 
    2320     if (!sensors_get_label_and_valid(*name,SENSORS_W83782D_IN7,&label,&valid) && 
    2321         !sensors_get_feature(*name,SENSORS_W83782D_IN7,&cur) && 
    2322         !sensors_get_feature(*name,SENSORS_W83782D_IN7_MIN,&min) && 
    2323         !sensors_get_feature(*name,SENSORS_W83782D_IN7_MAX,&max)) { 
    2324       if (valid) { 
    2325         print_label(label,10); 
    2326         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2327              cur,min,max,alarms&W83782D_ALARM_IN7?"ALARM":"     ", 
    2328              beeps&W83782D_ALARM_IN7?"(beep)":""); 
    2329       } 
    2330     } else 
    2331       printf("ERROR: Can't get IN7 data!\n"); 
    2332     free(label); 
    2333     if (!sensors_get_label_and_valid(*name,SENSORS_W83782D_IN8,&label,&valid) && 
    2334         !sensors_get_feature(*name,SENSORS_W83782D_IN8,&cur) && 
    2335         !sensors_get_feature(*name,SENSORS_W83782D_IN8_MIN,&min) && 
    2336         !sensors_get_feature(*name,SENSORS_W83782D_IN8_MAX,&max)) { 
    2337       if (valid) { 
    2338         print_label(label,10); 
    2339         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2340              cur,min,max,alarms&W83782D_ALARM_IN8?"ALARM":"     ", 
    2341              beeps&W83782D_ALARM_IN8?"(beep)":""); 
    2342       } 
    2343     } else 
    2344       printf("ERROR: Can't get IN8 data!\n"); 
    2345     free(label); 
    2346   } 
    2347  
    2348   if (is91d) { 
    2349     if (!sensors_get_label_and_valid(*name,SENSORS_W83791D_IN7,&label,&valid) && 
    2350         !sensors_get_feature(*name,SENSORS_W83791D_IN7,&cur) && 
    2351         !sensors_get_feature(*name,SENSORS_W83791D_IN7_MIN,&min) && 
    2352         !sensors_get_feature(*name,SENSORS_W83791D_IN7_MAX,&max)) { 
    2353       if (valid) { 
    2354         print_label(label,10); 
    2355         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2356              cur,min,max,alarms&W83791D_ALARM_IN7?"ALARM":"     ", 
    2357              beeps&W83791D_BEEP_IN7?"(beep)":""); 
    2358       } 
    2359     } else 
    2360       printf("ERROR: Can't get IN7 data!\n"); 
    2361     free(label); 
    2362     if (!sensors_get_label_and_valid(*name,SENSORS_W83791D_IN8,&label,&valid) && 
    2363         !sensors_get_feature(*name,SENSORS_W83791D_IN8,&cur) && 
    2364         !sensors_get_feature(*name,SENSORS_W83791D_IN8_MIN,&min) && 
    2365         !sensors_get_feature(*name,SENSORS_W83791D_IN8_MAX,&max)) { 
    2366       if (valid) { 
    2367         print_label(label,10); 
    2368         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2369              cur,min,max,alarms&W83791D_ALARM_IN8?"ALARM":"     ", 
    2370              beeps&W83791D_BEEP_IN8?"(beep)":""); 
    2371       } 
    2372     } else 
    2373       printf("ERROR: Can't get IN8 data!\n"); 
    2374     free(label); 
    2375     if (!sensors_get_label_and_valid(*name,SENSORS_W83791D_IN9,&label,&valid) && 
    2376         !sensors_get_feature(*name,SENSORS_W83791D_IN9,&cur) && 
    2377         !sensors_get_feature(*name,SENSORS_W83791D_IN9_MIN,&min) && 
    2378         !sensors_get_feature(*name,SENSORS_W83791D_IN9_MAX,&max)) { 
    2379       if (valid) { 
    2380         print_label(label,10); 
    2381         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s  %s\n", 
    2382              cur,min,max,alarms&W83791D_ALARM_IN9?"ALARM":"     ", 
    2383              beeps&W83791D_ALARM_IN9?"(beep)":""); 
    2384       } 
    2385     } else 
    2386       printf("ERROR: Can't get IN9 data!\n"); 
    2387     free(label); 
    2388   } 
    2389  
    2390   if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN1,&label,&valid) && 
    2391       !sensors_get_feature(*name,SENSORS_W83781D_FAN1,&cur) && 
    2392       !sensors_get_feature(*name,SENSORS_W83781D_FAN1_DIV,&fdiv) && 
    2393       !sensors_get_feature(*name,SENSORS_W83781D_FAN1_MIN,&min)) { 
    2394     if (valid) { 
    2395       print_label(label,10); 
    2396       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s  %s\n", 
    2397            cur,min,fdiv, alarms&W83781D_ALARM_FAN1?"ALARM":"     ", 
    2398            beeps&W83781D_ALARM_FAN1?"(beep)":""); 
    2399     } 
    2400   } else 
    2401     printf("ERROR: Can't get FAN1 data!\n"); 
    2402   free(label); 
    2403   if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN2,&label,&valid) && 
    2404       !sensors_get_feature(*name,SENSORS_W83781D_FAN2,&cur) && 
    2405       !sensors_get_feature(*name,SENSORS_W83781D_FAN2_DIV,&fdiv) && 
    2406       !sensors_get_feature(*name,SENSORS_W83781D_FAN2_MIN,&min)) { 
    2407     if (valid) { 
    2408       print_label(label,10); 
    2409       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s  %s\n", 
    2410            cur,min,fdiv, alarms&W83781D_ALARM_FAN2?"ALARM":"     ", 
    2411            beeps&W83781D_ALARM_FAN2?"(beep)":""); 
    2412     } 
    2413   } else 
    2414     printf("ERROR: Can't get FAN2 data!\n"); 
    2415   free(label); 
    2416  
    2417   if(!is697hf) { 
    2418     if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_FAN3,&label,&valid) && 
    2419         !sensors_get_feature(*name,SENSORS_W83781D_FAN3,&cur) && 
    2420         !sensors_get_feature(*name,SENSORS_W83781D_FAN3_DIV,&fdiv) && 
    2421         !sensors_get_feature(*name,SENSORS_W83781D_FAN3_MIN,&min)) { 
    2422       if (valid) { 
    2423         print_label(label,10); 
    2424         printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s  %s\n", 
    2425              cur,min,fdiv, alarms&W83781D_ALARM_FAN3?"ALARM":"     ", 
    2426              beeps&W83781D_ALARM_FAN3?"(beep)":""); 
    2427       } 
    2428     } else 
    2429       printf("ERROR: Can't get FAN3 data!\n"); 
    2430     free(label); 
    2431   } 
    2432  
    2433   if(is91d) { 
    2434     if (!sensors_get_label_and_valid(*name,SENSORS_W83791D_FAN4,&label,&valid) && 
    2435         !sensors_get_feature(*name,SENSORS_W83791D_FAN4,&cur) && 
    2436         !sensors_get_feature(*name,SENSORS_W83791D_FAN4_DIV,&fdiv) && 
    2437         !sensors_get_feature(*name,SENSORS_W83791D_FAN4_MIN,&min)) { 
    2438       if (valid) { 
    2439         print_label(label,10); 
    2440         printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s  %s\n", 
    2441              cur,min,fdiv, alarms&W83791D_ALARM_FAN4?"ALARM":"     ", 
    2442              beeps&W83791D_ALARM_FAN4?"(beep)":""); 
    2443       } 
    2444     } else 
    2445       printf("ERROR: Can't get FAN4 data!\n"); 
    2446     free(label); 
    2447     if (!sensors_get_label_and_valid(*name,SENSORS_W83791D_FAN5,&label,&valid) && 
    2448         !sensors_get_feature(*name,SENSORS_W83791D_FAN5,&cur) && 
    2449         !sensors_get_feature(*name,SENSORS_W83791D_FAN5_DIV,&fdiv) && 
    2450         !sensors_get_feature(*name,SENSORS_W83791D_FAN5_MIN,&min)) { 
    2451       if (valid) { 
    2452         print_label(label,10); 
    2453         printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s  %s\n", 
    2454              cur,min,fdiv, alarms&W83791D_ALARM_FAN5?"ALARM":"     ", 
    2455              beeps&W83791D_ALARM_FAN5?"(beep)":""); 
    2456       } 
    2457     } else 
    2458       printf("ERROR: Can't get FAN5 data!\n"); 
    2459     free(label); 
    2460   } 
    2461  
    2462   if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP1,&label,&valid) && 
    2463       !sensors_get_feature(*name,SENSORS_W83781D_TEMP1,&cur) && 
    2464       !sensors_get_feature(*name,SENSORS_W83781D_TEMP1_HYST,&min) && 
    2465       !sensors_get_feature(*name,SENSORS_W83781D_TEMP1_OVER,&max)) { 
    2466     if (valid) { 
    2467       if((!is82d) && (!is83s) && (!is697hf)) { 
    2468         print_label(label,10); 
    2469         if(min == 127) 
    2470           print_temp_info( cur, max, 0, MAXONLY, 0, 0); 
    2471         else 
    2472           print_temp_info( cur, max, min, HYST, 0, 0); 
    2473         printf(" %s  %s\n", alarms&W83781D_ALARM_TEMP1 ?"ALARM":"     ", 
    2474                beeps&W83781D_ALARM_TEMP1?"(beep)":""); 
    2475       } else { 
    2476         if(!sensors_get_feature(*name,SENSORS_W83781D_SENS1,&sens)) { 
    2477           print_label(label,10); 
    2478           if(min == 127) 
    2479             print_temp_info( cur, max, 0, MAXONLY, 0, 0); 
    2480           else 
    2481             print_temp_info( cur, max, min, HYST, 0, 0); 
    2482           printf( " sensor = %s   %s   %s\n", 
    2483                  (((int)sens)==1)?"diode":(((int)sens)==2)? 
    2484                  "transistor":"thermistor", 
    2485                  alarms&W83781D_ALARM_TEMP1?"ALARM":"     ", 
    2486                  beeps&W83781D_ALARM_TEMP1?"(beep)":""); 
    2487         } else { 
    2488           printf("ERROR: Can't get TEMP1 data!\n"); 
    2489         } 
    2490       } 
    2491     } 
    2492   } else 
    2493     printf("ERROR: Can't get TEMP1 data!\n"); 
    2494   free(label); 
    2495  
    2496   if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP2,&label,&valid) && 
    2497       !sensors_get_feature(*name,SENSORS_W83781D_TEMP2,&cur) && 
    2498       !sensors_get_feature(*name,SENSORS_W83781D_TEMP2_HYST,&min) && 
    2499       !sensors_get_feature(*name,SENSORS_W83781D_TEMP2_OVER,&max)) { 
    2500     if (valid) { 
    2501       if((!is82d) && (!is83s) && (!is697hf)) { 
    2502         print_label(label,10); 
    2503         print_temp_info( cur, max, min, HYST, 1, 0); 
    2504         printf(" %s  %s\n", alarms&W83781D_ALARM_TEMP2 ?"ALARM":"     ", 
    2505                beeps&W83781D_ALARM_TEMP2?"(beep)":""); 
    2506       } else { 
    2507         if(!sensors_get_feature(*name,SENSORS_W83781D_SENS2,&sens)) { 
    2508           print_label(label,10); 
    2509           print_temp_info( cur, max, min, HYST, 1, 0); 
    2510           printf( " sensor = %s   %s   %s\n", 
    2511                  (((int)sens)==1)?"diode":(((int)sens)==2)? 
    2512                  "transistor":"thermistor", 
    2513                  alarms&W83781D_ALARM_TEMP2?"ALARM":"     ", 
    2514                  beeps&W83781D_ALARM_TEMP2?"(beep)":""); 
    2515         } else { 
    2516           printf("ERROR: Can't get TEMP2 data!\n"); 
    2517         } 
    2518       } 
    2519     } 
    2520   } else 
    2521     printf("ERROR: Can't get TEMP2 data!\n"); 
    2522   free(label); 
    2523  
    2524   if ((!is83s) && (!is697hf)) { 
    2525     if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_TEMP3,&label,&valid) && 
    2526         !sensors_get_feature(*name,SENSORS_W83781D_TEMP3,&cur) && 
    2527         !sensors_get_feature(*name,SENSORS_W83781D_TEMP3_HYST,&min) && 
    2528         !sensors_get_feature(*name,SENSORS_W83781D_TEMP3_OVER,&max)) { 
    2529       if (valid) { 
    2530         if(!is82d) { 
    2531           print_label(label,10); 
    2532           print_temp_info( cur, max, min, HYST, 1, 0); 
    2533           if (!is81d) { 
    2534             /* for the w83791d, beep mask is different than the alarm mask */ 
    2535             if (is91d) 
    2536               beep_mask = W83791D_BEEP_TEMP3; 
    2537             else 
    2538               beep_mask = W83781D_ALARM_TEMP3; 
    2539             printf(" %s  %s\n", alarms&W83781D_ALARM_TEMP3?"ALARM":"     ", 
    2540                    beeps&beep_mask?"(beep)":""); 
    2541           } else 
    2542             printf(" %s  %s\n", alarms&W83781D_ALARM_TEMP23?"ALARM":"     ", 
    2543                    beeps&W83781D_ALARM_TEMP23?"(beep)":""); 
    2544         } else { 
    2545           if(!sensors_get_feature(*name,SENSORS_W83781D_SENS3,&sens)) { 
    2546             print_label(label,10); 
    2547             print_temp_info( cur, max, min, HYST, 1, 0); 
    2548             printf( " sensor = %s   %s   %s\n", 
    2549                    (((int)sens)==1)?"diode":(((int)sens)==2)? 
    2550                    "transistor":"thermistor", 
    2551                    alarms&W83781D_ALARM_TEMP3?"ALARM":"     ", 
    2552                    beeps&W83781D_ALARM_TEMP3?"(beep)":""); 
    2553           } else { 
    2554             printf("ERROR: Can't get TEMP3 data!\n"); 
    2555           } 
    2556         } 
    2557       } 
    2558     } else 
    2559       printf("ERROR: Can't get TEMP3 data!\n"); 
    2560     free(label); 
    2561   } 
    2562  
    2563   if(!is697hf) { 
    2564     print_vid_info(name, SENSORS_W83781D_VID, SENSORS_W83781D_VRM); 
    2565   } 
    2566      
    2567   if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_ALARMS,&label,&valid) 
    2568       && valid && !is83s) { 
    2569     print_label(label,10); 
    2570     if (alarms & W83781D_ALARM_CHAS) 
    2571       printf("Chassis intrusion detection                      ALARM\n"); 
    2572     else 
    2573       printf("\n"); 
    2574   } 
    2575   free(label); 
    2576  
    2577   if (!sensors_get_label_and_valid(*name,SENSORS_W83781D_BEEP_ENABLE,&label,&valid) 
    2578       && valid) { 
    2579     if (!sensors_get_feature(*name,SENSORS_W83781D_BEEP_ENABLE,&cur)) { 
    2580       print_label(label,10); 
    2581       if (cur < 0.5)  
    2582         printf("Sound alarm disabled\n"); 
    2583       else 
    2584         printf("Sound alarm enabled\n"); 
    2585     } else 
    2586       printf("ERROR: Can't get BEEP data!\n"); 
    2587   } 
    2588   free(label); 
    2589 } 
    2590  
    2591  
    2592 void print_w83792d(const sensors_chip_name *name) 
    2593 { 
    2594   char *label; 
    2595   int alarms; 
    2596   double cur,min,max,fdiv; 
    2597   int valid = 0; 
    2598  
    2599   if (!sensors_get_feature(*name,SENSORS_W83792D_ALARMS,&cur))  
    2600     alarms = cur + 0.5; 
    2601   else { 
    2602     printf("ERROR: Can't get alarm data!\n"); 
    2603     alarms = 0; 
    2604   } 
    2605  
    2606   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN0,&label,&valid) && 
    2607       !sensors_get_feature(*name,SENSORS_W83792D_IN0,&cur) && 
    2608       !sensors_get_feature(*name,SENSORS_W83792D_IN0_MIN,&min) && 
    2609       !sensors_get_feature(*name,SENSORS_W83792D_IN0_MAX,&max)) { 
    2610     if (valid) { 
    2611       print_label(label,10); 
    2612       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    2613            cur,min,max, (alarms&W83792D_ALARM_IN0)?"ALARM":""); 
    2614     } 
    2615   } else 
    2616     printf("ERROR: Can't get IN0 data!\n"); 
    2617   free(label); 
    2618  
    2619   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN1,&label,&valid) && 
    2620       !sensors_get_feature(*name,SENSORS_W83792D_IN1,&cur) && 
    2621       !sensors_get_feature(*name,SENSORS_W83792D_IN1_MIN,&min) && 
    2622       !sensors_get_feature(*name,SENSORS_W83792D_IN1_MAX,&max)) { 
    2623     if (valid) { 
    2624       print_label(label,10); 
    2625       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    2626            cur,min,max, (alarms&W83792D_ALARM_IN1)?"ALARM":""); 
    2627     } 
    2628   } else 
    2629     printf("ERROR: Can't get IN1 data!\n"); 
    2630   free(label); 
    2631  
    2632   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN2,&label,&valid) && 
    2633       !sensors_get_feature(*name,SENSORS_W83792D_IN2,&cur) && 
    2634       !sensors_get_feature(*name,SENSORS_W83792D_IN2_MIN,&min) && 
    2635       !sensors_get_feature(*name,SENSORS_W83792D_IN2_MAX,&max)) { 
    2636     if (valid) { 
    2637       print_label(label,10); 
    2638       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    2639            cur,min,max, (alarms&W83792D_ALARM_IN2)?"ALARM":""); 
    2640     } 
    2641   } else 
    2642     printf("ERROR: Can't get IN2 data!\n"); 
    2643   free(label); 
    2644  
    2645   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN3,&label,&valid) && 
    2646       !sensors_get_feature(*name,SENSORS_W83792D_IN3,&cur) && 
    2647       !sensors_get_feature(*name,SENSORS_W83792D_IN3_MIN,&min) && 
    2648       !sensors_get_feature(*name,SENSORS_W83792D_IN3_MAX,&max)) { 
    2649     if (valid) { 
    2650       print_label(label,10); 
    2651       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    2652            cur,min,max, (alarms&W83792D_ALARM_IN3)?"ALARM":""); 
    2653     } 
    2654   } else 
    2655     printf("ERROR: Can't get IN3 data!\n"); 
    2656   free(label); 
    2657  
    2658   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN4,&label,&valid) && 
    2659       !sensors_get_feature(*name,SENSORS_W83792D_IN4,&cur) && 
    2660       !sensors_get_feature(*name,SENSORS_W83792D_IN4_MIN,&min) && 
    2661       !sensors_get_feature(*name,SENSORS_W83792D_IN4_MAX,&max)) { 
    2662     if (valid) { 
    2663       print_label(label,10); 
    2664       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    2665            cur,min,max, (alarms&W83792D_ALARM_IN4)?"ALARM":""); 
    2666     } 
    2667   } else 
    2668     printf("ERROR: Can't get IN4 data!\n"); 
    2669   free(label); 
    2670  
    2671   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN5,&label,&valid) && 
    2672       !sensors_get_feature(*name,SENSORS_W83792D_IN5,&cur) && 
    2673       !sensors_get_feature(*name,SENSORS_W83792D_IN5_MIN,&min) && 
    2674       !sensors_get_feature(*name,SENSORS_W83792D_IN5_MAX,&max)) { 
    2675     if (valid) { 
    2676       print_label(label,10); 
    2677       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    2678            cur,min,max, (alarms&W83792D_ALARM_IN5)?"ALARM":""); 
    2679     } 
    2680   } else 
    2681     printf("ERROR: Can't get IN5 data!\n"); 
    2682   free(label); 
    2683  
    2684   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_IN6,&label,&valid) && 
    2685       !sensors_get_feature(*name,SENSORS_W83792D_IN6,&cur) && 
    2686       !sensors_get_feature(*name,SENSORS_W83792D_IN6_MIN,&min) && 
    2687       !sensors_get_feature(*name,SENSORS_W83792D_IN6_MAX,&max)) { 
    2688     if (valid) { 
    2689       print_label(label,10); 
    2690       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    2691            cur,min,max, (alarms&W83792D_ALARM_IN6)?"ALARM":""); 
    2692     } 
    2693   } else 
    2694     printf("ERROR: Can't get IN6 data!\n"); 
    2695   free(label); 
    2696  
    2697   if (!sensors_get_label_and_valid(*name, SENSORS_W83792D_IN7, 
    2698                                    &label, &valid) && 
    2699       !sensors_get_feature(*name, SENSORS_W83792D_IN7, &cur) && 
    2700       !sensors_get_feature(*name, SENSORS_W83792D_IN7_MIN, &min) && 
    2701       !sensors_get_feature(*name, SENSORS_W83792D_IN7_MAX, &max)) { 
    2702     if (valid) { 
    2703       print_label(label,10); 
    2704       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    2705            cur,min,max, (alarms&W83792D_ALARM_IN7)?"ALARM":""); 
    2706     } 
    2707   } else 
    2708     printf("ERROR: Can't get IN7 data!\n"); 
    2709   free(label); 
    2710  
    2711   if (!sensors_get_label_and_valid(*name, SENSORS_W83792D_IN8, 
    2712                                    &label, &valid) && 
    2713       !sensors_get_feature(*name, SENSORS_W83792D_IN8, &cur) && 
    2714       !sensors_get_feature(*name, SENSORS_W83792D_IN8_MIN, &min) && 
    2715       !sensors_get_feature(*name, SENSORS_W83792D_IN8_MAX, &max)) { 
    2716     if (valid) { 
    2717       print_label(label,10); 
    2718       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    2719            cur,min,max, (alarms&W83792D_ALARM_IN8)?"ALARM":""); 
    2720     } 
    2721   } else 
    2722     printf("ERROR: Can't get IN8 data!\n"); 
    2723   free(label); 
    2724  
    2725   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN1,&label,&valid) && 
    2726       !sensors_get_feature(*name,SENSORS_W83792D_FAN1,&cur) && 
    2727       !sensors_get_feature(*name,SENSORS_W83792D_FAN1_DIV,&fdiv) && 
    2728       !sensors_get_feature(*name,SENSORS_W83792D_FAN1_MIN,&min)) { 
    2729     if (valid) { 
    2730       print_label(label,10); 
    2731       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s\n", 
    2732            cur,min,fdiv, (alarms&W83792D_ALARM_FAN1)?"ALARM":""); 
    2733     } 
    2734   } else 
    2735     printf("ERROR: Can't get FAN1 data!\n"); 
    2736   free(label); 
    2737  
    2738   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN2,&label,&valid) && 
    2739       !sensors_get_feature(*name,SENSORS_W83792D_FAN2,&cur) && 
    2740       !sensors_get_feature(*name,SENSORS_W83792D_FAN2_DIV,&fdiv) && 
    2741       !sensors_get_feature(*name,SENSORS_W83792D_FAN2_MIN,&min)) { 
    2742     if (valid) { 
    2743       print_label(label,10); 
    2744       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s\n", 
    2745            cur,min,fdiv, (alarms&W83792D_ALARM_FAN2)?"ALARM":""); 
    2746     } 
    2747   } else 
    2748     printf("ERROR: Can't get FAN2 data!\n"); 
    2749   free(label); 
    2750  
    2751   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN3,&label,&valid) && 
    2752       !sensors_get_feature(*name,SENSORS_W83792D_FAN3,&cur) && 
    2753       !sensors_get_feature(*name,SENSORS_W83792D_FAN3_DIV,&fdiv) && 
    2754       !sensors_get_feature(*name,SENSORS_W83792D_FAN3_MIN,&min)) { 
    2755     if (valid) { 
    2756       print_label(label,10); 
    2757       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s\n", 
    2758            cur,min,fdiv, (alarms&W83792D_ALARM_FAN3)?"ALARM":""); 
    2759     } 
    2760   } else 
    2761     printf("ERROR: Can't get FAN3 data!\n"); 
    2762   free(label); 
    2763  
    2764   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN4,&label,&valid) && 
    2765       !sensors_get_feature(*name,SENSORS_W83792D_FAN4,&cur) && 
    2766       !sensors_get_feature(*name,SENSORS_W83792D_FAN4_DIV,&fdiv) && 
    2767       !sensors_get_feature(*name,SENSORS_W83792D_FAN4_MIN,&min)) { 
    2768     if (valid) { 
    2769       print_label(label,10); 
    2770       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s\n", 
    2771            cur,min,fdiv, (alarms&W83792D_ALARM_FAN4)?"ALARM":""); 
    2772     } 
    2773   } 
    2774   free(label); 
    2775  
    2776   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN5,&label,&valid) && 
    2777       !sensors_get_feature(*name,SENSORS_W83792D_FAN5,&cur) && 
    2778       !sensors_get_feature(*name,SENSORS_W83792D_FAN5_DIV,&fdiv) && 
    2779       !sensors_get_feature(*name,SENSORS_W83792D_FAN5_MIN,&min)) { 
    2780     if (valid) { 
    2781       print_label(label,10); 
    2782       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s\n", 
    2783            cur,min,fdiv, (alarms&W83792D_ALARM_FAN5)?"ALARM":""); 
    2784     } 
    2785   } 
    2786   free(label); 
    2787  
    2788   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN6,&label,&valid) && 
    2789       !sensors_get_feature(*name,SENSORS_W83792D_FAN6,&cur) && 
    2790       !sensors_get_feature(*name,SENSORS_W83792D_FAN6_DIV,&fdiv) && 
    2791       !sensors_get_feature(*name,SENSORS_W83792D_FAN6_MIN,&min)) { 
    2792     if (valid) { 
    2793       print_label(label,10); 
    2794       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s\n", 
    2795            cur,min,fdiv, (alarms&W83792D_ALARM_FAN6)?"ALARM":""); 
    2796     } 
    2797   } 
    2798   free(label); 
    2799  
    2800   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_FAN7,&label,&valid) && 
    2801       !sensors_get_feature(*name,SENSORS_W83792D_FAN7,&cur) && 
    2802       !sensors_get_feature(*name,SENSORS_W83792D_FAN7_DIV,&fdiv) && 
    2803       !sensors_get_feature(*name,SENSORS_W83792D_FAN7_MIN,&min)) { 
    2804     if (valid) { 
    2805       print_label(label,10); 
    2806       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s\n", 
    2807            cur,min,fdiv, (alarms&W83792D_ALARM_FAN7)?"ALARM":""); 
    2808     } 
    2809   } 
    2810   free(label); 
    2811  
    2812   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_TEMP1,&label,&valid) && 
    2813       !sensors_get_feature(*name,SENSORS_W83792D_TEMP1,&cur) && 
    2814       !sensors_get_feature(*name,SENSORS_W83792D_TEMP1_HYST,&min) && 
    2815       !sensors_get_feature(*name,SENSORS_W83792D_TEMP1_OVER,&max)) { 
    2816     if (valid) { 
    2817       print_label(label,10); 
    2818       if(min == 127){ 
    2819         print_temp_info( cur, max, 0, MAXONLY, 1, 1); 
    2820         printf(" %s\n", (cur>max)?"ALARM":""); 
    2821       }else{ 
    2822         print_temp_info( cur, max, min, HYST, 1, 1); 
    2823         printf(" %s\n", (alarms&W83792D_ALARM_TEMP1)?"ALARM":""); 
    2824       } 
    2825     } 
    2826   } else 
    2827     printf("ERROR: Can't get TEMP1 data!\n"); 
    2828   free(label); 
    2829  
    2830   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_TEMP2,&label,&valid) && 
    2831       !sensors_get_feature(*name,SENSORS_W83792D_TEMP2,&cur) && 
    2832       !sensors_get_feature(*name,SENSORS_W83792D_TEMP2_HYST,&min) && 
    2833       !sensors_get_feature(*name,SENSORS_W83792D_TEMP2_OVER,&max)) { 
    2834     if (valid) { 
    2835       print_label(label,10); 
    2836       print_temp_info( cur, max, min, HYST, 1, 1); 
    2837       printf(" %s\n", (alarms&W83792D_ALARM_TEMP2)?"ALARM":""); 
    2838     } 
    2839   } else 
    2840     printf("ERROR: Can't get TEMP2 data!\n"); 
    2841   free(label); 
    2842  
    2843   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_TEMP3,&label,&valid) && 
    2844       !sensors_get_feature(*name,SENSORS_W83792D_TEMP3,&cur) && 
    2845       !sensors_get_feature(*name,SENSORS_W83792D_TEMP3_HYST,&min) && 
    2846       !sensors_get_feature(*name,SENSORS_W83792D_TEMP3_OVER,&max)) { 
    2847     if (valid) { 
    2848       print_label(label,10); 
    2849       print_temp_info( cur, max, min, HYST, 1, 1); 
    2850       printf(" %s\n", (alarms&W83792D_ALARM_TEMP3)?"ALARM":""); 
    2851     } 
    2852   } else 
    2853     printf("ERROR: Can't get TEMP3 data!\n"); 
    2854   free(label); 
    2855  
    2856   /* print_vid_info(name, SENSORS_W83792D_VID, SENSORS_W83792D_VRM); */ 
    2857      
    2858   if (!sensors_get_label_and_valid(*name,SENSORS_W83792D_CHASSIS,&label,&valid) && 
    2859       !sensors_get_feature(*name,SENSORS_W83792D_CHASSIS,&cur) ) 
    2860   { 
    2861     if (valid) { 
    2862       print_label(label,10); 
    2863       if (cur==1) { 
    2864         printf("Chassis intrusion detection                  ALARM\n"); 
    2865       }else{ 
    2866         printf("Chassis is normal.\n"); 
    2867       } 
    2868     } 
    2869   }else{ 
    2870     printf("ERROR: Can't get Chassis data!\n"); 
    2871   } 
    2872   free(label); 
    2873 } 
    2874  
    2875 void print_w83l785ts(const sensors_chip_name *name) 
    2876 { 
    2877   char *label; 
    2878   double cur, over; 
    2879   int valid; 
    2880  
    2881   if (!sensors_get_label_and_valid(*name, SENSORS_W83L785TS_TEMP, &label, &valid) 
    2882    && !sensors_get_feature(*name, SENSORS_W83L785TS_TEMP, &cur) 
    2883    && !sensors_get_feature(*name, SENSORS_W83L785TS_TEMP_OVER, &over)) { 
    2884     if (valid) { 
    2885       print_label(label, 10); 
    2886       print_temp_info(cur, over, 0, MAXONLY, 0, 0); 
    2887       printf("\n"); 
    2888     } 
    2889   } else 
    2890     printf("ERROR: Can't get temperature data!\n"); 
    2891   free(label); 
    2892 } 
    2893  
    2894 void print_w83627ehf(const sensors_chip_name *name) 
    2895 { 
    2896   char *label; 
    2897   int i, valid, num_in; 
    2898   double cur, min, fdiv, max, alarm, over, hyst; 
    2899  
    2900   if (!strcmp(name->prefix, "w83627dhg")) 
    2901     num_in = 9; 
    2902   else 
    2903     num_in = 10; 
    2904  
    2905   for (i = 0; i < num_in; i++) { 
    2906     if (!sensors_get_label_and_valid(*name,SENSORS_W83627EHF_IN0+i, 
    2907         &label,&valid) 
    2908       && !sensors_get_feature(*name,SENSORS_W83627EHF_IN0+i,&cur) 
    2909       && !sensors_get_feature(*name,SENSORS_W83627EHF_IN0_MIN+i,&min) 
    2910       && !sensors_get_feature(*name,SENSORS_W83627EHF_IN0_MAX+i,&max) 
    2911       && !sensors_get_feature(*name,SENSORS_W83627EHF_IN0_ALARM+i,&alarm)) { 
    2912       if (valid) { 
    2913         print_label(label,10); 
    2914         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V) %s\n", 
    2915                cur,min,max,alarm ? "ALARM" : ""); 
    2916       } 
    2917     } 
    2918     /* Earlier versions of the driver did not have voltage support, so we 
    2919        keep quiet on error */ 
    2920     free(label); 
    2921   } 
    2922  
    2923   for (i = 0; i < 5; i++) { 
    2924     if (!sensors_get_label_and_valid(*name, SENSORS_W83627EHF_FAN1+i, 
    2925         &label, &valid) 
    2926      && !sensors_get_feature(*name, SENSORS_W83627EHF_FAN1+i, &cur) 
    2927      && !sensors_get_feature(*name, SENSORS_W83627EHF_FAN1_MIN+i, &min)) { 
    2928       if (valid) { 
    2929         print_label(label,10); 
    2930         printf("%4.0f RPM  (min = %4.0f RPM", cur, min); 
    2931         if (!sensors_get_feature(*name, SENSORS_W83627EHF_FAN1_DIV+i, &fdiv)) 
    2932           printf(", div = %1.0f", fdiv); 
    2933         printf(")"); 
    2934         if (!sensors_get_feature(*name, SENSORS_W83627EHF_FAN1_ALARM+i, 
    2935                                  &alarm) && alarm) 
    2936           printf(" ALARM"); 
    2937         printf("\n"); 
    2938       } 
    2939     } else if (i < 3) 
    2940       printf("ERROR: Can't get FAN%d data!\n", i + 1); 
    2941     free(label); 
    2942   } 
    2943  
    2944   for (i = 0; i < 3; i++) { 
    2945     if (!sensors_get_label_and_valid(*name, SENSORS_W83627EHF_TEMP1+i, 
    2946         &label, &valid) 
    2947      && !sensors_get_feature(*name, SENSORS_W83627EHF_TEMP1+i, &cur) 
    2948      && !sensors_get_feature(*name, SENSORS_W83627EHF_TEMP1_OVER+i, &over) 
    2949      && !sensors_get_feature(*name, SENSORS_W83627EHF_TEMP1_HYST+i, &hyst)) { 
    2950       if (valid) { 
    2951         print_label(label,10); 
    2952         print_temp_info(cur, over, hyst, HYST, i ? 1 : 0, i ? 1 : 0); 
    2953         if (!sensors_get_feature(*name, SENSORS_W83627EHF_TEMP1_ALARM+i, 
    2954                                  &alarm) && alarm) 
    2955           printf(" ALARM"); 
    2956         printf("\n"); 
    2957       } 
    2958     } else 
    2959       printf("ERROR: Can't get TEMP%d data!\n", i + 1); 
    2960     free(label); 
    2961   } 
    2962 } 
    2963  
    2964 void print_w83793(const sensors_chip_name *name) 
    2965 { 
    2966   char *label; 
    2967   int i, valid; 
    2968   double cur, min, max, over, hyst, alarm; 
    2969  
    2970   for (i = 0; i < 10; i++) { 
    2971     if (!sensors_get_label_and_valid(*name,SENSORS_W83793_IN(i), 
    2972                                      &label, &valid) && 
    2973         !sensors_get_feature(*name, SENSORS_W83793_IN(i), &cur) && 
    2974         !sensors_get_feature(*name, SENSORS_W83793_IN_MIN(i), &min) && 
    2975         !sensors_get_feature(*name, SENSORS_W83793_IN_MAX(i), &max) && 
    2976         !sensors_get_feature(*name, SENSORS_W83793_IN_ALARM(i), &alarm)) { 
    2977       if (valid) { 
    2978         print_label(label, 10); 
    2979         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    2980                cur, min, max, alarm ? "ALARM" : ""); 
    2981       } 
    2982     } else 
    2983       printf("ERROR: Can't get IN%d data!\n", i); 
    2984     free(label); 
    2985   } 
    2986  
    2987   for (i = 1; i <= 12; i++) { 
    2988     if (!sensors_get_label_and_valid(*name, SENSORS_W83793_FAN(i), 
    2989                                      &label, &valid) && 
    2990         !sensors_get_feature(*name, SENSORS_W83793_FAN(i), &cur) && 
    2991         !sensors_get_feature(*name, SENSORS_W83793_FAN_MIN(i), &min) && 
    2992         !sensors_get_feature(*name, SENSORS_W83793_FAN_ALARM(i), &alarm)) { 
    2993       if (valid) { 
    2994         print_label(label, 10); 
    2995         printf("%4.0f RPM  (min = %4.0f RPM)                   %s\n", 
    2996                cur, min, alarm ? "ALARM" : ""); 
    2997       } 
    2998     } else if (i <= 5) 
    2999       printf("ERROR: Can't get FAN%d data!\n", i); 
    3000     free(label); 
    3001   } 
    3002  
    3003   for (i = 1; i <= 6; i++) { 
    3004     if (!sensors_get_label_and_valid(*name, SENSORS_W83793_TEMP(i), 
    3005                                      &label, &valid) && 
    3006         !sensors_get_feature(*name, SENSORS_W83793_TEMP(i), &cur) && 
    3007         !sensors_get_feature(*name, SENSORS_W83793_TEMP_CRIT(i), &over) && 
    3008         !sensors_get_feature(*name, SENSORS_W83793_TEMP_CRIT_HYST(i), &hyst) && 
    3009         !sensors_get_feature(*name, SENSORS_W83793_TEMP_ALARM(i), &alarm)) { 
    3010       if (valid) { 
    3011         print_label(label, 10); 
    3012         print_temp_info(cur, over, hyst, HYST, i <= 4 ? 1 : 0, i <= 4 ? 1 : 0); 
    3013         printf(" %s\n", alarm ? "ALARM" : ""); 
    3014       } 
    3015     } 
    3016     free(label); 
    3017   } 
    3018  
    3019   print_vid_info(name, SENSORS_W83793_VID0, SENSORS_W83793_VRM); 
    3020   print_vid_info(name, SENSORS_W83793_VID1, SENSORS_W83793_VRM); 
    3021 } 
    3022  
    3023 void print_maxilife(const sensors_chip_name *name) 
    3024 { 
    3025    char  *label; 
    3026    double cur, min, max; 
    3027    int    alarms,valid; 
    3028  
    3029    if (!sensors_get_feature(*name, SENSORS_MAXI_CG_ALARMS, &cur))  
    3030       alarms = cur + 0.5; 
    3031    else { 
    3032       printf("ERROR: Can't get alarm data!\n"); 
    3033       alarms = 0; 
    3034    } 
    3035  
    3036    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP1, &label,&valid) && 
    3037        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1, &cur) && 
    3038        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1_MAX, &max) && 
    3039        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP1_HYST, &min)) { 
    3040       if (valid && (cur || max || min)) { 
    3041          print_label(label, 12); 
    3042          print_temp_info( cur, max, min, HYST, 1, 0); 
    3043          printf("\n"); 
    3044       } 
    3045    } else 
    3046       printf("ERROR: Can't get TEMP1 data!\n"); 
    3047    free(label); 
    3048  
    3049    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP2, &label,&valid) && 
    3050        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2, &cur) && 
    3051        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2_MAX, &max) && 
    3052        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP2_HYST, &min)) { 
    3053       if (valid && (cur || max || min)) { 
    3054          print_label(label, 12); 
    3055          print_temp_info( cur, max, min, HYST, 1, 0); 
    3056          printf(" %s\n", alarms&MAXI_ALARM_TEMP2 ? "ALARM" : ""); 
    3057       } 
    3058    } else 
    3059       printf("ERROR: Can't get TEMP2 data!\n"); 
    3060    free(label); 
    3061  
    3062    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP3, &label,&valid) && 
    3063        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3, &cur) && 
    3064        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3_MAX, &max) && 
    3065        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP3_HYST, &min)) { 
    3066       if (valid && (cur || max || min)) { 
    3067          print_label(label, 12); 
    3068          print_temp_info( cur, max, min, HYST, 1, 0); 
    3069          printf("\n"); 
    3070       } 
    3071    } else 
    3072       printf("ERROR: Can't get TEMP3 data!\n"); 
    3073    free(label); 
    3074  
    3075    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP4, &label,&valid) && 
    3076        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4, &cur) && 
    3077        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4_MAX, &max) && 
    3078        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP4_HYST, &min)) { 
    3079       if (valid && (cur || max || min)) { 
    3080          print_label(label, 12); 
    3081          print_temp_info( cur, max, min, HYST, 1, 0); 
    3082          printf(" %s\n", alarms&MAXI_ALARM_TEMP4 ? "ALARM" : ""); 
    3083       } 
    3084    } else 
    3085       printf("ERROR: Can't get TEMP4 data!\n"); 
    3086    free(label); 
    3087  
    3088    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_TEMP5, &label,&valid) && 
    3089        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5, &cur) && 
    3090        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5_MAX, &max) && 
    3091        !sensors_get_feature(*name, SENSORS_MAXI_CG_TEMP5_HYST, &min)) { 
    3092       if (valid && (cur || max || min)) { 
    3093          print_label(label, 12); 
    3094          print_temp_info( cur, max, min, HYST, 1, 0); 
    3095          printf(" %s\n", alarms&MAXI_ALARM_TEMP5 ? "ALARM" : ""); 
    3096       } 
    3097    } else 
    3098       printf("ERROR: Can't get TEMP5 data!\n"); 
    3099    free(label); 
    3100     
    3101    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN1, &label,&valid) && 
    3102        !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1, &cur) && 
    3103        !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1_MIN, &min) && 
    3104        !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN1_DIV, &max)) { 
    3105       if (valid && (cur || min || max)) { 
    3106          print_label(label, 12); 
    3107          if (cur < 0) 
    3108             printf("  OFF       (min = %4.0f RPM, div = %1.0f)      %s\n", 
    3109                    min/max, max, alarms&MAXI_ALARM_FAN1 ? "ALARM" : ""); 
    3110          else 
    3111             printf("%5.0f RPM   (min = %4.0f RPM, div = %1.0f)      %s\n", 
    3112                    cur/max, min/max, max, alarms&MAXI_ALARM_FAN1 ? "ALARM" : ""); 
    3113       } 
    3114    } else 
    3115       printf("ERROR: Can't get FAN1 data!\n"); 
    3116    free(label); 
    3117  
    3118    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN2, &label,&valid) && 
    3119        !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2, &cur) && 
    3120        !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2_MIN, &min) && 
    3121        !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN2_DIV, &max)) { 
    3122       if (valid && (cur || min || max)) { 
    3123          print_label(label, 12); 
    3124          if (cur < 0) 
    3125             printf("  OFF       (min = %4.0f RPM, div = %1.0f)      %s\n", 
    3126                    min/max, max, alarms&MAXI_ALARM_FAN2 ? "ALARM" : ""); 
    3127          else 
    3128             printf("%5.0f RPM   (min = %4.0f RPM, div = %1.0f)      %s\n", 
    3129                    cur/max, min/max, max, alarms&MAXI_ALARM_FAN2 ? "ALARM" : ""); 
    3130       } 
    3131    } else 
    3132       printf("ERROR: Can't get FAN2 data!\n"); 
    3133    free(label); 
    3134  
    3135    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_FAN3, &label,&valid) && 
    3136        !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3, &cur) && 
    3137        !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3_MIN, &min) && 
    3138        !sensors_get_feature(*name, SENSORS_MAXI_CG_FAN3_DIV, &max)) { 
    3139       if (valid && (cur || min || max)) { 
    3140          print_label(label, 12); 
    3141          if (cur < 0) 
    3142             printf("  OFF       (min = %4.0f RPM, div = %1.0f)      %s\n", 
    3143                    min/max, max, alarms&MAXI_ALARM_FAN3 ? "ALARM" : ""); 
    3144          else 
    3145             printf("%5.0f RPM   (min = %4.0f RPM, div = %1.0f)      %s\n", 
    3146                    cur/max, min/max, max, alarms&MAXI_ALARM_FAN3 ? "ALARM" : ""); 
    3147       } 
    3148    } else 
    3149       printf("ERROR: Can't get FAN3 data!\n"); 
    3150    free(label); 
    3151  
    3152    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_PLL, &label,&valid) && 
    3153        !sensors_get_feature(*name, SENSORS_MAXI_CG_PLL, &cur) && 
    3154        !sensors_get_feature(*name, SENSORS_MAXI_CG_PLL_MIN, &min) && 
    3155        !sensors_get_feature(*name, SENSORS_MAXI_CG_PLL_MAX, &max)) { 
    3156       if (valid && (cur || min || max)) { 
    3157          print_label(label, 12); 
    3158          printf("%4.2f MHz   (min = %4.2f MHz, max = %4.2f MHz) %s\n", 
    3159                 cur, min, max, alarms&MAXI_ALARM_PLL ? "ALARM" : ""); 
    3160       } 
    3161    } else 
    3162       printf("ERROR: Can't get PLL data!\n"); 
    3163    free(label); 
    3164  
    3165    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID1, &label,&valid) && 
    3166        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID1, &cur) && 
    3167        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID1_MIN, &min) && 
    3168        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID1_MAX, &max)) { 
    3169       if (valid && (cur || min || max)) { 
    3170          print_label(label, 12); 
    3171          printf("%+6.2f V    (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3172                 cur, min, max, alarms&MAXI_ALARM_VID1 ? "ALARM" : ""); 
    3173       } 
    3174    } else 
    3175       printf("ERROR: Can't get VID1 data!\n"); 
    3176    free(label); 
    3177  
    3178    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID2, &label,&valid) && 
    3179        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID2, &cur) && 
    3180        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID2_MIN, &min) && 
    3181        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID2_MAX, &max)) { 
    3182       if (valid && (cur || min || max)) { 
    3183          print_label(label, 12); 
    3184          printf("%+6.2f V    (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3185                 cur, min, max, alarms&MAXI_ALARM_VID2 ? "ALARM" : ""); 
    3186       } 
    3187    } else 
    3188       printf("ERROR: Can't get VID2 data!\n"); 
    3189    free(label); 
    3190  
    3191    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID3, &label,&valid) && 
    3192        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID3, &cur) && 
    3193        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID3_MIN, &min) && 
    3194        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID3_MAX, &max)) { 
    3195       if (valid && (cur || min || max)) { 
    3196          print_label(label, 12); 
    3197          printf("%+6.2f V    (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3198                 cur, min, max, alarms&MAXI_ALARM_VID3 ? "ALARM" : ""); 
    3199       } 
    3200    } else 
    3201       printf("ERROR: Can't get VID3 data!\n"); 
    3202    free(label); 
    3203  
    3204    if (!sensors_get_label_and_valid(*name, SENSORS_MAXI_CG_VID4, &label,&valid) && 
    3205        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID4, &cur) && 
    3206        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID4_MIN, &min) && 
    3207        !sensors_get_feature(*name, SENSORS_MAXI_CG_VID4_MAX, &max)) { 
    3208       if (valid && (cur || min || max)) { 
    3209          print_label(label, 12); 
    3210          printf("%+6.2f V    (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3211                 cur, min, max, alarms&MAXI_ALARM_VID4 ? "ALARM" : ""); 
    3212       } 
    3213    } else 
    3214       printf("ERROR: Can't get VID4 data!\n"); 
    3215    free(label); 
    3216 } 
    3217  
    3218 void print_it87(const sensors_chip_name *name) 
    3219 { 
    3220   char *label; 
    3221   double cur, min, max, fdiv, sens; 
    3222   int alarms, valid; 
    3223  
    3224   if (!sensors_get_feature(*name,SENSORS_IT87_ALARMS, &cur)) { 
    3225     alarms = cur + 0.5; 
    3226   } 
    3227   else { 
    3228     printf("ERROR: Can't get alarm data!\n"); 
    3229     alarms = 0; 
    3230   } 
    3231  
    3232   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN0,&label,&valid) && 
    3233       !sensors_get_feature(*name,SENSORS_IT87_IN0,&cur) && 
    3234       !sensors_get_feature(*name,SENSORS_IT87_IN0_MIN,&min) && 
    3235       !sensors_get_feature(*name,SENSORS_IT87_IN0_MAX,&max)) { 
    3236     if (valid) { 
    3237       print_label(label,10); 
    3238       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3239              cur,min,max,alarms&IT87_ALARM_IN0?"ALARM":""); 
    3240     } 
    3241   } else 
    3242     printf("ERROR: Can't get IN0 data!\n"); 
    3243   free(label); 
    3244   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN1,&label,&valid) && 
    3245       !sensors_get_feature(*name,SENSORS_IT87_IN1,&cur) && 
    3246       !sensors_get_feature(*name,SENSORS_IT87_IN1_MIN,&min) && 
    3247       !sensors_get_feature(*name,SENSORS_IT87_IN1_MAX,&max)) { 
    3248     if (valid) { 
    3249       print_label(label,10); 
    3250       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3251              cur,min,max,alarms&IT87_ALARM_IN1?"ALARM":""); 
    3252     } 
    3253   } else 
    3254     printf("ERROR: Can't get IN1 data!\n"); 
    3255   free(label); 
    3256   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN2,&label,&valid) && 
    3257       !sensors_get_feature(*name,SENSORS_IT87_IN2,&cur) && 
    3258       !sensors_get_feature(*name,SENSORS_IT87_IN2_MIN,&min) && 
    3259       !sensors_get_feature(*name,SENSORS_IT87_IN2_MAX,&max)) { 
    3260     if (valid) { 
    3261       print_label(label,10); 
    3262       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3263              cur,min,max,alarms&IT87_ALARM_IN2?"ALARM":""); 
    3264     } 
    3265   } else 
    3266     printf("ERROR: Can't get IN2 data!\n"); 
    3267   free(label); 
    3268   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN3,&label,&valid) && 
    3269       !sensors_get_feature(*name,SENSORS_IT87_IN3,&cur) && 
    3270       !sensors_get_feature(*name,SENSORS_IT87_IN3_MIN,&min) && 
    3271       !sensors_get_feature(*name,SENSORS_IT87_IN3_MAX,&max)) { 
    3272     if (valid) { 
    3273       print_label(label,10); 
    3274       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3275              cur,min,max,alarms&IT87_ALARM_IN3?"ALARM":""); 
    3276     } 
    3277   } else 
    3278     printf("ERROR: Can't get IN3 data!\n"); 
    3279   free(label); 
    3280   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN4,&label,&valid) && 
    3281       !sensors_get_feature(*name,SENSORS_IT87_IN4,&cur) && 
    3282       !sensors_get_feature(*name,SENSORS_IT87_IN4_MIN,&min) && 
    3283       !sensors_get_feature(*name,SENSORS_IT87_IN4_MAX,&max)) { 
    3284     if (valid) { 
    3285       print_label(label,10); 
    3286       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3287              cur,min,max,alarms&IT87_ALARM_IN4?"ALARM":""); 
    3288     } 
    3289   } else 
    3290     printf("ERROR: Can't get IN4 data!\n"); 
    3291   free(label); 
    3292   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN5,&label,&valid) && 
    3293       !sensors_get_feature(*name,SENSORS_IT87_IN5,&cur) && 
    3294       !sensors_get_feature(*name,SENSORS_IT87_IN5_MIN,&min) && 
    3295       !sensors_get_feature(*name,SENSORS_IT87_IN5_MAX,&max)) { 
    3296     if (valid) { 
    3297       print_label(label,10); 
    3298       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3299              cur,min,max,alarms&IT87_ALARM_IN5?"ALARM":""); 
    3300     } 
    3301   } 
    3302   free(label); 
    3303   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN6,&label,&valid) && 
    3304       !sensors_get_feature(*name,SENSORS_IT87_IN6,&cur) && 
    3305       !sensors_get_feature(*name,SENSORS_IT87_IN6_MIN,&min) && 
    3306       !sensors_get_feature(*name,SENSORS_IT87_IN6_MAX,&max)) { 
    3307     if (valid) { 
    3308       print_label(label,10); 
    3309       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3310              cur,min,max,alarms&IT87_ALARM_IN6?"ALARM":""); 
    3311     } 
    3312   } 
    3313   free(label); 
    3314   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN7,&label,&valid) && 
    3315       !sensors_get_feature(*name,SENSORS_IT87_IN7,&cur) && 
    3316       !sensors_get_feature(*name,SENSORS_IT87_IN7_MIN,&min) && 
    3317       !sensors_get_feature(*name,SENSORS_IT87_IN7_MAX,&max)) { 
    3318     if (valid) { 
    3319       print_label(label,10); 
    3320       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3321              cur,min,max,alarms&IT87_ALARM_IN7?"ALARM":""); 
    3322     } 
    3323   } else 
    3324     printf("ERROR: Can't get IN7 data!\n"); 
    3325   free(label); 
    3326   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_IN8,&label,&valid) && 
    3327       !sensors_get_feature(*name,SENSORS_IT87_IN8,&cur)) { 
    3328     if (valid) { 
    3329       print_label(label,10); 
    3330       printf("%+6.2f V\n", cur); 
    3331     } 
    3332   } else  
    3333     printf("ERROR: Can't get IN8 data!\n"); 
    3334   free(label); 
    3335  
    3336   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN1,&label,&valid) && 
    3337       !sensors_get_feature(*name,SENSORS_IT87_FAN1,&cur) && 
    3338       !sensors_get_feature(*name,SENSORS_IT87_FAN1_MIN,&min)) { 
    3339     if (valid) { 
    3340       print_label(label,10); 
    3341       printf("%4.0f RPM  (min = %4.0f RPM", cur, min); 
    3342       /* fan1_div is optional */ 
    3343       if (!sensors_get_feature(*name, SENSORS_IT87_FAN1_DIV, &fdiv)) 
    3344         printf(", div = %1.0f)", fdiv); 
    3345       else 
    3346         printf(")         "); 
    3347       printf("          %s\n", alarms&IT87_ALARM_FAN1?"ALARM":""); 
    3348     } 
    3349   } 
    3350   free(label); 
    3351   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN2,&label,&valid) && 
    3352       !sensors_get_feature(*name,SENSORS_IT87_FAN2,&cur) && 
    3353       !sensors_get_feature(*name,SENSORS_IT87_FAN2_MIN,&min)) { 
    3354     if (valid) { 
    3355       print_label(label,10); 
    3356       printf("%4.0f RPM  (min = %4.0f RPM", cur, min); 
    3357       /* fan2_div is optional */ 
    3358       if (!sensors_get_feature(*name, SENSORS_IT87_FAN2_DIV, &fdiv)) 
    3359         printf(", div = %1.0f)", fdiv); 
    3360       else 
    3361         printf(")         "); 
    3362       printf("          %s\n", alarms&IT87_ALARM_FAN2?"ALARM":""); 
    3363     } 
    3364   } 
    3365   free(label); 
    3366   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_FAN3,&label,&valid) && 
    3367       !sensors_get_feature(*name,SENSORS_IT87_FAN3,&cur) && 
    3368       !sensors_get_feature(*name,SENSORS_IT87_FAN3_MIN,&min)) { 
    3369     if (valid) { 
    3370       print_label(label,10); 
    3371       printf("%4.0f RPM  (min = %4.0f RPM", cur, min); 
    3372       /* fan3_div is optional */ 
    3373       if (!sensors_get_feature(*name, SENSORS_IT87_FAN3_DIV, &fdiv)) 
    3374         printf(", div = %1.0f)", fdiv); 
    3375       else 
    3376         printf(")         "); 
    3377       printf("          %s\n", alarms&IT87_ALARM_FAN3?"ALARM":""); 
    3378     } 
    3379   } 
    3380   free(label); 
    3381  
    3382   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP1,&label,&valid) && 
    3383       !sensors_get_feature(*name,SENSORS_IT87_TEMP1,&cur) && 
    3384       !sensors_get_feature(*name,SENSORS_IT87_TEMP1_LOW,&min) && 
    3385       !sensors_get_feature(*name,SENSORS_IT87_SENS1,&sens) && 
    3386       !sensors_get_feature(*name,SENSORS_IT87_TEMP1_HIGH,&max)) { 
    3387     if (valid) { 
    3388       print_label(label,10); 
    3389       print_temp_info( cur, max, min, MINMAX, 0, 0); 
    3390       printf(" sensor = %s  ", (((int)sens)==3) ? "diode" : 
    3391                                (((int)sens)==2) ? "thermistor" : 
    3392                                (((int)sens)==0) ? "disabled" : "invalid"); 
    3393       printf( " %s\n", alarms & IT87_ALARM_TEMP1 ? "ALARM" : "" ); 
    3394     } 
    3395   } else 
    3396     printf("ERROR: Can't get TEMP1 data!\n"); 
    3397   free(label); 
    3398   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP2,&label,&valid) && 
    3399       !sensors_get_feature(*name,SENSORS_IT87_TEMP2,&cur) && 
    3400       !sensors_get_feature(*name,SENSORS_IT87_TEMP2_LOW,&min) && 
    3401       !sensors_get_feature(*name,SENSORS_IT87_SENS2,&sens) && 
    3402       !sensors_get_feature(*name,SENSORS_IT87_TEMP2_HIGH,&max)) { 
    3403     if (valid) { 
    3404       print_label(label,10); 
    3405       print_temp_info( cur, max, min, MINMAX, 0, 0); 
    3406       printf(" sensor = %s  ", (((int)sens)==3) ? "diode" : 
    3407                              (((int)sens)==2) ? "thermistor" : 
    3408                              (((int)sens)==0) ? "disabled" : "invalid"); 
    3409       printf( " %s\n", alarms & IT87_ALARM_TEMP2 ? "ALARM" : "" ); 
    3410     } 
    3411   } else 
    3412     printf("ERROR: Can't get TEMP2 data!\n"); 
    3413   free(label); 
    3414   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_TEMP3,&label,&valid) && 
    3415       !sensors_get_feature(*name,SENSORS_IT87_TEMP3,&cur) && 
    3416       !sensors_get_feature(*name,SENSORS_IT87_TEMP3_LOW,&min) && 
    3417       !sensors_get_feature(*name,SENSORS_IT87_SENS3,&sens) && 
    3418       !sensors_get_feature(*name,SENSORS_IT87_TEMP3_HIGH,&max)) { 
    3419     if (valid) { 
    3420       print_label(label,10); 
    3421       print_temp_info( cur, max, min, MINMAX, 0, 0); 
    3422       printf(" sensor = %s  ", (((int)sens)==3) ? "diode" : 
    3423                                (((int)sens)==2) ? "thermistor" : 
    3424                                (((int)sens)==0) ? "disabled" : "invalid"); 
    3425       printf( " %s\n", alarms & IT87_ALARM_TEMP3 ? "ALARM" : "" ); 
    3426     } 
    3427   } else 
    3428     printf("ERROR: Can't get TEMP3 data!\n"); 
    3429   free(label); 
    3430  
    3431   if (!sensors_get_label_and_valid(*name,SENSORS_IT87_VID,&label,&valid) && 
    3432       !sensors_get_feature(*name,SENSORS_IT87_VID,&cur)) { 
    3433     if (valid) { 
    3434       print_label(label,10); 
    3435       printf("%+6.3f V\n", cur); 
    3436     } 
    3437   } 
    3438   free(label); 
    3439 } 
    3440  
    3441 void print_fscpos(const sensors_chip_name *name) 
    3442 { 
    3443   char *label; 
    3444   double voltage, temp, state, fan; 
    3445   int valid; 
    3446  
    3447   if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP1,&label,&valid) && 
    3448       !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP1,&temp) && 
    3449       !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP1_STATE,&state)) {  
    3450     if (valid) { 
    3451       print_label(label,10); 
    3452         if((int) state & 0x01) 
    3453           printf("\t%+6.2f C\n", temp); 
    3454         else 
    3455           printf("\tfailed\n"); 
    3456     } 
    3457   } else 
    3458     printf("ERROR: Can't get TEMP1 data!\n"); 
    3459   free(label); 
    3460  
    3461   if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP2,&label,&valid) && 
    3462       !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP2,&temp) && 
    3463       !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP2_STATE,&state)) {  
    3464     if (valid) { 
    3465       print_label(label,10); 
    3466         if((int) state & 0x01) 
    3467           printf("\t%+6.2f C\n", temp); 
    3468         else 
    3469           printf("\tfailed\n"); 
    3470     } 
    3471   } else 
    3472     printf("ERROR: Can't get TEMP2 data!\n"); 
    3473   free(label); 
    3474  
    3475   if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_TEMP3,&label,&valid) && 
    3476       !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP3,&temp) && 
    3477       !sensors_get_feature(*name,SENSORS_FSCPOS_TEMP3_STATE,&state)) {  
    3478     if (valid) { 
    3479       print_label(label,10); 
    3480         if((int) state & 0x01) 
    3481           printf("\t%+6.2f C\n", temp); 
    3482         else 
    3483           printf("\tfailed\n"); 
    3484     } 
    3485   } else 
    3486     printf("ERROR: Can't get TEMP3 data!\n"); 
    3487   free(label); 
    3488  
    3489   if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN1,&label,&valid) && 
    3490       !sensors_get_feature(*name,SENSORS_FSCPOS_FAN1,&fan) && 
    3491       !sensors_get_feature(*name,SENSORS_FSCPOS_FAN1_STATE,&state)) {  
    3492     if (valid) { 
    3493       print_label(label,10); 
    3494         if((int) state & 0x04) 
    3495           printf("\tfaulty\n"); 
    3496         else 
    3497           printf("\t%6.0f RPM\n", fan); 
    3498     } 
    3499   } else 
    3500     printf("ERROR: Can't get FAN1 data!\n"); 
    3501   free(label); 
    3502  
    3503   if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN2,&label,&valid) && 
    3504       !sensors_get_feature(*name,SENSORS_FSCPOS_FAN2,&fan) && 
    3505       !sensors_get_feature(*name,SENSORS_FSCPOS_FAN2_STATE,&state)) {  
    3506     if (valid) { 
    3507       print_label(label,10); 
    3508         if((int) state & 0x04) 
    3509           printf("\tfaulty\n"); 
    3510         else 
    3511           printf("\t%6.0f RPM\n", fan); 
    3512     } 
    3513   } else 
    3514     printf("ERROR: Can't get FAN2 data!\n"); 
    3515   free(label); 
    3516  
    3517   if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_FAN3,&label,&valid) && 
    3518       !sensors_get_feature(*name,SENSORS_FSCPOS_FAN3,&fan) && 
    3519       !sensors_get_feature(*name,SENSORS_FSCPOS_FAN3_STATE,&state)) {  
    3520     if (valid) { 
    3521       print_label(label,10); 
    3522         if((int) state & 0x04) 
    3523           printf("\tfaulty\n"); 
    3524         else 
    3525           printf("\t%6.0f RPM\n", fan); 
    3526     } 
    3527   } else 
    3528     printf("ERROR: Can't get FAN3 data!\n"); 
    3529   free(label); 
    3530  
    3531   if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE1,&label,&valid) && 
    3532       !sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE1,&voltage)) { 
    3533     if (valid) { 
    3534       print_label(label,10); 
    3535       printf("\t%+6.2f V\n",voltage); 
    3536     } 
    3537   } else 
    3538     printf("ERROR: Can't get IN0 data!\n"); 
    3539   free(label); 
    3540  
    3541   if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE2,&label,&valid) && 
    3542       !sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE2,&voltage)) { 
    3543     if (valid) { 
    3544       print_label(label,10); 
    3545       printf("\t%+6.2f V\n",voltage); 
    3546     } 
    3547   } else 
    3548     printf("ERROR: Can't get IN1 data!\n"); 
    3549   free(label); 
    3550  
    3551   if (!sensors_get_label_and_valid(*name,SENSORS_FSCPOS_VOLTAGE3,&label,&valid) && 
    3552       !sensors_get_feature(*name,SENSORS_FSCPOS_VOLTAGE3,&voltage)) { 
    3553     if (valid) { 
    3554       print_label(label,10); 
    3555       printf("\t%+6.2f V\n",voltage); 
    3556     } 
    3557   } else 
    3558     printf("ERROR: Can't get IN2 data!\n"); 
    3559   free(label); 
    3560 } 
    3561  
    3562 void print_fscscy(const sensors_chip_name *name) 
    3563 { 
    3564   char *label; 
    3565   double voltage, temp, tempmin, tempmax, templim, state, fan; 
    3566   int valid; 
    3567  
    3568   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP1,&label,&valid) && 
    3569       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1,&temp) && 
    3570       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_LIM,&templim) && 
    3571       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_MIN,&tempmin) && 
    3572       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_MAX,&tempmax) && 
    3573       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP1_STATE,&state)) {  
    3574     if (valid) { 
    3575       print_label(label,10); 
    3576         if((int) state & 0x01) 
    3577           printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n", 
    3578                 temp,tempmin,tempmax,templim); 
    3579         else 
    3580           printf("\tfailed\n"); 
    3581     } 
    3582   } else 
    3583     printf("ERROR: Can't get TEMP1 data!\n"); 
    3584   free(label); 
    3585  
    3586   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP2,&label,&valid) && 
    3587       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2,&temp) && 
    3588       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_LIM,&templim) && 
    3589       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_MIN,&tempmin) && 
    3590       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_MAX,&tempmax) && 
    3591       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP2_STATE,&state)) {  
    3592     if (valid) { 
    3593       print_label(label,10); 
    3594         if((int) state & 0x01) 
    3595           printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n", 
    3596                 temp,tempmin,tempmax,templim); 
    3597         else 
    3598           printf("\tfailed\n"); 
    3599     } 
    3600   } else 
    3601     printf("ERROR: Can't get TEMP2 data!\n"); 
    3602   free(label); 
    3603  
    3604   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP3,&label,&valid) && 
    3605       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3,&temp) && 
    3606       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_LIM,&templim) && 
    3607       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_MIN,&tempmin) && 
    3608       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_MAX,&tempmax) && 
    3609       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP3_STATE,&state)) {  
    3610     if (valid) { 
    3611       print_label(label,10); 
    3612         if((int) state & 0x01) 
    3613           printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n", 
    3614                 temp,tempmin,tempmax,templim); 
    3615         else 
    3616           printf("\tfailed\n"); 
    3617     } 
    3618   } else 
    3619     printf("ERROR: Can't get TEMP3 data!\n"); 
    3620   free(label); 
    3621  
    3622   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_TEMP4,&label,&valid) && 
    3623       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4,&temp) && 
    3624       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_LIM,&templim) && 
    3625       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_MIN,&tempmin) && 
    3626       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_MAX,&tempmax) && 
    3627       !sensors_get_feature(*name,SENSORS_FSCSCY_TEMP4_STATE,&state)) {  
    3628     if (valid) { 
    3629       print_label(label,10); 
    3630         if((int) state & 0x01) 
    3631           printf("\t%+6.2f C (Min = %+6.2f C, Max = %+6.2f C, Lim = %+6.2f C)\n", 
    3632                 temp,tempmin,tempmax,templim); 
    3633         else 
    3634           printf("\tfailed\n"); 
    3635     } 
    3636   } else 
    3637     printf("ERROR: Can't get TEMP4 data!\n"); 
    3638   free(label); 
    3639  
    3640   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN1,&label,&valid) && 
    3641       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN1,&fan) && 
    3642       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN1_STATE,&state)) {  
    3643     if (valid) { 
    3644       print_label(label,10); 
    3645         if((int) state & 0x02) 
    3646           printf("\tfaulty\n"); 
    3647         else 
    3648           printf("\t%6.0f RPM\n", fan); 
    3649     } 
    3650   } else 
    3651     printf("ERROR: Can't get FAN1 data!\n"); 
    3652   free(label); 
    3653  
    3654   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN2,&label,&valid) && 
    3655       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN2,&fan) && 
    3656       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN2_STATE,&state)) {  
    3657     if (valid) { 
    3658       print_label(label,10); 
    3659         if((int) state & 0x02) 
    3660           printf("\tfaulty\n"); 
    3661         else 
    3662           printf("\t%6.0f RPM\n", fan); 
    3663     } 
    3664   } else 
    3665     printf("ERROR: Can't get FAN2 data!\n"); 
    3666   free(label); 
    3667  
    3668   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN3,&label,&valid) && 
    3669       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN3,&fan) && 
    3670       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN3_STATE,&state)) {  
    3671     if (valid) { 
    3672       print_label(label,10); 
    3673         if((int) state & 0x02) 
    3674           printf("\tfaulty\n"); 
    3675         else 
    3676           printf("\t%6.0f RPM\n", fan); 
    3677     } 
    3678   } else 
    3679     printf("ERROR: Can't get FAN3 data!\n"); 
    3680   free(label); 
    3681  
    3682   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN4,&label,&valid) && 
    3683       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN4,&fan) && 
    3684       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN4_STATE,&state)) {  
    3685     if (valid) { 
    3686       print_label(label,10); 
    3687         if((int) state & 0x02) 
    3688           printf("\tfaulty\n"); 
    3689         else 
    3690           printf("\t%6.0f RPM\n", fan); 
    3691     } 
    3692   } else 
    3693     printf("ERROR: Can't get FAN4 data!\n"); 
    3694   free(label); 
    3695  
    3696   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN5,&label,&valid) && 
    3697       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN5,&fan) && 
    3698       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN5_STATE,&state)) {  
    3699     if (valid) { 
    3700       print_label(label,10); 
    3701         if((int) state & 0x02) 
    3702           printf("\tfaulty\n"); 
    3703         else 
    3704           printf("\t%6.0f RPM\n", fan); 
    3705     } 
    3706   } else 
    3707     printf("ERROR: Can't get FAN5 data!\n"); 
    3708   free(label); 
    3709  
    3710   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_FAN6,&label,&valid) && 
    3711       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN6,&fan) && 
    3712       !sensors_get_feature(*name,SENSORS_FSCSCY_FAN6_STATE,&state)) {  
    3713     if (valid) { 
    3714       print_label(label,10); 
    3715         if((int) state & 0x02) 
    3716           printf("\tfaulty\n"); 
    3717         else 
    3718           printf("\t%6.0f RPM\n", fan); 
    3719     } 
    3720   } else 
    3721     printf("ERROR: Can't get FAN6 data!\n"); 
    3722   free(label); 
    3723  
    3724   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE1,&label,&valid) && 
    3725       !sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE1,&voltage)) { 
    3726     if (valid) { 
    3727       print_label(label,10); 
    3728       printf("\t%+6.2f V\n",voltage); 
    3729     } 
    3730   } else 
    3731     printf("ERROR: Can't get IN0 data!\n"); 
    3732   free(label); 
    3733  
    3734   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE2,&label,&valid) && 
    3735       !sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE2,&voltage)) { 
    3736     if (valid) { 
    3737       print_label(label,10); 
    3738       printf("\t%+6.2f V\n",voltage); 
    3739     } 
    3740   } else 
    3741     printf("ERROR: Can't get IN1 data!\n"); 
    3742   free(label); 
    3743  
    3744   if (!sensors_get_label_and_valid(*name,SENSORS_FSCSCY_VOLTAGE3,&label,&valid) && 
    3745       !sensors_get_feature(*name,SENSORS_FSCSCY_VOLTAGE3,&voltage)) { 
    3746     if (valid) { 
    3747       print_label(label,10); 
    3748       printf("\t%+6.2f V\n",voltage); 
    3749     } 
    3750   } else 
    3751     printf("ERROR: Can't get IN2 data!\n"); 
    3752   free(label); 
    3753 } 
    3754  
    3755 void print_fscher(const sensors_chip_name *name) 
    3756 { 
    3757   char *label; 
    3758   double voltage, temp, state, fan; 
    3759   int valid; 
    3760    
    3761   if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP1,&label,&valid) 
    3762       && !sensors_get_feature(*name,SENSORS_FSCHER_TEMP1,&temp) 
    3763       && !sensors_get_feature(*name,SENSORS_FSCHER_TEMP1_STATE,&state)) {  
    3764     if (valid) { 
    3765       print_label(label,10); 
    3766       if((int) state & 0x01) 
    3767         printf("\t%+6.2f C\n", temp); 
    3768       else 
    3769         printf("\tfailed\n"); 
    3770     } 
    3771   } else 
    3772     printf("ERROR: Can't get TEMP1 data!\n"); 
    3773   free(label); 
    3774  
    3775   if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP2,&label,&valid) 
    3776       && !sensors_get_feature(*name,SENSORS_FSCHER_TEMP2,&temp) 
    3777       && !sensors_get_feature(*name,SENSORS_FSCHER_TEMP2_STATE,&state)) {  
    3778     if (valid) { 
    3779       print_label(label,10); 
    3780       if((int) state & 0x01) 
    3781         printf("\t%+6.2f C\n", temp); 
    3782       else 
    3783         printf("\tfailed\n"); 
    3784     } 
    3785   } else 
    3786     printf("ERROR: Can't get TEMP2 data!\n"); 
    3787   free(label); 
    3788  
    3789   if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_TEMP3,&label,&valid) 
    3790       && !sensors_get_feature(*name,SENSORS_FSCHER_TEMP3,&temp) 
    3791       && !sensors_get_feature(*name,SENSORS_FSCHER_TEMP3_STATE,&state)) {  
    3792     if (valid) { 
    3793       print_label(label,10); 
    3794       if((int) state & 0x01) 
    3795         printf("\t%+6.2f C\n", temp); 
    3796       else 
    3797         printf("\tfailed\n"); 
    3798     } 
    3799   } else 
    3800     printf("ERROR: Can't get TEMP3 data!\n"); 
    3801   free(label); 
    3802  
    3803   if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN1,&label,&valid) 
    3804       && !sensors_get_feature(*name,SENSORS_FSCHER_FAN1,&fan) 
    3805       && !sensors_get_feature(*name,SENSORS_FSCHER_FAN1_STATE,&state)) {  
    3806     if (valid) { 
    3807       print_label(label,10); 
    3808       if((int) state & 0x04) 
    3809         printf("\tfaulty\n"); 
    3810       else 
    3811         printf("\t%6.0f RPM\n", fan); 
    3812     } 
    3813   } else 
    3814     printf("ERROR: Can't get FAN1 data!\n"); 
    3815   free(label); 
    3816  
    3817   if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN2,&label,&valid) 
    3818       && !sensors_get_feature(*name,SENSORS_FSCHER_FAN2,&fan) 
    3819       && !sensors_get_feature(*name,SENSORS_FSCHER_FAN2_STATE,&state)) {  
    3820     if (valid) { 
    3821       print_label(label,10); 
    3822       if((int) state & 0x04) 
    3823         printf("\tfaulty\n"); 
    3824       else 
    3825         printf("\t%6.0f RPM\n", fan); 
    3826     } 
    3827   } else 
    3828     printf("ERROR: Can't get FAN2 data!\n"); 
    3829   free(label); 
    3830  
    3831   if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_FAN3,&label,&valid) 
    3832       && !sensors_get_feature(*name,SENSORS_FSCHER_FAN3,&fan) 
    3833       && !sensors_get_feature(*name,SENSORS_FSCHER_FAN3_STATE,&state)) {  
    3834     if (valid) { 
    3835       print_label(label,10); 
    3836       if((int) state & 0x04) 
    3837         printf("\tfaulty\n"); 
    3838       else 
    3839         printf("\t%6.0f RPM\n", fan); 
    3840     } 
    3841   } else 
    3842     printf("ERROR: Can't get FAN3 data!\n"); 
    3843   free(label); 
    3844  
    3845   if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE1,&label,&valid) 
    3846       && !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE1,&voltage)) { 
    3847     if (valid) { 
    3848       print_label(label,10); 
    3849       printf("\t%+6.2f V\n",voltage); 
    3850     } 
    3851   } else 
    3852     printf("ERROR: Can't get IN0 data!\n"); 
    3853   free(label); 
    3854  
    3855   if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE2,&label,&valid) 
    3856       && !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE2,&voltage)) { 
    3857     if (valid) { 
    3858       print_label(label,10); 
    3859       printf("\t%+6.2f V\n",voltage); 
    3860     } 
    3861   } else 
    3862     printf("ERROR: Can't get IN1 data!\n"); 
    3863   free(label); 
    3864  
    3865   if (!sensors_get_label_and_valid(*name,SENSORS_FSCHER_VOLTAGE3,&label,&valid) 
    3866       && !sensors_get_feature(*name,SENSORS_FSCHER_VOLTAGE3,&voltage)) { 
    3867     if (valid) { 
    3868       print_label(label,10); 
    3869       printf("\t%+6.2f V\n",voltage); 
    3870     } 
    3871   } else 
    3872     printf("ERROR: Can't get IN2 data!\n"); 
    3873   free(label); 
    3874 } 
    3875  
    3876 void print_pcf8591(const sensors_chip_name *name) 
    3877 { 
    3878   char *label; 
    3879   int ain_conf = -1; 
    3880   double ain; 
    3881   double aout_enable, aout; 
    3882   int valid; 
    3883  
    3884   if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_AIN_CONF,&label,&valid) && 
    3885       !sensors_get_feature(*name, SENSORS_PCF8591_AIN_CONF, &ain)) { 
    3886         ain_conf = (int)ain; 
    3887         if (valid) { 
    3888           print_label(label,10); 
    3889           switch (ain_conf) 
    3890           { 
    3891             case 0: printf("four single ended inputs\n"); 
    3892                     break; 
    3893             case 1: printf("three differential inputs\n"); 
    3894                     break; 
    3895             case 2: printf("single ended and differential mixed\n"); 
    3896                     break; 
    3897             case 3: printf("two differential inputs\n"); 
    3898                     break; 
    3899           } 
    3900         } 
    3901       } 
    3902   /* display no error, 2.6 driver doesn't have that file */ 
    3903   free(label); 
    3904  
    3905   if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH0,&label,&valid) && 
    3906       !sensors_get_feature(*name, SENSORS_PCF8591_CH0, &ain)) { 
    3907         if (valid) { 
    3908           print_label(label,10); 
    3909           printf("%6.2f V\n", ain); 
    3910         } 
    3911       } 
    3912   else printf("ERROR: Can't read ch0!\n"); 
    3913   free(label); 
    3914  
    3915   if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH1,&label,&valid) && 
    3916       !sensors_get_feature(*name, SENSORS_PCF8591_CH1, &ain)) { 
    3917         if (valid) { 
    3918           print_label(label,10); 
    3919           printf("%6.2f V\n", ain); 
    3920         } 
    3921       } 
    3922   else printf("ERROR: Can't read ch1!\n"); 
    3923   free(label); 
    3924  
    3925   if (ain_conf != 3) { 
    3926     if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH2,&label,&valid) && 
    3927         !sensors_get_feature(*name, SENSORS_PCF8591_CH2, &ain)) { 
    3928           if (valid) { 
    3929             print_label(label,10); 
    3930             printf("%6.2f V\n", ain); 
    3931           } 
    3932         } 
    3933     else if (ain_conf >= 0) /* hide error for 2.6 kernel driver */ 
    3934       printf("ERROR: Can't read ch2!\n"); 
    3935     free(label); 
    3936   } 
    3937  
    3938   if (ain_conf <= 0) { 
    3939     if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_CH3,&label,&valid) && 
    3940         !sensors_get_feature(*name, SENSORS_PCF8591_CH3, &ain)) { 
    3941           if (valid) { 
    3942             print_label(label,10); 
    3943             printf("%6.2f V\n", ain); 
    3944           } 
    3945         } 
    3946     else if (ain_conf >= 0) /* hide error for 2.6 kernel driver */ 
    3947       printf("ERROR: Can't read ch3!\n"); 
    3948     free(label); 
    3949   } 
    3950  
    3951   if (!sensors_get_label_and_valid(*name,SENSORS_PCF8591_AOUT,&label,&valid) && 
    3952       !sensors_get_feature(*name,SENSORS_PCF8591_AOUT,&aout) && 
    3953       !sensors_get_feature(*name,SENSORS_PCF8591_AOUT_ENABLE,&aout_enable)) { 
    3954         if (valid) { 
    3955           print_label(label,10); 
    3956           printf("%6.2f V (%s)\n", aout, aout_enable?"enabled":"disabled"); 
    3957         } 
    3958       } 
    3959   else printf("ERROR: Can't read aout!\n"); 
    3960   free(label); 
    3961  
    3962 } 
    3963  
    3964 void print_vt1211(const sensors_chip_name *name) 
    3965 { 
    3966   char *label; 
    3967   double cur,min,max,fdiv; 
    3968   int alarms,valid; 
    3969   int err; 
    3970  
    3971   /* per vt1211.c driver, temps 1,5,6,7 and inputs 0,1,6 are optional */ 
    3972   /* supress error messages reading from them */ 
    3973  
    3974   if (!sensors_get_feature(*name,SENSORS_VT1211_ALARMS,&cur))  
    3975     alarms = cur + 0.5; 
    3976   else { 
    3977     printf("ERROR: Can't get alarm data!\n"); 
    3978     alarms = 0; 
    3979   } 
    3980  
    3981   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN0,&label,&valid)) { 
    3982     printf("ERROR: Can't get IN0 config!\n"); 
    3983   } else if (valid) { 
    3984     if (!(err = sensors_get_feature(*name,SENSORS_VT1211_IN0,&cur)) && 
    3985         !(err = sensors_get_feature(*name,SENSORS_VT1211_IN0_MIN,&min)) && 
    3986         !(err = sensors_get_feature(*name,SENSORS_VT1211_IN0_MAX,&max))) { 
    3987       print_label(label,10); 
    3988       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    3989              cur,min,max,alarms&VT1211_ALARM_IN0?"ALARM":""); 
    3990     } else if (err != -SENSORS_ERR_PROC) 
    3991       printf("ERROR: Can't get IN0 data!\n"); 
    3992   } 
    3993   free(label); 
    3994   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN1,&label,&valid)) { 
    3995     printf("ERROR: Can't get IN1 config!\n"); 
    3996   } else if (valid) { 
    3997     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_IN1,&cur)) && 
    3998        !(err = sensors_get_feature(*name,SENSORS_VT1211_IN1_MIN,&min)) && 
    3999        !(err = sensors_get_feature(*name,SENSORS_VT1211_IN1_MAX,&max))) { 
    4000       print_label(label,10); 
    4001       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4002              cur,min,max,alarms&VT1211_ALARM_IN1?"ALARM":""); 
    4003     } else if (err != -SENSORS_ERR_PROC) 
    4004       printf("ERROR: Can't get IN1 data!\n"); 
    4005   } 
    4006   free(label); 
    4007   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN2,&label,&valid)) { 
    4008     printf("ERROR: Can't get IN2 config!\n"); 
    4009   } else if (valid) { 
    4010     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_IN2,&cur)) && 
    4011        !(err = sensors_get_feature(*name,SENSORS_VT1211_IN2_MIN,&min)) && 
    4012        !(err = sensors_get_feature(*name,SENSORS_VT1211_IN2_MAX,&max))) { 
    4013       print_label(label,10); 
    4014       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4015              cur,min,max,alarms&VT1211_ALARM_IN2?"ALARM":""); 
    4016     } else if (err != -SENSORS_ERR_PROC) 
    4017       printf("ERROR: Can't get IN2 data!\n"); 
    4018   } 
    4019   free(label); 
    4020   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN3,&label,&valid)) { 
    4021     printf("ERROR: Can't get IN3 config!\n"); 
    4022   } else if (valid) { 
    4023     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_IN3,&cur)) && 
    4024        !(err = sensors_get_feature(*name,SENSORS_VT1211_IN3_MIN,&min)) && 
    4025        !(err = sensors_get_feature(*name,SENSORS_VT1211_IN3_MAX,&max))) { 
    4026       print_label(label,10); 
    4027       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4028              cur,min,max,alarms&VT1211_ALARM_IN3?"ALARM":""); 
    4029     } else if (err != -SENSORS_ERR_PROC) 
    4030       printf("ERROR: Can't get IN3 data!\n"); 
    4031   } 
    4032   free(label); 
    4033   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN4,&label,&valid)) { 
    4034     printf("ERROR: Can't get IN4 config!\n"); 
    4035   } else if (valid) { 
    4036     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_IN4,&cur)) && 
    4037        !(err = sensors_get_feature(*name,SENSORS_VT1211_IN4_MIN,&min)) && 
    4038        !(err = sensors_get_feature(*name,SENSORS_VT1211_IN4_MAX,&max))) { 
    4039       print_label(label,10); 
    4040       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4041              cur,min,max,alarms&VT1211_ALARM_IN4?"ALARM":""); 
    4042     } else if (err != -SENSORS_ERR_PROC) 
    4043       printf("ERROR: Can't get IN4 data!\n"); 
    4044   } 
    4045   free(label); 
    4046   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_IN5,&label,&valid)) { 
    4047     printf("ERROR: Can't get IN5 config!\n"); 
    4048   } else if (valid) { 
    4049     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_IN5,&cur)) && 
    4050        !(err = sensors_get_feature(*name,SENSORS_VT1211_IN5_MIN,&min)) && 
    4051        !(err = sensors_get_feature(*name,SENSORS_VT1211_IN5_MAX,&max))) { 
    4052       print_label(label,10); 
    4053       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4054              cur,min,max,alarms&VT1211_ALARM_IN5?"ALARM":""); 
    4055     } 
    4056   } 
    4057   free(label); 
    4058  
    4059   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_FAN1,&label,&valid)) { 
    4060     printf("ERROR: Can't get FAN1 config!\n"); 
    4061   } else if (valid) { 
    4062     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_FAN1,&cur)) && 
    4063        !(err = sensors_get_feature(*name,SENSORS_VT1211_FAN1_DIV,&fdiv)) && 
    4064        !(err = sensors_get_feature(*name,SENSORS_VT1211_FAN1_MIN,&min))) { 
    4065       print_label(label,10); 
    4066       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    4067              cur,min,fdiv, alarms&VT1211_ALARM_FAN1?"ALARM":""); 
    4068     } else 
    4069       printf("ERROR: Can't get FAN1 data!\n"); 
    4070   } 
    4071   free(label); 
    4072   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_FAN2,&label,&valid)) { 
    4073     printf("ERROR: Can't get FAN2 config!\n"); 
    4074   } else if (valid) { 
    4075     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_FAN2,&cur)) && 
    4076        !(err = sensors_get_feature(*name,SENSORS_VT1211_FAN2_DIV,&fdiv)) && 
    4077        !(err = sensors_get_feature(*name,SENSORS_VT1211_FAN2_MIN,&min))) { 
    4078       print_label(label,10); 
    4079       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    4080              cur,min,fdiv, alarms&VT1211_ALARM_FAN2?"ALARM":""); 
    4081     } else 
    4082       printf("ERROR: Can't get FAN2 data!\n"); 
    4083   } 
    4084   free(label); 
    4085  
    4086   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP1,&label,&valid)) { 
    4087     printf("ERROR: Can't get TEMP1 config!\n"); 
    4088   } else if (valid) { 
    4089     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP1,&cur)) && 
    4090        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP1_HYST,&min)) && 
    4091        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP1_OVER,&max))) { 
    4092       print_label(label,10); 
    4093       print_temp_info( cur, max, min, HYST, 1, 0); 
    4094       printf(" %s\n", alarms & VT1211_ALARM_TEMP1 ? "ALARM" : "" ); 
    4095     } else 
    4096       printf("ERROR: Can't get TEMP1 data!\n"); 
    4097   } 
    4098   free(label); 
    4099   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP2,&label,&valid)) { 
    4100     printf("ERROR: Can't get TEMP2 config!\n"); 
    4101   } else if (valid) { 
    4102     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP2,&cur)) && 
    4103        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP2_HYST,&min)) && 
    4104        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP2_OVER,&max))) { 
    4105       print_label(label,10); 
    4106       print_temp_info( cur, max, min, HYST, 1, 0); 
    4107       printf(" %s\n", alarms & VT1211_ALARM_TEMP2 ? "ALARM" : "" ); 
    4108     } else 
    4109       printf("ERROR: Can't get TEMP2 data!\n"); 
    4110   } 
    4111   free(label); 
    4112   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP3,&label,&valid)) { 
    4113     printf("ERROR: Can't get TEMP3 config!\n"); 
    4114   } else if (valid) { 
    4115     if (!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP3,&cur)) && 
    4116         !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP3_HYST,&min)) && 
    4117         !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP3_OVER,&max))) { 
    4118       print_label(label,10); 
    4119       print_temp_info( cur, max, min, HYST, 1, 0); 
    4120       printf(" %s\n", alarms & VT1211_ALARM_TEMP3 ? "ALARM" : "" ); 
    4121     } else if (err != -SENSORS_ERR_PROC) 
    4122       printf("ERROR: Can't get TEMP3 data!\n"); 
    4123   } 
    4124   free(label); 
    4125   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP4,&label,&valid)) { 
    4126     printf("ERROR: Can't get TEMP4 config!\n"); 
    4127   } else if (valid) { 
    4128     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP4,&cur)) && 
    4129        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP4_HYST,&min)) && 
    4130        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP4_OVER,&max))) { 
    4131       print_label(label,10); 
    4132       print_temp_info( cur, max, min, HYST, 1, 0); 
    4133       printf(" %s\n", alarms & VT1211_ALARM_TEMP4 ? "ALARM" : "" ); 
    4134     } else if (err != -SENSORS_ERR_PROC) 
    4135       printf("ERROR: Can't get TEMP4 data!\n"); 
    4136   } 
    4137   free(label); 
    4138   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP5,&label,&valid)) { 
    4139     printf("ERROR: Can't get TEMP5 config!\n"); 
    4140   } else if (valid) { 
    4141     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP5,&cur)) && 
    4142        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP5_HYST,&min)) && 
    4143        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP5_OVER,&max))) { 
    4144       print_label(label,10); 
    4145       print_temp_info( cur, max, min, HYST, 1, 0); 
    4146       printf(" %s\n", alarms & VT1211_ALARM_TEMP5 ? "ALARM" : "" ); 
    4147     } else if (err != -SENSORS_ERR_PROC) 
    4148       printf("ERROR: Can't get TEMP5 data!\n"); 
    4149   } 
    4150   free(label); 
    4151   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP6,&label,&valid)) { 
    4152     printf("ERROR: Can't get TEMP6 config!\n"); 
    4153   } else if (valid) { 
    4154     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP6,&cur)) && 
    4155        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP6_HYST,&min)) && 
    4156        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP6_OVER,&max))) { 
    4157       print_label(label,10); 
    4158       print_temp_info( cur, max, min, HYST, 1, 0); 
    4159       printf(" %s\n", alarms & VT1211_ALARM_TEMP6 ? "ALARM" : "" ); 
    4160     } else if (err != -SENSORS_ERR_PROC) 
    4161       printf("ERROR: Can't get TEMP6 data!\n"); 
    4162   } 
    4163   free(label); 
    4164   if (sensors_get_label_and_valid(*name,SENSORS_VT1211_TEMP7,&label,&valid)) { 
    4165     printf("ERROR: Can't get TEMP7 config!\n"); 
    4166   } else if (valid) { 
    4167     if(!(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP7,&cur)) && 
    4168        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP7_HYST,&min)) && 
    4169        !(err = sensors_get_feature(*name,SENSORS_VT1211_TEMP7_OVER,&max))) { 
    4170       print_label(label,10); 
    4171       print_temp_info( cur, max, min, HYST, 1, 0); 
    4172       printf(" %s\n", alarms & VT1211_ALARM_TEMP7 ? "ALARM" : "" ); 
    4173     } else if (err != -SENSORS_ERR_PROC) 
    4174       printf("ERROR: Can't get TEMP7 data!\n"); 
    4175   } 
    4176   free(label); 
    4177  
    4178   print_vid_info(name, SENSORS_VT1211_VID, SENSORS_VT1211_VRM); 
    4179 } 
    4180  
    4181 void print_smsc47m1(const sensors_chip_name *name) 
    4182 { 
    4183   char *label; 
    4184   double cur, min, fdiv; 
    4185   int alarms, valid, i; 
    4186   int is_m2 = !strcmp(name->prefix, "smsc47m2"); 
    4187  
    4188   if (!sensors_get_feature(*name,SENSORS_SMSC47M1_ALARMS,&cur))  
    4189     alarms = cur + 0.5; 
    4190   else { 
    4191     printf("ERROR: Can't get alarm data!\n"); 
    4192     alarms = 0; 
    4193   } 
    4194  
    4195   for (i = 0; i < (is_m2 ? 3 : 2); i++) { /* 2 or 3 fans */ 
    4196     if (!sensors_get_label_and_valid(*name, SENSORS_SMSC47M1_FAN1+i, &label, &valid) 
    4197      && !sensors_get_feature(*name, SENSORS_SMSC47M1_FAN1+i, &cur) 
    4198      && !sensors_get_feature(*name, SENSORS_SMSC47M1_FAN1_DIV+i, &fdiv) 
    4199      && !sensors_get_feature(*name, SENSORS_SMSC47M1_FAN1_MIN+i, &min)) { 
    4200       if (valid) { 
    4201         print_label(label, 10); 
    4202         printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    4203                cur, min, fdiv, alarms&(SMSC47M1_ALARM_FAN1<<i) ? 
    4204                "ALARM" : ""); 
    4205       } 
    4206     } 
    4207     /* In Linux 2.6, the original chip configuration is respected, so channels 
    4208        may be missing without it being considered an error; thus we don't 
    4209        print any error if this happens. */ 
    4210     free(label); 
    4211   } 
    4212 } 
    4213  
    4214 void print_smsc47m192(const sensors_chip_name *name) 
    4215 { 
    4216   char *label; 
    4217   double cur, min, max; 
    4218   int valid, i; 
    4219  
    4220   for (i=0; i<8; i++) { 
    4221     if (!sensors_get_label_and_valid(*name, SENSORS_SMSC47M192_IN(i), 
    4222                                      &label, &valid) && 
    4223         !sensors_get_feature(*name, SENSORS_SMSC47M192_IN(i), &cur) && 
    4224         !sensors_get_feature(*name, SENSORS_SMSC47M192_IN_MIN(i), &min) && 
    4225         !sensors_get_feature(*name, SENSORS_SMSC47M192_IN_MAX(i), &max)) { 
    4226       if (valid) { 
    4227         print_label(label,10); 
    4228         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   ", cur, min, max); 
    4229         if (!sensors_get_feature(*name, SENSORS_SMSC47M192_IN_ALARM(i), &cur)) 
    4230           if (cur > 0.5) 
    4231             printf("ALARM"); 
    4232         printf("\n"); 
    4233       } 
    4234     } else 
    4235       if (i!=4) /* Chip may have +12V input used for VID instead */ 
    4236         printf("ERROR: Can't get IN%d data!\n", i); 
    4237     free(label); 
    4238   } 
    4239   for (i=1; i<=3; i++) { 
    4240     if (!sensors_get_label_and_valid(*name, SENSORS_SMSC47M192_TEMP(i), 
    4241                                      &label, &valid) && 
    4242         !sensors_get_feature(*name, SENSORS_SMSC47M192_TEMP(i), &cur) && 
    4243         !sensors_get_feature(*name, SENSORS_SMSC47M192_TEMP_MIN(i), &min) && 
    4244         !sensors_get_feature(*name, SENSORS_SMSC47M192_TEMP_MAX(i), &max)) { 
    4245       if (valid) { 
    4246         print_label(label,10); 
    4247         print_temp_info( cur, max, min, MINMAX, 1, 0); 
    4248         if (i > 1 && !sensors_get_feature(*name, 
    4249                                 SENSORS_SMSC47M192_TEMP_FAULT(i), &cur)) { 
    4250            if (cur > 0.5) 
    4251              printf("FAULT"); 
    4252         } else 
    4253         if (!sensors_get_feature(*name, SENSORS_SMSC47M192_TEMP_ALARM(i), &cur)) 
    4254           if (cur > 0.5) 
    4255             printf("ALARM"); 
    4256         printf("\n"); 
    4257       } 
    4258     } else 
    4259       printf("ERROR: Can't get TEMP%d data!\n", i); 
    4260     free(label); 
    4261   } 
    4262   print_vid_info(name, SENSORS_SMSC47M192_VID, SENSORS_SMSC47M192_VRM); 
    4263 } 
    4264  
    4265 void print_pc87360(const sensors_chip_name *name) 
    4266 { 
    4267   char *label; 
    4268   double cur, min, fdiv, tmp; 
    4269   int status, valid; 
    4270  
    4271   if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_FAN1, &label, &valid) 
    4272    && !sensors_get_feature(*name, SENSORS_PC87360_FAN1, &cur) 
    4273    && !sensors_get_feature(*name, SENSORS_PC87360_FAN1_DIV, &fdiv) 
    4274    && !sensors_get_feature(*name, SENSORS_PC87360_FAN1_MIN, &min) 
    4275    && !sensors_get_feature(*name, SENSORS_PC87360_FAN1_STATUS, &tmp)) { 
    4276     if (valid) { 
    4277       print_label(label, 10); 
    4278       status = tmp + 0.5; 
    4279       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    4280              cur, min, fdiv, 
    4281              status&PC87360_STATUS_FAN_OVERFLOW?"OVERFLOW": 
    4282              status&PC87360_STATUS_FAN_LOW?"ALARM":""); 
    4283     } 
    4284   } 
    4285   free(label); 
    4286  
    4287   if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_FAN2, &label, &valid) 
    4288    && !sensors_get_feature(*name, SENSORS_PC87360_FAN2, &cur) 
    4289    && !sensors_get_feature(*name, SENSORS_PC87360_FAN2_DIV, &fdiv) 
    4290    && !sensors_get_feature(*name, SENSORS_PC87360_FAN2_MIN, &min) 
    4291    && !sensors_get_feature(*name, SENSORS_PC87360_FAN2_STATUS, &tmp)) { 
    4292     if (valid) { 
    4293       print_label(label, 10); 
    4294       status = tmp + 0.5; 
    4295       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    4296              cur, min, fdiv, 
    4297              status&PC87360_STATUS_FAN_OVERFLOW?"OVERFLOW": 
    4298              status&PC87360_STATUS_FAN_LOW?"ALARM":""); 
    4299     } 
    4300   } 
    4301   free(label); 
    4302 } 
    4303  
    4304 void print_pc87364(const sensors_chip_name *name) 
    4305 { 
    4306   char *label; 
    4307   double cur, min, fdiv, tmp; 
    4308   int status, valid; 
    4309  
    4310   print_pc87360(name); 
    4311  
    4312   if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_FAN3, &label, &valid) 
    4313    && !sensors_get_feature(*name, SENSORS_PC87360_FAN3, &cur) 
    4314    && !sensors_get_feature(*name, SENSORS_PC87360_FAN3_DIV, &fdiv) 
    4315    && !sensors_get_feature(*name, SENSORS_PC87360_FAN3_MIN, &min) 
    4316    && !sensors_get_feature(*name, SENSORS_PC87360_FAN3_STATUS, &tmp)) { 
    4317     if (valid) { 
    4318       print_label(label, 10); 
    4319       status = tmp + 0.5; 
    4320       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    4321              cur, min, fdiv, 
    4322              status&PC87360_STATUS_FAN_OVERFLOW?"OVERFLOW": 
    4323              status&PC87360_STATUS_FAN_LOW?"ALARM":""); 
    4324     } 
    4325   } 
    4326   free(label); 
    4327 } 
    4328  
    4329 void print_pc87366(const sensors_chip_name *name) 
    4330 { 
    4331   char *label; 
    4332   double cur, min, max; 
    4333   int status, valid, i, tempnr = 2; 
    4334  
    4335   for (i = 0; i < 11; i++) { 
    4336     if (!sensors_get_feature(*name, SENSORS_PC87360_IN0_STATUS + i, &cur)) 
    4337       status = cur + 0.5; 
    4338     else { 
    4339       printf("ERROR: Can't get IN%d status data!\n", i); 
    4340       status = 0; 
    4341     } 
    4342  
    4343     if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_IN0 + i, &label, &valid) 
    4344      && !sensors_get_feature(*name, SENSORS_PC87360_IN0 + i, &cur) 
    4345      && !sensors_get_feature(*name, SENSORS_PC87360_IN0_MIN + i, &min) 
    4346      && !sensors_get_feature(*name, SENSORS_PC87360_IN0_MAX + i, &max)) { 
    4347       if (valid) { 
    4348         print_label(label, 10); 
    4349         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    4350                cur, min, max, 
    4351                status&(PC87365_STATUS_IN_MIN 
    4352                       |PC87365_STATUS_IN_MAX)?"ALARM":""); 
    4353       } 
    4354     } else 
    4355       printf("ERROR: Can't get IN%d data!\n", i); 
    4356     free(label); 
    4357   } 
    4358  
    4359   print_pc87364(name); 
    4360  
    4361   if (!strcmp(name->prefix, "pc87366")) 
    4362     tempnr = 6; 
    4363  
    4364   for (i = 0; i < tempnr; i++) { 
    4365     if (!sensors_get_feature(*name, SENSORS_PC87360_TEMP1_STATUS + i, &cur)) 
    4366       status = cur + 0.5; 
    4367     else { 
    4368       printf("ERROR: Can't get TEMP%d status data!\n", i + 1); 
    4369       status = 0; 
    4370     } 
    4371  
    4372     if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_TEMP1 + i, &label, &valid) 
    4373      && !sensors_get_feature(*name, SENSORS_PC87360_TEMP1 + i, &cur) 
    4374      && !sensors_get_feature(*name, SENSORS_PC87360_TEMP1_MIN + i, &min) 
    4375      && !sensors_get_feature(*name, SENSORS_PC87360_TEMP1_MAX + i, &max)) { 
    4376       if (valid) { 
    4377         print_label(label, 10); 
    4378         print_temp_info(cur, max, min, MINMAX, 0, 0); 
    4379         if (i<3 && status&PC87365_STATUS_TEMP_OPEN) 
    4380           printf(" OPEN"); 
    4381         else if (status&(PC87365_STATUS_TEMP_MIN|PC87365_STATUS_TEMP_MAX)) 
    4382           printf(" ALARM"); 
    4383         printf("\n"); 
    4384       } 
    4385     } else 
    4386       printf("ERROR: Can't get TEMP%d data!\n", i + 1); 
    4387     free(label); 
    4388  
    4389     if (!sensors_get_label_and_valid(*name, SENSORS_PC87360_TEMP1_CRIT + i, &label, &valid) 
    4390      && !sensors_get_feature(*name, SENSORS_PC87360_TEMP1_CRIT + i, &cur)) { 
    4391       if (valid) { 
    4392         print_label(label, 10); 
    4393         print_temp_info(cur, 0, 0, SINGLE, 0, 0); 
    4394         if (status&PC87365_STATUS_TEMP_CRIT) 
    4395           printf(" ALARM"); 
    4396         printf("\n"); 
    4397       } 
    4398     } else 
    4399       printf("ERROR: Can't get TEMP%d overtemperature data!\n", i + 1); 
    4400     free(label); 
    4401   } 
    4402    
    4403   print_vid_info(name, SENSORS_PC87360_VID, SENSORS_PC87360_VRM); 
    4404 } 
    4405  
    4406 void print_pc87427(const sensors_chip_name *name) 
    4407 { 
    4408   char *label; 
    4409   double cur, min, alarm, fault; 
    4410   int valid, i; 
    4411  
    4412   for (i = 1; i <= 8; i++) { 
    4413     if (!sensors_get_label_and_valid(*name, SENSORS_PC87427_FAN(i), 
    4414                                      &label, &valid) && 
    4415         !sensors_get_feature(*name, SENSORS_PC87427_FAN(i), &cur) && 
    4416         !sensors_get_feature(*name, SENSORS_PC87427_FAN_MIN(i), &min) && 
    4417         !sensors_get_feature(*name, SENSORS_PC87427_FAN_ALARM(i), &alarm) && 
    4418         !sensors_get_feature(*name, SENSORS_PC87427_FAN_FAULT(i), &fault)) { 
    4419       if (valid) { 
    4420         print_label(label, 10); 
    4421         printf("%4.0f RPM  (min = %4.0f RPM)          %s\n", 
    4422                cur, min, 
    4423                fault ? "FAULT" : alarm ? "ALARM" : ""); 
    4424       } 
    4425     } 
    4426   } 
    4427   free(label); 
    4428 } 
    4429  
    4430 static void lm92_print_temp (float n_cur,float n_high,float n_low,float n_crit,float n_hyst) 
    4431 { 
    4432         if (fahrenheit) { 
    4433                 n_cur = deg_ctof (n_cur); 
    4434                 n_high = deg_ctof (n_high); 
    4435                 n_low = deg_ctof (n_low); 
    4436                 n_crit = deg_ctof (n_crit); 
    4437                 n_hyst = deg_ctof (n_hyst); 
    4438         } 
    4439  
    4440         printf ("%+6.4f%s (high = %+6.4f%s, low = %+6.4f%s, crit = %+6.4f%s, hyst = %+6.4f%s)", 
    4441                         n_cur, degstr, 
    4442                         n_high, degstr, 
    4443                         n_low, degstr, 
    4444                         n_crit, degstr, 
    4445                         n_hyst, degstr); 
    4446 } 
    4447  
    4448 void print_lm92 (const sensors_chip_name *name) 
    4449 { 
    4450         char *label; 
    4451         double temp[5]; 
    4452         int valid,alarms; 
    4453  
    4454         if (!sensors_get_feature (*name,SENSORS_LM92_ALARMS,temp)) { 
    4455                 alarms = *temp + 0.5; 
    4456         } else { 
    4457                 printf ("ERROR: Can't get alarm data!\n"); 
    4458                 return; 
    4459         } 
    4460  
    4461         if (!sensors_get_label_and_valid (*name,SENSORS_LM92_TEMP,&label,&valid) && 
    4462                 !sensors_get_feature (*name,SENSORS_LM92_TEMP,temp) && 
    4463                 !sensors_get_feature (*name,SENSORS_LM92_TEMP_HIGH,temp + 1) && 
    4464                 !sensors_get_feature (*name,SENSORS_LM92_TEMP_LOW,temp + 2) && 
    4465                 !sensors_get_feature (*name,SENSORS_LM92_TEMP_CRIT,temp + 3) && 
    4466                 !sensors_get_feature (*name,SENSORS_LM92_TEMP_HYST,temp + 4)) { 
    4467                 if (valid) { 
    4468                         print_label (label,10); 
    4469                         lm92_print_temp (temp[0],temp[1],temp[2],temp[3],temp[4]); 
    4470                         if (alarms) { 
    4471                                 printf (" ALARMS ("); 
    4472  
    4473                                 if ((alarms & LM92_ALARM_TEMP_HIGH)) 
    4474                                         printf ("HIGH"); 
    4475  
    4476                                 if (alarms & LM92_ALARM_TEMP_LOW) 
    4477                                         printf ("%sLOW",(alarms & LM92_ALARM_TEMP_HIGH) ? "," : ""); 
    4478  
    4479                                 if (alarms & LM92_ALARM_TEMP_CRIT) 
    4480                                         printf ("%sCRIT",(alarms & (LM92_ALARM_TEMP_HIGH | LM92_ALARM_TEMP_LOW)) ? "," : ""); 
    4481  
    4482                                 printf (")"); 
    4483                         } 
    4484                         printf ("\n"); 
    4485                 } 
    4486         } else printf ("ERROR: Can't get temperature data!\n"); 
    4487  
    4488         free(label); 
    4489 } 
    4490  
    4491 void print_vt8231(const sensors_chip_name *name) 
    4492 { 
    4493   char *label; 
    4494   double cur,min,max,fdiv; 
    4495   int alarms,valid; 
    4496  
    4497   if (!sensors_get_feature(*name,SENSORS_VT8231_ALARMS,&cur))  
    4498     alarms = cur + 0.5; 
    4499   else { 
    4500     printf("ERROR: Can't get alarm data!\n"); 
    4501     alarms = 0; 
    4502   } 
    4503  
    4504   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN0,&label,&valid) && 
    4505       !sensors_get_feature(*name,SENSORS_VT8231_IN0,&cur) && 
    4506       !sensors_get_feature(*name,SENSORS_VT8231_IN0_MIN,&min) && 
    4507       !sensors_get_feature(*name,SENSORS_VT8231_IN0_MAX,&max)) { 
    4508     if (valid) { 
    4509       print_label(label,10); 
    4510       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4511              cur,min,max,alarms&VT8231_ALARM_IN0?"ALARM":""); 
    4512     } 
    4513   } 
    4514   free(label); 
    4515   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN1,&label,&valid) && 
    4516       !sensors_get_feature(*name,SENSORS_VT8231_IN1,&cur) && 
    4517       !sensors_get_feature(*name,SENSORS_VT8231_IN1_MIN,&min) && 
    4518       !sensors_get_feature(*name,SENSORS_VT8231_IN1_MAX,&max)) { 
    4519     if (valid) { 
    4520       print_label(label,10); 
    4521       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4522              cur,min,max,alarms&VT8231_ALARM_IN1?"ALARM":""); 
    4523     } 
    4524   } 
    4525   free(label); 
    4526   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN2,&label,&valid) && 
    4527       !sensors_get_feature(*name,SENSORS_VT8231_IN2,&cur) && 
    4528       !sensors_get_feature(*name,SENSORS_VT8231_IN2_MIN,&min) && 
    4529       !sensors_get_feature(*name,SENSORS_VT8231_IN2_MAX,&max)) { 
    4530     if (valid) { 
    4531       print_label(label,10); 
    4532       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4533              cur,min,max,alarms&VT8231_ALARM_IN2?"ALARM":""); 
    4534     } 
    4535   } 
    4536   free(label); 
    4537   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN3,&label,&valid) && 
    4538       !sensors_get_feature(*name,SENSORS_VT8231_IN3,&cur) && 
    4539       !sensors_get_feature(*name,SENSORS_VT8231_IN3_MIN,&min) && 
    4540       !sensors_get_feature(*name,SENSORS_VT8231_IN3_MAX,&max)) { 
    4541     if (valid) { 
    4542       print_label(label,10); 
    4543       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4544              cur,min,max,alarms&VT8231_ALARM_IN3?"ALARM":""); 
    4545     } 
    4546   } 
    4547   free(label); 
    4548   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN4,&label,&valid) && 
    4549       !sensors_get_feature(*name,SENSORS_VT8231_IN4,&cur) && 
    4550       !sensors_get_feature(*name,SENSORS_VT8231_IN4_MIN,&min) && 
    4551       !sensors_get_feature(*name,SENSORS_VT8231_IN4_MAX,&max)) { 
    4552     if (valid) { 
    4553       print_label(label,10); 
    4554       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4555              cur,min,max,alarms&VT8231_ALARM_IN4?"ALARM":""); 
    4556     } 
    4557   } 
    4558   free(label); 
    4559   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_IN5,&label,&valid) && 
    4560       !sensors_get_feature(*name,SENSORS_VT8231_IN5,&cur) && 
    4561       !sensors_get_feature(*name,SENSORS_VT8231_IN5_MIN,&min) && 
    4562       !sensors_get_feature(*name,SENSORS_VT8231_IN5_MAX,&max)) { 
    4563     if (valid) { 
    4564       print_label(label,10); 
    4565       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4566              cur,min,max,alarms&VT8231_ALARM_IN5?"ALARM":""); 
    4567     } 
    4568   } else 
    4569     printf("ERROR: Can't get IN5 data!\n"); 
    4570   free(label); 
    4571  
    4572   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_FAN1,&label,&valid) && 
    4573       !sensors_get_feature(*name,SENSORS_VT8231_FAN1,&cur) && 
    4574       !sensors_get_feature(*name,SENSORS_VT8231_FAN1_DIV,&fdiv) && 
    4575       !sensors_get_feature(*name,SENSORS_VT8231_FAN1_MIN,&min)) { 
    4576     if (valid) { 
    4577       print_label(label,10); 
    4578       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    4579              cur,min,fdiv, alarms&VT8231_ALARM_FAN1?"ALARM":""); 
    4580     } 
    4581   } else 
    4582     printf("ERROR: Can't get FAN1 data!\n"); 
    4583   free(label); 
    4584   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_FAN2,&label,&valid) && 
    4585       !sensors_get_feature(*name,SENSORS_VT8231_FAN2,&cur) && 
    4586       !sensors_get_feature(*name,SENSORS_VT8231_FAN2_DIV,&fdiv) && 
    4587       !sensors_get_feature(*name,SENSORS_VT8231_FAN2_MIN,&min)) { 
    4588     if (valid) { 
    4589     print_label(label,10); 
    4590     printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)          %s\n", 
    4591            cur,min,fdiv, alarms&VT8231_ALARM_FAN2?"ALARM":""); 
    4592     } 
    4593   } else 
    4594     printf("ERROR: Can't get FAN2 data!\n"); 
    4595   free(label); 
    4596  
    4597   if (!sensors_get_label_and_valid(*name, SENSORS_VT8231_TEMP, 
    4598                                    &label, &valid) && 
    4599       !sensors_get_feature(*name, SENSORS_VT8231_TEMP, &cur) && 
    4600       !sensors_get_feature(*name, SENSORS_VT8231_TEMP_HYST, &min) && 
    4601       !sensors_get_feature(*name, SENSORS_VT8231_TEMP_OVER, &max)) { 
    4602     if (valid) { 
    4603       print_label(label, 10); 
    4604       print_temp_info(cur, max, min, HYST, 1, 0); 
    4605       printf(" %s\n", alarms & VT8231_ALARM_TEMP ? "ALARM" : ""); 
    4606     } 
    4607   } else 
    4608     printf("ERROR: Can't get TEMP1 data!\n"); 
    4609   free(label); 
    4610   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP2,&label,&valid) && 
    4611       !sensors_get_feature(*name,SENSORS_VT8231_TEMP2,&cur) && 
    4612       !sensors_get_feature(*name,SENSORS_VT8231_TEMP2_HYST,&min) && 
    4613       !sensors_get_feature(*name,SENSORS_VT8231_TEMP2_OVER,&max)) { 
    4614     if (valid) { 
    4615       print_label(label,10); 
    4616       print_temp_info( cur, max, min, HYST, 1, 0); 
    4617       printf(" %s\n", alarms & VT8231_ALARM_TEMP2 ? "ALARM" : "" ); 
    4618     } 
    4619   } 
    4620   free(label); 
    4621   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP3,&label,&valid) && 
    4622       !sensors_get_feature(*name,SENSORS_VT8231_TEMP3,&cur) && 
    4623       !sensors_get_feature(*name,SENSORS_VT8231_TEMP3_HYST,&min) && 
    4624       !sensors_get_feature(*name,SENSORS_VT8231_TEMP3_OVER,&max)) { 
    4625     if (valid) { 
    4626       print_label(label,10); 
    4627       print_temp_info( cur, max, min, HYST, 1, 0); 
    4628       printf(" %s\n", alarms & VT8231_ALARM_TEMP3 ? "ALARM" : "" ); 
    4629     } 
    4630   } 
    4631   free(label); 
    4632   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP4,&label,&valid) && 
    4633       !sensors_get_feature(*name,SENSORS_VT8231_TEMP4,&cur) && 
    4634       !sensors_get_feature(*name,SENSORS_VT8231_TEMP4_HYST,&min) && 
    4635       !sensors_get_feature(*name,SENSORS_VT8231_TEMP4_OVER,&max)) { 
    4636     if (valid) { 
    4637       print_label(label,10); 
    4638       print_temp_info( cur, max, min, HYST, 1, 0); 
    4639       printf(" %s\n", alarms & VT8231_ALARM_TEMP4 ? "ALARM" : "" ); 
    4640     } 
    4641   } 
    4642   free(label); 
    4643   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP5,&label,&valid) && 
    4644       !sensors_get_feature(*name,SENSORS_VT8231_TEMP5,&cur) && 
    4645       !sensors_get_feature(*name,SENSORS_VT8231_TEMP5_HYST,&min) && 
    4646       !sensors_get_feature(*name,SENSORS_VT8231_TEMP5_OVER,&max)) { 
    4647     if (valid) { 
    4648       print_label(label,10); 
    4649       print_temp_info( cur, max, min, HYST, 1, 0); 
    4650       printf(" %s\n", alarms & VT8231_ALARM_TEMP5 ? "ALARM" : "" ); 
    4651     } 
    4652   } 
    4653   free(label); 
    4654   if (!sensors_get_label_and_valid(*name,SENSORS_VT8231_TEMP6,&label,&valid) && 
    4655       !sensors_get_feature(*name,SENSORS_VT8231_TEMP6,&cur) && 
    4656       !sensors_get_feature(*name,SENSORS_VT8231_TEMP6_HYST,&min) && 
    4657       !sensors_get_feature(*name,SENSORS_VT8231_TEMP6_OVER,&max)) { 
    4658     if (valid) { 
    4659       print_label(label,10); 
    4660       print_temp_info( cur, max, min, HYST, 1, 0); 
    4661       printf(" %s\n", alarms & VT8231_ALARM_TEMP6 ? "ALARM" : "" ); 
    4662     } 
    4663   } 
    4664   free(label); 
    4665  
    4666   print_vid_info(name, SENSORS_VT8231_VID, SENSORS_VT8231_VRM); 
    4667 } 
    4668  
    4669 #define BMC_MAX_INS 10 
    4670 #define BMC_MAX_FANS 10 
    4671 #define BMC_MAX_TEMPS 10 
    4672  
    4673 void print_bmc(const sensors_chip_name *name) 
    4674 { 
    4675   char *label; 
    4676   double cur,min,max; 
    4677   int alarms, valid, i; 
    4678  
    4679 /* 
    4680   if (!sensors_get_feature(*name,SENSORS_VT8231_ALARMS,&cur))  
    4681     alarms = cur + 0.5; 
    4682   else { 
    4683     printf("ERROR: Can't get alarm data!\n"); 
    4684     alarms = 0; 
    4685   } 
    4686 */ 
    4687 #define BMC_ALARM_IN1 0 
    4688 #define BMC_ALARM_FAN1 0 
    4689 #define BMC_ALARM_TEMP1 0 
    4690  
    4691     alarms = 0; 
    4692   for(i = 0; i < BMC_MAX_INS; i++) { 
    4693           if (!sensors_get_label_and_valid(*name,SENSORS_BMC_IN1+i,&label,&valid) && 
    4694               !sensors_get_feature(*name,SENSORS_BMC_IN1+i,&cur) && 
    4695               !sensors_get_feature(*name,SENSORS_BMC_IN1_MIN+i,&min) && 
    4696               !sensors_get_feature(*name,SENSORS_BMC_IN1_MAX+i,&max)) { 
    4697             if (valid) { 
    4698               print_label(label,10); 
    4699               printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4700                      cur,min,max,alarms&BMC_ALARM_IN1?"ALARM":""); 
    4701             } 
    4702           } 
    4703           free(label); 
    4704   } 
    4705  
    4706   for(i = 0; i < BMC_MAX_FANS; i++) { 
    4707           if (!sensors_get_label_and_valid(*name,SENSORS_BMC_FAN1+i,&label,&valid) && 
    4708               !sensors_get_feature(*name,SENSORS_BMC_FAN1+i,&cur) && 
    4709               !sensors_get_feature(*name,SENSORS_BMC_FAN1_MIN+i,&min)) { 
    4710             if (valid) { 
    4711               print_label(label,10); 
    4712               printf("%4.0f RPM  (min = %4.0f RPM)                  %s\n", 
    4713                      cur,min,alarms&BMC_ALARM_FAN1?"ALARM":""); 
    4714             } 
    4715           } 
    4716           free(label); 
    4717   } 
    4718  
    4719   for(i = 0; i < BMC_MAX_TEMPS; i++) { 
    4720           if (!sensors_get_label_and_valid(*name,SENSORS_BMC_TEMP1+i,&label,&valid) && 
    4721               !sensors_get_feature(*name,SENSORS_BMC_TEMP1+i,&cur) && 
    4722               !sensors_get_feature(*name,SENSORS_BMC_TEMP1_MIN+i,&min) && 
    4723               !sensors_get_feature(*name,SENSORS_BMC_TEMP1_MAX+i,&max)) { 
    4724             if (valid) { 
    4725               print_label(label,10); 
    4726               print_temp_info( cur, max, min, HYST, 1, 0); 
    4727               printf(" %s\n", alarms & BMC_ALARM_TEMP1 ? "ALARM" : "" ); 
    4728             } 
    4729           } 
    4730           free(label); 
    4731   }      
    4732 } 
    4733  
    4734 static long adm1026_alarms_in[] = { 
    4735   ADM1026_ALARM_IN0,  ADM1026_ALARM_IN1,  ADM1026_ALARM_IN2, 
    4736   ADM1026_ALARM_IN3,  ADM1026_ALARM_IN4,  ADM1026_ALARM_IN5, 
    4737   ADM1026_ALARM_IN6,  ADM1026_ALARM_IN7,  ADM1026_ALARM_IN8, 
    4738   ADM1026_ALARM_IN9,  ADM1026_ALARM_IN10, ADM1026_ALARM_IN11, 
    4739   ADM1026_ALARM_IN12, ADM1026_ALARM_IN13, ADM1026_ALARM_IN14, 
    4740   ADM1026_ALARM_IN15, ADM1026_ALARM_IN16 
    4741 }; 
    4742 static long adm1026_alarms_temp[] = { 
    4743   ADM1026_ALARM_TEMP1,  ADM1026_ALARM_TEMP2,  ADM1026_ALARM_TEMP3 
    4744 }; 
    4745  
    4746 void print_adm1026(const sensors_chip_name *name) 
    4747 { 
    4748   char *label; 
    4749   double cur,min,max; 
    4750   long alarms; 
    4751   int valid, i; 
    4752  
    4753   if (!sensors_get_feature(*name,SENSORS_ADM1026_ALARMS,&cur)) { 
    4754     alarms = cur + 0.5; 
    4755   } else { 
    4756     printf("ERROR: Can't get alarm data!\n"); 
    4757     alarms = 0; 
    4758   } 
    4759  
    4760   /* Seventeen voltage sensors */ 
    4761   for (i = 0; i <= 16 ; ++i) { 
    4762     int  feat_base = SENSORS_ADM1026_IN0 + (3 * i); 
    4763     int  feat_max = feat_base +1, feat_min = feat_base +2; 
    4764     if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) && 
    4765         !sensors_get_feature(*name,feat_base,&cur) && 
    4766         !sensors_get_feature(*name,feat_min,&min) && 
    4767         !sensors_get_feature(*name,feat_max,&max)) { 
    4768       if (valid) { 
    4769         print_label(label,10); 
    4770         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)   %s\n", 
    4771                cur,min,max,(alarms&adm1026_alarms_in[i])?"ALARM":""); 
    4772       } 
    4773     } else { 
    4774       printf("ERROR: Can't get IN%d data!\n",i); 
    4775     } 
    4776     free(label); 
    4777   }; 
    4778  
    4779   /* Eight fan sensors */ 
    4780   for (i = 0; i <= 7 ; ++i) { 
    4781     int  feat_base = SENSORS_ADM1026_FAN0 + (3 * i); 
    4782     int  feat_div = feat_base +1, feat_min = feat_base +2; 
    4783     if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) && 
    4784         !sensors_get_feature(*name,feat_base,&cur) && 
    4785         !sensors_get_feature(*name,feat_min,&min) && 
    4786         !sensors_get_feature(*name,feat_div,&max)) { 
    4787       if (valid) { 
    4788         print_label(label,10); 
    4789         printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)   %s\n", 
    4790                cur,min,max,(alarms&(ADM1026_ALARM_FAN0<<i))?"ALARM":""); 
    4791       } 
    4792     } else { 
    4793       printf("ERROR: Can't get FAN%d data!\n",i); 
    4794     } 
    4795     free(label); 
    4796   }; 
    4797  
    4798   /* Three temperature sensors 
    4799    * NOTE:  6 config values per temperature 
    4800    *      0  current 
    4801    *      1  max 
    4802    *      2  min 
    4803    *      3  offset   (to current) 
    4804    *      4  therm    (SMBAlert) 
    4805    *      5  tmin     (AFC) 
    4806    */ 
    4807   for (i = 0; i <= 2 ; ++i) { 
    4808     int  feat_base = SENSORS_ADM1026_TEMP1 + (6 * i); 
    4809     int  feat_max = feat_base +1; 
    4810     int  feat_min = feat_base +2; 
    4811  
    4812     if (!sensors_get_label_and_valid(*name,feat_base,&label,&valid) && 
    4813         !sensors_get_feature(*name,feat_base,&cur) && 
    4814         !sensors_get_feature(*name,feat_min,&min) && 
    4815         !sensors_get_feature(*name,feat_max,&max)) { 
    4816       if (valid) { 
    4817         print_label(label,10); 
    4818         print_temp_info( cur, max, min, MINMAX, 0, 0); 
    4819         puts( (alarms&adm1026_alarms_temp[i])?"   ALARM":"" ); 
    4820       } 
    4821     } else { 
    4822       printf("ERROR: Can't get TEMP%d data!\n",i+1); 
    4823     } 
    4824     free(label); 
    4825   }; 
    4826  
    4827   /* VID/VRM */ 
    4828   print_vid_info(name, SENSORS_ADM1026_VID, SENSORS_ADM1026_VRM); 
    4829 } 
    4830  
    4831 void print_lm83(const sensors_chip_name *name) 
    4832 { 
    4833   char *label; 
    4834   double cur,high,crit; 
    4835   int valid,alarms; 
    4836  
    4837   if (!sensors_get_feature(*name,SENSORS_LM83_ALARMS,&cur)) 
    4838     alarms = cur + 0.5; 
    4839   else { 
    4840     printf("ERROR: Can't get alarm data!\n"); 
    4841     alarms = 0; 
    4842   } 
    4843  
    4844   if (sensors_get_feature(*name,SENSORS_LM83_TCRIT,&crit)) { 
    4845     printf("ERROR: Can't get tcrit data!\n"); 
    4846     crit = 127; 
    4847   } 
    4848  
    4849   if (!sensors_get_label_and_valid(*name,SENSORS_LM83_LOCAL_TEMP,&label,&valid) && 
    4850       !sensors_get_feature(*name,SENSORS_LM83_LOCAL_TEMP,&cur) && 
    4851       !sensors_get_feature(*name,SENSORS_LM83_LOCAL_HIGH,&high))  { 
    4852     if (valid) { 
    4853       print_label(label,10); 
    4854       print_temp_info( cur, high, crit, CRIT, 0, 0); 
    4855       printf(" %s\n", 
    4856         alarms&LM83_ALARM_LOCAL_CRIT?"CRITICAL": 
    4857         alarms&LM83_ALARM_LOCAL_HIGH?"ALARM":""); 
    4858     } 
    4859   } else 
    4860     printf("ERROR: Can't get local temperature data!\n"); 
    4861   free(label); 
    4862  
    4863   if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE1_TEMP,&label,&valid) && 
    4864       !sensors_get_feature(*name,SENSORS_LM83_REMOTE1_TEMP,&cur) && 
    4865       !sensors_get_feature(*name,SENSORS_LM83_REMOTE1_HIGH,&high))  { 
    4866     if (valid) { 
    4867       print_label(label,10); 
    4868       print_temp_info( cur, high, crit, CRIT, 0, 0); 
    4869       printf(" %s\n", 
    4870         alarms&LM83_ALARM_REMOTE1_OPEN?"DISCONNECT": 
    4871         alarms&LM83_ALARM_REMOTE1_CRIT?"CRITICAL": 
    4872         alarms&LM83_ALARM_REMOTE1_HIGH?"ALARM":""); 
    4873     } 
    4874   } else 
    4875     printf("ERROR: Can't get remote temperature 1 data!\n"); 
    4876   free(label); 
    4877  
    4878   if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE2_TEMP,&label,&valid) && 
    4879       !sensors_get_feature(*name,SENSORS_LM83_REMOTE2_TEMP,&cur) && 
    4880       !sensors_get_feature(*name,SENSORS_LM83_REMOTE2_HIGH,&high))  { 
    4881     if (valid) { 
    4882       print_label(label,10); 
    4883       print_temp_info( cur, high, crit, CRIT, 0, 0); 
    4884       printf(" %s\n", 
    4885         alarms&LM83_ALARM_REMOTE2_OPEN?"DISCONNECT": 
    4886         alarms&LM83_ALARM_REMOTE2_CRIT?"CRITICAL": 
    4887         alarms&LM83_ALARM_REMOTE2_HIGH?"ALARM":""); 
    4888     } 
    4889   } else 
    4890     printf("ERROR: Can't get remote temperature 2 data!\n"); 
    4891   free(label); 
    4892  
    4893   if (!sensors_get_label_and_valid(*name,SENSORS_LM83_REMOTE3_TEMP,&label,&valid) && 
    4894       !sensors_get_feature(*name,SENSORS_LM83_REMOTE3_TEMP,&cur) && 
    4895       !sensors_get_feature(*name,SENSORS_LM83_REMOTE3_HIGH,&high))  { 
    4896     if (valid) { 
    4897       print_label(label,10); 
    4898       print_temp_info( cur, high, crit, CRIT, 0, 0); 
    4899       printf(" %s\n", 
    4900         alarms&LM83_ALARM_REMOTE3_OPEN?"DISCONNECT": 
    4901         alarms&LM83_ALARM_REMOTE3_CRIT?"CRITICAL": 
    4902         alarms&LM83_ALARM_REMOTE3_HIGH?"ALARM":""); 
    4903     } 
    4904   } else 
    4905     printf("ERROR: Can't get remote temperature 3 data!\n"); 
    4906   free(label); 
    4907 } 
    4908  
    4909 void print_lm90(const sensors_chip_name *name) 
    4910 { 
    4911   char *label; 
    4912   double cur, high, low, hyst; 
    4913   int valid, alarms; 
    4914  
    4915   if (!sensors_get_feature(*name, SENSORS_LM90_ALARMS, &cur)) 
    4916     alarms = cur + 0.5; 
    4917   else { 
    4918     printf("ERROR: Can't get alarm data!\n"); 
    4919     alarms = 0; 
    4920   } 
    4921  
    4922   if (!sensors_get_label_and_valid(*name, SENSORS_LM90_LOCAL_TEMP, 
    4923       &label, &valid) 
    4924    && !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TEMP, &cur) 
    4925    && !sensors_get_feature(*name, SENSORS_LM90_LOCAL_HIGH, &high) 
    4926    && !sensors_get_feature(*name, SENSORS_LM90_LOCAL_LOW, &low)) { 
    4927     if (valid) { 
    4928       print_label(label, 10); 
    4929       print_temp_info(cur, high, low, MINMAX, 0, 0); 
    4930       printf(" %s\n", 
    4931         alarms&LM90_ALARM_LOCAL_CRIT?"CRITICAL": 
    4932         alarms&(LM90_ALARM_LOCAL_HIGH|LM90_ALARM_LOCAL_LOW)?"ALARM":""); 
    4933     } 
    4934   } else 
    4935     printf("ERROR: Can't get local temperature data!\n"); 
    4936   free(label); 
    4937  
    4938   if (!sensors_get_label_and_valid(*name, SENSORS_LM90_REMOTE_TEMP, 
    4939       &label, &valid) 
    4940    && !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TEMP, &cur) 
    4941    && !sensors_get_feature(*name, SENSORS_LM90_REMOTE_HIGH, &high) 
    4942    && !sensors_get_feature(*name, SENSORS_LM90_REMOTE_LOW, &low)) { 
    4943     if (valid) { 
    4944       print_label(label, 10); 
    4945       print_temp_info(cur, high, low, MINMAX, 1, 1); 
    4946       printf(" %s\n", 
    4947         alarms&LM90_ALARM_REMOTE_OPEN?"DISCONNECT": 
    4948         alarms&LM90_ALARM_REMOTE_CRIT?"CRITICAL": 
    4949         alarms&(LM90_ALARM_REMOTE_HIGH|LM90_ALARM_REMOTE_LOW)?"ALARM":""); 
    4950     } 
    4951   } else 
    4952     printf("ERROR: Can't get remote temperature data!\n"); 
    4953   free(label); 
    4954  
    4955   if (!sensors_get_label_and_valid(*name, SENSORS_LM90_LOCAL_TCRIT, 
    4956       &label, &valid) 
    4957    && !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TCRIT, &high) 
    4958    && !sensors_get_feature(*name, SENSORS_LM90_LOCAL_TCRIT_HYST, &hyst)) { 
    4959     if (valid) { 
    4960       print_label(label, 10); 
    4961       print_temp_info(high, hyst, 0, HYSTONLY, 0, 0); 
    4962       printf("\n"); 
    4963     } 
    4964   } else 
    4965     printf("ERROR: Can't get local tcrit data!\n"); 
    4966   free(label); 
    4967  
    4968   if (!sensors_get_label_and_valid(*name, SENSORS_LM90_REMOTE_TCRIT, 
    4969       &label, &valid) 
    4970    && !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TCRIT, &high) 
    4971    && !sensors_get_feature(*name, SENSORS_LM90_REMOTE_TCRIT_HYST, &hyst)) { 
    4972     if (valid) { 
    4973       print_label(label, 10); 
    4974       print_temp_info(high, hyst, 0, HYSTONLY, 0, 0); 
    4975       printf("\n"); 
    4976     } 
    4977   } else 
    4978     printf("ERROR: Can't get remote tcrit data!\n"); 
    4979   free(label); 
    4980 } 
    4981  
    4982 void print_adm1029(const sensors_chip_name *name) 
    4983 { 
    4984         char *label; 
    4985         double cur, high, low, fan_div; 
    4986         int valid; 
    4987  
    4988         if (!sensors_get_label_and_valid(*name, SENSORS_ADM1029_TEMP1, 
    4989                 &label, &valid) 
    4990          && !sensors_get_feature(*name, SENSORS_ADM1029_TEMP1, &cur) 
    4991          && !sensors_get_feature(*name, SENSORS_ADM1029_TEMP1_MAX, &high) 
    4992          && !sensors_get_feature(*name, SENSORS_ADM1029_TEMP1_MIN, &low)) { 
    4993                 if (valid) { 
    4994                         print_label(label, 10); 
    4995                         print_temp_info(cur, high, low, MINMAX, 0, 0); 
    4996                         printf("\n"); 
    4997                 } 
    4998         } else 
    4999                 printf("ERROR: Can't get local temperature data!\n"); 
    5000         free(label); 
    5001  
    5002         if (!sensors_get_label_and_valid(*name, SENSORS_ADM1029_TEMP2, 
    5003                 &label, &valid) 
    5004          && !sensors_get_feature(*name, SENSORS_ADM1029_TEMP2, &cur) 
    5005          && !sensors_get_feature(*name, SENSORS_ADM1029_TEMP2_MAX, &high) 
    5006          && !sensors_get_feature(*name, SENSORS_ADM1029_TEMP2_MIN, &low)) { 
    5007                 if (valid) { 
    5008                         print_label(label, 10); 
    5009                         print_temp_info(cur, high, low, MINMAX, 0, 0); 
    5010                         printf("\n"); 
    5011                 } 
    5012         } else 
    5013                 printf("ERROR: Can't get remote1 temperature data!\n"); 
    5014         free(label); 
    5015  
    5016         if (!sensors_get_label_and_valid(*name, SENSORS_ADM1029_TEMP3, 
    5017                 &label, &valid) 
    5018          && !sensors_get_feature(*name, SENSORS_ADM1029_TEMP3, &cur) 
    5019          && !sensors_get_feature(*name, SENSORS_ADM1029_TEMP3_MAX, &high) 
    5020          && !sensors_get_feature(*name, SENSORS_ADM1029_TEMP3_MIN, &low)) { 
    5021                 if (valid) { 
    5022                         print_label(label, 10); 
    5023                         print_temp_info(cur, high, low, MINMAX, 0, 0); 
    5024                         printf("\n"); 
    5025                 } 
    5026         } else 
    5027                 printf("ERROR: Can't get remote2 temperature data!\n"); 
    5028         free(label); 
    5029  
    5030         if (!sensors_get_label_and_valid(*name, SENSORS_ADM1029_FAN1, 
    5031                 &label, &valid) 
    5032          && !sensors_get_feature(*name, SENSORS_ADM1029_FAN1, &cur) 
    5033          && !sensors_get_feature(*name, SENSORS_ADM1029_FAN1_MIN, &low) 
    5034          && !sensors_get_feature(*name, SENSORS_ADM1029_FAN1_DIV, &fan_div)) { 
    5035                 if (valid) { 
    5036                         print_label(label, 10); 
    5037                         printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)\n", 
    5038                                 cur, low, fan_div); 
    5039                 } 
    5040         } else 
    5041                 printf("ERROR: Can't get fan1 data!\n"); 
    5042         free(label); 
    5043  
    5044         if (!sensors_get_label_and_valid(*name, SENSORS_ADM1029_FAN2, 
    5045                 &label, &valid) 
    5046          && !sensors_get_feature(*name, SENSORS_ADM1029_FAN2, &cur) 
    5047          && !sensors_get_feature(*name, SENSORS_ADM1029_FAN2_MIN, &low) 
    5048          && !sensors_get_feature(*name, SENSORS_ADM1029_FAN2_DIV, &fan_div)) { 
    5049                 if (valid) { 
    5050                         print_label(label, 10); 
    5051                         printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)\n", 
    5052                                 cur, low , fan_div); 
    5053                 } 
    5054         } else 
    5055                 printf("ERROR: Can't get fan2 data!\n"); 
    5056         free(label); 
    5057 } 
    5058  
    5059 void print_lm63(const sensors_chip_name *name) 
    5060 { 
    5061   char *label; 
    5062   double cur, high, low; 
    5063   int valid, alarms; 
    5064  
    5065   if (!sensors_get_feature(*name, SENSORS_LM63_ALARMS, &cur)) 
    5066     alarms = cur + 0.5; 
    5067   else { 
    5068     printf("ERROR: Can't get alarm data!\n"); 
    5069     alarms = 0; 
    5070   } 
    5071  
    5072   if (!sensors_get_label_and_valid(*name, SENSORS_LM63_LOCAL_TEMP, 
    5073       &label, &valid) 
    5074    && !sensors_get_feature(*name, SENSORS_LM63_LOCAL_TEMP, &cur) 
    5075    && !sensors_get_feature(*name, SENSORS_LM63_LOCAL_HIGH, &high)) { 
    5076     if (valid) { 
    5077       print_label(label, 10); 
    5078       print_temp_info(cur, high, 0, MAXONLY, 0, 0); 
    5079       printf(" %s\n", 
    5080         alarms&LM63_ALARM_LOCAL_HIGH?"ALARM":""); 
    5081     } 
    5082   } else 
    5083     printf("ERROR: Can't get local temperature data!\n"); 
    5084   free(label); 
    5085  
    5086   if (!sensors_get_label_and_valid(*name, SENSORS_LM63_REMOTE_TEMP, 
    5087       &label, &valid) 
    5088    && !sensors_get_feature(*name, SENSORS_LM63_REMOTE_TEMP, &cur) 
    5089    && !sensors_get_feature(*name, SENSORS_LM63_REMOTE_HIGH, &high) 
    5090    && !sensors_get_feature(*name, SENSORS_LM63_REMOTE_LOW, &low)) { 
    5091     if (valid) { 
    5092       print_label(label, 10); 
    5093       print_temp_info(cur, high, low, MINMAX, 1, 1); 
    5094       printf(" %s\n", 
    5095         alarms&LM63_ALARM_REMOTE_OPEN?"OPEN": 
    5096         alarms&LM63_ALARM_REMOTE_CRIT?"CRITICAL": 
    5097         alarms&(LM63_ALARM_REMOTE_HIGH|LM63_ALARM_REMOTE_LOW)?"ALARM":""); 
    5098     } 
    5099   } else 
    5100     printf("ERROR: Can't get remote temperature data!\n"); 
    5101   free(label); 
    5102  
    5103   if (!sensors_get_label_and_valid(*name, SENSORS_LM63_REMOTE_TCRIT, 
    5104       &label, &valid) 
    5105    && !sensors_get_feature(*name, SENSORS_LM63_REMOTE_TCRIT, &high) 
    5106    && !sensors_get_feature(*name, SENSORS_LM63_REMOTE_TCRIT_HYST, &low)) { 
    5107     if (valid) { 
    5108       print_label(label, 10); 
    5109       print_temp_info(high, low, 0, HYSTONLY, 0, 0); 
    5110       printf("\n"); 
    5111     } 
    5112   } else 
    5113     printf("ERROR: Can't get remote tcrit data!\n"); 
    5114   free(label); 
    5115  
    5116   if (!sensors_get_label_and_valid(*name, SENSORS_LM63_FAN, 
    5117       &label, &valid) 
    5118    && !sensors_get_feature(*name, SENSORS_LM63_FAN, &cur) 
    5119    && !sensors_get_feature(*name, SENSORS_LM63_FAN_LOW, &low)) { 
    5120     if (valid) { 
    5121       print_label(label, 10); 
    5122       printf("%4.0f RPM  (min = %4.0f RPM) %s\n", cur, low, 
    5123         alarms&LM63_ALARM_FAN_LOW?"ALARM":""); 
    5124     } 
    5125   } 
    5126   /* No error if fan files are missing as it will happen with 2.6 
    5127      kernels when the tachometer pin is used as an alarm output. */ 
    5128   free(label); 
    5129 } 
    5130  
    5131 void print_adm1031(const sensors_chip_name *name) 
    5132 { 
    5133   char *label; 
    5134   double cur, high, low, crit, fdiv; 
    5135   int valid, alarms, i; 
    5136   int is_1031 = !strncmp("adm1031", name->prefix, 7); 
    5137  
    5138   if (!sensors_get_feature(*name, SENSORS_ADM1031_ALARMS, &cur)) 
    5139       alarms = cur; 
    5140   else { 
    5141       printf("ERROR: Can't get alarm data!\n"); 
    5142       alarms = 0; 
    5143   } 
    5144    
    5145   for(i=0; i<(is_1031?2:1);i++) { 
    5146       if (!sensors_get_label_and_valid(*name, SENSORS_ADM1031_FAN1+i*10, 
    5147                                        &label, &valid) 
    5148           && !sensors_get_feature(*name, SENSORS_ADM1031_FAN1+i*10, &cur) 
    5149           && !sensors_get_feature(*name, SENSORS_ADM1031_FAN1_MIN+i*10, &low) 
    5150           && !sensors_get_feature(*name, SENSORS_ADM1031_FAN1_DIV+i*10, &fdiv)) { 
    5151           if (valid) { 
    5152               print_label(label, 10); 
    5153               printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)", cur, low, fdiv); 
    5154               printf(" %s\n", 
    5155                      alarms&(ADM1031_ALARM_FAN1_FLT<<(i*8))?"FAULT": 
    5156                      alarms&(ADM1031_ALARM_FAN1_MIN<<(i*8))?"ALARM":""); 
    5157           } 
    5158       } else 
    5159           printf("ERROR: Can't get fan%d data!\n", i+1); 
    5160       free(label); 
    5161   } 
    5162  
    5163   if (!sensors_get_label_and_valid(*name, SENSORS_ADM1031_TEMP1, 
    5164                                    &label, &valid) 
    5165       && !sensors_get_feature(*name, SENSORS_ADM1031_TEMP1, &cur) 
    5166       && !sensors_get_feature(*name, SENSORS_ADM1031_TEMP1_MIN, &low) 
    5167       && !sensors_get_feature(*name, SENSORS_ADM1031_TEMP1_MAX, &high) 
    5168       && !sensors_get_feature(*name, SENSORS_ADM1031_TEMP1_CRIT, &crit)) { 
    5169       if (valid) { 
    5170           print_label(label, 10); 
    5171           print_temp_info(cur, high, low, MINMAX, 1, 0); 
    5172           printf(" %s\n", 
    5173                  alarms&(ADM1031_ALARM_TEMP1_HIGH|ADM1031_ALARM_TEMP1_LOW)?"ALARM":""); 
    5174       } 
    5175   } else 
    5176       printf("ERROR: Can't get temp1 temperature data!\n"); 
    5177   free(label); 
    5178   if (!sensors_get_label_and_valid(*name, SENSORS_ADM1031_TEMP1_CRIT, 
    5179                                    &label, &valid) 
    5180       && !sensors_get_feature(*name, SENSORS_ADM1031_TEMP1_CRIT, &cur)) { 
    5181       if (valid) { 
    5182           print_label(label, 10); 
    5183           print_temp_info(cur, 0, 0, SINGLE, 0, 0); 
    5184           printf(" %s\n", 
    5185                  alarms&ADM1031_ALARM_TEMP1_CRIT?"CRITICAL":""); 
    5186       } 
    5187   } else 
    5188       printf("ERROR: Can't get temp1 temperature data!\n"); 
    5189   free(label); 
    5190    
    5191   for (i=0; i < (is_1031 ? 2 : 1); i++) { 
    5192       if (!sensors_get_label_and_valid(*name, SENSORS_ADM1031_TEMP2+i*10, 
    5193                                        &label, &valid) 
    5194           && !sensors_get_feature(*name, SENSORS_ADM1031_TEMP2+i*10, &cur) 
    5195           && !sensors_get_feature(*name, SENSORS_ADM1031_TEMP2_MIN+i*10, &low) 
    5196           && !sensors_get_feature(*name, SENSORS_ADM1031_TEMP2_MAX+i*10, &high)) { 
    5197           if (valid) { 
    5198               print_label(label, 10); 
    5199               print_temp_info(cur, high, low, MINMAX, 1, 0); 
    5200               printf(" %s\n", 
    5201                      alarms&((ADM1031_ALARM_TEMP2_DIODE<<(i*8)))?"DISCONNECT": 
    5202                      alarms&((ADM1031_ALARM_TEMP2_HIGH<<(i*8))| 
    5203                              (ADM1031_ALARM_TEMP2_LOW<<(i*8)))?"ALARM":""); 
    5204           } 
    5205       } else 
    5206           printf("ERROR: Can't get temp%d temperature data!\n", i+2); 
    5207       free(label); 
    5208       if (!sensors_get_label_and_valid(*name, SENSORS_ADM1031_TEMP2_CRIT+i*10, 
    5209                                        &label, &valid) 
    5210           && !sensors_get_feature(*name, SENSORS_ADM1031_TEMP2_CRIT+i*10, &cur)) { 
    5211           if (valid) { 
    5212               print_label(label, 10); 
    5213               print_temp_info(cur, 0, 0, SINGLE, 0, 0); 
    5214               printf(" %s\n", 
    5215                      alarms&((ADM1031_ALARM_TEMP2_CRIT<<(i*8)))?"CRITICAL":""); 
    5216           } 
    5217       } else 
    5218           printf("ERROR: Can't get temp%d crit temperature data!\n", i+2); 
    5219       free(label); 
    5220   } 
    5221 } 
    5222  
    5223 void print_xeontemp(const sensors_chip_name *name) 
    5224 { 
    5225   char *label; 
    5226   double cur,hyst,over; 
    5227   int alarms,i,valid; 
    5228  
    5229   if (!sensors_get_feature(*name,SENSORS_XEONTEMP_ALARMS,&cur))  
    5230     alarms = cur + 0.5; 
    5231   else { 
    5232     printf("ERROR: Can't get alarm data!\n"); 
    5233     alarms = 0; 
    5234   } 
    5235  
    5236   if (!sensors_get_label_and_valid(*name,SENSORS_XEONTEMP_REMOTE_TEMP, 
    5237                                    &label,&valid) && 
    5238       !sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP,&cur) && 
    5239       !sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP_HYST,&hyst) && 
    5240       !sensors_get_feature(*name,SENSORS_XEONTEMP_REMOTE_TEMP_OVER,&over))  { 
    5241     if (valid) { 
    5242       print_label(label,10); 
    5243       print_temp_info( cur, over, hyst, MINMAX, 0, 0); 
    5244       if (alarms & (XEONTEMP_ALARM_RTEMP_HIGH | XEONTEMP_ALARM_RTEMP_LOW | 
    5245                     XEONTEMP_ALARM_RTEMP_NA)) { 
    5246         printf("ALARM ("); 
    5247         i = 0; 
    5248           if (alarms & XEONTEMP_ALARM_RTEMP_NA) { 
    5249           printf("N/A"); 
    5250           i++; 
    5251         } 
    5252         if (alarms & XEONTEMP_ALARM_RTEMP_LOW) { 
    5253           printf("%sLOW",i?",":""); 
    5254           i++; 
    5255         } 
    5256         if (alarms & XEONTEMP_ALARM_RTEMP_HIGH) 
    5257           printf("%sHIGH",i?",":""); 
    5258         printf(")"); 
    5259       } 
    5260       printf("\n"); 
    5261     } 
    5262   } else 
    5263     printf("ERROR: Can't get temperature data!\n"); 
    5264   free(label); 
    5265 } 
    5266  
    5267  
    5268 void print_max1619(const sensors_chip_name *name) 
    5269 { 
    5270   char *label; 
    5271   double cur, high, low; 
    5272   int valid, alarms; 
    5273  
    5274   if (!sensors_get_feature(*name, SENSORS_MAX1619_ALARMS, &cur)) 
    5275     alarms = cur + 0.5; 
    5276   else { 
    5277     printf("ERROR: Can't get alarm data!\n"); 
    5278     alarms = 0; 
    5279   } 
    5280  
    5281   if (!sensors_get_label_and_valid(*name, SENSORS_MAX1619_LOCAL_TEMP, 
    5282                                    &label, &valid) 
    5283    && !sensors_get_feature(*name, SENSORS_MAX1619_LOCAL_TEMP, &cur)) { 
    5284     if (valid) { 
    5285         print_label(label, 10); 
    5286         print_temp_info(cur,0 ,0 ,SINGLE , 0, 0); 
    5287         printf("\n"); 
    5288     } 
    5289   } else 
    5290     printf("ERROR: Can't get local temperature data!\n"); 
    5291   free(label); 
    5292  
    5293   if (!sensors_get_label_and_valid(*name, SENSORS_MAX1619_REMOTE_TEMP, 
    5294                                    &label, &valid) 
    5295    && !sensors_get_feature(*name, SENSORS_MAX1619_REMOTE_TEMP, &cur) 
    5296    && !sensors_get_feature(*name, SENSORS_MAX1619_REMOTE_LOW, &low) 
    5297    && !sensors_get_feature(*name, SENSORS_MAX1619_REMOTE_HIGH, &high)) { 
    5298     if (valid) { 
    5299       print_label(label, 10); 
    5300       print_temp_info(cur, low, high, MINMAX, 0, 0); 
    5301       printf(" %s\n", 
    5302         alarms&MAX1619_ALARM_REMOTE_OPEN?"DISCONNECT": 
    5303         alarms&(MAX1619_ALARM_REMOTE_THIGH|MAX1619_ALARM_REMOTE_TLOW)?"ALARM":""); 
    5304     } 
    5305   } else 
    5306     printf("ERROR: Can't get remote temperature data!\n"); 
    5307   free(label); 
    5308  
    5309   if (!sensors_get_label_and_valid(*name, SENSORS_MAX1619_REMOTE_MAX, 
    5310                                    &label, &valid) 
    5311    && !sensors_get_feature(*name, SENSORS_MAX1619_REMOTE_MAX, &high) 
    5312    && !sensors_get_feature(*name, SENSORS_MAX1619_REMOTE_HYST, &low)) { 
    5313     if (valid) { 
    5314       print_label(label, 10); 
    5315       print_temp_info(high, low, 0, HYSTONLY, 0, 0); 
    5316       printf("\n"); 
    5317     } 
    5318   } else 
    5319     printf("ERROR: Can't get remote temperature max data!\n"); 
    5320   free(label); 
    5321 } 
    5322  
    5323 void print_max6650(const sensors_chip_name *name) 
    5324 { 
    5325   char *label; 
    5326   double tach, speed; 
    5327   int valid, i; 
    5328  
    5329   static const struct 
    5330   { 
    5331     int tag; 
    5332     const char *name; 
    5333   } 
    5334   tach_list[] = 
    5335   { 
    5336     { SENSORS_MAX6650_FAN1_TACH, "FAN1" }, 
    5337     { SENSORS_MAX6650_FAN2_TACH, "FAN2" }, 
    5338     { SENSORS_MAX6650_FAN3_TACH, "FAN3" }, 
    5339     { SENSORS_MAX6650_FAN4_TACH, "FAN4" } 
    5340   }; 
    5341  
    5342   /* Display full config for fan1, which is controlled */ 
    5343  
    5344   if (!sensors_get_label_and_valid(*name,tach_list[0].tag,&label,&valid) && 
    5345       !sensors_get_feature(*name,tach_list[0].tag,&tach) && 
    5346       !sensors_get_feature(*name,SENSORS_MAX6650_SPEED,&speed)) { 
    5347     if (valid) { 
    5348       print_label(label,10); 
    5349       printf("configured %4.0f RPM, actual %4.0f RPM.\n", speed, tach); 
    5350     } 
    5351   } else 
    5352     printf("ERROR: Can't get %s data!\n", tach_list[0].name); 
    5353   free(label); 
    5354    
    5355   /* Just display the measured speed for the other three, uncontrolled fans */ 
    5356    
    5357   for (i = 1; i < 4; i++) 
    5358   { 
    5359     if (!sensors_get_label_and_valid(*name,tach_list[i].tag,&label,&valid) && 
    5360         !sensors_get_feature(*name,tach_list[i].tag,&tach)) { 
    5361       if (valid) { 
    5362         print_label(label,10); 
    5363         printf("%4.0f RPM\n", tach); 
    5364       } 
    5365     } else 
    5366       printf("ERROR: Can't get %s data!\n", tach_list[i].name); 
    5367   
    5368     free(label); 
    5369   } 
    5370 } 
    5371  
    5372 /* print_asb100_in() 
    5373  *   where in, in_min, and in_max are sensors feature IDs 
    5374  */ 
    5375 static void print_asb100_in(const sensors_chip_name *name, int alarm, 
    5376         int in, int in_min, int in_max) 
    5377 { 
    5378   char *label; 
    5379   double cur, min, max; 
    5380   int valid; 
    5381  
    5382   if (!sensors_get_label_and_valid(*name,in,&label,&valid) && 
    5383       !sensors_get_feature(*name,in,&cur) && 
    5384       !sensors_get_feature(*name,in_min,&min) && 
    5385       !sensors_get_feature(*name,in_max,&max)) { 
    5386     if (valid) { 
    5387       print_label(label,10); 
    5388       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)       %s\n", 
    5389            cur, min, max, alarm ? "ALARM" : ""); 
    5390     } 
    5391   } else 
    5392     printf("ERROR: Can't get IN data! (0x%04x)\n", in); 
    5393   free(label); 
    5394 } 
    5395  
    5396 #define PRINT_ASB100_IN(num, name, alarms) \ 
    5397         print_asb100_in((name), ((alarms) & ASB100_ALARM_IN##num), \ 
    5398                 (SENSORS_ASB100_IN##num), \ 
    5399                 (SENSORS_ASB100_IN##num##_MIN), \ 
    5400                 (SENSORS_ASB100_IN##num##_MAX)) 
    5401  
    5402 /* print_asb100_fan() 
    5403  *   where fan, fan_div, and fan_min are sensors feature IDs 
    5404  */ 
    5405 static void print_asb100_fan(const sensors_chip_name *name, int alarm, 
    5406         int fan, int fan_div, int fan_min) 
    5407 { 
    5408   char *label; 
    5409   double cur, fdiv, min; 
    5410   int valid; 
    5411  
    5412   if (!sensors_get_label_and_valid(*name,fan,&label,&valid) && 
    5413       !sensors_get_feature(*name,fan,&cur) && 
    5414       !sensors_get_feature(*name,fan_div, &fdiv) && 
    5415       !sensors_get_feature(*name,fan_min,&min)) { 
    5416     if (valid) { 
    5417       print_label(label,10); 
    5418       printf("%4.0f RPM  (min = %4.0f RPM, div = %1.0f)              %s\n", 
    5419            cur, min, fdiv, alarm ? "ALARM" : ""); 
    5420     } 
    5421   } else 
    5422     printf("ERROR: Can't get FAN data! (0x%04x)\n", fan); 
    5423   free(label); 
    5424 } 
    5425  
    5426 #define PRINT_ASB100_FAN(num, name, alarms) \ 
    5427         print_asb100_fan((name), ((alarms) & ASB100_ALARM_FAN##num), \ 
    5428                 (SENSORS_ASB100_FAN##num), \ 
    5429                 (SENSORS_ASB100_FAN##num##_DIV), \ 
    5430                 (SENSORS_ASB100_FAN##num##_MIN)) 
    5431  
    5432 /* print_asb100_temp() 
    5433  * where temp, temp_max, and temp_hyst are sensors feature IDs 
    5434  */ 
    5435 static void print_asb100_temp(const sensors_chip_name *name, int alarm, 
    5436         int temp, int temp_max, int temp_hyst) 
    5437 { 
    5438   char *label; 
    5439   double cur, max, hyst; 
    5440   int valid; 
    5441  
    5442   if (!sensors_get_label_and_valid(*name,temp,&label,&valid) && 
    5443       !sensors_get_feature(*name,temp,&cur) && 
    5444       !sensors_get_feature(*name,temp_max,&max) && 
    5445       !sensors_get_feature(*name,temp_hyst,&hyst)) { 
    5446     if (valid) { 
    5447       print_label(label,10); 
    5448       if (hyst == 127) 
    5449         print_temp_info(cur, max, 0, MAXONLY, 0, 0); 
    5450       else 
    5451         print_temp_info(cur, max, hyst, HYST, 0, 0); 
    5452  
    5453       printf(" %s\n", alarm ? "ALARM" : ""); 
    5454     } 
    5455   } else 
    5456     printf("ERROR: Can't get TEMP data! (0x%04x)\n", temp); 
    5457  
    5458   free(label); 
    5459 } 
    5460  
    5461 #ifndef ASB100_ALARM_TEMP4  
    5462 #define ASB100_ALARM_TEMP4 0 
    5463 #endif 
    5464  
    5465 #define PRINT_ASB100_TEMP(num, name, alarms) \ 
    5466         print_asb100_temp((name), ((alarms) & ASB100_ALARM_TEMP##num), \ 
    5467                 (SENSORS_ASB100_TEMP##num), \ 
    5468                 (SENSORS_ASB100_TEMP##num##_OVER), \ 
    5469                 (SENSORS_ASB100_TEMP##num##_HYST)) 
    5470  
    5471  
    5472 void print_asb100(const sensors_chip_name *name) 
    5473 { 
    5474   char *label; 
    5475   double cur; 
    5476   int valid, alarms = 0; 
    5477  
    5478   if (!sensors_get_feature(*name,SENSORS_ASB100_ALARMS,&cur))  
    5479     alarms = cur + 0.5; 
    5480   else 
    5481     printf("ERROR: Can't get alarm data!\n"); 
    5482  
    5483   PRINT_ASB100_IN(0, name, alarms); 
    5484   PRINT_ASB100_IN(1, name, alarms); 
    5485   PRINT_ASB100_IN(2, name, alarms); 
    5486   PRINT_ASB100_IN(3, name, alarms); 
    5487   PRINT_ASB100_IN(4, name, alarms); 
    5488   PRINT_ASB100_IN(5, name, alarms); 
    5489   PRINT_ASB100_IN(6, name, alarms); 
    5490  
    5491   PRINT_ASB100_FAN(1, name, alarms); 
    5492   PRINT_ASB100_FAN(2, name, alarms); 
    5493   PRINT_ASB100_FAN(3, name, alarms); 
    5494  
    5495   PRINT_ASB100_TEMP(1, name, alarms); 
    5496   PRINT_ASB100_TEMP(2, name, alarms); 
    5497   PRINT_ASB100_TEMP(3, name, alarms); 
    5498   PRINT_ASB100_TEMP(4, name, alarms); 
    5499  
    5500   print_vid_info(name, SENSORS_ASB100_VID, SENSORS_ASB100_VRM); 
    5501  
    5502   if (!sensors_get_label_and_valid(*name,SENSORS_ASB100_ALARMS,&label,&valid)) { 
    5503     print_label(label,10); 
    5504     if (alarms & ASB100_ALARM_CHAS) 
    5505       printf("Chassis intrusion detection                      ALARM\n"); 
    5506     else 
    5507       printf("\n"); 
    5508   } 
    5509   free(label); 
    5510  
    5511 } 
    5512  
    5513 /* happens to be similar to asb100*/ 
    5514 #define PRINT_LM93_IN(num, name, alarms) \ 
    5515         print_asb100_in((name), ((alarms) & LM93_ALARM_IN##num), \ 
    5516                 (SENSORS_LM93_IN##num), \ 
    5517                 (SENSORS_LM93_IN##num##_MIN), \ 
    5518                 (SENSORS_LM93_IN##num##_MAX)) 
    5519  
    5520 /* print_lm93_fan() 
    5521  *   where fan and fan_min are sensors feature IDs 
    5522  */ 
    5523 static void print_lm93_fan(const sensors_chip_name *name, int alarm, 
    5524         int fan, int fan_min) 
    5525 { 
    5526   char *label; 
    5527   double cur, min; 
    5528   int valid; 
    5529  
    5530   if (!sensors_get_label_and_valid(*name,fan,&label,&valid) && 
    5531       !sensors_get_feature(*name,fan,&cur) && 
    5532       !sensors_get_feature(*name,fan_min,&min)) { 
    5533     if (valid) { 
    5534       print_label(label,10); 
    5535       printf("%4.0f RPM  (min = %4.0f RPM)                       %s\n", 
    5536            cur, min, alarm ? "ALARM" : ""); 
    5537     } 
    5538   } else 
    5539     printf("ERROR: Can't get FAN data! (0x%04x)\n", fan); 
    5540   free(label); 
    5541 } 
    5542  
    5543 #define PRINT_LM93_FAN(num, name, alarms) \ 
    5544         print_lm93_fan((name), ((alarms) & LM93_ALARM_FAN##num), \ 
    5545                 (SENSORS_LM93_FAN##num), \ 
    5546                 (SENSORS_LM93_FAN##num##_MIN)) 
    5547  
    5548 /* print_lm93_temp() 
    5549  * where temp, temp_min, and temp_max are sensors feature IDs 
    5550  */ 
    5551 static void print_lm93_temp(const sensors_chip_name *name, int alarm, 
    5552         int temp, int temp_min, int temp_max) 
    5553 { 
    5554   char *label; 
    5555   double cur, min, max; 
    5556   int valid; 
    5557  
    5558   if (!sensors_get_label_and_valid(*name,temp,&label,&valid) && 
    5559       !sensors_get_feature(*name,temp,&cur) && 
    5560       !sensors_get_feature(*name,temp_min,&min) && 
    5561       !sensors_get_feature(*name,temp_max,&max)) { 
    5562     if (valid) { 
    5563       print_label(label,10); 
    5564       print_temp_info(cur, max, min, MINMAX, 0, 0); 
    5565       printf("     %s\n", alarm ? "ALARM" : ""); 
    5566     } 
    5567   } else 
    5568     printf("ERROR: Can't get TEMP data! (0x%04x)\n", temp); 
    5569  
    5570   free(label); 
    5571 } 
    5572  
    5573 #define PRINT_LM93_TEMP(num, name, alarms) \ 
    5574         print_lm93_temp((name), ((alarms) & LM93_ALARM_TEMP##num), \ 
    5575                 (SENSORS_LM93_TEMP##num), \ 
    5576                 (SENSORS_LM93_TEMP##num##_MIN), \ 
    5577                 (SENSORS_LM93_TEMP##num##_MAX)) 
    5578  
    5579 /* print_lm93_vid() 
    5580  * where vid is a sensors feature ID 
    5581  */ 
    5582 static void print_lm93_vid(const sensors_chip_name *name, int vid) 
    5583 { 
    5584   char *label; 
    5585   double cur; 
    5586   int valid; 
    5587  
    5588   if (!sensors_get_label_and_valid(*name,vid,&label,&valid) && 
    5589       !sensors_get_feature(*name,vid,&cur)) { 
    5590     if (valid) { 
    5591       print_label(label,10); 
    5592       printf("%+5.3f V\n",cur); 
    5593     } 
    5594   } else { 
    5595     printf("ERROR: Can't get VID data! (0x%04x)\n", vid); 
    5596   } 
    5597   free(label); 
    5598 } 
    5599  
    5600 void print_lm93(const sensors_chip_name *name) 
    5601 { 
    5602   double cur; 
    5603   int alarms = 0; 
    5604  
    5605   if (!sensors_get_feature(*name,SENSORS_LM93_ALARMS,&cur))  
    5606     alarms = cur + 0.5; 
    5607   else 
    5608     printf("ERROR: Can't get alarm data!\n"); 
    5609  
    5610   PRINT_LM93_IN(1, name, alarms); 
    5611   PRINT_LM93_IN(2, name, alarms); 
    5612   PRINT_LM93_IN(3, name, alarms); 
    5613   PRINT_LM93_IN(4, name, alarms); 
    5614   PRINT_LM93_IN(5, name, alarms); 
    5615   PRINT_LM93_IN(6, name, alarms); 
    5616   PRINT_LM93_IN(7, name, alarms); 
    5617   PRINT_LM93_IN(8, name, alarms); 
    5618   PRINT_LM93_IN(9, name, alarms); 
    5619   PRINT_LM93_IN(10, name, alarms); 
    5620   PRINT_LM93_IN(11, name, alarms); 
    5621   PRINT_LM93_IN(12, name, alarms); 
    5622   PRINT_LM93_IN(13, name, alarms); 
    5623   PRINT_LM93_IN(14, name, alarms); 
    5624   PRINT_LM93_IN(15, name, alarms); 
    5625   PRINT_LM93_IN(16, name, alarms); 
    5626  
    5627   PRINT_LM93_FAN(1, name, alarms); 
    5628   PRINT_LM93_FAN(2, name, alarms); 
    5629   PRINT_LM93_FAN(3, name, alarms); 
    5630   PRINT_LM93_FAN(4, name, alarms); 
    5631  
    5632   PRINT_LM93_TEMP(1, name, alarms); 
    5633   PRINT_LM93_TEMP(2, name, alarms); 
    5634   PRINT_LM93_TEMP(3, name, alarms); 
    5635  
    5636   print_lm93_vid(name, SENSORS_LM93_VID1); 
    5637   print_lm93_vid(name, SENSORS_LM93_VID2); 
    5638 } 
    5639  
    5640 /* print_smsc47b397_temp() 
    5641  * where temp is a sensors feature ID 
    5642  */ 
    5643 static void print_smsc47b397_temp(const sensors_chip_name *name, int temp) 
    5644 { 
    5645   char *label; 
    5646   double cur; 
    5647   int valid; 
    5648  
    5649   if (!sensors_get_label_and_valid(*name,temp,&label,&valid) && 
    5650       !sensors_get_feature(*name,temp,&cur)) { 
    5651     if (valid) { 
    5652       print_label(label,10); 
    5653       print_temp_info(cur, 0, 0, SINGLE, 0, 0); 
    5654       printf("\n"); 
    5655     } 
    5656   } else 
    5657     printf("ERROR: Can't get TEMP data! (0x%04x)\n", temp); 
    5658  
    5659   free(label); 
    5660 } 
    5661  
    5662 #define PRINT_SMSC47B397_TEMP(num, name) \ 
    5663         print_smsc47b397_temp((name), (SENSORS_SMSC47B397_TEMP1 + (num))) 
    5664  
    5665 /* print_smsc47b397_fan() 
    5666  *   where fan is a sensors feature ID 
    5667  */ 
    5668 static void print_smsc47b397_fan(const sensors_chip_name *name, int fan) 
    5669 { 
    5670   char *label; 
    5671   double cur; 
    5672   int valid; 
    5673  
    5674   if (!sensors_get_label_and_valid(*name,fan,&label,&valid) && 
    5675       !sensors_get_feature(*name,fan,&cur)) { 
    5676     if (valid) { 
    5677       print_label(label,10); 
    5678       printf("%4.0f RPM\n", cur); 
    5679     } 
    5680   } else 
    5681     printf("ERROR: Can't get FAN data! (0x%04x)\n", fan); 
    5682   free(label); 
    5683 } 
    5684  
    5685 #define PRINT_SMSC47B397_FAN(num, name) \ 
    5686         print_smsc47b397_fan((name), (SENSORS_SMSC47B397_FAN1 + (num))) 
    5687  
    5688 void print_smsc47b397(const sensors_chip_name *name) 
    5689 { 
    5690   int ii; 
    5691  
    5692   for (ii=0;ii<4;ii++) 
    5693     PRINT_SMSC47B397_TEMP(ii, name); 
    5694  
    5695   for (ii=0;ii<4;ii++) 
    5696     PRINT_SMSC47B397_FAN(ii, name); 
    5697 } 
    5698  
    5699 void print_f71805f(const sensors_chip_name *name) 
    5700 { 
    5701   char *label; 
    5702   double cur, min, max; 
    5703   int alarms, valid, i; 
    5704   const int is_f71872f = !strcmp(name->prefix, "f71872f"); 
    5705  
    5706   if (!sensors_get_feature(*name, SENSORS_F71805F_ALARMS_IN, &cur)) 
    5707     alarms = cur + 0.5; 
    5708   else { 
    5709     printf("ERROR: Can't get alarms_in data!\n"); 
    5710     alarms = 0; 
    5711   } 
    5712  
    5713   for (i = 0; i < (is_f71872f ? 11 : 9); i++) { 
    5714     if (!sensors_get_label_and_valid(*name, SENSORS_F71805F_IN(i), 
    5715         &label, &valid) 
    5716      && !sensors_get_feature(*name, SENSORS_F71805F_IN(i), &cur) 
    5717      && !sensors_get_feature(*name, SENSORS_F71805F_IN_MIN(i), &min) 
    5718      && !sensors_get_feature(*name, SENSORS_F71805F_IN_MAX(i), &max)) { 
    5719       if (valid) { 
    5720         print_label(label, 10); 
    5721         printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)  %s\n", 
    5722                cur, min, max, (alarms & (1 << i)) ? "ALARM" : ""); 
    5723       } 
    5724     } else 
    5725       printf("ERROR: Can't get in%d data!\n", i); 
    5726     free(label); 
    5727   } 
    5728  
    5729   if (!sensors_get_feature(*name, SENSORS_F71805F_ALARMS_FAN, &cur)) 
    5730     alarms = cur + 0.5; 
    5731   else { 
    5732     printf("ERROR: Can't get alarms_fan data!\n"); 
    5733     alarms = 0; 
    5734   } 
    5735  
    5736   for (i = 1; i <= 3; i++) { 
    5737     if (!sensors_get_label_and_valid(*name, SENSORS_F71805F_FAN(i), 
    5738         &label, &valid) 
    5739      && !sensors_get_feature(*name, SENSORS_F71805F_FAN(i), &cur) 
    5740      && !sensors_get_feature(*name, SENSORS_F71805F_FAN_MIN(i), &min)) { 
    5741       if (valid) { 
    5742         print_label(label, 10); 
    5743         printf("%4.0f RPM  (min = %4.0f RPM)                  %s\n", 
    5744                cur, min, (alarms & (1 << (i - 1))) ? "ALARM" : ""); 
    5745       } 
    5746     } 
    5747     free(label); 
    5748   } 
    5749  
    5750   if (!sensors_get_feature(*name, SENSORS_F71805F_ALARMS_TEMP, &cur)) 
    5751     alarms = cur + 0.5; 
    5752   else { 
    5753     printf("ERROR: Can't get alarms_temp data!\n"); 
    5754     alarms = 0; 
    5755   } 
    5756  
    5757   for (i = 1; i <= 3; i++) { 
    5758     if (!sensors_get_label_and_valid(*name, SENSORS_F71805F_TEMP(i), 
    5759         &label, &valid) 
    5760      && !sensors_get_feature(*name, SENSORS_F71805F_TEMP(i), &cur) 
    5761      && !sensors_get_feature(*name, SENSORS_F71805F_TEMP_MAX(i), &max) 
    5762      && !sensors_get_feature(*name, SENSORS_F71805F_TEMP_HYST(i), &min)) { 
    5763       if (valid) { 
    5764         print_label(label, 10); 
    5765         print_temp_info(cur, max, min, HYST, 0, 0); 
    5766         printf("%5s", (alarms & (1 << (i - 1))) ? "ALARM" : ""); 
    5767         if (!sensors_get_feature(*name, SENSORS_F71805F_TEMP_TYPE(i), &cur)) { 
    5768           int sensor = cur + 0.5; 
    5769           printf("  [%s]", sensor == 3 ? "diode" : "thermistor"); 
    5770         } 
    5771         printf("\n"); 
    5772       } 
    5773     } else 
    5774       printf("ERROR: Can't get temp%d data!\n", i); 
    5775     free(label); 
    5776   } 
    5777 } 
    5778  
    5779 /* print_abituguru_in() 
    5780  *   where in, in_min, in_min_alarm, in_max and in_max_alarm are sensors 
    5781  *   feature IDs 
    5782  */ 
    5783 static void print_abituguru_in(const sensors_chip_name *name, int in, 
    5784   int in_min, int in_min_alarm, int in_max, int in_max_alarm) 
    5785 { 
    5786   char *label; 
    5787   double cur, min, max, alarm_low, alarm_high; 
    5788   int valid; 
    5789  
    5790   if (!sensors_get_label_and_valid(*name, in, &label, &valid)) { 
    5791     if (valid) { 
    5792       if (!sensors_get_feature(*name, in, &cur) && 
    5793           !sensors_get_feature(*name, in_min, &min) && 
    5794           !sensors_get_feature(*name, in_max, &max) && 
    5795           !sensors_get_feature(*name, in_min_alarm, &alarm_low) && 
    5796           !sensors_get_feature(*name, in_max_alarm, &alarm_high)) { 
    5797         print_label(label, 23); 
    5798         printf("%+6.2f V (min %+6.2f V, max %+6.2f V)", 
    5799                cur, min, max); 
    5800         if (alarm_low || alarm_high) { 
    5801           printf(" ALARM ("); 
    5802           if (alarm_low) 
    5803             printf("LOW"); 
    5804           if (alarm_high) 
    5805             printf("%sHIGH", (alarm_low) ? "," : ""); 
    5806           printf(")"); 
    5807         } 
    5808         printf("\n"); 
    5809       } else 
    5810         printf("ERROR: Can't get IN data! (0x%04x)\n", in); 
    5811     } 
    5812     free(label); 
    5813   } 
    5814 } 
    5815  
    5816 /* print_abituguru_temp() 
    5817  * where temp, temp_alarm, temp_max, and temp_crit are sensors feature IDs 
    5818  */ 
    5819 static void print_abituguru_temp(const sensors_chip_name *name, int temp, 
    5820         int temp_alarm, int temp_max, int temp_crit) 
    5821 { 
    5822   char *label; 
    5823   double cur, alarm, max, crit; 
    5824   int valid; 
    5825  
    5826   if (!sensors_get_label_and_valid(*name, temp, &label, &valid)) { 
    5827     if (valid) { 
    5828       if (!sensors_get_feature(*name, temp, &cur) && 
    5829           !sensors_get_feature(*name, temp_alarm, &alarm) && 
    5830           !sensors_get_feature(*name, temp_max, &max) && 
    5831           !sensors_get_feature(*name, temp_crit, &crit)) { 
    5832         print_label(label, 23); 
    5833         print_temp_info(cur, max, crit, CRIT, 0, 0); 
    5834         if (alarm) 
    5835           printf(" ALARM\n"); 
    5836         else 
    5837           printf("\n"); 
    5838       } else 
    5839         printf("ERROR: Can't get TEMP data! (0x%04x)\n", temp); 
    5840     } 
    5841     free(label); 
    5842   } 
    5843 } 
    5844  
    5845 /* print_abituguru_fan() 
    5846  *   where fan, fan_alarm and fan_min are sensors feature IDs 
    5847  */ 
    5848 static void print_abituguru_fan(const sensors_chip_name *name, int fan, 
    5849         int fan_alarm, int fan_min) 
    5850 { 
    5851   char *label; 
    5852   double cur, alarm, min; 
    5853   int valid; 
    5854  
    5855   if (!sensors_get_label_and_valid(*name, fan, &label, &valid)) { 
    5856     if (valid) { 
    5857       if (!sensors_get_feature(*name, fan, &cur) && 
    5858           !sensors_get_feature(*name, fan_alarm, &alarm) && 
    5859           !sensors_get_feature(*name, fan_min, &min)) { 
    5860         print_label(label, 23); 
    5861         printf("%4.0f RPM (min %4.0f RPM)               %s\n", 
    5862                cur, min, alarm ? "ALARM" : ""); 
    5863       } else 
    5864         printf("ERROR: Can't get FAN data! (0x%04x)\n", fan); 
    5865     } 
    5866     free(label); 
    5867   } 
    5868 } 
    5869  
    5870 void print_abituguru(const sensors_chip_name *name) 
    5871 { 
    5872   int i; 
    5873  
    5874   for (i=0; i<11; i++) 
    5875     print_abituguru_in(name, SENSORS_ABITUGURU_IN(i), 
    5876       SENSORS_ABITUGURU_IN_MIN(i), SENSORS_ABITUGURU_IN_MIN_ALARM(i), 
    5877       SENSORS_ABITUGURU_IN_MAX(i), SENSORS_ABITUGURU_IN_MAX_ALARM(i)); 
    5878  
    5879   for (i=1; i<=7; i++) 
    5880     print_abituguru_temp(name, SENSORS_ABITUGURU_TEMP(i), 
    5881       SENSORS_ABITUGURU_TEMP_ALARM(i), SENSORS_ABITUGURU_TEMP_MAX(i), 
    5882       SENSORS_ABITUGURU_TEMP_CRIT(i)); 
    5883  
    5884   for (i=1; i<=6; i++) 
    5885     print_abituguru_fan(name, SENSORS_ABITUGURU_FAN(i), 
    5886       SENSORS_ABITUGURU_FAN_ALARM(i), SENSORS_ABITUGURU_FAN_MIN(i)); 
    5887 } 
    5888  
    5889 void print_k8temp(const sensors_chip_name *name) 
    5890 { 
    5891   char *label; 
    5892   double cur; 
    5893   int valid, i; 
    5894  
    5895   for (i = 0; i < 4; i++) { 
    5896     if (!sensors_get_label_and_valid(*name, SENSORS_K8TEMP_TEMP1+i, &label, &valid) 
    5897          && !sensors_get_feature(*name, SENSORS_K8TEMP_TEMP1+i, &cur)) { 
    5898            if (valid) { 
    5899                 print_label(label, 10); 
    5900                 print_temp_info(cur, 0, 0, SINGLE, 0, 0); 
    5901                 printf("\n"); 
    5902            } 
    5903    } 
    5904    free(label); 
    5905  } 
    5906 } 
    5907  
    5908 void print_coretemp(const sensors_chip_name *name) 
    5909 { 
    5910   char *label; 
    5911   double cur, over, alarm; 
    5912   int valid; 
    5913  
    5914   if (!sensors_get_label_and_valid(*name, SENSORS_CORETEMP_TEMP1, &label, &valid) 
    5915    && !sensors_get_feature(*name, SENSORS_CORETEMP_TEMP1, &cur) 
    5916    && !sensors_get_feature(*name, SENSORS_CORETEMP_TEMP1_CRIT_ALARM, &alarm) 
    5917    && !sensors_get_feature(*name, SENSORS_CORETEMP_TEMP1_CRIT, &over)) { 
    5918     if (valid) { 
    5919       print_label(label, 10); 
    5920       print_temp_info(cur, over, 0, MAXONLY, 0, 0); 
    5921       printf(" %s\n", alarm ? "ALARM" : ""); 
    5922     } 
    5923   } else 
    5924     printf("ERROR: Can't get temperature data!\n"); 
    5925   free(label); 
    5926 } 
    5927  
    5928 static void print_dme1737_in(const sensors_chip_name *name, int i) 
    5929 { 
    5930   char *label; 
    5931   double cur, min, max, alarm; 
    5932   int valid; 
    5933  
    5934   if (!sensors_get_label_and_valid(*name, SENSORS_DME1737_IN(i), &label, 
    5935                                    &valid) && 
    5936       !sensors_get_feature(*name, SENSORS_DME1737_IN(i), &cur) && 
    5937       !sensors_get_feature(*name, SENSORS_DME1737_IN_MIN(i), &min) && 
    5938       !sensors_get_feature(*name, SENSORS_DME1737_IN_MAX(i), &max) && 
    5939       !sensors_get_feature(*name, SENSORS_DME1737_IN_ALARM(i), &alarm)) { 
    5940     if (valid) { 
    5941       print_label(label, 10); 
    5942       printf("%+6.2f V  (min = %+6.2f V, max = %+6.2f V)  %s\n", 
    5943              cur, min, max, alarm ? "ALARM" : ""); 
    5944     } 
    5945   } else { 
    5946     printf("ERROR: Can't get in%d data!\n", i); 
    5947   } 
    5948   free(label); 
    5949 } 
    5950  
    5951 static void print_dme1737_temp(const sensors_chip_name *name, int i) 
    5952 { 
    5953   char *label; 
    5954   double cur, min, max, alarm, fault; 
    5955   int valid; 
    5956  
    5957   if (!sensors_get_label_and_valid(*name, SENSORS_DME1737_TEMP(i), &label, 
    5958                                    &valid) && 
    5959       !sensors_get_feature(*name, SENSORS_DME1737_TEMP(i), &cur) && 
    5960       !sensors_get_feature(*name, SENSORS_DME1737_TEMP_MIN(i), &min) && 
    5961       !sensors_get_feature(*name, SENSORS_DME1737_TEMP_MAX(i), &max) && 
    5962       !sensors_get_feature(*name, SENSORS_DME1737_TEMP_ALARM(i), &alarm) && 
    5963       !sensors_get_feature(*name, SENSORS_DME1737_TEMP_FAULT(i), &fault)) { 
    5964     if (valid) { 
    5965       print_label(label, 10); 
    5966       print_temp_info(cur, max, min, MINMAX, 0, 0); 
    5967       printf("%s  %s\n", fault ? "FAULT" : "", alarm ? "ALARM" : ""); 
    5968     } 
    5969   } else { 
    5970     printf("ERROR: Can't get temp%d data!\n", i); 
    5971   } 
    5972   free(label); 
    5973 } 
    5974  
    5975 static void print_dme1737_fan(const sensors_chip_name *name, int i) 
    5976 { 
    5977   char *label; 
    5978   double cur, min, alarm; 
    5979   int valid; 
    5980  
    5981   if (!sensors_get_label_and_valid(*name, SENSORS_DME1737_FAN(i), &label, 
    5982                                    &valid) && 
    5983       !sensors_get_feature(*name, SENSORS_DME1737_FAN(i), &cur) && 
    5984       !sensors_get_feature(*name, SENSORS_DME1737_FAN_MIN(i), &min) && 
    5985       !sensors_get_feature(*name, SENSORS_DME1737_FAN_ALARM(i), &alarm)) { 
    5986     if (valid) { 
    5987       print_label(label, 10); 
    5988       printf("%4.0f RPM  (min = %4.0f RPM)  %s\n",  
    5989              cur, min, alarm ? "ALARM" : ""); 
    5990     } 
    5991   } else { 
    5992     printf("ERROR: Can't get fan%d data!\n", i); 
    5993   } 
    5994   free(label); 
    5995 } 
    5996  
    5997 static void print_dme1737_pwm(const sensors_chip_name *name, int i) 
    5998 { 
    5999   char *label; 
    6000   double cur, enable, freq; 
    6001   int valid; 
    6002  
    6003   if (!sensors_get_label_and_valid(*name, SENSORS_DME1737_PWM(i), &label, 
    6004                                    &valid) && 
    6005       !sensors_get_feature(*name, SENSORS_DME1737_PWM(i), &cur) && 
    6006       !sensors_get_feature(*name, SENSORS_DME1737_PWM_ENABLE(i), &enable) && 
    6007       !sensors_get_feature(*name, SENSORS_DME1737_PWM_FREQ(i), &freq)) { 
    6008     if (valid) { 
    6009       print_label(label, 10); 
    6010       printf("%4.0f      (enable = %1.0f, freq = %6.0f Hz)\n", cur, enable, freq); 
    6011     } 
    6012   } else { 
    6013     printf("ERROR: Can't get pwm%d data!\n", i); 
    6014   } 
    6015   free(label); 
    6016 } 
    6017  
    6018 void print_dme1737(const sensors_chip_name *name) 
    6019 { 
    6020   int i; 
    6021  
    6022   for (i = 0; i < 7; i++) { 
    6023     print_dme1737_in(name, i); 
    6024   } 
    6025  
    6026   for (i = 1; i < 4; i++) { 
    6027     print_dme1737_temp(name, i); 
    6028   } 
    6029  
    6030   for (i = 1; i < 7; i++) { 
    6031     print_dme1737_fan(name, i); 
    6032   } 
    6033  
    6034   for (i = 1; i < 7; i++) { 
    6035     if (i == 4) 
    6036       continue; 
    6037     print_dme1737_pwm(name, i); 
    6038   } 
    6039  
    6040   print_vid_info(name, SENSORS_DME1737_VID, SENSORS_DME1737_VRM); 
    6041 } 
    6042  
    6043131void print_unknown_chip(const sensors_chip_name *name) 
    6044132{ 
  • lm-sensors/branches/lm-sensors-3.0.0/prog/sensors/chips.h

    r4428 r4503  
    2525extern void print_unknown_chip(const sensors_chip_name *name); 
    2626 
    27 extern void print_asb100(const sensors_chip_name *name); 
    28 extern void print_ds1621(const sensors_chip_name *name); 
    29 extern void print_mtp008(const sensors_chip_name *name); 
    30 extern void print_lm75(const sensors_chip_name *name); 
    31 extern void print_adm1021(const sensors_chip_name *name); 
    32 extern void print_adm1024(const sensors_chip_name *name); 
    33 extern void print_adm1025(const sensors_chip_name *name); 
    34 extern void print_adm1026(const sensors_chip_name *name); 
    35 extern void print_adm9240(const sensors_chip_name *name); 
    36 extern void print_lm78(const sensors_chip_name *name); 
    37 extern void print_sis5595(const sensors_chip_name *name); 
    38 extern void print_via686a(const sensors_chip_name *name); 
    39 extern void print_gl518(const sensors_chip_name *name); 
    40 extern void print_gl520(const sensors_chip_name *name); 
    41 extern void print_lm80(const sensors_chip_name *name); 
    42 extern void print_lm85(const sensors_chip_name *name); 
    43 extern void print_w83781d(const sensors_chip_name *name); 
    44 extern void print_w83792d(const sensors_chip_name *name); 
    45 extern void print_w83793(const sensors_chip_name *name); 
    46 extern void print_w83l785ts(const sensors_chip_name *name); 
    47 extern void print_w83627ehf(const sensors_chip_name *name); 
    48 extern void print_maxilife(const sensors_chip_name *name); 
    49 extern void print_lm87(const sensors_chip_name *name); 
    50 extern void print_it87(const sensors_chip_name *name); 
    51 extern void print_fscpos(const sensors_chip_name *name); 
    52 extern void print_fscscy(const sensors_chip_name *name); 
    53 extern void print_fscher(const sensors_chip_name *name); 
    54 extern void print_pcf8591(const sensors_chip_name *name); 
    55 extern void print_vt1211(const sensors_chip_name *name); 
    56 extern void print_smsc47m1(const sensors_chip_name *name); 
    57 extern void print_smsc47m192(const sensors_chip_name *name); 
    58 extern void print_pc87360(const sensors_chip_name *name); 
    59 extern void print_pc87364(const sensors_chip_name *name); 
    60 extern void print_pc87366(const sensors_chip_name *name); 
    61 extern void print_pc87427(const sensors_chip_name *name); 
    62 extern void print_lm92(const sensors_chip_name *name); 
    63 extern void print_vt8231(const sensors_chip_name *name); 
    64 extern void print_bmc(const sensors_chip_name *name); 
    65 extern void print_lm83(const sensors_chip_name *name); 
    66 extern void print_lm90(const sensors_chip_name *name); 
    67 extern void print_lm63(const sensors_chip_name *name); 
    68 extern void print_lm93(const sensors_chip_name *name); 
    69 extern void print_max1619(const sensors_chip_name *name); 
    70 extern void print_xeontemp(const sensors_chip_name *name); 
    71 extern void print_max6650(const sensors_chip_name *name); 
    72 extern void print_adm1029(const sensors_chip_name *name); 
    73 extern void print_adm1031(const sensors_chip_name *name); 
    74 extern void print_smsc47b397(const sensors_chip_name *name); 
    75 extern void print_f71805f(const sensors_chip_name *name); 
    76 extern void print_abituguru(const sensors_chip_name *name); 
    77 extern void print_k8temp(const sensors_chip_name *name); 
    78 extern void print_coretemp(const sensors_chip_name *name); 
    79 extern void print_dme1737(const sensors_chip_name *name); 
    80  
    8127/* some functions used by chips_generic.c */ 
    8228#define HYST 0 
  • lm-sensors/branches/lm-sensors-3.0.0/prog/sensors/main.c

    r4465 r4503  
    317317} 
    318318 
    319 struct match { 
    320         const char * prefix; 
    321         void (*fn) (const sensors_chip_name *name); 
    322 }; 
    323  
    324 struct match matches[] = { 
    325 /*      { "ds1621", print_ds1621 }, */ 
    326         { "lm75", print_lm75 }, 
    327         { "adm1021", print_adm1021 }, 
    328         { "max1617", print_adm1021 }, 
    329         { "max1617a", print_adm1021 }, 
    330         { "thmc10", print_adm1021 }, 
    331         { "lm84", print_adm1021 }, 
    332         { "gl523", print_adm1021 }, 
    333         { "adm1023", print_adm1021 }, 
    334         { "mc1066", print_adm1021 }, 
    335         { "adm9240", print_adm9240 }, 
    336         { "ds1780", print_adm9240 }, 
    337         { "lm81", print_adm9240 }, 
    338         { "lm78", print_lm78 }, 
    339         { "lm78-j", print_lm78 }, 
    340         { "lm79", print_lm78 }, 
    341         { "mtp008", print_mtp008 }, 
    342         { "sis5595", print_sis5595 }, 
    343         { "via686a", print_via686a }, 
    344         { "lm80", print_lm80 }, 
    345         { "lm85", print_lm85 }, 
    346         { "lm85b", print_lm85 }, 
    347         { "lm85c", print_lm85 }, 
    348         { "adm1027", print_lm85 }, 
    349         { "adt7463", print_lm85 }, 
    350         { "emc6d100", print_lm85 }, 
    351         { "emc6d102", print_lm85 }, 
    352         { "lm87", print_lm87 }, 
    353         { "gl518sm", print_gl518 }, 
    354         { "gl520sm", print_gl520 }, 
    355         { "adm1025", print_adm1025 }, 
    356         { "ne1619", print_adm1025 }, 
    357         { "adm1024", print_adm1024 }, 
    358         { "w83781d", print_w83781d }, 
    359         { "w83782d", print_w83781d }, 
    360         { "w83783d", print_w83781d }, 
    361         { "w83627hf", print_w83781d }, 
    362         { "w83627thf", print_w83781d }, 
    363         { "w83637hf", print_w83781d }, 
    364         { "w83697hf", print_w83781d }, 
    365         { "w83687thf", print_w83781d }, 
    366         { "w83627ehf", print_w83627ehf }, 
    367         { "w83627dhg", print_w83627ehf }, 
    368         { "w83791d", print_w83781d }, 
    369         { "w83792d", print_w83792d }, 
    370         { "w83793", print_w83793 }, 
    371         { "w83l785ts", print_w83l785ts }, 
    372         { "as99127f", print_w83781d }, 
    373         { "maxilife", print_maxilife }, 
    374         { "maxilife-cg", print_maxilife }, 
    375         { "maxilife-co", print_maxilife }, 
    376         { "maxilife-as", print_maxilife }, 
    377         { "maxilife-nba", print_maxilife }, 
    378         { "it87", print_it87 }, 
    379         { "it8712", print_it87 }, 
    380         { "it8716", print_it87 }, 
    381         { "it8718", print_it87 }, 
    382         { "fscpos", print_fscpos }, 
    383         { "fscscy", print_fscscy }, 
    384         { "fscher", print_fscher }, 
    385         { "pcf8591", print_pcf8591 }, 
    386         { "vt1211", print_vt1211 }, 
    387         { "smsc47m192", print_smsc47m192 }, 
    388         { "smsc47m1", print_smsc47m1 }, 
    389         { "smsc47m2", print_smsc47m1 }, 
    390         { "pc87360", print_pc87360 }, 
    391         { "pc87363", print_pc87360 }, 
    392         { "pc87364", print_pc87364 }, 
    393         { "pc87365", print_pc87366 }, 
    394         { "pc87366", print_pc87366 }, 
    395         { "pc87427", print_pc87427 }, 
    396         { "lm92", print_lm92 }, 
    397         { "vt8231", print_vt8231 }, 
    398         { "bmc", print_bmc }, 
    399         { "adm1026", print_adm1026 }, 
    400         { "lm83", print_lm83 }, 
    401 /*      { "lm90", print_lm90 }, 
    402         { "adm1032", print_lm90 }, 
    403         { "lm99", print_lm90 }, 
    404         { "lm86", print_lm90 }, 
    405         { "max6657", print_lm90 }, 
    406         { "adt7461", print_lm90 }, */ 
    407         { "lm63", print_lm63 }, 
    408         { "xeontemp", print_xeontemp }, 
    409         { "max6650", print_max6650 }, 
    410         { "asb100", print_asb100 }, 
    411         { "adm1029", print_adm1029 }, 
    412         { "adm1030", print_adm1031 }, 
    413         { "adm1031", print_adm1031 }, 
    414         { "lm93", print_lm93 }, 
    415         { "smsc47b397", print_smsc47b397 }, 
    416 /*      { "f71805f", print_f71805f }, 
    417         { "f71872f", print_f71805f }, */ 
    418 //      { "abituguru", print_abituguru }, 
    419 //      { "k8temp", print_k8temp }, 
    420         { "coretemp", print_coretemp }, 
    421         { "dme1737", print_dme1737 }, 
    422         { NULL, NULL } 
    423 }; 
    424  
    425319void do_a_print(sensors_chip_name name) 
    426320{ 
    427   struct match *m; 
    428  
    429   /* do we know how to display it? */ 
    430   for(m = matches; m->prefix != NULL; m++) { 
    431     if(!strcmp(name.prefix, m->prefix)) break; 
    432   } 
    433  
    434   if(m->prefix==NULL && hide_unknown) 
     321  if (hide_unknown) 
    435322    return; 
    436323 
     
    445332  if (do_unknown) 
    446333    print_unknown_chip(&name); 
    447   else if(do_generic) 
     334  else 
    448335    print_generic_chip(&name); 
    449   else { 
    450     if(m->prefix == NULL) 
    451         print_generic_chip(&name); 
    452     else 
    453         m->fn(&name); 
    454   } 
    455336  printf("\n"); 
    456337}