 @@ -1,14 +1,14 @@
-/*	$NetBSD: swsensor.c,v 1.11 2011/06/19 04:08:48 pgoyette Exp $ */
+/*	$NetBSD: swsensor.c,v 1.12 2011/06/19 15:52:48 pgoyette Exp $ */
 /*
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * 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.
+ *
 @@ -17,27 +17,27 @@
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: swsensor.c,v 1.11 2011/06/19 04:08:48 pgoyette Exp $");
+__KERNEL_RCSID(0, "$NetBSD: swsensor.c,v 1.12 2011/06/19 15:52:48 pgoyette Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/module.h>
 #include <sys/sysctl.h>
 #include <dev/sysmon/sysmonvar.h>
 #include <dev/sysmon/sysmon_envsysvar.h>
 #include <prop/proplib.h>
 #ifndef _MODULE
 #include "opt_modular.h"
 @@ -93,26 +93,35 @@ sysctl_swsensor_setup(void)
 		sensor_value_sysctl = me->sysctl_num;
+}
 /*
  * "Polling" routine to update sensor value
  */
 static
 void
 swsensor_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
+{
 	edata->value_cur = sw_sensor_value;
 	/* If value outside of legal range, mark it invalid */
 	if ((edata->flags & ENVSYS_FVALID_MIN &&
 	     edata->value_cur < edata->value_min) ||
 	    (edata->flags & ENVSYS_FVALID_MAX &&
 	     edata->value_cur > edata->value_max)) {
 		edata->state = ENVSYS_SINVALID;
 		return;
+	}
 	/*
 	 * Set state.  If we're handling the limits ourselves, do the
 	 * compare; otherwise just assume the value is valid.
 	 */
 	if ((sw_sensor_mode == 2) && (edata->upropset & PROP_CRITMIN) &&
 	    (edata->upropset & PROP_DRIVER_LIMITS) &&
 	    (edata->value_cur < edata->limits.sel_critmin))
 		edata->state = ENVSYS_SCRITUNDER;
 	else
 		edata->state = ENVSYS_SVALID;
+}
 /*
 @@ -149,27 +158,27 @@ swsensor_set_limits(struct sysmon_envsys
 		*props |= PROP_DRIVER_LIMITS;
 	else
 		*props &= ~PROP_DRIVER_LIMITS;
+}
 /*
  * Module management
  */
 static
 int
 swsensor_init(void *arg)
