Skip to contentSkip to conversation

incomplete mtp008.c port to 2.6.18.2

PATCH In review dean gaudet 3 participants 5 messages Nov 18, 2006 – May 29, 2007

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 incomplete mtp008.c port to 2.6.18.2

hi...

i've recently been resurrecting some tyan s2510 and would like to get their mtp008 working. i found Andrew Pam's patch which brought mtp008 forward to 2.6.12, but i'd like to run 2.6.18.2 or later.

so i went through the patch and compared it with other 2.6.18 hwmon drivers and without really any deep understanding made a bunch of changes which seem to have made it mostly work.

i have two problems:

- the lm-sensors userland code seems to expect temp?_over/temp?_hyst files for mtp008 but the driver has min/max... i patched lm-sensors for this, but maybe i should have fixed the driver instead.

- the mtp008 seems to hang and start reporting all zeroes/constant garbage. i'm skeptical this is just my hacked code though because the BIOS "System Health Monitor" has the exact same problem after a few minutes.

so... does anyone happen to have a datasheet for this part?

or can anyone spot some obvious boneheadedness in my patch?

note i didn't do the up/down -> mutex conversion yet.

thanks
-dean
-------------- next part --------------
Index: linux/drivers/hwmon/Kconfig
=================================--- linux.orig/drivers/hwmon/Kconfig 2006-11-17 02:10:30.000000000 -0800
+++ linux/drivers/hwmon/Kconfig 2006-11-17 15:42:10.000000000 -0800
@@ -517,4 +517,14 @@
a problem with I2C support and want to see more of what is going on.

