Provide support for AMI305 / AK8974 magnetometer chips.
coordinates are provided as polled input device.
Selftest and noise filtering (polled input device fuzziness)
are provided via sysfs.
Signed-off-by: Samu Onkalo <samu.p.onkalo@xxxxxxxxx>
---
drivers/misc/Kconfig | 11 +
drivers/misc/Makefile | 1 +
drivers/misc/ami305.c | 644 ++++++++++++++++++++++++++++++++++++++++++++
include/linux/i2c/ami305.h | 22 ++
4 files changed, 678 insertions(+), 0 deletions(-)
create mode 100644 drivers/misc/ami305.c
create mode 100644 include/linux/i2c/ami305.h
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index df1f86b..d9d0efc 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -246,6 +246,17 @@ config EP93XX_PWM
To compile this driver as a module, choose M here: the module will
be called ep93xx_pwm.
+config AMI305
+ tristate "AMI305";
+ depends on I2C
+ default n
+ ---help---
+ Say Y here if you want to build a driver for AMI305 magnetometer
+ chip.
+
+ To compile this driver as a module, choose M here: the
+ module will be called ami305. If unsure, say N here.
+
source "drivers/misc/c2port/Kconfig"
source "drivers/misc/eeprom/Kconfig"
source "drivers/misc/cb710/Kconfig"
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index f982d2e..bb5f969 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_SGI_GRU) += sgi-gru/
obj-$(CONFIG_HP_ILO) += hpilo.o
obj-$(CONFIG_ISL29003) += isl29003.o
obj-$(CONFIG_EP93XX_PWM) += ep93xx_pwm.o
+obj-$(CONFIG_AMI305) += ami305.o
obj-$(CONFIG_C2PORT) += c2port/
obj-y += eeprom/
obj-y += cb710/
diff --git a/drivers/misc/ami305.c b/drivers/misc/ami305.c
new file mode 100644
index 0000000..ead0190
--- /dev/null
+++ b/drivers/misc/ami305.c
@@ -0,0 +1,644 @@
+/*
+ * ami305.c is driver for AMI305 (Aichi Steel) and
+ * AK8974 (Asahi Kasei EMD Corporation) magnetometer chip
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: Samu Onkalo <samu.p.onkalo@xxxxxxxxx>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/i2c/ami305.h>
+#include <linux/input-polldev.h>
+
+#define DRV_NAME "ami305"
+
+/*
+ * 16-bit registers are little-endian. LSB is at the address defined below
+ * and MSB is at the next higher address.
+ */
+#define AMI305_SELFTEST 0x0C
+#define AMI305_INFO 0x0D
+#define AMI305_WHOAMI 0x0F
+#define AMI305_DATA_X 0x10
+#define AMI305_DATA_Y 0x12
+#define AMI305_DATA_Z 0x14
+#define AMI305_INT_SRC 0x16
+#define AMI305_STATUS 0x18
+#define AMI305_INT_CLEAR 0x1A
+#define AMI305_CTRL1 0x1B
+#define AMI305_CTRL2 0x1C
+#define AMI305_CTRL3 0x1D
+#define AMI305_INT_CTRL 0x1E
+#define AMI305_OFFSET_X 0x20
+#define AMI305_OFFSET_Y 0x22
+#define AMI305_OFFSET_Z 0x24
+#define AMI305_INT_THRES 0x26 /* absolute any axis value threshold */
+#define AMI305_PRESET 0x30
+#define AMI305_TEMP 0x31
+
+#define AMI305_SELFTEST_IDLE 0x55
+#define AMI305_SELFTEST_OK 0xAA
+
+#define AMI305_WHOAMI_VALUE_AMI305 0x47
+#define AMI305_WHOAMI_VALUE_AK8974 0x48
+
+#define AMI305_INT_X_HIGH 0x80 /* Axis over +threshold */
+#define AMI305_INT_Y_HIGH 0x40
+#define AMI305_INT_Z_HIGH 0x20
+#define AMI305_INT_X_LOW 0x10 /* Axis below -threshold */
+#define AMI305_INT_Y_LOW 0x08
+#define AMI305_INT_Z_LOW 0x04
+#define AMI305_INT_RANGE 0x02 /* Range overflow (any axis) */
+
+#define AMI305_STATUS_DRDY 0x40 /* Data ready */
+#define AMI305_STATUS_OVERRUN 0x20 /* Data overrun */
+#define AMI305_STATUS_INT 0x10 /* Interrupt occurred */
+
+#define AMI305_CTRL1_POWER 0x80 /* 0 = standby; 1 = active */
+#define AMI305_CTRL1_RATE 0x10 /* 0 = 10 Hz; 1 = 20 Hz */
+#define AMI305_CTRL1_FORCE_EN 0x02 /* 0 = normal; 1 = force */
+#define AMI305_CTRL1_MODE2 0x01 /* 0 */
+
+#define AMI305_CTRL2_INT_EN 0x10 /* 1 = enable interrupts */
+#define AMI305_CTRL2_DRDY_EN 0x08 /* 1 = enable data ready signal */
+#define AMI305_CTRL2_DRDY_POL 0x04 /* 1 = data ready active high */
+
+#define AMI305_CTRL3_RESET 0x80 /* Software reset */
+#define AMI305_CTRL3_FORCE 0x40 /* Start forced measurement */
+#define AMI305_CTRL3_SELFTEST 0x10 /* Set selftest register */
+
+#define AMI305_INT_CTRL_XEN 0x80 /* Enable interrupt for this axis */
+#define AMI305_INT_CTRL_YEN 0x40
+#define AMI305_INT_CTRL_ZEN 0x20
+#define AMI305_INT_CTRL_XYZEN 0xE0
+#define AMI305_INT_CTRL_POL 0x08 /* 0 = active low; 1 = active high */
+#define AMI305_INT_CTRL_PULSE 0x02 /* 0 = latched; 1 = pulse (50 usec) */
+
+#define AMI305_MAX_RANGE 2048
+#define AMI305_THRESHOLD_MAX (AMI305_MAX_RANGE - 1)
+
+#define AMI305_POLL_INTERVAL 100 /* ms */
+#define AMI305_ACTIVATE_DELAY 1 /* ms */
+#define AMI305_DEFAULT_FUZZ 3 /* input noise filtering */
+#define AMI305_MEAS_DELAY 6 /* one measurement in ms */
+#define AMI305_SELFTEST_DELAY 1 /* ms. Spec says 200us min */
+#define AMI305_RESET_DELAY 5 /* ms */
+
+#define AMI305_PWR_ON 1
+#define AMI305_PWR_OFF 0
+
+#define AMI305_MAX_TRY 2
+
+struct ami305_chip {
+ struct mutex lock; /* Serialize access to chip */
+ struct mutex users_lock;
+ struct i2c_client *client;
+ struct input_polled_dev *idev; /* input device */
+
+ int max_range;
+ int users;
+ int fuzz;
+
+ s16 x, y, z; /* Latest measurements */
+ s8 axis_x;
+ s8 axis_y;
+ s8 axis_z;
+};
+
+static int ami305_write(struct ami305_chip *chip, u8 reg, u8 data)
+{
+ return i2c_smbus_write_byte_data(chip->client, reg, data);
+}
+
+static int ami305_read(struct ami305_chip *chip, u8 reg)
+{
+ return i2c_smbus_read_byte_data(chip->client, reg);
+}
+
+static int ami305_read_block(struct ami305_chip *chip, u8 reg,
+ u8 *data, u8 length)
+{
+ s32 result;
+ result = i2c_smbus_read_i2c_block_data(chip->client,
+ reg, length, data);
+ return result;
+}
+
+static int ami305_power(struct ami305_chip *chip, int poweron)
+{
+ int r, v;
+
+ v = poweron ? AMI305_CTRL1_POWER : 0;
+ v = v | AMI305_CTRL1_FORCE_EN;
+ r = ami305_write(chip, AMI305_CTRL1, v);
+ if (r < 0)
+ return r;
+
+ if (poweron)
+ msleep(AMI305_ACTIVATE_DELAY);
+
+ return 0;
+}
+
+static int ami305_start_measurement(struct ami305_chip *chip)
+{
+ int ctrl3;
+ int ret = 0;
+
+ ctrl3 = ami305_read(chip, AMI305_CTRL3);
+ if (ctrl3 < 0)
+ return ctrl3;
+
+ ret = ami305_write(chip, AMI305_CTRL3, ctrl3 | AMI305_CTRL3_FORCE);
+
+ return ret;
+}
+
+static int ami305_reset(struct ami305_chip *chip)
+{
+ int r = 0;
+
+ /* Power on to get register access */
+ r = ami305_power(chip, AMI305_PWR_ON);
+ if (r < 0)
+ goto fail;
+
+ r = ami305_write(chip, AMI305_CTRL3, AMI305_CTRL3_RESET);
+ if (r < 0)
+ goto fail;
+
+ msleep(AMI305_RESET_DELAY);
+fail:
+ return r;
+}
+
+static int ami305_add_users(struct ami305_chip *chip)
+{
+ int r = 0;
+
+ mutex_lock(&chip->users_lock);
+
+ if (chip->users == 0) {
+ r = ami305_power(chip, AMI305_PWR_ON);
+ if (r < 0)
+ goto fail;
+ }
+ chip->users++;
+fail:
+ mutex_unlock(&chip->users_lock);
+ return r;
+}
+
+static int ami305_remove_users(struct ami305_chip *chip)
+{
+ int r = 0;
+
+ mutex_lock(&chip->users_lock);
+
+ if (chip->users != 0)
+ chip->users--;
+
+ if (chip->users == 0) {
+ r = ami305_power(chip, AMI305_PWR_OFF);
+ if (r < 0)
+ goto fail;
+ }
+fail:
+ mutex_unlock(&chip->users_lock);
+ return r;
+}
+
+static int ami305_configure(struct ami305_chip *chip)
+{
+ int err;
+
+ ami305_reset(chip);
+
+ ami305_add_users(chip);
+
+ err = ami305_write(chip, AMI305_CTRL2, AMI305_CTRL2_DRDY_EN);
+ if (err)
+ goto fail;
+
+ err = ami305_write(chip, AMI305_CTRL3, 0);
+ if (err)
+ goto fail;
+
+ err = ami305_write(chip, AMI305_INT_CTRL, AMI305_INT_CTRL_POL);
+ if (err)
+ goto fail;
+
+ err = ami305_write(chip, AMI305_PRESET, 0);
+ if (err)
+ goto fail;
+
+fail:
+ ami305_remove_users(chip);
+
+ return err;
+}
+
+static int ami305_get_axis(s8 axis, s16 hw_values[3])
+{
+ if (axis > 0)
+ return hw_values[axis - 1];
+ else
+ return -hw_values[-axis - 1];
+}
+
+static int ami305_read_values(struct ami305_chip *chip)
+{
+ s16 hw_values[3];
+ int i;
+
+ ami305_start_measurement(chip);
+
+ i = AMI305_MAX_TRY;
+ do {
+ msleep(AMI305_MEAS_DELAY);
+ if (ami305_read(chip, AMI305_STATUS) & AMI305_STATUS_DRDY)
+ break;
+ i--;
+ } while (i > 0);
+
+ if (i == 0)
+ return -ENODEV;
+
+ /* X, Y, Z are in conscutive addresses. 2 * 3 bytes */
+ ami305_read_block(chip, AMI305_DATA_X, (u8 *)hw_values, 6);
+
+ for (i = 0; i < 3; i++)
+ hw_values[i] = le16_to_cpu(hw_values[i]);
+
+ chip->x = ami305_get_axis(chip->axis_x, hw_values);
+ chip->y = ami305_get_axis(chip->axis_y, hw_values);
+ chip->z = ami305_get_axis(chip->axis_z, hw_values);
+
+ return 0;
+}
+
+static int ami305_selftest(struct ami305_chip *chip)
+{
+ int r;
+ int success = 0;
+
+ ami305_add_users(chip);
+
+ r = ami305_read(chip, AMI305_SELFTEST);
+ if (r != AMI305_SELFTEST_IDLE)
+ goto out;
+
+ r = ami305_read(chip, AMI305_CTRL3);
+ if (r < 0)
+ goto out;
+
+ r = ami305_write(chip, AMI305_CTRL3, r | AMI305_CTRL3_SELFTEST);
+ if (r < 0)
+ goto out;
+
+ msleep(AMI305_SELFTEST_DELAY);
+
+ r = ami305_read(chip, AMI305_SELFTEST);
+ if (r != AMI305_SELFTEST_OK)
+ goto out;
+
+ r = ami305_read(chip, AMI305_SELFTEST);
+ if (r == AMI305_SELFTEST_IDLE)
+ success = 1;
+
+ out:
+ ami305_remove_users(chip);
+
+ return success;
+}
+
+static void ami305_set_input_params(struct ami305_chip *chip, int fuzz)
+{
+ struct input_dev *input_dev = chip->idev->input;
+ int range;
+
+ range = chip->max_range;
+ input_set_abs_params(input_dev, ABS_X, -range, range, fuzz, 0);
+ input_set_abs_params(input_dev, ABS_Y, -range, range, fuzz, 0);
+ input_set_abs_params(input_dev, ABS_Z, -range, range, fuzz, 0);
+ chip->fuzz = fuzz;
+}
+/*
+ * SYSFS interface
+ */
+
+static ssize_t ami305_show_selftest(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct ami305_chip *chip = dev_get_drvdata(dev);
+ char *status;
+
+ mutex_lock(&chip->lock);
+ status = ami305_selftest(chip) ? "OK" : "FAIL";
+ mutex_unlock(&chip->lock);
+
+ return sprintf(buf, "%s\n", status);
+}
+
+static DEVICE_ATTR(selftest, S_IRUGO, ami305_show_selftest, NULL);
+
+static ssize_t ami305_show_active(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct ami305_chip *chip = dev_get_drvdata(dev);
+ int status;
+
+ /* Read from the chip to reflect real state of the HW */
+ status = ami305_read(chip, AMI305_CTRL1) & AMI305_CTRL1_POWER;
+ return sprintf(buf, "%s\n", status ? "ON" : "OFF");
+}
+
+static DEVICE_ATTR(active, S_IRUGO, ami305_show_active, NULL);
+
+static ssize_t ami305_get_fuzz(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct ami305_chip *chip = dev_get_drvdata(dev);
+
+ return sprintf(buf, "%d\n", chip->fuzz);
+}
+
+static ssize_t ami305_set_fuzz(struct device *dev,
+ struct device_attribute *attr, const char *buf,
+ size_t count)
+{
+ struct ami305_chip *chip = dev_get_drvdata(dev);
+ unsigned long fuzz;
+
+ if (strict_strtoul(buf, 0, &fuzz))
+ return -EINVAL;
+
+ if (fuzz > AMI305_MAX_RANGE)
+ return -EINVAL;
+
+ ami305_set_input_params(chip, fuzz);
+
+ return count;
+}
+
+static DEVICE_ATTR(fuzz, S_IRUGO | S_IWUSR, ami305_get_fuzz,
+ ami305_set_fuzz);
+
+static struct attribute *sysfs_attrs[] = {
+ &dev_attr_selftest.attr,
+ &dev_attr_active.attr,
+ &dev_attr_fuzz.attr,
+ NULL
+};
+
+static struct attribute_group ami305_attribute_group = {
+ .attrs = sysfs_attrs
+};
+
+/*
+ * Polled input device interface
+ */
+
+static void ami305_poll(struct input_polled_dev *pidev)
+{
+ struct ami305_chip *chip = pidev->private;
+
+ mutex_lock(&chip->lock);
+
+ ami305_read_values(chip);
+ input_report_abs(pidev->input, ABS_X, chip->x);
+ input_report_abs(pidev->input, ABS_Y, chip->y);
+ input_report_abs(pidev->input, ABS_Z, chip->z);
+ input_sync(pidev->input);
+
+ mutex_unlock(&chip->lock);
+}
+
+static void ami305_open(struct input_polled_dev *pidev)
+{
+ struct ami305_chip *chip = pidev->private;
+ ami305_add_users(chip);
+ ami305_poll(pidev);
+}
+
+static void ami305_close(struct input_polled_dev *pidev)
+{
+ struct ami305_chip *chip = pidev->private;
+ ami305_remove_users(chip);
+}
+
+int ami305_inputdev_enable(struct ami305_chip *chip)
+{
+ struct input_dev *input_dev;
+ int err;
+
+ if (chip->idev)
+ return -EINVAL;
+
+ chip->idev = input_allocate_polled_device();
+ if (!chip->idev)
+ return -ENOMEM;
+
+ chip->idev->private = chip;
+ chip->idev->poll = ami305_poll;
+ chip->idev->close = ami305_close;
+ chip->idev->open = ami305_open;
+ chip->idev->poll_interval = AMI305_POLL_INTERVAL;
+
+ input_dev = chip->idev->input;
+ input_dev->name = "AMI305 / AK8974 Magnetometer";
+ input_dev->phys = DRV_NAME "/input0";
+ input_dev->id.bustype = BUS_HOST;
+ input_dev->id.vendor = 0;
+ input_dev->dev.parent = &chip->client->dev;
+
+ set_bit(EV_ABS, input_dev->evbit);
+ ami305_set_input_params(chip, AMI305_DEFAULT_FUZZ);
+
+ err = input_register_polled_device(chip->idev);
+ if (err) {
+ input_free_polled_device(chip->idev);
+ chip->idev = NULL;
+ }
+
+ return err;
+}
+
+static int __devinit ami305_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct ami305_chip *chip;
+ struct ami305_platform_data *pdata;
+ int err = 0;
+ int whoami;
+ int x, y, z;
+
+ chip = kzalloc(sizeof *chip, GFP_KERNEL);
+ if (!chip)
+ return -ENOMEM;
+
+ i2c_set_clientdata(client, chip);
+ chip->client = client;
+
+ pdata = client->dev.platform_data;
+
+ x = AMI305_DEV_X;
+ y = AMI305_DEV_Y;
+ z = AMI305_DEV_Z;
+
+ if (pdata) {
+ /* Remap axes */
+ x = pdata->axis_x ? pdata->axis_x : x;
+ y = pdata->axis_y ? pdata->axis_y : y;
+ z = pdata->axis_z ? pdata->axis_z : z;
+ }
+
+ if ((abs(x) > 3) | (abs(y) > 3) | (abs(z) > 3)) {
+ dev_err(&client->dev, "Incorrect platform data\n");
+ err = -EINVAL;
+ goto fail1;
+ }
+
+ chip->axis_x = x;
+ chip->axis_y = y;
+ chip->axis_z = z;
+
+ chip->max_range = AMI305_MAX_RANGE;
+
+ mutex_init(&chip->lock);
+ mutex_init(&chip->users_lock);
+
+ whoami = ami305_read(chip, AMI305_WHOAMI);
+ if (whoami < 0) {
+ dev_err(&client->dev, "device not found\n");
+ err = -ENODEV;
+ goto fail1;
+ }
+
+ if (whoami == AMI305_WHOAMI_VALUE_AMI305) {
+ dev_dbg(&client->dev, "device is AMI305, ok\n");
+ } else if (whoami == AMI305_WHOAMI_VALUE_AK8974) {
+ dev_dbg(&client->dev, "device is AK8974, ok\n");
+ } else {
+ dev_err(&client->dev, "device is neither AMI305 nor AK8974\n");
+ err = -ENODEV;
+ goto fail1;
+ }
+
+ err = ami305_configure(chip);
+ if (err)
+ goto fail1;
+
+ err = ami305_inputdev_enable(chip);
+ if (err) {
+ dev_err(&client->dev, "Cannot setup input device\n");
+ goto fail1;
+ }
+
+ err = sysfs_create_group(&chip->client->dev.kobj,
+ &ami305_attribute_group);
+ if (err)
+ dev_err(&client->dev, "Sysfs registration failed\n");
+
+ return err;
+fail1:
+ kfree(chip);
+ return err;
+}
+
+static int __devexit ami305_remove(struct i2c_client *client)
+{
+ struct ami305_chip *chip = i2c_get_clientdata(client);
+
+ sysfs_remove_group(&chip->client->dev.kobj,
+ &ami305_attribute_group);
+ input_unregister_polled_device(chip->idev);
+ input_free_polled_device(chip->idev);
+ kfree(chip);
+ return 0;
+}
+
+#if CONFIG_PM
+static int ami305_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+ struct ami305_chip *chip = i2c_get_clientdata(client);
+ ami305_power(chip, AMI305_PWR_OFF);
+ return 0;
+}
+
+static int ami305_resume(struct i2c_client *client)
+{
+ struct ami305_chip *chip = i2c_get_clientdata(client);
+ ami305_power(chip, AMI305_PWR_ON);
+ return 0;
+}
+
+static void ami305_shutdown(struct i2c_client *client)
+{
+ struct ami305_chip *chip = i2c_get_clientdata(client);
+ ami305_power(chip, AMI305_PWR_OFF);
+}
+
+#else
+#define ami305_suspend NULL
+#define ami305_shutdown NULL
+#define ami305_resume NULL
+#endif
+
+static const struct i2c_device_id ami305_id[] = {
+ {DRV_NAME, 0 },
+ {}
+};
+
+MODULE_DEVICE_TABLE(i2c, ami305_id);
+
+static struct i2c_driver ami305_driver = {
+ .driver = {
+ .name = DRV_NAME,
+ .owner = THIS_MODULE,
+ },
+ .suspend = ami305_suspend,
+ .shutdown = ami305_shutdown,
+ .resume = ami305_resume,
+ .probe = ami305_probe,
+ .remove = __devexit_p(ami305_remove),
+ .id_table = ami305_id,
+};
+
+static int __init ami305_init(void)
+{
+ return i2c_add_driver(&ami305_driver);
+}
+
+static void __exit ami305_exit(void)
+{
+ i2c_del_driver(&ami305_driver);
+}
+
+MODULE_DESCRIPTION("AMI305 3-axis magnetometer driver");
+MODULE_AUTHOR("Samu Onkalo, Nokia Corporation");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("i2c:" DRV_NAME);
+
+module_init(ami305_init);
+module_exit(ami305_exit);
diff --git a/include/linux/i2c/ami305.h b/include/linux/i2c/ami305.h
new file mode 100644
index 0000000..6ca1931
--- /dev/null
+++ b/include/linux/i2c/ami305.h
@@ -0,0 +1,22 @@
+/*
+ * Configuration for AMI305 (and AK8974) magnetometer driver.
+ */
+
+#ifndef __LINUX_I2C_AMI305_H
+#define __LINUX_I2C_AMI305_H
+
+#define AMI305_NO_MAP 0
+#define AMI305_DEV_X 1
+#define AMI305_DEV_Y 2
+#define AMI305_DEV_Z 3
+#define AMI305_INV_DEV_X -1
+#define AMI305_INV_DEV_Y -2
+#define AMI305_INV_DEV_Z -3
+
+struct ami305_platform_data {
+ s8 axis_x;
+ s8 axis_y;
+ s8 axis_z;
+};
+
+#endif /* __LINUX_I2C_AMI305_H */
--
1.5.6.3
_______________________________________________
lm-sensors mailing list
lm-sensors@xxxxxxxxxxxxxx
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
