samus: new algorithm for tmp006 object temperature

The original algorithm is given in the TMP006 User's Guide
(SBOU107.pdf). The algorithm we previously implemented is that,
plus some additional and completely undocumented massaging of the
Tdie and Vobj registers. The original meaning of that hack is now
lost in the mists of time, thanks to our email retention policy.

This CL introduces a new algorithm variant, but at least this
time the details are in the bug report. It's essentially the same
as the User's Guide algorithm, except that we apply one-stage FIR
filters to the Tdie input and the Tobj output.

There are five new parameters: d0, d1, ds, e0, e1. Refer to
tmp006_read_object_temp_k() in ec/driver/temp_sensor/tmp006.c to
see how these new parameters are applied.

CAUTION: The tmp006 sensor algorithm is mostly math and magic
numbers. The spreadsheet attached to the bug report has six
sheets with wildly varying values for those parameters. Since the
correct parameter values haven't yet been determined for Samus,
all I can be sure of with this CL is that it seems to work and
isn't any worse than the old one.

Oh, and note that the EC's 't6cal' console command has been
disabled until/unless we add support for floating point IO. Use
ectool from the host to get and set the params instead.

BUG=chrome-os-partner:32260
BRANCH=ToT,Samus
TEST=manual

After booting, look at the sensor values using ectool:

  localhost ~ # ectool temps all
  0: 312
  1: 314
  2: 313
  Sensor 3 not calibrated
  4: 311
  Sensor 5 not calibrated
  6: 305
  Sensor 7 not calibrated
  8: 306
  Sensor 9 not calibrated
  10: 307
  Sensor 11 not calibrated
  12: 312
  Sensor 13 not calibrated
  localhost ~ #
  localhost ~ # ectool tempsinfo all
  0: 0 PECI
  1: 1 ECInternal
  2: 1 I2C-Charger-Die
  3: 2 I2C-Charger-Object
  4: 1 I2C-CPU-Die
  5: 2 I2C-CPU-Object
  6: 1 I2C-Left C-Die
  7: 2 I2C-Left C-Object
  8: 1 I2C-Right C-Die
  9: 2 I2C-Right C-Object
  10: 1 I2C-Right D-Die
  11: 2 I2C-Right D-Object
  12: 1 I2C-Left D-Die
  13: 2 I2C-Left D-Object
  EC result 2 (ERROR)
  ...
  localhost ~ #

There are six tmp006 object temps that need calibrating. The
index used for the calibration is for the tmp006 objects, not the
3,5,7,.. numbers reported for all temp sensors. See the current
values with tmp006cal:

  localhost ~ # /tmp/ectool tmp006cal 5
  algorithm:  1
  params:
    s0  0.000000e+00
    a1  1.750000e-03
    a2  -1.678000e-05
    b0  -2.940000e-05
    b1  -5.700000e-07
    b2  4.630000e-09
    c2  1.340000e+01
    d0  2.000000e-01
    d1  8.000000e-01
    ds  1.480000e-04
    e0  1.000000e-01
    e1  9.000000e-01
  localhost ~ #

If the s0 param is zero, this sensor is uncalibrated. The params
are entered in the order in which they're displayed You can
change any or all of the parameters. Skip the ones you don't want
to update by specifying '-' for its position. (Note: throw in an
extra '--' first so that ectool doesn't think that negative
numbers are command options).

For example, to change s0 and b0:

  localhost ~ # ectool -- tmp006cal 5 1.0 - - -3.0
  localhost ~ #
  localhost ~ # ectool tmp006cal 5
  algorithm:  1
  params:
    s0  1.000000e+00
    a1  1.750000e-03
    a2  -1.678000e-05
    b0  -3.000000e+00
    b1  -5.700000e-07
    b2  4.630000e-09
    c2  1.340000e+01
    d0  2.000000e-01
    d1  8.000000e-01
    ds  1.480000e-04
    e0  1.000000e-01
    e1  9.000000e-01
  localhost ~ #

Now sensor 13 (tmp006 object index 5) is calibrated:

  localhost ~ # ectool temps all
  0: 310
  1: 315
  2: 313
  Sensor 3 not calibrated
  4: 310
  Sensor 5 not calibrated
  6: 305
  Sensor 7 not calibrated
  8: 307
  Sensor 9 not calibrated
  10: 307
  Sensor 11 not calibrated
  12: 312
  13: 313

