diff --git a/Documentation/hwmon/ftsteutates b/Documentation/hwmon/ftsteutates
new file mode 100644
index 0000000..318c9eb
--- /dev/null
+++ b/Documentation/hwmon/ftsteutates
@@ -0,0 +1,24 @@
+Kernel driver ftsteutates
+=====================
+
+Supported chips:
+  * FTS Teutates
+    Prefix: 'ftsteutates'
+    Addresses scanned: I2C 0x73 (7-Bit)
+
+Author: Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>
+
+
+Description
+-----------
+The BMC Teutates is the Eleventh generation of Superior System
+monitoring and thermal management solution. It is builds on the basic
+functionality of the BMC Theseus and contains several new features and
+enhancements. It can monitor up to 4 voltages, 16 temperatures and
+8 fans. It also contains an integrated watchdog which is currently
+implemented in this driver.
+
+Specification of the chip can be found here:
+ftp://ftp.ts.fujitsu.com/pub/Mainboard-OEM-Sales/Products/Mainboards/ \
+	Industrial&ExtendedLifetime/D344x-S/IndustrialTools_D344x-S/      \
+	Linux_SystemMonitoring&Watchdog&GPIO
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index ff94007..5c98e55 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -486,6 +486,17 @@ config SENSORS_FSCHMD
 	  This driver can also be built as a module.  If so, the module
 	  will be called fschmd.
 
+config SENSORS_FTSTEUTATES
+	tristate "Fujitsu Technology Solutions sensor chip Teutates"
+	depends on X86 && I2C
+	help
+	  If you say yes here you get support for the Fujitsu Technology
+      Solutions (FTS) sensor chip "Teutates" including support for
+      the integrated watchdog.
+
+	  This driver can also be built as a module.  If so, the module
+	  will be called ftsteutates.
+
 config SENSORS_GL518SM
 	tristate "Genesys Logic GL518SM"
 	depends on I2C
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 2ef5b7c..dcad5f7 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -62,6 +62,7 @@ obj-$(CONFIG_SENSORS_F71882FG)	+= f71882fg.o
 obj-$(CONFIG_SENSORS_F75375S)	+= f75375s.o
 obj-$(CONFIG_SENSORS_FAM15H_POWER) += fam15h_power.o
 obj-$(CONFIG_SENSORS_FSCHMD)	+= fschmd.o
+obj-$(CONFIG_SENSORS_FTSTEUTATES) += ftsteutates.o
 obj-$(CONFIG_SENSORS_G760A)	+= g760a.o
 obj-$(CONFIG_SENSORS_G762)	+= g762.o
 obj-$(CONFIG_SENSORS_GL518SM)	+= gl518sm.o
