 @@ -1,14 +1,14 @@
-/*	$NetBSD: sysmon_envsys.c,v 1.113 2011/06/04 13:24:33 pgoyette Exp $	*/
+/*	$NetBSD: sysmon_envsys.c,v 1.114 2011/06/08 18:22:24 pgoyette Exp $	*/
 /*-
  * Copyright (c) 2007, 2008 Juan Romero Pardines.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -54,27 +54,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Environmental sensor framework for sysmon, exported to userland
  * with proplib(3).
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sysmon_envsys.c,v 1.113 2011/06/04 13:24:33 pgoyette Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sysmon_envsys.c,v 1.114 2011/06/08 18:22:24 pgoyette Exp $");
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/conf.h>
 #include <sys/errno.h>
 #include <sys/fcntl.h>
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/mutex.h>
 #include <sys/kmem.h>
 /* #define ENVSYS_DEBUG */
 @@ -1253,234 +1253,125 @@ out:
+}
 /*
  * sme_add_sensor_dictionary:
+ *
  * 	+ Adds the sensor objects into the dictionary and returns a pointer
  * 	  to a sme_event_drv_t object if a monitoring flag was set
  * 	  (or NULL otherwise).
  */
 static sme_event_drv_t *
 sme_add_sensor_dictionary(struct sysmon_envsys *sme, prop_array_t array,
 		    	  prop_dictionary_t dict, envsys_data_t *edata)