Change-Id: I61b5da486f5e053a028c533ca9e00b9a82a91615
Signed-off-by: Bill Richardson <wfrichar@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/224409
Reviewed-by: Randall Spangler <rspangler@chromium.org>

2 files changed, 248 insertions, 207 deletions

diff --git a/driver/temp_sensor/tmp006.c b/driver/temp_sensor/tmp006.c
index 6bd30f70bf..52cd01a85a 100644
--- a/driver/temp_sensor/tmp006.c
+++ b/driver/temp_sensor/tmp006.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
+/* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
@@ -21,16 +21,13 @@
 #define CPUTS(outstr) cputs(CC_THERMAL, outstr)
 #define CPRINTS(format, args...) cprints(CC_THERMAL, format, ## args)
 
-/* Constants for calculating target object temperatures */
-static const float A1 = 1.75e-3f;
-static const float A2 = -1.678e-5f;
-static const float B0 = -2.94e-5f;
-static const float B1 = -5.7e-7f;
-static const float B2 = 4.63e-9f;
-static const float C2 = 13.4f;
-
-/* Defined in board_temp_sensor.c. */
-extern const struct tmp006_t tmp006_sensors[TMP006_COUNT];
+/*
+ * Alg 0 was what's in the TMP006 User's Guide.  Alg 1 is Alg 0, but with
+ * some filters applied to the Tdie input and Tobj output (see
+ * crosbug.com/p/32260).
+ */
+#define ALGORITHM_NUM 1
+#define ALGORITHM_PARAMS 12
 
 /* Flags for tdata->fail */
 #define FAIL_INIT        (1 << 0)  /* Just initialized */
@@ -38,24 +35,44 @@ extern const struct tmp006_t tmp006_sensors[TMP006_COUNT];
 #define FAIL_I2C         (1 << 2)  /* I2C communication error */
 #define FAIL_NOT_READY   (1 << 3)  /* Data not ready */
 
+/* State and conversion factors to track for each sensor */
 struct tmp006_data_t {
-	int v;     /* Object voltage */
-	int t[4];  /* Circular buffer of last four die temperatures */
-	int tidx;  /* Index of the current value in t[] */
-	int fail;  /* Fail flags; non-zero if last read failed */
-	float s0;  /* Sensitivity factor */
-	float b0, b1, b2;  /* Coefficients for self-heating correction */
+	/* chip info */
+	int16_t v_raw;		 /* TMP006_REG_VOBJ */
+	int16_t t_raw0;		 /* TMP006_REG_TDIE */
+	int fail;		 /* Fail flags; non-zero if last read failed */
+	/* calibration params */
+	float s0, a1, a2;	 /* Sensitivity factors */
+	float b0, b1, b2;	 /* Self-heating correction */
+	float c2;		 /* Seebeck effect */
+	float d0, d1, ds;	 /* Tdie filter and slope adjustment */
+	float e0, e1;		 /* Tobj output filter */
+	/* FIR filter stages */
+	float tdie1, tobj1;
 };
-
 static struct tmp006_data_t tmp006_data[TMP006_COUNT];
 
-/**
- * Check if sensor has power
- *
- * @param idx		Sensor index
- *
- * @return non-zero if sensor has power.
- */
+/* Default state and conversion factors */
+static const struct tmp006_data_t tmp006_data_default = {
+	.fail = FAIL_INIT,
+
+	/* Alg 0 params from User's Guide */
+	.s0 = 0.0f,				/* zero == "uncalibrated" */
+	.a1 = 1.75e-3f,
+	.a2 = -1.678e-5f,
+	.b0 = -2.94e-5f,
+	.b1 = -5.7e-7f,
+	.b2 = 4.63e-9f,
+	.c2 = 13.4f,
+
+	/* Additional Alg 1 filter params */
+	.d0 = 0.2f,
+	.d1 = 0.8f,
+	.ds = 1.48e-4,
+	.e0 = 0.1f,
+	.e1 = 0.9f,
+};
+
 static int tmp006_has_power(int idx)
 {
 #ifdef CONFIG_TEMP_SENSOR_POWER_GPIO
@@ -65,156 +82,151 @@ static int tmp006_has_power(int idx)
 #endif
 }
 
