diff --git a/prog/sensord/Module.mk b/prog/sensord/Module.mk
index d2a6bddb..7556b66a 100644
--- a/prog/sensord/Module.mk
+++ b/prog/sensord/Module.mk
@@ -27,7 +27,7 @@ PROGSENSORDMAN1FILES := $(MODULE_DIR)/sensord.8
 # Regrettably, even 'simply expanded variables' will not put their currently
 # defined value verbatim into the command-list of rules...
 PROGSENSORDTARGETS := $(MODULE_DIR)/sensord
-PROGSENSORDSOURCES := $(MODULE_DIR)/sensord.c $(MODULE_DIR)/chips.c
+PROGSENSORDSOURCES := $(MODULE_DIR)/args.c $(MODULE_DIR)/chips.c $(MODULE_DIR)/lib.c $(MODULE_DIR)/sense.c $(MODULE_DIR)/sensord.c
 
 # Include all dependency files. We use '.rd' to indicate this will create
 # executables.
diff --git a/prog/sensord/args.c b/prog/sensord/args.c
new file mode 100644
index 00000000..32b96c45
--- /dev/null
+++ b/prog/sensord/args.c
@@ -0,0 +1,211 @@
+/*
+ * sensord
+ *
+ * A daemon that periodically logs sensor information to syslog.
+ *
+ * Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <syslog.h>
+
+#include "sensord.h"
+#include "lib/error.h"
+
+#define MAX_CHIP_NAMES 32
+
+int isDaemon = 0;
+const char *sensorsCfgFile = "sensors.conf";
+int sleepTime = 5 * 60;
+int logTime = 30 * 60;
+int syslogFacility = LOG_LOCAL4;
+int doSet = 0;
+sensors_chip_name chipNames[MAX_CHIP_NAMES];
+int numChipNames = 0;
+
+static int
+parseTime
+(char *arg) {
+  char *end;
+  int value = strtoul (arg, &end, 10);
+  if ((end > arg) && (*end == 's')) {
+    ++ end;
+  } else if ((end > arg) && (*end == 'm')) {
+    value *= 60;
+    ++ end;
+  } else if ((end > arg) && (*end == 'h')) {
+    value *= 60 * 60;
+    ++ end;
+  }
+  if ((end == arg) || *end) {
+    fprintf (stderr, "Error parsing time value `%s'.\n", arg);
+    return -1;
+  }
+  return value;
+}
+
+static struct {
+  const char *name;
+  int id;
+} facilities[] = {
+  { "local0", LOG_LOCAL0 }, { "local1", LOG_LOCAL1 },
+  { "local2", LOG_LOCAL2 }, { "local3", LOG_LOCAL3 },
+  { "local4", LOG_LOCAL4 }, { "local5", LOG_LOCAL5 },
+  { "local6", LOG_LOCAL6 }, { "local7", LOG_LOCAL7 },
+  { "daemon", LOG_DAEMON }, { "user", LOG_USER },
+  { NULL }
+};
+
+static int
+parseFacility
+(char *arg) {
+  int i = 0;
+  while (facilities[i].name && strcasecmp (arg, facilities[i].name))
+    ++ i;
+  if (!facilities[i].name) {
+    fprintf (stderr, "Error parsing facility value `%s'.\n", arg);
+    return -1;
+  }
+  return facilities[i].id;
+}
+
+/* TODO: -s, --set */
+
+static const char *daemonSyntax =
+  "  -i, --interval <time>     -- interval between checking sensors (default 5m)\n"
+  "  -l, --log-interval <time> -- interval between logging sensors (default 30m)\n"
+  "  -f, --syslog-facility <f> -- syslog facility to use (default local4)\n";
+static const char *appSyntax =
+  "  -s, --set                 -- execute set statements too (root only)\n";
+static const char *commonSyntax =
+  "  -c, --config-file <file>  -- configuration file (default sensors.conf)\n"
+  "  -v, --version             -- display version and exit\n"
+  "  -h, --help                -- display help and exit\n"
+  "\n"
+  "If no path is specified, a list of directories is examined for the config file;\n"
+  "specify the filename `-' to read the config file from stdin.\n"
+  "\n"
+  "If no chips are specified, all chip info will be printed.\n";
+
+static const char *daemonShortOptions = "i:l:f:c:vh";
+
+static const struct option daemonLongOptions[] = {
+  { "interval", required_argument, NULL, 'i' },
+  { "log-interval", required_argument, NULL, 'l' },
+  { "syslog-facility", required_argument, NULL, 'f' },
+  { "config-file", required_argument, NULL, 'c' },
+  { "version", no_argument, NULL, 'v' },
+  { "help", no_argument, NULL, 'h' },
+  { NULL, 0, NULL, 0 }
+};
+
+static const char *appShortOptions = "sc:vh";
+
+static const struct option appLongOptions[] = {
+  { "set", no_argument, NULL, 's' },
+  { "config-file", required_argument, NULL, 'c' },
+  { "version", no_argument, NULL, 'v' },
+  { "help", no_argument, NULL, 'h' },
+  { NULL, 0, NULL, 0 }
+};
+
+int
+parseArgs
+(int argc, char **argv) {
+  int c;
+  const char *shortOptions;
+  const struct option *longOptions;
+
+  isDaemon = (argv[0][strlen (argv[0]) - 1] == 'd');
+  shortOptions = isDaemon ? daemonShortOptions : appShortOptions;
+  longOptions = isDaemon ? daemonLongOptions : appLongOptions;
+
+  while ((c = getopt_long (argc, argv, shortOptions, longOptions, NULL)) != EOF) {
+    switch(c) {
+      case 'i':
+        if ((sleepTime = parseTime (optarg)) < 0)
+          return -1;
+        break;
+      case 'l':
+        if ((logTime = parseTime (optarg)) < 0)
+          return -1;
+        break;
+      case 'f':
+        if ((syslogFacility = parseFacility (optarg)) < 0)
+          return -1;
+        break;
+      case 's':
+        doSet = 1;
+        break;
+      case 'c':
+        if ((sensorsCfgFile = strdup (optarg)) == NULL)
+          return -1;
+        break;
+      case 'v':
+        printf ("sensord version %s\n", version);
+        exit (EXIT_SUCCESS);
+        break;
+      case 'h':
+        printf ("Syntax: %s {options} {chips}\n%s%s", argv[0], isDaemon ? daemonSyntax : appSyntax, commonSyntax);
+        exit (EXIT_SUCCESS);
+        break;
+      case ':':
+      case '?':
+        printf ("Try `%s --help' for more information.\n", argv[0]);
+        return -1;
+        break;
+      default:
+        fprintf (stderr, "Internal error while parsing options.\n");
+        return -1;
+        break;
+    }
+  }
+  
+  if (logTime < sleepTime)
+    logTime = sleepTime;
+
+  return 0;
+}
+
+int
+parseChips
+(int argc, char **argv) {
+  if (optind == argc) {
+    chipNames[0].prefix = SENSORS_CHIP_NAME_PREFIX_ANY;
+    chipNames[0].bus = SENSORS_CHIP_NAME_BUS_ANY;
+    chipNames[0].addr = SENSORS_CHIP_NAME_ADDR_ANY;
+    numChipNames = 1;
+  } else {
+    int i, n = argc - optind, err;
+    if (n > MAX_CHIP_NAMES) {
+      fprintf (stderr, "Too many chip names.\n");
+      return -1;
+    }
+    for (i = 0; i < n; ++ i) {
+      char *arg = argv[optind + i];
+      if ((err = sensors_parse_chip_name (arg, chipNames + i))) {
+        fprintf (stderr, "Invalid chip name `%s': %s\n", arg, sensors_strerror (err));
+        return -1;
+      }
+    }
+    numChipNames = n;
+  }
+  return 0;
+}
diff --git a/prog/sensord/chips.c b/prog/sensord/chips.c
index e1106c4b..e3e7e0f5 100644
--- a/prog/sensord/chips.c
+++ b/prog/sensord/chips.c
@@ -1,10 +1,9 @@
 /*
  * sensord
  *
- * A daemon that logs all sensor information to /var/log/sensors
- * every 5 minutes.
+ * A daemon that periodically logs sensor information to syslog.
  *
- * Copyright (c) 1999 Merlin Hughes <merlin@merlin.org>
+ * Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,70 +20,118 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include "lib/sensors.h"
-#include "lib/chips.h"
+#include <stdio.h>
+#include <stdlib.h>
 
 #include "sensord.h"
+#include "lib/chips.h"
+#include "kernel/include/sensors.h"
 
-/* missing: "gl520sm", "thmc50", "adm1022" */
-
-/* I don't support gl518sm-r00 - but neither does sensors */
-
-/* Should the maxilife funky fan stuff be in sensors.conf? */
-
-/* I don't support alarms. */
+/* N.B: missing from sensors (and this) but in lib/chips.h: "gl520sm", "thmc50", "adm1022" */
 
 /** formatters **/
 
 static char buff[4096];
 
 static char *