+{
-	const struct sme_descr_entry *sdt_state, *sdt_units, *sdt_battcap;
+	const struct sme_descr_entry *sdt;
-	const struct sme_descr_entry *sdt_drive;
+	int error;
 	sme_event_drv_t *sme_evdrv_t = NULL;
 	char indexstr[ENVSYS_DESCLEN];
 	/*
 	 * Find the correct units for this sensor.
 	 */
 	sdt_units = sme_find_table_entry(SME_DESC_UNITS, edata->units);
 	/*
 	 * Add the index sensor string.
+	 *
 	 * 		...
 	 * 		<key>index</eyr
 	 * 		<string>sensor0</string>
 	 * 		...
 	 */
 	(void)snprintf(indexstr, sizeof(indexstr), "sensor%d", edata->sensor);
 	if (sme_sensor_upstring(dict, "index", indexstr))
 		goto bad;
 	/*
 	 * 		...
 	 * 		<key>type</key>
 	 * 		<string>foo</string>
 	 * 		<key>description</key>
 	 * 		<string>blah blah</string>
 	 * 		...
 	 */
 	if (sme_sensor_upstring(dict, "type", sdt_units->desc))
 		goto bad;
 	if (sme_sensor_upstring(dict, "description", edata->desc))
 		goto bad;
 	/*
 	 * Add sensor's state description.
 	 * 		...
 	 * 		<key>state</key>
 	 * 		<string>valid</string>
 	 * 		...
 	 */
 	sdt_state = sme_find_table_entry(SME_DESC_STATES, edata->state);
 	DPRINTF(("%s: sensor desc=%s type=%d state=%d\n",
 	    __func__, edata->desc, edata->units, edata->state));
 	if (sme_sensor_upstring(dict, "state", sdt_state->desc))
 		goto bad;
 	/*
 	 * Add the monitoring boolean object:
+	 *
 	 * 		...
 	 * 		<key>monitoring-supported</key>
 	 * 		<true/>
 	 *		...
+	 *
 	 * always false on Battery {capacity,charge}, Drive and Indicator types.
 	 * They cannot be monitored.
+	 *
 	 */
 	if ((edata->flags & ENVSYS_FMONNOTSUPP) ||
 	    (edata->units == ENVSYS_INDICATOR) ||
 	    (edata->units == ENVSYS_DRIVE) ||
 	    (edata->units == ENVSYS_BATTERY_CAPACITY) ||
 	    (edata->units == ENVSYS_BATTERY_CHARGE)) {
 		if (sme_sensor_upbool(dict, "monitoring-supported", false))
 			goto out;
 	} else {
 		if (sme_sensor_upbool(dict, "monitoring-supported", true))
 			goto out;
+	}
 	/*
 	 * Add the percentage boolean object, true if ENVSYS_FPERCENT
 	 * is set or false otherwise.
 	 * 		...
 	 * 		<key>want-percentage</key>
 	 * 		<true/>
 	 * 		...
 	 */
 	if (edata->flags & ENVSYS_FPERCENT)
 		if (sme_sensor_upbool(dict, "want-percentage", true))
 			goto out;
 	/*
 	 * Add the allow-rfact boolean object, true if
-	 * ENVSYS_FCHANGERFACT if set or false otherwise.
+	 * ENVSYS_FCHANGERFACT is set, false otherwise.
+	 *
 	 * 		...
 	 * 		<key>allow-rfact</key>
 	 * 		<true/>
 	 * 		...
 	 */
 	if (edata->units == ENVSYS_SVOLTS_DC ||
 	    edata->units == ENVSYS_SVOLTS_AC) {
 		if (edata->flags & ENVSYS_FCHANGERFACT) {
 			if (sme_sensor_upbool(dict, "allow-rfact", true))
 				goto out;
 		} else {
 			if (sme_sensor_upbool(dict, "allow-rfact", false))
 				goto out;
+		}
+	}
-	/*
+	error = sme_update_sensor_dictionary(dict, edata,
-	 * Add the object for battery capacity sensors:
+			(edata->state == ENVSYS_SVALID));
 	if (error < 0)
-	 * 		...
+		goto bad;
-	 * 		<key>battery-capacity</key>
+	else if (error)
-	 * 		<string>NORMAL</string>
+		goto out;
 	 * 		...
 	 */
 	if (edata->units == ENVSYS_BATTERY_CAPACITY) {
 		sdt_battcap = sme_find_table_entry(SME_DESC_BATTERY_CAPACITY,
 		    edata->value_cur);
 		if (sme_sensor_upstring(dict, "battery-capacity",
 					sdt_battcap->desc))
 			goto out;
 	/*
 	 * Add the drive-state object for drive sensors:
 	 * 		...
 	 * 		<key>drive-state</key>
 	 * 		<string>drive is online</string>
 	 * 		...
 	 */
 	if (edata->units == ENVSYS_DRIVE) {
 		sdt_drive = sme_find_table_entry(SME_DESC_DRIVE_STATES,
 		    edata->value_cur);
 		if (sme_sensor_upstring(dict, "drive-state", sdt_drive->desc))
 			goto out;
 	/*
 	 * Add the following objects if sensor is enabled...
 	 */
 	if (edata->state == ENVSYS_SVALID) {
 		/*
 		 * Add the following objects:
 		 * 	...
 		 * 	<key>rpms</key>
 		 * 	<integer>2500</integer>
 		 * 	<key>rfact</key>
 		 * 	<integer>10000</integer>
 		 * 	<key>cur-value</key>
 	 	 * 	<integer>1250</integer>
 	 	 * 	<key>min-value</key>
 	 	 * 	<integer>800</integer>
 	 	 * 	<key>max-value</integer>
 	 	 * 	<integer>3000</integer>
 	 	 * 	...
 	 	 */
 		if (edata->units == ENVSYS_SFANRPM)
 			if (sme_sensor_upuint32(dict, "rpms", edata->rpms))
 				goto out;
 		if (edata->units == ENVSYS_SVOLTS_AC ||
 	    	    edata->units == ENVSYS_SVOLTS_DC)
 			if (sme_sensor_upint32(dict, "rfact", edata->rfact))
 				goto out;
 		if (sme_sensor_upint32(dict, "cur-value", edata->value_cur))
 			goto out;
 		if (edata->flags & ENVSYS_FVALID_MIN) {
 			if (sme_sensor_upint32(dict,
 					       "min-value",
 					       edata->value_min))
 			goto out;
 		if (edata->flags & ENVSYS_FVALID_MAX) {
 			if (sme_sensor_upint32(dict,
 					       "max-value",
 					       edata->value_max))
 			goto out;
 	/*
 	 * 	...
 	 * </dict>
+	 *
 	 * Add the dictionary into the array.
+	 *
 	 */
 	if (!prop_array_add(array, dict)) {
 		DPRINTF(("%s: prop_array_add\n", __func__));
 		goto bad;
+	}
 	/*
 	 * Register new event(s) if any monitoring flag was set.
 	 */
 	if (edata->flags & ENVSYS_FMONANY) {
 		sme_evdrv_t = kmem_zalloc(sizeof(*sme_evdrv_t), KM_SLEEP);
 		sme_evdrv_t->sed_sdict = dict;
 		sme_evdrv_t->sed_edata = edata;
 		sme_evdrv_t->sed_sme = sme;
-		sme_evdrv_t->sed_powertype = sdt_units->crittype;
+		sdt = sme_find_table_entry(SME_DESC_UNITS, edata->units);
 		sme_evdrv_t->sed_powertype = sdt->crittype;
+	}
 out:
 	return sme_evdrv_t;
 bad:
 	prop_object_release(dict);
 	return NULL;
+}
 /*
  * Find the maximum of all currently reported values.
  * The provided callback decides wether a sensor is part of the
 @@ -1545,27 +1436,26 @@ sme_get_max_value(struct sysmon_envsys *
 	return maxv;
+}
 /*
  * sme_update_dictionary:
+ *
  * 	+ Update per-sensor dictionaries with new values if there were
  * 	  changes, otherwise the object in dictionary is untouched.
  */
 int
 sme_update_dictionary(struct sysmon_envsys *sme)
+{
 	const struct sme_descr_entry *sdt;
 	envsys_data_t *edata;
 	prop_object_t array, dict, obj, obj2;
 	int error = 0;
 	/*
 	 * Retrieve the array of dictionaries in device.
 	 */
 	array = prop_dictionary_get(sme_propd, sme->sme_name);
 	if (prop_object_type(array) != PROP_TYPE_ARRAY) {
 		DPRINTF(("%s: not an array (%s)\n", __func__, sme->sme_name));
 		return EINVAL;
+	}
 @@ -1618,143 +1508,147 @@ sme_update_dictionary(struct sysmon_envs
 		/*
 		 * retrieve sensor's dictionary.
 		 */
 		dict = prop_array_get(array, edata->sensor);
 		if (prop_object_type(dict) != PROP_TYPE_DICTIONARY) {
 			DPRINTF(("%s: not a dictionary (%d:%s)\n",
 			    __func__, edata->sensor, sme->sme_name));
 			return EINVAL;
+		}
 		/*
 		 * update sensor's state.
 		 */
-		sdt = sme_find_table_entry(SME_DESC_STATES, edata->state);
+		error = sme_update_sensor_dictionary(dict, edata, true);
 		DPRINTFOBJ(("%s: sensor #%d type=%d (%s) flags=%d\n",
 		    __func__, edata->sensor, sdt->type, sdt->desc,
 		    edata->flags));
 		error = sme_sensor_upstring(dict, "state", sdt->desc);
 		if (error)
 			break;
+	}
-		/*
+	return error;
 		 * update sensor's type.
 		 */
-		sdt = sme_find_table_entry(SME_DESC_UNITS, edata->units);
+int
 sme_update_sensor_dictionary(prop_object_t dict, envsys_data_t *edata,
 	bool value_update)
+{
 	const struct sme_descr_entry *sdt;
 	int error = 0;
 	sdt = sme_find_table_entry(SME_DESC_STATES, edata->state);
 	DPRINTFOBJ(("%s: sensor #%d type=%d (%s) flags=%d\n", __func__,
 	    edata->sensor, sdt->type, sdt->desc, edata->flags));
-		DPRINTFOBJ(("%s: sensor #%d units=%d (%s)\n",
+	error = sme_sensor_upstring(dict, "state", sdt->desc);
-		    __func__, edata->sensor, sdt->type, sdt->desc));
+	if (error)
 		return (-error);
-		error = sme_sensor_upstring(dict, "type", sdt->desc);
+	/*
 	 * update sensor's type.
 	 */
 	sdt = sme_find_table_entry(SME_DESC_UNITS, edata->units);
 	DPRINTFOBJ(("%s: sensor #%d units=%d (%s)\n", __func__, edata->sensor,
 	    sdt->type, sdt->desc));
 	error = sme_sensor_upstring(dict, "type", sdt->desc);
 	if (error)
 		return (-error);
 	/*
 	 * Battery charge and Indicator types do not
 	 * need the remaining objects, so skip them.
 	 */
 	if (edata->units == ENVSYS_INDICATOR ||
 	    edata->units == ENVSYS_BATTERY_CHARGE)
 		return error;
 	/*
 	 * update sensor flags.
 	 */
 	if (edata->flags & ENVSYS_FPERCENT) {
 		error = sme_sensor_upbool(dict, "want-percentage", true);
 		if (error)
-			break;
+			return error;
+	}
 	if (value_update) {
 		/*
 		 * update sensor's current value.
 		 */
-		error = sme_sensor_upint32(dict,
+		error = sme_sensor_upint32(dict, "cur-value", edata->value_cur);
 					   "cur-value",
 					   edata->value_cur);
 		if (error)
-			break;
+			return error;
 		/*
 		 * Battery charge, Integer and Indicator types do not
 		 * need the following objects, so skip them.
 		 */
 		if (edata->units == ENVSYS_INTEGER ||
 		    edata->units == ENVSYS_INDICATOR ||
 		    edata->units == ENVSYS_BATTERY_CHARGE)
 			continue;
 		/*
 		 * update sensor flags.
 		 */
 		if (edata->flags & ENVSYS_FPERCENT) {
 			error = sme_sensor_upbool(dict,
 						  "want-percentage",
 						  true);
 			if (error)
 				break;
 		/*
 		 * update sensor's {max,min}-value.
 		 */
 		if (edata->flags & ENVSYS_FVALID_MAX) {
-			error = sme_sensor_upint32(dict,
+			error = sme_sensor_upint32(dict, "max-value",
 						   "max-value",
 						   edata->value_max);
 			if (error)
-				break;
+				return error;
+		}
 		if (edata->flags & ENVSYS_FVALID_MIN) {
-			error = sme_sensor_upint32(dict,
+			error = sme_sensor_upint32(dict, "min-value",
 						   "min-value",
 						   edata->value_min);
 			if (error)
-				break;
+				return error;
+		}
 		/*
 		 * update 'rpms' only for ENVSYS_SFANRPM sensors.
 		 */
 		if (edata->units == ENVSYS_SFANRPM) {
-			error = sme_sensor_upuint32(dict,
+			error = sme_sensor_upuint32(dict, "rpms", edata->rpms);
 						    "rpms",
 						    edata->rpms);
 			if (error)
-				break;
+				return error;
+		}
 		/*
 		 * update 'rfact' only for ENVSYS_SVOLTS_[AD]C sensors.
 		 */
 		if (edata->units == ENVSYS_SVOLTS_AC ||
 		    edata->units == ENVSYS_SVOLTS_DC) {
-			error = sme_sensor_upint32(dict,
+			error = sme_sensor_upint32(dict, "rfact", edata->rfact);
 						   "rfact",
 						   edata->rfact);
 			if (error)
-				break;
+				return error;
 		/*
 		 * update 'drive-state' only for ENVSYS_DRIVE sensors.
 		 */
 		if (edata->units == ENVSYS_DRIVE) {
 			sdt = sme_find_table_entry(SME_DESC_DRIVE_STATES,
 			    edata->value_cur);
 			error = sme_sensor_upstring(dict, "drive-state",
 						    sdt->desc);
 			if (error)
 				break;
+		}
+	}
-		/*
+	/*
-		 * update 'battery-capacity' only for ENVSYS_BATTERY_CAPACITY
+	 * update 'drive-state' only for ENVSYS_DRIVE sensors.
-		 * sensors.
+	 */
-		 */
+	if (edata->units == ENVSYS_DRIVE) {
-		if (edata->units == ENVSYS_BATTERY_CAPACITY) {
+		sdt = sme_find_table_entry(SME_DESC_DRIVE_STATES,
-			sdt = sme_find_table_entry(SME_DESC_BATTERY_CAPACITY,
+					   edata->value_cur);
-			    edata->value_cur);
+		error = sme_sensor_upstring(dict, "drive-state", sdt->desc);
-			error = sme_sensor_upstring(dict, "battery-capacity",
+		if (error)
-						    sdt->desc);
+			return error;
 			if (error)
 				break;
 	/*
 	 * update 'battery-capacity' only for ENVSYS_BATTERY_CAPACITY
 	 * sensors.
 	 */
 	if (edata->units == ENVSYS_BATTERY_CAPACITY) {
 		sdt = sme_find_table_entry(SME_DESC_BATTERY_CAPACITY,
 		    edata->value_cur);
 		error = sme_sensor_upstring(dict, "battery-capacity",
 					    sdt->desc);
 		if (error)
 			return error;
+	}
 	return error;
+}
 /*
  * sme_userset_dictionary:
+ *
  * 	+ Parse the userland dictionary and run the appropiate tasks
  * 	  that were specified.
  */
 int
 sme_userset_dictionary(struct sysmon_envsys *sme, prop_dictionary_t udict,

 @@ -1,14 +1,14 @@
-/* $NetBSD: sysmon_envsysvar.h,v 1.38 2010/12/30 03:59:59 pgoyette Exp $ */
+/* $NetBSD: sysmon_envsysvar.h,v 1.39 2011/06/08 18:22:24 pgoyette Exp $ */
 /*-
  * Copyright (c) 2007, 2008 Juan Romero Pardines.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -101,26 +101,27 @@ struct sme_descr_entry {
  */
 extern	kmutex_t sme_global_mtx; 	/* for the sme linked list and dict */
 extern	prop_dictionary_t sme_propd;	/* the global sensor dictionary */
 /*
  * linked list for the sysmon envsys devices.
  */
 LIST_HEAD(, sysmon_envsys) sysmon_envsys_list;
 /*
  * functions to handle sysmon envsys devices.
  */
 int	sme_update_dictionary(struct sysmon_envsys *);
 int	sme_update_sensor_dictionary(prop_object_t, envsys_data_t *, bool);
 int	sme_userset_dictionary(struct sysmon_envsys *,
 			       prop_dictionary_t, prop_array_t);
 prop_dictionary_t sme_sensor_dictionary_get(prop_array_t, const char *);
 struct	sysmon_envsys *sysmon_envsys_find(const char *);
 void	sysmon_envsys_acquire(struct sysmon_envsys *, bool);
 void	sysmon_envsys_release(struct sysmon_envsys *, bool);
 /*
  * functions to handle sysmon envsys events.
  */
 int	sme_event_register(prop_dictionary_t, envsys_data_t *,
 			   struct sysmon_envsys *, sysmon_envsys_lim_t *,
 			   uint32_t, int, int);