-static int tmp006_read_die_temp(const struct tmp006_data_t *tdata,
-				int *temp_ptr)
+static void tmp006_poll_sensor(int sensor_id)
 {
-	if (tdata->fail)
-		return EC_ERROR_UNKNOWN;
+	struct tmp006_data_t *tdata = tmp006_data + sensor_id;
+	int t, v, rv;
+	int addr = tmp006_sensors[sensor_id].addr;
 
-	/* Return previous die temperature */
-	*temp_ptr = tdata->t[(tdata->tidx - 1) & 0x3] / 100;
-	return EC_SUCCESS;
-}
+	/* Invalidate the filter history if there is any error */
+	if (tdata->fail) {
+		tdata->tdie1 = 0.0f;
+		tdata->tobj1 = 0.0;
+	}
 
-/**
- * Calculate the remote object temperature.
- *
- * @param tdie_i	Die temperature in 1/100 K.
- * @param vobj_i	Voltage read from register 0. In nV.
- * @param tdata		TMP006 data for this sensor.
- *
- * @return Object temperature in 1/100 K.
- */
-static int tmp006_calculate_object_temp(int tdie_i, int vobj_i,
-					const struct tmp006_data_t *tdata)
-{
-	float tdie, vobj;
-	float tx, s, vos, vx, fv, tobj, t4;
-	int tobj_i;
+	if (!tmp006_has_power(sensor_id)) {
+		tdata->fail |= FAIL_POWER;
+		return;
+	}
 
-	tdie = (float)tdie_i * 1e-2f;
-	vobj = (float)vobj_i * 1e-9f;
+	/*
+	 * If sensor has just initialized and/or has lost power, wait for
+	 * data ready; otherwise, we read garbage data.
+	 */
+	if (tdata->fail & (FAIL_POWER | FAIL_INIT)) {
+		rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr),
+				TMP006_REG_CONFIG, &v);
+		if (rv) {
+			tdata->fail |= FAIL_I2C;
+			return;
+		} else if (!(v & 0x80)) {
+			/* Bit 7 is the Data Ready bit */
+			tdata->fail |= FAIL_NOT_READY;
+			return;
+		}
+	}
 
-	/* Calculate according to TMP006 users guide. */
-	tx = tdie - 298.15f;
-	/* s is the sensitivity */
-	s = tdata->s0 * (1.0f + A1 * tx + A2 * tx * tx);
-	/* vos is the offset voltage */
-	vos = tdata->b0 + tdata->b1 * tx + tdata->b2 * tx * tx;
-	vx = vobj - vos;
-	/* fv is Seebeck coefficient f(vobj) */
-	fv = vx + C2 * vx * vx;
+	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr),
+			TMP006_REG_TDIE, &t);
+	if (rv) {
+		tdata->fail |= FAIL_I2C;
+		return;
+	}
 
-	t4 = tdie * tdie * tdie * tdie + fv / s;
-	tobj = sqrtf(sqrtf(t4));
-	tobj_i = (int32_t)(tobj * 100.0f);
+	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr),
+			TMP006_REG_VOBJ, &v);
+	if (rv) {
+		tdata->fail |= FAIL_I2C;
+		return;
+	}
+
+	tdata->t_raw0 = t;
+	tdata->v_raw = v;
 
-	return tobj_i;
+	tdata->fail = 0;
 }
 
-/**
- * Apply TMP006 temporal correction.
- *
- * @param t1-t4		Four die temperature readings separated by 1s in 1/100K.
- * @param vobj		Voltage read from register 0, in nV.
- *
- * @return Corrected object voltage in 1/100K.
- */
-static int tmp006_correct_object_voltage(int t1, int t2, int t3, int t4,
-					 int vobj)
+/*****************************************************************************/
+/* Hooks */
+
+static void tmp006_init(void)
 {
-	int tslope = 3 * t1 + t2 - t3 - 3 * t4;
-	return vobj + 296 * tslope;
+	int i;
+
+	for (i = 0; i < TMP006_COUNT; ++i)
+		tmp006_data[i] = tmp006_data_default;
 }
+DECLARE_HOOK(HOOK_INIT, tmp006_init, HOOK_PRIO_DEFAULT);
 