+config SENSORS_MTP008
+ tristate "Myson MTP008 sensor chip"
+ depends on HWMON && I2C && EXPERIMENTAL
+ select HWMON_VID
+ help
+ If you say yes here you get support for MTP008 sensor chips.
+
+ This driver can also be built as a module. If so, the module
+ will be called mtp008.
+
endmenu
Index: linux/drivers/hwmon/Makefile
=================================--- linux.orig/drivers/hwmon/Makefile 2006-11-17 02:10:30.000000000 -0800
+++ linux/drivers/hwmon/Makefile 2006-11-17 02:12:14.000000000 -0800
@@ -39,6 +39,7 @@
obj-$(CONFIG_SENSORS_LM90) += lm90.o
obj-$(CONFIG_SENSORS_LM92) += lm92.o
obj-$(CONFIG_SENSORS_MAX1619) += max1619.o
+obj-$(CONFIG_SENSORS_MTP008) += mtp008.o
obj-$(CONFIG_SENSORS_PC87360) += pc87360.o
obj-$(CONFIG_SENSORS_SIS5595) += sis5595.o
obj-$(CONFIG_SENSORS_SMSC47B397)+= smsc47b397.o
Index: linux/drivers/hwmon/mtp008.c
=================================--- /dev/null 1970-01-01 00:00:00.000000000 +0000
+++ linux/drivers/hwmon/mtp008.c 2006-11-17 02:12:31.000000000 -0800
@@ -0,0 +1,972 @@
+/*

+   mtp008.c - Part of lm_sensors, Linux kernel modules for hardware
+   monitoring
+   Copyright (C) 2001, 2004  Kris Van Hees <aedil at alchar.org>
+   Port to Linux 2.6 Copyright (C) 2005  Andrew Pam <andrew at sericyb.com.au>
+   Port to Linux 2.6.18 Copyright (C) 2006  dean gaudet <dean at arctic.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 <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h> /* for hardware monitoring drivers */
+#include <linux/hwmon-sysfs.h>
+#include <linux/hwmon-vid.h> /* if you need VRM support */ +#include <linux/init.h>
+#include <linux/jiffies.h>
+#include <linux/err.h>
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = {0x2c, 0x2d, 0x2e, I2C_CLIENT_END}; +
+/* Insmod parameters */
+I2C_CLIENT_INSMOD_1(mtp008);
+
+/* The MTP008 registers */
+/* in0 .. in6 */
+#define MTP008_REG_IN(nr) (0x20 + (nr))
+#define MTP008_REG_IN_MAX(nr) (0x2b + (nr) * 2)
+#define MTP008_REG_IN_MIN(nr) (0x2c + (nr) * 2)
+
+/* temp1 */
+#define MTP008_REG_TEMP 0x27
+#define MTP008_REG_TEMP_MAX 0x39
+#define MTP008_REG_TEMP_MIN 0x3a
+
+/* fan1 .. fan3 (nr is 0..2) */
+#define MTP008_REG_FAN(nr) (0x28 + (nr))
+#define MTP008_REG_FAN_MIN(nr) (0x3b + (nr))
+
+#define MTP008_REG_CONFIG 0x40
+#define MTP008_REG_INT_STAT1 0x41
+#define MTP008_REG_INT_STAT2 0x42
+
+#define MTP008_REG_VID_FANDIV 0x47
+
+#define MTP008_REG_I2C_ADDR 0x48
+
+#define MTP008_REG_RESET_VID4 0x49
+
+#define MTP008_REG_OVT_PROP 0x50
+
+#define MTP008_REG_BEEP_CTRL1 0x51
+#define MTP008_REG_BEEP_CTRL2 0x52
+
+/* pwm1 .. pwm3 (nr is 0..2) */
+#define MTP008_REG_PWM_CTRL(nr) (0x53 + (nr))
+
+#define MTP008_REG_PIN_CTRL1 0x56
+#define MTP008_REG_PIN_CTRL2 0x57
+
+#define MTP008_REG_CHIPID 0x58
+
+/*
+ * Pin control register configuration constants.
+ */
+#define MTP008_CFG_VT1_MASK 0x08
+#define MTP008_CFG_VT2_MASK 0x06
+#define MTP008_CFG_VT3_MASK 0x01
+
+/*
+ * Conversion routines and macros. Limit checking is only done on
+ * the TO_REG variants.
+ */
+
+/* IN: mV, (0V to 4.08V)
+ REG: 16mV/bit */
+#define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8) / 16), 0, 255))
+#define IN_FROM_REG(val) ((val) * 16)
+
+/*
+ * The fan rotation count (as stored in the register) is calculated using the
+ * following formula:
+ * count = (22.5K * 60) / (rpm * div) = 1350000 / (rpm * div)
+ * and the rpm is therefore:
+ * rpm = 1350000 / (count * div)
+ */
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+ if (rpm <= 0)
+ return 255;
+
+ return SENSORS_LIMIT( (1350000 + rpm * div / 2) / (rpm * div), 1, 254);
+}
+
+#define FAN_FROM_REG(val, div) ( (val) = 0 ? -1 \
+ : (val) = 255 ? 0 \
+ : 1350000 / ((val) * (div)) \
+ )
+
+/* TEMP: mC (-128C to +127C)
+ REG: 1C/bit, two's complement */
+#define TEMP_TO_REG(val) ( \
+ ( (val) < 0 ? ((val) - 500) \
+ : ((val) + 500) \
+ ) / 1000 \
+ )
+#define TEMP_FROM_REG(val) ( (val) * 1000 )
+
+/* VID: mV

+ * REG: 0x00 to 0x0f    = 2.05 to 1.30 (0.05 per unit)
+ *      0x10 to 0x1e    = 3.50 to 2.10 (0.10 per unit)
+ *      0x1f            = No CPU

+ */
+#define VID_FROM_REG(val) ((val) = 0x1f \
+ ? 0 \
+ : (val) < 0x10 ? 2050 - (val) * 50 \
+ : 5100 - (val) * 100)
+
+/*
+ * Fan divider.
+ */
+#define DIV_FROM_REG(val) (1 << (val))
+
+/*
+ * PWM control. (nr is 0..2)
+ */
+#define PWM_FROM_REG(val) (val)
+#define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255))
+#define PWMENABLE_FROM_REG(nr, val) (((val) >> ((nr) + 4)) & 1)
+
+/* sysfs temperature sensor types mtp008 sensor types
+ * 0: Not defined 0: Analog input (voltage)
+ * 1: PII/Celeron Diode 2: PII Diode
+ * 2: 3904 transistor
+ * 3: thermal diode 1: Thermistor
+ */
+#define SENS_FROM_REG(val) ((val) = 0 ? 0 : (val) = 1 ? 3 : 1)
+#define SENS_TO_REG(val) ((val) = 0 ? 0 : (val) = 1 ? 2 : 1)
+
+/*
+ * For each registered MTP008, we need to keep some data in memory. The
+ * structure itself is dynamically allocated, at the same time when a new
+ * mtp008 client is allocated.
+ */
+struct mtp008_data {
+ struct i2c_client client;
+ struct class_device *class_dev;
+ struct semaphore update_lock;
+ char valid; /* !=0 if fields are valid */
+ unsigned long last_updated; /* In jiffies */
+
+ u8 in[7]; /* Register value */
+ u8 in_max[7]; /* Register value */
+ u8 in_min[7]; /* Register value */
+ s8 temp[3]; /* Register value */
+ s8 temp_max[3]; /* Register value */
+ s8 temp_min[3]; /* Register value */
+ u8 fan[3]; /* Register value */
+ u8 fan_min[3]; /* Register value */
+ u8 vid; /* Register encoding */
+ u8 fan_div[3]; /* Register encoding */
+ u16 alarms; /* Register encoding */
+ u16 beeps; /* Register encoding */
+ u8 pwm[3]; /* Register value */
+ u8 sens[3]; /* 0 = Analog input,
+ 1 = Thermistor,
+ 2 = PII/Celeron diode */
+ u8 pwmenable; /* Register 0x57 value */
+};
+
+static int mtp008_attach_adapter(struct i2c_adapter *adapter);
+static int mtp008_detect(struct i2c_adapter *adapter, int address, int kind); +static int mtp008_detach_client(struct i2c_client *client);
+
+static struct mtp008_data *mtp008_update_device(struct device *dev); +static void mtp008_init_client(struct i2c_client *client, struct mtp008_data *data); +
+static struct i2c_driver mtp008_driver +{
+ .driver = {
+ .name = "mtp008",
+ },
+ .id = I2C_DRIVERID_MTP008,
+ .attach_adapter = mtp008_attach_adapter,
+ .detach_client = mtp008_detach_client,
+};
+
+/* 7 Voltages */
+static ssize_t show_in(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
+}
+
+static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
+}
+
+static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
+}
+
+static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ unsigned long val = simple_strtoul(buf, NULL, 10);
+
+ if ((nr != 4 && nr != 5) || data->sens[nr - 3] = 0) {
+ down(&data->update_lock);
+ data->in_min[nr] = IN_TO_REG(val);
+ i2c_smbus_write_byte_data(client, MTP008_REG_IN_MIN(nr),
+ data->in_min[nr]);
+ up(&data->update_lock);
+ }
+ return count;
+}
+
+static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ unsigned long val = simple_strtoul(buf, NULL, 10);
+
+ if ((nr != 4 && nr != 5) || data->sens[nr - 3] = 0) {
+ down(&data->update_lock);
+ data->in_max[nr] = IN_TO_REG(val);
+ i2c_smbus_write_byte_data(client, MTP008_REG_IN_MAX(nr),
+ data->in_max[nr]);
+ up(&data->update_lock);
+ }
+ return count;
+}
+
+#define GENERATE_IN_FUNCTIONS(offset) \
+static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
+ show_in, NULL, offset); \
+static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
+ show_in_min, set_in_min, offset); \
+static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
+ show_in_max, set_in_max, offset);
+
+GENERATE_IN_FUNCTIONS(0);
+GENERATE_IN_FUNCTIONS(1);
+GENERATE_IN_FUNCTIONS(2);
+GENERATE_IN_FUNCTIONS(3);
+GENERATE_IN_FUNCTIONS(4);
+GENERATE_IN_FUNCTIONS(5);
+GENERATE_IN_FUNCTIONS(6);
+
+/* 3 Temperatures */
+static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
+}
+
+static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
+}
+
+static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
+}
+static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ long val = simple_strtol(buf, NULL, 10);
+
+ down(&data->update_lock);
+ data->temp_max[nr] = TEMP_TO_REG(val);
+ if (nr = 0) {
+ i2c_smbus_write_byte_data(client, MTP008_REG_TEMP_MAX,
+ data->temp_max[nr]);
+ }
+ else if (data->sens[nr] != 0) {
+ i2c_smbus_write_byte_data(client, MTP008_REG_IN_MAX(nr + 3),
+ data->temp_max[nr]);
+ }
+ up(&data->update_lock);
+ return count;
+}
+static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ long val = simple_strtol(buf, NULL, 10);
+
+ down(&data->update_lock);
+ data->temp_min[nr] = TEMP_TO_REG(val);
+ if (nr = 0) {
+ i2c_smbus_write_byte_data(client, MTP008_REG_TEMP_MIN,
+ data->temp_min[nr]);
+ }
+ else if (data->sens[nr] != 0) {
+ i2c_smbus_write_byte_data(client, MTP008_REG_IN_MIN(nr + 3),
+ data->temp_min[nr]);
+ }
+ up(&data->update_lock);
+ return count;
+}
+
+#define GENERATE_TEMP_FUNCTIONS(offset) \
+static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
+ show_temp, NULL, offset - 1); \
+static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
+ show_temp_min, set_temp_min, offset - 1); \
+static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
+ show_temp_max, set_temp_max, offset - 1);
+
+GENERATE_TEMP_FUNCTIONS(1);
+GENERATE_TEMP_FUNCTIONS(2);
+GENERATE_TEMP_FUNCTIONS(3);
+
+/* 3 Fans */
+static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
+ DIV_FROM_REG(data->fan_div[nr])) );
+}
+static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
+ DIV_FROM_REG(data->fan_div[nr])) );
+}
+static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
+}
+static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ unsigned long val = simple_strtoul(buf, NULL, 10);
+
+ down(&data->update_lock);
+ data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
+ i2c_smbus_write_byte_data(client, MTP008_REG_FAN_MIN(nr),
+ data->fan_min[nr]);
+ up(&data->update_lock);
+ return count;
+}
+
+/* Note: we save and restore the fan minimum here, because its value is

+   determined in part by the fan divisor.  This follows the principle of
+   least suprise; the user doesn't expect the fan minimum to change just
+   because the divisor changed. */