+{
-	int error;
+	int error, val = 0;
 	const char *key, *str;
 	prop_dictionary_t pd = (prop_dictionary_t)arg;
 	prop_object_t po, obj;
 	prop_object_iterator_t iter;
 	prop_type_t type;
 	const struct sme_descr_entry *descr;
 	swsensor_sme = sysmon_envsys_create();
 	if (swsensor_sme == NULL)
 		return ENOTTY;
 	swsensor_sme->sme_name = "swsensor";
 	swsensor_sme->sme_cookie = &swsensor_edata;
 @@ -185,160 +194,155 @@ swsensor_init(void *arg)
 	sw_sensor_value = 0;
 	sw_sensor_limit = 0;
 	/* Iterate over the provided dictionary, if any */
 	if (pd != NULL) {
 		iter = prop_dictionary_iterator(pd);
 		if (iter == NULL)
 			return ENOMEM;
 		while ((obj = prop_object_iterator_next(iter)) != NULL) {
 			key = prop_dictionary_keysym_cstring_nocopy(obj);
 			po  = prop_dictionary_get_keysym(pd, obj);
 			type = prop_object_type(po);
 			if (type == PROP_TYPE_NUMBER)
 				val = prop_number_integer_value(po);
 			/* Sensor type/units */
 			if (strcmp(key, "type") == 0) {
 				if (type == PROP_TYPE_NUMBER) {
-					swsensor_edata.units =
+					descr = sme_find_table_entry(
-					    prop_number_integer_value(po);
+							SME_DESC_UNITS, val);
 					if (descr == NULL)
 						return EINVAL;
 					swsensor_edata.units = descr->type;
 					continue;
+				}
 				if (type != PROP_TYPE_STRING)
 					return EINVAL;
 				str = prop_string_cstring_nocopy(po);
 				descr = sme_find_table_desc(SME_DESC_UNITS,
 							    str);
-				if (descr->type < 0)
+				if (descr == NULL)
 					return EINVAL;
 				swsensor_edata.units = descr->type;
 				continue;
+			}
 			/* Sensor flags */
 			if (strcmp(key, "flags") == 0) {
 				if (type != PROP_TYPE_NUMBER)
 					return EINVAL;
-				swsensor_edata.flags =
+				swsensor_edata.flags = val;
 				    prop_number_integer_value(po);
 				continue;
+			}
 			/* Sensor limit behavior
 			 *	0 - simple sensor, no hw limits
 			 *	1 - simple sensor, hw provides initial limit
 			 *	2 - complex sensor, hw provides settable
 			 *	    limits and does its own limit checking
 			 */
 			if (strcmp(key, "mode") == 0) {
 				if (type != PROP_TYPE_NUMBER)
 					return EINVAL;
-				sw_sensor_mode = prop_number_integer_value(po);
+				sw_sensor_mode = val;
 				if (sw_sensor_mode > 2)
 					sw_sensor_mode = 2;
 				else if (sw_sensor_mode < 0)
 					sw_sensor_mode = 0;
 				continue;
+			}
 			/* Grab any limit that might be specified */
 			if (strcmp(key, "limit") == 0) {
 				if (type != PROP_TYPE_NUMBER)
 					return EINVAL;
-				sw_sensor_limit = prop_number_integer_value(po);
+				sw_sensor_limit = val;
 				continue;
+			}
 			/* Grab the initial value */
 			if (strcmp(key, "value") == 0) {
 				if (type != PROP_TYPE_NUMBER)
 					return EINVAL;
-				sw_sensor_value = prop_number_integer_value(po);
+				sw_sensor_value = val;
 				continue;
+			}
 			/* Grab value_min and value_max */
 			if (strcmp(key, "value_min") == 0) {
 				if (type != PROP_TYPE_NUMBER)
 					return EINVAL;
-				swsensor_edata.value_min =
+				swsensor_edata.value_min = val;
 				    prop_number_integer_value(po);
 				swsensor_edata.flags |= ENVSYS_FVALID_MIN;
 				continue;
+			}
 			if (strcmp(key, "value_max") == 0) {
 				if (type != PROP_TYPE_NUMBER)
 					return EINVAL;
-				swsensor_edata.value_max =
+				swsensor_edata.value_max = val;
 				    prop_number_integer_value(po);
 				swsensor_edata.flags |= ENVSYS_FVALID_MAX;
 				continue;
+			}
 			/* See if sensor reports percentages vs raw values */
 			if (strcmp(key, "percentage") == 0) {
 				if (type != PROP_TYPE_BOOL)
 					return EINVAL;
 				if (prop_bool_true(po))
 					swsensor_edata.flags |= ENVSYS_FPERCENT;
 				continue;
+			}
 			/* Unrecognized dicttionary object */
 #ifdef DEBUG
 			printf("%s: unknown attribute %s\n", __func__, key);
 #endif
 			return EINVAL;
 		} /* while */
 		prop_object_iterator_release(iter);
+	}
 	/* Initialize limit processing */
 	if (sw_sensor_mode >= 1)
 		swsensor_sme->sme_get_limits = swsensor_get_limits;
 	if (sw_sensor_mode == 2)
 		swsensor_sme->sme_set_limits = swsensor_set_limits;
 	if (sw_sensor_mode != 0) {
 		swsensor_edata.flags |= ENVSYS_FMONLIMITS;
 		swsensor_get_limits(swsensor_sme, &swsensor_edata,
 		    &sw_sensor_deflims, &sw_sensor_defprops);
+	}
 	/*
 	 * If {min, max} value range was specified, make sure that the
 	 * current value is within the range.
 	 */
 	if (swsensor_edata.flags & ENVSYS_FVALID_MAX &&
 	    sw_sensor_value > swsensor_edata.value_max)
 		swsensor_edata.state = ENVSYS_SINVALID;
 	if (swsensor_edata.flags & ENVSYS_FVALID_MIN &&
 	    sw_sensor_value < swsensor_edata.value_min)
 		swsensor_edata.state = ENVSYS_SINVALID;
 	else
 		swsensor_edata.state = ENVSYS_SVALID;
 	swsensor_edata.value_cur = sw_sensor_value;
 	strlcpy(swsensor_edata.desc, "sensor", ENVSYS_DESCLEN);
 	/* Wait for refresh to validate the sensor value */
 	swsensor_edata.state = ENVSYS_SINVALID;
 	error = sysmon_envsys_sensor_attach(swsensor_sme, &swsensor_edata);
 	if (error != 0) {
 		aprint_error("sysmon_envsys_sensor_attach failed: %d\n", error);
 		return error;
+	}
 	error = sysmon_envsys_register(swsensor_sme);
-	if (error != 0)
+	if (error != 0) {
 		aprint_error("sysmon_envsys_register failed: %d\n", error);
 		return error;
+	}
 	sysctl_swsensor_setup();
 	aprint_normal("swsensor: initialized\n");
 	return 0;
+}
 static
 int
 swsensor_fini(void *arg)
+{
 	sysmon_envsys_unregister(swsensor_sme);