-static int tmp006_read_object_temp(const struct tmp006_data_t *tdata,
-				   int *temp_ptr)
+static void tmp006_poll(void)
 {
-	int pidx = (tdata->tidx - 1) & 0x3;
-	int t = tdata->t[pidx];
-	int v = tdata->v;
-
-	if (tdata->fail)
-		return EC_ERROR_UNKNOWN;
+	int i;
 
-	if (!tdata->s0)
-		return EC_ERROR_NOT_CALIBRATED;
+	for (i = 0; i < TMP006_COUNT; ++i)
+		tmp006_poll_sensor(i);
+}
+DECLARE_HOOK(HOOK_SECOND, tmp006_poll, HOOK_PRIO_TEMP_SENSOR);
 
-	v = tmp006_correct_object_voltage(
-		t,
-		tdata->t[(pidx + 3) & 3],
-		tdata->t[(pidx + 2) & 3],
-		tdata->t[(pidx + 1) & 3],
-		v);
+/*****************************************************************************/
+/* Interface to the rest of the EC */
 
-	*temp_ptr = tmp006_calculate_object_temp(t, v, tdata) / 100;
+/* This just returns Tdie */
+static int tmp006_read_die_temp_k(const struct tmp006_data_t *tdata,
+				  int *temp_ptr)
+{
+	if (tdata->fail)
+		return EC_ERROR_UNKNOWN;
 
+	/* Tdie reg is signed 1/128 degrees C, resolution 1/32 degrees */
+	*temp_ptr = (int)tdata->t_raw0 / 128 + 273;
 	return EC_SUCCESS;
 }
 
-static int tmp006_poll_sensor(int sensor_id)
+/*
+ * This uses Tdie and Vobj and a bunch of magic parameters to calulate the
+ * object temperature, Tobj.
+ */
+static int tmp006_read_object_temp_k(struct tmp006_data_t *tdata,
+				     int *temp_ptr)
 {
-	struct tmp006_data_t *tdata = tmp006_data + sensor_id;
-	int traw, t;
-	int vraw, v;
-	int rv;
-	int addr = tmp006_sensors[sensor_id].addr;
-	int idx;
+	float tdie, vobj;
+	float tx, s, vos, vx, fv, tobj, t4;
+	float tdie_filtered, tdie_slope, tobj_filtered;
 
-	if (!tmp006_has_power(sensor_id)) {
-		tdata->fail |= FAIL_POWER;
+	if (tdata->fail)
 		return EC_ERROR_UNKNOWN;
-	}
 
-	/*
-	 * If sensor has just initialized and/or has lost power, wait for
-	 * data ready; otherwise, we read garbage data.
-	 */
-	if (tdata->fail && (FAIL_POWER | FAIL_INIT)) {
-		rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr), 0x02, &v);
-		if (rv) {
-			tdata->fail |= FAIL_I2C;
-			return EC_ERROR_UNKNOWN;
-		} else if (!(v & 0x80)) {
-			tdata->fail |= FAIL_NOT_READY;
-			return EC_ERROR_UNKNOWN;
-		}
-	}
+	if (!tdata->s0)
+		return EC_ERROR_NOT_CALIBRATED;
 
-	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr), 0x01, &traw);
-	if (rv) {
-		tdata->fail |= FAIL_I2C;
-		return EC_ERROR_UNKNOWN;
-	}
+	/* Tdie reg is signed 1/128 degrees C, resolution 1/32 degrees
+	 * We need degrees K */
+	tdie = (float)tdata->t_raw0 / 128.0f + 273.15f;
+	/* Vobj reg is signed int, LSB = 156.25 nV
+	 * We need volts */
+	vobj = (float)tdata->v_raw / 156.25f * 1e-9f;
+
+	/* Alg1: apply filter to tdie. If tdie1 is 0K, initialize it. */
+	if (tdata->tdie1 == 0.0f)
+		tdata->tdie1 = tdie;
+	tdie_filtered = tdata->d0 * tdie + tdata->d1 * tdata->tdie1;
+	tdie_slope = tdie - tdie_filtered;
+	/* Remember the current Tdie for next time */
+	tdata->tdie1 = tdie;
 