+static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ unsigned long val = simple_strtoul(buf, NULL, 10);
+ unsigned long min;
+ u8 reg;
+
+ down(&data->update_lock);
+ min = FAN_FROM_REG(data->fan_min[nr],
+ DIV_FROM_REG(data->fan_div[nr]));
+
+ switch (val) {
+ case 1: data->fan_div[nr] = 0; break;
+ case 2: data->fan_div[nr] = 1; break;
+ case 4: data->fan_div[nr] = 2; break;
+ case 8: data->fan_div[nr] = 3; break;
+ default:
+ dev_err(&client->dev, "fan_div value %ld not "
+ "supported. Choose one of 1, 2, 4 or 8!\n", val);
+ up(&data->update_lock);
+ return -EINVAL;
+ }
+
+ switch (nr) {
+ case 0:
+ reg = i2c_smbus_read_byte_data(client, MTP008_REG_VID_FANDIV);
+ reg = (reg & 0xcf) | ((data->fan_div[nr] & 0x03) << 4);
+ i2c_smbus_write_byte_data(client, MTP008_REG_VID_FANDIV, reg);
+ break;
+ case 1:
+ reg = i2c_smbus_read_byte_data(client, MTP008_REG_VID_FANDIV);
+ reg = (reg & 0x3f) | ((data->fan_div[nr] & 0x03) << 6);
+ i2c_smbus_write_byte_data(client, MTP008_REG_VID_FANDIV, reg);
+ break;
+ case 2:
+ reg = i2c_smbus_read_byte_data(client, MTP008_REG_PIN_CTRL1);
+ reg = (reg & 0x3f) | ((data->fan_div[nr] & 0x03) << 6);
+ i2c_smbus_write_byte_data(client, MTP008_REG_PIN_CTRL1, reg);
+ break;
+ }
+
+ data->fan_min[nr] + FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
+ i2c_smbus_write_byte_data(client, MTP008_REG_FAN_MIN(nr),
+ data->fan_min[nr]);
+ up(&data->update_lock);
+
+ return count;
+}
+
+#define GENERATE_FAN_FUNCTIONS(offset) \
+static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
+ show_fan, NULL, offset - 1); \
+static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
+ show_fan_min, set_fan_min, offset - 1); \
+static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
+ show_fan_div, set_fan_div, offset - 1);
+
+GENERATE_FAN_FUNCTIONS(1);
+GENERATE_FAN_FUNCTIONS(2);
+GENERATE_FAN_FUNCTIONS(3);
+
+/* VID */
+static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf) +{
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", VID_FROM_REG(data->vid));
+}
+static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
+
+/* Alarms */
+static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) +{
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%u\n", data->alarms);
+}
+static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
+
+/* Beeps */
+static ssize_t show_beeps(struct device *dev, struct device_attribute *attr, char *buf) +{
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%u\n", data->beeps);
+}
+
+static ssize_t set_beeps(struct device *dev, struct device_attribute *attr, const char *buf,
+ size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ unsigned long val = simple_strtoul(buf, NULL, 10);
+
+ down(&data->update_lock);
+ data->beeps = val & 0xdf8f;
+ i2c_smbus_write_byte_data(client, MTP008_REG_BEEP_CTRL1,
+ data->beeps & 0xff);
+ i2c_smbus_write_byte_data(client, MTP008_REG_BEEP_CTRL2,
+ data->beeps >> 8);
+ up(&data->update_lock);
+ return count;
+}
+static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR, show_beeps, set_beeps);
+
+/* 3 PWM fan speed controls */
+static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
+}
+static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ unsigned long val = simple_strtoul(buf, NULL, 10);
+
+ down(&data->update_lock);
+ data->pwm[nr] = PWM_TO_REG(val);
+ i2c_smbus_write_byte_data(client, MTP008_REG_PWM_CTRL(nr),
+ data->pwm[nr]);
+ up(&data->update_lock);
+ return count;
+}
+static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", PWMENABLE_FROM_REG(nr, data->pwmenable));
+}
+static ssize_t set_pwm_enable(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ unsigned long val = simple_strtoul(buf, NULL, 10);
+
+ down(&data->update_lock);
+ if (val)
+ data->pwmenable |= (0x10 << nr);
+ else
+ data->pwmenable &= ~(0x10 << nr);
+ i2c_smbus_write_byte_data(client, MTP008_REG_PIN_CTRL2,
+ data->pwmenable);
+ up(&data->update_lock);
+ return count;
+}
+
+#define GENERATE_PWM_FUNCTIONS(offset) \
+static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
+ show_pwm, set_pwm, offset - 1); \
+static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
+ show_pwm_enable, set_pwm_enable, offset - 1);
+
+GENERATE_PWM_FUNCTIONS(1);
+GENERATE_PWM_FUNCTIONS(2);
+GENERATE_PWM_FUNCTIONS(3);
+
+/* 3 Sensor type selections */
+static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct mtp008_data *data = mtp008_update_device(dev);
+ return sprintf(buf, "%d\n", SENS_FROM_REG(data->sens[nr]));
+}
+static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+ int nr = sensor_attr->index;
+
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ unsigned long val = simple_strtoul(buf, NULL, 10);
+ u8 reg, mask, bits;
+
+ mask = (nr = 0) ? MTP008_CFG_VT1_MASK
+ : (nr = 1) ? MTP008_CFG_VT2_MASK
+ : MTP008_CFG_VT3_MASK;
+ bits = SENS_TO_REG(val) << ((2 - nr) + 1);
+
+ if ( (val = 0) /* Undefined */

+	     || (data->sens[nr] = 0)		/* Voltage sensor */
+	     || ((bits & ~mask) != 0)		/* Invalid setting */

+ )
+ dev_err(&client->dev,
+ "Invalid sensor type %ld for sensor %d.\n",
+ val, nr + 1);
+ else {
+ down(&data->update_lock);
+ data->sens[nr] = SENS_TO_REG(val);
+ reg = (i2c_smbus_read_byte_data(client, MTP008_REG_PIN_CTRL2)
+ & ~mask) | bits;
+ i2c_smbus_write_byte_data(client, MTP008_REG_PIN_CTRL2, reg);
+ up(&data->update_lock);
+ }
+ return count;
+}
+
+#define GENERATE_SENS_FUNCTIONS(offset) \
+static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
+ show_sensor, set_sensor, offset - 1);
+
+GENERATE_SENS_FUNCTIONS(1);
+GENERATE_SENS_FUNCTIONS(2);
+GENERATE_SENS_FUNCTIONS(3);
+
+
+/* This function is called when:
+ * mtp008_driver is inserted (when this module is loaded), for each available
+ * adapter when a new adapter is inserted (and mtp008_driver is still present)
+ */
+static int mtp008_attach_adapter(struct i2c_adapter *adapter)
+{
+ if (!(adapter->class & I2C_CLASS_HWMON))
+ return 0;
+ return i2c_probe(adapter, &addr_data, mtp008_detect);
+}
+
+static int mtp008_detect(struct i2c_adapter *adapter, int address, int kind) +{
+ int err, i;
+ struct i2c_client *new_client;
+ struct mtp008_data *data;
+
+ err = 0;
+
+ /*
+ * We presume we have a valid client. We now create the client
+ * structure, even though we cannot fill it completely yet. But it
+ * allows us to use mtp008_(read|write)_value().
+ */
+ if (!(data = kzalloc(sizeof(struct mtp008_data), GFP_KERNEL))) {
+ err = -ENOMEM;
+ goto exit;
+ }
+
+ new_client = &data->client;
+ i2c_set_clientdata(new_client, data);
+ new_client->addr = address;
+ new_client->adapter = adapter;
+ new_client->driver = &mtp008_driver;
+ new_client->flags = 0;
+
+ /* Remaining detection. */
+ if ((kind < 0)
+ && (i2c_smbus_read_byte_data(new_client, MTP008_REG_CHIPID) != 0xac
+ || i2c_smbus_read_byte_data(new_client, MTP008_REG_I2C_ADDR)
+ != address)
+ ) {
+ err = -ENODEV;
+ goto exit_free;
+ }
+
+ /*
+ * Fill in the remaining client fields and put it into the global list.
+ */
+ strlcpy(new_client->name, "mtp008", I2C_NAME_SIZE);
+ data->valid = 0;
+ init_MUTEX(&data->update_lock);
+
+ /* Tell the I2C layer that a new client has arrived. */
+ if ((err = i2c_attach_client(new_client)))
+ goto exit_free;
+
+ /* Initialize the MTP008 chip. */
+ mtp008_init_client(new_client, data);
+
+ /* A few vars need to be filled upon startup */
+ for (i = 0; i < 3; i++) {
+ data->fan_min[i] = i2c_smbus_read_byte_data(new_client,
+ MTP008_REG_FAN_MIN(i));
+ }
+
+ /* Register sysfs hooks */
+ data->class_dev = hwmon_device_register(&new_client->dev);
+ if (IS_ERR(data->class_dev)) {
+ err = PTR_ERR(data->class_dev);
+ goto exit_detach;
+ }
+
+ device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr);
+ device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr);
+ device_create_file(&new_client->dev, &dev_attr_alarms);
+ device_create_file(&new_client->dev, &dev_attr_beep_mask);
+ device_create_file(&new_client->dev, &dev_attr_cpu0_vid);
+
+ return 0;
+
+exit_detach:
+ i2c_detach_client(new_client);
+exit_free:
+ kfree(data);
+exit:
+ return err;
+}
+
+static int mtp008_detach_client(struct i2c_client *client)
+{
+ struct mtp008_data *data = i2c_get_clientdata(client);
+ int err;
+
+ hwmon_device_unregister(data->class_dev);
+
+ if ((err = i2c_detach_client(client))) {
+ dev_err(&client->dev,
+ "Client deregistration failed, client not detached.\n");
+ return err;
+ }
+
+ kfree(i2c_get_clientdata(client));
+
+ return 0;
+}
+
+static void mtp008_getsensortype(struct mtp008_data *data, u8 inp)
+{
+ inp &= 0x0f;
+ data->sens[0] = (inp >> 3) + 1; /* 1 or 2 */
+ data->sens[1] = (inp >> 1) & 0x03; /* 0, 1 or 2 */
+ data->sens[2] = inp & 0x01; /* 0 or 1 */
+}
+
+/* Called when we have found a new MTP008. */
+static void mtp008_init_client(struct i2c_client *client, struct mtp008_data *data) +{
+ mtp008_getsensortype(data, i2c_smbus_read_byte_data(client,
+ MTP008_REG_PIN_CTRL2) );
+
+ /* Start monitoring. */
+ i2c_smbus_write_byte_data(
+ client, MTP008_REG_CONFIG,
+ (i2c_smbus_read_byte_data(client, MTP008_REG_CONFIG) & 0xf7)
+ | 0x01
+ );
+}
+
+static struct mtp008_data *mtp008_update_device(struct device *dev) +{
+ int i;
+ u8 inp;
+ struct i2c_client *client = to_i2c_client(dev);
+ struct mtp008_data *data = i2c_get_clientdata(client);
+
+ down(&data->update_lock);
+
+ if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
+ || !data->valid) {
+
+ dev_dbg(&client->dev, "Starting mtp008 update\n");
+
+ /*
+ * Read in the analog inputs. We're reading AIN4 and AIN5 as
+ * regular analog inputs, even though they may have been
+ * configured as temperature readings instead. Interpretation
+ * of these values is done below.
+ */
+ for (i = 0; i < 7; i++) {
+ data->in[i] + i2c_smbus_read_byte_data(client,
+ MTP008_REG_IN(i));
+ data->in_max[i] + i2c_smbus_read_byte_data(client,
+ MTP008_REG_IN_MAX(i));
+ data->in_min[i] + i2c_smbus_read_byte_data(client,
+ MTP008_REG_IN_MIN(i));
+ }
+
+ /* Read the temperature sensor. */
+ data->temp[0] = i2c_smbus_read_byte_data(client,
+ MTP008_REG_TEMP);
+ data->temp_max[0] = i2c_smbus_read_byte_data(client,
+ MTP008_REG_TEMP_MAX);
+ data->temp_min[0] = i2c_smbus_read_byte_data(client,
+ MTP008_REG_TEMP_MIN);
+
+ /*
+ * Read the first 2 fan dividers and the VID setting. Read the
+ * third fan divider from a different register.
+ */
+ inp = i2c_smbus_read_byte_data(client, MTP008_REG_VID_FANDIV);
+ data->vid = inp & 0x0f;
+ data->vid |= (i2c_smbus_read_byte_data(client,
+ MTP008_REG_RESET_VID4) & 0x01) << 4;
+
+ data->fan_div[0] = (inp >> 4) & 0x03;
+ data->fan_div[1] = inp >> 6;
+ data->fan_div[2] = i2c_smbus_read_byte_data(client,
+ MTP008_REG_PIN_CTRL1) >> 6;
+
+ /* Read the interrupt status registers. */
+ data->alarms + (i2c_smbus_read_byte_data(client,
+ MTP008_REG_INT_STAT1) & 0xdf) |
+ (i2c_smbus_read_byte_data(client,
+ MTP008_REG_INT_STAT2) & 0x0f) << 8;
+
+ /* Read the beep control registers. */
+ data->beeps + (i2c_smbus_read_byte_data(client,
+ MTP008_REG_BEEP_CTRL1) & 0xdf) |
+ (i2c_smbus_read_byte_data(client,
+ MTP008_REG_BEEP_CTRL2) & 0x8f) << 8;
+
+ /* Read the sensor configuration. */
+ inp = i2c_smbus_read_byte_data(client, MTP008_REG_PIN_CTRL2);
+ mtp008_getsensortype(data, inp);
+ data->pwmenable = inp;
+
+ /* Deal with the configuration of sensors 2 and 3. */
+ for (i = 1; i < 3; i++)
+ if (data->sens[i] = 0) { /* Voltage */
+ data->temp[i] = 0;
+ data->temp_max[i] = 0;
+ data->temp_min[i] = 0;
+ }
+ else {
+ data->temp[i] = data->in[i + 3];
+ data->in[i + 3] = 0;
+ data->temp_max[i] = data->in_max[i + 3];
+ data->in_max[i + 3] = 0;
+ data->temp_min[i] = data->in_min[i + 3];
+ data->in_min[i + 3] = 0;
+ }
+
+ /* Read the PWM registers if enabled. */
+ for (i = 0; i < 3; i++) {
+ if(PWMENABLE_FROM_REG(i, inp))
+ data->pwm[i] = i2c_smbus_read_byte_data(client,
+ MTP008_REG_PWM_CTRL(i));
+ else
+ data->pwm[i] = 255;
+ }
+
+ /* Read the fan sensors. Skip 3 if PWM1 enabled. */
+ for (i = 0; i < 3; i++) {
+ if (i = 2 && PWMENABLE_FROM_REG(0, inp)) {
+ data->fan[2] = 0;
+ data->fan_min[2] = 0;
+ } else {
+ data->fan[i] = i2c_smbus_read_byte_data(client,
+ MTP008_REG_FAN(i));
+ data->fan_min[i] + i2c_smbus_read_byte_data(client,
+ MTP008_REG_FAN_MIN(i));
+ }
+ }
+
+ data->last_updated = jiffies;
+ data->valid = 1;
+ }
+ up(&data->update_lock);
+
+ return data;
+}
+
+static int __init sm_mtp008_init(void)
+{
+ return i2c_add_driver(&mtp008_driver);
+}
+
+static void __exit sm_mtp008_exit(void)
+{
+ i2c_del_driver(&mtp008_driver);
+}
+
+
+
+MODULE_AUTHOR("Kris Van Hees <aedil at alchar.org> "
+ "and Andrew Pam <andrew at sericyb.com.au>");
+MODULE_DESCRIPTION("MTP008 driver");
+MODULE_LICENSE("GPL");
+
+module_init(sm_mtp008_init);
+module_exit(sm_mtp008_exit);
-------------- next part --------------
Index: lm-sensors-2.10.1/lib/chips.c
=================================--- lm-sensors-2.10.1.orig/lib/chips.c 2006-11-17 01:52:27.000000000 -0800
+++ lm-sensors-2.10.1/lib/chips.c 2006-11-17 01:53:44.000000000 -0800
@@ -4197,22 +4197,22 @@

                         R, MTP008_SYSCTL_TEMP2, VALUE(3), 1 },
     { SENSORS_MTP008_TEMP3, "temp3", NOMAP, NOMAP,
                         R, MTP008_SYSCTL_TEMP3, VALUE(3), 1 },