diff --git a/drivers/hwmon/ftsteutates.c b/drivers/hwmon/ftsteutates.c
new file mode 100644
index 0000000..0381e84
--- /dev/null
+++ b/drivers/hwmon/ftsteutates.c
@@ -0,0 +1,731 @@
+/*
+ * ftsteutates.c, Support for the FTS Systemmonitoring Chip "Teutates"
+ *
+ * Copyright (C) 2016 Fujitsu Technology Solutions GmbH,
+ *		  Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>
+ *
+ * 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.
+ *
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/mutex.h>
+#include <linux/sysfs.h>
+
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <linux/watchdog.h>
+
+#define FTSTEUTATES_DEVICE_ID_REG			0x0000
+#define FTSTEUTATES_DEVICE_REVISION_REG		0x0001
+#define FTSTEUTATES_DEVICE_STATUS_REG		0x0004
+#define FTSTEUTATES_SATELLITE_STATUS_REG	0x0005
+#define FTSTEUTATES_EVENT_STATUS_REG		0x0006
+#define FTSTEUTATES_GLOBAL_CONTROL_REG		0x0007
+
+#define FTSTEUTATES_SENSOR_EVENT_REG		0x0010
+
+#define FTSTEUTATES_FAN_EVENT_REG			0x0014
+#define FTSTEUTATES_FAN_PRESENT_REG			0x0015
+
+#define FTSTEUTATES_POWER_ON_TIME_COUNTER_A 0x007A
+#define FTSTEUTATES_POWER_ON_TIME_COUNTER_B 0x007B
+#define FTSTEUTATES_POWER_ON_TIME_COUNTER_C 0x007C
+
+#define FTSTEUTATES_PAGE_SELECT_REG			0x007F
+
+#define FTSTEUTATES_WATCHDOG_TIME_PRESET	0x000B
+
+/* currently undocumented register: Bit1 = 1 => 1 second watchdog resolution */
+#define FTSTEUTATES_WATCHDOG_CONTROL		0x5081
+#define FTSTEUTATES_WATCHDOG_RESOLUTION		1
+
+#define FTSTEUTATES_NO_FAN_SENSORS			0x08
+#define FTSTEUTATES_NO_TEMP_SENSORS			0x10
+#define FTSTEUTATES_NO_VOLT_SENSORS			0x04
+
+#define temp_sysfs_attr_group(offset) \
+static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp_value, \
+			  NULL, offset - 1); \
+static SENSOR_DEVICE_ATTR(temp##offset##_fault, S_IRUGO, show_temp_fault, \
+			  NULL, offset - 1); \
+static SENSOR_DEVICE_ATTR(temp##offset##_alarm, S_IRUGO | S_IWUSR, \
+			 show_temp_alarm, clear_temp_alarm, offset - 1); \
+static struct attribute *ftsteutates_temp##offset##_attrs[] = { \
+	&sensor_dev_attr_temp##offset##_input.dev_attr.attr, \
+	&sensor_dev_attr_temp##offset##_fault.dev_attr.attr, \
+	&sensor_dev_attr_temp##offset##_alarm.dev_attr.attr, \
+	NULL \
+}; \
+static struct attribute_group ftsteutates_temp##offset##_attrs_group = { \
+	.attrs = ftsteutates_temp##offset##_attrs \
+}
+
+#define fan_sysfs_attr_group(offset) \
+static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_value, NULL, \
+			  offset - 1); \
+static SENSOR_DEVICE_ATTR(fan##offset##_source, S_IRUGO, show_fan_source, \
+			  NULL, offset - 1); \
+static SENSOR_DEVICE_ATTR(fan##offset##_alarm, S_IRUGO | S_IWUSR, \
+			 show_fan_alarm, clear_fan_alarm, offset - 1); \
+static struct attribute *ftsteutates_fan##offset##_attrs[] = { \
+	&sensor_dev_attr_fan##offset##_input.dev_attr.attr, \
+	&sensor_dev_attr_fan##offset##_source.dev_attr.attr, \
+	&sensor_dev_attr_fan##offset##_alarm.dev_attr.attr, \
+	NULL \
+}; \
+static struct attribute_group ftsteutates_fan##offset##_attrs_group = { \
+	.is_visible = ftsteutates_fan_isvisible, \
+	.attrs = ftsteutates_fan##offset##_attrs \
+}
+
+/* possible addresses */
+static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
+
+static struct i2c_device_id ftsteutates_id[] = {
+	{ "ftsteutates", 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, ftsteutates_id);
+
+struct ftsteutates_data {
+	struct i2c_client *client;
+	struct device *hwmon_dev;
+	struct mutex update_lock;
+	bool valid; /* zero until following fields are valid */
+	unsigned long last_updated; /* in jiffies */
+
+	/* voltage */
+	u8 volt[FTSTEUTATES_NO_VOLT_SENSORS];
+
+	/* temprature */
+	u8 temp_input[FTSTEUTATES_NO_TEMP_SENSORS]; /* value */
+	bool temp_alarm[FTSTEUTATES_NO_TEMP_SENSORS]; /* alarm */
+
+	/* fan */
+	bool fan_present[FTSTEUTATES_NO_FAN_SENSORS]; /* presence */
+	u8 fan_input[FTSTEUTATES_NO_FAN_SENSORS]; /* revolutions per second */
+	u8 fan_source[FTSTEUTATES_NO_FAN_SENSORS]; /* sensor source */
+	bool fan_alarm[FTSTEUTATES_NO_FAN_SENSORS]; /* alarm */
+};
+DEFINE_MUTEX(access_lock);
+static bool watchdog_initialized = 0;
+
+/* input fan speed */
+static const u16 FTSTEUTATES_REG_FAN_input[FTSTEUTATES_NO_FAN_SENSORS] = {
+	  0x0020, 0x0021, 0x0022, 0x0023,
+	  0x0024, 0x0025, 0x0026, 0x0027 /* teutates */
+};
+/* fan sensor source */
+static const u16 FTSTEUTATES_REG_FAN_source[FTSTEUTATES_NO_FAN_SENSORS] = {
+	  0x0030, 0x0031, 0x0032, 0x0033,
+	  0x0034, 0x0035, 0x0036, 0x0037 /* teutates */
+};
+/* fan control */
+static const u16 FTSTEUTATES_REG_FAN_control[FTSTEUTATES_NO_FAN_SENSORS] = {
+	  0x4881, 0x4981, 0x4A81, 0x4B81,
+	  0x4C81, 0x4D81, 0x4E81, 0x4F81 /* teutates */
+};
+
+/* input temprature */
+static const u16 FTSTEUTATES_REG_TEMP_input[FTSTEUTATES_NO_TEMP_SENSORS] = {
+	  0x0040, 0x0041, 0x0042, 0x0043, 0x0044,
+	  0x0045, 0x0046, 0x0047, 0x0048, 0x0049,
+	  0x004A, 0x004B, 0x004C, 0x004D, 0x004E,
+	  0x004F /* teutates */
+};
+/* control temprature */
+static const u16 FTSTEUTATES_REG_TEMP_control[FTSTEUTATES_NO_TEMP_SENSORS] = {
+	  0x0681, 0x0781, 0x0881, 0x0981, 0x0A81,
+	  0x0B81, 0x0C81, 0x0D81, 0x0E81, 0x0F81,
+	  0x1081, 0x1181, 0x1281, 0x1381, 0x1481,
+	  0x1581 /* teutates */
+};
+
+/* voltage in */
+static const u16 FTSTEUTATES_REG_VOLT[FTSTEUTATES_NO_VOLT_SENSORS] = {
+	  0x001A, 0x0018, 0x0019, 0x001B /* teutates */
+};
+
+/*****************************************************************************/
+/* I2C Helper functions							     */
+/*****************************************************************************/
+int ftsteutates_read_byte(struct i2c_client *client, unsigned short reg)
+{
+	int ret = -1;
+	unsigned char page = reg>>8;
+
+	mutex_lock(&access_lock);
+	dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page);
+	ret = i2c_smbus_write_byte_data(client, FTSTEUTATES_PAGE_SELECT_REG,
+				page);
+
+	if (ret != 0)
+		goto error;
+
+	reg &= 0xFF;
+	ret = i2c_smbus_read_byte_data(client, reg);
+	dev_dbg(&client->dev, "read - reg: 0x%.02x: val: 0x%.02x\n", reg, ret);
+
+error:
+	mutex_unlock(&access_lock);
+	return ret;
+}
+
+int ftsteutates_write_byte(struct i2c_client *client, unsigned short reg,
+						   unsigned char value)
+{
+	int ret;
+	unsigned char page = reg>>8;
+
+	mutex_lock(&access_lock);
+	dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page);
+	ret = i2c_smbus_write_byte_data(client, FTSTEUTATES_PAGE_SELECT_REG,
+				page);
+
+	if (ret != 0)
+		goto error;
+
+	reg &= 0xFF;
+	dev_dbg(&client->dev,
+		"write - reg: 0x%.02x: val: 0x%.02x\n", reg, value);
+	ret = i2c_smbus_write_byte_data(client, reg, value);
+
+error:
+	mutex_unlock(&access_lock);
+	return ret;
+}
+
+/*****************************************************************************/
+/* Data Updater Helper function						     */
+/*****************************************************************************/
+static struct ftsteutates_data *ftsteutates_update_device(struct device *dev)
+{
+	struct ftsteutates_data *data = dev_get_drvdata(dev);
+	int i;
+	int present, alarm, status;
+
+	mutex_lock(&data->update_lock);
+	if (!time_after(jiffies, data->last_updated + 2 * HZ) && data->valid)
+		goto exit;
+
+	status = ftsteutates_read_byte(data->client,
+				       FTSTEUTATES_DEVICE_STATUS_REG);
+	if(status < 0) {
+		dev_err(dev, "couldn't read device status register\n");
+		goto exit;
+	}
+	data->valid = !!(status & 0x02);
+	if (!data->valid)
+		goto exit;
+
+	present = ftsteutates_read_byte(data->client,
+					FTSTEUTATES_FAN_PRESENT_REG);
+	if(present < 0) {
+		dev_err(dev, "couldn't read fan present register\n");
+		goto exit;
+	}
+
+	alarm = ftsteutates_read_byte(data->client, FTSTEUTATES_FAN_EVENT_REG);
+	if(present < 0) {
+		dev_err(dev, "couldn't read fan event register\n");
+		goto exit;
+	}
+
+	for (i = 0; i < FTSTEUTATES_NO_FAN_SENSORS; i++) {
+		data->fan_present[i] = !!(present & (1<<i));
+		if (data->fan_present[i]) {
+			data->fan_alarm[i] = !!(alarm & (1<<i));
+
+			data->fan_input[i] = ftsteutates_read_byte(data->client,
+						  FTSTEUTATES_REG_FAN_input[i]);
+			if(data->fan_input[i] < 0) {
+				dev_err(dev,
+					"couldn't read fan input register\n");
+				goto exit;
+			}
+
+			data->fan_source[i] = ftsteutates_read_byte(
+						 data->client,
+						 FTSTEUTATES_REG_FAN_source[i]);
+			if(data->fan_source[i] < 0) {
+				dev_err(dev,
+					"couldn't read fan source register\n");
+				goto exit;
+			}
+		} else {
+			data->fan_alarm[i] = 0;
+			data->fan_input[i] = 0;
+			data->fan_source[i] = 0;
+		}
+	}
+
+	alarm = ftsteutates_read_byte(data->client,
+				      FTSTEUTATES_SENSOR_EVENT_REG);
+	if(alarm < 0) {
+		dev_err(dev, "couldn't read sensor alarm register\n");
+		goto exit;
+	}
+
+	for (i = 0; i < FTSTEUTATES_NO_TEMP_SENSORS; i++) {
+		data->temp_input[i] = ftsteutates_read_byte(data->client,
+						FTSTEUTATES_REG_TEMP_input[i]);
+		if(data->temp_input[i] < 0) {
+			dev_err(dev,
+				"couldn't read temperature input register\n");
+			goto exit;
+		}
+		data->temp_alarm[i] = !!(alarm & (1<<i));
+	}
+
+	for (i = 0; i < FTSTEUTATES_NO_VOLT_SENSORS; i++) {
+		data->volt[i] = ftsteutates_read_byte(data->client,
+						      FTSTEUTATES_REG_VOLT[i]);
+		if(data->volt[i] < 0) {
+			dev_err(dev, "couldn't read voltage register\n");
+			goto exit;
+		}
+	}
+	data->last_updated = jiffies;
+
+exit:
+	mutex_unlock(&data->update_lock);
+	return data;
+}
+
+/*****************************************************************************/
+/* Watchdog functions							     */
+/*****************************************************************************/
+static int ftsteutates_wdt_set_timeout(struct watchdog_device *wdd,
+				       unsigned int timeout_seconds)
+{
+	wdd->timeout = DIV_ROUND_UP(wdd->timeout,
+				    FTSTEUTATES_WATCHDOG_RESOLUTION);
+	return 0;
+}
+
+static int ftsteutates_wdt_start(struct watchdog_device *wdd)
+{
+	struct ftsteutates_data *data;
+
+	data = watchdog_get_drvdata(wdd);
+	return ftsteutates_write_byte(data->client,
+			       FTSTEUTATES_WATCHDOG_TIME_PRESET, wdd->timeout);
+}
+
+static int ftsteutates_wdt_stop(struct watchdog_device *wdd)
+{
+	struct ftsteutates_data *data;
+
+	data = watchdog_get_drvdata(wdd);
+	return ftsteutates_write_byte(data->client,
+			FTSTEUTATES_WATCHDOG_TIME_PRESET, 0);
+}
+
+static const struct watchdog_info ftsteutates_wdt_info = {
+	.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+	.identity = "FTS Teutates Hardware Watchdog",
+};
+
+static const struct watchdog_ops ftsteutates_wdt_ops = {
+	.owner = THIS_MODULE,
+	.start = ftsteutates_wdt_start,
+	.stop = ftsteutates_wdt_stop,
+	.set_timeout = ftsteutates_wdt_set_timeout,
+};
+
+static struct watchdog_device ftsteutates_wdt = {
+	.info = &ftsteutates_wdt_info,
+	.ops = &ftsteutates_wdt_ops,
+};
+
+/*****************************************************************************/
+/* SysFS handler functions						     */
+/*****************************************************************************/
+static const int multi[4] = { 11, 11, 39, 10 };
+static ssize_t show_in_value(struct device *dev,
+			     struct device_attribute *devattr, char *buf)
+{
+	/* got from the systemboard specification */
+	int index = to_sensor_dev_attr(devattr)->index;
+	struct ftsteutates_data *data = ftsteutates_update_device(dev);
+	unsigned int val = (multi[index] * data->volt[index] * 330) / 256;
+
+	return sprintf(buf, "%u\n", val);
+}
+
+static ssize_t show_temp_value(struct device *dev,
+			       struct device_attribute *devattr, char *buf)
+{
+	int index = to_sensor_dev_attr(devattr)->index;
+	struct ftsteutates_data *data = ftsteutates_update_device(dev);
+	int value = data->temp_input[index];
+
+	/* 00h Temperature = Sensor Error */
+	return sprintf(buf, "%d\n", value > 0 ? (value - 64) * 1000 : 0);
+}
+
+static ssize_t show_temp_fault(struct device *dev,
+			       struct device_attribute *devattr, char *buf)
+{
+	int index = to_sensor_dev_attr(devattr)->index;
+	struct ftsteutates_data *data = ftsteutates_update_device(dev);
+
+	/* 00h Temperature = Sensor Error */
+	return sprintf(buf, "%d\n", data->temp_input[index] == 0);
+}
+
+static ssize_t show_temp_alarm(struct device *dev,
+			       struct device_attribute *devattr, char *buf)
+{
+	int index = to_sensor_dev_attr(devattr)->index;
+	struct ftsteutates_data *data = ftsteutates_update_device(dev);
+
+	return sprintf(buf, "%u\n", data->temp_alarm[index]);
+}
+
+static ssize_t
+clear_temp_alarm(struct device *dev, struct device_attribute *devattr,
+				 const char *buf, size_t count)
+{
+	int index = to_sensor_dev_attr(devattr)->index;
+	struct ftsteutates_data *data = ftsteutates_update_device(dev);
+	unsigned long val;
+	unsigned char reg;
+
+	if (kstrtoul(buf, 10, &val) || val != 0)
+		return -EINVAL;
+
+	mutex_lock(&data->update_lock);
+	reg = ftsteutates_read_byte(data->client,
+				    FTSTEUTATES_REG_TEMP_control[index]);
+	if(reg < 0) {
+		dev_err(dev, "couldn't read temp control register\n");
+		count = -EIO;
+		goto error;
+	}
+
+	val = ftsteutates_write_byte(data->client,
+				     FTSTEUTATES_REG_TEMP_control[index],
+				     reg | 0x1);
+	if(val < 0) {
+		dev_err(dev, "couldn't read temp control register\n");
+		count = -EIO;
+		goto error;
+	}
+	data->valid = 0;
+
+error:
+	mutex_unlock(&data->update_lock);
+	return count;
+}
+
+static umode_t ftsteutates_fan_isvisible(struct kobject *kobj,
+					 struct attribute *attr, int index)
+{
+	struct device *dev = container_of(kobj, struct device, kobj);
+	struct ftsteutates_data *data = ftsteutates_update_device(dev);
+	struct device_attribute *dev_attr = container_of(attr,
+						struct device_attribute, attr);
+	struct sensor_device_attribute *sattr = to_sensor_dev_attr(dev_attr);
+	umode_t ret = attr->mode;
+
+	if(!data->valid || !data->fan_present[sattr->index])
+		ret = 0;
+
+	return ret;
+}
+
+static ssize_t show_fan_value(struct device *dev,
+			      struct device_attribute *devattr, char *buf)
+{
+	int index = to_sensor_dev_attr(devattr)->index;
+	struct ftsteutates_data *data = ftsteutates_update_device(dev);
+
+	return sprintf(buf, "%u\n", data->fan_input[index] * 60);
+}
+
+static ssize_t show_fan_source(struct device *dev,
+			       struct device_attribute *devattr, char *buf)
+{
+	int index = to_sensor_dev_attr(devattr)->index;
+	struct ftsteutates_data *data = ftsteutates_update_device(dev);
+
+	if (data->fan_present[index]) {
+		if (data->fan_source[index] == 0xFF)
+			return sprintf(buf, "none\n");
+		else
+			return sprintf(buf, "%d\n", data->fan_source[index]);
+	} else
+		return sprintf(buf, "-\n");
+}
+
+static ssize_t show_fan_alarm(struct device *dev,
+			      struct device_attribute *devattr, char *buf)
+{
+	int index = to_sensor_dev_attr(devattr)->index;
+	struct ftsteutates_data *data = ftsteutates_update_device(dev);
+
+	return sprintf(buf, "%d\n", data->fan_alarm[index]);
+}
+
+static ssize_t
+clear_fan_alarm(struct device *dev, struct device_attribute *devattr,
+				const char *buf, size_t count)
+{
+	int index = to_sensor_dev_attr(devattr)->index;
+	struct ftsteutates_data *data = ftsteutates_update_device(dev);
+	unsigned long val;
+	unsigned char reg;
+
+	if (kstrtoul(buf, 10, &val) || val != 0)
+		return -EINVAL;
+
+	mutex_lock(&data->update_lock);
+	reg = ftsteutates_read_byte(data->client,
+		FTSTEUTATES_REG_FAN_control[index]);
+	if(reg < 0) {
+		dev_err(dev, "couldn't read fan control register\n");
+		count = -EIO;
+		goto error;
+	}
+
+	val = ftsteutates_write_byte(data->client,
+		FTSTEUTATES_REG_FAN_control[index], reg | 0x1);
+	if(val < 0) {
+		dev_err(dev, "couldn't write fan control register\n");
+		count = -EIO;
+		goto error;
+	}
+	data->valid = 0;
+
+error:
+	mutex_unlock(&data->update_lock);
+	return count;
+}
+
+/*****************************************************************************/
+/* SysFS structs							     */
+/*****************************************************************************/
+temp_sysfs_attr_group(1);
+temp_sysfs_attr_group(2);
+temp_sysfs_attr_group(3);
+temp_sysfs_attr_group(4);
+temp_sysfs_attr_group(5);
+temp_sysfs_attr_group(6);
+temp_sysfs_attr_group(7);
+temp_sysfs_attr_group(8);
+temp_sysfs_attr_group(9);
+temp_sysfs_attr_group(10);
+temp_sysfs_attr_group(11);
+temp_sysfs_attr_group(12);
+temp_sysfs_attr_group(13);
+temp_sysfs_attr_group(14);
+temp_sysfs_attr_group(15);
+temp_sysfs_attr_group(16);
+
+fan_sysfs_attr_group(1);
+fan_sysfs_attr_group(2);
+fan_sysfs_attr_group(3);
+fan_sysfs_attr_group(4);
+fan_sysfs_attr_group(5);
+fan_sysfs_attr_group(6);
+fan_sysfs_attr_group(7);
+fan_sysfs_attr_group(8);
+
+static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in_value, NULL, 0);
+static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in_value, NULL, 1);
+static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in_value, NULL, 2);
+static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in_value, NULL, 3);
+static struct attribute *ftsteutates_voltage_attrs[] = {
+	&sensor_dev_attr_in1_input.dev_attr.attr,
+	&sensor_dev_attr_in2_input.dev_attr.attr,
+	&sensor_dev_attr_in3_input.dev_attr.attr,
+	&sensor_dev_attr_in4_input.dev_attr.attr,
+	NULL
+};
+static struct attribute_group ftsteutates_voltage_attrs_group = {
+	.attrs = ftsteutates_voltage_attrs
+};
+
+static const struct attribute_group *ftsteutates_attr_groups[] = {
+	&ftsteutates_voltage_attrs_group,
+	&ftsteutates_temp1_attrs_group,
+	&ftsteutates_temp2_attrs_group,
+	&ftsteutates_temp3_attrs_group,
+	&ftsteutates_temp4_attrs_group,
+	&ftsteutates_temp5_attrs_group,
+	&ftsteutates_temp6_attrs_group,
+	&ftsteutates_temp7_attrs_group,
+	&ftsteutates_temp8_attrs_group,
+	&ftsteutates_temp9_attrs_group,
+	&ftsteutates_temp10_attrs_group,
+	&ftsteutates_temp11_attrs_group,
+	&ftsteutates_temp12_attrs_group,
+	&ftsteutates_temp13_attrs_group,
+	&ftsteutates_temp14_attrs_group,
+	&ftsteutates_temp15_attrs_group,
+	&ftsteutates_temp16_attrs_group,
+	&ftsteutates_fan1_attrs_group,
+	&ftsteutates_fan2_attrs_group,
+	&ftsteutates_fan3_attrs_group,
+	&ftsteutates_fan4_attrs_group,
+	&ftsteutates_fan5_attrs_group,
+	&ftsteutates_fan6_attrs_group,
+	&ftsteutates_fan7_attrs_group,
+	&ftsteutates_fan8_attrs_group,
+	NULL
+};
+
+/*****************************************************************************/
+/* Module initialization / remove functions				     */
+/*****************************************************************************/
+static int ftsteutates_detect(struct i2c_client *client,
+			      struct i2c_board_info *info)
+{
+	int val = ftsteutates_read_byte(client, FTSTEUTATES_DEVICE_ID_REG);
+
+	/* Baseboard Management Controller */
+	if (val > 0 && (val & 0xF0) == 0x10) {
+		switch (val & 0x0F) {
+		case 0x01:
+			strlcpy(info->type, ftsteutates_id[0].name,
+			I2C_NAME_SIZE);
+			info->flags = 0;
+			return 0;
+		}
+	}
+	return -ENODEV;
+}
+
+static int ftsteutates_remove(struct i2c_client *client)
+{
+	if(watchdog_initialized) {
+		watchdog_unregister_device(&ftsteutates_wdt);
+		ftsteutates_wdt_stop(&ftsteutates_wdt);
+	}
+	return 0;
+}
+
+static int ftsteutates_watchdog_init(struct ftsteutates_data *data)
+{
+	int ret;
+
+	ret = ftsteutates_read_byte(data->client,
+				    FTSTEUTATES_WATCHDOG_CONTROL);
+	if(ret < 0) {
+		dev_err(&data->client->dev,
+			"couldn't read watchdog control register\n");
+		return ret;
+	}
+
+	ret = ftsteutates_write_byte(data->client,
+				     FTSTEUTATES_WATCHDOG_CONTROL,
+				     ret | 0x2);
+	if(ret < 0) {
+		dev_err(&data->client->dev,
+			"couldn't set watchdog resolution\n");
+		return ret;
+	}
+
+	ret = ftsteutates_read_byte(data->client,
+				    FTSTEUTATES_WATCHDOG_TIME_PRESET);
+	if(ret < 0) {
+		dev_err(&data->client->dev,
+			"couldn't read watchdog time preset register\n");
+		return ret;
+	}
+
+	/* Register our watchdog part */
+	ftsteutates_wdt.parent = &data->client->dev;
+	ftsteutates_wdt.timeout = ret * FTSTEUTATES_WATCHDOG_RESOLUTION;
+	ftsteutates_wdt.min_timeout = FTSTEUTATES_WATCHDOG_RESOLUTION * 1;
+	ftsteutates_wdt.max_timeout = FTSTEUTATES_WATCHDOG_RESOLUTION * 0xFF;
+	watchdog_set_drvdata(&ftsteutates_wdt, data);
+	ret = watchdog_register_device(&ftsteutates_wdt);
+	return ret;
+}
+
+static int ftsteutates_probe(struct i2c_client *client,
+			     const struct i2c_device_id *id)
+{
+	u8 revision;
+	struct ftsteutates_data *data;
+	int err;
+
+	data = devm_kzalloc(&client->dev, sizeof(struct ftsteutates_data),
+			    GFP_KERNEL);
+	if (!data)
+		return -ENOMEM;
+
+	mutex_init(&data->update_lock);
+	data->client = client;
+
+	revision = ftsteutates_read_byte(client,
+					 FTSTEUTATES_DEVICE_REVISION_REG);
+	if(revision < 0) {
+		dev_err(&client->dev,
+			"couldn't read device revision register\n");
+		return revision;
+	}
+
+	data->hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
+					"ftsteutates", data,
+					ftsteutates_attr_groups);
+	if (IS_ERR(data->hwmon_dev)) {
+		err = PTR_ERR(data->hwmon_dev);
+		dev_err(&client->dev, "could not register hwmon device\n");
+		goto exit_detach;
+	}
+
+	err = ftsteutates_watchdog_init(data);
+	if (err) {
+		dev_err(&client->dev,
+			"Registering watchdog device failed: %d\n", err);
+		goto exit_detach;
+	}
+	watchdog_initialized = 1;
+
+	dev_info(&client->dev, "Detected FTS Teutates chip, revision: %d.%d\n",
+		 (revision & 0xF0)>>4, revision & 0x0F);
+	return 0;
+
+exit_detach:
+	ftsteutates_remove(client); /* will also free data for us */
+	return err;
+}
+
+/*****************************************************************************/
+/* Module Details							     */
+/*****************************************************************************/
+static struct i2c_driver ftsteutates_driver = {
+	.class	  = I2C_CLASS_HWMON,
+	.driver = {
+		.name	 = "ftsteutates",
+	},
+	.id_table	= ftsteutates_id,
+	.probe	  = ftsteutates_probe,
+	.remove	   = ftsteutates_remove,
+	.detect	   = ftsteutates_detect,
+	.address_list = normal_i2c,
+};
+
+module_i2c_driver(ftsteutates_driver);
+
+MODULE_AUTHOR("Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>");
+MODULE_DESCRIPTION("FTS Teutates driver");
+MODULE_LICENSE("GPL");