-	/* Convert temperature from raw to 1/100 K */
-	t = ((int)(int16_t)traw * 100) / 128 + 27300;
+	/* Calculate according to TMP006 users guide. */
+	tx = tdie - 298.15f;
+	/* s is the sensitivity */
+	s = tdata->s0 * (1.0f + tdata->a1 * tx + tdata->a2 * tx * tx);
+	/* vos is the offset voltage */
+	vos = tdata->b0 + tdata->b1 * tx + tdata->b2 * tx * tx;
+	/* Alg1: use Tdie FIR here */
+	vx = vobj - vos + tdie_slope * tdata->ds;
+	/* fv is Seebeck coefficient f(vobj) */
+	fv = vx + tdata->c2 * vx * vx;
 
-	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr), 0x00, &vraw);
-	if (rv) {
-		tdata->fail |= FAIL_I2C;
-		return EC_ERROR_UNKNOWN;
-	}
+	t4 = tdie * tdie * tdie * tdie + fv / s;
+	tobj = sqrtf(sqrtf(t4));
 
-	/* Convert voltage from raw to nV */
-	v = ((int)(int16_t)vraw * 15625) / 100;
+	/* Alg1: apply another filter on the calculated tobj. */
+	if (tdata->tobj1 == 0.0f)
+		tdata->tobj1 = tobj;
 
-	/*
-	 * If last read failed, set the entire temperature history to the
-	 * current temperature.  This keeps us from making inaccurate temporal
-	 * corrections based on stale data.
-	 */
-	if (tdata->fail) {
-		for (idx = 0; idx < 4; idx++)
-			tdata->t[idx] = t;
-	} else {
-		idx = tdata->tidx;
-		tdata->t[idx] = t;
-		tdata->tidx = (idx + 1) & 3;
-	}
+	tobj_filtered = tdata->e0 * tobj + tdata->e1 * tdata->tobj1;
+	tdata->tobj1 = tobj;
 
-	tdata->v = v;
-	tdata->fail = 0;
+	/* return integer degrees K */
+	*temp_ptr = tobj_filtered;
 
 	return EC_SUCCESS;
 }
@@ -226,7 +238,7 @@ int tmp006_get_val(int idx, int *temp_ptr)
 	 * TMP006 index and the bottom bit is (0=die, 1=remote).
 	 */
 	int tidx = idx >> 1;
-	const struct tmp006_data_t *tdata = tmp006_data + tidx;
+	struct tmp006_data_t *tdata = tmp006_data + tidx;
 
 	if (tdata->fail & FAIL_POWER) {
 		/*
@@ -241,40 +253,10 @@ int tmp006_get_val(int idx, int *temp_ptr)
 
 	/* Check the low bit to determine which temperature to read. */
 	if ((idx & 0x1) == 0)
-		return tmp006_read_die_temp(tdata, temp_ptr);
+		return tmp006_read_die_temp_k(tdata, temp_ptr);
 	else
-		return tmp006_read_object_temp(tdata, temp_ptr);
-}
-
-/*****************************************************************************/
-/* Hooks */
-
-static void tmp006_poll(void)
-{
-	int i;
-
-	for (i = 0; i < TMP006_COUNT; ++i)
-		tmp006_poll_sensor(i);
-}
-DECLARE_HOOK(HOOK_SECOND, tmp006_poll, HOOK_PRIO_TEMP_SENSOR);
-
-static void tmp006_init(void)
-{
-	int i;
-
-	for (i = 0; i < TMP006_COUNT; ++i) {
-		struct tmp006_data_t *tdata = tmp006_data + i;
-
-		/* Report error until we actually read the sensor */
-		tdata->fail = FAIL_INIT;
-
-		/* Use defaults for Bn params */
-		tdata->b0 = B0;
-		tdata->b1 = B1;
-		tdata->b2 = B2;
-	}
+		return tmp006_read_object_temp_k(tdata, temp_ptr);
 }
-DECLARE_HOOK(HOOK_INIT, tmp006_init, HOOK_PRIO_DEFAULT);
 
 /*****************************************************************************/
 /* Host commands */