-fmtValu_0
-(double values[]) {
-  sprintf (buff, "%.0f", values[0]);
+fmtExtra
+(int alarm, int beep) {
+  if (alarm)
+    sprintf (buff + strlen (buff), " [ALARM]");
+  if (beep)
+    sprintf (buff + strlen (buff), " [BEEP]");
   return buff;
 }
 
+static char *
+fmtValu_0
+(double values[], int alarm, int beep) {
+  sprintf (buff, "%.0f", values[0]);
+  return fmtExtra (alarm, beep);
+}
+
 static char *
 fmtTemps_0
-(double values[]) {
+(double values[], int alarm, int beep) {
   sprintf (buff, "%.0f C (limit = %.0f C, hysteresis = %.0f C)", values[0], values[1], values[2]);
-  return buff;
+  return fmtExtra (alarm, beep);
 }
 
 static char *
 fmtTemps_1
-(double values[]) {
+(double values[], int alarm, int beep) {
   sprintf (buff, "%.1f C (limit = %.1f C, hysteresis = %.1f C)", values[0], values[1], values[2]);
-  return buff;
+  return fmtExtra (alarm, beep);
 }
 
 static char *
 fmtVolt_2
-(double values[]) {
+(double values[], int alarm, int beep) {
   sprintf (buff, "%+.2f V", values[0]);
-  return buff;
+  return fmtExtra (alarm, beep);
 }
 
 static char *
 fmtVolts_2
-(double values[]) {
+(double values[], int alarm, int beep) {
   sprintf (buff, "%+.2f V (min = %+.2f V, max = %+.2f V)", values[0], values[1], values[2]);
-  return buff;
+  return fmtExtra (alarm, beep);
 }
 
 static char *
 fmtFans_0
-(double values[]) {
+(double values[], int alarm, int beep) {
   sprintf (buff, "%.0f RPM (min = %.0f RPM, div = %.0f)", values[0], values[1], values[2]);
-  return buff;
+  return fmtExtra (alarm, beep);
 }
 
 static char *
 fmtMHz_2
-(double values[]) {
+(double values[], int alarm, int beep) {
   sprintf (buff, "%.2f MHz (min = %.2f MHz, max = %.2f MHz)", values[0], values[1], values[2]);
-  return buff;
+  return fmtExtra (alarm, beep);
+}
+
+static char *
+fmtChassisIntrusionDetection
+(double values[], int alarm, int beep) {
+  sprintf (buff, "Chassis intrusion detection");
+  return fmtExtra (alarm, beep);
+}
+
+static char *
+fmtBoardTemperatureInput
+(double values[], int alarm, int beep) {
+  sprintf (buff, "Board temperature input"); /* N.B: "(usually LM75 chips)" */
+  return fmtExtra (alarm, beep);
+}
+
+static char *
+fmtSoundAlarm
+(double values[], int alarm, int beep) {
+  sprintf (buff, "Sound alarm %s", (values[0] < 0.5) ? "disabled" : "enabled");
+  return fmtExtra (alarm, beep);
+}
+
+static char *
+fmtInt
+(double values[], int alarm, int beep) {
+  sprintf (buff, "%d", (int) values[0]);
+  return fmtExtra (alarm, beep);
+}
+
+static char *
+fmtIntCrossInt
+(double values[], int alarm, int beep) {
+  sprintf (buff, "%dx%d", (int) values[0], (int) values[1]);
+  return fmtExtra (alarm, beep);
+}
+
+static char *
+fmtIntDashInt
+(double values[], int alarm, int beep) {
+  sprintf (buff, "%d-%d", (int) values[0], (int) values[1]);
+  return fmtExtra (alarm, beep);
 }
 
 /** LM75 **/
@@ -93,373 +140,634 @@ static const char *lm75_names[] = {
   SENSORS_LM75_PREFIX, NULL
 };
 
-static FeatureDescriptor lm75_features[] = {
-  { fmtTemps_1, SENSORS_LM75_TEMP,
+static const FeatureDescriptor lm75_features[] = {
+  { fmtTemps_1, 0, 0,
     { SENSORS_LM75_TEMP, SENSORS_LM75_TEMP_HYST, SENSORS_LM75_TEMP_OVER, -1 } },
   { NULL }
 };
 
+static const ChipDescriptor lm75_chip = {
+  lm75_names, lm75_features, 0, 0
+};
+
 /** ADM1021 **/
 
 static const char *adm1021_names[] = {
   SENSORS_ADM1021_PREFIX, NULL
 };
 
-static FeatureDescriptor adm1021_features[] = {
-  { fmtTemps_0, SENSORS_ADM1021_TEMP,
+static const FeatureDescriptor adm1021_features[] = {
+  { fmtTemps_0, ADM1021_ALARM_TEMP_HIGH | ADM1021_ALARM_TEMP_LOW, 0, /* TODO!! */
     { SENSORS_ADM1021_TEMP, SENSORS_ADM1021_TEMP_OVER, SENSORS_ADM1021_TEMP_HYST, -1 } },
-  { fmtTemps_0, SENSORS_ADM1021_REMOTE_TEMP,
+  { fmtTemps_0, ADM1021_ALARM_RTEMP_HIGH | ADM1021_ALARM_RTEMP_LOW | ADM1021_ALARM_RTEMP_NA, 0, /* TODO!! */
     { SENSORS_ADM1021_REMOTE_TEMP, SENSORS_ADM1021_REMOTE_TEMP_OVER, SENSORS_ADM1021_REMOTE_TEMP_HYST, -1 } },
-  { fmtValu_0, SENSORS_ADM1021_DIE_CODE,
+  { fmtValu_0, 0, 0,
     { SENSORS_ADM1021_DIE_CODE, -1 } },
   { NULL }
 };
 
+static const ChipDescriptor adm1021_chip = {
+  adm1021_names, adm1021_features, SENSORS_ADM1021_ALARMS, 0
+};
+
 /** MAX1617 **/
 
 static const char *max1617_names[] = {
   SENSORS_MAX1617_PREFIX, SENSORS_MAX1617A_PREFIX, SENSORS_THMC10_PREFIX, SENSORS_LM84_PREFIX, SENSORS_GL523_PREFIX, NULL
 };
 
-static FeatureDescriptor max1617_features[] = {
-  { fmtTemps_0, SENSORS_ADM1021_TEMP,
-    { SENSORS_ADM1021_TEMP, SENSORS_ADM1021_TEMP_OVER, SENSORS_ADM1021_TEMP_HYST, -1 } },
-  { fmtTemps_0, SENSORS_ADM1021_REMOTE_TEMP,
-    { SENSORS_ADM1021_REMOTE_TEMP, SENSORS_ADM1021_REMOTE_TEMP_OVER, SENSORS_ADM1021_REMOTE_TEMP_HYST, -1 } },
+static const FeatureDescriptor max1617_features[] = {
+  { fmtTemps_0, ADM1021_ALARM_TEMP_HIGH | ADM1021_ALARM_TEMP_LOW, 0, /* TODO!! */
+    { SENSORS_MAX1617_TEMP, SENSORS_MAX1617_TEMP_OVER, SENSORS_MAX1617_TEMP_HYST, -1 } },
+  { fmtTemps_0, ADM1021_ALARM_RTEMP_HIGH | ADM1021_ALARM_RTEMP_LOW | ADM1021_ALARM_RTEMP_NA, 0, /* TODO!! */
+    { SENSORS_MAX1617_REMOTE_TEMP, SENSORS_MAX1617_REMOTE_TEMP_OVER, SENSORS_MAX1617_REMOTE_TEMP_HYST, -1 } },
   { NULL }
 };
 
+static const ChipDescriptor max1617_chip = {
+  max1617_names, max1617_features, SENSORS_MAX1617_ALARMS, 0
+};
+
 /** ADM9240 **/
 
 static const char *adm9240_names[] = {
   SENSORS_ADM9240_PREFIX, SENSORS_DS1780_PREFIX, SENSORS_LM81_PREFIX, NULL
 };
 
-static FeatureDescriptor adm9240_features[] = {
-  { fmtVolts_2, SENSORS_ADM9240_IN0,
+static const FeatureDescriptor adm9240_features[] = {
+  { fmtVolts_2, ADM9240_ALARM_IN0, 0,
     { SENSORS_ADM9240_IN0, SENSORS_ADM9240_IN0_MIN, SENSORS_ADM9240_IN0_MAX, -1 } },
-  { fmtVolts_2, SENSORS_ADM9240_IN1,
+  { fmtVolts_2, ADM9240_ALARM_IN1, 0,
     { SENSORS_ADM9240_IN1, SENSORS_ADM9240_IN1_MIN, SENSORS_ADM9240_IN1_MAX, -1 } },
-  { fmtVolts_2, SENSORS_ADM9240_IN2,
+  { fmtVolts_2, ADM9240_ALARM_IN2, 0,
     { SENSORS_ADM9240_IN2, SENSORS_ADM9240_IN2_MIN, SENSORS_ADM9240_IN2_MAX, -1 } },
-  { fmtVolts_2, SENSORS_ADM9240_IN3,
+  { fmtVolts_2, ADM9240_ALARM_IN3, 0,
     { SENSORS_ADM9240_IN3, SENSORS_ADM9240_IN3_MIN, SENSORS_ADM9240_IN3_MAX, -1 } },
-  { fmtVolts_2, SENSORS_ADM9240_IN4,
+  { fmtVolts_2, ADM9240_ALARM_IN4, 0,
     { SENSORS_ADM9240_IN4, SENSORS_ADM9240_IN4_MIN, SENSORS_ADM9240_IN4_MAX, -1 } },
-  { fmtVolts_2, SENSORS_ADM9240_IN5,
+  { fmtVolts_2, ADM9240_ALARM_IN5, 0,
     { SENSORS_ADM9240_IN5, SENSORS_ADM9240_IN5_MIN, SENSORS_ADM9240_IN5_MAX, -1 } },
-  { fmtFans_0, SENSORS_ADM9240_FAN1,
+  { fmtFans_0, ADM9240_ALARM_FAN1, 0,
     { SENSORS_ADM9240_FAN1, SENSORS_ADM9240_FAN1_MIN, SENSORS_ADM9240_FAN1_DIV, -1 } },
-  { fmtFans_0, SENSORS_ADM9240_FAN2,
+  { fmtFans_0, ADM9240_ALARM_FAN2, 0,
     { SENSORS_ADM9240_FAN2, SENSORS_ADM9240_FAN2_MIN, SENSORS_ADM9240_FAN2_DIV, -1 } },
-  { fmtTemps_0, SENSORS_ADM9240_TEMP,
+  { fmtTemps_0, ADM9240_ALARM_TEMP, 0,
     { SENSORS_ADM9240_TEMP, SENSORS_ADM9240_TEMP_OVER, SENSORS_ADM9240_TEMP_HYST, -1 } },
-  { fmtVolt_2, SENSORS_ADM9240_VID,
+  { fmtVolt_2, 0, 0,
     { SENSORS_ADM9240_VID, -1 } },
+  { fmtChassisIntrusionDetection, ADM9240_ALARM_CHAS, 0,
+    { SENSORS_ADM9240_ALARMS, -1 } },
   { NULL }
 };
 
+static const ChipDescriptor adm9240_chip = {
+  adm9240_names, adm9240_features, SENSORS_ADM9240_ALARMS, 0
+};
+
+/** LM78 **/
+
+static const char *lm78_names[] = {
+  SENSORS_LM78_PREFIX, SENSORS_LM78J_PREFIX, SENSORS_LM79_PREFIX, NULL
+};
+
+static const FeatureDescriptor lm78_features[] = {
+  { fmtVolts_2, LM78_ALARM_IN0, 0,
+    { SENSORS_LM78_IN0, SENSORS_LM78_IN0_MIN, SENSORS_LM78_IN0_MAX, -1 } },
+  { fmtVolts_2, LM78_ALARM_IN1, 0,
+    { SENSORS_LM78_IN1, SENSORS_LM78_IN1_MIN, SENSORS_LM78_IN1_MAX, -1 } },
+  { fmtVolts_2, LM78_ALARM_IN2, 0,
+    { SENSORS_LM78_IN2, SENSORS_LM78_IN2_MIN, SENSORS_LM78_IN2_MAX, -1 } },
+  { fmtVolts_2, LM78_ALARM_IN3, 0,
+    { SENSORS_LM78_IN3, SENSORS_LM78_IN3_MIN, SENSORS_LM78_IN3_MAX, -1 } },
+  { fmtVolts_2, LM78_ALARM_IN4, 0,
+    { SENSORS_LM78_IN4, SENSORS_LM78_IN4_MIN, SENSORS_LM78_IN4_MAX, -1 } },
+  { fmtVolts_2, LM78_ALARM_IN5, 0,
+    { SENSORS_LM78_IN5, SENSORS_LM78_IN5_MIN, SENSORS_LM78_IN5_MAX, -1 } },
+  { fmtVolts_2, LM78_ALARM_IN6, 0,
+    { SENSORS_LM78_IN6, SENSORS_LM78_IN6_MIN, SENSORS_LM78_IN6_MAX, -1 } },
+  { fmtFans_0, LM78_ALARM_FAN1, 0,
+    { SENSORS_LM78_FAN1, SENSORS_LM78_FAN1_MIN, SENSORS_LM78_FAN1_DIV, -1 } },
+  { fmtFans_0, LM78_ALARM_FAN2, 0,
+    { SENSORS_LM78_FAN2, SENSORS_LM78_FAN2_MIN, SENSORS_LM78_FAN2_DIV, -1 } },
+  { fmtFans_0, LM78_ALARM_FAN3, 0,
+    { SENSORS_LM78_FAN3, SENSORS_LM78_FAN3_MIN, SENSORS_LM78_FAN3_DIV, -1 } },
+  { fmtTemps_0, LM78_ALARM_TEMP, 0,
+    { SENSORS_LM78_TEMP, SENSORS_LM78_TEMP_OVER, SENSORS_LM78_TEMP_HYST, -1 } },
+  { fmtBoardTemperatureInput, LM78_ALARM_BTI, 0,
+    { SENSORS_LM78_ALARMS, -1 } },
+  { fmtChassisIntrusionDetection, LM78_ALARM_CHAS, 0,
+    { SENSORS_LM78_ALARMS, -1 } },
+  { fmtVolt_2, 0, 0,
+    { SENSORS_LM78_VID, -1 } },
+  { NULL }
+};
+
+static const ChipDescriptor lm78_chip = {
+  lm78_names, lm78_features, SENSORS_LM78_ALARMS, 0
+};
+
 /** SIS5595 **/
 
 static const char *sis5595_names[] = {
   SENSORS_SIS5595_PREFIX, NULL
 };
 
-static FeatureDescriptor sis5595_features[] = {
-  { fmtVolts_2, SENSORS_SIS5595_IN0,
+static const FeatureDescriptor sis5595_features[] = {
+  { fmtVolts_2, SIS5595_ALARM_IN0, 0,
     { SENSORS_SIS5595_IN0, SENSORS_SIS5595_IN0_MIN, SENSORS_SIS5595_IN0_MAX, -1 } },
-  { fmtVolts_2, SENSORS_SIS5595_IN1,
+  { fmtVolts_2, SIS5595_ALARM_IN1, 0,
     { SENSORS_SIS5595_IN1, SENSORS_SIS5595_IN1_MIN, SENSORS_SIS5595_IN1_MAX, -1 } },
-  { fmtVolts_2, SENSORS_SIS5595_IN2,
+  { fmtVolts_2, SIS5595_ALARM_IN2, 0,
     { SENSORS_SIS5595_IN2, SENSORS_SIS5595_IN2_MIN, SENSORS_SIS5595_IN2_MAX, -1 } },
-  { fmtVolts_2, SENSORS_SIS5595_IN3,
+  { fmtVolts_2, SIS5595_ALARM_IN3, 0,
     { SENSORS_SIS5595_IN3, SENSORS_SIS5595_IN3_MIN, SENSORS_SIS5595_IN3_MAX, -1 } },
-  { fmtFans_0, SENSORS_SIS5595_FAN1,
+  { fmtFans_0, SIS5595_ALARM_FAN1, 0,
     { SENSORS_SIS5595_FAN1, SENSORS_SIS5595_FAN1_MIN, SENSORS_SIS5595_FAN1_DIV, -1 } },
-  { fmtFans_0, SENSORS_SIS5595_FAN2,
+  { fmtFans_0, SIS5595_ALARM_FAN2, 0,
     { SENSORS_SIS5595_FAN2, SENSORS_SIS5595_FAN2_MIN, SENSORS_SIS5595_FAN2_DIV, -1 } },
-  { fmtTemps_0, SENSORS_SIS5595_TEMP,
+  { fmtTemps_0, SIS5595_ALARM_TEMP, 0,
     { SENSORS_SIS5595_TEMP, SENSORS_SIS5595_TEMP_OVER, SENSORS_SIS5595_TEMP_HYST, -1 } },
+  { fmtBoardTemperatureInput, SIS5595_ALARM_BTI, 0,
+    { SENSORS_SIS5595_ALARMS, -1 } },
   { NULL }
 };
 
-/** LM78 **/
-
-static const char *lm78_names[] = {
-  SENSORS_LM78_PREFIX, SENSORS_LM78J_PREFIX, SENSORS_LM79_PREFIX, /*"sis5595",*/ NULL
+static const ChipDescriptor sis5595_chip = {
+  sis5595_names, sis5595_features, SENSORS_SIS5595_ALARMS, 0
 };
 
-static FeatureDescriptor lm78_features[] = {
-  { fmtVolts_2, SENSORS_LM78_IN0,
-    { SENSORS_LM78_IN0, SENSORS_LM78_IN0_MIN, SENSORS_LM78_IN0_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM78_IN1,
-    { SENSORS_LM78_IN1, SENSORS_LM78_IN1_MIN, SENSORS_LM78_IN1_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM78_IN2,
-    { SENSORS_LM78_IN2, SENSORS_LM78_IN2_MIN, SENSORS_LM78_IN2_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM78_IN3,
-    { SENSORS_LM78_IN3, SENSORS_LM78_IN3_MIN, SENSORS_LM78_IN3_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM78_IN4,
-    { SENSORS_LM78_IN4, SENSORS_LM78_IN4_MIN, SENSORS_LM78_IN4_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM78_IN5,
-    { SENSORS_LM78_IN5, SENSORS_LM78_IN5_MIN, SENSORS_LM78_IN5_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM78_IN6,
-    { SENSORS_LM78_IN6, SENSORS_LM78_IN6_MIN, SENSORS_LM78_IN6_MAX, -1 } },
-  { fmtFans_0, SENSORS_LM78_FAN1,
-    { SENSORS_LM78_FAN1, SENSORS_LM78_FAN1_MIN, SENSORS_LM78_FAN1_DIV, -1 } },
-  { fmtFans_0, SENSORS_LM78_FAN2,
-    { SENSORS_LM78_FAN2, SENSORS_LM78_FAN2_MIN, SENSORS_LM78_FAN2_DIV, -1 } },
-  { fmtFans_0, SENSORS_LM78_FAN3,
-    { SENSORS_LM78_FAN3, SENSORS_LM78_FAN3_MIN, SENSORS_LM78_FAN3_DIV, -1 } },
-  { fmtTemps_0, SENSORS_LM78_TEMP,
-    { SENSORS_LM78_TEMP, SENSORS_LM78_TEMP_OVER, SENSORS_LM78_TEMP_HYST, -1 } },
-  { fmtVolt_2, SENSORS_LM78_VID,
-    { SENSORS_LM78_VID, -1 } },
+/** VIA686A **/
+
+static const char *via686a_names[] = {
+  SENSORS_VIA686A_PREFIX, NULL
+};
+
+static const FeatureDescriptor via686a_features[] = {
+  { fmtVolts_2, VIA686A_ALARM_IN0, 0,
+    { SENSORS_VIA686A_IN0, SENSORS_VIA686A_IN0_MIN, SENSORS_VIA686A_IN0_MAX, -1 } },
+  { fmtVolts_2, VIA686A_ALARM_IN1, 0,
+    { SENSORS_VIA686A_IN1, SENSORS_VIA686A_IN1_MIN, SENSORS_VIA686A_IN1_MAX, -1 } },
+  { fmtVolts_2, VIA686A_ALARM_IN2, 0,
+    { SENSORS_VIA686A_IN2, SENSORS_VIA686A_IN2_MIN, SENSORS_VIA686A_IN2_MAX, -1 } },
+  { fmtVolts_2, VIA686A_ALARM_IN3, 0,
+    { SENSORS_VIA686A_IN3, SENSORS_VIA686A_IN3_MIN, SENSORS_VIA686A_IN3_MAX, -1 } },
+  { fmtVolts_2, VIA686A_ALARM_IN4, 0,
+    { SENSORS_VIA686A_IN4, SENSORS_VIA686A_IN4_MIN, SENSORS_VIA686A_IN4_MAX, -1 } },
+  { fmtFans_0, VIA686A_ALARM_FAN1, 0,
+    { SENSORS_VIA686A_FAN1, SENSORS_VIA686A_FAN1_MIN, SENSORS_VIA686A_FAN1_DIV, -1 } },
+  { fmtFans_0, VIA686A_ALARM_FAN2, 0,
+    { SENSORS_VIA686A_FAN2, SENSORS_VIA686A_FAN2_MIN, SENSORS_VIA686A_FAN2_DIV, -1 } },
+  { fmtTemps_1, VIA686A_ALARM_TEMP, 0,
+    { SENSORS_VIA686A_TEMP, SENSORS_VIA686A_TEMP_OVER, SENSORS_VIA686A_TEMP_HYST, -1 } },
+  { fmtTemps_1, VIA686A_ALARM_TEMP2, 0,
+    { SENSORS_VIA686A_TEMP2, SENSORS_VIA686A_TEMP2_OVER, SENSORS_VIA686A_TEMP2_HYST, -1 } },
+  { fmtTemps_1, VIA686A_ALARM_TEMP3, 0,
+    { SENSORS_VIA686A_TEMP3, SENSORS_VIA686A_TEMP3_OVER, SENSORS_VIA686A_TEMP3_HYST, -1 } },
   { NULL }
 };
 
-/** GL518 **/
-
-static const char *gl518_names[] = {
-  SENSORS_GL518_PREFIX, NULL
-};
-
-static FeatureDescriptor gl518_features[] = {
-  { fmtVolts_2, SENSORS_GL518_VDD,
-    { SENSORS_GL518_VDD, SENSORS_GL518_VDD_MIN, SENSORS_GL518_VDD_MAX, -1 } },
-  { fmtVolts_2, SENSORS_GL518_VIN1,
-    { SENSORS_GL518_VIN1, SENSORS_GL518_VIN1_MIN, SENSORS_GL518_VIN1_MAX, -1 } },
-  { fmtVolts_2, SENSORS_GL518_VIN2,
-    { SENSORS_GL518_VIN2, SENSORS_GL518_VIN2_MIN, SENSORS_GL518_VIN2_MAX, -1 } },
-  { fmtVolts_2, SENSORS_GL518_VIN3,
-    { SENSORS_GL518_VIN3, SENSORS_GL518_VIN3_MIN, SENSORS_GL518_VIN3_MAX, -1 } },
-  { fmtFans_0, SENSORS_GL518_FAN1,
-    { SENSORS_GL518_FAN1, SENSORS_GL518_FAN1_MIN, SENSORS_GL518_FAN1_DIV, -1 } },
-  { fmtFans_0, SENSORS_GL518_FAN2,
-    { SENSORS_GL518_FAN2, SENSORS_GL518_FAN2_MIN, SENSORS_GL518_FAN2_DIV, -1 } },
-  { fmtTemps_0, SENSORS_GL518_TEMP,
-    { SENSORS_GL518_TEMP, SENSORS_GL518_TEMP_OVER, SENSORS_GL518_TEMP_HYST, -1 } },
-  { NULL }
+static const ChipDescriptor via686a_chip = {
+  via686a_names, via686a_features, SENSORS_VIA686A_ALARMS, 0
 };
 
 /** LM80 **/
 
-static char *
+static char * /* N.B: in sensors the first temp is %.2f!! */
 fmtTemps_LM80
-(double values[]) {
+(double values[], int alarm, int beep) {
   sprintf (buff, "%.0f C (hot limit = %.0f C, hot hysteresis = %.0f C, os limit = %.0f C, os hysteresis = %.0f C)", values[0], values[1], values[2], values[3], values[4]);
-  return buff;
+  return fmtExtra (alarm, beep);
 }
 
 static const char *lm80_names[] = {
   SENSORS_LM80_PREFIX, NULL
 };
 
-static FeatureDescriptor lm80_features[] = {
-  { fmtVolts_2, SENSORS_LM80_IN0,
+static const FeatureDescriptor lm80_features[] = {
+  { fmtVolts_2, LM80_ALARM_IN0, 0,
     { SENSORS_LM80_IN0, SENSORS_LM80_IN0_MIN, SENSORS_LM80_IN0_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM80_IN1,
+  { fmtVolts_2, LM80_ALARM_IN1, 0,
     { SENSORS_LM80_IN1, SENSORS_LM80_IN1_MIN, SENSORS_LM80_IN1_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM80_IN2,
+  { fmtVolts_2, LM80_ALARM_IN2, 0,
     { SENSORS_LM80_IN2, SENSORS_LM80_IN2_MIN, SENSORS_LM80_IN2_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM80_IN3,
+  { fmtVolts_2, LM80_ALARM_IN3, 0,
     { SENSORS_LM80_IN3, SENSORS_LM80_IN3_MIN, SENSORS_LM80_IN3_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM80_IN4,
+  { fmtVolts_2, LM80_ALARM_IN4, 0,
     { SENSORS_LM80_IN4, SENSORS_LM80_IN4_MIN, SENSORS_LM80_IN4_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM80_IN5,
+  { fmtVolts_2, LM80_ALARM_IN5, 0,
     { SENSORS_LM80_IN5, SENSORS_LM80_IN5_MIN, SENSORS_LM80_IN5_MAX, -1 } },
-  { fmtVolts_2, SENSORS_LM80_IN6,
+  { fmtVolts_2, LM80_ALARM_IN6, 0,
     { SENSORS_LM80_IN6, SENSORS_LM80_IN6_MIN, SENSORS_LM80_IN6_MAX, -1 } },
-  { fmtFans_0, SENSORS_LM80_FAN1,
+  { fmtFans_0, LM80_ALARM_FAN1, 0,
     { SENSORS_LM80_FAN1, SENSORS_LM80_FAN1_MIN, SENSORS_LM80_FAN1_DIV, -1 } },
-  { fmtFans_0, SENSORS_LM80_FAN2,
+  { fmtFans_0, LM80_ALARM_FAN2, 0,
     { SENSORS_LM80_FAN2, SENSORS_LM80_FAN2_MIN, SENSORS_LM80_FAN2_DIV, -1 } },
-  { fmtTemps_LM80, SENSORS_LM80_TEMP,
+  { fmtTemps_LM80, LM80_ALARM_TEMP_HOT, 0,
     { SENSORS_LM80_TEMP, SENSORS_LM80_TEMP_HOT_MAX, SENSORS_LM80_TEMP_HOT_HYST, SENSORS_LM80_TEMP_OS_MAX, SENSORS_LM80_TEMP_OS_HYST, -1 } },
+  { fmtBoardTemperatureInput, LM80_ALARM_BTI, 0,
+    { SENSORS_LM80_ALARMS, -1 } },
+  { fmtChassisIntrusionDetection, LM80_ALARM_CHAS, 0,
+    { SENSORS_LM80_ALARMS, -1 } },
   { NULL }
 };
 
+static const ChipDescriptor lm80_chip = {
+  lm80_names, lm80_features, SENSORS_LM80_ALARMS, 0
+};
+
+/** GL518 **/
+
+/* N.B: sensors supports a "gl518sm-r00" but it is not picked up in main.c...
+static char *
+fmtVolts_GL518_R00
+(double values[], int alarm, int beep) {
+  if (values[0] == 0.0)
+    sprintf (buff, "n/a (min = %+.2f V, max = %+.2f V)", values[1], values[2]);
+  else
+    sprintf (buff, "%+.2f V (min = %+.2f V, max = %+.2f V)", values[0], values[1], values[2]);
+  return fmtExtra (alarm, beep);
+}
+*/
+
+static const char *gl518_names[] = {
+  SENSORS_GL518_PREFIX, NULL
+};
+
+static const FeatureDescriptor gl518_features[] = {
+  { fmtVolts_2, GL518_ALARM_VDD, GL518_ALARM_VDD,
+    { SENSORS_GL518_VDD, SENSORS_GL518_VDD_MIN, SENSORS_GL518_VDD_MAX, -1 } },
+  { fmtVolts_2, GL518_ALARM_VIN1, GL518_ALARM_VIN1,
+    { SENSORS_GL518_VIN1, SENSORS_GL518_VIN1_MIN, SENSORS_GL518_VIN1_MAX, -1 } },
+  { fmtVolts_2, GL518_ALARM_VIN2, GL518_ALARM_VIN2,
+    { SENSORS_GL518_VIN2, SENSORS_GL518_VIN2_MIN, SENSORS_GL518_VIN2_MAX, -1 } },
+  { fmtVolts_2, GL518_ALARM_VIN3, GL518_ALARM_VIN3,
+    { SENSORS_GL518_VIN3, SENSORS_GL518_VIN3_MIN, SENSORS_GL518_VIN3_MAX, -1 } },
+  { fmtFans_0, GL518_ALARM_FAN1, GL518_ALARM_FAN1,
+    { SENSORS_GL518_FAN1, SENSORS_GL518_FAN1_MIN, SENSORS_GL518_FAN1_DIV, -1 } },
+  { fmtFans_0, GL518_ALARM_FAN2, GL518_ALARM_FAN2,
+    { SENSORS_GL518_FAN2, SENSORS_GL518_FAN2_MIN, SENSORS_GL518_FAN2_DIV, -1 } },
+  { fmtTemps_0, GL518_ALARM_TEMP, GL518_ALARM_TEMP,
+    { SENSORS_GL518_TEMP, SENSORS_GL518_TEMP_OVER, SENSORS_GL518_TEMP_HYST, -1 } },
+  { fmtSoundAlarm, 0, 0,
+    { SENSORS_GL518_BEEP_ENABLE, -1 } },
+  { NULL }
+};
+
+static const ChipDescriptor gl518_chip = {
+  gl518_names, gl518_features, SENSORS_GL518_ALARMS, SENSORS_GL518_BEEPS
+};
+
+/** ADM1025 **/
+
+static const char *adm1025_names[] = {
+  SENSORS_ADM1025_PREFIX, NULL
+};
+
+static const FeatureDescriptor adm1025_features[] = {
+  { fmtVolts_2, ADM1025_ALARM_IN0, 0,
+    { SENSORS_ADM1025_IN0, SENSORS_ADM1025_IN0_MIN, SENSORS_ADM1025_IN0_MAX, -1 } },
+  { fmtVolts_2, ADM1025_ALARM_IN1, 0,
+    { SENSORS_ADM1025_IN1, SENSORS_ADM1025_IN1_MIN, SENSORS_ADM1025_IN1_MAX, -1 } },
+  { fmtVolts_2, ADM1025_ALARM_IN2, 0,
+    { SENSORS_ADM1025_IN2, SENSORS_ADM1025_IN2_MIN, SENSORS_ADM1025_IN2_MAX, -1 } },
+  { fmtVolts_2, ADM1025_ALARM_IN3, 0,
+    { SENSORS_ADM1025_IN3, SENSORS_ADM1025_IN3_MIN, SENSORS_ADM1025_IN3_MAX, -1 } },
+  { fmtVolts_2, ADM1025_ALARM_IN4, 0,
+    { SENSORS_ADM1025_IN4, SENSORS_ADM1025_IN4_MIN, SENSORS_ADM1025_IN4_MAX, -1 } },
+  { fmtVolts_2, ADM1025_ALARM_IN5, 0,
+    { SENSORS_ADM1025_IN5, SENSORS_ADM1025_IN5_MIN, SENSORS_ADM1025_IN5_MAX, -1 } },
+  { fmtTemps_1, ADM1025_ALARM_TEMP, 0,
+    { SENSORS_ADM1025_TEMP1, SENSORS_ADM1025_TEMP1_OVER, SENSORS_ADM1025_TEMP1_HYST, -1 } },
+  { NULL }
+};
+
+static const ChipDescriptor adm1025_chip = {
+  adm1025_names, adm1025_features, SENSORS_ADM1025_ALARMS, 0
+};
+
 /** W83781D **/
 
 static const char *w83781d_names[] = {
-  SENSORS_W83781D_PREFIX, NULL
+  SENSORS_W83781D_PREFIX, SENSORS_AS99127F_PREFIX, NULL
 };
 
-static FeatureDescriptor w83781d_features[] = {
-  { fmtVolts_2, SENSORS_W83781D_IN0,
+/* TODO: flags inverted for as99127f */
+static const FeatureDescriptor w83781d_features[] = {
+  { fmtVolts_2, W83781D_ALARM_IN0, W83781D_ALARM_IN0,
     { SENSORS_W83781D_IN0, SENSORS_W83781D_IN0_MIN, SENSORS_W83781D_IN0_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83781D_IN1,
+  { fmtVolts_2, W83781D_ALARM_IN1, W83781D_ALARM_IN1,
     { SENSORS_W83781D_IN1, SENSORS_W83781D_IN1_MIN, SENSORS_W83781D_IN1_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83781D_IN2,
+  { fmtVolts_2, W83781D_ALARM_IN2, W83781D_ALARM_IN2,
     { SENSORS_W83781D_IN2, SENSORS_W83781D_IN2_MIN, SENSORS_W83781D_IN2_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83781D_IN3,
+  { fmtVolts_2, W83781D_ALARM_IN3, W83781D_ALARM_IN3,
     { SENSORS_W83781D_IN3, SENSORS_W83781D_IN3_MIN, SENSORS_W83781D_IN3_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83781D_IN4,
+  { fmtVolts_2, W83781D_ALARM_IN4, W83781D_ALARM_IN4,
     { SENSORS_W83781D_IN4, SENSORS_W83781D_IN4_MIN, SENSORS_W83781D_IN4_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83781D_IN5,
+  { fmtVolts_2, W83781D_ALARM_IN5, W83781D_ALARM_IN5,
     { SENSORS_W83781D_IN5, SENSORS_W83781D_IN5_MIN, SENSORS_W83781D_IN5_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83781D_IN6,
+  { fmtVolts_2, W83781D_ALARM_IN6, W83781D_ALARM_IN6,
     { SENSORS_W83781D_IN6, SENSORS_W83781D_IN6_MIN, SENSORS_W83781D_IN6_MAX, -1 } },
-  { fmtFans_0, SENSORS_W83781D_FAN1,
+  { fmtFans_0, W83781D_ALARM_FAN1, W83781D_ALARM_FAN1,
     { SENSORS_W83781D_FAN1, SENSORS_W83781D_FAN1_MIN, SENSORS_W83781D_FAN1_DIV, -1 } },
-  { fmtFans_0, SENSORS_W83781D_FAN2,
+  { fmtFans_0, W83781D_ALARM_FAN2, W83781D_ALARM_FAN2,
     { SENSORS_W83781D_FAN2, SENSORS_W83781D_FAN2_MIN, SENSORS_W83781D_FAN2_DIV, -1 } },
-  { fmtFans_0, SENSORS_W83781D_FAN3,
+  { fmtFans_0, W83781D_ALARM_FAN3, W83781D_ALARM_FAN3,
     { SENSORS_W83781D_FAN3, SENSORS_W83781D_FAN3_MIN, SENSORS_W83781D_FAN3_DIV, -1 } },
-  { fmtTemps_1, SENSORS_W83781D_TEMP1,
+  { fmtTemps_1, W83781D_ALARM_TEMP1, W83781D_ALARM_TEMP1,
     { SENSORS_W83781D_TEMP1, SENSORS_W83781D_TEMP1_OVER, SENSORS_W83781D_TEMP1_HYST, -1 } },
-  { fmtTemps_1, SENSORS_W83781D_TEMP2,
+  { fmtTemps_1, W83781D_ALARM_TEMP2, W83781D_ALARM_TEMP2,
     { SENSORS_W83781D_TEMP2, SENSORS_W83781D_TEMP2_OVER, SENSORS_W83781D_TEMP2_HYST, -1 } },
-  { fmtTemps_1, SENSORS_W83781D_TEMP3,
+  { fmtTemps_1, W83781D_ALARM_TEMP3, W83781D_ALARM_TEMP3,
     { SENSORS_W83781D_TEMP3, SENSORS_W83781D_TEMP3_OVER, SENSORS_W83781D_TEMP3_HYST, -1 } },
-  { fmtVolt_2, SENSORS_W83781D_VID,
+  { fmtVolt_2, 0, 0,
     { SENSORS_W83781D_VID, -1 } },
+  { fmtChassisIntrusionDetection, W83781D_ALARM_CHAS, W83781D_ALARM_CHAS,
+    { SENSORS_W83781D_ALARMS, -1 } },
+  { fmtSoundAlarm, 0, 0, /* N.B: Is this beep correct for as99127f? */
+    { SENSORS_W83781D_BEEP_ENABLE, -1 } },
   { NULL }
 };
 
+static const ChipDescriptor w83781d_chip = {
+  w83781d_names, w83781d_features, SENSORS_W83781D_ALARMS, SENSORS_W83781D_BEEPS
+};
+
 /** W83782D **/
 
 static char *
 fmtTemps_W8378x
-(double values[]) {
+(double values[], int alarm, int beep) {
   int sensorID = (int) values[3];
-  char *sensor = (sensorID == 1) ? "PII/Celeron diode" : (sensorID == 2) ? "3904 transistor" : "thermistor"; /* Is this still right? */
-  sprintf (buff, "%.1f C (limit = %.1f C, hysteresis = %.1f C, sensor = %s)", values[0], values[1], values[2], sensor);
-  return buff;
-}
+  const char *sensor = (sensorID == 1) ? "PII/Celeron diode" :
+    (sensorID == 2) ? "3904 transistor" : "thermistor";
+   /* Is this still right? */
+  sprintf (buff, "%.1f C (limit = %.1f C, hysteresis = %.1f C, sensor = %s)",
+           values[0], values[1], values[2], sensor);
+  return fmtExtra (alarm, beep);
+} /* N.B: TEMP1 in sensors is just %.0f.. */
 
 static const char *w83782d_names[] = {
-  SENSORS_W83782D_PREFIX, SENSORS_W83627HF_PREFIX, SENSORS_AS99127F_PREFIX, NULL
+  SENSORS_W83782D_PREFIX, SENSORS_W83627HF_PREFIX, NULL
 };
 
-static FeatureDescriptor w83782d_features[] = {
-  { fmtVolts_2, SENSORS_W83782D_IN0,
+static const FeatureDescriptor w83782d_features[] = {
+  { fmtVolts_2, W83781D_ALARM_IN0, W83781D_ALARM_IN0,
     { SENSORS_W83782D_IN0, SENSORS_W83782D_IN0_MIN, SENSORS_W83782D_IN0_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83782D_IN1,
+  { fmtVolts_2, W83781D_ALARM_IN1, W83781D_ALARM_IN1,
     { SENSORS_W83782D_IN1, SENSORS_W83782D_IN1_MIN, SENSORS_W83782D_IN1_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83782D_IN2,
+  { fmtVolts_2, W83781D_ALARM_IN2, W83781D_ALARM_IN2,
     { SENSORS_W83782D_IN2, SENSORS_W83782D_IN2_MIN, SENSORS_W83782D_IN2_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83782D_IN3,
+  { fmtVolts_2, W83781D_ALARM_IN3, W83781D_ALARM_IN3,
     { SENSORS_W83782D_IN3, SENSORS_W83782D_IN3_MIN, SENSORS_W83782D_IN3_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83782D_IN4,
+  { fmtVolts_2, W83781D_ALARM_IN4, W83781D_ALARM_IN4,
     { SENSORS_W83782D_IN4, SENSORS_W83782D_IN4_MIN, SENSORS_W83782D_IN4_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83782D_IN5,
+  { fmtVolts_2, W83781D_ALARM_IN5, W83781D_ALARM_IN5,
     { SENSORS_W83782D_IN5, SENSORS_W83782D_IN5_MIN, SENSORS_W83782D_IN5_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83782D_IN7,
+  { fmtVolts_2, W83782D_ALARM_IN7, W83782D_ALARM_IN7,
     { SENSORS_W83782D_IN7, SENSORS_W83782D_IN7_MIN, SENSORS_W83782D_IN7_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83782D_IN8,
+  { fmtVolts_2, W83782D_ALARM_IN8, W83782D_ALARM_IN8,
     { SENSORS_W83782D_IN8, SENSORS_W83782D_IN8_MIN, SENSORS_W83782D_IN8_MAX, -1 } },
-  { fmtFans_0, SENSORS_W83782D_FAN1,
+  { fmtFans_0, W83781D_ALARM_FAN1, W83781D_ALARM_FAN1,
     { SENSORS_W83782D_FAN1, SENSORS_W83782D_FAN1_MIN, SENSORS_W83782D_FAN1_DIV, -1 } },
-  { fmtFans_0, SENSORS_W83782D_FAN2,
+  { fmtFans_0, W83781D_ALARM_FAN2, W83781D_ALARM_FAN2,
     { SENSORS_W83782D_FAN2, SENSORS_W83782D_FAN2_MIN, SENSORS_W83782D_FAN2_DIV, -1 } },
-  { fmtFans_0, SENSORS_W83782D_FAN3,
+  { fmtFans_0, W83781D_ALARM_FAN3, W83781D_ALARM_FAN3,
     { SENSORS_W83782D_FAN3, SENSORS_W83782D_FAN3_MIN, SENSORS_W83782D_FAN3_DIV, -1 } },
-  { fmtTemps_W8378x, SENSORS_W83782D_TEMP1,
+  { fmtTemps_W8378x, W83781D_ALARM_TEMP1, W83781D_ALARM_TEMP1,
     { SENSORS_W83782D_TEMP1, SENSORS_W83782D_TEMP1_OVER, SENSORS_W83782D_TEMP1_HYST, SENSORS_W83782D_SENS1, -1 } },
-  { fmtTemps_W8378x, SENSORS_W83782D_TEMP2,
+  { fmtTemps_W8378x, W83781D_ALARM_TEMP2, W83781D_ALARM_TEMP2,
     { SENSORS_W83782D_TEMP2, SENSORS_W83782D_TEMP2_OVER, SENSORS_W83782D_TEMP2_HYST, SENSORS_W83782D_SENS2, -1 } },
-  { fmtTemps_W8378x, SENSORS_W83782D_TEMP3,
+  { fmtTemps_W8378x, W83781D_ALARM_TEMP3, W83781D_ALARM_TEMP3,
     { SENSORS_W83782D_TEMP3, SENSORS_W83782D_TEMP3_OVER, SENSORS_W83782D_TEMP3_HYST, SENSORS_W83782D_SENS3, -1 } },
-  { fmtVolt_2, SENSORS_W83782D_VID,
+  { fmtVolt_2, 0, 0,
     { SENSORS_W83782D_VID, -1 } },
+  { fmtChassisIntrusionDetection, W83781D_ALARM_CHAS, W83781D_ALARM_CHAS,
+    { SENSORS_W83781D_ALARMS, -1 } },
+  { fmtSoundAlarm, 0, 0,
+    { SENSORS_W83781D_BEEP_ENABLE, -1 } },
   { NULL }
 };
 
+static const ChipDescriptor w83782d_chip = {
+  w83782d_names, w83782d_features, SENSORS_W83782D_ALARMS, SENSORS_W83782D_BEEPS
+};
+
 /** W83783S **/
 
 static const char *w83783s_names[] = {
   SENSORS_W83783S_PREFIX, NULL
 };
 
-static FeatureDescriptor w83783s_features[] = {
-  { fmtVolts_2, SENSORS_W83783S_IN0,
+static const FeatureDescriptor w83783s_features[] = {
+  { fmtVolts_2, W83781D_ALARM_IN0, W83781D_ALARM_IN0,
     { SENSORS_W83783S_IN0, SENSORS_W83783S_IN0_MIN, SENSORS_W83783S_IN0_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83783S_IN1,
-    { SENSORS_W83783S_IN1, SENSORS_W83783S_IN1_MIN, SENSORS_W83783S_IN1_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83783S_IN2,
+  { fmtVolts_2, W83781D_ALARM_IN2, W83781D_ALARM_IN2,
     { SENSORS_W83783S_IN2, SENSORS_W83783S_IN2_MIN, SENSORS_W83783S_IN2_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83783S_IN3,
+  { fmtVolts_2, W83781D_ALARM_IN3, W83781D_ALARM_IN3,
     { SENSORS_W83783S_IN3, SENSORS_W83783S_IN3_MIN, SENSORS_W83783S_IN3_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83783S_IN4,
+  { fmtVolts_2, W83781D_ALARM_IN4, W83781D_ALARM_IN4,
     { SENSORS_W83783S_IN4, SENSORS_W83783S_IN4_MIN, SENSORS_W83783S_IN4_MAX, -1 } },
-  { fmtVolts_2, SENSORS_W83783S_IN5,
+  { fmtVolts_2, W83781D_ALARM_IN5, W83781D_ALARM_IN5,
     { SENSORS_W83783S_IN5, SENSORS_W83783S_IN5_MIN, SENSORS_W83783S_IN5_MAX, -1 } },
-  { fmtFans_0, SENSORS_W83783S_FAN1,
+  { fmtFans_0, W83781D_ALARM_FAN1, W83781D_ALARM_FAN1,
     { SENSORS_W83783S_FAN1, SENSORS_W83783S_FAN1_MIN, SENSORS_W83783S_FAN1_DIV, -1 } },
-  { fmtFans_0, SENSORS_W83783S_FAN2,
+  { fmtFans_0, W83781D_ALARM_FAN2, W83781D_ALARM_FAN2,
     { SENSORS_W83783S_FAN2, SENSORS_W83783S_FAN2_MIN, SENSORS_W83783S_FAN2_DIV, -1 } },
-  { fmtFans_0, SENSORS_W83783S_FAN3,
+  { fmtFans_0, W83781D_ALARM_FAN3, W83781D_ALARM_FAN3,
     { SENSORS_W83783S_FAN3, SENSORS_W83783S_FAN3_MIN, SENSORS_W83783S_FAN3_DIV, -1 } },
-  { fmtTemps_W8378x, SENSORS_W83783S_TEMP1,
+  { fmtTemps_W8378x, W83781D_ALARM_TEMP1, W83781D_ALARM_TEMP1,
     { SENSORS_W83783S_TEMP1, SENSORS_W83783S_TEMP1_OVER, SENSORS_W83783S_TEMP1_HYST, SENSORS_W83783S_SENS1, -1 } },
-  { fmtTemps_W8378x, SENSORS_W83783S_TEMP2,
+  { fmtTemps_W8378x, W83781D_ALARM_TEMP2, W83781D_ALARM_TEMP2,
     { SENSORS_W83783S_TEMP2, SENSORS_W83783S_TEMP2_OVER, SENSORS_W83783S_TEMP2_HYST, SENSORS_W83783S_SENS2, -1 } },
-  { fmtVolt_2, SENSORS_W83783S_VID,
+  { fmtVolt_2, 0, 0,
     { SENSORS_W83783S_VID, -1 } },
+  { fmtChassisIntrusionDetection, W83781D_ALARM_CHAS, W83781D_ALARM_CHAS,
+    { SENSORS_W83781D_ALARMS, -1 } },
+  { fmtSoundAlarm, 0, 0,
+    { SENSORS_W83781D_BEEP_ENABLE, -1 } },
   { NULL }
 };
 
+static const ChipDescriptor w83783s_chip = {
+  w83783s_names, w83783s_features, SENSORS_W83783S_ALARMS, SENSORS_W83783S_BEEPS
+};
+
 /** MAXILIFE **/
 
+static char *
+fmtTemps_Maxilife
+(double values[], int alarm, int beep) {
+  if (!values[0] && !values[1] && !values[2])
+    return NULL;
+  return fmtTemps_1 (values, alarm, beep);
+}
+
 static char *
 fmtFans_Maxilife
-(double values[]) {
+(double values[], int alarm, int beep) {
+  if (!values[0] && !values[1] && !values[2])
+    return NULL;
   if (values[0] < 0) {
     sprintf (buff, "Off (min = %.0f RPM, div = %.0f)", values[1], values[2]); 
   } else {
     sprintf (buff, "%.0f RPM (min = %.0f RPM, div = %.0f)", values[0] / values[2], values[1] / values[2], values[2]); 
   }
-  return buff;
+  return fmtExtra (alarm, beep);
+}
+
+static char *
+fmtMHz_Maxilife
+(double values[], int alarm, int beep) {
+  if (!values[0] && !values[1] && !values[2])
+    return NULL;
+  return fmtMHz_2 (values, alarm, beep);
+}
+
+static char *
+fmtVolts_Maxilife
+(double values[], int alarm, int beep) {
+  if (!values[0] && !values[1] && !values[2])
+    return NULL;
+  return fmtVolts_2 (values, alarm, beep);
 }
 
 static const char *maxilife_names[] = {
   SENSORS_MAXI_CG_PREFIX, SENSORS_MAXI_CO_PREFIX, SENSORS_MAXI_AS_PREFIX, NULL
 };
 
-static FeatureDescriptor maxilife_features[] = {
-  { fmtTemps_1, SENSORS_MAXI_CG_TEMP1,
+static const FeatureDescriptor maxilife_features[] = {
+  { fmtTemps_Maxilife, 0, 0,
     { SENSORS_MAXI_CG_TEMP1, SENSORS_MAXI_CG_TEMP1_MAX, SENSORS_MAXI_CG_TEMP1_HYST, -1 } },
-  { fmtTemps_1, SENSORS_MAXI_CG_TEMP2,
+  { fmtTemps_Maxilife, MAXI_ALARM_TEMP2, 0,
     { SENSORS_MAXI_CG_TEMP2, SENSORS_MAXI_CG_TEMP2_MAX, SENSORS_MAXI_CG_TEMP2_HYST, -1 } },
-  { fmtTemps_1, SENSORS_MAXI_CG_TEMP3,
+  { fmtTemps_Maxilife, 0, 0,
     { SENSORS_MAXI_CG_TEMP3, SENSORS_MAXI_CG_TEMP3_MAX, SENSORS_MAXI_CG_TEMP3_HYST, -1 } },
-  { fmtTemps_1, SENSORS_MAXI_CG_TEMP4,
+  { fmtTemps_Maxilife, MAXI_ALARM_TEMP4, 0,
     { SENSORS_MAXI_CG_TEMP4, SENSORS_MAXI_CG_TEMP4_MAX, SENSORS_MAXI_CG_TEMP4_HYST, -1 } },
-  { fmtTemps_1, SENSORS_MAXI_CG_TEMP4,
+  { fmtTemps_Maxilife, MAXI_ALARM_TEMP5, 0,
     { SENSORS_MAXI_CG_TEMP5, SENSORS_MAXI_CG_TEMP5_MAX, SENSORS_MAXI_CG_TEMP4_HYST, -1 } },
-  { fmtFans_Maxilife, SENSORS_MAXI_CG_FAN1,
+  { fmtFans_Maxilife, MAXI_ALARM_FAN1, 0,
     { SENSORS_MAXI_CG_FAN1, SENSORS_MAXI_CG_FAN1_MIN, SENSORS_MAXI_CG_FAN1_DIV, -1 } },
-  { fmtFans_Maxilife, SENSORS_MAXI_CG_FAN2,
+  { fmtFans_Maxilife, MAXI_ALARM_FAN2, 0,
     { SENSORS_MAXI_CG_FAN2, SENSORS_MAXI_CG_FAN2_MIN, SENSORS_MAXI_CG_FAN2_DIV, -1 } },
-  { fmtFans_Maxilife, SENSORS_MAXI_CG_FAN3,
+  { fmtFans_Maxilife, MAXI_ALARM_FAN3, 0,
     { SENSORS_MAXI_CG_FAN3, SENSORS_MAXI_CG_FAN3_MIN, SENSORS_MAXI_CG_FAN3_DIV, -1 } },
-  { fmtMHz_2, SENSORS_MAXI_CG_PLL,
+  { fmtMHz_Maxilife, MAXI_ALARM_PLL, 0,
     { SENSORS_MAXI_CG_PLL, SENSORS_MAXI_CG_PLL_MIN, SENSORS_MAXI_CG_PLL_MAX, -1 } },
-  { fmtVolts_2, SENSORS_MAXI_CG_VID1,
+  { fmtVolts_Maxilife, MAXI_ALARM_VID1, 0,
     { SENSORS_MAXI_CG_VID1, SENSORS_MAXI_CG_VID1_MIN, SENSORS_MAXI_CG_VID1_MAX, -1 } },
-  { fmtVolts_2, SENSORS_MAXI_CG_VID2,
+  { fmtVolts_Maxilife, MAXI_ALARM_VID2, 0,
     { SENSORS_MAXI_CG_VID2, SENSORS_MAXI_CG_VID2_MIN, SENSORS_MAXI_CG_VID2_MAX, -1 } },
-  { fmtVolts_2, SENSORS_MAXI_CG_VID3,
+  { fmtVolts_Maxilife, MAXI_ALARM_VID3, 0,
     { SENSORS_MAXI_CG_VID3, SENSORS_MAXI_CG_VID3_MIN, SENSORS_MAXI_CG_VID3_MAX, -1 } },
-  { fmtVolts_2, SENSORS_MAXI_CG_VID4,
+  { fmtVolts_Maxilife, MAXI_ALARM_VID4, 0,
     { SENSORS_MAXI_CG_VID4, SENSORS_MAXI_CG_VID4_MIN, SENSORS_MAXI_CG_VID4_MAX, -1 } },
   { NULL }
 };
 
-/** ALL **/
+static const ChipDescriptor maxilife_chip = {
+  maxilife_names, maxilife_features, SENSORS_MAXI_CG_ALARMS, 0
+};
 
-ChipDescriptor knownChips[] = {
-  { lm75_names, lm75_features },
-  { adm1021_names, adm1021_features },
-  { max1617_names, max1617_features },
-  { adm9240_names, adm9240_features },
-  { lm78_names, lm78_features },
-  { sis5595_names, sis5595_features },
-  { lm80_names, lm80_features },
-  { gl518_names, gl518_features },
-  { w83781d_names, w83781d_features },
-  { w83782d_names, w83782d_features },
-  { w83783s_names, w83783s_features },
-  { maxilife_names, maxilife_features },
+/** EEPROM **/
+
+static char *
+fmtType_EEPROM
+(double values[], int alarm, int beep) {
+  if ((int) values[0] == 4)
+    sprintf (buff, "SDRAM DIMM SPD");
+  else
+    sprintf (buff, "Invalid"); /* N.B: sensors just returns, aborting further tests; I don't.. */
+  return fmtExtra (alarm, beep);
+}
+
+static char *
+fmtRowCol_EEPROM
+(double values[], int alarm, int beep) {
+  int row = (int) values[0];
+  int col = (int) values[1];
+  int num = (int) values[2];
+  int foo = (row & 0xf) + (col & 0xf) + num - 16;
+  if ((foo > 0) && (foo <= 10))
+    sprintf (buff, "%d", 1 << foo);
+  else
+    sprintf (buff, "Invalid");
+  return fmtExtra (alarm, beep);
+}
+
+static const char *eeprom_names[] = {
+  SENSORS_EEPROM_PREFIX, NULL
+};
+
+static const FeatureDescriptor eeprom_features[] = {
+  { fmtType_EEPROM, 0, 0,
+    { SENSORS_EEPROM_TYPE, -1 } },
+  { fmtRowCol_EEPROM, 0, 0,
+    { SENSORS_EEPROM_ROWADDR, SENSORS_EEPROM_COLADDR, SENSORS_EEPROM_NUMROWS, -1 } },
   { NULL }
 };
+
+static const ChipDescriptor eeprom_chip = {
+  eeprom_names, eeprom_features, 0, 0
+};
+
+/** DDCMON **/
+
+static char *
+fmtID_DDCMON
+(double values[], int alarm, int beep) {
+  int value = (int) values[0];
+  buff[0] = ((value >> 10) & 0x1f) + '@';
+  buff[1] = ((value >> 5) & 0x1f) + '@';
+  buff[2] = (value & 0x1f) + '@';
+  buff[3] = ((value >> 20) & 0xf) + '0';
+  buff[4] = ((value >> 16) & 0xf) + '0';
+  buff[5] = ((value >> 28) & 0xf) + '0';
+  buff[6] = ((value >> 24) & 0xf) + '0';
+  buff[7] = '\0';
+  return fmtExtra (alarm, beep);
+}
+
+static const char *ddcmon_names[] = {
+  SENSORS_DDCMON_PREFIX, NULL
+};
+
+static const FeatureDescriptor ddcmon_features[] = {
+  { fmtID_DDCMON, 0, 0,
+    { SENSORS_DDCMON_ID, -1 } },
+  { fmtInt, 0, 0,
+    { SENSORS_DDCMON_SERIAL, -1 } },
+  { fmtIntCrossInt, 0, 0,
+    { SENSORS_DDCMON_VERSIZE, SENSORS_DDCMON_HORSIZE, -1 } },
+  { fmtIntDashInt, 0, 0,
+    { SENSORS_DDCMON_VERSYNCMIN, SENSORS_DDCMON_VERSYNCMAX, -1 } },
+  { fmtIntDashInt, 0, 0,
+    { SENSORS_DDCMON_HORSYNCMIN, SENSORS_DDCMON_HORSYNCMAX, -1 } },
+  { NULL }
+};
+
+static const ChipDescriptor ddcmon_chip = {
+  ddcmon_names, ddcmon_features, 0, 0
+};
+
+/** ALL **/
+
+const ChipDescriptor * const knownChips[] = {
+  &adm1021_chip,
+  &adm1025_chip,
+  &adm9240_chip,
+  &ddcmon_chip,
+  &eeprom_chip,
+  &gl518_chip,
+  &lm75_chip,
+  &lm78_chip,
+  &lm80_chip,
+  &max1617_chip,
+  &maxilife_chip,
+  &sis5595_chip,
+  &via686a_chip,
+  &w83781d_chip,
+  &w83782d_chip,
+  &w83783s_chip,
+  NULL
+};
diff --git a/prog/sensord/lib.c b/prog/sensord/lib.c
new file mode 100644
index 00000000..e4428dff
--- /dev/null
+++ b/prog/sensord/lib.c
@@ -0,0 +1,131 @@
+/*
+ * sensord
+ *
+ * A daemon that periodically logs sensor information to syslog.
+ *
+ * Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include "sensord.h"
+#include "lib/error.h"
+
+static const char *sensorsCfgPaths[] = {
+  "/etc", "/usr/lib/sensors", "/usr/local/lib/sensors", "/usr/lib", "/usr/local/lib", NULL
+};
+
+#define CFG_PATH_LEN 4096
+
+static char cfgPath[CFG_PATH_LEN + 1];
+
+static time_t cfgLastModified;
+
+int
+initLib
+(void) {
+  cfgPath[CFG_PATH_LEN] = '\0';
+  if (!strcmp (sensorsCfgFile, "-")) {
+    strncpy (cfgPath, sensorsCfgFile, CFG_PATH_LEN);
+  } else if (sensorsCfgFile[0] == '/') {
+    strncpy (cfgPath, sensorsCfgFile, CFG_PATH_LEN);
+  } else if (strchr (sensorsCfgFile, '/')) {
+    char *cwd = getcwd (NULL, 0);
+    snprintf (cfgPath, CFG_PATH_LEN, "%s/%s", cwd, sensorsCfgFile);
+    free (cwd);
+  } else {
+    int index0;
+    struct stat stats;
+    for (index0 = 0; sensorsCfgPaths[index0]; ++ index0) {
+      snprintf (cfgPath, CFG_PATH_LEN, "%s/%s", sensorsCfgPaths[index0], sensorsCfgFile);
+      if (stat (cfgPath, &stats) == 0)
+        break;
+    }
+    if (!sensorsCfgPaths[index0]) {
+      sensorLog (LOG_ERR, "Error locating sensors configuration file: %s", sensorsCfgFile);
+      return 9;
+    }
+  }
+  return 0;
+}
+
+static int
+loadConfig
+(int reload) {
+  struct stat stats;
+  FILE *cfg = NULL;
+  int ret = 0;
+
+  if (!strcmp (cfgPath, "-")) {
+    if (!reload) {
+      if ((ret = sensors_init (stdin))) {
+        if (ret == SENSORS_ERR_PROC)
+          sensorLog (LOG_ERR, "Error reading /proc; modules probably not loaded");
+        else
+          sensorLog (LOG_ERR, "Error %d loading sensors configuration file: <stdin>", ret);
+        ret = 12;
+      }
+    }
+  } else if (stat (cfgPath, &stats) < 0) {
+    sensorLog (LOG_ERR, "Error stating sensors configuration file: %s", cfgPath);
+    ret = 10;
+  } else if (!reload || (difftime (stats.st_mtime, cfgLastModified) > 0.0)) {
+    if (reload)
+      sensorLog (LOG_INFO, "configuration reloading");
+    if (!(cfg = fopen (cfgPath, "r"))) {
+      sensorLog (LOG_ERR, "Error opening sensors configuration file: %s", cfgPath);
+      ret = 11;
+    } else if ((ret = sensors_init (cfg))) {
+      if (ret == SENSORS_ERR_PROC)
+        sensorLog (LOG_ERR, "Error reading /proc; modules probably not loaded");
+      else
+        sensorLog (LOG_ERR, "Error %d loading sensors configuration file: %s", ret, cfgPath);
+      ret = 11;
+    } else {
+      cfgLastModified = stats.st_mtime;
+    }
+    if (cfg)
+      fclose (cfg);
+  }
+
+  return ret;
+}
+
+int
+loadLib
+(void) {
+  return loadConfig (0);
+}
+
+int
+reloadLib
+(void) {
+  return loadConfig (1);
+}
+
+int
+unloadLib
+(void) {
+  sensors_cleanup ();
+  return 0;  
+}
diff --git a/prog/sensord/sense.c b/prog/sensord/sense.c
new file mode 100644
index 00000000..65be0803
--- /dev/null
+++ b/prog/sensord/sense.c
@@ -0,0 +1,210 @@
+/*
+ * sensord
+ *
+ * A daemon that periodically logs sensor information to syslog.
+ *
+ * Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+
+#include "sensord.h"
+#include "lib/error.h"
+
+static int
+getLabelAndValid
+(sensors_chip_name name, int feature, char **label, int *valid) {
+  int err;
+  err = sensors_get_label (name, feature, label);
+  if (!err)
+    err = sensors_get_ignored (name, feature);
+  if (err >= 0) {
+    *valid = err;
+    err = 0;
+  }
+  return err;
+}
+
+static int
+readUnknownChip
+(const sensors_chip_name *chip) {
+  const sensors_feature_data *sensor;
+  int index0 = 0, index1 = 0;
+  int ret = 0;
+
+  while ((ret == 0) && ((sensor = sensors_get_all_features (*chip, &index0, &index1)) != NULL)) {
+    char *label = NULL;
+    int valid = 0;
+    double value;
+    
+    if (getLabelAndValid (*chip, sensor->number, &label, &valid)) {
+      sensorLog (LOG_ERR, "Error getting sensor label: %s/%s", chip->prefix, sensor->name);
+      ret = 20;
+    } else if (!valid) {
+      /* skip invalid */
+    } else if (!(sensor->mode & SENSORS_MODE_R)) {
+      sensorLog (LOG_INFO, "%s: %s", sensor->name, label);
+    } else if ((ret = sensors_get_feature (*chip, sensor->number, &value))) {
+      sensorLog (LOG_ERR, "Error getting sensor data: %s/%s: %s", chip->prefix, sensor->name, sensors_strerror (ret));
+      ret = 21;
+    } else {
+      sensorLog (LOG_INFO, "%s%s: %.2f", (sensor->mapping == SENSORS_NO_MAPPING) ? "" : "-"/*, sensor->name*/, label, value);
+    }
+    if (label)
+      free (label);
+  }
+  
+  return ret;
+}
+
+static int
+readKnownChip
+(const sensors_chip_name *chip, const ChipDescriptor *descriptor) {
+  const FeatureDescriptor *features = descriptor->features;
+  int alarms = 0, beeps = 0;
+  int index0, subindex;
+  int ret = 0;
+  double tmp;
+
+  if (!ret && descriptor->alarmNumber) {
+    if ((ret = sensors_get_feature (*chip, descriptor->alarmNumber, &tmp))) {
+      sensorLog (LOG_ERR, "Error getting sensor data: %s/#%d: %s", chip->prefix, descriptor->alarmNumber, sensors_strerror (ret));
+      ret = 20;
+    } else {
+      alarms = (int) (tmp + 0.5);
+    }
+  }
+  if (!ret && descriptor->beepNumber) {
+    if ((ret = sensors_get_feature (*chip, descriptor->beepNumber, &tmp))) {
+      sensorLog (LOG_ERR, "Error getting sensor data: %s/#%d: %s", chip->prefix, descriptor->beepNumber, sensors_strerror (ret));
+      ret = 21;
+    } else {
+      beeps = (int) (tmp + 0.5);
+    }
+  }
+  for (index0 = 0; (ret == 0) && features[index0].format; ++ index0) {
+    const FeatureDescriptor *feature = features + index0;
+    int labelNumber = feature->dataNumbers[0];
+    char *label = NULL;
+    int valid = 0;
+    
+    if (getLabelAndValid (*chip, labelNumber, &label, &valid)) {
+      sensorLog (LOG_ERR, "Error getting sensor label: %s/#%d", chip->prefix, labelNumber);
+      ret = 22;
+    } else if (valid) {
+      double values[MAX_DATA];
+      int alarm = alarms & feature->alarmMask;
+      int beep = beeps & feature->beepMask;
+
+      for (subindex = 0; !ret && (feature->dataNumbers[subindex] >= 0); ++ subindex) {
+        if ((ret = sensors_get_feature (*chip, feature->dataNumbers[subindex], values + subindex))) {
+          sensorLog (LOG_ERR, "Error getting sensor data: %s/#%d: %s", chip->prefix, feature->dataNumbers[subindex], sensors_strerror (ret));
+          ret = 23;
+        }
+      }
+      if (ret == 0) {
+        char *formatted = feature->format (values, alarm, beep);
+        if (formatted) {
+          sensorLog (LOG_INFO, "  %s: %s"/*, sensor->name*/, label, formatted);
+        }
+      }
+    }
+    if (label)
+      free (label);
+  }
+  return ret;
+}
+
+static void
+idChip
+(const sensors_chip_name *chip) {
+  const char *adapter, *algorithm;
+
+  if (chip->bus == SENSORS_CHIP_NAME_BUS_ISA)
+    sensorLog (LOG_INFO, "Chip: %s-isa-%04x", chip->prefix, chip->addr);
+  else
+    sensorLog (LOG_INFO, "Chip: %s-i2c-%d-%02x", chip->prefix, chip->bus, chip->addr);
+  adapter = sensors_get_adapter_name (chip->bus);
+  if (adapter)
+    sensorLog (LOG_INFO, "Adapter: %s", adapter);
+  algorithm = sensors_get_algorithm_name (chip->bus);
+  if (algorithm)
+    sensorLog (LOG_INFO, "Algorithm: %s", algorithm);
+  /* assert adapter || algorithm */
+}
+
+
+static int
+setChip
+(const sensors_chip_name *chip) {
+  int ret;
+
+  if ((ret = sensors_do_chip_sets (*chip))) {
+    sensorLog (LOG_ERR, "Error performing chip sets: %s: %s", chip->prefix, sensors_strerror (ret));
+    ret = 20;
+  }
+
+  return ret;
+}
+
+static int
+readChip
+(const sensors_chip_name *chip) {
+  int index0, subindex, chipindex = -1;
+  int ret = 0;
+
+  for (index0 = 0; knownChips[index0]; ++ index0)
+    for (subindex = 0; knownChips[index0]->names[subindex]; ++ subindex)
+      if (!strcmp (chip->prefix, knownChips[index0]->names[subindex]))
+        chipindex = index0;
+  
+  if (chipindex >= 0)
+    ret = readKnownChip (chip, knownChips[chipindex]);
+  else
+    ret = readUnknownChip (chip);
+
+  return ret;
+}
+
+int
+readChips
+(void) {
+  const sensors_chip_name *chip;
+  int i = 0, j, ret = 0;
+
+  sensorLog (LOG_DEBUG, "sensor scan started");
+
+  while ((ret == 0) && ((chip = sensors_get_detected_chips (&i)) != NULL)) {
+    for (j = 0; j < numChipNames; ++ j) {
+      if (sensors_match_chip (*chip, chipNames[j])) {
+        idChip (chip);
+        if (doSet)
+          ret = setChip (chip);
+        else
+          ret = readChip (chip);
+        break;
+      }
+    }
+  }
+
+  sensorLog (LOG_DEBUG, "sensor scan finished");
+
+  return ret;
+}
diff --git a/prog/sensord/sensord.8 b/prog/sensord/sensord.8
index 21c284b3..a0ef340e 100644
--- a/prog/sensord/sensord.8
+++ b/prog/sensord/sensord.8
@@ -32,7 +32,7 @@ sensord \- Sensor information logging daemon.
 .SH DESCRIPTION
 .B Sensord
 is a daemon that records in a log file the readings of all sensor chips at
-an interval of five minutes, or as configured on the command line.
+an interval of thirty minutes, or as configured on the command line.
 
 .B Sensord
 knows about certain chips, and outputs nicely formatted readings for them; but
@@ -52,7 +52,7 @@ is not present, the following paths are examined:
 .BR /usr/local/lib .
 .IP "-i interval"
 Specifies the interval, in seconds, between sensor readings. The default
-is 300 seconds (5 minutes).
+is 1800 seconds (30 minutes).
 .IP "-l log-file"
 Specify the log file to which to append. If no file is specified, the
 default log file `/var/log/sensors' is created. Note that this file is
@@ -82,6 +82,24 @@ being started. Typically, this is achieved with an entry in
 `/etc/rc.d/...' containing
 .BR modprobe (1)
 commands to load the required modules before starting the daemon.
+.SH WARNING
+On a typical system with one sensor chip, expect about 1KB per sensor
+entry in the log file. This works out at about 1.5MB per month. You
+must rotate the sensor log files, using something like
+.BR logrotate (8)
+or equivalent. You might, for example, create `/etc/logrotate.d/sensord'
+containing:
+.IP
+.nf
+  # Sample logrotate.d entry
+  /var/log/sensors {
+      missingok
+      postrotate
+          /usr/sbin/killall -HUP sensord
+      endscript
+  }
+.fi
+.PP
 .SH BUGS
 .B Sensord
 does not currently support reading alarm events from sensor devices.
diff --git a/prog/sensord/sensord.c b/prog/sensord/sensord.c
index 17d4ec3b..b5765bc7 100644
--- a/prog/sensord/sensord.c
+++ b/prog/sensord/sensord.c
@@ -1,10 +1,9 @@
 /*
  * sensord
  *
- * A daemon that logs all sensor information to /var/log/sensors
- * every 5 minutes.
+ * A daemon that periodically logs sensor information to syslog.
  *
- * Copyright (c) 1999 Merlin Hughes <merlin@merlin.org>
+ * Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,339 +22,95 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <signal.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <dirent.h>
-#include <unistd.h>
 #include <syslog.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
-
-#include "lib/sensors.h"
+#include <unistd.h>
 
 #include "sensord.h"
 
-static const char *version = "0.2.0";
-
-static const char *sensorsCfgPaths[] = {
-  "/etc", "/usr/lib/sensors", "/usr/local/lib/sensors", "/usr/lib", "/usr/local/lib", NULL
-};
-static const char *sensorsCfgFile = "sensors.conf";
-static const char *sensorsLogFile = "/var/log/sensors";
-static int sleepTime = 5 * 60;
-
-static int cfgLoaded = 0;
-time_t cfgLastModified;
-
-static FILE *sensorsLog = NULL;
+static int logOpened = 0;
 
 static volatile sig_atomic_t done = 0;
-static volatile sig_atomic_t rotate = 0;
+
+#define LOG_BUFFER 4096
+
+#include <stdarg.h>
+
+void
+sensorLog
+(int priority, const char *fmt, ...) {
+  static char buffer[1 + LOG_BUFFER];
+  va_list ap;
+  va_start (ap, fmt);
+  vsnprintf (buffer, LOG_BUFFER, fmt, ap);
+  buffer[LOG_BUFFER] = '\0';
+  va_end (ap);
+  if (logOpened) {
+    syslog (priority, "%s", buffer);
+  } else if (priority != LOG_DEBUG) {
+    fprintf (stderr, "%s\n", buffer);
+    fflush (stderr);
+  }
+}
 
 static void
 signalHandler
 (int sig) {
   signal (sig, signalHandler);
   switch (sig) {
-    case SIGHUP:
-      rotate = 1;
-      break;
     case SIGTERM:
       done = 1;
       break;
   }
 }
 
-static void
-initSignals
-(void) {
-  /* I should use sigaction but... */
-  signal (SIGHUP, signalHandler);
-  signal (SIGTERM, signalHandler);
-}
-
-static char *
-nowf
-(void) {
-  time_t now;
-  char *str;
-  int len;
-  static char buff[1024];
-
-  time (&now);
-  str = ctime (&now);
-  len = strlen (str);
-  memcpy (buff, str, len - 1);
-  buff[len - 1] = '\0';
-
-  return buff;
-}
-
-static int
-readUnknownChip
-(const sensors_chip_name *chip) {
-  const sensors_feature_data *sensor;
-  int index0 = 0, index1 = 0;
-  int ret = 0;
-
-  while (!done && (ret == 0) && ((sensor = sensors_get_all_features (*chip, &index0, &index1)) != NULL)) {
-    char *label = NULL;
-    double value;
-    
-    if (sensors_get_label (*chip, sensor->number, &label)) {
-      syslog (LOG_ERR, "Error getting sensor label: %s/%s", chip->prefix, sensor->name);
-      ret = 20;
-    } else if (!(sensor->mode & SENSORS_MODE_R)) {
-      fprintf (sensorsLog, "\t%s: %s\n", sensor->name, label);
-    } else if (sensors_get_feature (*chip, sensor->number, &value)) {
-      syslog (LOG_ERR, "Error getting sensor data: %s/%s", chip->prefix, sensor->name);
-      ret = 21;
-    } else {
-      fprintf (sensorsLog, "\t%s%s: %s: %.2f\n", (sensor->mapping == SENSORS_NO_MAPPING) ? "" : "-", sensor->name, label, value);
-    }
-    if (label)
-      free (label);
-  }
-  
-  return ret;
-}
-
-static int
-readKnownChip
-(const sensors_chip_name *chip, ChipDescriptor *descriptor) {
-  FeatureDescriptor *features = descriptor->features;
-  int index0, subindex;
-  int ret = 0;
-
-  for (index0 = 0; !done && (ret == 0) && features[index0].format; ++ index0) {
-    FeatureDescriptor *feature = features + index0;
-    char *label = NULL;
-    double values[MAX_DATA];
-    
-    if (sensors_get_label (*chip, feature->labelNumber, &label)) {
-      syslog (LOG_ERR, "Error getting sensor label: %s/#%d", chip->prefix, feature->labelNumber);
-      ret = 20;
-    }
-    for (subindex = 0; !done && (ret == 0) && (feature->dataNumbers[subindex] >= 0); ++ subindex) {
-      if (sensors_get_feature (*chip, feature->dataNumbers[subindex], values + subindex)) {
-        syslog (LOG_ERR, "Error getting sensor data: %s/#%d", chip->prefix, feature->dataNumbers[subindex]);
-        ret = 21;
-      }
-    }
-    if (!done && (ret == 0))
-      fprintf (sensorsLog, "\t%s: %s\n"/*, sensor->name*/, label, feature->format (values));
-    if (label)
-      free (label);
-  }
-  return ret;
-}
-
-static int
-readChip
-(const sensors_chip_name *chip) {
-  const char *adapter, *algorithm;
-  int index0, subindex, chipindex = -1;
-  int ret = 0;
-
-  if (chip->bus == SENSORS_CHIP_NAME_BUS_ISA)
-    fprintf (sensorsLog, "%s: Chip: %s-isa-%04x\n", nowf(), chip->prefix, chip->addr);
-  else
-    fprintf (sensorsLog, "%s: Chip: %s-i2c-%d-%02x\n", nowf(), chip->prefix, chip->bus, chip->addr);
-  adapter = sensors_get_adapter_name (chip->bus);
-  if (adapter)
-    fprintf (sensorsLog, "%s: Adapter: %s\n", nowf(), adapter);
-  algorithm = sensors_get_algorithm_name (chip->bus);
-  if (algorithm)
-    fprintf (sensorsLog, "%s: Algorithm: %s\n", nowf(), algorithm);
-  /* assert adapter || algorithm */
-
-  for (index0 = 0; knownChips[index0].names; ++ index0)
-    for (subindex = 0; knownChips[index0].names[subindex]; ++ subindex)
-      if (!strcmp (chip->prefix, knownChips[index0].names[subindex]))
-        chipindex = index0;
-  
-  if (chipindex >= 0)
-    ret = readKnownChip (chip, knownChips + chipindex);
-  else
-    ret = readUnknownChip (chip);
-
-  return ret;
-}
-
-static int
-readChips
-(void) {
-  const sensors_chip_name *chip;
-  int index0 = 0;
-  int ret = 0;
-
-  fprintf (sensorsLog, "%s: Sense.\n", nowf());
-  fflush (sensorsLog);
-
-  while (!done && (ret == 0) && ((chip = sensors_get_detected_chips (&index0)) != NULL)) {
-    ret = readChip (chip);
-  }
-
-  fprintf (sensorsLog, "%s: Done.\n", nowf());
-  fflush (sensorsLog);
-
-  return ret;
-}
-
-static int
-rotateLog
-(void) {
-  int ret = 0;
-
-  if (sensorsLog != NULL) {
-    fprintf (sensorsLog, "%s: Rotate.\n", nowf());
-    fclose (sensorsLog);
-  }
-  if (!(sensorsLog = fopen (sensorsLogFile, "a"))) {
-    syslog (LOG_ERR, "Error opening sensors log: %s", sensorsLogFile);
-    ret = 1;
-  } else {
-    fprintf (sensorsLog, "%s: Started.\n", nowf());
-    fflush (sensorsLog);
-  }
-  rotate = 0;
-
-  return ret;
-}
-
-char cfgPath[4096] = "";
-
-static int
-initSensors
-(void) {
-  struct stat stats;
-  FILE *cfg = NULL;
-  int ret = 0;
-
-  if (!cfgPath[0]) {
-    if (sensorsCfgFile[0] == '/') {
-      strcpy (cfgPath, sensorsCfgFile);
-    } else {
-      int index0;
-      for (index0 = 0; sensorsCfgPaths[index0]; ++ index0) {
-        sprintf (cfgPath, "%s/%s", sensorsCfgPaths[index0], sensorsCfgFile);
-        if (stat (cfgPath, &stats) == 0)
-          break;
-      }
-      if (!sensorsCfgPaths[index0]) {
-        syslog (LOG_ERR, "Error locating sensors configuration: %s", sensorsCfgFile);
-        return 9;
-      }
-    }
-  }
-    
-  if (stat (cfgPath, &stats) < 0) {
-    syslog (LOG_ERR, "Error stating sensors configuration: %s", cfgPath);
-    ret = 10;
-  } else if (!cfgLoaded || (difftime (stats.st_mtime, cfgLastModified) > 0.0)) {
-    if (!(cfg = fopen (cfgPath, "r"))) {
-      syslog (LOG_ERR, "Error opening sensors configuration: %s", cfgPath);
-      ret = 11;
-    } else if (sensors_init (cfg)) {
-      syslog (LOG_ERR, "Error loading sensors configuration: %s", cfgPath);
-      ret = 11;
-    } else {
-      cfgLastModified = stats.st_mtime;
-      cfgLoaded = 1;
-    }
-    if (cfg)
-      fclose (cfg);
-  }
-
-  return ret;
-}
-
 static int
 sensord
 (void) {
   int ret = 0;
 
-  openlog ("sensord", 0, LOG_DAEMON);
-  
-  initSignals ();
+  sensorLog (LOG_INFO, "sensord started");
 
   while (!done && (ret == 0)) {
-    if (rotate || (sensorsLog == NULL))
-      ret = rotateLog ();
     if (ret == 0)
-      ret = initSensors ();
+      ret = reloadLib ();
     if (ret == 0)
       ret = readChips ();
-    if (!done && !rotate && (ret == 0))
+    if (!done && (ret == 0))
       sleep (sleepTime);
   }
 
-  if (cfgLoaded)
-    sensors_cleanup ();
-
-  if (sensorsLog) {
-    fprintf (sensorsLog, "%s: %s.\n", nowf(), ret ? "Failed" : "Stopped");
-    fclose (sensorsLog);
-  }
-
-  closelog ();
+  sensorLog (LOG_INFO, "sensord %s", ret ? "failed" : "stopped");
 
   return ret;
 }
 
-static void
-syntaxError
-(void) {
-  printf ("Syntax: sensord [options]\n"
-          "\t-i <interval>     -- seconds between samples (default 300)\n"
-          "\t-l <log-file>     -- log file (default /var/log/sensors)\n"
-          "\t-c <config-file>  -- configuration file (default /etc/sensors.conf)\n"
-          "\t-v                -- display version and exit\n"
-          "\t-h                -- display help and exit\n");
-  exit (EXIT_FAILURE);
-}
-
-static void
-parseArgs
-(int argc, char **argv) {
-  int i;
-
-  for (i = 1; i < argc; ++ i) {
-    if (!strcmp (argv[i], "-i") && (i < argc - 1)) {
-      sleepTime = atoi (argv[++ i]);
-    } else if (!strcmp (argv[i], "-l") && (i < argc - 1)) {
-      sensorsLogFile = argv[++ i];
-    } else if (!strcmp (argv[i], "-c") && (i < argc - 1)) {
-      sensorsCfgFile = argv[++ i];
-    } else if (!strcmp (argv[i], "-v")) {
-      printf ("sensord version %s\n", version);
-      exit (EXIT_SUCCESS);
-    } else {
-      syntaxError ();
-    }
-  }
-}
-
 static void
 daemonize
 (void) {
   int pid;
 
-  if ((pid = fork ()) == -1) {
-    fprintf (stderr, "Error forking daemon\n");
-    exit (EXIT_FAILURE);
-  } else if (pid != 0) {
-    exit (EXIT_SUCCESS);
-  }
+  openlog ("sensord", 0, syslogFacility);
+  
+  logOpened = 1;
 
   if (chdir ("/") < 0) {
     perror ("chdir()");
     exit (EXIT_FAILURE);
   }
+  
+  /* I should use sigaction but... */
+  if (signal (SIGTERM, signalHandler) == SIG_ERR) {
+    perror ("signal(SIGTERM)");
+    exit (EXIT_FAILURE);
+  }
+
+  if ((pid = fork ()) == -1) {
+    perror ("fork()");
+    exit (EXIT_FAILURE);
+  } else if (pid != 0) {
+    exit (EXIT_SUCCESS);
+  }
 
   if (setsid () < 0) {
     perror ("setsid()");
@@ -367,10 +122,35 @@ daemonize
   close (STDERR_FILENO);
 }
 
+static void 
+undaemonize
+(void) {
+  closelog ();
+}
+
 int
 main
 (int argc, char **argv) {
-  parseArgs (argc, argv);
-  daemonize ();
-  return sensord ();
+  int ret;
+  
+  if (parseArgs (argc, argv) ||
+      parseChips (argc, argv))
+    exit (EXIT_FAILURE);
+  
+  if (initLib () ||
+      loadLib ())
+    exit (EXIT_FAILURE);
+  
+  if (isDaemon) {
+    daemonize ();
+    ret = sensord ();
+    undaemonize ();
+  } else {
+    ret = readChips ();
+  }
+  
+  if (unloadLib ())
+    exit (EXIT_FAILURE);
+  
+  return ret;
 }
diff --git a/prog/sensord/sensord.h b/prog/sensord/sensord.h
index aa080a81..d6cd55b0 100644
--- a/prog/sensord/sensord.h
+++ b/prog/sensord/sensord.h
@@ -1,10 +1,9 @@
 /*
  * sensord
  *
- * A daemon that logs all sensor information to /var/log/sensors
- * every 5 minutes.
+ * A daemon that periodically logs sensor information to syslog.
  *
- * Copyright (c) 1999 Merlin Hughes <merlin@merlin.org>
+ * Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,19 +20,55 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define version "0.3.0"
+
+#include "lib/sensors.h"
+
+extern void sensorLog (int priority, const char *fmt, ...);
+
+/* from args.c */
+
+extern int isDaemon;
+extern const char *sensorsCfgFile;
+extern int sleepTime;
+extern int logTime;
+extern int syslogFacility;
+extern int doSet;
+extern sensors_chip_name chipNames[];
+extern int numChipNames;
+
+extern int parseArgs (int argc, char **argv);
+extern int parseChips (int argc, char **argv);
+
+/* from lib.c */
+
+extern int initLib (void);
+extern int loadLib (void);
+extern int reloadLib (void);
+extern int unloadLib (void);
+
+/* from sense.c */
+
+extern int readChips (void);
+
+/* from chips.c */
+
 #define MAX_DATA 5
 
-typedef char * (*FormatterFN) (double[]);
+typedef char * (*FormatterFN) (double values[], int alarm, int beep);
 
 typedef struct {
   FormatterFN format;
-  int labelNumber;
-  int dataNumbers[MAX_DATA + 1];
+  int alarmMask;
+  int beepMask;
+  const int dataNumbers[MAX_DATA + 1]; /* First entry is used for the label */
 } FeatureDescriptor;
 
 typedef struct {
-  char **names;
-  FeatureDescriptor *features;
+  const char * const *names;
+  const FeatureDescriptor *features;
+  int alarmNumber;
+  int beepNumber;
 } ChipDescriptor;
 
-extern ChipDescriptor knownChips[];
+extern const ChipDescriptor * const knownChips[];