- { SENSORS_MTP008_TEMP1_OVER, "temp1_over", SENSORS_MTP008_TEMP1,
+ { SENSORS_MTP008_TEMP1_MAX, "temp1_max", SENSORS_MTP008_TEMP1,
SENSORS_MTP008_TEMP1, RW, MTP008_SYSCTL_TEMP1, VALUE(1), 1 },
- { SENSORS_MTP008_TEMP2_OVER, "temp2_over", SENSORS_MTP008_TEMP2,
+ { SENSORS_MTP008_TEMP2_MAX, "temp2_max", SENSORS_MTP008_TEMP2,
SENSORS_MTP008_TEMP2, RW, MTP008_SYSCTL_TEMP2, VALUE(1), 1 },
- { SENSORS_MTP008_TEMP3_OVER, "temp3_over", SENSORS_MTP008_TEMP3,
+ { SENSORS_MTP008_TEMP3_MAX, "temp3_max", SENSORS_MTP008_TEMP3,
SENSORS_MTP008_TEMP3, RW, MTP008_SYSCTL_TEMP3, VALUE(1), 1 },
- { SENSORS_MTP008_TEMP1_HYST, "temp1_hyst", SENSORS_MTP008_TEMP1,
+ { SENSORS_MTP008_TEMP1_MIN, "temp1_min", SENSORS_MTP008_TEMP1,
SENSORS_MTP008_TEMP1, RW, MTP008_SYSCTL_TEMP1, VALUE(2), 1 },
- { SENSORS_MTP008_TEMP2_HYST, "temp2_hyst", SENSORS_MTP008_TEMP2,
+ { SENSORS_MTP008_TEMP2_MIN, "temp2_min", SENSORS_MTP008_TEMP2,
SENSORS_MTP008_TEMP2, RW, MTP008_SYSCTL_TEMP2, VALUE(2), 1 },
- { SENSORS_MTP008_TEMP3_HYST, "temp3_hyst", SENSORS_MTP008_TEMP3,
+ { SENSORS_MTP008_TEMP3_MIN, "temp3_min", SENSORS_MTP008_TEMP3,
SENSORS_MTP008_TEMP3, RW, MTP008_SYSCTL_TEMP3, VALUE(2), 1 },

     { SENSORS_MTP008_VID, "vid", NOMAP, NOMAP,

Index: lm-sensors-2.10.1/lib/chips.h
=================================--- lm-sensors-2.10.1.orig/lib/chips.h 2006-11-17 01:52:28.000000000 -0800
+++ lm-sensors-2.10.1/lib/chips.h 2006-11-17 01:54:04.000000000 -0800
@@ -1494,12 +1494,12 @@

 #define SENSORS_MTP008_TEMP1           51 /* R */
 #define SENSORS_MTP008_TEMP2           52 /* R */
 #define SENSORS_MTP008_TEMP3           53 /* R */
-#define SENSORS_MTP008_TEMP1_OVER      54 /* RW */
-#define SENSORS_MTP008_TEMP1_HYST      55 /* RW */
-#define SENSORS_MTP008_TEMP2_OVER      56 /* RW */
-#define SENSORS_MTP008_TEMP2_HYST      57 /* RW */
-#define SENSORS_MTP008_TEMP3_OVER      58 /* RW */
-#define SENSORS_MTP008_TEMP3_HYST      59 /* RW */
+#define SENSORS_MTP008_TEMP1_MAX       54 /* RW */
+#define SENSORS_MTP008_TEMP1_MIN       55 /* RW */
+#define SENSORS_MTP008_TEMP2_MAX       56 /* RW */
+#define SENSORS_MTP008_TEMP2_MIN       57 /* RW */
+#define SENSORS_MTP008_TEMP3_MAX       58 /* RW */
+#define SENSORS_MTP008_TEMP3_MIN       59 /* RW */
 #define SENSORS_MTP008_VID             61 /* R */
 #define SENSORS_MTP008_FAN1_DIV        71 /* RW */
 #define SENSORS_MTP008_FAN2_DIV        72 /* RW */

Index: lm-sensors-2.10.1/prog/sensors/chips.c
=================================--- lm-sensors-2.10.1.orig/prog/sensors/chips.c 2006-11-17 01:52:27.000000000 -0800
+++ lm-sensors-2.10.1/prog/sensors/chips.c 2006-11-17 02:03:29.000000000 -0800
@@ -2136,11 +2136,11 @@

if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP1,&label,&valid) &&

       !sensors_get_feature(*name,SENSORS_MTP008_TEMP1,&cur) &&
-      !sensors_get_feature(*name,SENSORS_MTP008_TEMP1_HYST,&min) &&
-      !sensors_get_feature(*name,SENSORS_MTP008_TEMP1_OVER,&max)) {
+      !sensors_get_feature(*name,SENSORS_MTP008_TEMP1_MIN,&min) &&
+      !sensors_get_feature(*name,SENSORS_MTP008_TEMP1_MAX,&max)) {
     if (valid) {
       print_label(label,10);
-      print_temp_info( cur, max, min, HYST, 0, 0);
+      print_temp_info( cur, max, min, MINMAX, 0, 0);
       printf(" %s\n", alarms&MTP008_ALARM_TEMP1?"ALARM":"");
     }

} else
@@ -2149,11 +2149,11 @@

if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP2,&label,&valid) &&

       !sensors_get_feature(*name,SENSORS_MTP008_TEMP2,&cur) &&
-      !sensors_get_feature(*name,SENSORS_MTP008_TEMP2_HYST,&min) &&
-      !sensors_get_feature(*name,SENSORS_MTP008_TEMP2_OVER,&max)) {
+      !sensors_get_feature(*name,SENSORS_MTP008_TEMP2_MIN,&min) &&
+      !sensors_get_feature(*name,SENSORS_MTP008_TEMP2_MAX,&max)) {
     if (valid) {
       print_label(label,10);
-      print_temp_info( cur, max, min, HYST, 0, 0);
+      print_temp_info( cur, max, min, MINMAX, 0, 0);
       printf(" %s\n", alarms&MTP008_ALARM_TEMP2?"ALARM":"");
     }

} else
@@ -2162,11 +2162,11 @@

if (!sensors_get_label_and_valid(*name,SENSORS_MTP008_TEMP3,&label,&valid) &&

       !sensors_get_feature(*name,SENSORS_MTP008_TEMP3,&cur) &&
-      !sensors_get_feature(*name,SENSORS_MTP008_TEMP3_HYST,&min) &&
-      !sensors_get_feature(*name,SENSORS_MTP008_TEMP3_OVER,&max)) {
+      !sensors_get_feature(*name,SENSORS_MTP008_TEMP3_MIN,&min) &&
+      !sensors_get_feature(*name,SENSORS_MTP008_TEMP3_MAX,&max)) {
     if (valid) {
       print_label(label,10);
-      print_temp_info( cur, max, min, HYST, 0, 0);
+      print_temp_info( cur, max, min, MINMAX, 0, 0);
       printf(" %s\n", alarms&MTP008_ALARM_TEMP3?"ALARM":"");
     }

} else

#1 lore raw

PATCH 1/1 incomplete mtp008.c port to 2.6.18.2

Hi Dean,

Quoted 8 lines · dean gaudet

i've recently been resurrecting some tyan s2510 and would like to get their mtp008 working. i found Andrew Pam's patch which brought mtp008 forward to 2.6.12, but i'd like to run 2.6.18.2 or later.

so i went through the patch and compared it with other 2.6.18 hwmon drivers and without really any deep understanding made a bunch of changes which seem to have made it mostly work.

Quoted 5 lines

i have two problems:

- the lm-sensors userland code seems to expect temp?_over/temp?_hyst files for mtp008 but the driver has min/max... i patched lm-sensors for this, but maybe i should have fixed the driver instead.

The user-space code looks OK to me, it's the driver which needs fixing. The low temperature limit is in fact an hysteresis limit for that chip, so the tempN_min files should actually be named tempN_max_hyst. Then libsensors should be able to translate automatically between the old names and the new names, so no further change should be required.

Quoted 4 lines

- the mtp008 seems to hang and start reporting all zeroes/constant garbage. i'm skeptical this is just my hacked code though because the BIOS "System Health Monitor" has the exact same problem after a few minutes.

I found the following in our FAQ:
"Also, MTP008 chips seem to randomly refuse to respond, for unknown reasons. You can see this as 'XX' entries in i2cdump."
So it might be a known issue with this chip. Which makes me wonder if it's worth having a driver if it'll stop working after only a few minutes. Unless this is a bug in the original drivers and we manage to fix it, of course.

Quoted 1 line

so... does anyone happen to have a datasheet for this part?

I'll send it to you privately.

Quoted 1 line

or can anyone spot some obvious boneheadedness in my patch?

I don't have the time to review such a large patch at the moment so here are just two random comments:

Review

Quoted 3 lines
(quoted diff) +3 -0
+#include <linux/hwmon.h>     /* for hardware monitoring drivers */
+#include <linux/hwmon-sysfs.h>
+#include <linux/hwmon-vid.h> /* if you need VRM support */

Drop these comments, they are hints for the reader of the driver porting guide, not meant to be left in the final source code ;)

Quoted 41 lines
(quoted diff) +41 -0
+	device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr);

Review

Quoted 10 lines
(quoted diff) +10 -0
+	device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr);
+	device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr);
+	device_create_file(&new_client->dev, &dev_attr_alarms);
+	device_create_file(&new_client->dev, &dev_attr_beep_mask);
+	device_create_file(&new_client->dev, &dev_attr_cpu0_vid);