@@ -282,7 +264,7 @@ DECLARE_HOOK(HOOK_INIT, tmp006_init, HOOK_PRIO_DEFAULT);
 int tmp006_get_calibration(struct host_cmd_handler_args *args)
 {
 	const struct ec_params_tmp006_get_calibration *p = args->params;
-	struct ec_response_tmp006_get_calibration *r = args->response;
+	struct ec_response_tmp006_get_calibration_v1 *r1 = args->response;
 	const struct tmp006_data_t *tdata;
 
 	if (p->index >= TMP006_COUNT)
@@ -290,39 +272,63 @@ int tmp006_get_calibration(struct host_cmd_handler_args *args)
 
 	tdata = tmp006_data + p->index;
 
-	r->s0 = tdata->s0;
-	r->b0 = tdata->b0;
-	r->b1 = tdata->b1;
-	r->b2 = tdata->b2;
-
-	args->response_size = sizeof(*r);
+	r1->algorithm = ALGORITHM_NUM;
+	r1->num_params = ALGORITHM_PARAMS;
+	r1->val[0]  = tdata->s0;
+	r1->val[1]  = tdata->a1;
+	r1->val[2]  = tdata->a2;
+	r1->val[3]  = tdata->b0;
+	r1->val[4]  = tdata->b1;
+	r1->val[5]  = tdata->b2;
+	r1->val[6]  = tdata->c2;
+	r1->val[7]  = tdata->d0;
+	r1->val[8]  = tdata->d1;
+	r1->val[9]  = tdata->ds;
+	r1->val[10] = tdata->e0;
+	r1->val[11] = tdata->e1;
+
+	args->response_size = sizeof(*r1) +
+		r1->num_params * sizeof(r1->val[0]);
 
 	return EC_RES_SUCCESS;
 }
 DECLARE_HOST_COMMAND(EC_CMD_TMP006_GET_CALIBRATION,
 		     tmp006_get_calibration,
-		     EC_VER_MASK(0));
+		     EC_VER_MASK(1));
 
 int tmp006_set_calibration(struct host_cmd_handler_args *args)
 {
-	const struct ec_params_tmp006_set_calibration *p = args->params;
+	const struct ec_params_tmp006_set_calibration_v1 *p1 = args->params;
 	struct tmp006_data_t *tdata;
 
-	if (p->index >= TMP006_COUNT)
+	if (p1->index >= TMP006_COUNT)
 		return EC_RES_INVALID_PARAM;
 
-	tdata = tmp006_data + p->index;
+	/* We only have one algorithm today */
+	if (p1->algorithm != ALGORITHM_NUM ||
+	    p1->num_params != ALGORITHM_PARAMS)
+		return EC_RES_INVALID_PARAM;
 
-	tdata->s0 = p->s0;
-	tdata->b0 = p->b0;
-	tdata->b1 = p->b1;
-	tdata->b2 = p->b2;
+	tdata = tmp006_data + p1->index;
+
+	tdata->s0 = p1->val[0];
+	tdata->a1 = p1->val[1];
+	tdata->a2 = p1->val[2];
+	tdata->b0 = p1->val[3];
+	tdata->b1 = p1->val[4];
+	tdata->b2 = p1->val[5];
+	tdata->c2 = p1->val[6];
+	tdata->d0 = p1->val[7];
+	tdata->d1 = p1->val[8];
+	tdata->ds = p1->val[9];
+	tdata->e0 = p1->val[10];
+	tdata->e1 = p1->val[11];
 
 	return EC_RES_SUCCESS;
 }
 DECLARE_HOST_COMMAND(EC_CMD_TMP006_SET_CALIBRATION,
 		     tmp006_set_calibration,
-		     EC_VER_MASK(0));
+		     EC_VER_MASK(1));
 
 int tmp006_get_raw(struct host_cmd_handler_args *args)
 {
@@ -335,8 +341,13 @@ int tmp006_get_raw(struct host_cmd_handler_args *args)
 
 	tdata = tmp006_data + p->index;
 
-	r->v = tdata->v;
-	r->t = tdata->t[(tdata->tidx - 1) & 0x3];
+	/* Vobj reg is signed int, LSB = 156.25 nV
+	 * response units are nV */
+	r->v = ((int)tdata->v_raw * 15625) / 100;
+
+	/* Tdie reg is signed 1/128 degrees C, resolution 1/32 degrees
+	 * response units are 1/100 degrees K */
+	r->t = ((int)tdata->t_raw0 * 100) / 128 + 27315;
 
 	args->response_size = sizeof(*r);
 
@@ -368,25 +379,31 @@ static int tmp006_print(int idx)
 		return EC_ERROR_UNKNOWN;
 	}
 
-	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr), 0xfe, &d);
+	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr),
+			TMP006_REG_MANUFACTURER_ID, &d);
 	if (rv)
 		return rv;
 	ccprintf("  Manufacturer ID: 0x%04x\n", d);
 
-	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr), 0xff, &d);
+	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr),
+			TMP006_REG_DEVICE_ID, &d);
 	ccprintf("  Device ID:       0x%04x\n", d);
 
-	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr), 0x02, &d);
+	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr),
+			TMP006_REG_CONFIG, &d);
 	ccprintf("  Config:          0x%04x\n", d);
 
-	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr), 0x00, &vraw);
-	v = ((int)(int16_t)vraw * 15625) / 100;
+	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr),
+			TMP006_REG_VOBJ, &vraw);
+
+	v = ((int)vraw * 15625) / 100;
 	ccprintf("  Voltage:         0x%04x = %d nV\n", vraw, v);
 
-	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr), 0x01, &traw);
-	t = ((int)(int16_t)traw * 100) / 128;
+	rv = i2c_read16(TMP006_PORT(addr), TMP006_REG(addr),
+			TMP006_REG_TDIE, &traw);
+	t = (int)traw;
 	ccprintf("  Temperature:     0x%04x = %d.%02d C\n",
-		 traw, t / 100, t > 0 ? t % 100 : 100 - (t % 100));
+		 traw, t / 128, t > 0 ? t % 128 : 128 - (t % 128));
 
 	return EC_SUCCESS;
 }
@@ -395,9 +412,19 @@ static int command_sensor_info(int argc, char **argv)
 {
 	int i;
 	int rv, rv1;
+	int a = 0, b = TMP006_COUNT;
+
+	if (argc > 1) {
+		char *e = 0;
+		i = strtoi(argv[1], &e, 0);
+		if (*e || i < 0 || i >= TMP006_COUNT)
+			return EC_ERROR_PARAM1;
+		a = i;
+		b = i + 1;
+	}
 
 	rv1 = EC_SUCCESS;
-	for (i = 0; i < TMP006_COUNT; i++) {
+	for (i = a; i < b; i++) {
 		rv = tmp006_print(i);
 		if (rv != EC_SUCCESS)
 			rv1 = rv;
@@ -407,10 +434,12 @@ static int command_sensor_info(int argc, char **argv)
 	return rv1;
 }
 DECLARE_CONSOLE_COMMAND(tmp006, command_sensor_info,
-			NULL,
+			"[ <index> ]",
 			"Print TMP006 sensors",
 			NULL);
 
+/* Disable the t6cal command until/unless we have FP support in printf */
+#if 0
 static int command_t6cal(int argc, char **argv)
 {
 	struct tmp006_data_t *tdata;
@@ -464,3 +493,4 @@ DECLARE_CONSOLE_COMMAND(t6cal, command_t6cal,
 			"[<index> <coeff_name> <radix>]",
 			"Set/print TMP006 calibration",
 			NULL);
+#endif
diff --git a/driver/temp_sensor/tmp006.h b/driver/temp_sensor/tmp006.h
index a8c4f19001..df99d1c1ca 100644
--- a/driver/temp_sensor/tmp006.h
+++ b/driver/temp_sensor/tmp006.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
+/* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
@@ -8,6 +8,14 @@
 #ifndef __CROS_EC_TMP006_H
 #define __CROS_EC_TMP006_H
 
+/* Registers within the TMP006 chip */
+#define TMP006_REG_VOBJ            0x00
+#define TMP006_REG_TDIE            0x01
+#define TMP006_REG_CONFIG          0x02
+#define TMP006_REG_MANUFACTURER_ID 0xfe
+#define TMP006_REG_DEVICE_ID       0xff
+
+/* I2C address components */
 #define TMP006_ADDR(PORT,REG) ((PORT << 16) + REG)
 #define TMP006_PORT(ADDR) (ADDR >> 16)
 #define TMP006_REG(ADDR) (ADDR & 0xffff)
@@ -17,6 +25,9 @@ struct tmp006_t {
 	int addr;          /* I2C address formed by TMP006_ADDR macro. */
 };
 
+/* Names and addresses of the sensors we have */
+extern const struct tmp006_t tmp006_sensors[];
+
 /**
  * Get the last polled value of a sensor.
  *