I seem to understand that the MTP008 has some inputs which are shared between different functions, depending on the chip configuration. So not all the features listed above are present on a given system. You should only create the interface files which correspond to the chip configuration. The user-space code might then need be educated not to generate errors on missing files. The benefit is that you stop presenting bogus data to the user, in turn limiting the support requests we receive.

Quoted 1 line

note i didn't do the up/down -> mutex conversion yet.

You will also have to properly handle errors that might be returned by device_create_file(), and to explicitely delete the files on driver removal. The most efficient way to do this is to use file groups. Almost all hardware monitoring drivers were converted that way between 2.6.18 and 2.6.19, so you can just take a look at how things were done in other drivers, and do the same.

Signature · 1 line
Jean Delvare
#2 lore raw

PATCH 1/1 incomplete mtp008.c port to 2.6.18.2

In reply to dean gaudet
Quoted 6 lines · Jean Delvare
Quoted 4 lines · dean gaudet

- the mtp008 seems to hang and start reporting all zeroes/constant garbage. i'm skeptical this is just my hacked code though because the BIOS "System Health Monitor" has the exact same problem after a few minutes.

Quoted 7 lines

I found the following in our FAQ:
"Also, MTP008 chips seem to randomly refuse to respond, for unknown reasons. You can see this as 'XX' entries in i2cdump."
So it might be a known issue with this chip. Which makes me wonder if it's worth having a driver if it'll stop working after only a few minutes. Unless this is a bug in the original drivers and we manage to fix it, of course.

i tried some more and had no luck avoiding this problem... and even managed to cause it to shut off power to the cpu fans! that made me a bit nervous, and since i had a deadline for putting those boxes online i decided to just live without sensors, alas. (fortunately they're in a redundant config, so i'm not so worried.)

thanks for the info though... i might try more in the future.

-dean

#4 lore raw
In reply to dean gaudet

i gave up on it ... the mtp008 i was experimenting with kept getting wedged up when i read the sensors. sometimes it would even turn off the cpu fans for extra badness.

-dean

Quoted 6 lines · Mr cctsurf

I'm wondering how this is going?

_________________________________________________________________
More photos, more messages, more storage—get 2GB with Windows Live Hotmail.
http://imagine-windowslive.com/hotmail/?locale=en-us&ocid=TXT_TAGHM_migration_HM_mini_2G_0507

_______________________________________________
lm-sensors mailing list
[email protected]
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors